@Override public List<ModifiableVariableHolder> getAllModifiableVariableHolders() { List<ModifiableVariableHolder> holders = super.getAllModifiableVariableHolders(); if (ticket != null) { holders.add(ticket); } return holders; }
protected void prepareExtensionLength() { msg.setExtensionsLength(msg.getExtensionBytes().getValue().length); LOGGER.debug("ExtensionLength: " + msg.getExtensionsLength().getValue()); }
public static List<ExtensionMessage> getAllSendExtensions(WorkflowTrace trace) { List<HandshakeMessage> handshakeMessageList = getAllSendHandshakeMessages(trace); List<ExtensionMessage> extensionList = new LinkedList<>(); for (HandshakeMessage message : handshakeMessageList) { extensionList.addAll(message.getExtensions()); } return extensionList; }
private void prepareFragmentOffset(HandshakeMessage msg) { msg.setFragmentOffset(0); LOGGER.debug("FragmentOffset: " + msg.getFragmentOffset().getValue()); }
protected void prepareExtensions() { ByteArrayOutputStream stream = new ByteArrayOutputStream(); if (msg.getExtensions() != null) { for (ExtensionMessage extensionMessage : msg.getExtensions()) { HandshakeMessageType handshakeMessageType = msg.getHandshakeMessageType(); if (extensionMessage instanceof HRRKeyShareExtensionMessage) { handshakeMessageType = HandshakeMessageType.HELLO_RETRY_REQUEST; } ExtensionHandler handler = HandlerFactory.getExtensionHandler(chooser.getContext(), extensionMessage.getExtensionTypeConstant(), handshakeMessageType); handler.getPreparator(extensionMessage).prepare(); try { stream.write(extensionMessage.getExtensionBytes().getValue()); } catch (IOException ex) { throw new PreparationException("Could not write ExtensionBytes to byte[]", ex); } } } msg.setExtensionBytes(stream.toByteArray()); LOGGER.debug("ExtensionBytes: " + ArrayConverter.bytesToHexString(msg.getExtensionBytes().getValue())); }
/** * Reads the next bytes as the ExtensionBytes and writes them in the message * and adds parsed Extensions to the message * * @param message * Message to write in */ protected void parseExtensionBytes(T message) { byte[] extensionBytes = parseByteArrayField(message.getExtensionsLength().getValue()); message.setExtensionBytes(extensionBytes); LOGGER.debug("ExtensionBytes:" + ArrayConverter.bytesToHexString(extensionBytes, false)); List<ExtensionMessage> extensionMessages = new LinkedList<>(); int pointer = 0; while (pointer < extensionBytes.length) { ExtensionParser parser = ExtensionParserFactory.getExtensionParser(extensionBytes, pointer, message.getHandshakeMessageType()); extensionMessages.add(parser.parse()); if (pointer == parser.getPointer()) { throw new ParserException("Ran into infinite Loop while parsing Extensions"); } pointer = parser.getPointer(); } message.setExtensions(extensionMessages); }
/** * Parses a byteArray from a Position into a MessageObject and returns the * parsed MessageObjet and parser position in a parser result. The current * Chooser is adjusted as * * @param message * The byte[] messages which should be parsed * @param pointer * The pointer (startposition) into the message bytes * @return The Parser result */ public ParserResult parseMessage(byte[] message, int pointer) { Parser<Message> parser = getParser(message, pointer); Message parsedMessage = parser.parse(); try { prepareAfterParse(parsedMessage); if (parsedMessage instanceof HandshakeMessage) { if (((HandshakeMessage) parsedMessage).getIncludeInDigest()) { tlsContext.getDigest().append(parsedMessage.getCompleteResultingMessage().getValue()); } } adjustTLSContext(parsedMessage); } catch (AdjustmentException | UnsupportedOperationException E) { LOGGER.warn("Could not adjust TLSContext"); LOGGER.debug(E); } return new ParserResult(parsedMessage, parser.getPointer()); }
private void parseFragmentLength(T msg) { msg.setFragmentLength(parseIntField(HandshakeByteLength.DTLS_FRAGMENT_LENGTH)); LOGGER.debug("FragmentLength:" + msg.getFragmentLength().getValue()); }
/** * Reads the next bytes as the ExtensionLength and writes them in the * message * * @param message * Message to write in */ protected void parseExtensionLength(T message) { message.setExtensionsLength(parseIntField(HandshakeByteLength.EXTENSION_LENGTH)); LOGGER.debug("ExtensionLength:" + message.getExtensionsLength().getValue()); }
@Override protected final void prepareProtocolMessageContents() { prepareHandshakeMessageContents(); // Ugly but only temporary serializer = (HandshakeMessageSerializer) msg.getHandler(chooser.getContext()).getSerializer(msg); prepareMessageLength(serializer.serializeHandshakeMessageContent().length); if (isDTLS()) { prepareFragmentLenth(msg); prepareFragmentOffset(msg); prepareMessageSeq(msg); } prepareMessageType(msg.getHandshakeMessageType()); }
/** * Checks if the message has an ExtensionsLength field * * @return True if the message has an ExtensionLength field */ protected boolean hasExtensionLengthField() { return msg.getExtensionsLength() != null; }
private static List<HandshakeMessage> filterMessageList(List<HandshakeMessage> messages, HandshakeMessageType type) { List<HandshakeMessage> returnedMessages = new LinkedList<>(); for (HandshakeMessage handshakeMessage : messages) { if (handshakeMessage.getHandshakeMessageType() == type) { returnedMessages.add(handshakeMessage); } } return returnedMessages; }
/** * Checks if the message has Extensions * * @return True if the message has Extensions */ protected boolean hasExtensions() { return msg.getExtensionBytes() != null; }
/** * Writes the FragmentOffset of the HandshakeMessage into the final byte[] */ private void writeFragmentOffset() { appendInt(msg.getFragmentOffset().getValue(), HandshakeByteLength.DTLS_FRAGMENT_OFFSET); LOGGER.debug("FragmentOffset: " + msg.getFragmentOffset().getValue()); }
/** * Writes the FragmentLength of the HandshakeMessage into the final byte[] */ private void writeFragmentLength() { appendInt(msg.getFragmentLength().getValue(), HandshakeByteLength.DTLS_FRAGMENT_LENGTH); LOGGER.debug("FragmentLength: " + msg.getFragmentLength().getValue()); }
protected void afterPrepareExtensions() { ByteArrayOutputStream stream = new ByteArrayOutputStream(); if (msg.getExtensions() != null) { for (ExtensionMessage extensionMessage : msg.getExtensions()) { HandshakeMessageType handshakeMessageType = msg.getHandshakeMessageType(); if (extensionMessage instanceof HRRKeyShareExtensionMessage) { // TODO // fix // design // flaw handshakeMessageType = HandshakeMessageType.HELLO_RETRY_REQUEST; } ExtensionHandler handler = HandlerFactory.getExtensionHandler(chooser.getContext(), extensionMessage.getExtensionTypeConstant(), handshakeMessageType); Preparator preparator = handler.getPreparator(extensionMessage); if (handler instanceof PreSharedKeyExtensionHandler && msg instanceof ClientHelloMessage && chooser.getConnectionEndType() == ConnectionEndType.CLIENT) { ((PreSharedKeyExtensionPreparator) preparator).setClientHello((ClientHelloMessage) msg); preparator.afterPrepare(); } try { stream.write(extensionMessage.getExtensionBytes().getValue()); } catch (IOException ex) { throw new PreparationException("Could not write ExtensionBytes to byte[]", ex); } } } msg.setExtensionBytes(stream.toByteArray()); LOGGER.debug("ExtensionBytes: " + ArrayConverter.bytesToHexString(msg.getExtensionBytes().getValue())); }
message.setCompleteResultingMessage(completeMessage); if (message instanceof HandshakeMessage) { if (((HandshakeMessage) message).getIncludeInDigest()) { tlsContext.getDigest().append(message.getCompleteResultingMessage().getValue());
/** * Reads the next bytes as the MessageLength and writes them in the message * * @param message * Message to write in */ private void parseLength(HandshakeMessage message) { message.setLength(parseIntField(HandshakeByteLength.MESSAGE_LENGTH_FIELD)); LOGGER.debug("Length:" + message.getLength().getValue()); }