1 /* 2 * Copyright 2012-2020 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the OpenSSL license (the "License"). You may not use 5 * this file except in compliance with the License. You can obtain a copy 6 * in the file LICENSE in the source distribution or at 7 * https://www.openssl.org/source/license.html 8 */ 9 10 #include "ssl_local.h" 11 12 #ifndef OPENSSL_NO_SSL_TRACE 13 14 /* Packet trace support for OpenSSL */ 15 16 typedef struct { 17 int num; 18 const char *name; 19 } ssl_trace_tbl; 20 21 # define ssl_trace_str(val, tbl) \ 22 do_ssl_trace_str(val, tbl, OSSL_NELEM(tbl)) 23 24 # define ssl_trace_list(bio, indent, msg, msglen, value, table) \ 25 do_ssl_trace_list(bio, indent, msg, msglen, value, \ 26 table, OSSL_NELEM(table)) 27 28 static const char *do_ssl_trace_str(int val, const ssl_trace_tbl *tbl, 29 size_t ntbl) 30 { 31 size_t i; 32 33 for (i = 0; i < ntbl; i++, tbl++) { 34 if (tbl->num == val) 35 return tbl->name; 36 } 37 return "UNKNOWN"; 38 } 39 40 static int do_ssl_trace_list(BIO *bio, int indent, 41 const unsigned char *msg, size_t msglen, 42 size_t vlen, const ssl_trace_tbl *tbl, size_t ntbl) 43 { 44 int val; 45 46 if (msglen % vlen) 47 return 0; 48 while (msglen) { 49 val = msg[0]; 50 if (vlen == 2) 51 val = (val << 8) | msg[1]; 52 BIO_indent(bio, indent, 80); 53 BIO_printf(bio, "%s (%d)\n", do_ssl_trace_str(val, tbl, ntbl), val); 54 msg += vlen; 55 msglen -= vlen; 56 } 57 return 1; 58 } 59 60 /* Version number */ 61 62 static const ssl_trace_tbl ssl_version_tbl[] = { 63 {SSL3_VERSION, "SSL 3.0"}, 64 {TLS1_VERSION, "TLS 1.0"}, 65 {TLS1_1_VERSION, "TLS 1.1"}, 66 {TLS1_2_VERSION, "TLS 1.2"}, 67 {TLS1_3_VERSION, "TLS 1.3"}, 68 {DTLS1_VERSION, "DTLS 1.0"}, 69 {DTLS1_2_VERSION, "DTLS 1.2"}, 70 {DTLS1_BAD_VER, "DTLS 1.0 (bad)"} 71 }; 72 73 static const ssl_trace_tbl ssl_content_tbl[] = { 74 {SSL3_RT_CHANGE_CIPHER_SPEC, "ChangeCipherSpec"}, 75 {SSL3_RT_ALERT, "Alert"}, 76 {SSL3_RT_HANDSHAKE, "Handshake"}, 77 {SSL3_RT_APPLICATION_DATA, "ApplicationData"}, 78 }; 79 80 /* Handshake types, sorted by ascending id */ 81 static const ssl_trace_tbl ssl_handshake_tbl[] = { 82 {SSL3_MT_HELLO_REQUEST, "HelloRequest"}, 83 {SSL3_MT_CLIENT_HELLO, "ClientHello"}, 84 {SSL3_MT_SERVER_HELLO, "ServerHello"}, 85 {DTLS1_MT_HELLO_VERIFY_REQUEST, "HelloVerifyRequest"}, 86 {SSL3_MT_NEWSESSION_TICKET, "NewSessionTicket"}, 87 {SSL3_MT_END_OF_EARLY_DATA, "EndOfEarlyData"}, 88 {SSL3_MT_ENCRYPTED_EXTENSIONS, "EncryptedExtensions"}, 89 {SSL3_MT_CERTIFICATE, "Certificate"}, 90 {SSL3_MT_SERVER_KEY_EXCHANGE, "ServerKeyExchange"}, 91 {SSL3_MT_CERTIFICATE_REQUEST, "CertificateRequest"}, 92 {SSL3_MT_SERVER_DONE, "ServerHelloDone"}, 93 {SSL3_MT_CERTIFICATE_VERIFY, "CertificateVerify"}, 94 {SSL3_MT_CLIENT_KEY_EXCHANGE, "ClientKeyExchange"}, 95 {SSL3_MT_FINISHED, "Finished"}, 96 {SSL3_MT_CERTIFICATE_URL, "CertificateUrl"}, 97 {SSL3_MT_CERTIFICATE_STATUS, "CertificateStatus"}, 98 {SSL3_MT_SUPPLEMENTAL_DATA, "SupplementalData"}, 99 {SSL3_MT_KEY_UPDATE, "KeyUpdate"}, 100 # ifndef OPENSSL_NO_NEXTPROTONEG 101 {SSL3_MT_NEXT_PROTO, "NextProto"}, 102 # endif 103 {SSL3_MT_MESSAGE_HASH, "MessageHash"} 104 }; 105 106 /* Cipher suites */ 107 static const ssl_trace_tbl ssl_ciphers_tbl[] = { 108 {0x0000, "TLS_NULL_WITH_NULL_NULL"}, 109 {0x0001, "TLS_RSA_WITH_NULL_MD5"}, 110 {0x0002, "TLS_RSA_WITH_NULL_SHA"}, 111 {0x0003, "TLS_RSA_EXPORT_WITH_RC4_40_MD5"}, 112 {0x0004, "TLS_RSA_WITH_RC4_128_MD5"}, 113 {0x0005, "TLS_RSA_WITH_RC4_128_SHA"}, 114 {0x0006, "TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5"}, 115 {0x0007, "TLS_RSA_WITH_IDEA_CBC_SHA"}, 116 {0x0008, "TLS_RSA_EXPORT_WITH_DES40_CBC_SHA"}, 117 {0x0009, "TLS_RSA_WITH_DES_CBC_SHA"}, 118 {0x000A, "TLS_RSA_WITH_3DES_EDE_CBC_SHA"}, 119 {0x000B, "TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA"}, 120 {0x000C, "TLS_DH_DSS_WITH_DES_CBC_SHA"}, 121 {0x000D, "TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA"}, 122 {0x000E, "TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA"}, 123 {0x000F, "TLS_DH_RSA_WITH_DES_CBC_SHA"}, 124 {0x0010, "TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA"}, 125 {0x0011, "TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA"}, 126 {0x0012, "TLS_DHE_DSS_WITH_DES_CBC_SHA"}, 127 {0x0013, "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA"}, 128 {0x0014, "TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA"}, 129 {0x0015, "TLS_DHE_RSA_WITH_DES_CBC_SHA"}, 130 {0x0016, "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA"}, 131 {0x0017, "TLS_DH_anon_EXPORT_WITH_RC4_40_MD5"}, 132 {0x0018, "TLS_DH_anon_WITH_RC4_128_MD5"}, 133 {0x0019, "TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA"}, 134 {0x001A, "TLS_DH_anon_WITH_DES_CBC_SHA"}, 135 {0x001B, "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA"}, 136 {0x001D, "SSL_FORTEZZA_KEA_WITH_FORTEZZA_CBC_SHA"}, 137 {0x001E, "SSL_FORTEZZA_KEA_WITH_RC4_128_SHA"}, 138 {0x001F, "TLS_KRB5_WITH_3DES_EDE_CBC_SHA"}, 139 {0x0020, "TLS_KRB5_WITH_RC4_128_SHA"}, 140 {0x0021, "TLS_KRB5_WITH_IDEA_CBC_SHA"}, 141 {0x0022, "TLS_KRB5_WITH_DES_CBC_MD5"}, 142 {0x0023, "TLS_KRB5_WITH_3DES_EDE_CBC_MD5"}, 143 {0x0024, "TLS_KRB5_WITH_RC4_128_MD5"}, 144 {0x0025, "TLS_KRB5_WITH_IDEA_CBC_MD5"}, 145 {0x0026, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA"}, 146 {0x0027, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA"}, 147 {0x0028, "TLS_KRB5_EXPORT_WITH_RC4_40_SHA"}, 148 {0x0029, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5"}, 149 {0x002A, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5"}, 150 {0x002B, "TLS_KRB5_EXPORT_WITH_RC4_40_MD5"}, 151 {0x002C, "TLS_PSK_WITH_NULL_SHA"}, 152 {0x002D, "TLS_DHE_PSK_WITH_NULL_SHA"}, 153 {0x002E, "TLS_RSA_PSK_WITH_NULL_SHA"}, 154 {0x002F, "TLS_RSA_WITH_AES_128_CBC_SHA"}, 155 {0x0030, "TLS_DH_DSS_WITH_AES_128_CBC_SHA"}, 156 {0x0031, "TLS_DH_RSA_WITH_AES_128_CBC_SHA"}, 157 {0x0032, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA"}, 158 {0x0033, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"}, 159 {0x0034, "TLS_DH_anon_WITH_AES_128_CBC_SHA"}, 160 {0x0035, "TLS_RSA_WITH_AES_256_CBC_SHA"}, 161 {0x0036, "TLS_DH_DSS_WITH_AES_256_CBC_SHA"}, 162 {0x0037, "TLS_DH_RSA_WITH_AES_256_CBC_SHA"}, 163 {0x0038, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA"}, 164 {0x0039, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"}, 165 {0x003A, "TLS_DH_anon_WITH_AES_256_CBC_SHA"}, 166 {0x003B, "TLS_RSA_WITH_NULL_SHA256"}, 167 {0x003C, "TLS_RSA_WITH_AES_128_CBC_SHA256"}, 168 {0x003D, "TLS_RSA_WITH_AES_256_CBC_SHA256"}, 169 {0x003E, "TLS_DH_DSS_WITH_AES_128_CBC_SHA256"}, 170 {0x003F, "TLS_DH_RSA_WITH_AES_128_CBC_SHA256"}, 171 {0x0040, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256"}, 172 {0x0041, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA"}, 173 {0x0042, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA"}, 174 {0x0043, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA"}, 175 {0x0044, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA"}, 176 {0x0045, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA"}, 177 {0x0046, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA"}, 178 {0x0067, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"}, 179 {0x0068, "TLS_DH_DSS_WITH_AES_256_CBC_SHA256"}, 180 {0x0069, "TLS_DH_RSA_WITH_AES_256_CBC_SHA256"}, 181 {0x006A, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"}, 182 {0x006B, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"}, 183 {0x006C, "TLS_DH_anon_WITH_AES_128_CBC_SHA256"}, 184 {0x006D, "TLS_DH_anon_WITH_AES_256_CBC_SHA256"}, 185 {0x0081, "TLS_GOSTR341001_WITH_28147_CNT_IMIT"}, 186 {0x0083, "TLS_GOSTR341001_WITH_NULL_GOSTR3411"}, 187 {0x0084, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA"}, 188 {0x0085, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA"}, 189 {0x0086, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA"}, 190 {0x0087, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA"}, 191 {0x0088, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA"}, 192 {0x0089, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA"}, 193 {0x008A, "TLS_PSK_WITH_RC4_128_SHA"}, 194 {0x008B, "TLS_PSK_WITH_3DES_EDE_CBC_SHA"}, 195 {0x008C, "TLS_PSK_WITH_AES_128_CBC_SHA"}, 196 {0x008D, "TLS_PSK_WITH_AES_256_CBC_SHA"}, 197 {0x008E, "TLS_DHE_PSK_WITH_RC4_128_SHA"}, 198 {0x008F, "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA"}, 199 {0x0090, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA"}, 200 {0x0091, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA"}, 201 {0x0092, "TLS_RSA_PSK_WITH_RC4_128_SHA"}, 202 {0x0093, "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA"}, 203 {0x0094, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA"}, 204 {0x0095, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA"}, 205 {0x0096, "TLS_RSA_WITH_SEED_CBC_SHA"}, 206 {0x0097, "TLS_DH_DSS_WITH_SEED_CBC_SHA"}, 207 {0x0098, "TLS_DH_RSA_WITH_SEED_CBC_SHA"}, 208 {0x0099, "TLS_DHE_DSS_WITH_SEED_CBC_SHA"}, 209 {0x009A, "TLS_DHE_RSA_WITH_SEED_CBC_SHA"}, 210 {0x009B, "TLS_DH_anon_WITH_SEED_CBC_SHA"}, 211 {0x009C, "TLS_RSA_WITH_AES_128_GCM_SHA256"}, 212 {0x009D, "TLS_RSA_WITH_AES_256_GCM_SHA384"}, 213 {0x009E, "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"}, 214 {0x009F, "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"}, 215 {0x00A0, "TLS_DH_RSA_WITH_AES_128_GCM_SHA256"}, 216 {0x00A1, "TLS_DH_RSA_WITH_AES_256_GCM_SHA384"}, 217 {0x00A2, "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256"}, 218 {0x00A3, "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384"}, 219 {0x00A4, "TLS_DH_DSS_WITH_AES_128_GCM_SHA256"}, 220 {0x00A5, "TLS_DH_DSS_WITH_AES_256_GCM_SHA384"}, 221 {0x00A6, "TLS_DH_anon_WITH_AES_128_GCM_SHA256"}, 222 {0x00A7, "TLS_DH_anon_WITH_AES_256_GCM_SHA384"}, 223 {0x00A8, "TLS_PSK_WITH_AES_128_GCM_SHA256"}, 224 {0x00A9, "TLS_PSK_WITH_AES_256_GCM_SHA384"}, 225 {0x00AA, "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256"}, 226 {0x00AB, "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384"}, 227 {0x00AC, "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256"}, 228 {0x00AD, "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384"}, 229 {0x00AE, "TLS_PSK_WITH_AES_128_CBC_SHA256"}, 230 {0x00AF, "TLS_PSK_WITH_AES_256_CBC_SHA384"}, 231 {0x00B0, "TLS_PSK_WITH_NULL_SHA256"}, 232 {0x00B1, "TLS_PSK_WITH_NULL_SHA384"}, 233 {0x00B2, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256"}, 234 {0x00B3, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384"}, 235 {0x00B4, "TLS_DHE_PSK_WITH_NULL_SHA256"}, 236 {0x00B5, "TLS_DHE_PSK_WITH_NULL_SHA384"}, 237 {0x00B6, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256"}, 238 {0x00B7, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384"}, 239 {0x00B8, "TLS_RSA_PSK_WITH_NULL_SHA256"}, 240 {0x00B9, "TLS_RSA_PSK_WITH_NULL_SHA384"}, 241 {0x00BA, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, 242 {0x00BB, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256"}, 243 {0x00BC, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, 244 {0x00BD, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256"}, 245 {0x00BE, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, 246 {0x00BF, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256"}, 247 {0x00C0, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256"}, 248 {0x00C1, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256"}, 249 {0x00C2, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256"}, 250 {0x00C3, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256"}, 251 {0x00C4, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256"}, 252 {0x00C5, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256"}, 253 {0x00FF, "TLS_EMPTY_RENEGOTIATION_INFO_SCSV"}, 254 {0x5600, "TLS_FALLBACK_SCSV"}, 255 {0xC001, "TLS_ECDH_ECDSA_WITH_NULL_SHA"}, 256 {0xC002, "TLS_ECDH_ECDSA_WITH_RC4_128_SHA"}, 257 {0xC003, "TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA"}, 258 {0xC004, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA"}, 259 {0xC005, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA"}, 260 {0xC006, "TLS_ECDHE_ECDSA_WITH_NULL_SHA"}, 261 {0xC007, "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA"}, 262 {0xC008, "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"}, 263 {0xC009, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"}, 264 {0xC00A, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"}, 265 {0xC00B, "TLS_ECDH_RSA_WITH_NULL_SHA"}, 266 {0xC00C, "TLS_ECDH_RSA_WITH_RC4_128_SHA"}, 267 {0xC00D, "TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA"}, 268 {0xC00E, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA"}, 269 {0xC00F, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA"}, 270 {0xC010, "TLS_ECDHE_RSA_WITH_NULL_SHA"}, 271 {0xC011, "TLS_ECDHE_RSA_WITH_RC4_128_SHA"}, 272 {0xC012, "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"}, 273 {0xC013, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"}, 274 {0xC014, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"}, 275 {0xC015, "TLS_ECDH_anon_WITH_NULL_SHA"}, 276 {0xC016, "TLS_ECDH_anon_WITH_RC4_128_SHA"}, 277 {0xC017, "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA"}, 278 {0xC018, "TLS_ECDH_anon_WITH_AES_128_CBC_SHA"}, 279 {0xC019, "TLS_ECDH_anon_WITH_AES_256_CBC_SHA"}, 280 {0xC01A, "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA"}, 281 {0xC01B, "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA"}, 282 {0xC01C, "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA"}, 283 {0xC01D, "TLS_SRP_SHA_WITH_AES_128_CBC_SHA"}, 284 {0xC01E, "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA"}, 285 {0xC01F, "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA"}, 286 {0xC020, "TLS_SRP_SHA_WITH_AES_256_CBC_SHA"}, 287 {0xC021, "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA"}, 288 {0xC022, "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA"}, 289 {0xC023, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"}, 290 {0xC024, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"}, 291 {0xC025, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256"}, 292 {0xC026, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384"}, 293 {0xC027, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"}, 294 {0xC028, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"}, 295 {0xC029, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256"}, 296 {0xC02A, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384"}, 297 {0xC02B, "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"}, 298 {0xC02C, "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"}, 299 {0xC02D, "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256"}, 300 {0xC02E, "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384"}, 301 {0xC02F, "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"}, 302 {0xC030, "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"}, 303 {0xC031, "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256"}, 304 {0xC032, "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384"}, 305 {0xC033, "TLS_ECDHE_PSK_WITH_RC4_128_SHA"}, 306 {0xC034, "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA"}, 307 {0xC035, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA"}, 308 {0xC036, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA"}, 309 {0xC037, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256"}, 310 {0xC038, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384"}, 311 {0xC039, "TLS_ECDHE_PSK_WITH_NULL_SHA"}, 312 {0xC03A, "TLS_ECDHE_PSK_WITH_NULL_SHA256"}, 313 {0xC03B, "TLS_ECDHE_PSK_WITH_NULL_SHA384"}, 314 {0xC03C, "TLS_RSA_WITH_ARIA_128_CBC_SHA256"}, 315 {0xC03D, "TLS_RSA_WITH_ARIA_256_CBC_SHA384"}, 316 {0xC03E, "TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256"}, 317 {0xC03F, "TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384"}, 318 {0xC040, "TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256"}, 319 {0xC041, "TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384"}, 320 {0xC042, "TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256"}, 321 {0xC043, "TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384"}, 322 {0xC044, "TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256"}, 323 {0xC045, "TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384"}, 324 {0xC046, "TLS_DH_anon_WITH_ARIA_128_CBC_SHA256"}, 325 {0xC047, "TLS_DH_anon_WITH_ARIA_256_CBC_SHA384"}, 326 {0xC048, "TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256"}, 327 {0xC049, "TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384"}, 328 {0xC04A, "TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256"}, 329 {0xC04B, "TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384"}, 330 {0xC04C, "TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256"}, 331 {0xC04D, "TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384"}, 332 {0xC04E, "TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256"}, 333 {0xC04F, "TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384"}, 334 {0xC050, "TLS_RSA_WITH_ARIA_128_GCM_SHA256"}, 335 {0xC051, "TLS_RSA_WITH_ARIA_256_GCM_SHA384"}, 336 {0xC052, "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256"}, 337 {0xC053, "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384"}, 338 {0xC054, "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256"}, 339 {0xC055, "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384"}, 340 {0xC056, "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256"}, 341 {0xC057, "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384"}, 342 {0xC058, "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256"}, 343 {0xC059, "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384"}, 344 {0xC05A, "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256"}, 345 {0xC05B, "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384"}, 346 {0xC05C, "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256"}, 347 {0xC05D, "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384"}, 348 {0xC05E, "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256"}, 349 {0xC05F, "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384"}, 350 {0xC060, "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256"}, 351 {0xC061, "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384"}, 352 {0xC062, "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256"}, 353 {0xC063, "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384"}, 354 {0xC064, "TLS_PSK_WITH_ARIA_128_CBC_SHA256"}, 355 {0xC065, "TLS_PSK_WITH_ARIA_256_CBC_SHA384"}, 356 {0xC066, "TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256"}, 357 {0xC067, "TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384"}, 358 {0xC068, "TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256"}, 359 {0xC069, "TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384"}, 360 {0xC06A, "TLS_PSK_WITH_ARIA_128_GCM_SHA256"}, 361 {0xC06B, "TLS_PSK_WITH_ARIA_256_GCM_SHA384"}, 362 {0xC06C, "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256"}, 363 {0xC06D, "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384"}, 364 {0xC06E, "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256"}, 365 {0xC06F, "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384"}, 366 {0xC070, "TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256"}, 367 {0xC071, "TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384"}, 368 {0xC072, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"}, 369 {0xC073, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"}, 370 {0xC074, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"}, 371 {0xC075, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"}, 372 {0xC076, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, 373 {0xC077, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384"}, 374 {0xC078, "TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, 375 {0xC079, "TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384"}, 376 {0xC07A, "TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, 377 {0xC07B, "TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, 378 {0xC07C, "TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, 379 {0xC07D, "TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, 380 {0xC07E, "TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, 381 {0xC07F, "TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, 382 {0xC080, "TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256"}, 383 {0xC081, "TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384"}, 384 {0xC082, "TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256"}, 385 {0xC083, "TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384"}, 386 {0xC084, "TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256"}, 387 {0xC085, "TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384"}, 388 {0xC086, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256"}, 389 {0xC087, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384"}, 390 {0xC088, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256"}, 391 {0xC089, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384"}, 392 {0xC08A, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, 393 {0xC08B, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, 394 {0xC08C, "TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, 395 {0xC08D, "TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, 396 {0xC08E, "TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256"}, 397 {0xC08F, "TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384"}, 398 {0xC090, "TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256"}, 399 {0xC091, "TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384"}, 400 {0xC092, "TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256"}, 401 {0xC093, "TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384"}, 402 {0xC094, "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256"}, 403 {0xC095, "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384"}, 404 {0xC096, "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"}, 405 {0xC097, "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"}, 406 {0xC098, "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256"}, 407 {0xC099, "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384"}, 408 {0xC09A, "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"}, 409 {0xC09B, "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"}, 410 {0xC09C, "TLS_RSA_WITH_AES_128_CCM"}, 411 {0xC09D, "TLS_RSA_WITH_AES_256_CCM"}, 412 {0xC09E, "TLS_DHE_RSA_WITH_AES_128_CCM"}, 413 {0xC09F, "TLS_DHE_RSA_WITH_AES_256_CCM"}, 414 {0xC0A0, "TLS_RSA_WITH_AES_128_CCM_8"}, 415 {0xC0A1, "TLS_RSA_WITH_AES_256_CCM_8"}, 416 {0xC0A2, "TLS_DHE_RSA_WITH_AES_128_CCM_8"}, 417 {0xC0A3, "TLS_DHE_RSA_WITH_AES_256_CCM_8"}, 418 {0xC0A4, "TLS_PSK_WITH_AES_128_CCM"}, 419 {0xC0A5, "TLS_PSK_WITH_AES_256_CCM"}, 420 {0xC0A6, "TLS_DHE_PSK_WITH_AES_128_CCM"}, 421 {0xC0A7, "TLS_DHE_PSK_WITH_AES_256_CCM"}, 422 {0xC0A8, "TLS_PSK_WITH_AES_128_CCM_8"}, 423 {0xC0A9, "TLS_PSK_WITH_AES_256_CCM_8"}, 424 {0xC0AA, "TLS_PSK_DHE_WITH_AES_128_CCM_8"}, 425 {0xC0AB, "TLS_PSK_DHE_WITH_AES_256_CCM_8"}, 426 {0xC0AC, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM"}, 427 {0xC0AD, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM"}, 428 {0xC0AE, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8"}, 429 {0xC0AF, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8"}, 430 {0xCCA8, "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"}, 431 {0xCCA9, "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"}, 432 {0xCCAA, "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256"}, 433 {0xCCAB, "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256"}, 434 {0xCCAC, "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256"}, 435 {0xCCAD, "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256"}, 436 {0xCCAE, "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256"}, 437 {0x1301, "TLS_AES_128_GCM_SHA256"}, 438 {0x1302, "TLS_AES_256_GCM_SHA384"}, 439 {0x1303, "TLS_CHACHA20_POLY1305_SHA256"}, 440 {0x1304, "TLS_AES_128_CCM_SHA256"}, 441 {0x1305, "TLS_AES_128_CCM_8_SHA256"}, 442 {0xFEFE, "SSL_RSA_FIPS_WITH_DES_CBC_SHA"}, 443 {0xFEFF, "SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA"}, 444 {0xFF85, "GOST2012-GOST8912-GOST8912"}, 445 {0xFF87, "GOST2012-NULL-GOST12"}, 446 }; 447 448 /* Compression methods */ 449 static const ssl_trace_tbl ssl_comp_tbl[] = { 450 {0x0000, "No Compression"}, 451 {0x0001, "Zlib Compression"} 452 }; 453 454 /* Extensions sorted by ascending id */ 455 static const ssl_trace_tbl ssl_exts_tbl[] = { 456 {TLSEXT_TYPE_server_name, "server_name"}, 457 {TLSEXT_TYPE_max_fragment_length, "max_fragment_length"}, 458 {TLSEXT_TYPE_client_certificate_url, "client_certificate_url"}, 459 {TLSEXT_TYPE_trusted_ca_keys, "trusted_ca_keys"}, 460 {TLSEXT_TYPE_truncated_hmac, "truncated_hmac"}, 461 {TLSEXT_TYPE_status_request, "status_request"}, 462 {TLSEXT_TYPE_user_mapping, "user_mapping"}, 463 {TLSEXT_TYPE_client_authz, "client_authz"}, 464 {TLSEXT_TYPE_server_authz, "server_authz"}, 465 {TLSEXT_TYPE_cert_type, "cert_type"}, 466 {TLSEXT_TYPE_supported_groups, "supported_groups"}, 467 {TLSEXT_TYPE_ec_point_formats, "ec_point_formats"}, 468 {TLSEXT_TYPE_srp, "srp"}, 469 {TLSEXT_TYPE_signature_algorithms, "signature_algorithms"}, 470 {TLSEXT_TYPE_use_srtp, "use_srtp"}, 471 {TLSEXT_TYPE_heartbeat, "tls_heartbeat"}, 472 {TLSEXT_TYPE_application_layer_protocol_negotiation, 473 "application_layer_protocol_negotiation"}, 474 {TLSEXT_TYPE_signed_certificate_timestamp, "signed_certificate_timestamps"}, 475 {TLSEXT_TYPE_padding, "padding"}, 476 {TLSEXT_TYPE_encrypt_then_mac, "encrypt_then_mac"}, 477 {TLSEXT_TYPE_extended_master_secret, "extended_master_secret"}, 478 {TLSEXT_TYPE_session_ticket, "session_ticket"}, 479 {TLSEXT_TYPE_psk, "psk"}, 480 {TLSEXT_TYPE_early_data, "early_data"}, 481 {TLSEXT_TYPE_supported_versions, "supported_versions"}, 482 {TLSEXT_TYPE_cookie, "cookie_ext"}, 483 {TLSEXT_TYPE_psk_kex_modes, "psk_key_exchange_modes"}, 484 {TLSEXT_TYPE_certificate_authorities, "certificate_authorities"}, 485 {TLSEXT_TYPE_post_handshake_auth, "post_handshake_auth"}, 486 {TLSEXT_TYPE_signature_algorithms_cert, "signature_algorithms_cert"}, 487 {TLSEXT_TYPE_key_share, "key_share"}, 488 {TLSEXT_TYPE_renegotiate, "renegotiate"}, 489 # ifndef OPENSSL_NO_NEXTPROTONEG 490 {TLSEXT_TYPE_next_proto_neg, "next_proto_neg"}, 491 # endif 492 }; 493 494 static const ssl_trace_tbl ssl_groups_tbl[] = { 495 {1, "sect163k1 (K-163)"}, 496 {2, "sect163r1"}, 497 {3, "sect163r2 (B-163)"}, 498 {4, "sect193r1"}, 499 {5, "sect193r2"}, 500 {6, "sect233k1 (K-233)"}, 501 {7, "sect233r1 (B-233)"}, 502 {8, "sect239k1"}, 503 {9, "sect283k1 (K-283)"}, 504 {10, "sect283r1 (B-283)"}, 505 {11, "sect409k1 (K-409)"}, 506 {12, "sect409r1 (B-409)"}, 507 {13, "sect571k1 (K-571)"}, 508 {14, "sect571r1 (B-571)"}, 509 {15, "secp160k1"}, 510 {16, "secp160r1"}, 511 {17, "secp160r2"}, 512 {18, "secp192k1"}, 513 {19, "secp192r1 (P-192)"}, 514 {20, "secp224k1"}, 515 {21, "secp224r1 (P-224)"}, 516 {22, "secp256k1"}, 517 {23, "secp256r1 (P-256)"}, 518 {24, "secp384r1 (P-384)"}, 519 {25, "secp521r1 (P-521)"}, 520 {26, "brainpoolP256r1"}, 521 {27, "brainpoolP384r1"}, 522 {28, "brainpoolP512r1"}, 523 {29, "ecdh_x25519"}, 524 {30, "ecdh_x448"}, 525 {256, "ffdhe2048"}, 526 {257, "ffdhe3072"}, 527 {258, "ffdhe4096"}, 528 {259, "ffdhe6144"}, 529 {260, "ffdhe8192"}, 530 {0xFF01, "arbitrary_explicit_prime_curves"}, 531 {0xFF02, "arbitrary_explicit_char2_curves"} 532 }; 533 534 static const ssl_trace_tbl ssl_point_tbl[] = { 535 {0, "uncompressed"}, 536 {1, "ansiX962_compressed_prime"}, 537 {2, "ansiX962_compressed_char2"} 538 }; 539 540 static const ssl_trace_tbl ssl_mfl_tbl[] = { 541 {0, "disabled"}, 542 {1, "max_fragment_length := 2^9 (512 bytes)"}, 543 {2, "max_fragment_length := 2^10 (1024 bytes)"}, 544 {3, "max_fragment_length := 2^11 (2048 bytes)"}, 545 {4, "max_fragment_length := 2^12 (4096 bytes)"} 546 }; 547 548 static const ssl_trace_tbl ssl_sigalg_tbl[] = { 549 {TLSEXT_SIGALG_ecdsa_secp256r1_sha256, "ecdsa_secp256r1_sha256"}, 550 {TLSEXT_SIGALG_ecdsa_secp384r1_sha384, "ecdsa_secp384r1_sha384"}, 551 {TLSEXT_SIGALG_ecdsa_secp521r1_sha512, "ecdsa_secp521r1_sha512"}, 552 {TLSEXT_SIGALG_ecdsa_sha224, "ecdsa_sha224"}, 553 {TLSEXT_SIGALG_ed25519, "ed25519"}, 554 {TLSEXT_SIGALG_ed448, "ed448"}, 555 {TLSEXT_SIGALG_ecdsa_sha1, "ecdsa_sha1"}, 556 {TLSEXT_SIGALG_rsa_pss_rsae_sha256, "rsa_pss_rsae_sha256"}, 557 {TLSEXT_SIGALG_rsa_pss_rsae_sha384, "rsa_pss_rsae_sha384"}, 558 {TLSEXT_SIGALG_rsa_pss_rsae_sha512, "rsa_pss_rsae_sha512"}, 559 {TLSEXT_SIGALG_rsa_pss_pss_sha256, "rsa_pss_pss_sha256"}, 560 {TLSEXT_SIGALG_rsa_pss_pss_sha384, "rsa_pss_pss_sha384"}, 561 {TLSEXT_SIGALG_rsa_pss_pss_sha512, "rsa_pss_pss_sha512"}, 562 {TLSEXT_SIGALG_rsa_pkcs1_sha256, "rsa_pkcs1_sha256"}, 563 {TLSEXT_SIGALG_rsa_pkcs1_sha384, "rsa_pkcs1_sha384"}, 564 {TLSEXT_SIGALG_rsa_pkcs1_sha512, "rsa_pkcs1_sha512"}, 565 {TLSEXT_SIGALG_rsa_pkcs1_sha224, "rsa_pkcs1_sha224"}, 566 {TLSEXT_SIGALG_rsa_pkcs1_sha1, "rsa_pkcs1_sha1"}, 567 {TLSEXT_SIGALG_dsa_sha256, "dsa_sha256"}, 568 {TLSEXT_SIGALG_dsa_sha384, "dsa_sha384"}, 569 {TLSEXT_SIGALG_dsa_sha512, "dsa_sha512"}, 570 {TLSEXT_SIGALG_dsa_sha224, "dsa_sha224"}, 571 {TLSEXT_SIGALG_dsa_sha1, "dsa_sha1"}, 572 {TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256, "gost2012_256"}, 573 {TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512, "gost2012_512"}, 574 {TLSEXT_SIGALG_gostr34102001_gostr3411, "gost2001_gost94"}, 575 }; 576 577 static const ssl_trace_tbl ssl_ctype_tbl[] = { 578 {1, "rsa_sign"}, 579 {2, "dss_sign"}, 580 {3, "rsa_fixed_dh"}, 581 {4, "dss_fixed_dh"}, 582 {5, "rsa_ephemeral_dh"}, 583 {6, "dss_ephemeral_dh"}, 584 {20, "fortezza_dms"}, 585 {64, "ecdsa_sign"}, 586 {65, "rsa_fixed_ecdh"}, 587 {66, "ecdsa_fixed_ecdh"} 588 }; 589 590 static const ssl_trace_tbl ssl_psk_kex_modes_tbl[] = { 591 {TLSEXT_KEX_MODE_KE, "psk_ke"}, 592 {TLSEXT_KEX_MODE_KE_DHE, "psk_dhe_ke"} 593 }; 594 595 static const ssl_trace_tbl ssl_key_update_tbl[] = { 596 {SSL_KEY_UPDATE_NOT_REQUESTED, "update_not_requested"}, 597 {SSL_KEY_UPDATE_REQUESTED, "update_requested"} 598 }; 599 600 static void ssl_print_hex(BIO *bio, int indent, const char *name, 601 const unsigned char *msg, size_t msglen) 602 { 603 size_t i; 604 605 BIO_indent(bio, indent, 80); 606 BIO_printf(bio, "%s (len=%d): ", name, (int)msglen); 607 for (i = 0; i < msglen; i++) 608 BIO_printf(bio, "%02X", msg[i]); 609 BIO_puts(bio, "\n"); 610 } 611 612 static int ssl_print_hexbuf(BIO *bio, int indent, const char *name, size_t nlen, 613 const unsigned char **pmsg, size_t *pmsglen) 614 { 615 size_t blen; 616 const unsigned char *p = *pmsg; 617 618 if (*pmsglen < nlen) 619 return 0; 620 blen = p[0]; 621 if (nlen > 1) 622 blen = (blen << 8) | p[1]; 623 if (*pmsglen < nlen + blen) 624 return 0; 625 p += nlen; 626 ssl_print_hex(bio, indent, name, p, blen); 627 *pmsg += blen + nlen; 628 *pmsglen -= blen + nlen; 629 return 1; 630 } 631 632 static int ssl_print_version(BIO *bio, int indent, const char *name, 633 const unsigned char **pmsg, size_t *pmsglen, 634 unsigned int *version) 635 { 636 int vers; 637 638 if (*pmsglen < 2) 639 return 0; 640 vers = ((*pmsg)[0] << 8) | (*pmsg)[1]; 641 if (version != NULL) 642 *version = vers; 643 BIO_indent(bio, indent, 80); 644 BIO_printf(bio, "%s=0x%x (%s)\n", 645 name, vers, ssl_trace_str(vers, ssl_version_tbl)); 646 *pmsg += 2; 647 *pmsglen -= 2; 648 return 1; 649 } 650 651 static int ssl_print_random(BIO *bio, int indent, 652 const unsigned char **pmsg, size_t *pmsglen) 653 { 654 unsigned int tm; 655 const unsigned char *p = *pmsg; 656 657 if (*pmsglen < 32) 658 return 0; 659 tm = ((unsigned int)p[0] << 24) 660 | ((unsigned int)p[1] << 16) 661 | ((unsigned int)p[2] << 8) 662 | (unsigned int)p[3]; 663 p += 4; 664 BIO_indent(bio, indent, 80); 665 BIO_puts(bio, "Random:\n"); 666 BIO_indent(bio, indent + 2, 80); 667 BIO_printf(bio, "gmt_unix_time=0x%08X\n", tm); 668 ssl_print_hex(bio, indent + 2, "random_bytes", p, 28); 669 *pmsg += 32; 670 *pmsglen -= 32; 671 return 1; 672 } 673 674 static int ssl_print_signature(BIO *bio, int indent, const SSL *ssl, 675 const unsigned char **pmsg, size_t *pmsglen) 676 { 677 if (*pmsglen < 2) 678 return 0; 679 if (SSL_USE_SIGALGS(ssl)) { 680 const unsigned char *p = *pmsg; 681 unsigned int sigalg = (p[0] << 8) | p[1]; 682 683 BIO_indent(bio, indent, 80); 684 BIO_printf(bio, "Signature Algorithm: %s (0x%04x)\n", 685 ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg); 686 *pmsg += 2; 687 *pmsglen -= 2; 688 } 689 return ssl_print_hexbuf(bio, indent, "Signature", 2, pmsg, pmsglen); 690 } 691 692 static int ssl_print_extension(BIO *bio, int indent, int server, 693 unsigned char mt, int extype, 694 const unsigned char *ext, size_t extlen) 695 { 696 size_t xlen, share_len; 697 unsigned int sigalg; 698 uint32_t max_early_data; 699 700 BIO_indent(bio, indent, 80); 701 BIO_printf(bio, "extension_type=%s(%d), length=%d\n", 702 ssl_trace_str(extype, ssl_exts_tbl), extype, (int)extlen); 703 switch (extype) { 704 case TLSEXT_TYPE_max_fragment_length: 705 if (extlen < 1) 706 return 0; 707 xlen = extlen; 708 return ssl_trace_list(bio, indent + 2, ext, xlen, 1, ssl_mfl_tbl); 709 710 case TLSEXT_TYPE_ec_point_formats: 711 if (extlen < 1) 712 return 0; 713 xlen = ext[0]; 714 if (extlen != xlen + 1) 715 return 0; 716 return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1, ssl_point_tbl); 717 718 case TLSEXT_TYPE_supported_groups: 719 if (extlen < 2) 720 return 0; 721 xlen = (ext[0] << 8) | ext[1]; 722 if (extlen != xlen + 2) 723 return 0; 724 return ssl_trace_list(bio, indent + 2, ext + 2, xlen, 2, ssl_groups_tbl); 725 case TLSEXT_TYPE_application_layer_protocol_negotiation: 726 if (extlen < 2) 727 return 0; 728 xlen = (ext[0] << 8) | ext[1]; 729 if (extlen != xlen + 2) 730 return 0; 731 ext += 2; 732 while (xlen > 0) { 733 size_t plen = *ext++; 734 735 if (plen + 1 > xlen) 736 return 0; 737 BIO_indent(bio, indent + 2, 80); 738 BIO_write(bio, ext, plen); 739 BIO_puts(bio, "\n"); 740 ext += plen; 741 xlen -= plen + 1; 742 } 743 return 1; 744 745 case TLSEXT_TYPE_signature_algorithms: 746 747 if (extlen < 2) 748 return 0; 749 xlen = (ext[0] << 8) | ext[1]; 750 if (extlen != xlen + 2) 751 return 0; 752 if (xlen & 1) 753 return 0; 754 ext += 2; 755 while (xlen > 0) { 756 BIO_indent(bio, indent + 2, 80); 757 sigalg = (ext[0] << 8) | ext[1]; 758 BIO_printf(bio, "%s (0x%04x)\n", 759 ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg); 760 xlen -= 2; 761 ext += 2; 762 } 763 break; 764 765 case TLSEXT_TYPE_renegotiate: 766 if (extlen < 1) 767 return 0; 768 xlen = ext[0]; 769 if (xlen + 1 != extlen) 770 return 0; 771 ext++; 772 if (xlen) { 773 if (server) { 774 if (xlen & 1) 775 return 0; 776 xlen >>= 1; 777 } 778 ssl_print_hex(bio, indent + 4, "client_verify_data", ext, xlen); 779 if (server) { 780 ext += xlen; 781 ssl_print_hex(bio, indent + 4, "server_verify_data", ext, xlen); 782 } 783 } else { 784 BIO_indent(bio, indent + 4, 80); 785 BIO_puts(bio, "<EMPTY>\n"); 786 } 787 break; 788 789 case TLSEXT_TYPE_heartbeat: 790 return 0; 791 792 case TLSEXT_TYPE_session_ticket: 793 if (extlen != 0) 794 ssl_print_hex(bio, indent + 4, "ticket", ext, extlen); 795 break; 796 797 case TLSEXT_TYPE_key_share: 798 if (server && extlen == 2) { 799 int group_id; 800 801 /* We assume this is an HRR, otherwise this is an invalid key_share */ 802 group_id = (ext[0] << 8) | ext[1]; 803 BIO_indent(bio, indent + 4, 80); 804 BIO_printf(bio, "NamedGroup: %s (%d)\n", 805 ssl_trace_str(group_id, ssl_groups_tbl), group_id); 806 break; 807 } 808 if (extlen < 2) 809 return 0; 810 if (server) { 811 xlen = extlen; 812 } else { 813 xlen = (ext[0] << 8) | ext[1]; 814 if (extlen != xlen + 2) 815 return 0; 816 ext += 2; 817 } 818 for (; xlen > 0; ext += share_len, xlen -= share_len) { 819 int group_id; 820 821 if (xlen < 4) 822 return 0; 823 group_id = (ext[0] << 8) | ext[1]; 824 share_len = (ext[2] << 8) | ext[3]; 825 ext += 4; 826 xlen -= 4; 827 if (xlen < share_len) 828 return 0; 829 BIO_indent(bio, indent + 4, 80); 830 BIO_printf(bio, "NamedGroup: %s (%d)\n", 831 ssl_trace_str(group_id, ssl_groups_tbl), group_id); 832 ssl_print_hex(bio, indent + 4, "key_exchange: ", ext, share_len); 833 } 834 break; 835 836 case TLSEXT_TYPE_supported_versions: 837 if (server) { 838 int version; 839 840 if (extlen != 2) 841 return 0; 842 version = (ext[0] << 8) | ext[1]; 843 BIO_indent(bio, indent + 4, 80); 844 BIO_printf(bio, "%s (%d)\n", 845 ssl_trace_str(version, ssl_version_tbl), version); 846 break; 847 } 848 if (extlen < 1) 849 return 0; 850 xlen = ext[0]; 851 if (extlen != xlen + 1) 852 return 0; 853 return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 2, 854 ssl_version_tbl); 855 856 case TLSEXT_TYPE_psk_kex_modes: 857 if (extlen < 1) 858 return 0; 859 xlen = ext[0]; 860 if (extlen != xlen + 1) 861 return 0; 862 return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1, 863 ssl_psk_kex_modes_tbl); 864 865 case TLSEXT_TYPE_early_data: 866 if (mt != SSL3_MT_NEWSESSION_TICKET) 867 break; 868 if (extlen != 4) 869 return 0; 870 max_early_data = ((unsigned int)ext[0] << 24) 871 | ((unsigned int)ext[1] << 16) 872 | ((unsigned int)ext[2] << 8) 873 | (unsigned int)ext[3]; 874 BIO_indent(bio, indent + 2, 80); 875 BIO_printf(bio, "max_early_data=%u\n", max_early_data); 876 break; 877 878 default: 879 BIO_dump_indent(bio, (const char *)ext, extlen, indent + 2); 880 } 881 return 1; 882 } 883 884 static int ssl_print_extensions(BIO *bio, int indent, int server, 885 unsigned char mt, const unsigned char **msgin, 886 size_t *msginlen) 887 { 888 size_t extslen, msglen = *msginlen; 889 const unsigned char *msg = *msgin; 890 891 BIO_indent(bio, indent, 80); 892 if (msglen == 0) { 893 BIO_puts(bio, "No extensions\n"); 894 return 1; 895 } 896 if (msglen < 2) 897 return 0; 898 extslen = (msg[0] << 8) | msg[1]; 899 msglen -= 2; 900 msg += 2; 901 if (extslen == 0) { 902 BIO_puts(bio, "No extensions\n"); 903 *msgin = msg; 904 *msginlen = msglen; 905 return 1; 906 } 907 if (extslen > msglen) 908 return 0; 909 BIO_printf(bio, "extensions, length = %d\n", (int)extslen); 910 msglen -= extslen; 911 while (extslen > 0) { 912 int extype; 913 size_t extlen; 914 if (extslen < 4) 915 return 0; 916 extype = (msg[0] << 8) | msg[1]; 917 extlen = (msg[2] << 8) | msg[3]; 918 if (extslen < extlen + 4) { 919 BIO_printf(bio, "extensions, extype = %d, extlen = %d\n", extype, 920 (int)extlen); 921 BIO_dump_indent(bio, (const char *)msg, extslen, indent + 2); 922 return 0; 923 } 924 msg += 4; 925 if (!ssl_print_extension(bio, indent + 2, server, mt, extype, msg, 926 extlen)) 927 return 0; 928 msg += extlen; 929 extslen -= extlen + 4; 930 } 931 932 *msgin = msg; 933 *msginlen = msglen; 934 return 1; 935 } 936 937 static int ssl_print_client_hello(BIO *bio, const SSL *ssl, int indent, 938 const unsigned char *msg, size_t msglen) 939 { 940 size_t len; 941 unsigned int cs; 942 943 if (!ssl_print_version(bio, indent, "client_version", &msg, &msglen, NULL)) 944 return 0; 945 if (!ssl_print_random(bio, indent, &msg, &msglen)) 946 return 0; 947 if (!ssl_print_hexbuf(bio, indent, "session_id", 1, &msg, &msglen)) 948 return 0; 949 if (SSL_IS_DTLS(ssl)) { 950 if (!ssl_print_hexbuf(bio, indent, "cookie", 1, &msg, &msglen)) 951 return 0; 952 } 953 if (msglen < 2) 954 return 0; 955 len = (msg[0] << 8) | msg[1]; 956 msg += 2; 957 msglen -= 2; 958 BIO_indent(bio, indent, 80); 959 BIO_printf(bio, "cipher_suites (len=%d)\n", (int)len); 960 if (msglen < len || len & 1) 961 return 0; 962 while (len > 0) { 963 cs = (msg[0] << 8) | msg[1]; 964 BIO_indent(bio, indent + 2, 80); 965 BIO_printf(bio, "{0x%02X, 0x%02X} %s\n", 966 msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl)); 967 msg += 2; 968 msglen -= 2; 969 len -= 2; 970 } 971 if (msglen < 1) 972 return 0; 973 len = msg[0]; 974 msg++; 975 msglen--; 976 if (msglen < len) 977 return 0; 978 BIO_indent(bio, indent, 80); 979 BIO_printf(bio, "compression_methods (len=%d)\n", (int)len); 980 while (len > 0) { 981 BIO_indent(bio, indent + 2, 80); 982 BIO_printf(bio, "%s (0x%02X)\n", 983 ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]); 984 msg++; 985 msglen--; 986 len--; 987 } 988 if (!ssl_print_extensions(bio, indent, 0, SSL3_MT_CLIENT_HELLO, &msg, 989 &msglen)) 990 return 0; 991 return 1; 992 } 993 994 static int dtls_print_hello_vfyrequest(BIO *bio, int indent, 995 const unsigned char *msg, size_t msglen) 996 { 997 if (!ssl_print_version(bio, indent, "server_version", &msg, &msglen, NULL)) 998 return 0; 999 if (!ssl_print_hexbuf(bio, indent, "cookie", 1, &msg, &msglen)) 1000 return 0; 1001 return 1; 1002 } 1003 1004 static int ssl_print_server_hello(BIO *bio, int indent, 1005 const unsigned char *msg, size_t msglen) 1006 { 1007 unsigned int cs; 1008 unsigned int vers; 1009 1010 if (!ssl_print_version(bio, indent, "server_version", &msg, &msglen, &vers)) 1011 return 0; 1012 if (!ssl_print_random(bio, indent, &msg, &msglen)) 1013 return 0; 1014 if (vers != TLS1_3_VERSION 1015 && !ssl_print_hexbuf(bio, indent, "session_id", 1, &msg, &msglen)) 1016 return 0; 1017 if (msglen < 2) 1018 return 0; 1019 cs = (msg[0] << 8) | msg[1]; 1020 BIO_indent(bio, indent, 80); 1021 BIO_printf(bio, "cipher_suite {0x%02X, 0x%02X} %s\n", 1022 msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl)); 1023 msg += 2; 1024 msglen -= 2; 1025 if (vers != TLS1_3_VERSION) { 1026 if (msglen < 1) 1027 return 0; 1028 BIO_indent(bio, indent, 80); 1029 BIO_printf(bio, "compression_method: %s (0x%02X)\n", 1030 ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]); 1031 msg++; 1032 msglen--; 1033 } 1034 if (!ssl_print_extensions(bio, indent, 1, SSL3_MT_SERVER_HELLO, &msg, 1035 &msglen)) 1036 return 0; 1037 return 1; 1038 } 1039 1040 static int ssl_get_keyex(const char **pname, const SSL *ssl) 1041 { 1042 unsigned long alg_k = ssl->s3->tmp.new_cipher->algorithm_mkey; 1043 1044 if (alg_k & SSL_kRSA) { 1045 *pname = "rsa"; 1046 return SSL_kRSA; 1047 } 1048 if (alg_k & SSL_kDHE) { 1049 *pname = "DHE"; 1050 return SSL_kDHE; 1051 } 1052 if (alg_k & SSL_kECDHE) { 1053 *pname = "ECDHE"; 1054 return SSL_kECDHE; 1055 } 1056 if (alg_k & SSL_kPSK) { 1057 *pname = "PSK"; 1058 return SSL_kPSK; 1059 } 1060 if (alg_k & SSL_kRSAPSK) { 1061 *pname = "RSAPSK"; 1062 return SSL_kRSAPSK; 1063 } 1064 if (alg_k & SSL_kDHEPSK) { 1065 *pname = "DHEPSK"; 1066 return SSL_kDHEPSK; 1067 } 1068 if (alg_k & SSL_kECDHEPSK) { 1069 *pname = "ECDHEPSK"; 1070 return SSL_kECDHEPSK; 1071 } 1072 if (alg_k & SSL_kSRP) { 1073 *pname = "SRP"; 1074 return SSL_kSRP; 1075 } 1076 if (alg_k & SSL_kGOST) { 1077 *pname = "GOST"; 1078 return SSL_kGOST; 1079 } 1080 *pname = "UNKNOWN"; 1081 return 0; 1082 } 1083 1084 static int ssl_print_client_keyex(BIO *bio, int indent, const SSL *ssl, 1085 const unsigned char *msg, size_t msglen) 1086 { 1087 const char *algname; 1088 int id = ssl_get_keyex(&algname, ssl); 1089 1090 BIO_indent(bio, indent, 80); 1091 BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname); 1092 if (id & SSL_PSK) { 1093 if (!ssl_print_hexbuf(bio, indent + 2, 1094 "psk_identity", 2, &msg, &msglen)) 1095 return 0; 1096 } 1097 switch (id) { 1098 1099 case SSL_kRSA: 1100 case SSL_kRSAPSK: 1101 if (TLS1_get_version(ssl) == SSL3_VERSION) { 1102 ssl_print_hex(bio, indent + 2, 1103 "EncryptedPreMasterSecret", msg, msglen); 1104 } else { 1105 if (!ssl_print_hexbuf(bio, indent + 2, 1106 "EncryptedPreMasterSecret", 2, &msg, &msglen)) 1107 return 0; 1108 } 1109 break; 1110 1111 case SSL_kDHE: 1112 case SSL_kDHEPSK: 1113 if (!ssl_print_hexbuf(bio, indent + 2, "dh_Yc", 2, &msg, &msglen)) 1114 return 0; 1115 break; 1116 1117 case SSL_kECDHE: 1118 case SSL_kECDHEPSK: 1119 if (!ssl_print_hexbuf(bio, indent + 2, "ecdh_Yc", 1, &msg, &msglen)) 1120 return 0; 1121 break; 1122 1123 } 1124 1125 return !msglen; 1126 } 1127 1128 static int ssl_print_server_keyex(BIO *bio, int indent, const SSL *ssl, 1129 const unsigned char *msg, size_t msglen) 1130 { 1131 const char *algname; 1132 int id = ssl_get_keyex(&algname, ssl); 1133 1134 BIO_indent(bio, indent, 80); 1135 BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname); 1136 if (id & SSL_PSK) { 1137 if (!ssl_print_hexbuf(bio, indent + 2, 1138 "psk_identity_hint", 2, &msg, &msglen)) 1139 return 0; 1140 } 1141 switch (id) { 1142 case SSL_kRSA: 1143 1144 if (!ssl_print_hexbuf(bio, indent + 2, "rsa_modulus", 2, &msg, &msglen)) 1145 return 0; 1146 if (!ssl_print_hexbuf(bio, indent + 2, "rsa_exponent", 2, 1147 &msg, &msglen)) 1148 return 0; 1149 break; 1150 1151 case SSL_kDHE: 1152 case SSL_kDHEPSK: 1153 if (!ssl_print_hexbuf(bio, indent + 2, "dh_p", 2, &msg, &msglen)) 1154 return 0; 1155 if (!ssl_print_hexbuf(bio, indent + 2, "dh_g", 2, &msg, &msglen)) 1156 return 0; 1157 if (!ssl_print_hexbuf(bio, indent + 2, "dh_Ys", 2, &msg, &msglen)) 1158 return 0; 1159 break; 1160 1161 # ifndef OPENSSL_NO_EC 1162 case SSL_kECDHE: 1163 case SSL_kECDHEPSK: 1164 if (msglen < 1) 1165 return 0; 1166 BIO_indent(bio, indent + 2, 80); 1167 if (msg[0] == EXPLICIT_PRIME_CURVE_TYPE) 1168 BIO_puts(bio, "explicit_prime\n"); 1169 else if (msg[0] == EXPLICIT_CHAR2_CURVE_TYPE) 1170 BIO_puts(bio, "explicit_char2\n"); 1171 else if (msg[0] == NAMED_CURVE_TYPE) { 1172 int curve; 1173 if (msglen < 3) 1174 return 0; 1175 curve = (msg[1] << 8) | msg[2]; 1176 BIO_printf(bio, "named_curve: %s (%d)\n", 1177 ssl_trace_str(curve, ssl_groups_tbl), curve); 1178 msg += 3; 1179 msglen -= 3; 1180 if (!ssl_print_hexbuf(bio, indent + 2, "point", 1, &msg, &msglen)) 1181 return 0; 1182 } else { 1183 BIO_printf(bio, "UNKNOWN CURVE PARAMETER TYPE %d\n", msg[0]); 1184 return 0; 1185 } 1186 break; 1187 # endif 1188 1189 case SSL_kPSK: 1190 case SSL_kRSAPSK: 1191 break; 1192 } 1193 if (!(id & SSL_PSK)) 1194 ssl_print_signature(bio, indent, ssl, &msg, &msglen); 1195 return !msglen; 1196 } 1197 1198 static int ssl_print_certificate(BIO *bio, int indent, 1199 const unsigned char **pmsg, size_t *pmsglen) 1200 { 1201 size_t msglen = *pmsglen; 1202 size_t clen; 1203 X509 *x; 1204 const unsigned char *p = *pmsg, *q; 1205 1206 if (msglen < 3) 1207 return 0; 1208 clen = (p[0] << 16) | (p[1] << 8) | p[2]; 1209 if (msglen < clen + 3) 1210 return 0; 1211 q = p + 3; 1212 BIO_indent(bio, indent, 80); 1213 BIO_printf(bio, "ASN.1Cert, length=%d", (int)clen); 1214 x = d2i_X509(NULL, &q, clen); 1215 if (!x) 1216 BIO_puts(bio, "<UNPARSEABLE CERTIFICATE>\n"); 1217 else { 1218 BIO_puts(bio, "\n------details-----\n"); 1219 X509_print_ex(bio, x, XN_FLAG_ONELINE, 0); 1220 PEM_write_bio_X509(bio, x); 1221 /* Print certificate stuff */ 1222 BIO_puts(bio, "------------------\n"); 1223 X509_free(x); 1224 } 1225 if (q != p + 3 + clen) { 1226 BIO_puts(bio, "<TRAILING GARBAGE AFTER CERTIFICATE>\n"); 1227 } 1228 *pmsg += clen + 3; 1229 *pmsglen -= clen + 3; 1230 return 1; 1231 } 1232 1233 static int ssl_print_certificates(BIO *bio, const SSL *ssl, int server, 1234 int indent, const unsigned char *msg, 1235 size_t msglen) 1236 { 1237 size_t clen; 1238 1239 if (SSL_IS_TLS13(ssl) 1240 && !ssl_print_hexbuf(bio, indent, "context", 1, &msg, &msglen)) 1241 return 0; 1242 1243 if (msglen < 3) 1244 return 0; 1245 clen = (msg[0] << 16) | (msg[1] << 8) | msg[2]; 1246 if (msglen != clen + 3) 1247 return 0; 1248 msg += 3; 1249 BIO_indent(bio, indent, 80); 1250 BIO_printf(bio, "certificate_list, length=%d\n", (int)clen); 1251 while (clen > 0) { 1252 if (!ssl_print_certificate(bio, indent + 2, &msg, &clen)) 1253 return 0; 1254 if (SSL_IS_TLS13(ssl) 1255 && !ssl_print_extensions(bio, indent + 2, server, 1256 SSL3_MT_CERTIFICATE, &msg, &clen)) 1257 return 0; 1258 1259 } 1260 return 1; 1261 } 1262 1263 static int ssl_print_cert_request(BIO *bio, int indent, const SSL *ssl, 1264 const unsigned char *msg, size_t msglen) 1265 { 1266 size_t xlen; 1267 unsigned int sigalg; 1268 1269 if (SSL_IS_TLS13(ssl)) { 1270 if (!ssl_print_hexbuf(bio, indent, "request_context", 1, &msg, &msglen)) 1271 return 0; 1272 if (!ssl_print_extensions(bio, indent, 1, 1273 SSL3_MT_CERTIFICATE_REQUEST, &msg, &msglen)) 1274 return 0; 1275 return 1; 1276 } else { 1277 if (msglen < 1) 1278 return 0; 1279 xlen = msg[0]; 1280 if (msglen < xlen + 1) 1281 return 0; 1282 msg++; 1283 BIO_indent(bio, indent, 80); 1284 BIO_printf(bio, "certificate_types (len=%d)\n", (int)xlen); 1285 if (!ssl_trace_list(bio, indent + 2, msg, xlen, 1, ssl_ctype_tbl)) 1286 return 0; 1287 msg += xlen; 1288 msglen -= xlen + 1; 1289 } 1290 if (SSL_USE_SIGALGS(ssl)) { 1291 if (msglen < 2) 1292 return 0; 1293 xlen = (msg[0] << 8) | msg[1]; 1294 if (msglen < xlen + 2 || (xlen & 1)) 1295 return 0; 1296 msg += 2; 1297 msglen -= xlen + 2; 1298 BIO_indent(bio, indent, 80); 1299 BIO_printf(bio, "signature_algorithms (len=%d)\n", (int)xlen); 1300 while (xlen > 0) { 1301 BIO_indent(bio, indent + 2, 80); 1302 sigalg = (msg[0] << 8) | msg[1]; 1303 BIO_printf(bio, "%s (0x%04x)\n", 1304 ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg); 1305 xlen -= 2; 1306 msg += 2; 1307 } 1308 msg += xlen; 1309 } 1310 1311 if (msglen < 2) 1312 return 0; 1313 xlen = (msg[0] << 8) | msg[1]; 1314 BIO_indent(bio, indent, 80); 1315 if (msglen < xlen + 2) 1316 return 0; 1317 msg += 2; 1318 msglen -= 2 + xlen; 1319 BIO_printf(bio, "certificate_authorities (len=%d)\n", (int)xlen); 1320 while (xlen > 0) { 1321 size_t dlen; 1322 X509_NAME *nm; 1323 const unsigned char *p; 1324 if (xlen < 2) 1325 return 0; 1326 dlen = (msg[0] << 8) | msg[1]; 1327 if (xlen < dlen + 2) 1328 return 0; 1329 msg += 2; 1330 BIO_indent(bio, indent + 2, 80); 1331 BIO_printf(bio, "DistinguishedName (len=%d): ", (int)dlen); 1332 p = msg; 1333 nm = d2i_X509_NAME(NULL, &p, dlen); 1334 if (!nm) { 1335 BIO_puts(bio, "<UNPARSEABLE DN>\n"); 1336 } else { 1337 X509_NAME_print_ex(bio, nm, 0, XN_FLAG_ONELINE); 1338 BIO_puts(bio, "\n"); 1339 X509_NAME_free(nm); 1340 } 1341 xlen -= dlen + 2; 1342 msg += dlen; 1343 } 1344 if (SSL_IS_TLS13(ssl)) { 1345 if (!ssl_print_hexbuf(bio, indent, "request_extensions", 2, 1346 &msg, &msglen)) 1347 return 0; 1348 } 1349 return msglen == 0; 1350 } 1351 1352 static int ssl_print_ticket(BIO *bio, int indent, const SSL *ssl, 1353 const unsigned char *msg, size_t msglen) 1354 { 1355 unsigned int tick_life; 1356 1357 if (msglen == 0) { 1358 BIO_indent(bio, indent + 2, 80); 1359 BIO_puts(bio, "No Ticket\n"); 1360 return 1; 1361 } 1362 if (msglen < 4) 1363 return 0; 1364 tick_life = ((unsigned int)msg[0] << 24) 1365 | ((unsigned int)msg[1] << 16) 1366 | ((unsigned int)msg[2] << 8) 1367 | (unsigned int)msg[3]; 1368 msglen -= 4; 1369 msg += 4; 1370 BIO_indent(bio, indent + 2, 80); 1371 BIO_printf(bio, "ticket_lifetime_hint=%u\n", tick_life); 1372 if (SSL_IS_TLS13(ssl)) { 1373 unsigned int ticket_age_add; 1374 1375 if (msglen < 4) 1376 return 0; 1377 ticket_age_add = 1378 ((unsigned int)msg[0] << 24) 1379 | ((unsigned int)msg[1] << 16) 1380 | ((unsigned int)msg[2] << 8) 1381 | (unsigned int)msg[3]; 1382 msglen -= 4; 1383 msg += 4; 1384 BIO_indent(bio, indent + 2, 80); 1385 BIO_printf(bio, "ticket_age_add=%u\n", ticket_age_add); 1386 if (!ssl_print_hexbuf(bio, indent + 2, "ticket_nonce", 1, &msg, 1387 &msglen)) 1388 return 0; 1389 } 1390 if (!ssl_print_hexbuf(bio, indent + 2, "ticket", 2, &msg, &msglen)) 1391 return 0; 1392 if (SSL_IS_TLS13(ssl) 1393 && !ssl_print_extensions(bio, indent + 2, 0, 1394 SSL3_MT_NEWSESSION_TICKET, &msg, &msglen)) 1395 return 0; 1396 if (msglen) 1397 return 0; 1398 return 1; 1399 } 1400 1401 static int ssl_print_handshake(BIO *bio, const SSL *ssl, int server, 1402 const unsigned char *msg, size_t msglen, 1403 int indent) 1404 { 1405 size_t hlen; 1406 unsigned char htype; 1407 1408 if (msglen < 4) 1409 return 0; 1410 htype = msg[0]; 1411 hlen = (msg[1] << 16) | (msg[2] << 8) | msg[3]; 1412 BIO_indent(bio, indent, 80); 1413 BIO_printf(bio, "%s, Length=%d\n", 1414 ssl_trace_str(htype, ssl_handshake_tbl), (int)hlen); 1415 msg += 4; 1416 msglen -= 4; 1417 if (SSL_IS_DTLS(ssl)) { 1418 if (msglen < 8) 1419 return 0; 1420 BIO_indent(bio, indent, 80); 1421 BIO_printf(bio, "message_seq=%d, fragment_offset=%d, " 1422 "fragment_length=%d\n", 1423 (msg[0] << 8) | msg[1], 1424 (msg[2] << 16) | (msg[3] << 8) | msg[4], 1425 (msg[5] << 16) | (msg[6] << 8) | msg[7]); 1426 msg += 8; 1427 msglen -= 8; 1428 } 1429 if (msglen < hlen) 1430 return 0; 1431 switch (htype) { 1432 case SSL3_MT_CLIENT_HELLO: 1433 if (!ssl_print_client_hello(bio, ssl, indent + 2, msg, msglen)) 1434 return 0; 1435 break; 1436 1437 case DTLS1_MT_HELLO_VERIFY_REQUEST: 1438 if (!dtls_print_hello_vfyrequest(bio, indent + 2, msg, msglen)) 1439 return 0; 1440 break; 1441 1442 case SSL3_MT_SERVER_HELLO: 1443 if (!ssl_print_server_hello(bio, indent + 2, msg, msglen)) 1444 return 0; 1445 break; 1446 1447 case SSL3_MT_SERVER_KEY_EXCHANGE: 1448 if (!ssl_print_server_keyex(bio, indent + 2, ssl, msg, msglen)) 1449 return 0; 1450 break; 1451 1452 case SSL3_MT_CLIENT_KEY_EXCHANGE: 1453 if (!ssl_print_client_keyex(bio, indent + 2, ssl, msg, msglen)) 1454 return 0; 1455 break; 1456 1457 case SSL3_MT_CERTIFICATE: 1458 if (!ssl_print_certificates(bio, ssl, server, indent + 2, msg, msglen)) 1459 return 0; 1460 break; 1461 1462 case SSL3_MT_CERTIFICATE_VERIFY: 1463 if (!ssl_print_signature(bio, indent + 2, ssl, &msg, &msglen)) 1464 return 0; 1465 break; 1466 1467 case SSL3_MT_CERTIFICATE_REQUEST: 1468 if (!ssl_print_cert_request(bio, indent + 2, ssl, msg, msglen)) 1469 return 0; 1470 break; 1471 1472 case SSL3_MT_FINISHED: 1473 ssl_print_hex(bio, indent + 2, "verify_data", msg, msglen); 1474 break; 1475 1476 case SSL3_MT_SERVER_DONE: 1477 if (msglen != 0) 1478 ssl_print_hex(bio, indent + 2, "unexpected value", msg, msglen); 1479 break; 1480 1481 case SSL3_MT_NEWSESSION_TICKET: 1482 if (!ssl_print_ticket(bio, indent + 2, ssl, msg, msglen)) 1483 return 0; 1484 break; 1485 1486 case SSL3_MT_ENCRYPTED_EXTENSIONS: 1487 if (!ssl_print_extensions(bio, indent + 2, 1, 1488 SSL3_MT_ENCRYPTED_EXTENSIONS, &msg, &msglen)) 1489 return 0; 1490 break; 1491 1492 case SSL3_MT_KEY_UPDATE: 1493 if (msglen != 1) { 1494 ssl_print_hex(bio, indent + 2, "unexpected value", msg, msglen); 1495 return 0; 1496 } 1497 if (!ssl_trace_list(bio, indent + 2, msg, msglen, 1, 1498 ssl_key_update_tbl)) 1499 return 0; 1500 break; 1501 1502 default: 1503 BIO_indent(bio, indent + 2, 80); 1504 BIO_puts(bio, "Unsupported, hex dump follows:\n"); 1505 BIO_dump_indent(bio, (const char *)msg, msglen, indent + 4); 1506 } 1507 return 1; 1508 } 1509 1510 void SSL_trace(int write_p, int version, int content_type, 1511 const void *buf, size_t msglen, SSL *ssl, void *arg) 1512 { 1513 const unsigned char *msg = buf; 1514 BIO *bio = arg; 1515 1516 switch (content_type) { 1517 case SSL3_RT_HEADER: 1518 { 1519 int hvers; 1520 1521 /* avoid overlapping with length at the end of buffer */ 1522 if (msglen < (size_t)(SSL_IS_DTLS(ssl) ? 1523 DTLS1_RT_HEADER_LENGTH : SSL3_RT_HEADER_LENGTH)) { 1524 BIO_puts(bio, write_p ? "Sent" : "Received"); 1525 ssl_print_hex(bio, 0, " too short message", msg, msglen); 1526 break; 1527 } 1528 hvers = msg[1] << 8 | msg[2]; 1529 BIO_puts(bio, write_p ? "Sent" : "Received"); 1530 BIO_printf(bio, " Record\nHeader:\n Version = %s (0x%x)\n", 1531 ssl_trace_str(hvers, ssl_version_tbl), hvers); 1532 if (SSL_IS_DTLS(ssl)) { 1533 BIO_printf(bio, 1534 " epoch=%d, sequence_number=%04x%04x%04x\n", 1535 (msg[3] << 8 | msg[4]), 1536 (msg[5] << 8 | msg[6]), 1537 (msg[7] << 8 | msg[8]), (msg[9] << 8 | msg[10])); 1538 } 1539 1540 BIO_printf(bio, " Content Type = %s (%d)\n Length = %d", 1541 ssl_trace_str(msg[0], ssl_content_tbl), msg[0], 1542 msg[msglen - 2] << 8 | msg[msglen - 1]); 1543 } 1544 break; 1545 1546 case SSL3_RT_INNER_CONTENT_TYPE: 1547 BIO_printf(bio, " Inner Content Type = %s (%d)", 1548 ssl_trace_str(msg[0], ssl_content_tbl), msg[0]); 1549 break; 1550 1551 case SSL3_RT_HANDSHAKE: 1552 if (!ssl_print_handshake(bio, ssl, ssl->server ? write_p : !write_p, 1553 msg, msglen, 4)) 1554 BIO_printf(bio, "Message length parse error!\n"); 1555 break; 1556 1557 case SSL3_RT_CHANGE_CIPHER_SPEC: 1558 if (msglen == 1 && msg[0] == 1) 1559 BIO_puts(bio, " change_cipher_spec (1)\n"); 1560 else 1561 ssl_print_hex(bio, 4, "unknown value", msg, msglen); 1562 break; 1563 1564 case SSL3_RT_ALERT: 1565 if (msglen != 2) 1566 BIO_puts(bio, " Illegal Alert Length\n"); 1567 else { 1568 BIO_printf(bio, " Level=%s(%d), description=%s(%d)\n", 1569 SSL_alert_type_string_long(msg[0] << 8), 1570 msg[0], SSL_alert_desc_string_long(msg[1]), msg[1]); 1571 } 1572 1573 } 1574 1575 BIO_puts(bio, "\n"); 1576 } 1577 1578 #endif 1579