adulau/ssldump
1
0
Fork 0
mirror of https://github.com/adulau/ssldump.git synced 2024-11-21 08:57:04 +00:00
Code Issues Projects Releases Packages Wiki Activity
ssldump/ssl/ssl.enums.c
Peter Kovář 00171e1bf9 Add ECH 
Signed-off-by: Peter Kovář <peter.kovar@reflexion.tv>
2024-08-10 20:29:32 +02:00

1760 lines
66 KiB
C
Raw Permalink Blame History

#include <json.h>
#include <openssl/md5.h>
#include "network.h"
#include "ssl_h.h"
#include "sslprint.h"
#include "sslxprint.h"
#ifdef OPENSSL
#include <openssl/ssl.h>
#endif
#include "ssl.enums.h"
static int decode_extension(ssl_obj *ssl, int dir, segment *seg, Data *data);
static int decode_server_name(ssl_obj *ssl, int dir, segment *seg, Data *data);
static int decode_ContentType_ChangeCipherSpec(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "msg_type",
json_object_new_string("ChangeCipherSpec"));
ssl_process_change_cipher_spec(ssl, ssl->decoder, dir);
if(dir == DIR_I2R) {
ssl->i_state = SSL_ST_SENT_CHANGE_CIPHER_SPEC;
} else {
ssl->r_state = SSL_ST_SENT_CHANGE_CIPHER_SPEC;
}
LF;
return 0;
}
static int decode_ContentType_Alert(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r;
struct json_object *jobj;
if(ssl->record_encryption == REC_CIPHERTEXT) {
LF;
return 0;
}
if(data->len != 2) {
fprintf(stderr, "Wrong length for alert message: %d\n", data->len);
ERETURN(R_EOD);
}
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "msg_type", json_object_new_string("Alert"));
P_(P_HL) {
LF;
SSL_DECODE_ENUM(ssl, "level", 1, AlertLevel_decoder, P_HL, data, 0);
LF;
SSL_DECODE_ENUM(ssl, "value", 1, AlertDescription_decoder, P_HL, data, 0);
LF;
}
else {
SSL_DECODE_ENUM(ssl, 0, 1, AlertLevel_decoder, SSL_PRINT_ALL, data, 0);
SSL_DECODE_ENUM(ssl, 0, 1, AlertDescription_decoder, SSL_PRINT_ALL, data,
0);
LF;
}
return 0;
}
static int decode_ContentType_Handshake(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
extern decoder HandshakeType_decoder[];
int r;
UINT4 t, l;
int rs = 0;
Data d;
struct json_object *jobj;
if(ssl->record_encryption == REC_CIPHERTEXT) {
LF;
return 0;
}
while(data->len > 0) {
SSL_DECODE_UINT8(ssl, 0, 0, data, &t);
SSL_DECODE_UINT24(ssl, 0, 0, data, &l);
if(data->len < l) {
fprintf(stderr, "Error: short handshake length: expected %d got %d\n", l,
data->len);
ERETURN(R_EOD);
}
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "msg_type",
json_object_new_string("Handshake"));
d.data = data->data;
d.len = l;
data->len -= l;
data->data += l;
P_(P_HL) {
if(!rs) {
LF;
rs = 1;
}
}
ssl_decode_switch(ssl, HandshakeType_decoder, t, dir, seg, &d);
}
return 0;
}
static int decode_ContentType_application_data(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r;
Data d;
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "msg_type",
json_object_new_string("application data"));
SSL_DECODE_OPAQUE_ARRAY(ssl, "data", data->len, 0, data, &d);
if(NET_print_flags & NET_PRINT_JSON) {
json_object_object_add(jobj, "msg_data",
json_object_new_string_len((char *)d.data, d.len));
} else
P_(P_AD) { print_data(ssl, &d); }
else {
LF;
}
return 0;
}
decoder ContentType_decoder[] = {
{20, "ChangeCipherSpec", decode_ContentType_ChangeCipherSpec},
{21, "Alert", decode_ContentType_Alert},
{22, "Handshake", decode_ContentType_Handshake},
{23, "application_data", decode_ContentType_application_data},
{-1}};
static int decode_HandshakeType_HelloRequest(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "handshake_type",
json_object_new_string("HelloRequest"));
LF;
return 0;
}
static int decode_HandshakeType_ClientHello(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "handshake_type",
json_object_new_string("ClientHello"));
UINT4 vj, vn, cs, cslen, complen, comp, odd, exlen, ex;
Data session_id, random;
int r;
char *ja3_fp = NULL;
char *ja3_str = NULL;
char *ja3_ver_str = NULL;
char *ja3_cs_str = NULL;
char *ja3_ex_str = NULL;
char *ja3_ec_str = NULL;
char *ja3_ecp_str = NULL;
ssl->cur_ja3_ec_str = NULL;
ssl->cur_ja3_ecp_str = NULL;
extern decoder cipher_suite_decoder[];
extern decoder compression_method_decoder[];
extern decoder extension_decoder[];
LF;
ssl_update_handshake_messages(ssl, data);
SSL_DECODE_UINT8(ssl, 0, 0, data, &vj);
SSL_DECODE_UINT8(ssl, 0, 0, data, &vn);
ja3_ver_str = calloc(7, sizeof(char));
snprintf(ja3_ver_str, 7, "%u", ((vj & 0xff) << 8) | (vn & 0xff));
P_(P_HL) {
explain(ssl, "Version %d.%d ", vj, vn);
LF;
}
SSL_DECODE_OPAQUE_ARRAY(ssl, "random", 32, P_ND, data, &random);
ssl_set_client_random(ssl->decoder, random.data, random.len);
SSL_DECODE_OPAQUE_ARRAY(ssl, "session_id", -32, 0, data, &session_id);
ssl_set_client_session_id(ssl->decoder, session_id.data, session_id.len);
P_(P_HL) {
if(session_id.len)
exdump(ssl, "resume ", &session_id);
}
ssl_process_client_session_id(ssl, ssl->decoder, session_id.data,
session_id.len);
P_(P_HL) {
SSL_DECODE_UINT16(ssl, "cipher Suites len", 0, data, &cslen);
explain(ssl, "cipher suites\n");
odd = cslen % 2;
if(odd) {
printf("Wrong cipher suites length, fixing ...\n");
cslen -= odd;
}
for(; cslen; cslen -= 2) {
if(ssl_decode_enum(ssl, 0, 2, cipher_suite_decoder, 0, data, &cs))
return 1;
ssl_print_cipher_suite(ssl, (vj << 8) | vn, P_HL, cs);
if(!ja3_cs_str)
ja3_cs_str = calloc(7, 1);
else
ja3_cs_str = realloc(ja3_cs_str, strlen(ja3_cs_str) + 7);
snprintf(ja3_cs_str + strlen(ja3_cs_str), 7, "%u-", cs);
LF;
}
if(ja3_cs_str && ja3_cs_str[strlen(ja3_cs_str) - 1] == '-')
ja3_cs_str[strlen(ja3_cs_str) - 1] = '\0';
}
SSL_DECODE_UINT8(ssl, "compressionMethod len", 0, data, &complen);
if(complen) {
explain(ssl, "compression methods\n");
for(; complen; complen--) {
SSL_DECODE_ENUM(ssl, 0, 1, compression_method_decoder, P_HL, data, &comp);
LF;
}
}
SSL_DECODE_UINT16(ssl, "extensions len", 0, data, &exlen);
if(exlen) {
explain(ssl, "extensions\n");
while(data->len > 0) {
SSL_DECODE_UINT16(ssl, "extension type", 0, data, &ex);
if(!ja3_ex_str)
ja3_ex_str = calloc(7, 1);
else
ja3_ex_str = realloc(ja3_ex_str, strlen(ja3_ex_str) + 7);
snprintf(ja3_ex_str + strlen(ja3_ex_str), 7, "%u-", ex);
if(ssl_decode_switch(ssl, extension_decoder, ex, dir, seg, data) ==
R_NOT_FOUND) {
decode_extension(ssl, dir, seg, data);
P_(P_RH) {
explain(ssl, "Extension type: %u not yet implemented in ssldump\n",
ex);
}
continue;
}
LF;
}
if(ja3_ex_str && ja3_ex_str[strlen(ja3_ex_str) - 1] == '-')
ja3_ex_str[strlen(ja3_ex_str) - 1] = '\0';
}
ja3_ec_str = ssl->cur_ja3_ec_str;
ja3_ecp_str = ssl->cur_ja3_ecp_str;
if(!ja3_ver_str) {
ja3_ver_str = calloc(1, 1);
*ja3_ver_str = '\0';
}
if(!ja3_cs_str) {
ja3_cs_str = calloc(1, 1);
*ja3_cs_str = '\0';
}
if(!ja3_ex_str) {
ja3_ex_str = calloc(1, 1);
*ja3_ex_str = '\0';
}
if(!ja3_ec_str) {
ja3_ec_str = calloc(1, 1);
*ja3_ec_str = '\0';
}
if(!ja3_ecp_str) {
ja3_ecp_str = calloc(1, 1);
*ja3_ecp_str = '\0';
}
int ja3_str_len = strlen(ja3_ver_str) + 1 + strlen(ja3_cs_str) + 1 +
strlen(ja3_ex_str) + 1 + strlen(ja3_ec_str) + 1 +
strlen(ja3_ecp_str) + 1;
ja3_str = calloc(ja3_str_len, 1);
snprintf(ja3_str, ja3_str_len, "%s,%s,%s,%s,%s", ja3_ver_str, ja3_cs_str,
ja3_ex_str, ja3_ec_str, ja3_ecp_str);
EVP_MD_CTX *mdctx;
const EVP_MD *md;
unsigned char md_value[EVP_MAX_MD_SIZE];
unsigned int md_len, i;
md = EVP_get_digestbyname("MD5");
mdctx = EVP_MD_CTX_new();
EVP_DigestInit_ex(mdctx, md, NULL);
EVP_DigestUpdate(mdctx, ja3_str, strlen(ja3_str));
EVP_DigestFinal_ex(mdctx, md_value, &md_len);
EVP_MD_CTX_free(mdctx);
ja3_fp = calloc(33, 1);
*ja3_fp = '\0';
for(i = 0; i < 16; i++) {
snprintf(ja3_fp + strlen(ja3_fp), 3, "%02x", md_value[i]);
}
json_object_object_add(jobj, "ja3_str", json_object_new_string(ja3_str));
json_object_object_add(jobj, "ja3_fp", json_object_new_string(ja3_fp));
explain(ssl, "ja3 string: %s\n", ja3_str);
explain(ssl, "ja3 fingerprint: %s\n", ja3_fp);
free(ja3_fp);
free(ja3_str);
free(ja3_ver_str);
free(ja3_cs_str);
free(ja3_ex_str);
free(ja3_ec_str);
free(ja3_ecp_str);
return 0;
}
static int decode_HandshakeType_ServerHello(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r;
Data rnd, session_id;
UINT4 vj, vn, exlen, ex;
char *ja3s_fp = NULL;
char *ja3s_str = NULL;
char *ja3s_ver_str = NULL;
char *ja3s_c_str = NULL;
char *ja3s_ex_str = NULL;
extern decoder extension_decoder[];
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "handshake_type",
json_object_new_string("ServerHello"));
LF;
ssl_update_handshake_messages(ssl, data);
SSL_DECODE_UINT8(ssl, 0, 0, data, &vj);
SSL_DECODE_UINT8(ssl, 0, 0, data, &vn);
ja3s_ver_str = calloc(7, sizeof(char));
snprintf(ja3s_ver_str, 7, "%u", ((vj & 0xff) << 8) | (vn & 0xff));
ssl->version = vj * 256 + vn;
P_(P_HL) {
explain(ssl, "Version %d.%d ", vj, vn);
LF;
}
SSL_DECODE_OPAQUE_ARRAY(ssl, "random", 32, P_ND, data, &rnd);
ssl_set_server_random(ssl->decoder, rnd.data, rnd.len);
SSL_DECODE_OPAQUE_ARRAY(ssl, "session_id", -32, P_HL, data, &session_id);
SSL_DECODE_ENUM(ssl, "cipherSuite", 2, cipher_suite_decoder, 0, data,
&ssl->cipher_suite);
P_(P_HL) {
explain(ssl, "cipherSuite ");
ssl_print_cipher_suite(ssl, ssl->version, P_HL, ssl->cipher_suite);
}
ssl_find_cipher(ssl->cipher_suite, &ssl->cs);
ja3s_c_str = calloc(6, 1);
snprintf(ja3s_c_str, 6, "%u", ssl->cipher_suite);
P_(P_HL) LF;
SSL_DECODE_ENUM(ssl, "compressionMethod", 1, compression_method_decoder, P_HL,
data, 0);
P_(P_HL) LF;
SSL_DECODE_UINT16(ssl, "extensions len", 0, data, &exlen);
if(exlen) {
explain(ssl, "extensions\n");
while(data->len) {
SSL_DECODE_UINT16(ssl, "extension type", 0, data, &ex);
if(!ja3s_ex_str)
ja3s_ex_str = calloc(7, 1);
else
ja3s_ex_str = realloc(ja3s_ex_str, strlen(ja3s_ex_str) + 7);
snprintf(ja3s_ex_str + strlen(ja3s_ex_str), 7, "%u-", ex);
if(ssl_decode_switch(ssl, extension_decoder, ex, dir, seg, data) ==
R_NOT_FOUND) {
decode_extension(ssl, dir, seg, data);
P_(P_RH) {
explain(ssl, "Extension type: %u not yet implemented in ssldump,\n",
ex);
}
continue;
}
LF;
}
if(ja3s_ex_str && ja3s_ex_str[strlen(ja3s_ex_str) - 1] == '-')
ja3s_ex_str[strlen(ja3s_ex_str) - 1] = '\0';
}
if(ssl->version == TLSV13_VERSION) {
// tls version is known in server hello for tls1.3 hence generate keying
// material here
ssl_tls13_generate_keying_material(ssl, ssl->decoder);
}
ssl_process_server_session_id(ssl, ssl->decoder, session_id.data,
session_id.len);
if(!ja3s_ver_str) {
ja3s_ver_str = calloc(1, 1);
*ja3s_ver_str = '\0';
}
if(!ja3s_c_str) {
ja3s_c_str = calloc(1, 1);
*ja3s_c_str = '\0';
}
if(!ja3s_ex_str) {
ja3s_ex_str = calloc(1, 1);
*ja3s_ex_str = '\0';
}
int ja3s_str_len = strlen(ja3s_ver_str) + 1 + strlen(ja3s_c_str) + 1 +
strlen(ja3s_ex_str) + 1;
ja3s_str = calloc(ja3s_str_len, 1);
snprintf(ja3s_str, ja3s_str_len, "%s,%s,%s", ja3s_ver_str, ja3s_c_str,
ja3s_ex_str);
EVP_MD_CTX *mdctx;
const EVP_MD *md;
unsigned char md_value[EVP_MAX_MD_SIZE];
unsigned int md_len, i;
md = EVP_get_digestbyname("MD5");
mdctx = EVP_MD_CTX_new();
EVP_DigestInit_ex(mdctx, md, NULL);
EVP_DigestUpdate(mdctx, ja3s_str, strlen(ja3s_str));
EVP_DigestFinal_ex(mdctx, md_value, &md_len);
EVP_MD_CTX_free(mdctx);
ja3s_fp = calloc(33, 1);
*ja3s_fp = '\0';
for(i = 0; i < 16; i++) {
snprintf(ja3s_fp + strlen(ja3s_fp), 3, "%02x", md_value[i]);
}
json_object_object_add(jobj, "ja3s_str", json_object_new_string(ja3s_str));
json_object_object_add(jobj, "ja3s_fp", json_object_new_string(ja3s_fp));
explain(ssl, "ja3s string: %s\n", ja3s_str);
explain(ssl, "ja3s fingerprint: %s\n", ja3s_fp);
free(ja3s_fp);
free(ja3s_str);
free(ja3s_ver_str);
free(ja3s_c_str);
free(ja3s_ex_str);
return 0;
}
static int decode_HandshakeType_Certificate(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
UINT4 len, exlen, ex;
Data cert;
int r;
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "handshake_type",
json_object_new_string("Certificate"));
extern decoder extension_decoder[];
LF;
ssl_update_handshake_messages(ssl, data);
if(ssl->version == TLSV13_VERSION) {
SSL_DECODE_OPAQUE_ARRAY(ssl, "certificate request context", -((1 << 7) - 1),
0, data, NULL);
}
SSL_DECODE_UINT24(ssl, "certificates len", 0, data, &len);
json_object_object_add(jobj, "cert_chain", json_object_new_array());
while(len) {
SSL_DECODE_OPAQUE_ARRAY(ssl, "certificate", -((1 << 23) - 1), 0, data,
&cert);
sslx_print_certificate(ssl, &cert, P_ND);
len -= (cert.len + 3);
if(ssl->version == TLSV13_VERSION) { // TLS 1.3 has certificate extensions
SSL_DECODE_UINT16(ssl, "certificate extensions len", 0, data, &exlen);
len -= 2;
while(exlen) {
SSL_DECODE_UINT16(ssl, "extension type", 0, data, &ex);
len -= (2 + ex);
if(ssl_decode_switch(ssl, extension_decoder, ex, dir, seg, data) ==
R_NOT_FOUND) {
decode_extension(ssl, dir, seg, data);
P_(P_RH) {
explain(ssl, "Extension type: %u not yet implemented in ssldump\n",
ex);
}
continue;
}
LF;
}
}
}
return 0;
}
static int decode_HandshakeType_SessionTicket(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r;
UINT4 exlen, ex, val;
extern decoder extension_decoder[];
SSL_DECODE_UINT32(ssl, "ticket_lifetime", P_HL, data, &val);
if(ssl->version == TLSV13_VERSION) {
SSL_DECODE_UINT32(ssl, "ticket_age_add", P_HL, data, &val);
SSL_DECODE_OPAQUE_ARRAY(ssl, "ticket_nonce", -((1 << 7) - 1), P_ND, data,
NULL);
}
SSL_DECODE_OPAQUE_ARRAY(ssl, "ticket", -((1 << 15) - 1), P_ND, data, NULL);
if(ssl->version == TLSV13_VERSION) {
SSL_DECODE_UINT16(ssl, "exlen", 0, data, &exlen);
if(exlen) {
while(data->len) {
SSL_DECODE_UINT16(ssl, "extension type", 0, data, &ex);
if(ssl_decode_switch(ssl, extension_decoder, ex, dir, seg, data) ==
R_NOT_FOUND) {
if((r = decode_extension(ssl, dir, seg, data)))
ERETURN(r);
P_(P_RH) {
explain(ssl, "Extension type: %u not yet implemented in ssldump\n",
ex);
}
continue;
}
LF;
}
}
}
return 0;
}
static int decode_HandshakeType_EncryptedExtensions(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r;
UINT4 exlen, ex;
extern decoder extension_decoder[];
SSL_DECODE_UINT16(ssl, 0, 0, data, &exlen);
LF;
if(exlen) {
while(data->len) {
SSL_DECODE_UINT16(ssl, "extension type", 0, data, &ex);
if(ssl_decode_switch(ssl, extension_decoder, ex, dir, seg, data) ==
R_NOT_FOUND) {
decode_extension(ssl, dir, seg, data);
P_(P_RH) {
explain(ssl, "Extension type: %u not yet implemented in ssldump\n",
ex);
}
continue;
}
LF;
}
}
return 0;
}
static int decode_HandshakeType_ServerKeyExchange(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r;
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "handshake_type",
json_object_new_string("ServerKeyExchange"));
LF;
ssl_update_handshake_messages(ssl, data);
if(ssl->cs) {
P_(P_ND) { explain(ssl, "params\n"); }
INDENT_INCR;
switch(ssl->cs->kex) {
case KEX_DH:
SSL_DECODE_OPAQUE_ARRAY(ssl, "DH_p", -((1 << 15) - 1), P_ND, data, 0);
SSL_DECODE_OPAQUE_ARRAY(ssl, "DH_g", -((1 << 15) - 1), P_ND, data, 0);
SSL_DECODE_OPAQUE_ARRAY(ssl, "DH_Ys", -((1 << 15) - 1), P_ND, data, 0);
break;
case KEX_RSA:
SSL_DECODE_OPAQUE_ARRAY(ssl, "RSA_modulus", -((1 << 15) - 1), P_ND,
data, 0);
SSL_DECODE_OPAQUE_ARRAY(ssl, "RSA_exponent", -((1 << 15) - 1), P_ND,
data, 0);
break;
}
INDENT_POP;
SSL_DECODE_OPAQUE_ARRAY(ssl, "signature", -((1 << 15) - 1), P_ND, data, 0);
}
return 0;
}
static int decode_HandshakeType_CertificateRequest(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
UINT4 len;
Data ca;
int r;
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "handshake_type",
json_object_new_string("CertificateRequest"));
LF;
ssl_update_handshake_messages(ssl, data);
SSL_DECODE_UINT8(ssl, "certificate_types len", 0, data, &len);
for(; len; len--) {
SSL_DECODE_ENUM(ssl, "certificate_types", 1,
client_certificate_type_decoder, P_HL, data, 0);
P_(P_HL) { LF; }
};
SSL_DECODE_UINT16(ssl, "certificate_authorities len", 0, data, &len);
while(len) {
SSL_DECODE_OPAQUE_ARRAY(ssl, "certificate_authorities", -((1 << 15) - 1), 0,
data, &ca);
explain(ssl, "certificate_authority\n");
INDENT_INCR;
sslx_print_dn(ssl, &ca, P_HL);
INDENT_POP;
len -= (ca.len + 2);
}
return 0;
}
static int decode_HandshakeType_ServerHelloDone(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "handshake_type",
json_object_new_string("ServerHelloDone"));
LF;
ssl_update_handshake_messages(ssl, data);
return 0;
}
static int decode_HandshakeType_CertificateVerify(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r;
UINT4 signature_type;
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "handshake_type",
json_object_new_string("CertificateVerify"));
LF;
ssl_update_handshake_messages(ssl, data);
if(ssl->version == TLSV13_VERSION) {
SSL_DECODE_UINT16(ssl, "signature_type", P_HL, data, &signature_type);
}
SSL_DECODE_OPAQUE_ARRAY(ssl, "Signature", -((1 << 15) - 1), P_HL, data, 0);
return 0;
}
static int decode_HandshakeType_ClientKeyExchange(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r;
Data pms;
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "handshake_type",
json_object_new_string("ClientKeyExchange"));
LF;
ssl_update_handshake_messages(ssl, data);
if(ssl->cs) {
switch(ssl->cs->kex) {
case KEX_RSA:
if(ssl->version > 768) {
SSL_DECODE_OPAQUE_ARRAY(ssl, "EncryptedPreMasterSecret",
-((1 << 15) - 1), P_ND, data, &pms);
} else {
SSL_DECODE_OPAQUE_ARRAY(ssl, "EncryptedPreMasterSecret", data->len,
P_ND, data, &pms);
}
ssl_process_client_key_exchange(ssl, ssl->decoder, pms.data, pms.len);
break;
case KEX_DH:
SSL_DECODE_OPAQUE_ARRAY(ssl, "DiffieHellmanClientPublicValue",
-((1 << 7) - 1), P_HL, data, 0);
ssl_process_client_key_exchange(ssl, ssl->decoder, NULL, 0);
}
}
return 0;
}
static int decode_HandshakeType_Finished(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r;
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "handshake_type",
json_object_new_string("Finished"));
LF;
switch(ssl->version) {
case 0x300:
SSL_DECODE_OPAQUE_ARRAY(ssl, "md5_hash", 16, P_ND, data, 0);
SSL_DECODE_OPAQUE_ARRAY(ssl, "sha_hash", 20, P_ND, data, 0);
break;
case 0x301:
SSL_DECODE_OPAQUE_ARRAY(ssl, "verify_data", 12, P_ND, data, 0);
P_(P_ND)
LF;
break;
}
ssl_process_handshake_finished(ssl, ssl->decoder, data);
return 0;
}
static int decode_HandshakeType_KeyUpdate(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
LF;
ssl_tls13_update_keying_material(ssl, ssl->decoder, dir);
return 0;
}
decoder HandshakeType_decoder[] = {
{0, "HelloRequest", decode_HandshakeType_HelloRequest},
{1, "ClientHello", decode_HandshakeType_ClientHello},
{2, "ServerHello", decode_HandshakeType_ServerHello},
{4, "SessionTicket", decode_HandshakeType_SessionTicket},
{8, "EncryptedExtensions", decode_HandshakeType_EncryptedExtensions},
{11, "Certificate", decode_HandshakeType_Certificate},
{12, "ServerKeyExchange", decode_HandshakeType_ServerKeyExchange},
{13, "CertificateRequest", decode_HandshakeType_CertificateRequest},
{14, "ServerHelloDone", decode_HandshakeType_ServerHelloDone},
{15, "CertificateVerify", decode_HandshakeType_CertificateVerify},
{16, "ClientKeyExchange", decode_HandshakeType_ClientKeyExchange},
{20, "Finished", decode_HandshakeType_Finished},
{24, "KeyUpdate", decode_HandshakeType_KeyUpdate},
{-1}};
decoder cipher_suite_decoder[] = {
// https://www.iana.org/assignments/tls-parameters/tls-parameters.txt
{0, "TLS_NULL_WITH_NULL_NULL", 0},
{1, "TLS_RSA_WITH_NULL_MD5", 0},
{2, "TLS_RSA_WITH_NULL_SHA", 0},
{3, "TLS_RSA_EXPORT_WITH_RC4_40_MD5", 0},
{4, "TLS_RSA_WITH_RC4_128_MD5", 0},
{5, "TLS_RSA_WITH_RC4_128_SHA", 0},
{6, "TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5", 0},
{7, "TLS_RSA_WITH_IDEA_CBC_SHA", 0},
{8, "TLS_RSA_EXPORT_WITH_DES40_CBC_SHA", 0},
{9, "TLS_RSA_WITH_DES_CBC_SHA", 0},
{10, "TLS_RSA_WITH_3DES_EDE_CBC_SHA", 0},
{11, "TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA", 0},
{12, "TLS_DH_DSS_WITH_DES_CBC_SHA", 0},
{13, "TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA", 0},
{14, "TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA", 0},
{15, "TLS_DH_RSA_WITH_DES_CBC_SHA", 0},
{16, "TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA", 0},
{17, "TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA", 0},
{18, "TLS_DHE_DSS_WITH_DES_CBC_SHA", 0},
{19, "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA", 0},
{20, "TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA", 0},
{21, "TLS_DHE_RSA_WITH_DES_CBC_SHA", 0},
{22, "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA", 0},
{23, "TLS_DH_anon_EXPORT_WITH_RC4_40_MD5", 0},
{24, "TLS_DH_anon_WITH_RC4_128_MD5", 0},
{25, "TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA", 0},
{26, "TLS_DH_anon_WITH_DES_CBC_SHA", 0},
{27, "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA", 0},
{30, "TLS_KRB5_WITH_DES_CBC_SHA", 0},
{31, "TLS_KRB5_WITH_3DES_EDE_CBC_SHA", 0},
{32, "TLS_KRB5_WITH_RC4_128_SHA", 0},
{33, "TLS_KRB5_WITH_IDEA_CBC_SHA", 0},
{34, "TLS_KRB5_WITH_DES_CBC_MD5", 0},
{35, "TLS_KRB5_WITH_3DES_EDE_CBC_MD5", 0},
{36, "TLS_KRB5_WITH_RC4_128_MD5", 0},
{37, "TLS_KRB5_WITH_IDEA_CBC_MD5", 0},
{38, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA", 0},
{39, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA", 0},
{40, "TLS_KRB5_EXPORT_WITH_RC4_40_SHA", 0},
{41, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5", 0},
{42, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5", 0},
{43, "TLS_KRB5_EXPORT_WITH_RC4_40_MD5", 0},
{44, "TLS_PSK_WITH_NULL_SHA", 0},
{45, "TLS_DHE_PSK_WITH_NULL_SHA", 0},
{46, "TLS_RSA_PSK_WITH_NULL_SHA", 0},
{47, "TLS_RSA_WITH_AES_128_CBC_SHA", 0},
{48, "TLS_DH_DSS_WITH_AES_128_CBC_SHA", 0},
{49, "TLS_DH_RSA_WITH_AES_128_CBC_SHA", 0},
{50, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA", 0},
{51, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA", 0},
{52, "TLS_DH_anon_WITH_AES_128_CBC_SHA", 0},
{53, "TLS_RSA_WITH_AES_256_CBC_SHA", 0},
{54, "TLS_DH_DSS_WITH_AES_256_CBC_SHA", 0},
{55, "TLS_DH_RSA_WITH_AES_256_CBC_SHA", 0},
{56, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA", 0},
{57, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA", 0},
{58, "TLS_DH_anon_WITH_AES_256_CBC_SHA", 0},
{59, "TLS_RSA_WITH_NULL_SHA256", 0},
{60, "TLS_RSA_WITH_AES_128_CBC_SHA256", 0},
{61, "TLS_RSA_WITH_AES_256_CBC_SHA256", 0},
{62, "TLS_DH_DSS_WITH_AES_128_CBC_SHA256", 0},
{63, "TLS_DH_RSA_WITH_AES_128_CBC_SHA256", 0},
{64, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256", 0},
{65, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA", 0},
{66, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA", 0},
{67, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA", 0},
{68, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA", 0},
{69, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA", 0},
{70, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA", 0},
{103, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256", 0},
{104, "TLS_DH_DSS_WITH_AES_256_CBC_SHA256", 0},
{105, "TLS_DH_RSA_WITH_AES_256_CBC_SHA256", 0},
{106, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256", 0},
{107, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256", 0},
{108, "TLS_DH_anon_WITH_AES_128_CBC_SHA256", 0},
{109, "TLS_DH_anon_WITH_AES_256_CBC_SHA256", 0},
{132, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA", 0},
{133, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA", 0},
{134, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA", 0},
{135, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA", 0},
{136, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA", 0},
{137, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA", 0},
{138, "TLS_PSK_WITH_RC4_128_SHA", 0},
{139, "TLS_PSK_WITH_3DES_EDE_CBC_SHA", 0},
{140, "TLS_PSK_WITH_AES_128_CBC_SHA", 0},
{141, "TLS_PSK_WITH_AES_256_CBC_SHA", 0},
{142, "TLS_DHE_PSK_WITH_RC4_128_SHA", 0},
{143, "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA", 0},
{144, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA", 0},
{145, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA", 0},
{146, "TLS_RSA_PSK_WITH_RC4_128_SHA", 0},
{147, "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA", 0},
{148, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA", 0},
{149, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA", 0},
{150, "TLS_RSA_WITH_SEED_CBC_SHA", 0},
{151, "TLS_DH_DSS_WITH_SEED_CBC_SHA", 0},
{152, "TLS_DH_RSA_WITH_SEED_CBC_SHA", 0},
{153, "TLS_DHE_DSS_WITH_SEED_CBC_SHA", 0},
{154, "TLS_DHE_RSA_WITH_SEED_CBC_SHA", 0},
{155, "TLS_DH_anon_WITH_SEED_CBC_SHA", 0},
{156, "TLS_RSA_WITH_AES_128_GCM_SHA256", 0},
{157, "TLS_RSA_WITH_AES_256_GCM_SHA384", 0},
{158, "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256", 0},
{159, "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384", 0},
{160, "TLS_DH_RSA_WITH_AES_128_GCM_SHA256", 0},
{161, "TLS_DH_RSA_WITH_AES_256_GCM_SHA384", 0},
{162, "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256", 0},
{163, "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384", 0},
{164, "TLS_DH_DSS_WITH_AES_128_GCM_SHA256", 0},
{165, "TLS_DH_DSS_WITH_AES_256_GCM_SHA384", 0},
{166, "TLS_DH_anon_WITH_AES_128_GCM_SHA256", 0},
{167, "TLS_DH_anon_WITH_AES_256_GCM_SHA384", 0},
{168, "TLS_PSK_WITH_AES_128_GCM_SHA256", 0},
{169, "TLS_PSK_WITH_AES_256_GCM_SHA384", 0},
{170, "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256", 0},
{171, "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384", 0},
{172, "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256", 0},
{173, "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384", 0},
{174, "TLS_PSK_WITH_AES_128_CBC_SHA256", 0},
{175, "TLS_PSK_WITH_AES_256_CBC_SHA384", 0},
{176, "TLS_PSK_WITH_NULL_SHA256", 0},
{177, "TLS_PSK_WITH_NULL_SHA384", 0},
{178, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256", 0},
{179, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384", 0},
{180, "TLS_DHE_PSK_WITH_NULL_SHA256", 0},
{181, "TLS_DHE_PSK_WITH_NULL_SHA384", 0},
{182, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256", 0},
{183, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384", 0},
{184, "TLS_RSA_PSK_WITH_NULL_SHA256", 0},
{185, "TLS_RSA_PSK_WITH_NULL_SHA384", 0},
{186, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256", 0},
{187, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256", 0},
{188, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256", 0},
{189, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256", 0},
{190, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256", 0},
{191, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256", 0},
{192, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256", 0},
{193, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256", 0},
{194, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256", 0},
{195, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256", 0},
{196, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256", 0},
{197, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256", 0},
{255, "TLS_EMPTY_RENEGOTIATION_INFO_SCSV", 0},
{4865, "TLS_AES_128_GCM_SHA256", 0},
{4866, "TLS_AES_256_GCM_SHA384", 0},
{4867, "TLS_CHACHA20_POLY1305_SHA256", 0},
{4868, "TLS_AES_128_CCM_SHA256", 0},
{4869, "TLS_AES_128_CCM_8_SHA256", 0},
{22016, "TLS_FALLBACK_SCSV", 0},
{49153, "TLS_ECDH_ECDSA_WITH_NULL_SHA", 0},
{49154, "TLS_ECDH_ECDSA_WITH_RC4_128_SHA", 0},
{49155, "TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA", 0},
{49156, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA", 0},
{49157, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA", 0},
{49158, "TLS_ECDHE_ECDSA_WITH_NULL_SHA", 0},
{49159, "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA", 0},
{49160, "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA", 0},
{49161, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA", 0},
{49162, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA", 0},
{49163, "TLS_ECDH_RSA_WITH_NULL_SHA", 0},
{49164, "TLS_ECDH_RSA_WITH_RC4_128_SHA", 0},
{49165, "TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA", 0},
{49166, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA", 0},
{49167, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA", 0},
{49168, "TLS_ECDHE_RSA_WITH_NULL_SHA", 0},
{49169, "TLS_ECDHE_RSA_WITH_RC4_128_SHA", 0},
{49170, "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA", 0},
{49171, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA", 0},
{49172, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA", 0},
{49173, "TLS_ECDH_anon_WITH_NULL_SHA", 0},
{49174, "TLS_ECDH_anon_WITH_RC4_128_SHA", 0},
{49175, "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA", 0},
{49176, "TLS_ECDH_anon_WITH_AES_128_CBC_SHA", 0},
{49177, "TLS_ECDH_anon_WITH_AES_256_CBC_SHA", 0},
{49178, "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA", 0},
{49179, "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA", 0},
{49180, "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA", 0},
{49181, "TLS_SRP_SHA_WITH_AES_128_CBC_SHA", 0},
{49182, "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA", 0},
{49183, "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA", 0},
{49184, "TLS_SRP_SHA_WITH_AES_256_CBC_SHA", 0},
{49185, "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA", 0},
{49186, "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA", 0},
{49187, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256", 0},
{49188, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384", 0},
{49189, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256", 0},
{49190, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384", 0},
{49191, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256", 0},
{49192, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384", 0},
{49193, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256", 0},
{49194, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384", 0},
{49195, "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256", 0},
{49196, "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384", 0},
{49197, "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256", 0},
{49198, "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384", 0},
{49199, "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", 0},
{49200, "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384", 0},
{49201, "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256", 0},
{49202, "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384", 0},
{49203, "TLS_ECDHE_PSK_WITH_RC4_128_SHA", 0},
{49204, "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA", 0},
{49205, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA", 0},
{49206, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA", 0},
{49207, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256", 0},
{49208, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384", 0},
{49209, "TLS_ECDHE_PSK_WITH_NULL_SHA", 0},
{49210, "TLS_ECDHE_PSK_WITH_NULL_SHA256", 0},
{49211, "TLS_ECDHE_PSK_WITH_NULL_SHA384", 0},
{49212, "TLS_RSA_WITH_ARIA_128_CBC_SHA256", 0},
{49213, "TLS_RSA_WITH_ARIA_256_CBC_SHA384", 0},
{49214, "TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256", 0},
{49215, "TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384", 0},
{49216, "TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256", 0},
{49217, "TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384", 0},
{49218, "TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256", 0},
{49219, "TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384", 0},
{49220, "TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256", 0},
{49221, "TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384", 0},
{49222, "TLS_DH_anon_WITH_ARIA_128_CBC_SHA256", 0},
{49223, "TLS_DH_anon_WITH_ARIA_256_CBC_SHA384", 0},
{49224, "TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256", 0},
{49225, "TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384", 0},
{49226, "TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256", 0},
{49227, "TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384", 0},
{49228, "TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256", 0},
{49229, "TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384", 0},
{49230, "TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256", 0},
{49231, "TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384", 0},
{49232, "TLS_RSA_WITH_ARIA_128_GCM_SHA256", 0},
{49233, "TLS_RSA_WITH_ARIA_256_GCM_SHA384", 0},
{49234, "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256", 0},
{49235, "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384", 0},
{49236, "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256", 0},
{49237, "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384", 0},
{49238, "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256", 0},
{49239, "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384", 0},
{49240, "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256", 0},
{49241, "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384", 0},
{49242, "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256", 0},
{49243, "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384", 0},
{49244, "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256", 0},
{49245, "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384", 0},
{49246, "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256", 0},
{49247, "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384", 0},
{49248, "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256", 0},
{49249, "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384", 0},
{49250, "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256", 0},
{49251, "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384", 0},
{49252, "TLS_PSK_WITH_ARIA_128_CBC_SHA256", 0},
{49253, "TLS_PSK_WITH_ARIA_256_CBC_SHA384", 0},
{49254, "TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256", 0},
{49255, "TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384", 0},
{49256, "TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256", 0},
{49257, "TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384", 0},
{49258, "TLS_PSK_WITH_ARIA_128_GCM_SHA256", 0},
{49259, "TLS_PSK_WITH_ARIA_256_GCM_SHA384", 0},
{49260, "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256", 0},
{49261, "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384", 0},
{49262, "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256", 0},
{49263, "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384", 0},
{49264, "TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256", 0},
{49265, "TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384", 0},
{49266, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256", 0},
{49267, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384", 0},
{49268, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256", 0},
{49269, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384", 0},
{49270, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256", 0},
{49271, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384", 0},
{49272, "TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256", 0},
{49273, "TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384", 0},
{49274, "TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256", 0},
{49275, "TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384", 0},
{49276, "TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256", 0},
{49277, "TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384", 0},
{49278, "TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256", 0},
{49279, "TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384", 0},
{49280, "TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256", 0},
{49281, "TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384", 0},
{49282, "TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256", 0},
{49283, "TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384", 0},
{49284, "TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256", 0},
{49285, "TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384", 0},
{49286, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256", 0},
{49287, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384", 0},
{49288, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256", 0},
{49289, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384", 0},
{49290, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256", 0},
{49291, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384", 0},
{49292, "TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256", 0},
{49293, "TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384", 0},
{49294, "TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256", 0},
{49295, "TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384", 0},
{49296, "TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256", 0},
{49297, "TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384", 0},
{49298, "TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256", 0},
{49299, "TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384", 0},
{49300, "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256", 0},
{49301, "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384", 0},
{49302, "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256", 0},
{49303, "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384", 0},
{49304, "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256", 0},
{49305, "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384", 0},
{49306, "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256", 0},
{49307, "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384", 0},
{49308, "TLS_RSA_WITH_AES_128_CCM", 0},
{49309, "TLS_RSA_WITH_AES_256_CCM", 0},
{49310, "TLS_DHE_RSA_WITH_AES_128_CCM", 0},
{49311, "TLS_DHE_RSA_WITH_AES_256_CCM", 0},
{49312, "TLS_RSA_WITH_AES_128_CCM_8", 0},
{49313, "TLS_RSA_WITH_AES_256_CCM_8", 0},
{49314, "TLS_DHE_RSA_WITH_AES_128_CCM_8", 0},
{49315, "TLS_DHE_RSA_WITH_AES_256_CCM_8", 0},
{49316, "TLS_PSK_WITH_AES_128_CCM", 0},
{49317, "TLS_PSK_WITH_AES_256_CCM", 0},
{49318, "TLS_DHE_PSK_WITH_AES_128_CCM", 0},
{49319, "TLS_DHE_PSK_WITH_AES_256_CCM", 0},
{49320, "TLS_PSK_WITH_AES_128_CCM_8", 0},
{49321, "TLS_PSK_WITH_AES_256_CCM_8", 0},
{49322, "TLS_PSK_DHE_WITH_AES_128_CCM_8", 0},
{49323, "TLS_PSK_DHE_WITH_AES_256_CCM_8", 0},
{49324, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM", 0},
{49325, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM", 0},
{49326, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8", 0},
{49327, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8", 0},
{52392, "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256", 0},
{52393, "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256", 0},
{52394, "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256", 0},
{52395, "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256", 0},
{52396, "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256", 0},
{52397, "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256", 0},
{52398, "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256", 0},
// DRAFT-IETF-TLS-ECC
{71, "TLS_ECDH_ECDSA_WITH_NULL_SHA", 0},
{72, "TLS_ECDH_ECDSA_WITH_RC4_128_SHA", 0},
{73, "TLS_ECDH_ECDSA_WITH_DES_CBC_SHA", 0},
{74, "TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA", 0},
{75, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA", 0},
{76, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA", 0},
{75, "TLS_ECDH_ECDSA_EXPORT_WITH_RC4_40_SHA", 0},
{76, "TLS_ECDH_ECDSA_EXPORT_WITH_RC4_56_SHA", 0},
{77, "TLS_ECDH_RSA_WITH_NULL_SHA", 0},
{78, "TLS_ECDH_RSA_WITH_RC4_128_SHA", 0},
{79, "TLS_ECDH_RSA_WITH_DES_CBC_SHA", 0},
{80, "TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA", 0},
{81, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA", 0},
{82, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA", 0},
{83, "TLS_ECDH_RSA_EXPORT_WITH_RC4_40_SHA", 0},
{84, "TLS_ECDH_RSA_EXPORT_WITH_RC4_56_SHA", 0},
{85, "TLS_ECDH_anon_NULL_WITH_SHA", 0},
{86, "TLS_ECDH_anon_WITH_RC4_128_SHA", 0},
{87, "TLS_ECDH_anon_WITH_DES_CBC_SHA", 0},
{88, "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA", 0},
{89, "TLS_ECDH_anon_EXPORT_WITH_DES40_CBC_SHA", 0},
{90, "TLS_ECDH_anon_EXPORT_WITH_RC4_40_SHA", 0},
// DRAFT-IETF-TLS-56-BIT-CIPHERSUITES
{96, "TLS_RSA_EXPORT1024_WITH_RC4_56_MD5", 0},
{97, "TLS_RSA_EXPORT1024_WITH_RC2_CBC_56_MD5", 0},
{98, "TLS_RSA_EXPORT1024_WITH_DES_CBC_SHA", 0},
{99, "TLS_DHE_DSS_EXPORT1024_WITH_DES_CBC_SHA", 0},
{100, "TLS_RSA_EXPORT1024_WITH_RC4_56_SHA", 0},
{101, "TLS_DHE_DSS_EXPORT1024_WITH_RC4_56_SHA", 0},
{102, "TLS_DHE_DSS_WITH_RC4_128_SHA", 0},
// FIPS SSL (Netscape)
{65278, "SSL_RSA_FIPS_WITH_DES_CBC_SHA", 0},
{65279, "SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA", 0},
// SSL 2.0
{65664, "SSL2_RC4_128_WITH_MD5", 0},
{131200, "SSL2_RC4_128_EXPORT40_WITH_MD5", 0},
{196736, "SSL2_RC2_CBC_128_CBC_WITH_MD5", 0},
{262272, "SSL2_RC2_128_CBC_EXPORT40_WITH_MD5", 0},
{327808, "SSL2_IDEA_128_CBC_WITH_MD5", 0},
{393280, "SSL2_DES_64_CBC_WITH_MD5", 0},
{393536, "SSL2_DES_64_CBC_WITH_SHA", 0},
{458944, "SSL2_DES_192_EDE3_CBC_WITH_MD5", 0},
{459200, "SSL2_DES_192_EDE3_CBC_WITH_SHA", 0},
{524416, "SSL2_RC4_64_WITH_MD5", 0},
{2570, "GREASE 0x0A0A", 0},
{6682, "GREASE 0x1A1A", 0},
{10794, "GREASE 0x2A2A", 0},
{14906, "GREASE 0x3A3A", 0},
{19018, "GREASE 0x4A4A", 0},
{23130, "GREASE 0x5A5A", 0},
{27242, "GREASE 0x6A6A", 0},
{31354, "GREASE 0x7A7A", 0},
{35466, "GREASE 0x8A8A", 0},
{39578, "GREASE 0x9A9A", 0},
{43690, "GREASE 0xAAAA", 0},
{47802, "GREASE 0xBABA", 0},
{51914, "GREASE 0xCACA", 0},
{56026, "GREASE 0xDADA", 0},
{60138, "GREASE 0xEAEA", 0},
{64250, "GREASE 0xFAFA", 0},
{-1}};
static int decode_AlertLevel_warning(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "alert_level",
json_object_new_string("warning"));
return 0;
}
static int decode_AlertLevel_fatal(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
struct json_object *jobj;
jobj = ssl->cur_json_st;
json_object_object_add(jobj, "alert_level", json_object_new_string("fatal"));
return 0;
}
decoder AlertLevel_decoder[] = {{1, "warning", decode_AlertLevel_warning},
{2, "fatal", decode_AlertLevel_fatal},
{-1}};
static int decode_AlertDescription_close_notify(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_unexpected_message(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_bad_record_mac(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_decryption_failed(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_record_overflow(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_decompression_failure(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_handshake_failure(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_bad_certificate(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_unsupported_certificate(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_certificate_revoked(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_certificate_expired(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_certificate_unknown(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_illegal_parameter(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_unknown_ca(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_access_denied(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_decode_error(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_decrypt_error(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_export_restriction(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_protocol_version(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_insufficient_security(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_internal_error(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_user_canceled(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_AlertDescription_no_renegotiation(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
decoder AlertDescription_decoder[] = {
{0, "close_notify", decode_AlertDescription_close_notify},
{10, "unexpected_message", decode_AlertDescription_unexpected_message},
{20, "bad_record_mac", decode_AlertDescription_bad_record_mac},
{21, "decryption_failed", decode_AlertDescription_decryption_failed},
{22, "record_overflow", decode_AlertDescription_record_overflow},
{30, "decompression_failure",
decode_AlertDescription_decompression_failure},
{40, "handshake_failure", decode_AlertDescription_handshake_failure},
{42, "bad_certificate", decode_AlertDescription_bad_certificate},
{43, "unsupported_certificate",
decode_AlertDescription_unsupported_certificate},
{44, "certificate_revoked", decode_AlertDescription_certificate_revoked},
{45, "certificate_expired", decode_AlertDescription_certificate_expired},
{46, "certificate_unknown", decode_AlertDescription_certificate_unknown},
{47, "illegal_parameter", decode_AlertDescription_illegal_parameter},
{48, "unknown_ca", decode_AlertDescription_unknown_ca},
{49, "access_denied", decode_AlertDescription_access_denied},
{50, "decode_error", decode_AlertDescription_decode_error},
{51, "decrypt_error", decode_AlertDescription_decrypt_error},
{60, "export_restriction", decode_AlertDescription_export_restriction},
{70, "protocol_version", decode_AlertDescription_protocol_version},
{71, "insufficient_security",
decode_AlertDescription_insufficient_security},
{80, "internal_error", decode_AlertDescription_internal_error},
{90, "user_canceled", decode_AlertDescription_user_canceled},
{100, "no_renegotiation", decode_AlertDescription_no_renegotiation},
{-1}};
decoder compression_method_decoder[] = {{0, "NULL", 0}, {-1}};
static int decode_client_certificate_type_rsa_sign(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_client_certificate_type_dss_sign(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_client_certificate_type_rsa_fixed_dh(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
static int decode_client_certificate_type_dss_fixed_dh(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
return 0;
}
decoder client_certificate_type_decoder[] = {
{1, "rsa_sign", decode_client_certificate_type_rsa_sign},
{2, "dss_sign", decode_client_certificate_type_dss_sign},
{3, "rsa_fixed_dh", decode_client_certificate_type_rsa_fixed_dh},
{4, "dss_fixed_dh", decode_client_certificate_type_dss_fixed_dh},
{-1}};
static int decode_extension_server_name(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
UINT4 t, l;
int r, p;
extern decoder server_name_type_decoder[];
SSL_DECODE_UINT16(ssl, "extension length", 0, data, &l);
if(dir == DIR_I2R) {
SSL_DECODE_UINT16(ssl, "server name list length", 0, data, &l);
LF;
while(l) {
p = data->len;
SSL_DECODE_UINT8(ssl, "server name type", 0, data, &t);
if(ssl_decode_switch(ssl, server_name_type_decoder, t, dir, seg, data) ==
R_NOT_FOUND) {
decode_server_name(ssl, dir, seg, data);
P_(P_RH) {
explain(ssl, "Server Name type: %u not yet implemented in ssldump\n",
t);
}
continue;
}
l -= (p - data->len);
}
} else {
data->len -= l;
data->data += l;
}
return 0;
}
static int decode_extension_encrypt_then_mac(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r, *etm;
UINT4 l;
etm = &ssl->extensions->encrypt_then_mac;
SSL_DECODE_UINT16(ssl, "extension length", 0, data, &l);
data->len -= l;
data->data += l;
dir == DIR_I2R ? *etm = 1 : ++*etm;
return 0;
}
static int decode_extension_extended_master_secret(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r, *ems;
UINT4 l;
ems = &ssl->extensions->extended_master_secret;
SSL_DECODE_UINT16(ssl, "extension length", 0, data, &l);
data->len -= l;
data->data += l;
dir == DIR_I2R ? *ems = 1 : ++*ems;
return 0;
}
static int decode_extension(ssl_obj *ssl, int dir, segment *seg, Data *data) {
int r;
UINT4 l;
SSL_DECODE_UINT16(ssl, "extension length", 0, data, &l);
data->len -= l;
data->data += l;
return 0;
}
decoder supported_groups_decoder[] = {
{0x0017, "secp256r1", 0}, {0x0018, "secp384r1", 0},
{0x0019, "secp521r1", 0}, {0x001d, "x25519", 0},
{0x001e, "x448", 0}, {0x0100, "ffdhe2048", 0},
{0x0101, "ffdhe3072", 0}, {0x0102, "ffdhe4096", 0},
{0x0103, "ffdhe6144", 0}, {0x0104, "ffdhe8192", 0},
};
// Extension #10 supported_groups (renamed from "elliptic_curves")
static int decode_extension_supported_groups(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r, p;
UINT4 l, g;
char *ja3_ec_str = NULL;
SSL_DECODE_UINT16(ssl, "extension length", 0, data, &l);
if(dir == DIR_I2R) {
SSL_DECODE_UINT16(ssl, "supported_groups list length", 0, data, &l);
LF;
while(l) {
p = data->len;
SSL_DECODE_ENUM(ssl, "supported group", 2, supported_groups_decoder,
SSL_PRINT_ALL, data, &g);
LF;
if(!ja3_ec_str)
ja3_ec_str = calloc(7, 1);
else
ja3_ec_str = realloc(ja3_ec_str, strlen(ja3_ec_str) + 7);
snprintf(ja3_ec_str + strlen(ja3_ec_str), 7, "%u-", g);
l -= (p - data->len);
}
if(ja3_ec_str && ja3_ec_str[strlen(ja3_ec_str) - 1] == '-')
ja3_ec_str[strlen(ja3_ec_str) - 1] = '\0';
} else {
data->len -= l;
data->data += l;
}
ssl->cur_ja3_ec_str = ja3_ec_str;
return 0;
}
decoder ec_point_formats_decoder[] = {{
0,
"uncompressed",
0,
},
{
1,
"ansiX962_compressed_prime",
0,
},
{
2,
"ansiX962_compressed_char2",
0,
}};
// Extension #11 ec_point_formats
static int decode_extension_ec_point_formats(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r, p;
UINT4 l, f;
char *ja3_ecp_str = NULL;
SSL_DECODE_UINT16(ssl, "extension length", 0, data, &l);
if(dir == DIR_I2R) {
SSL_DECODE_UINT8(ssl, "ec_point_formats list length", 0, data, &l);
LF;
while(l) {
p = data->len;
SSL_DECODE_ENUM(ssl, "ec point format", 1, ec_point_formats_decoder,
SSL_PRINT_ALL, data, &f);
LF;
if(!ja3_ecp_str)
ja3_ecp_str = calloc(5, 1);
else
ja3_ecp_str = realloc(ja3_ecp_str, strlen(ja3_ecp_str) + 5);
snprintf(ja3_ecp_str + strlen(ja3_ecp_str), 5, "%u-", f);
l -= (p - data->len);
}
if(ja3_ecp_str && ja3_ecp_str[strlen(ja3_ecp_str) - 1] == '-')
ja3_ecp_str[strlen(ja3_ecp_str) - 1] = '\0';
} else {
data->len -= l;
data->data += l;
}
ssl->cur_ja3_ecp_str = ja3_ecp_str;
return 0;
}
static int decode_extension_supported_versions(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r;
UINT4 len, version;
SSL_DECODE_UINT16(ssl, "extensions length", 0, data, &len);
LF;
if(dir == DIR_I2R)
SSL_DECODE_UINT8(ssl, "supported versions length", 0, data,
&len); // client sends extension<..>
while(len) {
SSL_DECODE_UINT16(ssl, "supported version", 0, data, &version);
explain(ssl, "version: %u.%u", (version >> 8) & 0xff, version & 0xff);
len -= 2;
if(len)
printf("\n");
}
if(dir == DIR_R2I)
ssl->version = version; // Server sets the tls version
return 0;
}
decoder tls13_certificate_types[] = {{0, "x509", 0},
{1, "openpgp", 0},
{2, "raw public key", 0},
{3, "1609 dot 2", 0}};
static int decode_extension_client_certificate_type(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r;
UINT4 len, certificate_type;
SSL_DECODE_UINT16(ssl, "extensions length", 0, data, &len);
LF;
if(dir == DIR_I2R)
SSL_DECODE_UINT8(ssl, "client certificates length", 0, data,
&len); // client sends certificates<..>
while(len) {
SSL_DECODE_ENUM(ssl, "certificate type", 1, tls13_certificate_types,
SSL_PRINT_ALL, data, &certificate_type);
len -= 1;
data += 1;
if(len)
printf("\n");
}
if(dir == DIR_R2I)
ssl->extensions->client_certificate_type =
certificate_type; // Server sets the client_certificate_type
return 0;
}
static int decode_extension_server_certificate_type(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r;
UINT4 len, certificate_type;
SSL_DECODE_UINT16(ssl, "extensions length", 0, data, &len);
LF;
if(dir == DIR_I2R)
SSL_DECODE_UINT8(ssl, "server certificates length", 0, data,
&len); // client sends certificates<..>
while(len) {
SSL_DECODE_ENUM(ssl, "certificate type", 1, tls13_certificate_types,
SSL_PRINT_ALL, data, &certificate_type);
len -= 1;
data += 1;
if(len)
printf("\n");
}
if(dir == DIR_R2I)
ssl->extensions->server_certificate_type =
certificate_type; // Server sets the server_certificate_type
return 0;
}
decoder extension_decoder[] = {
{
0,
"server_name",
decode_extension_server_name,
},
{1, "max_fragment_length", decode_extension},
{2, "client_certificate_url", decode_extension},
{3, "trusted_ca_keys", decode_extension},
{4, "truncated_hmac", decode_extension},
{5, "status_request", decode_extension},
{6, "user_mapping", decode_extension},
{7, "client_authz", decode_extension},
{8, "server_authz", decode_extension},
{9, "cert_type", decode_extension},
{10, "supported_groups", decode_extension_supported_groups},
{11, "ec_point_formats", decode_extension_ec_point_formats},
{12, "srp", decode_extension},
{13, "signature_algorithms", decode_extension},
{14, "use_srtp", decode_extension},
{15, "heartbeat", decode_extension},
{16, "application_layer_protocol_negotiation", decode_extension},
{17, "status_request_v2", decode_extension},
{18, "signed_certificate_timestamp", decode_extension},
{19, "client_certificate_type", decode_extension_client_certificate_type},
{20, "server_certificate_type", decode_extension_server_certificate_type},
{21, "padding", decode_extension},
{22, "encrypt_then_mac", decode_extension_encrypt_then_mac},
{23, "extended_master_secret", decode_extension_extended_master_secret},
{24, "token_binding", decode_extension},
{25, "cached_info", decode_extension},
{26, "tls_lts", decode_extension},
{27, "compress_certificate", decode_extension},
{28, "record_size_limit", decode_extension},
{29, "pwd_protect", decode_extension},
{30, "pwd_clear", decode_extension},
{31, "password_salt", decode_extension},
{32, "ticket_pinning", decode_extension},
{33, "tls_cert_with_extern_psk", decode_extension},
{34, "delegated_credentials", decode_extension},
{35, "session_ticket", decode_extension},
{36, "TLMSP", decode_extension},
{37, "TLMSP_proxying", decode_extension},
{38, "TLMSP_delegate", decode_extension},
{39, "supported_ekt_ciphers", decode_extension},
{41, "pre_shared_key", decode_extension},
{42, "early_data", decode_extension},
{43, "supported_versions", decode_extension_supported_versions},
{44, "cookie", decode_extension},
{45, "psk_key_exchange_modes", decode_extension},
{47, "certificate_authorities", decode_extension},
{48, "oid_filters", decode_extension},
{49, "post_handshake_auth", decode_extension},
{50, "signature_algorithms_cert", decode_extension},
{51, "key_share", decode_extension},
{52, "transparency_info", decode_extension},
{53, "connection_id", decode_extension},
{55, "external_id_hash", decode_extension},
{56, "external_session_id", decode_extension},
{13172, "next_protocol_negotiation", decode_extension},
{0xfe0d, "encrypted_client_hello", decode_extension},
{0xff01, "renegotiation_info", decode_extension},
{-1}};
static int decode_server_name_type_host_name(ssl_obj *ssl,
int dir,
segment *seg,
Data *data) {
int r;
UINT4 l;
SSL_DECODE_UINT16(ssl, "server name length", 0, data, &l);
if(!(NET_print_flags & NET_PRINT_JSON))
printf(": %.*s", l, data->data);
/* Possibly use data->data to set/modify ssl->server_name */
if(l != 0) {
char *server_name;
server_name = calloc(l + 1, sizeof(char));
if(server_name != NULL) {
if(ssl->server_name)
free(ssl->server_name);
if(l > data->len)
l = data->len;
memcpy(server_name, data->data, l);
ssl->server_name = server_name;
}
}
data->len -= l;
data->data += l;
return 0;
}
static int decode_server_name(ssl_obj *ssl, int dir, segment *seg, Data *data) {
int r;
UINT4 l;
SSL_DECODE_UINT16(ssl, "server name length", 0, data, &l);
data->len -= l;
data->data += l;
return 0;
}
decoder server_name_type_decoder[] = {
{0, "host_name", decode_server_name_type_host_name},
{-1}};
Reference in a new issue View git blame Copy permalink