1 /* 2 * Copyright 2012-2018 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 = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]; 660 p += 4; 661 BIO_indent(bio, indent, 80); 662 BIO_puts(bio, "Random:\n"); 663 BIO_indent(bio, indent + 2, 80); 664 BIO_printf(bio, "gmt_unix_time=0x%08X\n", tm); 665 ssl_print_hex(bio, indent + 2, "random_bytes", p, 28); 666 *pmsg += 32; 667 *pmsglen -= 32; 668 return 1; 669 } 670 671 static int ssl_print_signature(BIO *bio, int indent, const SSL *ssl, 672 const unsigned char **pmsg, size_t *pmsglen) 673 { 674 if (*pmsglen < 2) 675 return 0; 676 if (SSL_USE_SIGALGS(ssl)) { 677 const unsigned char *p = *pmsg; 678 unsigned int sigalg = (p[0] << 8) | p[1]; 679 680 BIO_indent(bio, indent, 80); 681 BIO_printf(bio, "Signature Algorithm: %s (0x%04x)\n", 682 ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg); 683 *pmsg += 2; 684 *pmsglen -= 2; 685 } 686 return ssl_print_hexbuf(bio, indent, "Signature", 2, pmsg, pmsglen); 687 } 688 689 static int ssl_print_extension(BIO *bio, int indent, int server, 690 unsigned char mt, int extype, 691 const unsigned char *ext, size_t extlen) 692 { 693 size_t xlen, share_len; 694 unsigned int sigalg; 695 uint32_t max_early_data; 696 697 BIO_indent(bio, indent, 80); 698 BIO_printf(bio, "extension_type=%s(%d), length=%d\n", 699 ssl_trace_str(extype, ssl_exts_tbl), extype, (int)extlen); 700 switch (extype) { 701 case TLSEXT_TYPE_max_fragment_length: 702 if (extlen < 1) 703 return 0; 704 xlen = extlen; 705 return ssl_trace_list(bio, indent + 2, ext, xlen, 1, ssl_mfl_tbl); 706 707 case TLSEXT_TYPE_ec_point_formats: 708 if (extlen < 1) 709 return 0; 710 xlen = ext[0]; 711 if (extlen != xlen + 1) 712 return 0; 713 return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1, ssl_point_tbl); 714 715 case TLSEXT_TYPE_supported_groups: 716 if (extlen < 2) 717 return 0; 718 xlen = (ext[0] << 8) | ext[1]; 719 if (extlen != xlen + 2) 720 return 0; 721 return ssl_trace_list(bio, indent + 2, ext + 2, xlen, 2, ssl_groups_tbl); 722 case TLSEXT_TYPE_application_layer_protocol_negotiation: 723 if (extlen < 2) 724 return 0; 725 xlen = (ext[0] << 8) | ext[1]; 726 if (extlen != xlen + 2) 727 return 0; 728 ext += 2; 729 while (xlen > 0) { 730 size_t plen = *ext++; 731 732 if (plen + 1 > xlen) 733 return 0; 734 BIO_indent(bio, indent + 2, 80); 735 BIO_write(bio, ext, plen); 736 BIO_puts(bio, "\n"); 737 ext += plen; 738 xlen -= plen + 1; 739 } 740 return 1; 741 742 case TLSEXT_TYPE_signature_algorithms: 743 744 if (extlen < 2) 745 return 0; 746 xlen = (ext[0] << 8) | ext[1]; 747 if (extlen != xlen + 2) 748 return 0; 749 if (xlen & 1) 750 return 0; 751 ext += 2; 752 while (xlen > 0) { 753 BIO_indent(bio, indent + 2, 80); 754 sigalg = (ext[0] << 8) | ext[1]; 755 BIO_printf(bio, "%s (0x%04x)\n", 756 ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg); 757 xlen -= 2; 758 ext += 2; 759 } 760 break; 761 762 case TLSEXT_TYPE_renegotiate: 763 if (extlen < 1) 764 return 0; 765 xlen = ext[0]; 766 if (xlen + 1 != extlen) 767 return 0; 768 ext++; 769 if (xlen) { 770 if (server) { 771 if (xlen & 1) 772 return 0; 773 xlen >>= 1; 774 } 775 ssl_print_hex(bio, indent + 4, "client_verify_data", ext, xlen); 776 if (server) { 777 ext += xlen; 778 ssl_print_hex(bio, indent + 4, "server_verify_data", ext, xlen); 779 } 780 } else { 781 BIO_indent(bio, indent + 4, 80); 782 BIO_puts(bio, "<EMPTY>\n"); 783 } 784 break; 785 786 case TLSEXT_TYPE_heartbeat: 787 return 0; 788 789 case TLSEXT_TYPE_session_ticket: 790 if (extlen != 0) 791 ssl_print_hex(bio, indent + 4, "ticket", ext, extlen); 792 break; 793 794 case TLSEXT_TYPE_key_share: 795 if (server && extlen == 2) { 796 int group_id; 797 798 /* We assume this is an HRR, otherwise this is an invalid key_share */ 799 group_id = (ext[0] << 8) | ext[1]; 800 BIO_indent(bio, indent + 4, 80); 801 BIO_printf(bio, "NamedGroup: %s (%d)\n", 802 ssl_trace_str(group_id, ssl_groups_tbl), group_id); 803 break; 804 } 805 if (extlen < 2) 806 return 0; 807 if (server) { 808 xlen = extlen; 809 } else { 810 xlen = (ext[0] << 8) | ext[1]; 811 if (extlen != xlen + 2) 812 return 0; 813 ext += 2; 814 } 815 for (; xlen > 0; ext += share_len, xlen -= share_len) { 816 int group_id; 817 818 if (xlen < 4) 819 return 0; 820 group_id = (ext[0] << 8) | ext[1]; 821 share_len = (ext[2] << 8) | ext[3]; 822 ext += 4; 823 xlen -= 4; 824 if (xlen < share_len) 825 return 0; 826 BIO_indent(bio, indent + 4, 80); 827 BIO_printf(bio, "NamedGroup: %s (%d)\n", 828 ssl_trace_str(group_id, ssl_groups_tbl), group_id); 829 ssl_print_hex(bio, indent + 4, "key_exchange: ", ext, share_len); 830 } 831 break; 832 833 case TLSEXT_TYPE_supported_versions: 834 if (server) { 835 int version; 836 837 if (extlen != 2) 838 return 0; 839 version = (ext[0] << 8) | ext[1]; 840 BIO_indent(bio, indent + 4, 80); 841 BIO_printf(bio, "%s (%d)\n", 842 ssl_trace_str(version, ssl_version_tbl), version); 843 break; 844 } 845 if (extlen < 1) 846 return 0; 847 xlen = ext[0]; 848 if (extlen != xlen + 1) 849 return 0; 850 return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 2, 851 ssl_version_tbl); 852 853 case TLSEXT_TYPE_psk_kex_modes: 854 if (extlen < 1) 855 return 0; 856 xlen = ext[0]; 857 if (extlen != xlen + 1) 858 return 0; 859 return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1, 860 ssl_psk_kex_modes_tbl); 861 862 case TLSEXT_TYPE_early_data: 863 if (mt != SSL3_MT_NEWSESSION_TICKET) 864 break; 865 if (extlen != 4) 866 return 0; 867 max_early_data = (ext[0] << 24) | (ext[1] << 16) | (ext[2] << 8) 868 | ext[3]; 869 BIO_indent(bio, indent + 2, 80); 870 BIO_printf(bio, "max_early_data=%u\n", max_early_data); 871 break; 872 873 default: 874 BIO_dump_indent(bio, (const char *)ext, extlen, indent + 2); 875 } 876 return 1; 877 } 878 879 static int ssl_print_extensions(BIO *bio, int indent, int server, 880 unsigned char mt, const unsigned char **msgin, 881 size_t *msginlen) 882 { 883 size_t extslen, msglen = *msginlen; 884 const unsigned char *msg = *msgin; 885 886 BIO_indent(bio, indent, 80); 887 if (msglen == 0) { 888 BIO_puts(bio, "No extensions\n"); 889 return 1; 890 } 891 if (msglen < 2) 892 return 0; 893 extslen = (msg[0] << 8) | msg[1]; 894 msglen -= 2; 895 msg += 2; 896 if (extslen == 0) { 897 BIO_puts(bio, "No extensions\n"); 898 *msgin = msg; 899 *msginlen = msglen; 900 return 1; 901 } 902 if (extslen > msglen) 903 return 0; 904 BIO_printf(bio, "extensions, length = %d\n", (int)extslen); 905 msglen -= extslen; 906 while (extslen > 0) { 907 int extype; 908 size_t extlen; 909 if (extslen < 4) 910 return 0; 911 extype = (msg[0] << 8) | msg[1]; 912 extlen = (msg[2] << 8) | msg[3]; 913 if (extslen < extlen + 4) { 914 BIO_printf(bio, "extensions, extype = %d, extlen = %d\n", extype, 915 (int)extlen); 916 BIO_dump_indent(bio, (const char *)msg, extslen, indent + 2); 917 return 0; 918 } 919 msg += 4; 920 if (!ssl_print_extension(bio, indent + 2, server, mt, extype, msg, 921 extlen)) 922 return 0; 923 msg += extlen; 924 extslen -= extlen + 4; 925 } 926 927 *msgin = msg; 928 *msginlen = msglen; 929 return 1; 930 } 931 932 static int ssl_print_client_hello(BIO *bio, const SSL *ssl, int indent, 933 const unsigned char *msg, size_t msglen) 934 { 935 size_t len; 936 unsigned int cs; 937 938 if (!ssl_print_version(bio, indent, "client_version", &msg, &msglen, NULL)) 939 return 0; 940 if (!ssl_print_random(bio, indent, &msg, &msglen)) 941 return 0; 942 if (!ssl_print_hexbuf(bio, indent, "session_id", 1, &msg, &msglen)) 943 return 0; 944 if (SSL_IS_DTLS(ssl)) { 945 if (!ssl_print_hexbuf(bio, indent, "cookie", 1, &msg, &msglen)) 946 return 0; 947 } 948 if (msglen < 2) 949 return 0; 950 len = (msg[0] << 8) | msg[1]; 951 msg += 2; 952 msglen -= 2; 953 BIO_indent(bio, indent, 80); 954 BIO_printf(bio, "cipher_suites (len=%d)\n", (int)len); 955 if (msglen < len || len & 1) 956 return 0; 957 while (len > 0) { 958 cs = (msg[0] << 8) | msg[1]; 959 BIO_indent(bio, indent + 2, 80); 960 BIO_printf(bio, "{0x%02X, 0x%02X} %s\n", 961 msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl)); 962 msg += 2; 963 msglen -= 2; 964 len -= 2; 965 } 966 if (msglen < 1) 967 return 0; 968 len = msg[0]; 969 msg++; 970 msglen--; 971 if (msglen < len) 972 return 0; 973 BIO_indent(bio, indent, 80); 974 BIO_printf(bio, "compression_methods (len=%d)\n", (int)len); 975 while (len > 0) { 976 BIO_indent(bio, indent + 2, 80); 977 BIO_printf(bio, "%s (0x%02X)\n", 978 ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]); 979 msg++; 980 msglen--; 981 len--; 982 } 983 if (!ssl_print_extensions(bio, indent, 0, SSL3_MT_CLIENT_HELLO, &msg, 984 &msglen)) 985 return 0; 986 return 1; 987 } 988 989 static int dtls_print_hello_vfyrequest(BIO *bio, int indent, 990 const unsigned char *msg, size_t msglen) 991 { 992 if (!ssl_print_version(bio, indent, "server_version", &msg, &msglen, NULL)) 993 return 0; 994 if (!ssl_print_hexbuf(bio, indent, "cookie", 1, &msg, &msglen)) 995 return 0; 996 return 1; 997 } 998 999 static int ssl_print_server_hello(BIO *bio, int indent, 1000 const unsigned char *msg, size_t msglen) 1001 { 1002 unsigned int cs; 1003 unsigned int vers; 1004 1005 if (!ssl_print_version(bio, indent, "server_version", &msg, &msglen, &vers)) 1006 return 0; 1007 if (!ssl_print_random(bio, indent, &msg, &msglen)) 1008 return 0; 1009 if (vers != TLS1_3_VERSION 1010 && !ssl_print_hexbuf(bio, indent, "session_id", 1, &msg, &msglen)) 1011 return 0; 1012 if (msglen < 2) 1013 return 0; 1014 cs = (msg[0] << 8) | msg[1]; 1015 BIO_indent(bio, indent, 80); 1016 BIO_printf(bio, "cipher_suite {0x%02X, 0x%02X} %s\n", 1017 msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl)); 1018 msg += 2; 1019 msglen -= 2; 1020 if (vers != TLS1_3_VERSION) { 1021 if (msglen < 1) 1022 return 0; 1023 BIO_indent(bio, indent, 80); 1024 BIO_printf(bio, "compression_method: %s (0x%02X)\n", 1025 ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]); 1026 msg++; 1027 msglen--; 1028 } 1029 if (!ssl_print_extensions(bio, indent, 1, SSL3_MT_SERVER_HELLO, &msg, 1030 &msglen)) 1031 return 0; 1032 return 1; 1033 } 1034 1035 static int ssl_get_keyex(const char **pname, const SSL *ssl) 1036 { 1037 unsigned long alg_k = ssl->s3->tmp.new_cipher->algorithm_mkey; 1038 1039 if (alg_k & SSL_kRSA) { 1040 *pname = "rsa"; 1041 return SSL_kRSA; 1042 } 1043 if (alg_k & SSL_kDHE) { 1044 *pname = "DHE"; 1045 return SSL_kDHE; 1046 } 1047 if (alg_k & SSL_kECDHE) { 1048 *pname = "ECDHE"; 1049 return SSL_kECDHE; 1050 } 1051 if (alg_k & SSL_kPSK) { 1052 *pname = "PSK"; 1053 return SSL_kPSK; 1054 } 1055 if (alg_k & SSL_kRSAPSK) { 1056 *pname = "RSAPSK"; 1057 return SSL_kRSAPSK; 1058 } 1059 if (alg_k & SSL_kDHEPSK) { 1060 *pname = "DHEPSK"; 1061 return SSL_kDHEPSK; 1062 } 1063 if (alg_k & SSL_kECDHEPSK) { 1064 *pname = "ECDHEPSK"; 1065 return SSL_kECDHEPSK; 1066 } 1067 if (alg_k & SSL_kSRP) { 1068 *pname = "SRP"; 1069 return SSL_kSRP; 1070 } 1071 if (alg_k & SSL_kGOST) { 1072 *pname = "GOST"; 1073 return SSL_kGOST; 1074 } 1075 *pname = "UNKNOWN"; 1076 return 0; 1077 } 1078 1079 static int ssl_print_client_keyex(BIO *bio, int indent, const SSL *ssl, 1080 const unsigned char *msg, size_t msglen) 1081 { 1082 const char *algname; 1083 int id = ssl_get_keyex(&algname, ssl); 1084 1085 BIO_indent(bio, indent, 80); 1086 BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname); 1087 if (id & SSL_PSK) { 1088 if (!ssl_print_hexbuf(bio, indent + 2, 1089 "psk_identity", 2, &msg, &msglen)) 1090 return 0; 1091 } 1092 switch (id) { 1093 1094 case SSL_kRSA: 1095 case SSL_kRSAPSK: 1096 if (TLS1_get_version(ssl) == SSL3_VERSION) { 1097 ssl_print_hex(bio, indent + 2, 1098 "EncryptedPreMasterSecret", msg, msglen); 1099 } else { 1100 if (!ssl_print_hexbuf(bio, indent + 2, 1101 "EncryptedPreMasterSecret", 2, &msg, &msglen)) 1102 return 0; 1103 } 1104 break; 1105 1106 case SSL_kDHE: 1107 case SSL_kDHEPSK: 1108 if (!ssl_print_hexbuf(bio, indent + 2, "dh_Yc", 2, &msg, &msglen)) 1109 return 0; 1110 break; 1111 1112 case SSL_kECDHE: 1113 case SSL_kECDHEPSK: 1114 if (!ssl_print_hexbuf(bio, indent + 2, "ecdh_Yc", 1, &msg, &msglen)) 1115 return 0; 1116 break; 1117 1118 } 1119 1120 return !msglen; 1121 } 1122 1123 static int ssl_print_server_keyex(BIO *bio, int indent, const SSL *ssl, 1124 const unsigned char *msg, size_t msglen) 1125 { 1126 const char *algname; 1127 int id = ssl_get_keyex(&algname, ssl); 1128 1129 BIO_indent(bio, indent, 80); 1130 BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname); 1131 if (id & SSL_PSK) { 1132 if (!ssl_print_hexbuf(bio, indent + 2, 1133 "psk_identity_hint", 2, &msg, &msglen)) 1134 return 0; 1135 } 1136 switch (id) { 1137 case SSL_kRSA: 1138 1139 if (!ssl_print_hexbuf(bio, indent + 2, "rsa_modulus", 2, &msg, &msglen)) 1140 return 0; 1141 if (!ssl_print_hexbuf(bio, indent + 2, "rsa_exponent", 2, 1142 &msg, &msglen)) 1143 return 0; 1144 break; 1145 1146 case SSL_kDHE: 1147 case SSL_kDHEPSK: 1148 if (!ssl_print_hexbuf(bio, indent + 2, "dh_p", 2, &msg, &msglen)) 1149 return 0; 1150 if (!ssl_print_hexbuf(bio, indent + 2, "dh_g", 2, &msg, &msglen)) 1151 return 0; 1152 if (!ssl_print_hexbuf(bio, indent + 2, "dh_Ys", 2, &msg, &msglen)) 1153 return 0; 1154 break; 1155 1156 # ifndef OPENSSL_NO_EC 1157 case SSL_kECDHE: 1158 case SSL_kECDHEPSK: 1159 if (msglen < 1) 1160 return 0; 1161 BIO_indent(bio, indent + 2, 80); 1162 if (msg[0] == EXPLICIT_PRIME_CURVE_TYPE) 1163 BIO_puts(bio, "explicit_prime\n"); 1164 else if (msg[0] == EXPLICIT_CHAR2_CURVE_TYPE) 1165 BIO_puts(bio, "explicit_char2\n"); 1166 else if (msg[0] == NAMED_CURVE_TYPE) { 1167 int curve; 1168 if (msglen < 3) 1169 return 0; 1170 curve = (msg[1] << 8) | msg[2]; 1171 BIO_printf(bio, "named_curve: %s (%d)\n", 1172 ssl_trace_str(curve, ssl_groups_tbl), curve); 1173 msg += 3; 1174 msglen -= 3; 1175 if (!ssl_print_hexbuf(bio, indent + 2, "point", 1, &msg, &msglen)) 1176 return 0; 1177 } else { 1178 BIO_printf(bio, "UNKNOWN CURVE PARAMETER TYPE %d\n", msg[0]); 1179 return 0; 1180 } 1181 break; 1182 # endif 1183 1184 case SSL_kPSK: 1185 case SSL_kRSAPSK: 1186 break; 1187 } 1188 if (!(id & SSL_PSK)) 1189 ssl_print_signature(bio, indent, ssl, &msg, &msglen); 1190 return !msglen; 1191 } 1192 1193 static int ssl_print_certificate(BIO *bio, int indent, 1194 const unsigned char **pmsg, size_t *pmsglen) 1195 { 1196 size_t msglen = *pmsglen; 1197 size_t clen; 1198 X509 *x; 1199 const unsigned char *p = *pmsg, *q; 1200 1201 if (msglen < 3) 1202 return 0; 1203 clen = (p[0] << 16) | (p[1] << 8) | p[2]; 1204 if (msglen < clen + 3) 1205 return 0; 1206 q = p + 3; 1207 BIO_indent(bio, indent, 80); 1208 BIO_printf(bio, "ASN.1Cert, length=%d", (int)clen); 1209 x = d2i_X509(NULL, &q, clen); 1210 if (!x) 1211 BIO_puts(bio, "<UNPARSEABLE CERTIFICATE>\n"); 1212 else { 1213 BIO_puts(bio, "\n------details-----\n"); 1214 X509_print_ex(bio, x, XN_FLAG_ONELINE, 0); 1215 PEM_write_bio_X509(bio, x); 1216 /* Print certificate stuff */ 1217 BIO_puts(bio, "------------------\n"); 1218 X509_free(x); 1219 } 1220 if (q != p + 3 + clen) { 1221 BIO_puts(bio, "<TRAILING GARBAGE AFTER CERTIFICATE>\n"); 1222 } 1223 *pmsg += clen + 3; 1224 *pmsglen -= clen + 3; 1225 return 1; 1226 } 1227 1228 static int ssl_print_certificates(BIO *bio, const SSL *ssl, int server, 1229 int indent, const unsigned char *msg, 1230 size_t msglen) 1231 { 1232 size_t clen; 1233 1234 if (SSL_IS_TLS13(ssl) 1235 && !ssl_print_hexbuf(bio, indent, "context", 1, &msg, &msglen)) 1236 return 0; 1237 1238 if (msglen < 3) 1239 return 0; 1240 clen = (msg[0] << 16) | (msg[1] << 8) | msg[2]; 1241 if (msglen != clen + 3) 1242 return 0; 1243 msg += 3; 1244 BIO_indent(bio, indent, 80); 1245 BIO_printf(bio, "certificate_list, length=%d\n", (int)clen); 1246 while (clen > 0) { 1247 if (!ssl_print_certificate(bio, indent + 2, &msg, &clen)) 1248 return 0; 1249 if (SSL_IS_TLS13(ssl) 1250 && !ssl_print_extensions(bio, indent + 2, server, 1251 SSL3_MT_CERTIFICATE, &msg, &clen)) 1252 return 0; 1253 1254 } 1255 return 1; 1256 } 1257 1258 static int ssl_print_cert_request(BIO *bio, int indent, const SSL *ssl, 1259 const unsigned char *msg, size_t msglen) 1260 { 1261 size_t xlen; 1262 unsigned int sigalg; 1263 1264 if (SSL_IS_TLS13(ssl)) { 1265 if (!ssl_print_hexbuf(bio, indent, "request_context", 1, &msg, &msglen)) 1266 return 0; 1267 if (!ssl_print_extensions(bio, indent, 1, 1268 SSL3_MT_CERTIFICATE_REQUEST, &msg, &msglen)) 1269 return 0; 1270 return 1; 1271 } else { 1272 if (msglen < 1) 1273 return 0; 1274 xlen = msg[0]; 1275 if (msglen < xlen + 1) 1276 return 0; 1277 msg++; 1278 BIO_indent(bio, indent, 80); 1279 BIO_printf(bio, "certificate_types (len=%d)\n", (int)xlen); 1280 if (!ssl_trace_list(bio, indent + 2, msg, xlen, 1, ssl_ctype_tbl)) 1281 return 0; 1282 msg += xlen; 1283 msglen -= xlen + 1; 1284 } 1285 if (SSL_USE_SIGALGS(ssl)) { 1286 if (msglen < 2) 1287 return 0; 1288 xlen = (msg[0] << 8) | msg[1]; 1289 if (msglen < xlen + 2 || (xlen & 1)) 1290 return 0; 1291 msg += 2; 1292 msglen -= xlen + 2; 1293 BIO_indent(bio, indent, 80); 1294 BIO_printf(bio, "signature_algorithms (len=%d)\n", (int)xlen); 1295 while (xlen > 0) { 1296 BIO_indent(bio, indent + 2, 80); 1297 sigalg = (msg[0] << 8) | msg[1]; 1298 BIO_printf(bio, "%s (0x%04x)\n", 1299 ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg); 1300 xlen -= 2; 1301 msg += 2; 1302 } 1303 msg += xlen; 1304 } 1305 1306 if (msglen < 2) 1307 return 0; 1308 xlen = (msg[0] << 8) | msg[1]; 1309 BIO_indent(bio, indent, 80); 1310 if (msglen < xlen + 2) 1311 return 0; 1312 msg += 2; 1313 msglen -= 2 + xlen; 1314 BIO_printf(bio, "certificate_authorities (len=%d)\n", (int)xlen); 1315 while (xlen > 0) { 1316 size_t dlen; 1317 X509_NAME *nm; 1318 const unsigned char *p; 1319 if (xlen < 2) 1320 return 0; 1321 dlen = (msg[0] << 8) | msg[1]; 1322 if (xlen < dlen + 2) 1323 return 0; 1324 msg += 2; 1325 BIO_indent(bio, indent + 2, 80); 1326 BIO_printf(bio, "DistinguishedName (len=%d): ", (int)dlen); 1327 p = msg; 1328 nm = d2i_X509_NAME(NULL, &p, dlen); 1329 if (!nm) { 1330 BIO_puts(bio, "<UNPARSEABLE DN>\n"); 1331 } else { 1332 X509_NAME_print_ex(bio, nm, 0, XN_FLAG_ONELINE); 1333 BIO_puts(bio, "\n"); 1334 X509_NAME_free(nm); 1335 } 1336 xlen -= dlen + 2; 1337 msg += dlen; 1338 } 1339 if (SSL_IS_TLS13(ssl)) { 1340 if (!ssl_print_hexbuf(bio, indent, "request_extensions", 2, 1341 &msg, &msglen)) 1342 return 0; 1343 } 1344 return msglen == 0; 1345 } 1346 1347 static int ssl_print_ticket(BIO *bio, int indent, const SSL *ssl, 1348 const unsigned char *msg, size_t msglen) 1349 { 1350 unsigned int tick_life; 1351 1352 if (msglen == 0) { 1353 BIO_indent(bio, indent + 2, 80); 1354 BIO_puts(bio, "No Ticket\n"); 1355 return 1; 1356 } 1357 if (msglen < 4) 1358 return 0; 1359 tick_life = (msg[0] << 24) | (msg[1] << 16) | (msg[2] << 8) | msg[3]; 1360 msglen -= 4; 1361 msg += 4; 1362 BIO_indent(bio, indent + 2, 80); 1363 BIO_printf(bio, "ticket_lifetime_hint=%u\n", tick_life); 1364 if (SSL_IS_TLS13(ssl)) { 1365 unsigned int ticket_age_add; 1366 1367 if (msglen < 4) 1368 return 0; 1369 ticket_age_add = 1370 (msg[0] << 24) | (msg[1] << 16) | (msg[2] << 8) | msg[3]; 1371 msglen -= 4; 1372 msg += 4; 1373 BIO_indent(bio, indent + 2, 80); 1374 BIO_printf(bio, "ticket_age_add=%u\n", ticket_age_add); 1375 if (!ssl_print_hexbuf(bio, indent + 2, "ticket_nonce", 1, &msg, 1376 &msglen)) 1377 return 0; 1378 } 1379 if (!ssl_print_hexbuf(bio, indent + 2, "ticket", 2, &msg, &msglen)) 1380 return 0; 1381 if (SSL_IS_TLS13(ssl) 1382 && !ssl_print_extensions(bio, indent + 2, 0, 1383 SSL3_MT_NEWSESSION_TICKET, &msg, &msglen)) 1384 return 0; 1385 if (msglen) 1386 return 0; 1387 return 1; 1388 } 1389 1390 static int ssl_print_handshake(BIO *bio, const SSL *ssl, int server, 1391 const unsigned char *msg, size_t msglen, 1392 int indent) 1393 { 1394 size_t hlen; 1395 unsigned char htype; 1396 1397 if (msglen < 4) 1398 return 0; 1399 htype = msg[0]; 1400 hlen = (msg[1] << 16) | (msg[2] << 8) | msg[3]; 1401 BIO_indent(bio, indent, 80); 1402 BIO_printf(bio, "%s, Length=%d\n", 1403 ssl_trace_str(htype, ssl_handshake_tbl), (int)hlen); 1404 msg += 4; 1405 msglen -= 4; 1406 if (SSL_IS_DTLS(ssl)) { 1407 if (msglen < 8) 1408 return 0; 1409 BIO_indent(bio, indent, 80); 1410 BIO_printf(bio, "message_seq=%d, fragment_offset=%d, " 1411 "fragment_length=%d\n", 1412 (msg[0] << 8) | msg[1], 1413 (msg[2] << 16) | (msg[3] << 8) | msg[4], 1414 (msg[5] << 16) | (msg[6] << 8) | msg[7]); 1415 msg += 8; 1416 msglen -= 8; 1417 } 1418 if (msglen < hlen) 1419 return 0; 1420 switch (htype) { 1421 case SSL3_MT_CLIENT_HELLO: 1422 if (!ssl_print_client_hello(bio, ssl, indent + 2, msg, msglen)) 1423 return 0; 1424 break; 1425 1426 case DTLS1_MT_HELLO_VERIFY_REQUEST: 1427 if (!dtls_print_hello_vfyrequest(bio, indent + 2, msg, msglen)) 1428 return 0; 1429 break; 1430 1431 case SSL3_MT_SERVER_HELLO: 1432 if (!ssl_print_server_hello(bio, indent + 2, msg, msglen)) 1433 return 0; 1434 break; 1435 1436 case SSL3_MT_SERVER_KEY_EXCHANGE: 1437 if (!ssl_print_server_keyex(bio, indent + 2, ssl, msg, msglen)) 1438 return 0; 1439 break; 1440 1441 case SSL3_MT_CLIENT_KEY_EXCHANGE: 1442 if (!ssl_print_client_keyex(bio, indent + 2, ssl, msg, msglen)) 1443 return 0; 1444 break; 1445 1446 case SSL3_MT_CERTIFICATE: 1447 if (!ssl_print_certificates(bio, ssl, server, indent + 2, msg, msglen)) 1448 return 0; 1449 break; 1450 1451 case SSL3_MT_CERTIFICATE_VERIFY: 1452 if (!ssl_print_signature(bio, indent + 2, ssl, &msg, &msglen)) 1453 return 0; 1454 break; 1455 1456 case SSL3_MT_CERTIFICATE_REQUEST: 1457 if (!ssl_print_cert_request(bio, indent + 2, ssl, msg, msglen)) 1458 return 0; 1459 break; 1460 1461 case SSL3_MT_FINISHED: 1462 ssl_print_hex(bio, indent + 2, "verify_data", msg, msglen); 1463 break; 1464 1465 case SSL3_MT_SERVER_DONE: 1466 if (msglen != 0) 1467 ssl_print_hex(bio, indent + 2, "unexpected value", msg, msglen); 1468 break; 1469 1470 case SSL3_MT_NEWSESSION_TICKET: 1471 if (!ssl_print_ticket(bio, indent + 2, ssl, msg, msglen)) 1472 return 0; 1473 break; 1474 1475 case SSL3_MT_ENCRYPTED_EXTENSIONS: 1476 if (!ssl_print_extensions(bio, indent + 2, 1, 1477 SSL3_MT_ENCRYPTED_EXTENSIONS, &msg, &msglen)) 1478 return 0; 1479 break; 1480 1481 case SSL3_MT_KEY_UPDATE: 1482 if (msglen != 1) { 1483 ssl_print_hex(bio, indent + 2, "unexpected value", msg, msglen); 1484 return 0; 1485 } 1486 if (!ssl_trace_list(bio, indent + 2, msg, msglen, 1, 1487 ssl_key_update_tbl)) 1488 return 0; 1489 break; 1490 1491 default: 1492 BIO_indent(bio, indent + 2, 80); 1493 BIO_puts(bio, "Unsupported, hex dump follows:\n"); 1494 BIO_dump_indent(bio, (const char *)msg, msglen, indent + 4); 1495 } 1496 return 1; 1497 } 1498 1499 void SSL_trace(int write_p, int version, int content_type, 1500 const void *buf, size_t msglen, SSL *ssl, void *arg) 1501 { 1502 const unsigned char *msg = buf; 1503 BIO *bio = arg; 1504 1505 switch (content_type) { 1506 case SSL3_RT_HEADER: 1507 { 1508 int hvers; 1509 1510 /* avoid overlapping with length at the end of buffer */ 1511 if (msglen < (size_t)(SSL_IS_DTLS(ssl) ? 1512 DTLS1_RT_HEADER_LENGTH : SSL3_RT_HEADER_LENGTH)) { 1513 BIO_puts(bio, write_p ? "Sent" : "Received"); 1514 ssl_print_hex(bio, 0, " too short message", msg, msglen); 1515 break; 1516 } 1517 hvers = msg[1] << 8 | msg[2]; 1518 BIO_puts(bio, write_p ? "Sent" : "Received"); 1519 BIO_printf(bio, " Record\nHeader:\n Version = %s (0x%x)\n", 1520 ssl_trace_str(hvers, ssl_version_tbl), hvers); 1521 if (SSL_IS_DTLS(ssl)) { 1522 BIO_printf(bio, 1523 " epoch=%d, sequence_number=%04x%04x%04x\n", 1524 (msg[3] << 8 | msg[4]), 1525 (msg[5] << 8 | msg[6]), 1526 (msg[7] << 8 | msg[8]), (msg[9] << 8 | msg[10])); 1527 } 1528 1529 BIO_printf(bio, " Content Type = %s (%d)\n Length = %d", 1530 ssl_trace_str(msg[0], ssl_content_tbl), msg[0], 1531 msg[msglen - 2] << 8 | msg[msglen - 1]); 1532 } 1533 break; 1534 1535 case SSL3_RT_INNER_CONTENT_TYPE: 1536 BIO_printf(bio, " Inner Content Type = %s (%d)", 1537 ssl_trace_str(msg[0], ssl_content_tbl), msg[0]); 1538 break; 1539 1540 case SSL3_RT_HANDSHAKE: 1541 if (!ssl_print_handshake(bio, ssl, ssl->server ? write_p : !write_p, 1542 msg, msglen, 4)) 1543 BIO_printf(bio, "Message length parse error!\n"); 1544 break; 1545 1546 case SSL3_RT_CHANGE_CIPHER_SPEC: 1547 if (msglen == 1 && msg[0] == 1) 1548 BIO_puts(bio, " change_cipher_spec (1)\n"); 1549 else 1550 ssl_print_hex(bio, 4, "unknown value", msg, msglen); 1551 break; 1552 1553 case SSL3_RT_ALERT: 1554 if (msglen != 2) 1555 BIO_puts(bio, " Illegal Alert Length\n"); 1556 else { 1557 BIO_printf(bio, " Level=%s(%d), description=%s(%d)\n", 1558 SSL_alert_type_string_long(msg[0] << 8), 1559 msg[0], SSL_alert_desc_string_long(msg[1]), msg[1]); 1560 } 1561 1562 } 1563 1564 BIO_puts(bio, "\n"); 1565 } 1566 1567 #endif 1568