下面列出了java.security.spec.InvalidParameterSpecException#org.apache.commons.codec.binary.Hex 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* Generate a continuation token which is used in get Bucket.
*
* @return if key is not null return continuation token, else returns null.
*/
public String encodeToString() {
if (this.lastKey != null) {
ByteBuffer buffer = ByteBuffer
.allocate(4 + lastKey.length()
+ (lastDir == null ? 0 : lastDir.length()));
buffer.putInt(lastKey.length());
buffer.put(lastKey.getBytes(StandardCharsets.UTF_8));
if (lastDir != null) {
buffer.put(lastDir.getBytes(StandardCharsets.UTF_8));
}
String hex = Hex.encodeHexString(buffer.array());
String digest = DigestUtils.sha256Hex(hex);
return hex + CONTINUE_TOKEN_SEPERATOR + digest;
} else {
return null;
}
}
private static void handleRelay() {
get("/relay", (request, response) -> {
log.info("Incoming relay request from: " + request.userAgent());
boolean isAndroid = request.queryParams("isAndroid").equalsIgnoreCase("true");
boolean useSound = request.queryParams("snd").equalsIgnoreCase("true");
String token = new String(Hex.decodeHex(request.queryParams("token").toCharArray()), "UTF-8");
String encryptedMessage = new String(Hex.decodeHex(request.queryParams("msg").toCharArray()), "UTF-8");
log.info("isAndroid={}\nuseSound={}\napsTokenHex={}\nencryptedMessage={}", isAndroid, useSound, token,
encryptedMessage);
if (isAndroid) {
return relayService.sendAndroidMessage(token, encryptedMessage, useSound);
} else {
boolean isProduction = request.queryParams("isProduction").equalsIgnoreCase("true");
boolean isContentAvailable = request.queryParams("isContentAvailable").equalsIgnoreCase("true");
return relayService.sendAppleMessage(isProduction, isContentAvailable, token, encryptedMessage, useSound);
}
});
}
protected void printStreams(Namespace namespace) throws Exception {
Iterator<String> streams = namespace.getLogs();
System.out.println("Streams under " + getUri() + " : ");
System.out.println("--------------------------------");
while (streams.hasNext()) {
String streamName = streams.next();
System.out.println(streamName);
if (!printMetadata) {
continue;
}
MetadataAccessor accessor =
namespace.getNamespaceDriver().getMetadataAccessor(streamName);
byte[] metadata = accessor.getMetadata();
if (null == metadata || metadata.length == 0) {
continue;
}
if (printHex) {
System.out.println(Hex.encodeHexString(metadata));
} else {
System.out.println(new String(metadata, UTF_8));
}
System.out.println("");
}
System.out.println("--------------------------------");
}
public AndroidRelocationIterator(int objectSize, SymbolLocator symtab, byte[] androidRelData, boolean rela) {
if (log.isDebugEnabled()) {
Inspector.inspect(androidRelData, "androidRelData hex=" + Hex.encodeHexString(androidRelData));
}
this.objectSize = objectSize;
this.buffer = ByteBuffer.wrap(androidRelData);
this.rela = rela;
reloc_ = new ElfRelocation(objectSize, symtab);
relocation_count_ = readSleb128();
reloc_.offset = readSleb128();
relocation_index_ = 0;
relocation_group_index_ = 0;
group_size_ = 0;
}
private String sha2Digest(byte[]... bytes) {
try {
MessageDigest md = MessageDigest.getInstance(HASH_ALGORITHM);
for (byte[] data : bytes) {
md.update(data);
}
return Hex.encodeHexString(md.digest());
} catch (Exception e) {
LOGGER.error("Error generating {} hash", HASH_ALGORITHM, e);
ExceptionUtils.bomb(e);
}
return null;
}
/**
* MD5 and Hexify an array of bytes. Take the input array, MD5 encodes it
* and then turns it into Hex.
* @param secretBytes you want md5hexed
* @return md5hexed String.
*/
public static String md5Hex(byte[] secretBytes) {
String retval = null;
// add secret
MessageDigest md;
try {
md = MessageDigest.getInstance("MD5");
//byte[] secretBytes = inputString.getBytes("UTF-8");
md.update(secretBytes);
// generate the digest
byte[] digest = md.digest();
// hexify this puppy
retval = new String(Hex.encodeHex(digest));
}
catch (NoSuchAlgorithmException e) {
throw new RuntimeException("NoSuchAlgorithm: MD5. Something" +
" weird with your JVM, you should be able to do this.", e);
}
return retval;
}
public String getMd5(int[] program) {
MessageDigest messageDigest;
try {
messageDigest = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException e) {
//srlsy??
throw new RuntimeException("", e);
}
for (int i = 0; i < program.length; i++) {
messageDigest.update((byte)i);
}
return new String(Hex.encodeHex(messageDigest.digest()));
}
private static String toString(final byte[] uuid) {
if (uuid == null) {
return new UUID(0, 0).toString();
}
final String encoded = Hex.encodeHexString(Objects.requireNonNull(uuid));
final StringBuffer sb = new StringBuffer(encoded);
while (sb.length() != 32) {
sb.insert(0, "0");
}
sb.ensureCapacity(32);
sb.insert(8, '-');
sb.insert(13, '-');
sb.insert(18, '-');
sb.insert(23, '-');
return sb.toString();
}
/**
* Returns the digest value of a given public key.
*
* <p>In Version “H003” of the EBICS protocol the ES of the financial:
*
* <p>The SHA-256 hash values of the financial institution's public keys for X002 and E002 are
* composed by concatenating the exponent with a blank character and the modulus in hexadecimal
* representation (using lower case letters) without leading zero (as to the hexadecimal
* representation). The resulting string has to be converted into a byte array based on US ASCII
* code.
*
* @param publicKey the public key
* @return the digest value
* @throws EbicsException
*/
public static byte[] getKeyDigest(RSAPublicKey publicKey) throws AxelorException {
String modulus;
String exponent;
String hash;
byte[] digest;
exponent = Hex.encodeHexString(publicKey.getPublicExponent().toByteArray());
modulus = Hex.encodeHexString(removeFirstByte(publicKey.getModulus().toByteArray()));
hash = exponent + " " + modulus;
if (hash.charAt(0) == '0') {
hash = hash.substring(1);
}
try {
digest = MessageDigest.getInstance("SHA-256", "BC").digest(hash.getBytes("US-ASCII"));
} catch (GeneralSecurityException | UnsupportedEncodingException e) {
throw new AxelorException(
e.getCause(), TraceBackRepository.CATEGORY_CONFIGURATION_ERROR, e.getMessage());
}
return new String(Hex.encodeHex(digest, false)).getBytes();
}
@Override
public void process(InputStream in, OutputStream out) throws IOException {
int len;
byte[] inBuf = new byte[8192];
Hex h = new Hex();
while ((len = in.read(inBuf)) > 0) {
// If the input buffer is of odd length, try to get another byte
if (len % 2 != 0) {
int b = in.read();
if (b != -1) {
inBuf[len] = (byte) b;
len++;
}
}
// Construct a new buffer bounded to len
byte[] slice = Arrays.copyOfRange(inBuf, 0, len);
try {
out.write(h.decode(slice));
} catch (DecoderException ex) {
throw new IOException(ex);
}
}
out.flush();
}
private static boolean doCompareTypePrefix(String crypted, String defaultCrypt, byte[] bytes) {
int typeEnd = crypted.indexOf("}");
String hashType = crypted.substring(1, typeEnd);
String hashed = crypted.substring(typeEnd + 1);
MessageDigest messagedigest = getMessageDigest(hashType);
messagedigest.update(bytes);
byte[] digestBytes = messagedigest.digest();
char[] digestChars = Hex.encodeHex(digestBytes);
String checkCrypted = new String(digestChars);
if (hashed.equals(checkCrypted)) {
return true;
}
// This next block should be removed when all {prefix}oldFunnyHex are fixed.
if (hashed.equals(oldFunnyHex(digestBytes))) {
Debug.logWarning("Warning: detected oldFunnyHex password prefixed with a hashType; this is not valid, please update the value in the database with ({%s}%s)", module, hashType, checkCrypted);
return true;
}
return false;
}
@Test
public void testOutBoundAndInboundSpan() throws Exception {
TracingConfig tracingConfig =
new TracingConfig(
"tracingHandlerClientIntegrationTest", config().getConfig("settings.tracing"));
val client = newClient(new FakeTracer(tracingConfig));
val request =
DefaultSegmentedRequest.builder()
.method(GET)
.path("/v1/authinit")
.host("127.0.0.1" + ":" + server.getPort())
.build();
client.write(request);
// We wait on the local future because this signals the full roundtrip between outbound and
// return trip from the Application Handler out and then back in.
local.get();
assertEquals(reportedSpans.size(), 1);
val responseHex = ByteBufUtil.hexDump(((SegmentedData) response).content());
byte[] bytes = Hex.decodeHex(responseHex.toCharArray());
assertEquals(expectedResponse, new String(bytes, "UTF-8"));
}
private static Object getJavaObjectFromPrimitiveData(Object data, ObjectInspector objInsp) {
assert(objInsp.getCategory() == Category.PRIMITIVE);
if (data == null) {
return null;
}
if (data instanceof BytesWritable && objInsp instanceof WritableHiveDecimalObjectInspector) {
// BytesWritable cannot be directly cast to HiveDecimalWritable
WritableHiveDecimalObjectInspector oi = (WritableHiveDecimalObjectInspector) objInsp;
data = oi.create(((BytesWritable) data).getBytes(), oi.scale());
}
Object obj = ObjectInspectorUtils.copyToStandardJavaObject(data, objInsp);
if (obj instanceof HiveDecimal) {
obj = ((HiveDecimal) obj).bigDecimalValue();
} else if (obj instanceof HiveVarchar || obj instanceof HiveChar) {
obj = obj.toString();
} else if (obj instanceof byte[]) {
obj = Hex.encodeHexString((byte[]) obj);
}
return obj;
}
private String encryptAnnotation(String plainAnnotation, Cipher cipher)
{
if(plainAnnotation == null)
return null;
try
{
String encryptedAnnotationStr;
byte[] encryptedAnnotation = cipher.doFinal(plainAnnotation.getBytes(StandardCharsets.UTF_8));
encryptedAnnotationStr = Hex.encodeHexString(encryptedAnnotation);
return encryptedAnnotationStr;
}
catch(Exception ex)
{
String message = "Unable to encrypt annotation " + "'" + plainAnnotation + "'. " +
"This would disturb any further encryption of annotations.";
logger.log(Level.WARNING, message, ex);
return null;
}
}
@Override
protected void verify(final Path file, final MessageDigest digest, final Checksum checksum) throws ChecksumException {
if(null == digest) {
log.debug(String.format("Digest verification disabled for file %s", file));
return;
}
if(file.getType().contains(Path.Type.encrypted)) {
log.warn(String.format("Skip checksum verification for %s with client side encryption enabled", file));
return;
}
final String expected = Hex.encodeHexString(digest.digest());
if(!checksum.equals(Checksum.parse(expected))) {
throw new ChecksumException(MessageFormat.format(LocaleFactory.localizedString("Upload {0} failed", "Error"), file.getName()),
MessageFormat.format("Mismatch between {0} hash {1} of uploaded data and ETag {2} returned by the server",
checksum.algorithm.toString(), expected, checksum.hash));
}
}
@Override
public AddressInformation getAddressInformation(final String address) throws ApplicationException {
try (final CloseableHttpClient client = getAuthenticatedHttpClientProxy();
final InputStream jsonData = doComplexJSONRPCMethod(client, "searchrawtransactions", address).getContent()) {
final AddressInformation addressInformation = JSONRPCParser.getAddressInformation(address, jsonData);
for (final AddressOutpoint outpoint : addressInformation.getOutpoints()) {
final String txid = new String(Hex.encodeHex(outpoint.getReferenceTransaction()));
try (final InputStream utxoJsonData = doComplexJSONRPCMethod(client, "gettxout", txid, outpoint.getIndex()).getContent()) {
outpoint.setSpent(JSONRPCParser.isNullResult(utxoJsonData));
}
}
return addressInformation;
} catch (IOException | HttpException | DecoderException e) {
e.printStackTrace();
throw new ApplicationException(e.getMessage());
}
}
public static byte[] hexStringToByteArray(String s) {
try {
return Hex.decodeHex(s.toCharArray());
} catch (DecoderException ex) {
// Crash the tests at this point, we've input bad data in our hard-coded values
throw new RuntimeException("Error decoding hex data: " + s);
}
}
/**
* Read pcap file to get all includes packet
*
* @param pcapFile
* @return
* @throws PcapNativeException
* @throws NotOpenException
*/
private List<String> getpcapPacketList(String pcapFile) throws PcapNativeException, NotOpenException {
PcapHandle handler = Pcaps.openOffline(pcapFile);
Packet packet = null;
List<String> packetList = new ArrayList<>();
while ((packet = handler.getNextPacket()) != null) {
packetList.add(Hex.encodeHexString(packet.getRawData()));
}
return packetList;
}
/**
* refresh underlying RegionScanner we call this when new store file gets
* created by MemStore flushes or current scanner fails due to compaction
*/
public void updateScanner() throws IOException {
if (LOG.isDebugEnabled()) {
SpliceLogUtils.debug(LOG,
"updateScanner with hregionInfo=%s, tableName=%s, rootDir=%s, scan=%s",
hri, htd.getNameAsString(), rootDir, scan);
}
if (flushed) {
if (LOG.isDebugEnabled())
SpliceLogUtils.debug(LOG, "Flush occurred");
byte[] restartRow = null;
if (rowBuffer != null && !rowBuffer.isEmpty()) {
restartRow = CellUtil.cloneRow(rowBuffer.get(0));
rowBuffer = null;
} else if (this.topCell != null) {
restartRow = Bytes.add(CellUtil.cloneRow(topCell), new byte[]{0});
}
if (restartRow != null) {
if (LOG.isDebugEnabled())
SpliceLogUtils.debug(LOG, "setting start row to %s", Hex.encodeHexString(restartRow));
//noinspection deprecation
scan.setStartRow(restartRow);
}
}
memScannerList.add(getMemStoreScanner());
this.region = openHRegion();
RegionScanner regionScanner = new CountingRegionScanner(HRegionUtil.getScanner(region, scan, memScannerList), region, scan);
if (flushed) {
if (scanner != null)
scanner.close();
}
scanner = regionScanner;
}
private static SecretKeySpec bй0439йй0439й(String str) throws Exception {
String str2 = null;
while (true) {
try {
str2.length();
} catch (Exception e) {
b0429Щ0429Щ0429Щ = b0429ЩЩЩ0429Щ();
try {
return new SecretKeySpec(Hex.decodeHex(str.toCharArray()), "AES");
} catch (Exception e2) {
throw e2;
}
}
}
}
private String saltAndEncrypt(char[] data) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
String value;
Hex hex = new Hex();
char[] saltedData = addSalt(data);
byte[] encode = encrypt(saltedData, password);
value = new String(hex.encode(encode));
return value;
}
public UpdatableDigester(final String modifier, final String algorithm) {
super(new UpdatableInputStreamDigester(20 * 1024 * 1024,
algorithm, algorithm.replace("-", ""), Hex::encodeHexString) {
@Override
protected String getDigestUpdateModifier() {
return modifier;
}
});
this.algorithm = algorithm;
}
/**
* 加密操作
*/
@Test
public void testEncryptPassword() {
String plainPsd = "123";
// 1. 用SecureRandom生成一个随机数
byte[] salt = new byte[8];
SecureRandom securityRandom = new SecureRandom();
securityRandom.nextBytes(salt);
// 2.用Hex来对随机数进行编码
String encodedSalt = Hex.encodeHexString(salt);
// 3.将随机数和密码用不可逆加密算法加密1024次
byte[] result = null;
try {
MessageDigest digest = MessageDigest.getInstance("SHA1");
digest.update(salt);
result = digest.digest(plainPsd.getBytes());
for (int i = 1; i < 1024; i++) {
digest.reset();
result = digest.digest(result);
}
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 4.将上一步得到的字节数组用Hex编码
String sha1Psd = Hex.encodeHexString(result);
// 5.将第二步和第四步得到的值拼凑
String encryptedPsd = encodedSalt + sha1Psd;
System.out.println(encryptedPsd);
}
@Test
public void testMapBlobColumn() {
byte[] value = new byte[20];
new Random().nextBytes(value);
primeWithType(Hex.encodeHexString(value), BLOB);
ResultSet resultSet = getResultSet();
Schema schema = Schema.builder().addNullableField("col", FieldType.BYTES).build();
Row expected = Row.withSchema(schema).addValue(value).build();
assertEquals(expected, cassandraRowMapper.map(resultSet).next());
}
@Test
public void testGetEntityId() throws DecoderException {
String id = "1234567890123456789012345678901234567890";
String superid = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
String extraid = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
Map<String, Object> delta = new HashMap<String, Object>();
delta.put("_id", Hex.decodeHex(id.toCharArray()));
assertEquals(id + "_id", DeltaJournal.getEntityId(delta));
delta.put("i", Arrays.asList(Hex.decodeHex(superid.toCharArray())));
assertEquals(superid + "_id" + id + "_id", DeltaJournal.getEntityId(delta));
delta.put("i", Arrays.asList(Hex.decodeHex(superid.toCharArray()), Hex.decodeHex(extraid.toCharArray())));
assertEquals(extraid + "_id" + superid + "_id" + id + "_id", DeltaJournal.getEntityId(delta));
}
private static <T> Java getByteCodeVersion(final Class<T> clazz) throws IOException {
final InputStream stream =
clazz.getClassLoader().getResourceAsStream(clazz.getName().replace(".", "/") + ".class");
final byte[] classBytes = IOUtils.toByteArray(stream);
final String versionInHexString =
Hex.encodeHexString(new byte[] {classBytes[6], classBytes[7]});
return versionMapping.get(versionInHexString);
}
/**
* Static method to get an MD5Digest from a binary byte representation
* @param md5Bytes
* @return a filled out MD5Digest
*/
public static MD5Digest fromBytes(byte[] md5Bytes)
{
Preconditions.checkArgument(md5Bytes.length == MD5_BYTES_LENGTH,
"md5 bytes must be " + MD5_BYTES_LENGTH + " bytes in length, found " + md5Bytes.length + " bytes.");
String md5String = Hex.encodeHexString(md5Bytes);
return new MD5Digest(md5String, md5Bytes);
}
@Test
public void buildModeOnlySpread() {
// Cluster ID test.
final byte[] result = IDBuilder.build(new Blueprint(0, 0, 0, 0));
final byte[] lastTwoBytes = new byte[]{result[6], result[7]};
final String expected = "0000";
assertThat(Hex.encodeHexString(lastTwoBytes), is(expected));
}
private static String createHmacSignature(String secret, String inputText, String algoName) {
try {
Mac mac = Mac.getInstance(algoName);
SecretKeySpec key = new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), algoName);
mac.init(key);
return new String(Hex.encodeHex(mac.doFinal(inputText.getBytes(StandardCharsets.UTF_8))));
} catch (Exception e) {
throw new RuntimeException("cannot create " + algoName, e);
}
}
/** the counter name should uniquely identify the entity being counted. */
@JsonIgnore
public String getCounterName() {
if ( counterName == null ) {
counterName = tableName + ":" + Hex.encodeHexString( getKeyNameBytes().array() ) + ":" + Hex
.encodeHexString( getColumnNameBytes().array() );
}
return counterName;
}