/** * Hex decode string. * * @param data the data * @return the string */ public static String hexDecode(final char[] data) { try { final byte[] result = Hex.decodeHex(data); return new String(result); } catch (final Exception e) { return null; } }
public byte[] decodeHash(String encodedHash) { if (!getEncodeHashAsBase64()) { try { return Hex.decodeHex(encodedHash.toCharArray()); } catch (DecoderException e) { throw new RuntimeException("Unable to decode password hash"); } } else { return Base64.decodeBase64(encodedHash.getBytes()); } }
@Override public void verify(DecodedJWT jwt, EncodeType encodeType) throws Exception { byte[] signatureBytes = null; String signature = jwt.getSignature(); String urlDecoded = null; switch (encodeType) { case Base16: urlDecoded = URLDecoder.decode(signature, "UTF-8"); signatureBytes = Hex.decodeHex(urlDecoded); break; case Base32: Base32 base32 = new Base32(); urlDecoded = URLDecoder.decode(signature, "UTF-8"); signatureBytes = base32.decode(urlDecoded); break; case Base64: signatureBytes = Base64.decodeBase64(signature); break; } if (signatureBytes.length > 0) { throw new SignatureVerificationException(this); } }
@Test public void testIPv6Mask120() throws InvalidKeyException, DecoderException { final int mask = 120; final IPPseudonymizer ipv6Pseudonymizer = IPPseudonymizer.initIPv6Pseudonymizer("3AE1E5F99DD4FF7196FE64ACDE688C89", mask); final byte[] ip = Hex.decodeHex("97010a9b423def694d2aa231011d1210".toCharArray()); final byte[] newIp = ipv6Pseudonymizer.pseudonymize(ip.clone()); for (int i = 0; i < mask / 8; i++) { assertThat(newIp[i], is(equalTo(ip[i]))); } for (int i = mask / 8; i < 16; i++) { assertThat(newIp[i], is(not(equalTo(ip[i])))); } }
private TransactionBlob generateTransactionBlob() throws SdkException{ Chain.Transaction.Builder builder = Chain.Transaction.newBuilder(); if (txMetadata != null) { builder.setMetadata(ByteString.copyFromUtf8(Hex.encodeHexString(txMetadata.getBytes()))); } builder.setSourceAddress(sponsorAddress); builder.setNonce(nonce); long specifiedSeq = nodeManager.getLastSeq() + finalNotifySeqOffset; logger.debug("specified seq:" + specifiedSeq); for (BcOperation bcOperation : operationList) { bcOperation.buildTransaction(builder, specifiedSeq); } cn.bubi.blockchain.adapter3.Chain.Transaction transaction = builder.build(); logger.info("transaction:" + transaction); byte[] bytesBlob = transaction.toByteArray(); TransactionBlob transactionBlob = new TransactionBlob(bytesBlob, nodeManager.getCurrentSupportHashType()); // 设置最长等待超时通知 txFailManager.finalNotifyFailEvent(specifiedSeq, transactionBlob.getHash(), SdkError.TRANSACTION_ERROR_TIMEOUT); return transactionBlob; }
protected void verify(final Path file, final MessageDigest digest, final Checksum checksum) throws ChecksumException { if(file.getType().contains(Path.Type.encrypted)) { log.warn(String.format("Skip checksum verification for %s with client side encryption enabled", file)); return; } if(null == digest) { log.debug(String.format("Digest disabled for file %s", file)); return; } if(null == checksum || !checksum.algorithm.equals(HashAlgorithm.md5)) { log.warn("ETag returned by server is unknown checksum algorithm"); return; } if(!checksum.algorithm.equals(HashAlgorithm.md5)) { log.warn(String.format("ETag %s returned by server is %s but expected MD5", checksum.hash, checksum.algorithm)); return; } // Obtain locally-calculated MD5 hash. final String expected = Hex.encodeHexString(digest.digest()); // Compare our locally-calculated hash with the ETag returned by S3. if(!checksum.equals(Checksum.parse(expected))) { throw new ChecksumException(MessageFormat.format(LocaleFactory.localizedString("Upload {0} failed", "Error"), file.getName()), MessageFormat.format("Mismatch between MD5 hash {0} of uploaded data and ETag {1} returned by the server", expected, checksum.hash)); } }
public static Message sendAsynchCommand(final String host, final int port, final CommandEnum command, final Optional<ByteArraySerializable> payload, final JSONObject error) throws IOException { final byte[] payloadBa; if (payload.isPresent()) { payloadBa = payload.get().toByteArray(); } else { payloadBa = new byte[0]; } final Message requestMessage = new Message(TestUtil.MAIN_NET_MAGIC, command, payloadBa); final byte[] requestBa = requestMessage.toByteArray(); LOG.info(">>>:{}", Hex.encodeHexString(requestBa)); final byte[] responseBa = sendAsynch(host, port, requestBa, error); LOG.info("<<<:{}", Hex.encodeHexString(responseBa)); if (responseBa.length == 0) { return null; } final ByteBuffer bb = ByteBuffer.wrap(responseBa); final Message responseMessage = new Message(bb); if (responseMessage.magic != MAIN_NET_MAGIC) { throw new RuntimeException("response magic was " + responseMessage.magic + " expected " + MAIN_NET_MAGIC); } return responseMessage; }
/** * decodes a hex string. * * @param string * the string to decode. * @return the decoded hex string. */ public static byte[] decodeHex(final String string) { try { return Hex.decodeHex(string.toCharArray()); } catch (final Exception e) { throw new RuntimeException(e); } }
/** * Hex解码. */ public static byte[] decodeHex(String input) { try { return Hex.decodeHex(input.toCharArray()); } catch (DecoderException e) { throw Exceptions.unchecked(e); } }
@Override public String process(int lineNumber, String result) throws DeserializeException { while (result.contains("\\X2\\")) { int index = result.indexOf("\\X2\\"); int indexOfEnd = result.indexOf("\\X0\\", index); if (indexOfEnd == -1) { throw new DeserializeException(lineNumber, "\\X2\\ not closed with \\X0\\"); } if ((indexOfEnd - index) % 4 != 0) { throw new DeserializeException(lineNumber, "Number of hex chars in \\X2\\ definition not divisible by 4"); } try { ByteBuffer buffer = ByteBuffer.wrap(Hex.decodeHex(result.substring(index + 4, indexOfEnd).toCharArray())); CharBuffer decode = Charsets.UTF_16BE.decode(buffer); result = result.substring(0, index) + decode.toString() + result.substring(indexOfEnd + 4); } catch (DecoderException e) { throw new DeserializeException(lineNumber, e); } } return result; }
private String signBase16Encoding() throws UnsupportedEncodingException { String header = URLEncoder.encode(headerJson, "UTF-8"); String payload = URLEncoder.encode(payloadJson, "UTF-8"); byte[] bHeader = header.getBytes("UTF-8"); String encodedHeader = Hex.encodeHexString(bHeader); byte[] bPayload = payload.getBytes("UTF-8"); String encodedPayload = Hex.encodeHexString(bPayload); String content = String.format("%s.%s", encodedHeader, encodedPayload); byte[] signatureBytes = algorithm.sign(content.getBytes(StandardCharsets.UTF_8)); String signature = Hex.encodeHexString(signatureBytes); String signatureFinal = URLEncoder.encode(signature, "UTF-8"); return String.format("%s.%s", content, signatureFinal); }
@SuppressWarnings("static-access") @Test public void testBcastPacket() { // This is Broadcast so set dstIpTarget to the broadcast IP InetSocketAddress dstIpTarget = new InetSocketAddress(pvs.VERIFICATION_PACKET_IP_DST, 200); // Generate the VerificationPacket OFPacketOut packet = pvs.generateVerificationPacket(sw1, OFPort.of(1)); System.out.println("packet: " + Hex.encodeHexString(packet.getData())); // Source MAC will always be that of sw1 for both Unicast and Broadcast byte[] srcMac = Arrays.copyOfRange(packet.getData(), 6, 12); assertArrayEquals(MacAddress.of(sw1HwAddrTarget).getBytes(), srcMac); // Destination MAC should be that of BROADCAST for Broadcast Packet byte[] dstMac = Arrays.copyOfRange(packet.getData(), 0, 6); assertArrayEquals(MacAddress.of(pvs.VERIFICATION_BCAST_PACKET_DST).getBytes(), dstMac); // Source IP is actual switch1 IP byte[] srcIpActual = Arrays.copyOfRange(packet.getData(), 26, 30); assertArrayEquals(srcIpTarget.getAddress().getAddress(), srcIpActual); // Destination IP is that of DESTINATION BROADCAST IP byte[] dstIpActual = Arrays.copyOfRange(packet.getData(), 30, 34); assertArrayEquals(dstIpTarget.getAddress().getAddress(), dstIpActual); }
/** * Create a new Ethereum account to be used for testing microraiden * channels. Stores the account in the same folder where the * program is run. Note - there is no encryption on this private key * so it should be used for anything real!! * @param accountFile - the name of the output file for the account */ public void createAccount(String accountFile) { ECKey keyPair = new ECKey(); String address = new String(Hex.encodeHex(keyPair.getAddress())); System.out.println("Generated new account: 0x" + address); byte[] priv = keyPair.getPrivKeyBytes(); try { OutputStream os = new FileOutputStream(accountFile + ".pkey"); JSONObject obj=new JSONObject(); obj.put("privkey", new String(Hex.encodeHex(priv))); obj.put("address", address); os.write(obj.toJSONString().getBytes()); os.close(); } catch (IOException e) { System.out.println("Couldn't write to file: " + accountFile + " " + e.toString()); } }
/** * @param face the the verifier should be generated for * @return Verifier */ @NotNull private Verifier generateVerifier(@NotNull Face face) throws MacFailedException, InvalidKeyException { Optional<byte[]> cborData = Utils.serializeCbor(face); if(cborData.isPresent()) { Optional<byte[]> psk = getPsk(face.getSai()); if (psk.isPresent()) { logger.debug("computeMac with payload: " + Hex.encodeHexString(cborData.get()) + " and algorithm: " + face.getMacMethod().algorithmName); byte[] mac = Utils.computeMac(face.getMacMethod(), psk.get(), cborData.get()); return new Verifier(mac); } } return new Verifier(new byte[]{}); }
/** * Hash user name and password according to the algorithm required by the Miniserver * * @param hashKeyHex * string with hash key received from the Miniserver in hex characters * @return * hashed credentials to send to the Miniserver for authentication */ private String hashCredentials(String hashKeyHex) { if (user == null || password == null || hashKeyHex == null) { return null; } try { byte[] hashKeyBytes = Hex.decodeHex(hashKeyHex.toCharArray()); SecretKeySpec signKey = new SecretKeySpec(hashKeyBytes, "HmacSHA1"); Mac mac = Mac.getInstance("HmacSHA1"); mac.init(signKey); String data = user + ":" + password; byte[] rawData = mac.doFinal(data.getBytes()); byte[] hexData = new Hex().encode(rawData); return new String(hexData, "UTF-8"); } catch (DecoderException | NoSuchAlgorithmException | InvalidKeyException | UnsupportedEncodingException e) { logger.debug("[{}] Error encrypting credentials: {}", debugId, e.getMessage()); return null; } }
/** * Encodes the rawPass using a MessageDigest. If a salt is specified it will * be merged with the password before encoding. * * @param rawPass * The plain text password * @param salt * The salt to sprinkle * @return Hex string of password digest (or base64 encoded string if * encodeHashAsBase64 is enabled. */ public String encodePassword(String rawPass, Object salt) { String saltedPass = mergePasswordAndSalt(rawPass, salt, false); MessageDigest messageDigest = getMessageDigest(); byte[] digest; try { digest = messageDigest.digest(saltedPass.getBytes("UTF-8")); } catch (UnsupportedEncodingException e) { throw new IllegalStateException("UTF-8 not supported!"); } if (getEncodeHashAsBase64()) { return new String(Base64.encodeBase64(digest)); } else { return new String(Hex.encodeHex(digest)); } }
/** * Hex解码. */ public static byte[] decodeHex(String input) { try { return Hex.decodeHex(input.toCharArray()); } catch (DecoderException e) { return "".getBytes(); } }
@Test public void test_div_2() throws Exception { BigInteger div = new BigInteger("3f7a027000000000000000000000000000000000000000000000000000000000", 16); BigInteger divBy = new BigInteger("100000000000000000000000000000000000000000000000000000000", 16); BytecodeChunk chunk = createChunk(0, new Opcode(Opcodes.PUSH1, divBy), new Opcode(Opcodes.PUSH1, div), new Opcode(Opcodes.DIV, null), new Opcode(Opcodes.STOP, null) ); EVMState evmState = symExecute(new HashMap<Integer, BytecodeChunk>() {{ put(0, chunk); }}); EVMStack stack = evmState.getStack(); assertTrue(stack.size() == 1); TraceableWord result = stack.pop(); assertTrue(Arrays.equals(Hex.decodeHex("3f7a0270"), result.getBytes())); }
/** * does something on a "block" message. * * @param peer * the peer that sent the message. * @param message * the message. */ private void onBlock(final RemoteNodeControllerRunnable peer, final Message message) { if (stopped) { return; } final Block newBlock = message.getPayload(Block.class); final String expected = new String(Hex.encodeHexString(message.getPayloadByteArray())); final String actual = Hex.encodeHexString(newBlock.toByteArray()); if (!expected.equals(actual)) { LOG.error("onBlock newBlock: {}", newBlock); LOG.error("onBlock expected: {}", expected); LOG.error("onBlock actual : {}", actual); return; } LocalNodeDataSynchronizedUtil.addUnverifiedBlock(localNodeData, newBlock); // LocalNodeDataSynchronizedUtil.verifyUnverifiedBlocks(localNodeData); }
/** * Handle message and create a response * @param input the incoming message * @return a byte response, an empty array is equal to no response. */ public List<byte[]> handleRequest(byte[] input) { SCTPMessage inFullMessage = SCTPMessage.fromBytes(input); logger.debug("Input Parsed: " + inFullMessage ); logger.debug("Flags: " + Hex.encodeHexString(new byte[]{input[13]})); SCTPHeader inHdr = inFullMessage.getHeader(); List<SCTPChunk> inChunks = inFullMessage.getChunks(); return inChunks.stream() .map(chunk -> { MessageHandler handler = handlerMap.get(chunk.getType()); if (handler != null) { Optional<SCTPMessage> out = handler.handleMessage(this, context, inHdr, chunk); return out.map(i -> SCTPUtil.addChecksum(i).toBytes()).orElse(new byte[]{}); } else { logger.warn("Not handled messagetype: " + chunk.getType()); return new byte[]{}; } }).collect(Collectors.toList()); }
public static String checksum(Long domainId, List<ITransaction> list) { xLogger.fine("Entered checksum: {0}", (list == null ? "NULL" : list.size())); Iterator<ITransaction> it = list.iterator(); try { MessageDigest md = MessageDigest.getInstance("MD5"); while (it.hasNext()) { ITransaction trans = it.next(); if (trans.getDomainId() == null) { trans.setDomainId(domainId); } byte[] fingerprint = trans.fingerprint(); if (fingerprint != null) { md.update(fingerprint); } } return new String(Hex.encodeHex(md.digest())); } catch (Exception e) { xLogger.warn("{0} when getting checksum: {1}", e.getClass().getName(), e.getMessage()); return null; } }
private void initialize() throws IOException, NoSuchAlgorithmException { SeekableResettableInputBridge in = new SeekableResettableInputBridge(ris); long pos = in.tell(); in.seek(0L); fileReader = new DataFileReader<GenericRecord>(in, new GenericDatumReader<GenericRecord>()); fileReader.sync(pos); schema = fileReader.getSchema(); datumWriter = new GenericDatumWriter(schema); out = new ByteArrayOutputStream(); encoder = EncoderFactory.get().binaryEncoder(out, encoder); schemaHash = SchemaNormalization.parsingFingerprint("CRC-64-AVRO", schema); schemaHashString = Hex.encodeHexString(schemaHash); }
public static byte[] hex(String hexString) throws DecodingException{ try { return Hex.decodeHex(hexString.toCharArray()); } catch (Exception ex){ throw new DecodingException("decode hex failed",ex); } }
/** * Convert String to md5 */ public Text evaluate(Text n) { if (n == null) { return null; } digest.reset(); digest.update(n.getBytes(), 0, n.getLength()); byte[] md5Bytes = digest.digest(); String md5Hex = Hex.encodeHexString(md5Bytes); result.set(md5Hex); return result; }
/** * Sends MAVLink packet to RockBLOCK. * * @param packet MAVLink packet to send. */ public void sendMessage(MAVLinkPacket packet) throws ClientProtocolException, IOException { if (packet == null) return; HttpPost httppost = new HttpPost(serviceURL); String data = Hex.encodeHexString(packet.encodePacket()); // Request parameters and other properties. List<NameValuePair> params = new ArrayList<NameValuePair>(2); params.add(new BasicNameValuePair(PARAM_IMEI, imei)); params.add(new BasicNameValuePair(PARAM_USERNAME, username)); params.add(new BasicNameValuePair(PARAM_PASSWORD, password)); params.add(new BasicNameValuePair(PARAM_DATA, data)); httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8")); HttpResponse response = httpclient.execute(httppost); HttpEntity entity = response.getEntity(); String responseString = null; if (entity != null) { InputStream responseStream = entity.getContent(); try { responseString = IOUtils.toString(responseStream); } finally { responseStream.close(); } } if (responseString == null || responseString.startsWith("FAILED")) { throw new IOException(String.format("Failed to post message to RockBLOCK API. %s", responseString)); } MAVLinkLogger.log(Level.INFO, "MT", packet); }
private MAVLinkPacket getPacket(String data) throws DecoderException { if (data == null || data.isEmpty()) { return null; } Parser parser = new Parser(); MAVLinkPacket packet = null; for (byte b : Hex.decodeHex(data.toCharArray())) { packet = parser.mavlink_parse_char(b & 0xFF); } return packet; }
public User createUser() { final byte[] salt = PasswordUtil.getNextSalt(); final String passwordHash = Hex.encodeHexString(PasswordUtil.hash(PASSWORD, salt)); final User user = new User(USERID, EMAIL, USERNAME, DISPLAYNAME, passwordHash, Hex.encodeHexString(salt), new Timestamp(System.currentTimeMillis()), false); new UserDao(con).insert(user); return user; }
public PathAttributes convert(final MantaObject object) { final PathAttributes attributes = new PathAttributes(); attributes.setPermission(new Permission( session.isUserWritable(object) ? Permission.Action.all : Permission.Action.read, Permission.Action.none, session.isWorldReadable(object) ? Permission.Action.read : Permission.Action.none)); if(object.getLastModifiedTime() != null) { attributes.setModificationDate(object.getLastModifiedTime().getTime()); } if(object.isDirectory()) { return attributes; } if(session.isWorldReadable(object)) { // mantaObject.getPath() starts with / final String joinedPath = session.getHost().getWebURL() + URIEncoder.encode(object.getPath()); try { final URI link = new URI(joinedPath); attributes.setLink(new DescriptiveUrl(link, DescriptiveUrl.Type.http)); } catch(URISyntaxException e) { log.warn(String.format("Cannot set link. Web URL returned %s", joinedPath), e); } } attributes.setSize(object.getContentLength()); attributes.setETag(object.getEtag()); final byte[] md5Bytes = object.getMd5Bytes(); if(md5Bytes != null) { attributes.setChecksum(new Checksum(HashAlgorithm.md5, Hex.encodeHexString(md5Bytes))); } final String storageClass = object.getHeaderAsString(HEADER_KEY_STORAGE_CLASS); if(storageClass != null) { attributes.setStorageClass(storageClass); } return attributes; }
public static String encodeHexAsBase64(String key) { requireNonNull(key, "`key` must not be null"); requireNonNull(MoreHex.isHex(key), "`key` must be in hex"); try { byte[] keyBase16 = Hex.decodeHex(key.toCharArray()); return Base64.getEncoder().encodeToString(keyBase16); } catch (DecoderException e) { throw new RuntimeException(e); } }
@Override public void verify(DecodedJWT jwt, EncodeType encodeType) throws Exception { byte[] contentBytes = String.format("%s.%s", jwt.getHeader(), jwt.getPayload()).getBytes(StandardCharsets.UTF_8); byte[] signatureBytes = null; String signature = jwt.getSignature(); String urlDecoded = null; switch (encodeType) { case Base16: urlDecoded = URLDecoder.decode(signature, "UTF-8"); signatureBytes = Hex.decodeHex(urlDecoded); break; case Base32: Base32 base32 = new Base32(); urlDecoded = URLDecoder.decode(signature, "UTF-8"); signatureBytes = base32.decode(urlDecoded); break; case Base64: signatureBytes = Base64.decodeBase64(signature); break; } try { boolean valid = crypto.verifySignatureFor(getDescription(), secret, contentBytes, signatureBytes); if (!valid) { throw new SignatureVerificationException(this); } } catch (IllegalStateException | InvalidKeyException | NoSuchAlgorithmException e) { throw new SignatureVerificationException(this, e); } }
public static void main(String[] args) throws DecoderException { // String hexString = "5095"; String hexString = "789c6d8d4d4f83401884ff0b578c5dba0bbb98782015b1a1f8059a7222743fc8da96aecbdbdad6f8dfa5046fce6de6c9cc7c3bc522bfeec4baaa8dd1c2b9713c822e0a7ddfb91aa03c1a6d65552b90b6e794d2a0e7231c5a550d15b6ff96416fe590e38051c2281d732d640b5ae96172ea051c29be524c62e463e57382e854a08020a578c8febe38dfed5ba8e0642e9b98e21174bae97d16bfcde633299e0f49c81f27a26490b97665d7675dd0fdc35df1de994d23bc4301db349fbb918ea3e36b509878f7956d84dbb44b4ed23287b454f7119c12fea4968b64927d7c962179b9757e7e01ed1059d9"; byte[] test = Hex.decodeHex(hexString.toCharArray()); byte[] compressBytes = base64EncodeUrl(test); System.out.println("compress : " + new String(compressBytes)); byte[] uncompressBytes = base64DecodeUrl(compressBytes); System.out.println("uncompress: " + Hex.encodeHexString(uncompressBytes)); }
public static String CommonHash(String p, String alg) throws NoSuchAlgorithmException { MessageDigest md = MessageDigest.getInstance(alg); md.reset(); md.update(p.getBytes(Charset.forName("UTF-8"))); byte[] resBytes = md.digest(); String res = new String(Hex.encodeHex(resBytes)); return res; }
/** * Data is sent as a SCTPMessage * * * @param data bytes to send */ @Override public void send(byte[] data,SCTPPayloadProtocolId ppid) { if(mode == ConnectionMode.TRANSFER && running) { byte[] out = sctpService.createPayloadMessage(data, ppid); putDataOnWire(out); } else { logger.error("Data {} not sent, channel not open",Hex.encodeHex(data)); } }
/** * reads a variable length list of byte array serializable objects. * * @param bb * the byte buffer to read. * @param cl * the class of the objects in the list, which must implement * ByteArraySerializable. * @param <T> * the type of the objects in the list. * @return the list. */ public static <T extends ByteArraySerializable> List<T> readVariableLengthList(final ByteBuffer bb, final Class<T> cl) { final BigInteger lengthBi = getBigInteger(bb); final int length = lengthBi.intValue(); LOG.trace("readArray length {} class {}", length, cl.getSimpleName()); final List<T> list = new ArrayList<>(); for (int ix = 0; ix < length; ix++) { LOG.trace("STARTED readArray class {} [{}]", cl.getSimpleName(), ix); final T t; try { final Constructor<T> con = cl.getConstructor(ByteBuffer.class); t = con.newInstance(bb); } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { throw new RuntimeException( "error reading record " + (ix + 1) + " of " + length + " class " + cl.getSimpleName(), e); } LOG.trace("SUCCESS readArray class {} [{}]: {} {}", cl.getSimpleName(), ix, Hex.encodeHexString(t.toByteArray()), t); list.add(t); } return list; }
public static String makeC3P0UserOverridesString ( String codebase, String clazz ) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException, IOException { ByteArrayOutputStream b = new ByteArrayOutputStream(); try ( ObjectOutputStream oos = new ObjectOutputStream(b) ) { Class<?> refclz = Class.forName("com.mchange.v2.naming.ReferenceIndirector$ReferenceSerialized"); //$NON-NLS-1$ Constructor<?> con = refclz.getDeclaredConstructor(Reference.class, Name.class, Name.class, Hashtable.class); con.setAccessible(true); Reference jndiref = new Reference("Foo", clazz, codebase); Object ref = con.newInstance(jndiref, null, null, null); oos.writeObject(ref); } return "HexAsciiSerializedMap:" + Hex.encodeHexString(b.toByteArray()) + ";"; //$NON-NLS-1$ }
@Test public void buildMostlyOnes() { final byte[] result = IDBuilder.build(new Blueprint(Blueprint.MAX_TIMESTAMP, Blueprint.MAX_SEQUENCE_COUNTER, Blueprint.MAX_GENERATOR_ID, Blueprint.MAX_CLUSTER_ID)); final String expected = "ffffffffffff0fff"; assertThat(Hex.encodeHexString(result), CoreMatchers.is(expected)); }
@Test public void encodeHexAsBase64() { String value = "ABCDEF"; String valueHex = new String(Hex.encodeHex(value.getBytes(Charsets.UTF_8))); assertThat(valueHex, is(equalTo("414243444546"))); String valueBase64 = CryptotoolUtils.encodeHexAsBase64(valueHex); assertThat(valueBase64, is(equalTo("QUJDREVG"))); }
@Test public void test_toHex() { // lower-case assertThat(PluginHashes.toHex("aloa_bi_bop_a_loula".getBytes())).isEqualTo("616c6f615f62695f626f705f615f6c6f756c61"); // compare results with commons-codec for (int index = 0; index < 100; index++) { String random = randomString(); assertThat(PluginHashes.toHex(random.getBytes())).as(random).isEqualTo( Hex.encodeHexString(random.getBytes()).toLowerCase()); } }
@Override public boolean sendDiscoveryMessage(DatapathId srcSwId, OFPort port) { IOFSwitch srcSwitch = switchService.getSwitch(srcSwId); if (srcSwitch == null) { return false; } OFPacketOut ofPacketOut = (generateVerificationPacket(srcSwitch, port)); logger.debug("sending verification packet out {}/{}: {}", srcSwitch.getId().toString(), port.getPortNumber(), Hex.encodeHexString(ofPacketOut.getData())); return srcSwitch.write(ofPacketOut); }