MAP;
private final byte[] byteValue;
public byte[] getByteValue() {
return this.byteValue;
}
static {
MAP = new HashMap<>();
for (EsniDnsKeyRecordVersion version : values()) {
byte[] versionBytes = version.getByteValue();
if (versionBytes != null) {
BigInteger hashMapKey = new BigInteger(versionBytes);
MAP.put(hashMapKey, version);
}
}
}
public static EsniDnsKeyRecordVersion getEnumByByte(byte[] versionBytes) {
if (versionBytes == null) {
return EsniDnsKeyRecordVersion.NULL;
} else {
BigInteger hashMapKey = new BigInteger(versionBytes);
return MAP.get(hashMapKey);
}
}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/EsniVersion.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
public enum EsniVersion {
DRAFT_0(EsniDnsKeyRecordVersion.NULL),
DRAFT_1(EsniDnsKeyRecordVersion.FF01),
DRAFT_2(EsniDnsKeyRecordVersion.FF01),
DRAFT_3(EsniDnsKeyRecordVersion.FF02),
DRAFT_4(EsniDnsKeyRecordVersion.FF03),
DRAFT_5(EsniDnsKeyRecordVersion.FF03);
EsniVersion(EsniDnsKeyRecordVersion dnsKeyRecordVersion) {
this.dnsKeyRecordVersion = dnsKeyRecordVersion;
}
EsniDnsKeyRecordVersion dnsKeyRecordVersion;
public EsniDnsKeyRecordVersion getDnsKeyRecordVersion() {
return this.dnsKeyRecordVersion;
}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/ExtensionByteLength.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
public class ExtensionByteLength {
/** extensions byte length */
public static final int EXTENSIONS_LENGTH = 2;
/** extension type */
public static final int TYPE = 2;
/** EC point formats length field of the ec point format extension message */
public static final int EC_POINT_FORMATS = 1;
/** Supported Elliptic Curves length field of the elliptic curve extension message */
public static final int SUPPORTED_GROUPS = 2;
/** Heartbeat mode length in the heartbeat extension message */
public static final int HEARTBEAT_MODE = 1;
/** MaxFragment length field in the MaxFragmentExtension message */
public static final int MAX_FRAGMENT = 1;
/** ServerNameType length in the ServerNameIndicationExtension */
public static final int SERVER_NAME_TYPE = 1;
/** ServerName length in the ServerNameIndicationExtension */
public static final int SERVER_NAME = 2;
/** ServerNameListLength in the ServerNameIndicationExtension */
public static final int SERVER_NAME_LIST = 2;
/** ExtendedRandomLength in the ExtendedRandomExtension */
public static final int EXTENDED_RANDOM_LENGTH = 2;
/** KeyShareGroup length in the KeyShareExtension */
public static final int KEY_SHARE_GROUP = 2;
/** KeyShare length in the KeyShareExtension */
public static final int KEY_SHARE_LENGTH = 2;
/** KeyShareListLength in the KeyShareExtension */
public static final int KEY_SHARE_LIST_LENGTH = 2;
/** KeyExchangeModes length in the PSKKeyExchangeModesExtension */
public static final int PSK_KEY_EXCHANGE_MODES_LENGTH = 1;
/** PSKIdentity length in the PreSharedKeyExtension */
public static final int PSK_IDENTITY_LENGTH = 2;
/** PSKList length in the PreSharedKeyExtension */
public static final int PSK_IDENTITY_LIST_LENGTH = 2;
/** PSKBinder length in the PreSharedKeyExtension */
public static final int PSK_BINDER_LENGTH = 1;
/** PSKBinderList length in the PreSharedKeyExtension */
public static final int PSK_BINDER_LIST_LENGTH = 2;
/** SelectedIdentity length in the PreSharedKeyExtension */
public static final int PSK_SELECTED_IDENTITY_LENGTH = 2;
/** TicketAge length in the PreSharedKeyExtension */
public static final int TICKET_AGE_LENGTH = 4;
/** Based on the suggested length of the encrypted session ticket */
public static final int ENCRYPTED_SESSION_TICKET_STATE_LENGTH = 2;
/** MaxEarlyDataSize length in the EarlyDataExtension */
public static final int MAX_EARLY_DATA_SIZE_LENGTH = 4;
/**
* Length of the Signature and HashAlgorithm Length field of the SignatureAndHashAlgorithms
* Extension
*/
public static final int SIGNATURE_AND_HASH_ALGORITHMS_LENGTH = 2;
/** Supported Protocol Versions length field of the SupportedVersionsExtension message */
public static final int SUPPORTED_PROTOCOL_VERSIONS_LENGTH = 1;
/** Length of the Padding Length field of the Padding Extension */
public static final int PADDING_LENGTH = 2;
public static final int SIGNATURE_AND_HASH_ALGORITHMS = 2;
/** Length of the version field as used by the token binding extension. */
public static final int TOKENBINDING_VERSION = 2;
/** Length of the token binding extension key parameter length field */
public static final int TOKENBINDING_KEYPARAMETER_LENGTH = 1;
/** Length of the certificate status request responder id list length field */
public static final int CERTIFICATE_STATUS_REQUEST_RESPONDER_ID_LIST_LENGTH = 2;
/** Length of the certificate status request "request extension" length field */
public static final int CERTIFICATE_STATUS_REQUEST_REQUEST_EXTENSION_LENGTH = 2;
/** Length of the certificate status request status type field */
public static final int CERTIFICATE_STATUS_REQUEST_STATUS_TYPE = 1;
/** Length of the application layer protocol extension length field */
public static final int ALPN_EXTENSION_LENGTH = 2;
public static final int ALPN_ENTRY_LENGTH = 1;
/** Length of the Quic Transport Parameters Extension Length Field */
public static final int QUIC_EXTENSION_LENTGH = 2;
public static final int QUIC_PARAMETER_ENTRY_LENGTH = 1;
/** Length of the SRP extension identifier length field */
public static final int SRP_IDENTIFIER_LENGTH = 1;
/** Length of the SRTP extension master key identifier length field */
public static final int SRTP_MASTER_KEY_IDENTIFIER_LENGTH = 1;
/** Length of the SRTP extension protection profiles length field length */
public static final int SRTP_PROTECTION_PROFILES_LENGTH = 2;
/** Length of the user mapping extension user mapping hint field */
public static final int USER_MAPPING_MAPPINGTYPE = 1;
/** Length of the certificate_type certificate_types length field */
public static final int CERTIFICATE_TYPE_TYPE_LENGTH = 1;
/** Length of the client authz extension length field */
public static final int CLIENT_AUTHZ_FORMAT_LIST_LENGTH = 1;
/** Length of the server authz extension length field */
public static final int SERVER_AUTHZ_FORMAT_LIST_LENGTH = 1;
/** Length of the cached information extension length field */
public static final int CACHED_INFO_LENGTH = 2;
/** Length of the CachedInfoType */
public static final int CACHED_INFO_TYPE = 1;
/** Length of the Cached Info extension hash value length */
public static final int CACHED_INFO_HASH_LENGTH = 1;
/** Length of the trusted ca indication authority type length */
public static final int TRUSTED_AUTHORITY_TYPE = 1;
/** Length of the trusted ca indication sha1 hash length */
public static final int TRUSTED_AUTHORITY_HASH = 20;
/** Length of the trusted ca indication distinguished name length field */
public static final int TRUSTED_AUTHORITY_DISTINGUISHED_NAME_LENGTH = 2;
/** Length of the trusted ca indication trusted authority list */
public static final int TRUSTED_AUTHORITY_LIST_LENGTH = 2;
/** Length of the status request v2 responder id length */
public static final int CERTIFICATE_STATUS_REQUEST_V2_RESPONDER_ID = 2;
/** Length of the status request v2 request extension length */
public static final int CERTIFICATE_STATUS_REQUEST_V2_REQUEST_EXTENSION = 2;
/** Length of the status request v2 request length */
public static final int CERTIFICATE_STATUS_REQUEST_V2_REQUEST_LENGTH = 2;
/** Length of the status request v2 list length */
public static final int CERTIFICATE_STATUS_REQUEST_V2_LIST = 2;
public static final int RENEGOTIATION_INFO = 1;
/** PWD_NAME length field of the pwd_clear and pwd_protect extension messages */
public static final int PWD_NAME = 1;
public static final int PWD_SCALAR = 1;
/**
* PASSWORD_SALT length field of the password_salt extension message
*
* Note that the field has a different length than the salt field in the ServerKeyExchange
* for some reason
*/
public static final int PASSWORD_SALT = 2;
/** Fields in the DNS Record of the EncryptedServerNameIndicationExtension */
public static final int ESNI_RECORD_VERSION = 2;
public static final int ESNI_RECORD_CHECKSUM = 4;
public static final int ESNI_RECORD_PUBLIC_NAME = 2;
public static final int ESNI_RECORD_PADDED_LENGTH = 2;
public static final int ESNI_RECORD_NOT_BEFORE = 8;
public static final int ESNI_RECORD_NOT_AFTER = 8;
public static final int ESNI_RECORD_EXTENSIONS = 2;
/** Length of encryptedSni in the EncryptedServerNameIndicationExtension */
public static final int ENCRYPTED_SNI_LENGTH = 2;
/** Nonce in EncryptedServerNameIndicationExtension */
public static final int NONCE = 16;
/** PaddedLength in the ClientEsniInner of the EncryptedServerNameIndicationExtension */
public static final int PADDED_LENGTH = 2;
/** recordDigestLength in EncryptedServerNameIndicationExtension */
public static final int RECORD_DIGEST_LENGTH = 2;
/** Fields in the ECH Config of the EncryptedClientHelloExtension */
public static final int ECH_CONFIG_LIST_LENGTH = 2;
public static final int ECH_CONFIG_LENGTH = 2;
public static final int ECH_CONFIG_PUBLIC_NAME = 1;
public static final int ECH_CONFIG_PUBLIC_NAME_LONG = 2;
public static final int ECH_CONFIG_PUBLIC_KEY = 2;
public static final int ECH_CONFIG_MAX_NAME_LENGTH = 1;
public static final int ECH_CONFIG_ID = 1;
public static final int ECH_CONFIG_KEM_ID = 2;
public static final int ECH_CONFIG_CIPHERSUITES = 2;
public static final int ECH_CONFIG_KDF_ID = 2;
public static final int ECH_CONFIG_AEAD_ID = 2;
public static final int ECH_CLIENT_HELLO_TYPE = 1;
public static final int ECH_ENC_LENGTH = 2;
public static final int ECH_PAYLOAD_LENGTH = 2;
public static final int ECH_ACCEPT_CONFIRMATION_LENGTH = 8;
/** cookieLength in the CookieExtension */
public static final int COOKIE_LENGTH = 2;
/** RecordSizeLimit length in the RecordSizeLimitExtension */
public static final int RECORD_SIZE_LIMIT_LENGTH = 2;
/** connectionIdLength in ConnectionIdExtension */
public static final int CONNECTION_ID_LENGTH = 1;
/** SignatureAlgorithmsCert Extension Fields */
public static final int SIGNATURE_ALGORITHMS_CERT_LENGTH = 2;
public static final int SIGNATURE_ALGORITHMS_CERT = 2;
private ExtensionByteLength() {}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/ExtensionType.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
public enum ExtensionType {
SERVER_NAME_INDICATION(new byte[] {(byte) 0, (byte) 0}),
MAX_FRAGMENT_LENGTH(new byte[] {(byte) 0, (byte) 1}),
CLIENT_CERTIFICATE_URL(new byte[] {(byte) 0, (byte) 2}),
TRUSTED_CA_KEYS(new byte[] {(byte) 0, (byte) 3}),
TRUNCATED_HMAC(new byte[] {(byte) 0, (byte) 4}),
STATUS_REQUEST(new byte[] {(byte) 0, (byte) 5}),
USER_MAPPING(new byte[] {(byte) 0, (byte) 6}),
CLIENT_AUTHZ(new byte[] {(byte) 0, (byte) 7}),
SERVER_AUTHZ(new byte[] {(byte) 0, (byte) 8}),
CERT_TYPE(new byte[] {(byte) 0, (byte) 9}),
ELLIPTIC_CURVES(new byte[] {(byte) 0, (byte) 10}),
EC_POINT_FORMATS(new byte[] {(byte) 0, (byte) 11}),
SRP(new byte[] {(byte) 0, (byte) 12}),
SIGNATURE_AND_HASH_ALGORITHMS(new byte[] {(byte) 0, (byte) 13}),
USE_SRTP(new byte[] {(byte) 0, (byte) 14}),
HEARTBEAT(new byte[] {(byte) 0, (byte) 15}),
ALPN(new byte[] {(byte) 0, (byte) 16}),
STATUS_REQUEST_V2(new byte[] {(byte) 0, (byte) 17}),
SIGNED_CERTIFICATE_TIMESTAMP(new byte[] {(byte) 0, (byte) 18}),
CLIENT_CERTIFICATE_TYPE(new byte[] {(byte) 0, (byte) 19}),
SERVER_CERTIFICATE_TYPE(new byte[] {(byte) 0, (byte) 20}),
PADDING(new byte[] {(byte) 0, (byte) 21}),
ENCRYPT_THEN_MAC(new byte[] {(byte) 0, (byte) 22}),
EXTENDED_MASTER_SECRET(new byte[] {(byte) 0, (byte) 23}),
TOKEN_BINDING(new byte[] {(byte) 0, (byte) 24}),
CACHED_INFO(new byte[] {(byte) 0, (byte) 25}),
RECORD_SIZE_LIMIT(new byte[] {(byte) 0, (byte) 28}),
PWD_PROTECT(new byte[] {(byte) 0, (byte) 29}),
PWD_CLEAR(new byte[] {(byte) 0, (byte) 30}),
PASSWORD_SALT(new byte[] {(byte) 0, (byte) 31}),
SESSION_TICKET(new byte[] {(byte) 0, (byte) 35}),
EXTENDED_RANDOM(new byte[] {(byte) 0, (byte) 40}), // Shares same IANA ID
// as old keyshare
// extension.
PRE_SHARED_KEY(new byte[] {(byte) 0, (byte) 41}),
EARLY_DATA(new byte[] {(byte) 0, (byte) 42}),
SUPPORTED_VERSIONS(new byte[] {(byte) 0, (byte) 43}),
COOKIE(new byte[] {0x00, (byte) 44}),
PSK_KEY_EXCHANGE_MODES(new byte[] {(byte) 0, (byte) 45}),
CERTIFICATE_AUTHORITIES(new byte[] {(byte) 0, (byte) 47}),
OID_FILTERS(new byte[] {(byte) 0, (byte) 48}),
POST_HANDSHAKE_AUTH(new byte[] {(byte) 0, (byte) 49}),
SIGNATURE_ALGORITHMS_CERT(new byte[] {(byte) 0, (byte) 50}),
KEY_SHARE(new byte[] {(byte) 0, (byte) 51}),
RENEGOTIATION_INFO(new byte[] {(byte) 0xFF, (byte) 0x01}),
ENCRYPTED_SERVER_NAME_INDICATION(new byte[] {(byte) 0xFF, (byte) 0xCE}),
QUIC_TRANSPORT_PARAMETERS(new byte[] {(byte) 0x00, (byte) 0x39}),
CONNECTION_ID(new byte[] {(byte) 0, (byte) 54}),
ENCRYPTED_CLIENT_HELLO_DRAFT_07(new byte[] {(byte) 0xFF, (byte) 0x02}),
ENCRYPTED_CLIENT_HELLO_DRAFT_08(new byte[] {(byte) 0xFF, (byte) 0x08}),
ENCRYPTED_CLIENT_HELLO_DRAFT_09(new byte[] {(byte) 0xFF, (byte) 0x09}),
ENCRYPTED_CLIENT_HELLO_DRAFT_10(new byte[] {(byte) 0xFF, (byte) 0x0a}),
ENCRYPTED_CLIENT_HELLO_DRAFT_11(new byte[] {(byte) 0xFF, (byte) 0x0b}),
ENCRYPTED_CLIENT_HELLO_DRAFT_12(new byte[] {(byte) 0xFF, (byte) 0x0c}),
ENCRYPTED_CLIENT_HELLO(new byte[] {(byte) 0xFE, (byte) 0x0D}),
ENCRYPTED_CLIENT_HELLO_ENCRYPTED_EXTENSIONS(new byte[] {(byte) 0xFE, (byte) 0x0D}),
// Debug extension
DEBUG(new byte[] {(byte) 0xFB, (byte) 0xFB}),
// GREASE constants
GREASE_00(new byte[] {(byte) 0x0A, (byte) 0x0A}),
GREASE_01(new byte[] {(byte) 0x1A, (byte) 0x1A}),
GREASE_02(new byte[] {(byte) 0x2A, (byte) 0x2A}),
GREASE_03(new byte[] {(byte) 0x3A, (byte) 0x3A}),
GREASE_04(new byte[] {(byte) 0x4A, (byte) 0x4A}),
GREASE_05(new byte[] {(byte) 0x5A, (byte) 0x5A}),
GREASE_06(new byte[] {(byte) 0x6A, (byte) 0x6A}),
GREASE_07(new byte[] {(byte) 0x7A, (byte) 0x7A}),
GREASE_08(new byte[] {(byte) 0x8A, (byte) 0x8A}),
GREASE_09(new byte[] {(byte) 0x9A, (byte) 0x9A}),
GREASE_10(new byte[] {(byte) 0xAA, (byte) 0xAA}),
GREASE_11(new byte[] {(byte) 0xBA, (byte) 0xBA}),
GREASE_12(new byte[] {(byte) 0xCA, (byte) 0xCA}),
GREASE_13(new byte[] {(byte) 0xDA, (byte) 0xDA}),
GREASE_14(new byte[] {(byte) 0xEA, (byte) 0xEA}),
GREASE_15(new byte[] {(byte) 0xFA, (byte) 0xFA}),
UNKNOWN(new byte[0]);
private byte[] value;
private static final Map MAP;
ExtensionType(byte[] value) {
this.value = value;
}
static {
MAP = new HashMap<>();
for (ExtensionType c : values()) {
MAP.put(valueToInt(c.value), c);
}
}
private static int valueToInt(byte[] value) {
if (value.length == 2) {
return (value[0] & 0xff) << Bits.IN_A_BYTE | (value[1] & 0xff);
} else {
return -1;
}
}
public static ExtensionType getExtensionType(byte[] value) {
ExtensionType type = MAP.get(valueToInt(value));
if (type == null) {
return UNKNOWN;
}
return type;
}
public byte[] getValue() {
return value;
}
public byte getMajor() {
return value[0];
}
public byte getMinor() {
return value[1];
}
public boolean isGrease() {
return this.name().contains("GREASE");
}
public static List getSendable() {
List list = new LinkedList<>();
list.add(ALPN);
list.add(CACHED_INFO);
list.add(CERT_TYPE);
list.add(CLIENT_AUTHZ);
list.add(CLIENT_CERTIFICATE_TYPE);
list.add(CLIENT_CERTIFICATE_URL);
list.add(EARLY_DATA);
list.add(EC_POINT_FORMATS);
list.add(ELLIPTIC_CURVES);
list.add(ENCRYPT_THEN_MAC);
list.add(EXTENDED_MASTER_SECRET);
list.add(HEARTBEAT);
list.add(KEY_SHARE);
list.add(EXTENDED_RANDOM);
list.add(MAX_FRAGMENT_LENGTH);
list.add(PADDING);
list.add(PRE_SHARED_KEY);
list.add(PSK_KEY_EXCHANGE_MODES);
list.add(RENEGOTIATION_INFO);
list.add(SERVER_AUTHZ);
list.add(SERVER_CERTIFICATE_TYPE);
list.add(SERVER_NAME_INDICATION);
list.add(SESSION_TICKET);
list.add(SIGNATURE_AND_HASH_ALGORITHMS);
list.add(SIGNATURE_ALGORITHMS_CERT);
list.add(SIGNED_CERTIFICATE_TIMESTAMP);
list.add(SRP);
list.add(STATUS_REQUEST);
list.add(STATUS_REQUEST_V2);
list.add(SUPPORTED_VERSIONS);
list.add(TOKEN_BINDING);
list.add(TRUNCATED_HMAC);
list.add(TRUSTED_CA_KEYS);
list.add(USE_SRTP);
list.add(COOKIE);
list.add(RECORD_SIZE_LIMIT);
list.add(CONNECTION_ID);
list.add(QUIC_TRANSPORT_PARAMETERS);
list.add(ENCRYPTED_CLIENT_HELLO);
return list;
}
public static List getReceivable() {
List list = new LinkedList<>();
list.add(ALPN);
list.add(CACHED_INFO);
list.add(CERT_TYPE);
list.add(CLIENT_AUTHZ);
list.add(CLIENT_CERTIFICATE_TYPE);
list.add(CLIENT_CERTIFICATE_URL);
list.add(EARLY_DATA);
list.add(EC_POINT_FORMATS);
list.add(ELLIPTIC_CURVES);
list.add(ENCRYPT_THEN_MAC);
list.add(EXTENDED_MASTER_SECRET);
list.add(HEARTBEAT);
list.add(KEY_SHARE);
list.add(EXTENDED_RANDOM);
list.add(MAX_FRAGMENT_LENGTH);
list.add(PADDING);
list.add(PRE_SHARED_KEY);
list.add(PSK_KEY_EXCHANGE_MODES);
list.add(RENEGOTIATION_INFO);
list.add(SERVER_AUTHZ);
list.add(SERVER_CERTIFICATE_TYPE);
list.add(SERVER_NAME_INDICATION);
list.add(SESSION_TICKET);
list.add(SIGNATURE_AND_HASH_ALGORITHMS);
list.add(SIGNATURE_ALGORITHMS_CERT);
list.add(SIGNED_CERTIFICATE_TIMESTAMP);
list.add(SRP);
list.add(STATUS_REQUEST);
list.add(STATUS_REQUEST_V2);
list.add(SUPPORTED_VERSIONS);
list.add(TOKEN_BINDING);
list.add(TRUNCATED_HMAC);
list.add(TRUSTED_CA_KEYS);
list.add(USE_SRTP);
list.add(COOKIE);
list.add(RECORD_SIZE_LIMIT);
list.add(CONNECTION_ID);
list.add(QUIC_TRANSPORT_PARAMETERS);
list.add(ENCRYPTED_CLIENT_HELLO);
list.add(ENCRYPTED_CLIENT_HELLO_ENCRYPTED_EXTENSIONS);
return list;
}
public static List getImplemented() {
List list = new LinkedList<>();
list.add(EARLY_DATA);
list.add(EC_POINT_FORMATS);
list.add(ELLIPTIC_CURVES);
list.add(EXTENDED_MASTER_SECRET);
list.add(KEY_SHARE);
list.add(MAX_FRAGMENT_LENGTH);
list.add(PADDING);
list.add(PRE_SHARED_KEY);
list.add(PSK_KEY_EXCHANGE_MODES);
list.add(SERVER_NAME_INDICATION);
list.add(SIGNATURE_AND_HASH_ALGORITHMS);
list.add(SIGNATURE_ALGORITHMS_CERT);
list.add(SUPPORTED_VERSIONS);
list.add(TOKEN_BINDING);
list.add(RENEGOTIATION_INFO);
list.add(HEARTBEAT);
list.add(EXTENDED_RANDOM);
list.add(COOKIE);
list.add(RECORD_SIZE_LIMIT);
list.add(CONNECTION_ID);
list.add(ENCRYPTED_CLIENT_HELLO);
list.add(ENCRYPTED_CLIENT_HELLO_ENCRYPTED_EXTENSIONS);
return list;
}
public static boolean allowedInEncryptedExtensions(ExtensionType extType) {
switch (extType) {
case SERVER_NAME_INDICATION:
case MAX_FRAGMENT_LENGTH:
case ELLIPTIC_CURVES:
case USE_SRTP:
case HEARTBEAT:
case ALPN:
case CLIENT_CERTIFICATE_TYPE:
case SERVER_CERTIFICATE_TYPE:
case EARLY_DATA:
case QUIC_TRANSPORT_PARAMETERS:
case ENCRYPTED_CLIENT_HELLO_ENCRYPTED_EXTENSIONS:
case RECORD_SIZE_LIMIT:
return true;
default:
return false;
}
}
public static List getNonTls13Extensions() {
List list = new LinkedList<>();
list.add(EXTENDED_MASTER_SECRET);
list.add(EXTENDED_RANDOM);
list.add(ENCRYPT_THEN_MAC);
list.add(SRP);
list.add(TRUNCATED_HMAC);
list.add(RENEGOTIATION_INFO);
return list;
}
public static List getTls13OnlyExtensions() {
List list = new LinkedList<>();
list.add(EARLY_DATA);
list.add(KEY_SHARE);
return list;
}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/FiniteFieldGroups.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
public enum FiniteFieldGroups {
FFDHE2048(new byte[] {01, 00}),
FFDHE3072(new byte[] {01, 01}),
FFDHE4096(new byte[] {01, 02}),
FFDHE6144(new byte[] {01, 03}),
FFDHE8192(new byte[] {01, 04});
private final byte[] value;
FiniteFieldGroups(byte[] value) {
this.value = value;
}
public byte[] getValue() {
return value;
}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/GOSTCurve.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
import de.rub.nds.protocol.constants.GroupParameters;
import de.rub.nds.protocol.crypto.ec.Point;
import org.bouncycastle.asn1.ASN1ObjectIdentifier;
import org.bouncycastle.asn1.cryptopro.CryptoProObjectIdentifiers;
import org.bouncycastle.asn1.rosstandart.RosstandartObjectIdentifiers;
import org.bouncycastle.jce.spec.ECNamedCurveSpec;
public enum GOSTCurve {
GostR3410_2001_CryptoPro_A(CryptoProObjectIdentifiers.gostR3410_2001_CryptoPro_A),
GostR3410_2001_CryptoPro_B(CryptoProObjectIdentifiers.gostR3410_2001_CryptoPro_B),
GostR3410_2001_CryptoPro_C(CryptoProObjectIdentifiers.gostR3410_2001_CryptoPro_C),
GostR3410_2001_CryptoPro_XchA(CryptoProObjectIdentifiers.gostR3410_2001_CryptoPro_XchA),
GostR3410_2001_CryptoPro_XchB(CryptoProObjectIdentifiers.gostR3410_2001_CryptoPro_XchB),
Tc26_Gost_3410_12_256_paramSetA(
RosstandartObjectIdentifiers.id_tc26_gost_3410_12_256_paramSetA),
Tc26_Gost_3410_12_512_paramSetA(
RosstandartObjectIdentifiers.id_tc26_gost_3410_12_512_paramSetA),
Tc26_Gost_3410_12_512_paramSetB(
RosstandartObjectIdentifiers.id_tc26_gost_3410_12_512_paramSetB),
Tc26_Gost_3410_12_512_paramSetC(
RosstandartObjectIdentifiers.id_tc26_gost_3410_12_512_paramSetC);
private final ASN1ObjectIdentifier identifier;
private GroupParameters groupParameters;
GOSTCurve(ASN1ObjectIdentifier identifier) {
this.identifier = identifier;
}
public ASN1ObjectIdentifier getIdentifier() {
return identifier;
}
public GroupParameters getGroupParameters() {
return groupParameters;
}
public String getJavaName() {
return name().replace('_', '-');
}
public boolean is512bit2012() {
return name().contains("3410_12_512");
}
public static GOSTCurve fromNamedSpec(ECNamedCurveSpec spec) {
return fromString(spec.getName());
}
public static GOSTCurve fromString(String name) {
return GOSTCurve.valueOf(name.replace('-', '_'));
}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/HKDFAlgorithm.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
import de.rub.nds.protocol.constants.MacAlgorithm;
public enum HKDFAlgorithm {
TLS_HKDF_SHA256(MacAlgorithm.HMAC_SHA256),
TLS_HKDF_SHA384(MacAlgorithm.HMAC_SHA384),
TLS_HKDF_SHA512(MacAlgorithm.HMAC_SHA512),
TLS_HKDF_SM3(MacAlgorithm.HMAC_SM3);
HKDFAlgorithm(MacAlgorithm macAlgorithm) {
this.macAlgorithm = macAlgorithm;
}
private final MacAlgorithm macAlgorithm;
public MacAlgorithm getMacAlgorithm() {
return macAlgorithm;
}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/HandshakeByteLength.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
public class HandshakeByteLength {
/** Type length */
public static final int TYPE_LENGTH = 1;
/** Length length */
public static final int HANDSHAKE_MESSAGE_LENGTH_FIELD_LENGTH = 3;
/** certificate length field */
public static final int CERTIFICATE_LENGTH = 3;
/** certificate request context length field */
public static final int CERTIFICATE_REQUEST_CONTEXT_LENGTH = 1;
/** version field length */
public static final int VERSION = 2;
/** extension length field length */
public static final int EXTENSION_LENGTH = 2;
/** certificates length field (certificate array can include several certificates) */
public static final int CERTIFICATES_LENGTH = 3;
/** cipher suite length field length */
public static final int CIPHER_SUITES_LENGTH = 2;
/** cipher suite byte length */
public static final int CIPHER_SUITE = 2;
/** compression length */
public static final int COMPRESSION = 1;
/** compression length field length */
public static final int COMPRESSION_LENGTH = 1;
/** message type length */
public static final int MESSAGE_TYPE = 1;
/** length of the length field included in this message type */
public static final int MESSAGE_LENGTH_FIELD = 3;
/** random length */
public static final int RANDOM = 32;
/** length of the session id length field indicating the session id length */
public static final int SESSION_ID_LENGTH = 1;
/** length of the dtls cookie length field indicating the dtls cookie length */
public static final int DTLS_COOKIE_LENGTH = 1;
/** unix time byte length */
public static final int UNIX_TIME = 4;
/** Premaster Secret */
public static final int PREMASTER_SECRET = 48;
/** Length of the length field for the encrypted Premaster Secret */
public static final int ENCRYPTED_PREMASTER_SECRET_LENGTH = 2;
/** Master Secret */
public static final int MASTER_SECRET = 48;
/** Verify data from the finished message */
public static final int VERIFY_DATA = 12;
/** Length of the signature length field */
public static final int SIGNATURE_LENGTH = 2;
/** DH modulus length */
public static final int DH_MODULUS_LENGTH = 2;
/** DH generator length */
public static final int DH_GENERATOR_LENGTH = 2;
/** DH public key length */
public static final int DH_PUBLICKEY_LENGTH = 2;
/** DHE param length */
public static final int DHE_PARAM_LENGTH = 2;
/** ECDH param length */
public static final int ECDH_PARAM_LENGTH = 1;
/** ECDHE param length */
public static final int ECDHE_PARAM_LENGTH = 1;
/** Certificate Types Count in CertRequest */
public static final int CERTIFICATES_TYPES_COUNT = 1;
/** Length of the signature hash algorithms length field */
public static final int SIGNATURE_HASH_ALGORITHMS_LENGTH = 2;
/** Length of the signature algorithm field */
public static final int SIGNATURE = 1;
/** Length of the hash algorithm field */
public static final int HASH = 1;
/** Length of the signature hash algorithms field in the certificateVerify message */
public static final int SIGNATURE_HASH_ALGORITHM = 2;
/** Length of the distinguished names length field */
public static final int DISTINGUISHED_NAMES_LENGTH = 2;
/** Length of an elliptic curve field */
public static final int ELLIPTIC_CURVE = 1;
/** Length of a named group constant */
public static final int NAMED_GROUP = 2;
/** Length of the cookie field in DTLS ClientHello and ClientHelloVerify messages. */
public static final int DTLS_HANDSHAKE_COOKIE_LENGTH = 1;
/** Length of the Message Sequence field */
public static final int DTLS_MESSAGE_SEQUENCE = 2;
/** Fragment Offset length */
public static final int DTLS_FRAGMENT_OFFSET = 3;
/** Fragment length */
public static final int DTLS_FRAGMENT_LENGTH = 3;
/** Length of PSK_Identity */
public static final int PSK_IDENTITY_LENGTH = 2;
public static final int PSK_LENGTH = 2;
public static final int PSK_ZERO = 0;
public static final int SRP_MODULUS_LENGTH = 2;
public static final int SRP_SALT_LENGTH = 1;
public static final int SRP_GENERATOR_LENGTH = 2;
public static final int SRP_PUBLICKEY_LENGTH = 2;
/** New Session Ticket */
public static final int NEWSESSIONTICKET_TICKET_LENGTH = 2;
public static final int NEWSESSIONTICKET_LIFETIMEHINT_LENGTH = 4;
public static final int ENCRYPTED_STATE_LENGTH = 2;
public static final int TICKET_AGE_ADD_LENGTH = 4;
public static final int TICKET_NONCE_LENGTH = 1;
/** length of the ClientAuthenticationType in the TLS byte arrays */
public static final int CLIENT_AUTHENTICATION_TYPE = 1;
/** Length of the Supplemental Data Field */
public static final int SUPPLEMENTAL_DATA_LENGTH = 3;
/** Length of the Supplemental Data Entry Type */
public static final int SUPPLEMENTAL_DATA_ENTRY_TYPE_LENGTH = 2;
/** Length of the Supplemental Data Entry */
public static final int SUPPLEMENTAL_DATA_ENTRY_LENGTH = 2;
/** Length of the salt in PWD */
public static final int PWD_SALT_LENGTH = 1;
/** Length of the element in PWD */
public static final int PWD_ELEMENT_LENGTH = 1;
/** Length of the scalar in PWD */
public static final int PWD_SCALAR_LENGTH = 1;
/** certificate status type length field */
public static final int CERTIFICATE_STATUS_TYPE_LENGTH = 1;
/** certificate status response length field */
public static final int CERTIFICATE_STATUS_RESPONSE_LENGTH = 3;
/** RSA modulus length */
public static final int RSA_MODULUS_LENGTH = 2;
/** RSA public key length */
public static final int RSA_PUBLICKEY_LENGTH = 2;
/** KeyUpdate Message Length */
public static final int KEY_UPDATE_LENGTH = 1;
/** RequestConnectionId number of CIDs length */
public static final int REQUEST_CONNECTION_ID_NUMBER_CIDS_LENGTH = 1;
/** NewConnectionId length of the number of CIDs */
public static final int NEW_CONNECTION_ID_CIDS_LENGTH = 2;
/** NewConnectionId usage length */
public static final int NEW_CONNECTION_ID_USAGE_LENGTH = 1;
/** ConnectionId length field length */
public static final int CONNECTION_ID_LENGTH = 1;
private HandshakeByteLength() {}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/HandshakeMessageType.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
import java.util.HashMap;
import java.util.Map;
/** Also called Handshake Type */
public enum HandshakeMessageType {
UNKNOWN((byte) 255),
HELLO_REQUEST((byte) 0),
CLIENT_HELLO((byte) 1),
SERVER_HELLO((byte) 2),
HELLO_VERIFY_REQUEST((byte) 3),
NEW_SESSION_TICKET((byte) 4),
END_OF_EARLY_DATA((byte) 5),
// HELLO_RETRY_REQUEST((byte) 6), ONLY IN TLS 1.3 DRAFT
ENCRYPTED_EXTENSIONS((byte) 8),
REQUEST_CONNECTION_ID((byte) 9),
NEW_CONNECTION_ID((byte) 10),
CERTIFICATE((byte) 11),
SERVER_KEY_EXCHANGE((byte) 12),
CERTIFICATE_REQUEST((byte) 13),
SERVER_HELLO_DONE((byte) 14),
CERTIFICATE_VERIFY((byte) 15),
CLIENT_KEY_EXCHANGE((byte) 16),
FINISHED((byte) 20),
KEY_UPDATE((byte) 24),
CERTIFICATE_STATUS((byte) 22),
SUPPLEMENTAL_DATA((byte) 23),
MESSAGE_HASH((byte) 254);
private int value;
private static final Map MAP;
HandshakeMessageType(byte value) {
this.value = value;
}
HandshakeMessageType() {
this.value = -1;
}
static {
MAP = new HashMap<>();
for (HandshakeMessageType cm : values()) {
if (cm == UNKNOWN || cm.name().contains("SSL2")) {
continue;
}
MAP.put((byte) cm.value, cm);
}
}
public static HandshakeMessageType getMessageType(byte value) {
HandshakeMessageType type = MAP.get(value);
if (type == null) {
type = UNKNOWN;
}
return type;
}
public byte getValue() {
return (byte) value;
}
public byte[] getArrayValue() {
return new byte[] {(byte) value};
}
public String getName() {
return this.name();
}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/HeartbeatByteLength.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
public class HeartbeatByteLength {
/** payload length field */
public static final int TYPE = 1;
/** payload length field */
public static final int PAYLOAD_LENGTH = 2;
private HeartbeatByteLength() {}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/HeartbeatMessageType.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
import java.util.HashMap;
import java.util.Map;
public enum HeartbeatMessageType {
HEARTBEAT_REQUEST((byte) 1),
HEARTBEAT_RESPONSE((byte) 2);
private byte value;
private static final Map MAP;
HeartbeatMessageType(byte value) {
this.value = value;
}
static {
MAP = new HashMap<>();
for (HeartbeatMessageType cm : values()) {
MAP.put(cm.value, cm);
}
}
public static HeartbeatMessageType getHeartbeatMessageType(byte value) {
return MAP.get(value);
}
public byte getValue() {
return value;
}
public byte[] getArrayValue() {
return new byte[] {value};
}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/HeartbeatMode.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public enum HeartbeatMode {
PEER_ALLOWED_TO_SEND((byte) 1),
PEER_NOT_ALLOWED_TO_SEND((byte) 2);
private byte value;
private static final Map MAP;
HeartbeatMode(byte value) {
this.value = value;
}
static {
MAP = new HashMap<>();
for (HeartbeatMode cm : values()) {
MAP.put(cm.value, cm);
}
}
public static HeartbeatMode getHeartbeatMessageType(byte value) {
return MAP.get(value);
}
public byte getValue() {
return value;
}
public byte[] getArrayValue() {
return new byte[] {value};
}
public static HeartbeatMode getRandom(Random random) {
HeartbeatMode c = null;
while (c == null) {
Object[] o = MAP.values().toArray();
c = (HeartbeatMode) o[random.nextInt(o.length)];
}
return c;
}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/HpkeLabel.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
import java.nio.charset.StandardCharsets;
public enum HpkeLabel {
EMPTY(""),
PSK_ID_HASH("psk_id_hash"),
INFO_HASH("info_hash"),
SECRET("secret"),
KEY("key"),
BASE_NONCE("base_nonce"),
EXPAND("exp"),
KEM("KEM"),
HPKE("HPKE"),
EXTRACT_AND_EXPAND("eae_prk"),
SHARED_SECRET("shared_secret"),
HPKE_VERSION_1("HPKE-v1");
private final String name;
HpkeLabel(String name) {
this.name = name;
}
public byte[] getBytes() {
return this.name.getBytes(StandardCharsets.US_ASCII);
}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/KeyExchangeAlgorithm.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
public enum KeyExchangeAlgorithm {
NULL,
DHE_DSS,
DHE_RSA,
DHE_PSK,
DH_ANON,
RSA,
RSA_EXPORT,
RSA_PSK,
DH_DSS,
DH_RSA,
KRB5,
SRP_SHA_DSS,
SRP_SHA_RSA,
SRP_SHA,
PSK,
ECDH_RSA,
ECDH_ANON,
ECDH_ECDSA,
ECDHE_ECDSA,
ECDHE_RSA,
ECDHE_PSK,
VKO_GOST94,
VKO_GOST01,
VKO_GOST12,
FORTEZZA_KEA,
ECMQV_ECDSA,
ECMQV_ECNRA,
ECDH_ECNRA,
CECPQ1_ECDSA,
ECCPWD,
CECPQ1_RSA,
GOSTR341112_256;
public boolean isKeyExchangeRsa() {
switch (this) {
case RSA:
case RSA_EXPORT:
return true;
default:
return false;
}
}
public boolean isKeyExchangeDh() {
switch (this) {
case DHE_DSS:
case DHE_PSK:
case DHE_RSA:
case DH_ANON:
case DH_DSS:
case DH_RSA:
return true;
default:
return false;
}
}
public boolean isKeyExchangeStaticDh() {
switch (this) {
case DH_DSS:
case DH_RSA:
return true;
default:
return false;
}
}
public boolean isSrp() {
switch (this) {
case SRP_SHA_DSS:
case SRP_SHA_RSA:
case SRP_SHA:
return true;
default:
return false;
}
}
public boolean isKeyExchangeDhe() {
switch (this) {
case DHE_DSS:
case DHE_PSK:
case DHE_RSA:
case DH_ANON: // This is also ephemeral(!)
return true;
default:
return false;
}
}
public boolean isKeyExchangeEcdhe() {
switch (this) {
case ECDHE_ECDSA:
case ECDHE_PSK:
case ECDHE_RSA:
case ECDH_ANON:
return true;
default:
return false;
}
}
public boolean isKeyExchangeEcdh() {
switch (this) {
case ECDHE_ECDSA:
case ECDHE_PSK:
case ECDHE_RSA:
case ECDH_ANON:
case ECDH_ECDSA:
case ECDH_ECNRA:
case ECDH_RSA:
return true;
default:
return false;
}
}
public boolean isKeyExchangeStaticEcdh() {
switch (this) {
case ECDH_ECDSA:
case ECDH_ECNRA:
case ECDH_RSA:
return true;
default:
return false;
}
}
public boolean isKeyExchangeEphemeralEcdh() {
switch (this) {
case ECDHE_ECDSA:
case ECDHE_PSK:
case ECDHE_RSA:
case ECDH_ANON: // This is also ephemeral(!)
return true;
default:
return false;
}
}
public boolean isKeyExchangeEphemeral() {
switch (this) {
case ECDHE_ECDSA:
case ECDHE_PSK:
case ECDHE_RSA:
case ECDH_ANON: // This is also ephemeral(!)
case DHE_DSS:
case DHE_PSK:
case DHE_RSA:
case DH_ANON: // This is also ephemeral(!)
return true;
default:
return false;
}
}
public boolean isEC() {
switch (this) {
case ECDH_RSA:
case ECDH_ANON:
case ECDH_ECDSA:
case ECDHE_ECDSA:
case ECDHE_RSA:
case ECDHE_PSK:
case ECDH_ECNRA:
case ECMQV_ECDSA:
case ECMQV_ECNRA:
case CECPQ1_ECDSA:
return true;
default:
return false;
}
}
public boolean isAnon() {
switch (this) {
case DH_ANON:
case ECDH_ANON:
return true;
default:
return false;
}
}
public boolean isPsk() {
switch (this) {
case PSK:
case RSA_PSK:
case DHE_PSK:
case ECDHE_PSK:
return true;
default:
return false;
}
}
public boolean isExport() {
return this.name().contains("EXPORT");
}
public boolean requiresCertificate() {
switch (this) {
case RSA:
case RSA_EXPORT:
case DHE_DSS:
case DHE_RSA:
case DH_DSS:
case DH_RSA:
case ECDHE_ECDSA:
case ECDHE_RSA:
case ECDH_RSA:
case ECDH_ECDSA:
case ECDH_ECNRA:
case ECMQV_ECDSA:
case ECMQV_ECNRA:
case CECPQ1_ECDSA:
case VKO_GOST01:
case VKO_GOST12:
case SRP_SHA_DSS:
case SRP_SHA_RSA:
return true;
case FORTEZZA_KEA: // I dont know if this is correct actually
case KRB5:
case PSK:
case RSA_PSK:
case ECDHE_PSK:
case DHE_PSK:
case ECCPWD:
case SRP_SHA:
case DH_ANON:
case ECDH_ANON:
case NULL:
return false;
default:
throw new UnsupportedOperationException(
this.name()
+ " not defined yet! Please ask the developers to add this KEX algorithm");
}
}
public boolean isDss() {
switch (this) {
case DHE_DSS:
case DH_DSS:
case SRP_SHA_DSS:
return true;
default:
return false;
}
}
public boolean isGost() {
switch (this) {
case VKO_GOST94:
case VKO_GOST01:
case VKO_GOST12:
case GOSTR341112_256:
return true;
default:
return false;
}
}
public boolean isEcdsa() {
switch (this) {
case ECDHE_ECDSA:
case ECDH_ECDSA:
case ECMQV_ECDSA:
case CECPQ1_ECDSA:
return true;
default:
return false;
}
}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/KeyUpdateRequest.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
public enum KeyUpdateRequest {
UPDATE_NOT_REQUESTED((byte) 0),
UPDATE_REQUESTED((byte) 1);
private byte value;
KeyUpdateRequest(byte value) {
this.value = value;
}
public byte getValue() {
return value;
}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/ListDelegateType.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
/** Types that can be listed via ListDelegate */
public enum ListDelegateType {
ciphers,
filters,
groups,
sign_hash_algos,
workflow_trace_types
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/MaxFragmentLength.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public enum MaxFragmentLength {
TWO_9((byte) 1, 512),
TWO_10((byte) 2, 1024),
TWO_11((byte) 3, 2048),
TWO_12((byte) 4, 4096);
private byte value;
private int lengthValue;
private static final Map MAP;
MaxFragmentLength(byte value, int lengthValue) {
this.value = value;
this.lengthValue = lengthValue;
}
static {
MAP = new HashMap<>();
for (MaxFragmentLength cm : values()) {
MAP.put(cm.value, cm);
}
}
public static MaxFragmentLength getMaxFragmentLength(byte value) {
return MAP.get(value);
}
public byte getValue() {
return value;
}
public byte[] getArrayValue() {
return new byte[] {value};
}
public static MaxFragmentLength getRandom(Random random) {
MaxFragmentLength c = null;
while (c == null) {
Object[] o = MAP.values().toArray();
c = (MaxFragmentLength) o[random.nextInt(o.length)];
}
return c;
}
public int getReceiveLimit() {
return lengthValue;
}
}
================================================
FILE: TLS-Core/src/main/java/de/rub/nds/tlsattacker/core/constants/NamedGroup.java
================================================
/*
* TLS-Attacker - A Modular Penetration Testing Framework for TLS
*
* Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH
*
* Licensed under Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0.txt
*/
package de.rub.nds.tlsattacker.core.constants;
import de.rub.nds.protocol.constants.EcCurveEquationType;
import de.rub.nds.protocol.constants.FfdhGroupParameters;
import de.rub.nds.protocol.constants.GroupParameters;
import de.rub.nds.protocol.constants.NamedEllipticCurveParameters;
import de.rub.nds.protocol.crypto.ec.EllipticCurve;
import de.rub.nds.protocol.crypto.ffdh.Rfc7919Group2048;
import de.rub.nds.protocol.crypto.ffdh.Rfc7919Group3072;
import de.rub.nds.protocol.crypto.ffdh.Rfc7919Group4096;
import de.rub.nds.protocol.crypto.ffdh.Rfc7919Group6144;
import de.rub.nds.protocol.crypto.ffdh.Rfc7919Group8192;
import de.rub.nds.protocol.util.SilentByteArrayOutputStream;
import de.rub.nds.x509attacker.constants.X509NamedCurve;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public enum NamedGroup {
SECT163K1(new byte[] {(byte) 0, (byte) 1}, NamedEllipticCurveParameters.SECT163K1),
SECT163R1(new byte[] {(byte) 0, (byte) 2}, NamedEllipticCurveParameters.SECT163R1),
SECT163R2(new byte[] {(byte) 0, (byte) 3}, NamedEllipticCurveParameters.SECT163R2),
SECT193R1(new byte[] {(byte) 0, (byte) 4}, NamedEllipticCurveParameters.SECT193R1),
SECT193R2(new byte[] {(byte) 0, (byte) 5}, NamedEllipticCurveParameters.SECT193R2),
SECT233K1(new byte[] {(byte) 0, (byte) 6}, NamedEllipticCurveParameters.SECT233K1),
SECT233R1(new byte[] {(byte) 0, (byte) 7}, NamedEllipticCurveParameters.SECT233R1),
SECT239K1(new byte[] {(byte) 0, (byte) 8}, NamedEllipticCurveParameters.SECT239K1),
SECT283K1(new byte[] {(byte) 0, (byte) 9}, NamedEllipticCurveParameters.SECT283K1),
SECT283R1(new byte[] {(byte) 0, (byte) 10}, NamedEllipticCurveParameters.SECT283R1),
SECT409K1(new byte[] {(byte) 0, (byte) 11}, NamedEllipticCurveParameters.SECT409K1),
SECT409R1(new byte[] {(byte) 0, (byte) 12}, NamedEllipticCurveParameters.SECT409R1),
SECT571K1(new byte[] {(byte) 0, (byte) 13}, NamedEllipticCurveParameters.SECT571K1),
SECT571R1(new byte[] {(byte) 0, (byte) 14}, NamedEllipticCurveParameters.SECT571R1),
SECP160K1(new byte[] {(byte) 0, (byte) 15}, NamedEllipticCurveParameters.SECP160K1),
SECP160R1(new byte[] {(byte) 0, (byte) 16}, NamedEllipticCurveParameters.SECP160R1),
SECP160R2(new byte[] {(byte) 0, (byte) 17}, NamedEllipticCurveParameters.SECP160R2),
SECP192K1(new byte[] {(byte) 0, (byte) 18}, NamedEllipticCurveParameters.SECP192K1),
SECP192R1(new byte[] {(byte) 0, (byte) 19}, NamedEllipticCurveParameters.SECP192R1),
SECP224K1(new byte[] {(byte) 0, (byte) 20}, NamedEllipticCurveParameters.SECP224K1),
SECP224R1(new byte[] {(byte) 0, (byte) 21}, NamedEllipticCurveParameters.SECP224R1),
SECP256K1(new byte[] {(byte) 0, (byte) 22}, NamedEllipticCurveParameters.SECP256K1),
SECP256R1(new byte[] {(byte) 0, (byte) 23}, NamedEllipticCurveParameters.SECP256R1),
SECP384R1(new byte[] {(byte) 0, (byte) 24}, NamedEllipticCurveParameters.SECP384R1),
SECP521R1(new byte[] {(byte) 0, (byte) 25}, NamedEllipticCurveParameters.SECP521R1),
BRAINPOOLP256R1(new byte[] {(byte) 0, (byte) 26}, NamedEllipticCurveParameters.BRAINPOOLP256R1),
BRAINPOOLP384R1(new byte[] {(byte) 0, (byte) 27}, NamedEllipticCurveParameters.BRAINPOOLP384R1),
BRAINPOOLP512R1(new byte[] {(byte) 0, (byte) 28}, NamedEllipticCurveParameters.BRAINPOOLP512R1),
ECDH_X25519(new byte[] {(byte) 0, (byte) 29}, NamedEllipticCurveParameters.CURVE_X25519),
ECDH_X448(new byte[] {(byte) 0, (byte) 30}, NamedEllipticCurveParameters.CURVE_X448),
BRAINPOOLP256R1TLS13(
new byte[] {(byte) 0, (byte) 31}, NamedEllipticCurveParameters.BRAINPOOLP256R1),
BRAINPOOLP384R1TLS13(
new byte[] {(byte) 0, (byte) 32}, NamedEllipticCurveParameters.BRAINPOOLP384R1),
BRAINPOOLP512R1TLS13(
new byte[] {(byte) 0, (byte) 33}, NamedEllipticCurveParameters.BRAINPOOLP512R1),
GC256A(new byte[] {(byte) 0, (byte) 34}, null),
GC256B(new byte[] {(byte) 0, (byte) 35}, null),
GC256C(new byte[] {(byte) 0, (byte) 36}, null),
GC256D(new byte[] {(byte) 0, (byte) 37}, null),
GC512A(new byte[] {(byte) 0, (byte) 38}, null),
GC512B(new byte[] {(byte) 0, (byte) 39}, null),
GC512C(new byte[] {(byte) 0, (byte) 40}, null),
CURVE_SM2(new byte[] {(byte) 0, (byte) 41}, NamedEllipticCurveParameters.CURVE_SM2),
FFDHE2048(new byte[] {(byte) 1, (byte) 0}, new Rfc7919Group2048()),
FFDHE3072(new byte[] {(byte) 1, (byte) 1}, new Rfc7919Group3072()),
FFDHE4096(new byte[] {(byte) 1, (byte) 2}, new Rfc7919Group4096()),
FFDHE6144(new byte[] {(byte) 1, (byte) 3}, new Rfc7919Group6144()),
FFDHE8192(new byte[] {(byte) 1, (byte) 4}, new Rfc7919Group8192()),
MLKEM512(new byte[] {(byte) 2, (byte) 0}, null),
MLKEM768(new byte[] {(byte) 2, (byte) 1}, null),
MLKEM1024(new byte[] {(byte) 2, (byte) 2}, null),
SECP256R1_MLKEM768(new byte[] {0x11, (byte) 0xEB}, null),
X25519_MLKEM768(new byte[] {0x11, (byte) 0xEC}, null),
SECP384R1_MLKEM1024(new byte[] {0x11, (byte) 0xED}, null),
X25519_KYBER768_DRAFT00(new byte[] {0x63, (byte) 0x99}, null),
EXPLICIT_PRIME(new byte[] {(byte) 0xFF, (byte) 1}, null),
// GREASE constants
EXPLICIT_CHAR2(new byte[] {(byte) 0xFF, (byte) 2}, null),
GREASE_00(new byte[] {(byte) 0x0A, (byte) 0x0A}, null),
GREASE_01(new byte[] {(byte) 0x1A, (byte) 0x1A}, null),
GREASE_02(new byte[] {(byte) 0x2A, (byte) 0x2A}, null),
GREASE_03(new byte[] {(byte) 0x3A, (byte) 0x3A}, null),
GREASE_04(new byte[] {(byte) 0x4A, (byte) 0x4A}, null),
GREASE_05(new byte[] {(byte) 0x5A, (byte) 0x5A}, null),
GREASE_06(new byte[] {(byte) 0x6A, (byte) 0x6A}, null),
GREASE_07(new byte[] {(byte) 0x7A, (byte) 0x7A}, null),
GREASE_08(new byte[] {(byte) 0x8A, (byte) 0x8A}, null),
GREASE_09(new byte[] {(byte) 0x9A, (byte) 0x9A}, null),
GREASE_10(new byte[] {(byte) 0xAA, (byte) 0xAA}, null),
GREASE_11(new byte[] {(byte) 0xBA, (byte) 0xBA}, null),
GREASE_12(new byte[] {(byte) 0xCA, (byte) 0xCA}, null),
GREASE_13(new byte[] {(byte) 0xDA, (byte) 0xDA}, null),
GREASE_14(new byte[] {(byte) 0xEA, (byte) 0xEA}, null),
GREASE_15(new byte[] {(byte) 0xFA, (byte) 0xFA}, null);
private static final Logger LOGGER = LogManager.getLogger();
private byte[] value;
private GroupParameters groupParameters;
private static final Map MAP;
private static final Set tls13Groups =
new HashSet<>(
Arrays.asList(
ECDH_X25519,
ECDH_X448,
FFDHE2048,
FFDHE3072,
FFDHE4096,
FFDHE6144,
FFDHE8192,
SECP256R1,
SECP384R1,
SECP521R1,
CURVE_SM2,
MLKEM512,
MLKEM768,
MLKEM1024,
BRAINPOOLP256R1TLS13,
BRAINPOOLP384R1TLS13,
BRAINPOOLP512R1TLS13,
X25519_MLKEM768,
SECP256R1_MLKEM768,
SECP384R1_MLKEM1024));
NamedGroup(byte[] value, GroupParameters group) {
this.value = value;
this.groupParameters = group;
}
static {
MAP = new HashMap<>();
for (NamedGroup group : values()) {
MAP.put(ByteBuffer.wrap(group.value), group);
}
}
public static NamedGroup getNamedGroup(byte[] value) {
return MAP.get(ByteBuffer.wrap(value));
}
public X509NamedCurve convertToX509() {
switch (this) {
case BRAINPOOLP256R1:
return X509NamedCurve.BRAINPOOLP256R1;
case BRAINPOOLP384R1:
return X509NamedCurve.BRAINPOOLP384R1;
case BRAINPOOLP512R1:
return X509NamedCurve.BRAINPOOLP512R1;
case ECDH_X25519:
case ECDH_X448:
// X448 and X25519 are special values in x509 that are treated differently to
// all
// other curves
return null;
case EXPLICIT_CHAR2:
case EXPLICIT_PRIME:
// Not a named curve in x509
return null;
case FFDHE2048:
case FFDHE3072:
case FFDHE4096:
case FFDHE6144:
case FFDHE8192:
// FFDHE has no x509 equivalent
return null;
case GREASE_00:
case GREASE_01:
case GREASE_02:
case GREASE_03:
case GREASE_04:
case GREASE_05:
case GREASE_06:
case GREASE_07:
case GREASE_08:
case GREASE_09:
case GREASE_10:
case GREASE_11:
case GREASE_12:
case GREASE_13:
case GREASE_14:
case GREASE_15:
// GREASE has no equivalent
return null;
case SECP160K1:
return X509NamedCurve.SECP160K1;
case SECP160R1:
return X509NamedCurve.SECP160R1;
case SECP160R2:
return X509NamedCurve.SECP160R2;
case SECP192K1:
return X509NamedCurve.SECP192K1;
case SECP192R1:
return X509NamedCurve.SECP192R1;
case SECP224K1:
return X509NamedCurve.SECP224K1;
case SECP224R1:
return X509NamedCurve.SECP224R1;
case SECP256K1:
return X509NamedCurve.SECP256K1;
case SECP256R1:
return X509NamedCurve.SECP256R1;
case SECP384R1:
return X509NamedCurve.SECP384R1;
case SECP521R1:
return X509NamedCurve.SECP521R1;
case SECT163K1:
return X509NamedCurve.SECT163K1;
case SECT163R1:
return X509NamedCurve.SECT163R1;
case SECT163R2:
return X509NamedCurve.SECT163R2;
case SECT193R1:
return X509NamedCurve.SECT193R1;
case SECT193R2:
return X509NamedCurve.SECT193R2;
case SECT233K1:
return X509NamedCurve.SECT233K1;
case SECT233R1:
return X509NamedCurve.SECT233R1;
case SECT239K1:
return X509NamedCurve.SECT239K1;
case SECT283K1:
return X509NamedCurve.SECT283K1;
case SECT283R1:
return X509NamedCurve.SECT283R1;
case SECT409K1:
return X509NamedCurve.SECT409K1;
case SECT409R1:
return X509NamedCurve.SECT409R1;
case SECT571K1:
return X509NamedCurve.SECT571K1;
case SECT571R1:
return X509NamedCurve.SECT571R1;
default:
return null;
}
}
public static NamedGroup convertFromX509NamedCurve(X509NamedCurve curve) {
switch (curve) {
case BRAINPOOLP160R1:
return null; // Has no TLS equivalent
case BRAINPOOLP160T1:
return null; // Has no TLS equivalent
case BRAINPOOLP192R1:
return null; // Has no TLS equivalent
case BRAINPOOLP192T1:
return null; // Has no TLS equivalent
case BRAINPOOLP224R1:
return null; // Has no TLS equivalent
case BRAINPOOLP224T1:
return null; // Has no TLS equivalent
case BRAINPOOLP256R1:
return NamedGroup.BRAINPOOLP256R1;
case BRAINPOOLP256T1:
return null; // Has no TLS equivalent
case BRAINPOOLP320R1:
return null; // Has no TLS equivalent
case BRAINPOOLP320T1:
return null; // Has no TLS equivalent
case BRAINPOOLP384R1:
return NamedGroup.BRAINPOOLP384R1;
case BRAINPOOLP384T1:
return null; // Has no TLS equivalent
case BRAINPOOLP512R1:
return NamedGroup.BRAINPOOLP512R1;
case BRAINPOOLP512T1:
return null; // Has no TLS equivalent
case SECP112R1:
return null; // Has no TLS equivalent
case SECP112R2:
return null; // Has no TLS equivalent
case SECP128R1:
return null; // Has no TLS equivalent
case SECP128R2:
return null; // Has no TLS equivalent
case SECP160K1:
return NamedGroup.SECP160K1;
case SECP160R1:
return NamedGroup.SECP160R1;
case SECP160R2:
return NamedGroup.SECP160R2;
case SECP192K1:
return NamedGroup.SECP192K1;
case SECP192R1:
return NamedGroup.SECP192R1;
case SECP224K1:
return NamedGroup.SECP224K1;
case SECP224R1:
return NamedGroup.SECP224R1;
case SECP256K1:
return NamedGroup.SECP256K1;
case SECP256R1:
return NamedGroup.SECP256R1;
case SECP384R1:
return NamedGroup.SECP384R1;
case SECP521R1:
return NamedGroup.SECP521R1;
case SECT113R1:
return null; // Has no TLS equivalent
case SECT113R2:
return null; // Has no TLS equivalent
case SECT131R1:
return null; // Has no TLS equivalent
case SECT131R2:
return null; // Has no TLS equivalent
case SECT163K1:
return NamedGroup.SECT163K1;
case SECT163R1:
return NamedGroup.SECT163R1;
case SECT163R2:
return NamedGroup.SECT163R2;
case SECT193R1:
return NamedGroup.SECT193R1;
case SECT193R2:
return NamedGroup.SECT193R2;
case SECT233K1:
return NamedGroup.SECT233K1;
case SECT233R1:
return NamedGroup.SECT233R1;
case SECT239K1:
return NamedGroup.SECT239K1;
case SECT283K1:
return NamedGroup.SECT283K1;
case SECT283R1:
return NamedGroup.SECT283R1;
case SECT409K1:
return NamedGroup.SECT409K1;
case SECT409R1:
return NamedGroup.SECT409R1;
case SECT571K1:
return NamedGroup.SECT571K1;
case SECT571R1:
return NamedGroup.SECT571R1;
default:
return null;
}
}
public static NamedGroup convert(GroupParameters parameters) {
for (NamedGroup group : values()) {
if (group.getGroupParameters() == parameters) {
return group;
}
}
return null;
}
public byte[] getValue() {
return value;
}
public GroupParameters getGroupParameters() {
return groupParameters;
}
public static NamedGroup getRandom(Random random) {
NamedGroup c = null;
while (c == null) {
Object[] o = MAP.values().toArray();
c = (NamedGroup) o[random.nextInt(o.length)];
}
return c;
}
public static byte[] namedGroupsToByteArray(List groups) throws IOException {
if (groups == null || groups.isEmpty()) {
return new byte[0];
}
try (SilentByteArrayOutputStream bytes = new SilentByteArrayOutputStream()) {
for (NamedGroup i : groups) {
bytes.write(i.getValue());
}
return bytes.toByteArray();
}
}
public static List namedGroupsFromByteArray(byte[] sourceBytes) {
if (sourceBytes == null || sourceBytes.length == 0) {
return new ArrayList<>();
}
if (sourceBytes.length % HandshakeByteLength.NAMED_GROUP != 0) {
throw new IllegalArgumentException(
"Failed to convert byte array. "
+ "Source array size is not a multiple of destination type size.");
}
ByteArrayInputStream inputStream = new ByteArrayInputStream(sourceBytes);
List