SSLCommon.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <stdint.h>
 
 
namespace pcpp
{
#pragma pack(push, 1)
    struct ssl_tls_record_layer
    {
        uint8_t recordType;
        uint16_t recordVersion;
        uint16_t length;
    };
#pragma pack(pop)
    static_assert(sizeof(ssl_tls_record_layer) == 5, "ssl_tls_record_layer size is not 5 bytes");
 
#pragma pack(push, 1)
    struct ssl_tls_handshake_layer
    {
        uint8_t handshakeType;
        uint8_t length1;
        uint16_t length2;
    };
#pragma pack(pop)
    static_assert(sizeof(ssl_tls_handshake_layer) == 4, "ssl_tls_handshake_layer size is not 4 bytes");
 
#pragma pack(push, 1)
    struct ssl_tls_client_server_hello : ssl_tls_handshake_layer
    {
        uint16_t handshakeVersion;
        uint8_t random[32];
    };
#pragma pack(pop)
    static_assert(sizeof(ssl_tls_client_server_hello) == 38, "ssl_tls_client_server_hello size is not 38 bytes");
 
#pragma pack(push, 1)
    struct ssl_tls_change_cipher_spec
    {
        uint8_t changeCipherSpec;
    };
#pragma pack(pop)
    static_assert(sizeof(ssl_tls_change_cipher_spec) == 1, "ssl_tls_change_cipher_spec size is not 1 byte");
 
#pragma pack(push, 1)
    struct ssl_tls_alert
    {
        uint8_t alertLevel;
        uint8_t alertDescription;
    };
#pragma pack(pop)
    static_assert(sizeof(ssl_tls_alert) == 2, "ssl_tls_alert size is not 2 bytes");
 
    enum SSLRecordType
    {
        SSL_CHANGE_CIPHER_SPEC = 20,
        SSL_ALERT = 21,
        SSL_HANDSHAKE = 22,
        SSL_APPLICATION_DATA = 23
    };
 
    class SSLVersion
    {
    public:
        enum SSLVersionEnum
        {
            SSL3 = 0x0300,
            TLS1_0 = 0x0301,
            TLS1_1 = 0x0302,
            TLS1_2 = 0x0303,
            TLS1_3 = 0x0304,
            TLS1_3_D14 = 0x7f0e,
            TLS1_3_D15 = 0x7f0f,
            TLS1_3_D16 = 0x7f10,
            TLS1_3_D17 = 0x7f11,
            TLS1_3_D18 = 0x7f12,
            TLS1_3_D19 = 0x7f13,
            TLS1_3_D20 = 0x7f14,
            TLS1_3_D21 = 0x7f15,
            TLS1_3_D22 = 0x7f16,
            TLS1_3_D23 = 0x7f17,
            TLS1_3_D24 = 0x7f18,
            TLS1_3_D25 = 0x7f19,
            TLS1_3_D26 = 0x7f1a,
            TLS1_3_D27 = 0x7f1b,
            TLS1_3_D28 = 0x7f1c,
            TLS1_3_FBD23 = 0xfb17,
            TLS1_3_FBD26 = 0xfb1a,
            Unknown = 0
        };
 
        explicit SSLVersion(uint16_t sslVersionValue)
        {
            m_SSLVersionValue = sslVersionValue;
        }
 
        SSLVersionEnum asEnum(bool countTlsDraftsAs1_3 = false);
 
        uint16_t asUInt()
        {
            return m_SSLVersionValue;
        }
 
        std::string toString(bool countTlsDraftsAs1_3 = false);
 
    private:
        uint16_t m_SSLVersionValue;
 
        // unimplemented empty c'tor
        SSLVersion();
    };
 
    enum SSLHandshakeType
    {
        SSL_HELLO_REQUEST = 0,
        SSL_CLIENT_HELLO = 1,
        SSL_SERVER_HELLO = 2,
        SSL_NEW_SESSION_TICKET = 4,
        SSL_END_OF_EARLY_DATE = 5,
        SSL_ENCRYPTED_EXTENSIONS = 8,
        SSL_CERTIFICATE = 11,
        SSL_SERVER_KEY_EXCHANGE = 12,
        SSL_CERTIFICATE_REQUEST = 13,
        SSL_SERVER_DONE = 14,
        SSL_CERTIFICATE_VERIFY = 15,
        SSL_CLIENT_KEY_EXCHANGE = 16,
        SSL_FINISHED = 20,
        SSL_KEY_UPDATE = 24,
        SSL_HANDSHAKE_UNKNOWN = 255
    };
 
    enum SSLAlertLevel
    {
        SSL_ALERT_LEVEL_WARNING = 1,
        SSL_ALERT_LEVEL_FATAL = 2,
        SSL_ALERT_LEVEL_ENCRYPTED = 255
    };
 
    enum SSLAlertDescription
    {
        SSL_ALERT_CLOSE_NOTIFY = 0,
        SSL_ALERT_UNEXPECTED_MESSAGE = 10,
        SSL_ALERT_BAD_RECORD_MAC = 20,
        SSL_ALERT_DECRYPTION_FAILED = 21,
        SSL_ALERT_RECORD_OVERFLOW = 22,
        SSL_ALERT_DECOMPRESSION_FAILURE = 30,
        SSL_ALERT_HANDSHAKE_FAILURE = 40,
        SSL_ALERT_NO_CERTIFICATE = 41,
        SSL_ALERT_BAD_CERTIFICATE = 42,
        SSL_ALERT_UNSUPPORTED_CERTIFICATE = 43,
        SSL_ALERT_CERTIFICATE_REVOKED = 44,
        SSL_ALERT_CERTIFICATE_EXPIRED = 45,
        SSL_ALERT_CERTIFICATE_UNKNOWN = 46,
        SSL_ALERT_ILLEGAL_PARAMETER = 47,
        SSL_ALERT_UNKNOWN_CA = 48,
        SSL_ALERT_ACCESS_DENIED = 49,
        SSL_ALERT_DECODE_ERROR = 50,
        SSL_ALERT_DECRYPT_ERROR = 51,
        SSL_ALERT_EXPORT_RESTRICTION = 60,
        SSL_ALERT_PROTOCOL_VERSION = 70,
        SSL_ALERT_INSUFFICIENT_SECURITY = 71,
        SSL_ALERT_INTERNAL_ERROR = 80,
        SSL_ALERT_USER_CANCELLED = 90,
        SSL_ALERT_NO_RENEGOTIATION = 100,
        SSL_ALERT_UNSUPPORTED_EXTENSION = 110,
        SSL_ALERT_ENCRYPTED = 255
    };
 
    enum SSLKeyExchangeAlgorithm
    {
        SSL_KEYX_NULL,
        SSL_KEYX_RSA,
        SSL_KEYX_DH,
        SSL_KEYX_DHE,
        SSL_KEYX_ECDH,
        SSL_KEYX_ECDHE,
        SSL_KEYX_FORTEZZA,
        SSL_KEYX_KRB5,
        SSL_KEYX_PSK,
        SSL_KEYX_GOST,
        SSL_KEYX_SRP,
        SSL_KEYX_PCT,
        SSL_KEYX_Unknown
    };
 
    enum SSLAuthenticationAlgorithm
    {
        SSL_AUTH_NULL,
        SSL_AUTH_RSA,
        SSL_AUTH_DSS,
        SSL_AUTH_anon,
        SSL_AUTH_KEA,
        SSL_AUTH_KRB5,
        SSL_AUTH_PSK,
        SSL_AUTH_ECDSA,
        SSL_AUTH_GOST,
        SSL_AUTH_SHA,
        SSL_AUTH_PCT,
        SSL_AUTH_DHE,
        SSL_AUTH_Unknown
    };
 
    enum SSLSymetricEncryptionAlgorithm
    {
        SSL_SYM_NULL,
        SSL_SYM_RC4_40,
        SSL_SYM_RC4_128,
        SSL_SYM_RC2_CBC_40,
        SSL_SYM_IDEA_CBC,
        SSL_SYM_DES40_CBC,
        SSL_SYM_DES_CBC,
        SSL_SYM_3DES_EDE_CBC,
        SSL_SYM_FORTEZZA_CBC,
        SSL_SYM_DES_CBC_40,
        SSL_SYM_AES_128_CBC,
        SSL_SYM_AES_256_CBC,
        SSL_SYM_CAMELLIA_128_CBC,
        SSL_SYM_CAMELLIA_128_GCM,
        SSL_SYM_CAMELLIA_256_GCM,
        SSL_SYM_RC4_56,
        SSL_SYM_RC2_CBC_56,
        SSL_SYM_GOST28147,
        SSL_SYM_CAMELLIA_256_CBC,
        SSL_SYM_SEED_CBC,
        SSL_SYM_AES_128,
        SSL_SYM_AES_256,
        SSL_SYM_AES_128_GCM,
        SSL_SYM_AES_256_GCM,
        SSL_SYM_RC4_128_EXPORT40,
        SSL_SYM_RC2_CBC_128_CBC,
        SSL_SYM_IDEA_128_CBC,
        SSL_SYM_DES_64_CBC,
        SSL_SYM_DES_192_EDE3_CBC,
        SSL_SYM_RC4_64,
        SSL_SYM_ARIA_128_CBC,
        SSL_SYM_ARIA_256_CBC,
        SSL_SYM_ARIA_128_GCM,
        SSL_SYM_ARIA_256_GCM,
        SSL_SYM_CHACHA20_POLY1305,
        SSL_SYM_AES_128_CCM,
        SSL_SYM_AES_128_CCM_8,
        SSL_SYM_Unknown
    };
 
    enum SSLHashingAlgorithm
    {
        SSL_HASH_NULL,
        SSL_HASH_MD5,
        SSL_HASH_SHA,
        SSL_HASH_SHA256,
        SSL_HASH_GOST28147,
        SSL_HASH_GOSTR3411,
        SSL_HASH_SHA384,
        SSL_HASH_CCM,
        SSL_HASH_CCM_8,
        SSL_HASH_Unknown
    };
 
    enum SSLExtensionType
    {
        SSL_EXT_SERVER_NAME = 0,
        SSL_EXT_MAX_FRAGMENT_LENGTH = 1,
        SSL_EXT_CLIENT_CERTIFICATE_URL = 2,
        SSL_EXT_TRUSTED_CA_KEYS = 3,
        SSL_EXT_TRUNCATED_HMAC = 4,
        SSL_EXT_STATUS_REQUEST = 5,
        SSL_EXT_USER_MAPPING = 6,
        SSL_EXT_CLIENT_AUTHZ = 7,
        SSL_EXT_SERVER_AUTHZ = 8,
        SSL_EXT_CERT_TYPE = 9,
        SSL_EXT_SUPPORTED_GROUPS = 10,
        SSL_EXT_EC_POINT_FORMATS = 11,
        SSL_EXT_SRP = 12,
        SSL_EXT_SIGNATURE_ALGORITHMS = 13,
        SSL_EXT_USE_SRTP = 14,
        SSL_EXT_HEARTBEAT = 15,
        SSL_EXT_APPLICATION_LAYER_PROTOCOL_NEGOTIATION = 16,
        SSL_EXT_STATUS_REQUEST_V2 = 17,
        SSL_EXT_SIGNED_CERTIFICATE_TIMESTAMP = 18,
        SSL_EXT_CLIENT_CERTIFICATE_TYPE = 19,
        SSL_EXT_SERVER_CERTIFICATE_TYPE = 20,
        SSL_EXT_PADDING = 21,
        SSL_EXT_ENCRYPT_THEN_MAC = 22,
        SSL_EXT_EXTENDED_MASTER_SECRET = 23,
        SSL_EXT_TOKEN_BINDING = 24,
        SSL_EXT_SESSIONTICKET_TLS = 35,
        SSL_EXT_PRE_SHARED_KEY = 41,
        SSL_EXT_EARLY_DATA = 42,
        SSL_EXT_SUPPORTED_VERSIONS = 43,
        SSL_EXT_COOKIE = 44,
        SSL_EXT_PSK_KEY_EXCHANGE_MODES = 45,
        SSL_EXT_CERTIFICATE_AUTHORITIES = 47,
        SSL_EXT_OLD_FILTERS = 48,
        SSL_EXT_POST_HANDSHAKE_AUTH = 49,
        SSL_EXT_SIGNATURE_ALGORITHM_CERT = 50,
        SSL_EXT_KEY_SHARE = 51,
        SSL_EXT_RENEGOTIATION_INFO = 65281,
        SSL_EXT_Unknown
    };
 
    enum SSLClientCertificateType
    {
        SSL_CCT_RSA_SIGN = 1,
        SSL_CCT_DSS_SIGN = 2,
        SSL_CCT_RSA_FIXED_DH = 3,
        SSL_CCT_DSS_FIXED_DH = 4,
        SSL_CCT_RSA_EPHEMERAL_DH_RESERVED = 5,
        SSL_CCT_DSS_EPHEMERAL_DH_RESERVED = 6,
        SSL_CCT_FORTEZZA_DMS_RESERVED = 20,
        SSL_CCT_ECDSA_SIGN = 64,
        SSL_CCT_RSA_FIXED_ECDH = 65,
        SSL_CCT_ECDSA_FIXED_ECDH = 66,
        SSL_CCT_UNKNOWN
    };
}  // namespace pcpp