How to use

ProtocolMessage

in

de.rub.nds.tlsattacker.core.protocol.message

/**
 * Reads the next bytes as the CompleteResultingMessage and writes them in
 * the message
 *
 * @param msg
 *            Message to write in
 */
private void parseCompleteResultingMessage(ProtocolMessage msg) {
  msg.setCompleteResultingMessage(getAlreadyParsed());
  LOGGER.debug("CompleteResultMessage: "
      + ArrayConverter.bytesToHexString(msg.getCompleteResultingMessage().getValue()));
}

private static List<ProtocolMessage> filterMessageList(List<ProtocolMessage> messages, ProtocolMessageType type) {
  List<ProtocolMessage> returnedMessages = new LinkedList<>();
  for (ProtocolMessage protocolMessage : messages) {
    if (protocolMessage.getProtocolMessageType() == type) {
      returnedMessages.add(protocolMessage);
    }
  }
  return returnedMessages;
}

public static List<HandshakeMessage> filterHandshakeMessagesFromList(List<ProtocolMessage> messages) {
  List<HandshakeMessage> returnedMessages = new LinkedList<>();
  for (ProtocolMessage protocolMessage : messages) {
    if (protocolMessage.isHandshakeMessage()) {
      returnedMessages.add((HandshakeMessage) protocolMessage);
    }
  }
  return returnedMessages;
}

/**
 * Apply the contents of the messages to the given TLS context.
 * 
 * @param protocolMessages
 * @param tlsContext
 */
private void applyMessages(TlsContext ctx) {
  for (ProtocolMessage msg : receivedMessages) {
    LOGGER.debug("Applying " + msg.toCompactString() + " to forward context " + ctx);
    ProtocolMessageHandler h = msg.getHandler(ctx);
    h.adjustTLSContext(msg);
  }
}

public String getReadableString(List<ProtocolMessage> messages, Boolean verbose) {
  StringBuilder builder = new StringBuilder();
  if (messages == null) {
    return builder.toString();
  }
  for (ProtocolMessage message : messages) {
    if (verbose) {
      builder.append(message.toString());
    } else {
      builder.append(message.toCompactString());
    }
    if (!message.isRequired()) {
      builder.append("*");
    }
    builder.append(", ");
  }
  return builder.toString();
}

@Override
public String toString() {
  StringBuilder sb = new StringBuilder("PopAndSendAction:\n");
  sb.append("Messages:\n");
  for (ProtocolMessage message : messages) {
    sb.append(message.toCompactString());
    sb.append(", ");
  }
  return sb.toString();
}

  Serializer serializer = getSerializer(message);
  byte[] completeMessage = serializer.serialize();
  message.setCompleteResultingMessage(completeMessage);
  if (message instanceof HandshakeMessage) {
    if (((HandshakeMessage) message).getIncludeInDigest()) {
      tlsContext.getDigest().append(message.getCompleteResultingMessage().getValue());
  if (message.getAdjustContext()) {
    adjustTLSContext(message);
  } else {
    LOGGER.debug("Not adjusting TLSContext for " + message.toCompactString());
  LOGGER.debug(E);
return message.getCompleteResultingMessage().getValue();

MessageBytesCollector messageBytesCollector = new MessageBytesCollector();
for (ProtocolMessage message : messages) {
  if (message.getProtocolMessageType() != lastType && lastMessage != null
      && context.getConfig().isFlushOnMessageTypeChange()) {
    recordPosition = flushBytesToRecords(messageBytesCollector, lastType, records, recordPosition, context);
    lastMessage.getHandler(context).adjustTlsContextAfterSerialize(lastMessage);
    lastMessage = null;
  lastType = message.getProtocolMessageType();
  byte[] protocolMessageBytes;
  if (prepareMessages) {
    LOGGER.debug("Preparing " + message.toCompactString());
    protocolMessageBytes = handleProtocolMessage(message, context);
  } else {
    protocolMessageBytes = handleProtocolMessageWithoutPrepare(message, context);
  if (message.isGoingToBeSent()) {
    messageBytesCollector.appendProtocolMessageBytes(protocolMessageBytes);
  } else {
    LOGGER.debug("Not adding message bytes for " + message.toCompactString() + " - goingToBeSent is false!");
    message.getHandler(context).adjustTlsContextAfterSerialize(message);
    lastMessage = null;
  lastMessage.getHandler(context).adjustTlsContextAfterSerialize(lastMessage);

  private byte[] computeControlValue(WorkflowTrace trace, TlsContext tlsContext) throws CryptoException {
    tlsContext.getDigest().reset();
    for (MessageAction messageAction : trace.getMessageActions()) {
      for (ProtocolMessage message : messageAction.getMessages()) {
        if (message instanceof ChangeCipherSpecMessage) {
          break;
        }
        if (message.isHandshakeMessage()) {
          HandshakeMessage handshakeMessage = (HandshakeMessage) message;
          if (handshakeMessage.getIncludeInDigest()) {
            tlsContext.getDigest().append(message.getCompleteResultingMessage().getValue());
          }
        }
      }
    }

    byte[] handshakeMessageHash = tlsContext.getDigest().digest(tlsContext.getSelectedProtocolVersion(),
        tlsContext.getSelectedCipherSuite());
    PRFAlgorithm prfAlgorithm = tlsContext.getChooser().getPRFAlgorithm();
    byte[] control = PseudoRandomFunction.compute(prfAlgorithm, tlsContext.getMasterSecret(),
        PseudoRandomFunction.CLIENT_FINISHED_LABEL, handshakeMessageHash, HandshakeByteLength.VERIFY_DATA);
    byte[] compare = ArrayConverter.concatenate(HandshakeMessageType.FINISHED.getArrayValue(),
        ArrayConverter.intToBytes(control.length, HandshakeByteLength.MESSAGE_LENGTH_FIELD), control);
    return compare;
  }
}

  @Override
  public List<ModifiableVariableHolder> getAllModifiableVariableHolders() {
    List<ModifiableVariableHolder> holders = super.getAllModifiableVariableHolders();
    if (getExtensions() != null) {
      for (ExtensionMessage em : getExtensions()) {
        if (em != null) {
          holders.addAll(em.getAllModifiableVariableHolders());
        }
      }
    }
    return holders;
  }
}

/**
 * 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 byte[] handleProtocolMessageWithoutPrepare(ProtocolMessage message, TlsContext context) {
  ProtocolMessageHandler handler = message.getHandler(context);
  byte[] protocolMessageBytes = handler.prepareMessage(message, false);
  return protocolMessageBytes;
}

@Override
public Field getRandomModifiableVariableField(Random random) {
  List<Field> fields = getAllModifiableVariableFields();
  int randomField = random.nextInt(fields.size());
  return fields.get(randomField);
}

@Override
public String toString() {
  StringBuilder sb = new StringBuilder("BufferedSend Action:\n");
  sb.append("Messages:\n");
  for (ProtocolMessage message : messages) {
    sb.append(message.toCompactString());
    sb.append(", ");
  }
  return sb.toString();
}

@Override
public void execute(State state) throws WorkflowExecutionException, IOException {
  TlsContext ctx = state.getTlsContext(connectionAlias);
  if (isExecuted()) {
    throw new WorkflowExecutionException("Action already executed!");
  }
  List<ProtocolMessage> messages = ctx.getMessageBuffer();
  if (messages.isEmpty()) {
    LOGGER.debug("Empty buffer, no messages to apply");
  } else {
    for (ProtocolMessage msg : messages) {
      LOGGER.debug("Applying buffered " + msg.toCompactString() + " to context " + ctx);
      ProtocolMessageHandler h = msg.getHandler(ctx);
      h.adjustTLSContext(msg);
    }
  }
  setExecuted(true);
}

public String getReadableString(List<ProtocolMessage> messages, Boolean verbose) {
  StringBuilder builder = new StringBuilder();
  if (messages == null) {
    return builder.toString();
  }
  for (ProtocolMessage message : messages) {
    if (verbose) {
      builder.append(message.toString());
    } else {
      builder.append(message.toCompactString());
    }
    if (!message.isRequired()) {
      builder.append("*");
    }
    builder.append(", ");
  }
  return builder.toString();
}

if (messages != null) {
  for (ProtocolMessage message : messages) {
    holders.addAll(message.getAllModifiableVariableHolders());

  private byte[] handleProtocolMessage(ProtocolMessage message, TlsContext context) {
    ProtocolMessageHandler handler = message.getHandler(context);
    byte[] protocolMessageBytes = handler.prepareMessage(message);
    return protocolMessageBytes;
  }
}

@Override
public String toString() {
  StringBuilder sb = new StringBuilder("Receive Action:\n");
  sb.append("\tActual:");
  for (ProtocolMessage message : messages) {
    sb.append(message.toCompactString());
    sb.append(", ");
  }
  return sb.toString();
}

public static List<ProtocolMessage> getAllReceivedMessages(WorkflowTrace trace, ProtocolMessageType type) {
  List<ProtocolMessage> receivedMessage = new LinkedList<>();
  for (ProtocolMessage message : getAllReceivedMessages(trace)) {
    if (message.getProtocolMessageType() == type) {
      receivedMessage.add(message);
    }
  }
  return receivedMessage;
}