@Override public byte[] fragmentToByteArray() { DatagramWriter writer = new DatagramWriter(); writer.writeBytes(verifyData); return writer.toByteArray(); }
@Override public byte[] fragmentToByteArray() { DatagramWriter writer = new DatagramWriter(); switch (curveType) { // TODO add support for other curve types case EXPLICIT_PRIME: case EXPLICIT_CHAR2: break; case NAMED_CURVE: writeNamedCurve(writer); break; default: LOGGER.log(Level.WARNING, MSG_UNKNOWN_CURVE_TYPE, curveType); break; } return writer.toByteArray(); }
@Override public byte[] fragmentToByteArray() { DatagramWriter writer = new DatagramWriter(); // TODO only true, if the public value encoding is explicit (not in the // client's certificate), see // http://tools.ietf.org/html/rfc4492#section-5.7 int length = pointEncoded.length; writer.write(length, LENGTH_BITS); writer.writeBytes(pointEncoded); return writer.toByteArray(); }
@Override public byte[] fragmentToByteArray() { DatagramWriter writer = new DatagramWriter(); writer.write(identityEncoded.length, IDENTITY_LENGTH_BITS); writer.writeBytes(identityEncoded); return writer.toByteArray(); }
@Override public byte[] toByteArray() { DatagramWriter writer = new DatagramWriter(); writer.write(CCSProtocolType.getCode(), CCS_BITS); return writer.toByteArray(); }
private byte[] getNonce(byte[] implicitNonce, byte[] explicitNonce) { DatagramWriter writer = new DatagramWriter(); writer.writeBytes(implicitNonce); writer.writeBytes(explicitNonce); return writer.toByteArray(); }
@Override public byte[] fragmentToByteArray() { DatagramWriter writer = new DatagramWriter(); writer.write(hintEncoded.length, IDENTITY_HINT_LENGTH_BITS); writer.writeBytes(hintEncoded); return writer.toByteArray(); }
/** * Transform a list of cipher suites into the appropriate bit-format. * * @param cipherSuites * the cipher suites * @return the byte[] */ public static byte[] listToByteArray(List<CipherSuite> cipherSuites) { DatagramWriter writer = new DatagramWriter(); for (CipherSuite cipherSuite : cipherSuites) { writer.write(cipherSuite.getCode(), CIPHER_SUITE_BITS); } return writer.toByteArray(); }
/** * Takes a list of compression methods and creates the representing byte * stream. * * @param compressionMethods * the list of the compression methods * @return the corresponding byte array */ public static byte[] listToByteArray(List<CompressionMethod> compressionMethods) { DatagramWriter writer = new DatagramWriter(); for (CompressionMethod compressionMethod : compressionMethods) { writer.write(compressionMethod.getCode(), COMPRESSION_METHOD_BITS); } return writer.toByteArray(); }
public byte[] toByteArray() { if (extensions.isEmpty()) { return new byte[]{}; } else { DatagramWriter writer = new DatagramWriter(); writer.write(getLength(), LENGTH_BITS); for (HelloExtension extension : extensions) { writer.writeBytes(extension.toByteArray()); } return writer.toByteArray(); } }
/** * Generates the explicit part of the nonce to be used with the AEAD Cipher. * * <a href="http://tools.ietf.org/html/rfc6655#section-3">RFC6655, Section 3</a> * encourages the use of the session's 16bit epoch value concatenated * with a monotonically increasing 48bit sequence number as the explicit nonce. * * @return the 64-bit explicit nonce constructed from the epoch and sequence number */ private byte[] generateExplicitNonce() { //TODO: re-factor to use simple byte array manipulation instead of using bit-based DatagramWriter DatagramWriter writer = new DatagramWriter(); writer.write(epoch, EPOCH_BITS); writer.writeLong(sequenceNumber, SEQUENCE_NUMBER_BITS); return writer.toByteArray(); }
/** * Serializes this extension to its byte representation as specified by its * respective RFC. * <p> * This method writes this extension's 2-byte code to the result array * and then hands the array over to the {@link #addExtensionData(DatagramWriter)} * method in order to add the encoded extension data. * * @return The byte representation. */ public final byte[] toByteArray() { DatagramWriter writer = new DatagramWriter(); writer.write(type.getId(), TYPE_BITS); addExtensionData(writer); return writer.toByteArray(); }
/** * {@inheritDoc} */ @Override public byte[] toByteArray() { DatagramWriter writer = new DatagramWriter(); writer.write(level.getCode(), BITS); writer.write(description.getCode(), BITS); return writer.toByteArray(); }
@Override public byte[] fragmentToByteArray() { DatagramWriter writer = new DatagramWriter(); writer.write(serverVersion.getMajor(), VERSION_BITS); writer.write(serverVersion.getMinor(), VERSION_BITS); writer.write(cookie.length, COOKIE_LENGTH_BITS); writer.writeBytes(cookie); return writer.toByteArray(); }
@Override public byte[] fragmentToByteArray() { DatagramWriter writer = new DatagramWriter(); if (rawPublicKeyBytes == null) { writer.write(getMessageLength() - 3, CERTIFICATE_LIST_LENGTH); // the size of the certificate chain for (byte[] encoded : encodedChain) { // the size of the current certificate writer.write(encoded.length, CERTIFICATE_LENGTH_BITS); // the encoded current certificate writer.writeBytes(encoded); } } else { writer.write(rawPublicKeyBytes.length, CERTIFICATE_LENGTH_BITS); writer.writeBytes(rawPublicKeyBytes); } return writer.toByteArray(); }
@Override public byte[] fragmentToByteArray() { DatagramWriter writer = new DatagramWriter(); // according to http://tools.ietf.org/html/rfc5246#section-4.7 the // signature algorithm must also be included writer.write(signatureAndHashAlgorithm.getHash().getCode(), HASH_ALGORITHM_BITS); writer.write(signatureAndHashAlgorithm.getSignature().getCode(), SIGNATURE_ALGORITHM_BITS); writer.write(signatureBytes.length, SIGNATURE_LENGTH_BITS); writer.writeBytes(signatureBytes); return writer.toByteArray(); }
/** * Serializes a request to the wire format. * <p> * The main difference between this and the <em>serializeRequest</em> method is that this method * does <em>not</em> cache the byte array in the request's <em>bytes</em> property. * * @param request The request to serialize. * @return The encoded request. */ public final byte[] getByteArray(final Request request) { DatagramWriter writer = new DatagramWriter(); byte[] body = serializeOptionsAndPayload(request); MessageHeader header = new MessageHeader(CoAP.VERSION, request.getType(), request.getToken(), request.getRawCode(), request.getMID(), body.length); serializeHeader(writer, header); writer.writeBytes(body); return writer.toByteArray(); }
/** * Encodes this record into its corresponding <em>DTLSCiphertext</em> structure. * * @return a byte array containing the <em>DTLSCiphertext</em> structure */ public synchronized byte[] toByteArray() { DatagramWriter writer = new DatagramWriter(); writer.write(type.getCode(), CONTENT_TYPE_BITS); writer.write(version.getMajor(), VERSION_BITS); writer.write(version.getMinor(), VERSION_BITS); writer.write(epoch, EPOCH_BITS); writer.writeLong(sequenceNumber, SEQUENCE_NUMBER_BITS); length = fragmentBytes.length; writer.write(length, LENGTH_BITS); writer.writeBytes(fragmentBytes); return writer.toByteArray(); }
/** * Serializes empty messages and caches bytes on the emptyMessage object to skip future serializations. * * @param emptyMessage The message to serialize. * @return The object containing the serialized message. */ public final RawData serializeEmptyMessage(final EmptyMessage emptyMessage) { if (emptyMessage.getBytes() == null) { DatagramWriter writer = new DatagramWriter(); byte[] body = serializeOptionsAndPayload(emptyMessage); MessageHeader header = new MessageHeader(CoAP.VERSION, emptyMessage.getType(), emptyMessage.getToken(), 0, emptyMessage.getMID(), body.length); serializeHeader(writer, header); writer.writeBytes(body); byte[] bytes = writer.toByteArray(); emptyMessage.setBytes(bytes); } return new RawData(emptyMessage.getBytes(), emptyMessage.getDestination(), emptyMessage.getDestinationPort()); }
@Override public byte[] fragmentToByteArray() { DatagramWriter writer = new DatagramWriter(); writer.write(serverVersion.getMajor(), VERSION_BITS); writer.write(serverVersion.getMinor(), VERSION_BITS); writer.writeBytes(random.getRandomBytes()); writer.write(sessionId.length(), SESSION_ID_LENGTH_BITS); writer.writeBytes(sessionId.getId()); writer.write(cipherSuite.getCode(), CIPHER_SUITE_BITS); writer.write(compressionMethod.getCode(), COMPRESSION_METHOD_BITS); if (extensions != null) { writer.writeBytes(extensions.toByteArray()); } return writer.toByteArray(); }