Skip to content

Commit 4ac61a2

Browse files
Christoph Penkertic0ns
Christoph Penkert
authored and
ic0ns
committed
Added first classes to support Supplemental Data (#346)
* Added first classes to support Supplemental Data
1 parent 0f29d3a commit 4ac61a2

File tree

8 files changed

+398
-1
lines changed

8 files changed

+398
-1
lines changed

‎TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/HandshakeMessageType.java‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,8 @@ public enum HandshakeMessageType {
3333
SERVER_HELLO_DONE((byte) 14),
3434
CERTIFICATE_VERIFY((byte) 15),
3535
CLIENT_KEY_EXCHANGE((byte) 16),
36-
FINISHED((byte) 20);
36+
FINISHED((byte) 20),
37+
SUPPLEMENTAL_DATA((byte) 23);
3738

3839
private int value;
3940

‎TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/protocol/handler/SupplementalDataMessageHandler.java‎

Lines changed: 45 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,45 @@
1+
/**
2+
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
3+
*
4+
* Copyright 2014-2017 Ruhr University Bochum / Hackmanit GmbH
5+
*
6+
* Licensed under Apache License 2.0
7+
* http://www.apache.org/licenses/LICENSE-2.0
8+
*/
9+
package de.rub.nds.tlsattacker.core.protocol.handler;
10+
11+
import de.rub.nds.tlsattacker.core.protocol.message.SupplementalDataMessage;
12+
import de.rub.nds.tlsattacker.core.protocol.parser.SupplementalDataMessageParser;
13+
import de.rub.nds.tlsattacker.core.protocol.preparator.SupplementalDataMessagePreparator;
14+
import de.rub.nds.tlsattacker.core.protocol.serializer.SupplementalDataMessageSerializer;
15+
import de.rub.nds.tlsattacker.core.state.TlsContext;
16+
17+
/**
18+
* @author Christoph Penkert <christoph.penkert@rub.de>
19+
*/
20+
21+
public class SupplementalDataMessageHandler extends HandshakeMessageHandler<SupplementalDataMessage> {
22+
public SupplementalDataMessageHandler(TlsContext tlsContext) {
23+
super(tlsContext);
24+
}
25+
26+
@Override
27+
public SupplementalDataMessageParser getParser(byte[] message, int pointer) {
28+
return new SupplementalDataMessageParser(pointer, message, tlsContext.getChooser().getLastRecordVersion());
29+
}
30+
31+
@Override
32+
public SupplementalDataMessagePreparator getPreparator(SupplementalDataMessage message) {
33+
return new SupplementalDataMessagePreparator(this.tlsContext.getChooser(), message);
34+
}
35+
36+
@Override
37+
public SupplementalDataMessageSerializer getSerializer(SupplementalDataMessage message) {
38+
return new SupplementalDataMessageSerializer(message, this.tlsContext.getSelectedProtocolVersion());
39+
}
40+
41+
@Override
42+
public void adjustTLSContext(SupplementalDataMessage message) {
43+
44+
}
45+
}

‎TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/protocol/message/SupplementalDataMessage.java‎

Lines changed: 93 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,93 @@
1+
/**
2+
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
3+
*
4+
* Copyright 2014-2017 Ruhr University Bochum / Hackmanit GmbH
5+
*
6+
* Licensed under Apache License 2.0
7+
* http://www.apache.org/licenses/LICENSE-2.0
8+
*/
9+
package de.rub.nds.tlsattacker.core.protocol.message;
10+
11+
import de.rub.nds.modifiablevariable.HoldsModifiableVariable;
12+
import de.rub.nds.modifiablevariable.ModifiableVariableFactory;
13+
import de.rub.nds.modifiablevariable.ModifiableVariableProperty;
14+
import de.rub.nds.modifiablevariable.bytearray.ModifiableByteArray;
15+
import de.rub.nds.modifiablevariable.integer.ModifiableInteger;
16+
import de.rub.nds.modifiablevariable.util.ArrayConverter;
17+
import de.rub.nds.tlsattacker.core.constants.HandshakeMessageType;
18+
import de.rub.nds.tlsattacker.core.protocol.message.extension.SupplementalData.SupplementalDataEntry;
19+
import de.rub.nds.tlsattacker.core.protocol.handler.SupplementalDataMessageHandler;
20+
import de.rub.nds.tlsattacker.core.state.TlsContext;
21+
import javax.xml.bind.annotation.XmlRootElement;
22+
import java.util.LinkedList;
23+
import java.util.List;
24+
25+
/**
26+
* @author Christoph Penkert <christoph.penkert@rub.de>
27+
*/
28+
29+
@XmlRootElement
30+
public class SupplementalDataMessage extends HandshakeMessage {
31+
32+
@HoldsModifiableVariable
33+
private List<SupplementalDataEntry> entries;
34+
35+
@ModifiableVariableProperty(type = ModifiableVariableProperty.Type.LENGTH)
36+
private ModifiableInteger supplementalDataLength;
37+
38+
@ModifiableVariableProperty
39+
private ModifiableByteArray supplementalDataBytes;
40+
41+
public SupplementalDataMessage(LinkedList<SupplementalDataEntry> entries) {
42+
super(HandshakeMessageType.SUPPLEMENTAL_DATA);
43+
this.entries = new LinkedList<>(entries);
44+
}
45+
46+
public List<SupplementalDataEntry> getEntries() {
47+
return entries;
48+
}
49+
50+
public void setEntries(List<SupplementalDataEntry> entries) {
51+
this.entries = entries;
52+
}
53+
54+
public ModifiableInteger getSupplementalDataLength() {
55+
return supplementalDataLength;
56+
}
57+
58+
public void setSupplementalDataLength(ModifiableInteger supplementalDataLength) {
59+
this.supplementalDataLength = supplementalDataLength;
60+
}
61+
62+
public ModifiableByteArray getSupplementalDataBytes() {
63+
return supplementalDataBytes;
64+
}
65+
66+
public void setSupplementalDataBytes(ModifiableByteArray supplementalDataBytes) {
67+
this.supplementalDataBytes = supplementalDataBytes;
68+
}
69+
70+
public void setSupplementalDataBytes(byte[] supplementalDataBytes) {
71+
this.supplementalDataBytes = ModifiableVariableFactory.safelySetValue(this.supplementalDataBytes,
72+
supplementalDataBytes);
73+
}
74+
75+
@Override
76+
public SupplementalDataMessageHandler getHandler(TlsContext context) {
77+
return new SupplementalDataMessageHandler(context);
78+
}
79+
80+
@Override
81+
public String toString() {
82+
StringBuilder sb = new StringBuilder(super.toString());
83+
sb.append("\n Supplemental Data Length: ").append(supplementalDataLength.getValue());
84+
for (SupplementalDataEntry entry : entries) {
85+
sb.append("\n Supplemental Data Type: ").append(entry.getSupplementalDataType().getValue());
86+
sb.append("\n Supplemental Data Length: ").append(entry.getSupplementalDataLength().getValue());
87+
sb.append("\n Supplemental Data : ").append(
88+
ArrayConverter.bytesToHexString(entry.getSupplementalData().getValue()));
89+
}
90+
return sb.toString();
91+
}
92+
93+
}

‎TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/protocol/message/extension/SupplementalData/SupplementalDataEntry.java‎

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,78 @@
1+
/**
2+
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
3+
*
4+
* Copyright 2014-2017 Ruhr University Bochum / Hackmanit GmbH
5+
*
6+
* Licensed under Apache License 2.0
7+
* http://www.apache.org/licenses/LICENSE-2.0
8+
*/
9+
package de.rub.nds.tlsattacker.core.protocol.message.extension.SupplementalData;
10+
11+
import de.rub.nds.modifiablevariable.ModifiableVariableFactory;
12+
import de.rub.nds.modifiablevariable.ModifiableVariableProperty;
13+
import de.rub.nds.modifiablevariable.bytearray.ModifiableByteArray;
14+
import de.rub.nds.modifiablevariable.integer.ModifiableInteger;
15+
16+
/**
17+
* @author Christoph Penkert <christoph.penkert@rub.de>
18+
*/
19+
20+
public class SupplementalDataEntry {
21+
22+
@ModifiableVariableProperty
23+
private ModifiableByteArray supplementalData;
24+
25+
@ModifiableVariableProperty
26+
private ModifiableInteger supplementalDataType;
27+
28+
@ModifiableVariableProperty(type = ModifiableVariableProperty.Type.LENGTH)
29+
private ModifiableInteger supplementalDataLength;
30+
31+
public SupplementalDataEntry(int supplementalDataType, int supplementalDataLength, byte[] supplementalData) {
32+
this.supplementalDataType = ModifiableVariableFactory.safelySetValue(this.supplementalDataType,
33+
supplementalDataType);
34+
this.supplementalDataLength = ModifiableVariableFactory.safelySetValue(this.supplementalDataLength,
35+
supplementalDataLength);
36+
this.supplementalData = ModifiableVariableFactory.safelySetValue(this.supplementalData, supplementalData);
37+
38+
}
39+
40+
public ModifiableByteArray getSupplementalData() {
41+
return this.supplementalData;
42+
}
43+
44+
public void setSupplementalData(ModifiableByteArray supplementalData) {
45+
this.supplementalData = supplementalData;
46+
}
47+
48+
public void setSupplementalData(byte[] supplementalData) {
49+
this.supplementalData = ModifiableVariableFactory.safelySetValue(this.supplementalData, supplementalData);
50+
}
51+
52+
public ModifiableInteger getSupplementalDataType() {
53+
return supplementalDataType;
54+
}
55+
56+
public void setSupplementalDataType(ModifiableInteger supplementalDataType) {
57+
this.supplementalDataType = supplementalDataType;
58+
}
59+
60+
public void setSupplementalDataType(int supplementalDataType) {
61+
this.supplementalDataType = ModifiableVariableFactory.safelySetValue(this.supplementalDataType,
62+
supplementalDataType);
63+
}
64+
65+
public ModifiableInteger getSupplementalDataLength() {
66+
return supplementalDataLength;
67+
}
68+
69+
public void setSupplementalDataLength(ModifiableInteger supplementalDataLength) {
70+
this.supplementalDataLength = supplementalDataLength;
71+
}
72+
73+
public void setSupplementalDataLength(int supplementalDataLength) {
74+
this.supplementalDataLength = ModifiableVariableFactory.safelySetValue(this.supplementalDataLength,
75+
supplementalDataLength);
76+
}
77+
78+
}

‎TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/protocol/message/extension/SupplementalData/SupplementalDataType.java‎

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,57 @@
1+
/**
2+
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
3+
*
4+
* Copyright 2014-2017 Ruhr University Bochum / Hackmanit GmbH
5+
*
6+
* Licensed under Apache License 2.0
7+
* http://www.apache.org/licenses/LICENSE-2.0
8+
*/
9+
package de.rub.nds.tlsattacker.core.protocol.message.extension.SupplementalData;
10+
11+
import java.util.HashMap;
12+
import java.util.Map;
13+
14+
/**
15+
* @author Christoph Penkert <christoph.penkert@rub.de>
16+
*/
17+
18+
public enum SupplementalDataType {
19+
20+
USER_MAPPING_DATA(new byte[] { (byte) 0, (byte) 0 }),
21+
AUTHZ_DATA(new byte[] { (byte) 0x40, (byte) 0x02 }),
22+
UNKNOWN(new byte[0]);
23+
24+
private byte[] value;
25+
26+
SupplementalDataType(byte[] value) {
27+
this.value = value;
28+
}
29+
30+
private static final Map<Integer, SupplementalDataType> MAP;
31+
static {
32+
MAP = new HashMap<>();
33+
for (SupplementalDataType s : SupplementalDataType.values()) {
34+
MAP.put(valueToInt(s.value), s);
35+
}
36+
}
37+
38+
private static int valueToInt(byte[] value) {
39+
if (value.length == 2) {
40+
return (value[0] & 0xff) << 8 | (value[1] & 0xff);
41+
} else {
42+
return -1;
43+
}
44+
}
45+
46+
public static SupplementalDataType getSupplementalDataType(byte[] value) {
47+
SupplementalDataType type = MAP.get(valueToInt(value));
48+
if (type == null) {
49+
return UNKNOWN;
50+
}
51+
return type;
52+
}
53+
54+
public byte[] getValue() {
55+
return value;
56+
}
57+
}

‎TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/protocol/parser/SupplementalDataMessageParser.java‎

Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,46 @@
1+
/**
2+
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
3+
*
4+
* Copyright 2014-2017 Ruhr University Bochum / Hackmanit GmbH
5+
*
6+
* Licensed under Apache License 2.0
7+
* http://www.apache.org/licenses/LICENSE-2.0
8+
*/
9+
package de.rub.nds.tlsattacker.core.protocol.parser;
10+
11+
import de.rub.nds.tlsattacker.core.constants.HandshakeMessageType;
12+
import de.rub.nds.tlsattacker.core.constants.ProtocolVersion;
13+
import de.rub.nds.tlsattacker.core.protocol.message.SupplementalDataMessage;
14+
15+
/**
16+
* @author Christoph Penkert <christoph.penkert@rub.de>
17+
*/
18+
19+
// todo Implement SupplementalDataMessageParser
20+
public class SupplementalDataMessageParser<T extends SupplementalDataMessage> extends HandshakeMessageParser<T> {
21+
/**
22+
* Constructor for the Parser class
23+
*
24+
* @param pointer
25+
* Position in the array where the HandshakeMessageParser is
26+
* supposed to start parsing
27+
* @param array
28+
* The byte[] which the HandshakeMessageParser is supposed to
29+
* parse
30+
* @param version
31+
*/
32+
public SupplementalDataMessageParser(int pointer, byte[] array, ProtocolVersion version) {
33+
super(pointer, array, HandshakeMessageType.SUPPLEMENTAL_DATA, version);
34+
}
35+
36+
@Override
37+
protected void parseHandshakeMessageContent(SupplementalDataMessage msg) {
38+
LOGGER.debug("Parsing SupplementalDataMessage");
39+
throw new UnsupportedOperationException("Not Implemented");
40+
}
41+
42+
@Override
43+
protected T createHandshakeMessage() {
44+
throw new UnsupportedOperationException("Not Implemented");
45+
}
46+
}

‎TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/protocol/preparator/SupplementalDataMessagePreparator.java‎

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
/**
2+
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
3+
*
4+
* Copyright 2014-2017 Ruhr University Bochum / Hackmanit GmbH
5+
*
6+
* Licensed under Apache License 2.0
7+
* http://www.apache.org/licenses/LICENSE-2.0
8+
*/
9+
package de.rub.nds.tlsattacker.core.protocol.preparator;
10+
11+
import de.rub.nds.tlsattacker.core.protocol.message.HandshakeMessage;
12+
import de.rub.nds.tlsattacker.core.protocol.message.SupplementalDataMessage;
13+
import de.rub.nds.tlsattacker.core.workflow.chooser.Chooser;
14+
15+
/**
16+
* @author Christoph Penkert <christoph.penkert@rub.de>
17+
*/
18+
19+
// todo implement SupplementalDataMessagePreparator
20+
public class SupplementalDataMessagePreparator<T extends SupplementalDataMessage> extends
21+
HandshakeMessagePreparator<HandshakeMessage> {
22+
23+
private final SupplementalDataMessage msg;
24+
25+
public SupplementalDataMessagePreparator(Chooser chooser, SupplementalDataMessage message) {
26+
super(chooser, message);
27+
this.msg = message;
28+
}
29+
30+
@Override
31+
protected void prepareHandshakeMessageContents() {
32+
LOGGER.debug("Preparing SupplementalDataMessage");
33+
throw new UnsupportedOperationException("Not Implemented");
34+
}
35+
36+
}

0 commit comments

Comments
 (0)