wolf SSL / wolfSSL

wolfSSL SSL/TLS library, support up to TLS1.3

Dependents:   CyaSSL-Twitter-OAuth4Tw Example-client-tls-cert TwitterReader TweetTest ... more

src/sniffer.c@13:f67a6c6013ca, 2017-08-22 (annotated)

Committer:
wolfSSL
Date:
Tue Aug 22 10:48:22 2017 +0000
Revision:
13:f67a6c6013ca
wolfSSL3.12.0 with TLS1.3

Who changed what in which revision?

UserRevisionLine numberNew contents of line
wolfSSL 13:f67a6c6013ca 1 /* sniffer.c
wolfSSL 13:f67a6c6013ca 2 *
wolfSSL 13:f67a6c6013ca 3 * Copyright (C) 2006-2016 wolfSSL Inc.
wolfSSL 13:f67a6c6013ca 4 *
wolfSSL 13:f67a6c6013ca 5 * This file is part of wolfSSL.
wolfSSL 13:f67a6c6013ca 6 *
wolfSSL 13:f67a6c6013ca 7 * wolfSSL is free software; you can redistribute it and/or modify
wolfSSL 13:f67a6c6013ca 8 * it under the terms of the GNU General Public License as published by
wolfSSL 13:f67a6c6013ca 9 * the Free Software Foundation; either version 2 of the License, or
wolfSSL 13:f67a6c6013ca 10 * (at your option) any later version.
wolfSSL 13:f67a6c6013ca 11 *
wolfSSL 13:f67a6c6013ca 12 * wolfSSL is distributed in the hope that it will be useful,
wolfSSL 13:f67a6c6013ca 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
wolfSSL 13:f67a6c6013ca 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
wolfSSL 13:f67a6c6013ca 15 * GNU General Public License for more details.
wolfSSL 13:f67a6c6013ca 16 *
wolfSSL 13:f67a6c6013ca 17 * You should have received a copy of the GNU General Public License
wolfSSL 13:f67a6c6013ca 18 * along with this program; if not, write to the Free Software
wolfSSL 13:f67a6c6013ca 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
wolfSSL 13:f67a6c6013ca 20 */
wolfSSL 13:f67a6c6013ca 21
wolfSSL 13:f67a6c6013ca 22
wolfSSL 13:f67a6c6013ca 23 #ifdef HAVE_CONFIG_H
wolfSSL 13:f67a6c6013ca 24 #include <config.h>
wolfSSL 13:f67a6c6013ca 25 #endif
wolfSSL 13:f67a6c6013ca 26
wolfSSL 13:f67a6c6013ca 27 #include <wolfssl/wolfcrypt/settings.h>
wolfSSL 13:f67a6c6013ca 28
wolfSSL 13:f67a6c6013ca 29 #ifndef WOLFCRYPT_ONLY
wolfSSL 13:f67a6c6013ca 30 #ifdef WOLFSSL_SNIFFER
wolfSSL 13:f67a6c6013ca 31
wolfSSL 13:f67a6c6013ca 32 #include <assert.h>
wolfSSL 13:f67a6c6013ca 33 #include <time.h>
wolfSSL 13:f67a6c6013ca 34
wolfSSL 13:f67a6c6013ca 35 #ifndef _WIN32
wolfSSL 13:f67a6c6013ca 36 #include <arpa/inet.h>
wolfSSL 13:f67a6c6013ca 37 #endif
wolfSSL 13:f67a6c6013ca 38
wolfSSL 13:f67a6c6013ca 39 #ifdef _WIN32
wolfSSL 13:f67a6c6013ca 40 #define SNPRINTF _snprintf
wolfSSL 13:f67a6c6013ca 41 #else
wolfSSL 13:f67a6c6013ca 42 #define SNPRINTF snprintf
wolfSSL 13:f67a6c6013ca 43 #endif
wolfSSL 13:f67a6c6013ca 44
wolfSSL 13:f67a6c6013ca 45 #include <wolfssl/openssl/ssl.h>
wolfSSL 13:f67a6c6013ca 46 #include <wolfssl/internal.h>
wolfSSL 13:f67a6c6013ca 47 #include <wolfssl/error-ssl.h>
wolfSSL 13:f67a6c6013ca 48 #include <wolfssl/sniffer.h>
wolfSSL 13:f67a6c6013ca 49 #include <wolfssl/sniffer_error.h>
wolfSSL 13:f67a6c6013ca 50 #ifdef NO_INLINE
wolfSSL 13:f67a6c6013ca 51 #include <wolfssl/wolfcrypt/misc.h>
wolfSSL 13:f67a6c6013ca 52 #else
wolfSSL 13:f67a6c6013ca 53 #define WOLFSSL_MISC_INCLUDED
wolfSSL 13:f67a6c6013ca 54 #include <wolfcrypt/src/misc.c>
wolfSSL 13:f67a6c6013ca 55 #endif
wolfSSL 13:f67a6c6013ca 56
wolfSSL 13:f67a6c6013ca 57
wolfSSL 13:f67a6c6013ca 58 #ifndef WOLFSSL_SNIFFER_TIMEOUT
wolfSSL 13:f67a6c6013ca 59 #define WOLFSSL_SNIFFER_TIMEOUT 900
wolfSSL 13:f67a6c6013ca 60 /* Cache unclosed Sessions for 15 minutes since last used */
wolfSSL 13:f67a6c6013ca 61 #endif
wolfSSL 13:f67a6c6013ca 62
wolfSSL 13:f67a6c6013ca 63 /* Misc constants */
wolfSSL 13:f67a6c6013ca 64 enum {
wolfSSL 13:f67a6c6013ca 65 MAX_SERVER_ADDRESS = 128, /* maximum server address length */
wolfSSL 13:f67a6c6013ca 66 MAX_SERVER_NAME = 128, /* maximum server name length */
wolfSSL 13:f67a6c6013ca 67 MAX_ERROR_LEN = 80, /* maximum error length */
wolfSSL 13:f67a6c6013ca 68 ETHER_IF_ADDR_LEN = 6, /* ethernet interface address length */
wolfSSL 13:f67a6c6013ca 69 LOCAL_IF_ADDR_LEN = 4, /* localhost interface address length, !windows */
wolfSSL 13:f67a6c6013ca 70 TCP_PROTO = 6, /* TCP_PROTOCOL */
wolfSSL 13:f67a6c6013ca 71 IP_HDR_SZ = 20, /* IP header length, min */
wolfSSL 13:f67a6c6013ca 72 TCP_HDR_SZ = 20, /* TCP header length, min */
wolfSSL 13:f67a6c6013ca 73 IPV4 = 4, /* IP version 4 */
wolfSSL 13:f67a6c6013ca 74 TCP_PROTOCOL = 6, /* TCP Protocol id */
wolfSSL 13:f67a6c6013ca 75 TRACE_MSG_SZ = 80, /* Trace Message buffer size */
wolfSSL 13:f67a6c6013ca 76 HASH_SIZE = 499, /* Session Hash Table Rows */
wolfSSL 13:f67a6c6013ca 77 PSEUDO_HDR_SZ = 12, /* TCP Pseudo Header size in bytes */
wolfSSL 13:f67a6c6013ca 78 FATAL_ERROR_STATE = 1, /* SnifferSession fatal error state */
wolfSSL 13:f67a6c6013ca 79 TICKET_HINT_LEN = 4, /* Session Ticket Hint length */
wolfSSL 13:f67a6c6013ca 80 EXT_TYPE_SZ = 2, /* Extension length */
wolfSSL 13:f67a6c6013ca 81 MAX_INPUT_SZ = MAX_RECORD_SIZE + COMP_EXTRA + MAX_MSG_EXTRA +
wolfSSL 13:f67a6c6013ca 82 MTU_EXTRA, /* Max input sz of reassembly */
wolfSSL 13:f67a6c6013ca 83 EXT_MASTER_SECRET = 0x17, /* Extended Master Secret Extension ID */
wolfSSL 13:f67a6c6013ca 84 TICKET_EXT_ID = 0x23 /* Session Ticket Extension ID */
wolfSSL 13:f67a6c6013ca 85 };
wolfSSL 13:f67a6c6013ca 86
wolfSSL 13:f67a6c6013ca 87
wolfSSL 13:f67a6c6013ca 88 #ifdef _WIN32
wolfSSL 13:f67a6c6013ca 89
wolfSSL 13:f67a6c6013ca 90 static HMODULE dllModule; /* for error string resources */
wolfSSL 13:f67a6c6013ca 91
wolfSSL 13:f67a6c6013ca 92 BOOL APIENTRY DllMain( HMODULE hModule,
wolfSSL 13:f67a6c6013ca 93 DWORD ul_reason_for_call,
wolfSSL 13:f67a6c6013ca 94 LPVOID lpReserved
wolfSSL 13:f67a6c6013ca 95 )
wolfSSL 13:f67a6c6013ca 96 {
wolfSSL 13:f67a6c6013ca 97 static int didInit = 0;
wolfSSL 13:f67a6c6013ca 98
wolfSSL 13:f67a6c6013ca 99 switch (ul_reason_for_call)
wolfSSL 13:f67a6c6013ca 100 {
wolfSSL 13:f67a6c6013ca 101 case DLL_PROCESS_ATTACH:
wolfSSL 13:f67a6c6013ca 102 if (didInit == 0) {
wolfSSL 13:f67a6c6013ca 103 dllModule = hModule;
wolfSSL 13:f67a6c6013ca 104 ssl_InitSniffer();
wolfSSL 13:f67a6c6013ca 105 didInit = 1;
wolfSSL 13:f67a6c6013ca 106 }
wolfSSL 13:f67a6c6013ca 107 break;
wolfSSL 13:f67a6c6013ca 108 case DLL_THREAD_ATTACH:
wolfSSL 13:f67a6c6013ca 109 break;
wolfSSL 13:f67a6c6013ca 110 case DLL_THREAD_DETACH:
wolfSSL 13:f67a6c6013ca 111 break;
wolfSSL 13:f67a6c6013ca 112 case DLL_PROCESS_DETACH:
wolfSSL 13:f67a6c6013ca 113 if (didInit) {
wolfSSL 13:f67a6c6013ca 114 ssl_FreeSniffer();
wolfSSL 13:f67a6c6013ca 115 didInit = 0;
wolfSSL 13:f67a6c6013ca 116 }
wolfSSL 13:f67a6c6013ca 117 break;
wolfSSL 13:f67a6c6013ca 118 }
wolfSSL 13:f67a6c6013ca 119 return TRUE;
wolfSSL 13:f67a6c6013ca 120 }
wolfSSL 13:f67a6c6013ca 121
wolfSSL 13:f67a6c6013ca 122 #endif /* _WIN32 */
wolfSSL 13:f67a6c6013ca 123
wolfSSL 13:f67a6c6013ca 124
wolfSSL 13:f67a6c6013ca 125 static int TraceOn = 0; /* Trace is off by default */
wolfSSL 13:f67a6c6013ca 126 static FILE* TraceFile = 0;
wolfSSL 13:f67a6c6013ca 127
wolfSSL 13:f67a6c6013ca 128
wolfSSL 13:f67a6c6013ca 129 /* windows uses .rc table for this */
wolfSSL 13:f67a6c6013ca 130 #ifndef _WIN32
wolfSSL 13:f67a6c6013ca 131
wolfSSL 13:f67a6c6013ca 132 static const char* const msgTable[] =
wolfSSL 13:f67a6c6013ca 133 {
wolfSSL 13:f67a6c6013ca 134 /* 1 */
wolfSSL 13:f67a6c6013ca 135 "Out of Memory",
wolfSSL 13:f67a6c6013ca 136 "New SSL Sniffer Server Registered",
wolfSSL 13:f67a6c6013ca 137 "Checking IP Header",
wolfSSL 13:f67a6c6013ca 138 "SSL Sniffer Server Not Registered",
wolfSSL 13:f67a6c6013ca 139 "Checking TCP Header",
wolfSSL 13:f67a6c6013ca 140
wolfSSL 13:f67a6c6013ca 141 /* 6 */
wolfSSL 13:f67a6c6013ca 142 "SSL Sniffer Server Port Not Registered",
wolfSSL 13:f67a6c6013ca 143 "RSA Private Decrypt Error",
wolfSSL 13:f67a6c6013ca 144 "RSA Private Decode Error",
wolfSSL 13:f67a6c6013ca 145 "Set Cipher Spec Error",
wolfSSL 13:f67a6c6013ca 146 "Server Hello Input Malformed",
wolfSSL 13:f67a6c6013ca 147
wolfSSL 13:f67a6c6013ca 148 /* 11 */
wolfSSL 13:f67a6c6013ca 149 "Couldn't Resume Session Error",
wolfSSL 13:f67a6c6013ca 150 "Server Did Resumption",
wolfSSL 13:f67a6c6013ca 151 "Client Hello Input Malformed",
wolfSSL 13:f67a6c6013ca 152 "Client Trying to Resume",
wolfSSL 13:f67a6c6013ca 153 "Handshake Input Malformed",
wolfSSL 13:f67a6c6013ca 154
wolfSSL 13:f67a6c6013ca 155 /* 16 */
wolfSSL 13:f67a6c6013ca 156 "Got Hello Verify msg",
wolfSSL 13:f67a6c6013ca 157 "Got Server Hello msg",
wolfSSL 13:f67a6c6013ca 158 "Got Cert Request msg",
wolfSSL 13:f67a6c6013ca 159 "Got Server Key Exchange msg",
wolfSSL 13:f67a6c6013ca 160 "Got Cert msg",
wolfSSL 13:f67a6c6013ca 161
wolfSSL 13:f67a6c6013ca 162 /* 21 */
wolfSSL 13:f67a6c6013ca 163 "Got Server Hello Done msg",
wolfSSL 13:f67a6c6013ca 164 "Got Finished msg",
wolfSSL 13:f67a6c6013ca 165 "Got Client Hello msg",
wolfSSL 13:f67a6c6013ca 166 "Got Client Key Exchange msg",
wolfSSL 13:f67a6c6013ca 167 "Got Cert Verify msg",
wolfSSL 13:f67a6c6013ca 168
wolfSSL 13:f67a6c6013ca 169 /* 26 */
wolfSSL 13:f67a6c6013ca 170 "Got Unknown Handshake msg",
wolfSSL 13:f67a6c6013ca 171 "New SSL Sniffer Session created",
wolfSSL 13:f67a6c6013ca 172 "Couldn't create new SSL",
wolfSSL 13:f67a6c6013ca 173 "Got a Packet to decode",
wolfSSL 13:f67a6c6013ca 174 "No data present",
wolfSSL 13:f67a6c6013ca 175
wolfSSL 13:f67a6c6013ca 176 /* 31 */
wolfSSL 13:f67a6c6013ca 177 "Session Not Found",
wolfSSL 13:f67a6c6013ca 178 "Got an Old Client Hello msg",
wolfSSL 13:f67a6c6013ca 179 "Old Client Hello Input Malformed",
wolfSSL 13:f67a6c6013ca 180 "Old Client Hello OK",
wolfSSL 13:f67a6c6013ca 181 "Bad Old Client Hello",
wolfSSL 13:f67a6c6013ca 182
wolfSSL 13:f67a6c6013ca 183 /* 36 */
wolfSSL 13:f67a6c6013ca 184 "Bad Record Header",
wolfSSL 13:f67a6c6013ca 185 "Record Header Input Malformed",
wolfSSL 13:f67a6c6013ca 186 "Got a HandShake msg",
wolfSSL 13:f67a6c6013ca 187 "Bad HandShake msg",
wolfSSL 13:f67a6c6013ca 188 "Got a Change Cipher Spec msg",
wolfSSL 13:f67a6c6013ca 189
wolfSSL 13:f67a6c6013ca 190 /* 41 */
wolfSSL 13:f67a6c6013ca 191 "Got Application Data msg",
wolfSSL 13:f67a6c6013ca 192 "Bad Application Data",
wolfSSL 13:f67a6c6013ca 193 "Got an Alert msg",
wolfSSL 13:f67a6c6013ca 194 "Another msg to Process",
wolfSSL 13:f67a6c6013ca 195 "Removing Session From Table",
wolfSSL 13:f67a6c6013ca 196
wolfSSL 13:f67a6c6013ca 197 /* 46 */
wolfSSL 13:f67a6c6013ca 198 "Bad Key File",
wolfSSL 13:f67a6c6013ca 199 "Wrong IP Version",
wolfSSL 13:f67a6c6013ca 200 "Wrong Protocol type",
wolfSSL 13:f67a6c6013ca 201 "Packet Short for header processing",
wolfSSL 13:f67a6c6013ca 202 "Got Unknown Record Type",
wolfSSL 13:f67a6c6013ca 203
wolfSSL 13:f67a6c6013ca 204 /* 51 */
wolfSSL 13:f67a6c6013ca 205 "Can't Open Trace File",
wolfSSL 13:f67a6c6013ca 206 "Session in Fatal Error State",
wolfSSL 13:f67a6c6013ca 207 "Partial SSL record received",
wolfSSL 13:f67a6c6013ca 208 "Buffer Error, malformed input",
wolfSSL 13:f67a6c6013ca 209 "Added to Partial Input",
wolfSSL 13:f67a6c6013ca 210
wolfSSL 13:f67a6c6013ca 211 /* 56 */
wolfSSL 13:f67a6c6013ca 212 "Received a Duplicate Packet",
wolfSSL 13:f67a6c6013ca 213 "Received an Out of Order Packet",
wolfSSL 13:f67a6c6013ca 214 "Received an Overlap Duplicate Packet",
wolfSSL 13:f67a6c6013ca 215 "Received an Overlap Reassembly Begin Duplicate Packet",
wolfSSL 13:f67a6c6013ca 216 "Received an Overlap Reassembly End Duplicate Packet",
wolfSSL 13:f67a6c6013ca 217
wolfSSL 13:f67a6c6013ca 218 /* 61 */
wolfSSL 13:f67a6c6013ca 219 "Missed the Client Hello Entirely",
wolfSSL 13:f67a6c6013ca 220 "Got Hello Request msg",
wolfSSL 13:f67a6c6013ca 221 "Got Session Ticket msg",
wolfSSL 13:f67a6c6013ca 222 "Bad Input",
wolfSSL 13:f67a6c6013ca 223 "Bad Decrypt Type",
wolfSSL 13:f67a6c6013ca 224
wolfSSL 13:f67a6c6013ca 225 /* 66 */
wolfSSL 13:f67a6c6013ca 226 "Bad Finished Message Processing",
wolfSSL 13:f67a6c6013ca 227 "Bad Compression Type",
wolfSSL 13:f67a6c6013ca 228 "Bad DeriveKeys Error",
wolfSSL 13:f67a6c6013ca 229 "Saw ACK for Missing Packet Error",
wolfSSL 13:f67a6c6013ca 230 "Bad Decrypt Operation",
wolfSSL 13:f67a6c6013ca 231
wolfSSL 13:f67a6c6013ca 232 /* 71 */
wolfSSL 13:f67a6c6013ca 233 "Decrypt Keys Not Set Up",
wolfSSL 13:f67a6c6013ca 234 "Late Key Load Error",
wolfSSL 13:f67a6c6013ca 235 "Got Certificate Status msg",
wolfSSL 13:f67a6c6013ca 236 "RSA Key Missing Error",
wolfSSL 13:f67a6c6013ca 237 "Secure Renegotiation Not Supported",
wolfSSL 13:f67a6c6013ca 238
wolfSSL 13:f67a6c6013ca 239 /* 76 */
wolfSSL 13:f67a6c6013ca 240 "Get Session Stats Failure",
wolfSSL 13:f67a6c6013ca 241 "Reassembly Buffer Size Exceeded",
wolfSSL 13:f67a6c6013ca 242 "Dropping Lost Fragment",
wolfSSL 13:f67a6c6013ca 243 "Dropping Partial Record",
wolfSSL 13:f67a6c6013ca 244 "Clear ACK Fault",
wolfSSL 13:f67a6c6013ca 245
wolfSSL 13:f67a6c6013ca 246 /* 81 */
wolfSSL 13:f67a6c6013ca 247 "Bad Decrypt Size",
wolfSSL 13:f67a6c6013ca 248 "Extended Master Secret Hash Error"
wolfSSL 13:f67a6c6013ca 249 };
wolfSSL 13:f67a6c6013ca 250
wolfSSL 13:f67a6c6013ca 251
wolfSSL 13:f67a6c6013ca 252 /* *nix version uses table above */
wolfSSL 13:f67a6c6013ca 253 static void GetError(int idx, char* str)
wolfSSL 13:f67a6c6013ca 254 {
wolfSSL 13:f67a6c6013ca 255 XSTRNCPY(str, msgTable[idx - 1], MAX_ERROR_LEN);
wolfSSL 13:f67a6c6013ca 256 }
wolfSSL 13:f67a6c6013ca 257
wolfSSL 13:f67a6c6013ca 258
wolfSSL 13:f67a6c6013ca 259 #else /* _WIN32 */
wolfSSL 13:f67a6c6013ca 260
wolfSSL 13:f67a6c6013ca 261
wolfSSL 13:f67a6c6013ca 262 /* Windows version uses .rc table */
wolfSSL 13:f67a6c6013ca 263 static void GetError(int idx, char* buffer)
wolfSSL 13:f67a6c6013ca 264 {
wolfSSL 13:f67a6c6013ca 265 if (!LoadStringA(dllModule, idx, buffer, MAX_ERROR_LEN))
wolfSSL 13:f67a6c6013ca 266 buffer[0] = 0;
wolfSSL 13:f67a6c6013ca 267 }
wolfSSL 13:f67a6c6013ca 268
wolfSSL 13:f67a6c6013ca 269
wolfSSL 13:f67a6c6013ca 270 #endif /* _WIN32 */
wolfSSL 13:f67a6c6013ca 271
wolfSSL 13:f67a6c6013ca 272
wolfSSL 13:f67a6c6013ca 273 /* Packet Buffer for reassembly list and ready list */
wolfSSL 13:f67a6c6013ca 274 typedef struct PacketBuffer {
wolfSSL 13:f67a6c6013ca 275 word32 begin; /* relative sequence begin */
wolfSSL 13:f67a6c6013ca 276 word32 end; /* relative sequence end */
wolfSSL 13:f67a6c6013ca 277 byte* data; /* actual data */
wolfSSL 13:f67a6c6013ca 278 struct PacketBuffer* next; /* next on reassembly list or ready list */
wolfSSL 13:f67a6c6013ca 279 } PacketBuffer;
wolfSSL 13:f67a6c6013ca 280
wolfSSL 13:f67a6c6013ca 281
wolfSSL 13:f67a6c6013ca 282 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 283
wolfSSL 13:f67a6c6013ca 284 /* NamedKey maps a SNI name to a specific private key */
wolfSSL 13:f67a6c6013ca 285 typedef struct NamedKey {
wolfSSL 13:f67a6c6013ca 286 char name[MAX_SERVER_NAME]; /* server DNS name */
wolfSSL 13:f67a6c6013ca 287 word32 nameSz; /* size of server DNS name */
wolfSSL 13:f67a6c6013ca 288 byte* key; /* DER private key */
wolfSSL 13:f67a6c6013ca 289 word32 keySz; /* size of DER private key */
wolfSSL 13:f67a6c6013ca 290 struct NamedKey* next; /* for list */
wolfSSL 13:f67a6c6013ca 291 } NamedKey;
wolfSSL 13:f67a6c6013ca 292
wolfSSL 13:f67a6c6013ca 293 #endif
wolfSSL 13:f67a6c6013ca 294
wolfSSL 13:f67a6c6013ca 295
wolfSSL 13:f67a6c6013ca 296 /* Sniffer Server holds info for each server/port monitored */
wolfSSL 13:f67a6c6013ca 297 typedef struct SnifferServer {
wolfSSL 13:f67a6c6013ca 298 SSL_CTX* ctx; /* SSL context */
wolfSSL 13:f67a6c6013ca 299 char address[MAX_SERVER_ADDRESS]; /* passed in server address */
wolfSSL 13:f67a6c6013ca 300 word32 server; /* netowrk order address */
wolfSSL 13:f67a6c6013ca 301 int port; /* server port */
wolfSSL 13:f67a6c6013ca 302 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 303 NamedKey* namedKeys; /* mapping of names and keys */
wolfSSL 13:f67a6c6013ca 304 wolfSSL_Mutex namedKeysMutex; /* mutex for namedKey list */
wolfSSL 13:f67a6c6013ca 305 #endif
wolfSSL 13:f67a6c6013ca 306 struct SnifferServer* next; /* for list */
wolfSSL 13:f67a6c6013ca 307 } SnifferServer;
wolfSSL 13:f67a6c6013ca 308
wolfSSL 13:f67a6c6013ca 309
wolfSSL 13:f67a6c6013ca 310 /* Session Flags */
wolfSSL 13:f67a6c6013ca 311 typedef struct Flags {
wolfSSL 13:f67a6c6013ca 312 byte side; /* which end is current packet headed */
wolfSSL 13:f67a6c6013ca 313 byte serverCipherOn; /* indicates whether cipher is active */
wolfSSL 13:f67a6c6013ca 314 byte clientCipherOn; /* indicates whether cipher is active */
wolfSSL 13:f67a6c6013ca 315 byte resuming; /* did this session come from resumption */
wolfSSL 13:f67a6c6013ca 316 byte cached; /* have we cached this session yet */
wolfSSL 13:f67a6c6013ca 317 byte clientHello; /* processed client hello yet, for SSLv2 */
wolfSSL 13:f67a6c6013ca 318 byte finCount; /* get both FINs before removing */
wolfSSL 13:f67a6c6013ca 319 byte fatalError; /* fatal error state */
wolfSSL 13:f67a6c6013ca 320 byte cliAckFault; /* client acked unseen data from server */
wolfSSL 13:f67a6c6013ca 321 byte srvAckFault; /* server acked unseen data from client */
wolfSSL 13:f67a6c6013ca 322 byte cliSkipPartial; /* client skips partial data to catch up */
wolfSSL 13:f67a6c6013ca 323 byte srvSkipPartial; /* server skips partial data to catch up */
wolfSSL 13:f67a6c6013ca 324 #ifdef HAVE_EXTENDED_MASTER
wolfSSL 13:f67a6c6013ca 325 byte expectEms; /* expect extended master secret */
wolfSSL 13:f67a6c6013ca 326 #endif
wolfSSL 13:f67a6c6013ca 327 } Flags;
wolfSSL 13:f67a6c6013ca 328
wolfSSL 13:f67a6c6013ca 329
wolfSSL 13:f67a6c6013ca 330 /* Out of Order FIN caputre */
wolfSSL 13:f67a6c6013ca 331 typedef struct FinCaputre {
wolfSSL 13:f67a6c6013ca 332 word32 cliFinSeq; /* client relative sequence FIN 0 is no */
wolfSSL 13:f67a6c6013ca 333 word32 srvFinSeq; /* server relative sequence FIN, 0 is no */
wolfSSL 13:f67a6c6013ca 334 byte cliCounted; /* did we count yet, detects duplicates */
wolfSSL 13:f67a6c6013ca 335 byte srvCounted; /* did we count yet, detects duplicates */
wolfSSL 13:f67a6c6013ca 336 } FinCaputre;
wolfSSL 13:f67a6c6013ca 337
wolfSSL 13:f67a6c6013ca 338
wolfSSL 13:f67a6c6013ca 339 typedef struct HsHashes {
wolfSSL 13:f67a6c6013ca 340 #ifndef NO_OLD_TLS
wolfSSL 13:f67a6c6013ca 341 #ifndef NO_SHA
wolfSSL 13:f67a6c6013ca 342 Sha hashSha;
wolfSSL 13:f67a6c6013ca 343 #endif
wolfSSL 13:f67a6c6013ca 344 #ifndef NO_MD5
wolfSSL 13:f67a6c6013ca 345 Md5 hashMd5;
wolfSSL 13:f67a6c6013ca 346 #endif
wolfSSL 13:f67a6c6013ca 347 #endif
wolfSSL 13:f67a6c6013ca 348 #ifndef NO_SHA256
wolfSSL 13:f67a6c6013ca 349 Sha256 hashSha256;
wolfSSL 13:f67a6c6013ca 350 #endif
wolfSSL 13:f67a6c6013ca 351 #ifdef WOLFSSL_SHA384
wolfSSL 13:f67a6c6013ca 352 Sha384 hashSha384;
wolfSSL 13:f67a6c6013ca 353 #endif
wolfSSL 13:f67a6c6013ca 354 } HsHashes;
wolfSSL 13:f67a6c6013ca 355
wolfSSL 13:f67a6c6013ca 356
wolfSSL 13:f67a6c6013ca 357 /* Sniffer Session holds info for each client/server SSL/TLS session */
wolfSSL 13:f67a6c6013ca 358 typedef struct SnifferSession {
wolfSSL 13:f67a6c6013ca 359 SnifferServer* context; /* server context */
wolfSSL 13:f67a6c6013ca 360 SSL* sslServer; /* SSL server side decode */
wolfSSL 13:f67a6c6013ca 361 SSL* sslClient; /* SSL client side decode */
wolfSSL 13:f67a6c6013ca 362 word32 server; /* server address in network byte order */
wolfSSL 13:f67a6c6013ca 363 word32 client; /* client address in network byte order */
wolfSSL 13:f67a6c6013ca 364 word16 srvPort; /* server port */
wolfSSL 13:f67a6c6013ca 365 word16 cliPort; /* client port */
wolfSSL 13:f67a6c6013ca 366 word32 cliSeqStart; /* client start sequence */
wolfSSL 13:f67a6c6013ca 367 word32 srvSeqStart; /* server start sequence */
wolfSSL 13:f67a6c6013ca 368 word32 cliExpected; /* client expected sequence (relative) */
wolfSSL 13:f67a6c6013ca 369 word32 srvExpected; /* server expected sequence (relative) */
wolfSSL 13:f67a6c6013ca 370 FinCaputre finCaputre; /* retain out of order FIN s */
wolfSSL 13:f67a6c6013ca 371 Flags flags; /* session flags */
wolfSSL 13:f67a6c6013ca 372 time_t lastUsed; /* last used ticks */
wolfSSL 13:f67a6c6013ca 373 PacketBuffer* cliReassemblyList; /* client out of order packets */
wolfSSL 13:f67a6c6013ca 374 PacketBuffer* srvReassemblyList; /* server out of order packets */
wolfSSL 13:f67a6c6013ca 375 word32 cliReassemblyMemory; /* client packet memory used */
wolfSSL 13:f67a6c6013ca 376 word32 srvReassemblyMemory; /* server packet memory used */
wolfSSL 13:f67a6c6013ca 377 struct SnifferSession* next; /* for hash table list */
wolfSSL 13:f67a6c6013ca 378 byte* ticketID; /* mac ID of session ticket */
wolfSSL 13:f67a6c6013ca 379 #ifdef HAVE_EXTENDED_MASTER
wolfSSL 13:f67a6c6013ca 380 HsHashes* hash;
wolfSSL 13:f67a6c6013ca 381 #endif
wolfSSL 13:f67a6c6013ca 382 } SnifferSession;
wolfSSL 13:f67a6c6013ca 383
wolfSSL 13:f67a6c6013ca 384
wolfSSL 13:f67a6c6013ca 385 /* Sniffer Server List and mutex */
wolfSSL 13:f67a6c6013ca 386 static SnifferServer* ServerList = 0;
wolfSSL 13:f67a6c6013ca 387 static wolfSSL_Mutex ServerListMutex;
wolfSSL 13:f67a6c6013ca 388
wolfSSL 13:f67a6c6013ca 389
wolfSSL 13:f67a6c6013ca 390 /* Session Hash Table, mutex, and count */
wolfSSL 13:f67a6c6013ca 391 static SnifferSession* SessionTable[HASH_SIZE];
wolfSSL 13:f67a6c6013ca 392 static wolfSSL_Mutex SessionMutex;
wolfSSL 13:f67a6c6013ca 393 static int SessionCount = 0;
wolfSSL 13:f67a6c6013ca 394
wolfSSL 13:f67a6c6013ca 395 /* Recovery of missed data switches and stats */
wolfSSL 13:f67a6c6013ca 396 static wolfSSL_Mutex RecoveryMutex; /* for stats */
wolfSSL 13:f67a6c6013ca 397 static int RecoveryEnabled = 0; /* global switch */
wolfSSL 13:f67a6c6013ca 398 static int MaxRecoveryMemory = -1; /* per session max recovery memory */
wolfSSL 13:f67a6c6013ca 399 static word32 MissedDataSessions = 0; /* # of sessions with missed data */
wolfSSL 13:f67a6c6013ca 400
wolfSSL 13:f67a6c6013ca 401
wolfSSL 13:f67a6c6013ca 402 static void UpdateMissedDataSessions(void)
wolfSSL 13:f67a6c6013ca 403 {
wolfSSL 13:f67a6c6013ca 404 wc_LockMutex(&RecoveryMutex);
wolfSSL 13:f67a6c6013ca 405 MissedDataSessions += 1;
wolfSSL 13:f67a6c6013ca 406 wc_UnLockMutex(&RecoveryMutex);
wolfSSL 13:f67a6c6013ca 407 }
wolfSSL 13:f67a6c6013ca 408
wolfSSL 13:f67a6c6013ca 409
wolfSSL 13:f67a6c6013ca 410 /* Initialize overall Sniffer */
wolfSSL 13:f67a6c6013ca 411 void ssl_InitSniffer(void)
wolfSSL 13:f67a6c6013ca 412 {
wolfSSL 13:f67a6c6013ca 413 wolfSSL_Init();
wolfSSL 13:f67a6c6013ca 414 wc_InitMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 415 wc_InitMutex(&SessionMutex);
wolfSSL 13:f67a6c6013ca 416 wc_InitMutex(&RecoveryMutex);
wolfSSL 13:f67a6c6013ca 417 }
wolfSSL 13:f67a6c6013ca 418
wolfSSL 13:f67a6c6013ca 419
wolfSSL 13:f67a6c6013ca 420 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 421
wolfSSL 13:f67a6c6013ca 422 /* Free Named Key and the zero out the private key it holds */
wolfSSL 13:f67a6c6013ca 423 static void FreeNamedKey(NamedKey* in)
wolfSSL 13:f67a6c6013ca 424 {
wolfSSL 13:f67a6c6013ca 425 if (in) {
wolfSSL 13:f67a6c6013ca 426 if (in->key) {
wolfSSL 13:f67a6c6013ca 427 ForceZero(in->key, in->keySz);
wolfSSL 13:f67a6c6013ca 428 free(in->key);
wolfSSL 13:f67a6c6013ca 429 }
wolfSSL 13:f67a6c6013ca 430 free(in);
wolfSSL 13:f67a6c6013ca 431 }
wolfSSL 13:f67a6c6013ca 432 }
wolfSSL 13:f67a6c6013ca 433
wolfSSL 13:f67a6c6013ca 434
wolfSSL 13:f67a6c6013ca 435 static void FreeNamedKeyList(NamedKey* in)
wolfSSL 13:f67a6c6013ca 436 {
wolfSSL 13:f67a6c6013ca 437 NamedKey* next;
wolfSSL 13:f67a6c6013ca 438
wolfSSL 13:f67a6c6013ca 439 while (in) {
wolfSSL 13:f67a6c6013ca 440 next = in->next;
wolfSSL 13:f67a6c6013ca 441 FreeNamedKey(in);
wolfSSL 13:f67a6c6013ca 442 in = next;
wolfSSL 13:f67a6c6013ca 443 }
wolfSSL 13:f67a6c6013ca 444 }
wolfSSL 13:f67a6c6013ca 445
wolfSSL 13:f67a6c6013ca 446 #endif
wolfSSL 13:f67a6c6013ca 447
wolfSSL 13:f67a6c6013ca 448
wolfSSL 13:f67a6c6013ca 449 /* Free Sniffer Server's resources/self */
wolfSSL 13:f67a6c6013ca 450 static void FreeSnifferServer(SnifferServer* srv)
wolfSSL 13:f67a6c6013ca 451 {
wolfSSL 13:f67a6c6013ca 452 if (srv) {
wolfSSL 13:f67a6c6013ca 453 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 454 wc_LockMutex(&srv->namedKeysMutex);
wolfSSL 13:f67a6c6013ca 455 FreeNamedKeyList(srv->namedKeys);
wolfSSL 13:f67a6c6013ca 456 wc_UnLockMutex(&srv->namedKeysMutex);
wolfSSL 13:f67a6c6013ca 457 wc_FreeMutex(&srv->namedKeysMutex);
wolfSSL 13:f67a6c6013ca 458 #endif
wolfSSL 13:f67a6c6013ca 459 SSL_CTX_free(srv->ctx);
wolfSSL 13:f67a6c6013ca 460 }
wolfSSL 13:f67a6c6013ca 461 free(srv);
wolfSSL 13:f67a6c6013ca 462 }
wolfSSL 13:f67a6c6013ca 463
wolfSSL 13:f67a6c6013ca 464
wolfSSL 13:f67a6c6013ca 465 /* free PacketBuffer's resources/self */
wolfSSL 13:f67a6c6013ca 466 static void FreePacketBuffer(PacketBuffer* del)
wolfSSL 13:f67a6c6013ca 467 {
wolfSSL 13:f67a6c6013ca 468 if (del) {
wolfSSL 13:f67a6c6013ca 469 free(del->data);
wolfSSL 13:f67a6c6013ca 470 free(del);
wolfSSL 13:f67a6c6013ca 471 }
wolfSSL 13:f67a6c6013ca 472 }
wolfSSL 13:f67a6c6013ca 473
wolfSSL 13:f67a6c6013ca 474
wolfSSL 13:f67a6c6013ca 475 /* remove PacketBuffer List */
wolfSSL 13:f67a6c6013ca 476 static void FreePacketList(PacketBuffer* in)
wolfSSL 13:f67a6c6013ca 477 {
wolfSSL 13:f67a6c6013ca 478 if (in) {
wolfSSL 13:f67a6c6013ca 479 PacketBuffer* del;
wolfSSL 13:f67a6c6013ca 480 PacketBuffer* packet = in;
wolfSSL 13:f67a6c6013ca 481
wolfSSL 13:f67a6c6013ca 482 while (packet) {
wolfSSL 13:f67a6c6013ca 483 del = packet;
wolfSSL 13:f67a6c6013ca 484 packet = packet->next;
wolfSSL 13:f67a6c6013ca 485 FreePacketBuffer(del);
wolfSSL 13:f67a6c6013ca 486 }
wolfSSL 13:f67a6c6013ca 487 }
wolfSSL 13:f67a6c6013ca 488 }
wolfSSL 13:f67a6c6013ca 489
wolfSSL 13:f67a6c6013ca 490
wolfSSL 13:f67a6c6013ca 491 /* Free Sniffer Session's resources/self */
wolfSSL 13:f67a6c6013ca 492 static void FreeSnifferSession(SnifferSession* session)
wolfSSL 13:f67a6c6013ca 493 {
wolfSSL 13:f67a6c6013ca 494 if (session) {
wolfSSL 13:f67a6c6013ca 495 SSL_free(session->sslClient);
wolfSSL 13:f67a6c6013ca 496 SSL_free(session->sslServer);
wolfSSL 13:f67a6c6013ca 497
wolfSSL 13:f67a6c6013ca 498 FreePacketList(session->cliReassemblyList);
wolfSSL 13:f67a6c6013ca 499 FreePacketList(session->srvReassemblyList);
wolfSSL 13:f67a6c6013ca 500
wolfSSL 13:f67a6c6013ca 501 free(session->ticketID);
wolfSSL 13:f67a6c6013ca 502 #ifdef HAVE_EXTENDED_MASTER
wolfSSL 13:f67a6c6013ca 503 free(session->hash);
wolfSSL 13:f67a6c6013ca 504 #endif
wolfSSL 13:f67a6c6013ca 505 }
wolfSSL 13:f67a6c6013ca 506 free(session);
wolfSSL 13:f67a6c6013ca 507 }
wolfSSL 13:f67a6c6013ca 508
wolfSSL 13:f67a6c6013ca 509
wolfSSL 13:f67a6c6013ca 510 /* Free overall Sniffer */
wolfSSL 13:f67a6c6013ca 511 void ssl_FreeSniffer(void)
wolfSSL 13:f67a6c6013ca 512 {
wolfSSL 13:f67a6c6013ca 513 SnifferServer* srv;
wolfSSL 13:f67a6c6013ca 514 SnifferServer* removeServer;
wolfSSL 13:f67a6c6013ca 515 SnifferSession* session;
wolfSSL 13:f67a6c6013ca 516 SnifferSession* removeSession;
wolfSSL 13:f67a6c6013ca 517 int i;
wolfSSL 13:f67a6c6013ca 518
wolfSSL 13:f67a6c6013ca 519 wc_LockMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 520 wc_LockMutex(&SessionMutex);
wolfSSL 13:f67a6c6013ca 521
wolfSSL 13:f67a6c6013ca 522 srv = ServerList;
wolfSSL 13:f67a6c6013ca 523 while (srv) {
wolfSSL 13:f67a6c6013ca 524 removeServer = srv;
wolfSSL 13:f67a6c6013ca 525 srv = srv->next;
wolfSSL 13:f67a6c6013ca 526 FreeSnifferServer(removeServer);
wolfSSL 13:f67a6c6013ca 527 }
wolfSSL 13:f67a6c6013ca 528
wolfSSL 13:f67a6c6013ca 529 for (i = 0; i < HASH_SIZE; i++) {
wolfSSL 13:f67a6c6013ca 530 session = SessionTable[i];
wolfSSL 13:f67a6c6013ca 531 while (session) {
wolfSSL 13:f67a6c6013ca 532 removeSession = session;
wolfSSL 13:f67a6c6013ca 533 session = session->next;
wolfSSL 13:f67a6c6013ca 534 FreeSnifferSession(removeSession);
wolfSSL 13:f67a6c6013ca 535 }
wolfSSL 13:f67a6c6013ca 536 }
wolfSSL 13:f67a6c6013ca 537
wolfSSL 13:f67a6c6013ca 538 wc_UnLockMutex(&SessionMutex);
wolfSSL 13:f67a6c6013ca 539 wc_UnLockMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 540
wolfSSL 13:f67a6c6013ca 541 wc_FreeMutex(&RecoveryMutex);
wolfSSL 13:f67a6c6013ca 542 wc_FreeMutex(&SessionMutex);
wolfSSL 13:f67a6c6013ca 543 wc_FreeMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 544
wolfSSL 13:f67a6c6013ca 545 if (TraceFile) {
wolfSSL 13:f67a6c6013ca 546 TraceOn = 0;
wolfSSL 13:f67a6c6013ca 547 fclose(TraceFile);
wolfSSL 13:f67a6c6013ca 548 TraceFile = NULL;
wolfSSL 13:f67a6c6013ca 549 }
wolfSSL 13:f67a6c6013ca 550
wolfSSL 13:f67a6c6013ca 551 wolfSSL_Cleanup();
wolfSSL 13:f67a6c6013ca 552 }
wolfSSL 13:f67a6c6013ca 553
wolfSSL 13:f67a6c6013ca 554
wolfSSL 13:f67a6c6013ca 555 #ifdef HAVE_EXTENDED_MASTER
wolfSSL 13:f67a6c6013ca 556
wolfSSL 13:f67a6c6013ca 557 static int HashInit(HsHashes* hash)
wolfSSL 13:f67a6c6013ca 558 {
wolfSSL 13:f67a6c6013ca 559 int ret = 0;
wolfSSL 13:f67a6c6013ca 560
wolfSSL 13:f67a6c6013ca 561 XMEMSET(hash, 0, sizeof(HsHashes));
wolfSSL 13:f67a6c6013ca 562
wolfSSL 13:f67a6c6013ca 563 #ifndef NO_OLD_TLS
wolfSSL 13:f67a6c6013ca 564 #ifndef NO_SHA
wolfSSL 13:f67a6c6013ca 565 if (ret == 0)
wolfSSL 13:f67a6c6013ca 566 ret = wc_InitSha(&hash->hashSha);
wolfSSL 13:f67a6c6013ca 567 #endif
wolfSSL 13:f67a6c6013ca 568 #ifndef NO_MD5
wolfSSL 13:f67a6c6013ca 569 if (ret == 0) {
wolfSSL 13:f67a6c6013ca 570 ret = wc_InitMd5(&hash->hashMd5);
wolfSSL 13:f67a6c6013ca 571 }
wolfSSL 13:f67a6c6013ca 572 #endif
wolfSSL 13:f67a6c6013ca 573 #endif
wolfSSL 13:f67a6c6013ca 574 #ifndef NO_SHA256
wolfSSL 13:f67a6c6013ca 575 if (ret == 0)
wolfSSL 13:f67a6c6013ca 576 ret = wc_InitSha256(&hash->hashSha256);
wolfSSL 13:f67a6c6013ca 577 #endif
wolfSSL 13:f67a6c6013ca 578 #ifdef WOLFSSL_SHA384
wolfSSL 13:f67a6c6013ca 579 if (ret == 0)
wolfSSL 13:f67a6c6013ca 580 ret = wc_InitSha384(&hash->hashSha384);
wolfSSL 13:f67a6c6013ca 581 #endif
wolfSSL 13:f67a6c6013ca 582
wolfSSL 13:f67a6c6013ca 583 return ret;
wolfSSL 13:f67a6c6013ca 584 }
wolfSSL 13:f67a6c6013ca 585
wolfSSL 13:f67a6c6013ca 586
wolfSSL 13:f67a6c6013ca 587 static int HashUpdate(HsHashes* hash, const byte* input, int sz)
wolfSSL 13:f67a6c6013ca 588 {
wolfSSL 13:f67a6c6013ca 589 int ret = 0;
wolfSSL 13:f67a6c6013ca 590
wolfSSL 13:f67a6c6013ca 591 input -= HANDSHAKE_HEADER_SZ;
wolfSSL 13:f67a6c6013ca 592 sz += HANDSHAKE_HEADER_SZ;
wolfSSL 13:f67a6c6013ca 593
wolfSSL 13:f67a6c6013ca 594 #ifndef NO_OLD_TLS
wolfSSL 13:f67a6c6013ca 595 #ifndef NO_SHA
wolfSSL 13:f67a6c6013ca 596 if (ret == 0)
wolfSSL 13:f67a6c6013ca 597 ret = wc_ShaUpdate(&hash->hashSha, input, sz);
wolfSSL 13:f67a6c6013ca 598 #endif
wolfSSL 13:f67a6c6013ca 599 #ifndef NO_MD5
wolfSSL 13:f67a6c6013ca 600 if (ret == 0) {
wolfSSL 13:f67a6c6013ca 601 ret = wc_Md5Update(&hash->hashMd5, input, sz);
wolfSSL 13:f67a6c6013ca 602 }
wolfSSL 13:f67a6c6013ca 603 #endif
wolfSSL 13:f67a6c6013ca 604 #endif
wolfSSL 13:f67a6c6013ca 605 #ifndef NO_SHA256
wolfSSL 13:f67a6c6013ca 606 if (ret == 0)
wolfSSL 13:f67a6c6013ca 607 ret = wc_Sha256Update(&hash->hashSha256, input, sz);
wolfSSL 13:f67a6c6013ca 608 #endif
wolfSSL 13:f67a6c6013ca 609 #ifdef WOLFSSL_SHA384
wolfSSL 13:f67a6c6013ca 610 if (ret == 0)
wolfSSL 13:f67a6c6013ca 611 ret = wc_Sha384Update(&hash->hashSha384, input, sz);
wolfSSL 13:f67a6c6013ca 612 #endif
wolfSSL 13:f67a6c6013ca 613
wolfSSL 13:f67a6c6013ca 614 return ret;
wolfSSL 13:f67a6c6013ca 615 }
wolfSSL 13:f67a6c6013ca 616
wolfSSL 13:f67a6c6013ca 617
wolfSSL 13:f67a6c6013ca 618 static int HashCopy(HS_Hashes* d, HsHashes* s)
wolfSSL 13:f67a6c6013ca 619 {
wolfSSL 13:f67a6c6013ca 620 #ifndef NO_OLD_TLS
wolfSSL 13:f67a6c6013ca 621 #ifndef NO_SHA
wolfSSL 13:f67a6c6013ca 622 XMEMCPY(&d->hashSha, &s->hashSha, sizeof(Sha));
wolfSSL 13:f67a6c6013ca 623 #endif
wolfSSL 13:f67a6c6013ca 624 #ifndef NO_MD5
wolfSSL 13:f67a6c6013ca 625 XMEMCPY(&d->hashMd5, &s->hashMd5, sizeof(Md5));
wolfSSL 13:f67a6c6013ca 626 #endif
wolfSSL 13:f67a6c6013ca 627 #endif
wolfSSL 13:f67a6c6013ca 628
wolfSSL 13:f67a6c6013ca 629 #ifndef NO_SHA256
wolfSSL 13:f67a6c6013ca 630 XMEMCPY(&d->hashSha256, &s->hashSha256, sizeof(Sha256));
wolfSSL 13:f67a6c6013ca 631 #endif
wolfSSL 13:f67a6c6013ca 632 #ifdef WOLFSSL_SHA384
wolfSSL 13:f67a6c6013ca 633 XMEMCPY(&d->hashSha384, &s->hashSha384, sizeof(Sha384));
wolfSSL 13:f67a6c6013ca 634 #endif
wolfSSL 13:f67a6c6013ca 635
wolfSSL 13:f67a6c6013ca 636 return 0;
wolfSSL 13:f67a6c6013ca 637 }
wolfSSL 13:f67a6c6013ca 638
wolfSSL 13:f67a6c6013ca 639 #endif
wolfSSL 13:f67a6c6013ca 640
wolfSSL 13:f67a6c6013ca 641
wolfSSL 13:f67a6c6013ca 642 /* Initialize a SnifferServer */
wolfSSL 13:f67a6c6013ca 643 static void InitSnifferServer(SnifferServer* sniffer)
wolfSSL 13:f67a6c6013ca 644 {
wolfSSL 13:f67a6c6013ca 645 sniffer->ctx = 0;
wolfSSL 13:f67a6c6013ca 646 XMEMSET(sniffer->address, 0, MAX_SERVER_ADDRESS);
wolfSSL 13:f67a6c6013ca 647 sniffer->server = 0;
wolfSSL 13:f67a6c6013ca 648 sniffer->port = 0;
wolfSSL 13:f67a6c6013ca 649 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 650 sniffer->namedKeys = 0;
wolfSSL 13:f67a6c6013ca 651 wc_InitMutex(&sniffer->namedKeysMutex);
wolfSSL 13:f67a6c6013ca 652 #endif
wolfSSL 13:f67a6c6013ca 653 sniffer->next = 0;
wolfSSL 13:f67a6c6013ca 654 }
wolfSSL 13:f67a6c6013ca 655
wolfSSL 13:f67a6c6013ca 656
wolfSSL 13:f67a6c6013ca 657 /* Initialize session flags */
wolfSSL 13:f67a6c6013ca 658 static void InitFlags(Flags* flags)
wolfSSL 13:f67a6c6013ca 659 {
wolfSSL 13:f67a6c6013ca 660 flags->side = 0;
wolfSSL 13:f67a6c6013ca 661 flags->serverCipherOn = 0;
wolfSSL 13:f67a6c6013ca 662 flags->clientCipherOn = 0;
wolfSSL 13:f67a6c6013ca 663 flags->resuming = 0;
wolfSSL 13:f67a6c6013ca 664 flags->cached = 0;
wolfSSL 13:f67a6c6013ca 665 flags->clientHello = 0;
wolfSSL 13:f67a6c6013ca 666 flags->finCount = 0;
wolfSSL 13:f67a6c6013ca 667 flags->fatalError = 0;
wolfSSL 13:f67a6c6013ca 668 flags->cliAckFault = 0;
wolfSSL 13:f67a6c6013ca 669 flags->srvAckFault = 0;
wolfSSL 13:f67a6c6013ca 670 flags->cliSkipPartial = 0;
wolfSSL 13:f67a6c6013ca 671 flags->srvSkipPartial = 0;
wolfSSL 13:f67a6c6013ca 672 #ifdef HAVE_EXTENDED_MASTER
wolfSSL 13:f67a6c6013ca 673 flags->expectEms = 0;
wolfSSL 13:f67a6c6013ca 674 #endif
wolfSSL 13:f67a6c6013ca 675 }
wolfSSL 13:f67a6c6013ca 676
wolfSSL 13:f67a6c6013ca 677
wolfSSL 13:f67a6c6013ca 678 /* Initialize FIN Capture */
wolfSSL 13:f67a6c6013ca 679 static void InitFinCapture(FinCaputre* cap)
wolfSSL 13:f67a6c6013ca 680 {
wolfSSL 13:f67a6c6013ca 681 cap->cliFinSeq = 0;
wolfSSL 13:f67a6c6013ca 682 cap->srvFinSeq = 0;
wolfSSL 13:f67a6c6013ca 683 cap->cliCounted = 0;
wolfSSL 13:f67a6c6013ca 684 cap->srvCounted = 0;
wolfSSL 13:f67a6c6013ca 685 }
wolfSSL 13:f67a6c6013ca 686
wolfSSL 13:f67a6c6013ca 687
wolfSSL 13:f67a6c6013ca 688 /* Initialize a Sniffer Session */
wolfSSL 13:f67a6c6013ca 689 static void InitSession(SnifferSession* session)
wolfSSL 13:f67a6c6013ca 690 {
wolfSSL 13:f67a6c6013ca 691 session->context = 0;
wolfSSL 13:f67a6c6013ca 692 session->sslServer = 0;
wolfSSL 13:f67a6c6013ca 693 session->sslClient = 0;
wolfSSL 13:f67a6c6013ca 694 session->server = 0;
wolfSSL 13:f67a6c6013ca 695 session->client = 0;
wolfSSL 13:f67a6c6013ca 696 session->srvPort = 0;
wolfSSL 13:f67a6c6013ca 697 session->cliPort = 0;
wolfSSL 13:f67a6c6013ca 698 session->cliSeqStart = 0;
wolfSSL 13:f67a6c6013ca 699 session->srvSeqStart = 0;
wolfSSL 13:f67a6c6013ca 700 session->cliExpected = 0;
wolfSSL 13:f67a6c6013ca 701 session->srvExpected = 0;
wolfSSL 13:f67a6c6013ca 702 session->lastUsed = 0;
wolfSSL 13:f67a6c6013ca 703 session->cliReassemblyList = 0;
wolfSSL 13:f67a6c6013ca 704 session->srvReassemblyList = 0;
wolfSSL 13:f67a6c6013ca 705 session->cliReassemblyMemory = 0;
wolfSSL 13:f67a6c6013ca 706 session->srvReassemblyMemory = 0;
wolfSSL 13:f67a6c6013ca 707 session->next = 0;
wolfSSL 13:f67a6c6013ca 708 session->ticketID = 0;
wolfSSL 13:f67a6c6013ca 709
wolfSSL 13:f67a6c6013ca 710 InitFlags(&session->flags);
wolfSSL 13:f67a6c6013ca 711 InitFinCapture(&session->finCaputre);
wolfSSL 13:f67a6c6013ca 712 #ifdef HAVE_EXTENDED_MASTER
wolfSSL 13:f67a6c6013ca 713 session->hash = 0;
wolfSSL 13:f67a6c6013ca 714 #endif
wolfSSL 13:f67a6c6013ca 715 }
wolfSSL 13:f67a6c6013ca 716
wolfSSL 13:f67a6c6013ca 717
wolfSSL 13:f67a6c6013ca 718 /* IP Info from IP Header */
wolfSSL 13:f67a6c6013ca 719 typedef struct IpInfo {
wolfSSL 13:f67a6c6013ca 720 int length; /* length of this header */
wolfSSL 13:f67a6c6013ca 721 int total; /* total length of fragment */
wolfSSL 13:f67a6c6013ca 722 word32 src; /* network order source address */
wolfSSL 13:f67a6c6013ca 723 word32 dst; /* network order destination address */
wolfSSL 13:f67a6c6013ca 724 } IpInfo;
wolfSSL 13:f67a6c6013ca 725
wolfSSL 13:f67a6c6013ca 726
wolfSSL 13:f67a6c6013ca 727 /* TCP Info from TCP Header */
wolfSSL 13:f67a6c6013ca 728 typedef struct TcpInfo {
wolfSSL 13:f67a6c6013ca 729 int srcPort; /* source port */
wolfSSL 13:f67a6c6013ca 730 int dstPort; /* source port */
wolfSSL 13:f67a6c6013ca 731 int length; /* length of this header */
wolfSSL 13:f67a6c6013ca 732 word32 sequence; /* sequence number */
wolfSSL 13:f67a6c6013ca 733 word32 ackNumber; /* ack number */
wolfSSL 13:f67a6c6013ca 734 byte fin; /* FIN set */
wolfSSL 13:f67a6c6013ca 735 byte rst; /* RST set */
wolfSSL 13:f67a6c6013ca 736 byte syn; /* SYN set */
wolfSSL 13:f67a6c6013ca 737 byte ack; /* ACK set */
wolfSSL 13:f67a6c6013ca 738 } TcpInfo;
wolfSSL 13:f67a6c6013ca 739
wolfSSL 13:f67a6c6013ca 740
wolfSSL 13:f67a6c6013ca 741 /* Tcp Pseudo Header for Checksum calculation */
wolfSSL 13:f67a6c6013ca 742 typedef struct TcpPseudoHdr {
wolfSSL 13:f67a6c6013ca 743 word32 src; /* source address */
wolfSSL 13:f67a6c6013ca 744 word32 dst; /* destination address */
wolfSSL 13:f67a6c6013ca 745 byte rsv; /* reserved, always 0 */
wolfSSL 13:f67a6c6013ca 746 byte protocol; /* IP protocol */
wolfSSL 13:f67a6c6013ca 747 word16 length; /* tcp header length + data length (doesn't include */
wolfSSL 13:f67a6c6013ca 748 /* pseudo header length) network order */
wolfSSL 13:f67a6c6013ca 749 } TcpPseudoHdr;
wolfSSL 13:f67a6c6013ca 750
wolfSSL 13:f67a6c6013ca 751
wolfSSL 13:f67a6c6013ca 752 /* Password Setting Callback */
wolfSSL 13:f67a6c6013ca 753 static int SetPassword(char* passwd, int sz, int rw, void* userdata)
wolfSSL 13:f67a6c6013ca 754 {
wolfSSL 13:f67a6c6013ca 755 (void)rw;
wolfSSL 13:f67a6c6013ca 756 XSTRNCPY(passwd, (const char*)userdata, sz);
wolfSSL 13:f67a6c6013ca 757 return (int)XSTRLEN((const char*)userdata);
wolfSSL 13:f67a6c6013ca 758 }
wolfSSL 13:f67a6c6013ca 759
wolfSSL 13:f67a6c6013ca 760
wolfSSL 13:f67a6c6013ca 761 /* Ethernet Header */
wolfSSL 13:f67a6c6013ca 762 typedef struct EthernetHdr {
wolfSSL 13:f67a6c6013ca 763 byte dst[ETHER_IF_ADDR_LEN]; /* destination host address */
wolfSSL 13:f67a6c6013ca 764 byte src[ETHER_IF_ADDR_LEN]; /* source host address */
wolfSSL 13:f67a6c6013ca 765 word16 type; /* IP, ARP, etc */
wolfSSL 13:f67a6c6013ca 766 } EthernetHdr;
wolfSSL 13:f67a6c6013ca 767
wolfSSL 13:f67a6c6013ca 768
wolfSSL 13:f67a6c6013ca 769 /* IP Header */
wolfSSL 13:f67a6c6013ca 770 typedef struct IpHdr {
wolfSSL 13:f67a6c6013ca 771 byte ver_hl; /* version/header length */
wolfSSL 13:f67a6c6013ca 772 byte tos; /* type of service */
wolfSSL 13:f67a6c6013ca 773 word16 length; /* total length */
wolfSSL 13:f67a6c6013ca 774 word16 id; /* identification */
wolfSSL 13:f67a6c6013ca 775 word16 offset; /* fragment offset field */
wolfSSL 13:f67a6c6013ca 776 byte ttl; /* time to live */
wolfSSL 13:f67a6c6013ca 777 byte protocol; /* protocol */
wolfSSL 13:f67a6c6013ca 778 word16 sum; /* checksum */
wolfSSL 13:f67a6c6013ca 779 word32 src; /* source address */
wolfSSL 13:f67a6c6013ca 780 word32 dst; /* destination address */
wolfSSL 13:f67a6c6013ca 781 } IpHdr;
wolfSSL 13:f67a6c6013ca 782
wolfSSL 13:f67a6c6013ca 783
wolfSSL 13:f67a6c6013ca 784 #define IP_HL(ip) ( (((ip)->ver_hl) & 0x0f) * 4)
wolfSSL 13:f67a6c6013ca 785 #define IP_V(ip) ( ((ip)->ver_hl) >> 4)
wolfSSL 13:f67a6c6013ca 786
wolfSSL 13:f67a6c6013ca 787 /* TCP Header */
wolfSSL 13:f67a6c6013ca 788 typedef struct TcpHdr {
wolfSSL 13:f67a6c6013ca 789 word16 srcPort; /* source port */
wolfSSL 13:f67a6c6013ca 790 word16 dstPort; /* destination port */
wolfSSL 13:f67a6c6013ca 791 word32 sequence; /* sequence number */
wolfSSL 13:f67a6c6013ca 792 word32 ack; /* acknoledgment number */
wolfSSL 13:f67a6c6013ca 793 byte offset; /* data offset, reserved */
wolfSSL 13:f67a6c6013ca 794 byte flags; /* option flags */
wolfSSL 13:f67a6c6013ca 795 word16 window; /* window */
wolfSSL 13:f67a6c6013ca 796 word16 sum; /* checksum */
wolfSSL 13:f67a6c6013ca 797 word16 urgent; /* urgent pointer */
wolfSSL 13:f67a6c6013ca 798 } TcpHdr;
wolfSSL 13:f67a6c6013ca 799
wolfSSL 13:f67a6c6013ca 800 #define TCP_LEN(tcp) ( (((tcp)->offset & 0xf0) >> 4) * 4)
wolfSSL 13:f67a6c6013ca 801 #define TCP_FIN 0x01
wolfSSL 13:f67a6c6013ca 802 #define TCP_SYN 0x02
wolfSSL 13:f67a6c6013ca 803 #define TCP_RST 0x04
wolfSSL 13:f67a6c6013ca 804 #define TCP_ACK 0x10
wolfSSL 13:f67a6c6013ca 805
wolfSSL 13:f67a6c6013ca 806
wolfSSL 13:f67a6c6013ca 807
wolfSSL 13:f67a6c6013ca 808
wolfSSL 13:f67a6c6013ca 809
wolfSSL 13:f67a6c6013ca 810 /* Use platform specific GetError to write to tracfile if tracing */
wolfSSL 13:f67a6c6013ca 811 static void Trace(int idx)
wolfSSL 13:f67a6c6013ca 812 {
wolfSSL 13:f67a6c6013ca 813 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 814 char myBuffer[MAX_ERROR_LEN];
wolfSSL 13:f67a6c6013ca 815 GetError(idx, myBuffer);
wolfSSL 13:f67a6c6013ca 816 fprintf(TraceFile, "\t%s\n", myBuffer);
wolfSSL 13:f67a6c6013ca 817 #ifdef DEBUG_SNIFFER
wolfSSL 13:f67a6c6013ca 818 fprintf(stderr, "\t%s\n", myBuffer);
wolfSSL 13:f67a6c6013ca 819 #endif
wolfSSL 13:f67a6c6013ca 820 }
wolfSSL 13:f67a6c6013ca 821 }
wolfSSL 13:f67a6c6013ca 822
wolfSSL 13:f67a6c6013ca 823
wolfSSL 13:f67a6c6013ca 824 /* Show TimeStamp for beginning of packet Trace */
wolfSSL 13:f67a6c6013ca 825 static void TraceHeader(void)
wolfSSL 13:f67a6c6013ca 826 {
wolfSSL 13:f67a6c6013ca 827 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 828 time_t ticks = time(NULL);
wolfSSL 13:f67a6c6013ca 829 fprintf(TraceFile, "\n%s", ctime(&ticks));
wolfSSL 13:f67a6c6013ca 830 }
wolfSSL 13:f67a6c6013ca 831 }
wolfSSL 13:f67a6c6013ca 832
wolfSSL 13:f67a6c6013ca 833
wolfSSL 13:f67a6c6013ca 834 /* Show Set Server info for Trace */
wolfSSL 13:f67a6c6013ca 835 static void TraceSetServer(const char* srv, int port, const char* keyFile)
wolfSSL 13:f67a6c6013ca 836 {
wolfSSL 13:f67a6c6013ca 837 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 838 fprintf(TraceFile, "\tTrying to install a new Sniffer Server with\n");
wolfSSL 13:f67a6c6013ca 839 fprintf(TraceFile, "\tserver: %s, port: %d, keyFile: %s\n", srv, port,
wolfSSL 13:f67a6c6013ca 840 keyFile);
wolfSSL 13:f67a6c6013ca 841 }
wolfSSL 13:f67a6c6013ca 842 }
wolfSSL 13:f67a6c6013ca 843
wolfSSL 13:f67a6c6013ca 844
wolfSSL 13:f67a6c6013ca 845 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 846
wolfSSL 13:f67a6c6013ca 847 /* Show Set Named Server info for Trace */
wolfSSL 13:f67a6c6013ca 848 static void TraceSetNamedServer(const char* name,
wolfSSL 13:f67a6c6013ca 849 const char* srv, int port, const char* keyFile)
wolfSSL 13:f67a6c6013ca 850 {
wolfSSL 13:f67a6c6013ca 851 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 852 fprintf(TraceFile, "\tTrying to install a new Sniffer Server with\n");
wolfSSL 13:f67a6c6013ca 853 fprintf(TraceFile, "\tname: %s, server: %s, port: %d, keyFile: %s\n",
wolfSSL 13:f67a6c6013ca 854 name, srv, port, keyFile);
wolfSSL 13:f67a6c6013ca 855 }
wolfSSL 13:f67a6c6013ca 856 }
wolfSSL 13:f67a6c6013ca 857
wolfSSL 13:f67a6c6013ca 858 #endif
wolfSSL 13:f67a6c6013ca 859
wolfSSL 13:f67a6c6013ca 860
wolfSSL 13:f67a6c6013ca 861 /* Trace got packet number */
wolfSSL 13:f67a6c6013ca 862 static void TracePacket(void)
wolfSSL 13:f67a6c6013ca 863 {
wolfSSL 13:f67a6c6013ca 864 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 865 static word32 packetNumber = 0;
wolfSSL 13:f67a6c6013ca 866 fprintf(TraceFile, "\tGot a Packet to decode, packet %u\n",
wolfSSL 13:f67a6c6013ca 867 ++packetNumber);
wolfSSL 13:f67a6c6013ca 868 }
wolfSSL 13:f67a6c6013ca 869 }
wolfSSL 13:f67a6c6013ca 870
wolfSSL 13:f67a6c6013ca 871
wolfSSL 13:f67a6c6013ca 872 /* Convert network byte order address into human readable */
wolfSSL 13:f67a6c6013ca 873 static char* IpToS(word32 addr, char* str)
wolfSSL 13:f67a6c6013ca 874 {
wolfSSL 13:f67a6c6013ca 875 byte* p = (byte*)&addr;
wolfSSL 13:f67a6c6013ca 876
wolfSSL 13:f67a6c6013ca 877 SNPRINTF(str, TRACE_MSG_SZ, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
wolfSSL 13:f67a6c6013ca 878
wolfSSL 13:f67a6c6013ca 879 return str;
wolfSSL 13:f67a6c6013ca 880 }
wolfSSL 13:f67a6c6013ca 881
wolfSSL 13:f67a6c6013ca 882
wolfSSL 13:f67a6c6013ca 883 /* Show destination and source address from Ip Hdr for packet Trace */
wolfSSL 13:f67a6c6013ca 884 static void TraceIP(IpHdr* iphdr)
wolfSSL 13:f67a6c6013ca 885 {
wolfSSL 13:f67a6c6013ca 886 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 887 char src[TRACE_MSG_SZ];
wolfSSL 13:f67a6c6013ca 888 char dst[TRACE_MSG_SZ];
wolfSSL 13:f67a6c6013ca 889 fprintf(TraceFile, "\tdst:%s src:%s\n", IpToS(iphdr->dst, dst),
wolfSSL 13:f67a6c6013ca 890 IpToS(iphdr->src, src));
wolfSSL 13:f67a6c6013ca 891 }
wolfSSL 13:f67a6c6013ca 892 }
wolfSSL 13:f67a6c6013ca 893
wolfSSL 13:f67a6c6013ca 894
wolfSSL 13:f67a6c6013ca 895 /* Show destination and source port from Tcp Hdr for packet Trace */
wolfSSL 13:f67a6c6013ca 896 static void TraceTcp(TcpHdr* tcphdr)
wolfSSL 13:f67a6c6013ca 897 {
wolfSSL 13:f67a6c6013ca 898 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 899 fprintf(TraceFile, "\tdstPort:%u srcPort:%u\n", ntohs(tcphdr->dstPort),
wolfSSL 13:f67a6c6013ca 900 ntohs(tcphdr->srcPort));
wolfSSL 13:f67a6c6013ca 901 }
wolfSSL 13:f67a6c6013ca 902 }
wolfSSL 13:f67a6c6013ca 903
wolfSSL 13:f67a6c6013ca 904
wolfSSL 13:f67a6c6013ca 905 /* Show sequence and payload length for Trace */
wolfSSL 13:f67a6c6013ca 906 static void TraceSequence(word32 seq, int len)
wolfSSL 13:f67a6c6013ca 907 {
wolfSSL 13:f67a6c6013ca 908 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 909 fprintf(TraceFile, "\tSequence:%u, payload length:%d\n", seq, len);
wolfSSL 13:f67a6c6013ca 910 }
wolfSSL 13:f67a6c6013ca 911 }
wolfSSL 13:f67a6c6013ca 912
wolfSSL 13:f67a6c6013ca 913
wolfSSL 13:f67a6c6013ca 914 /* Show sequence and payload length for Trace */
wolfSSL 13:f67a6c6013ca 915 static void TraceAck(word32 ack, word32 expected)
wolfSSL 13:f67a6c6013ca 916 {
wolfSSL 13:f67a6c6013ca 917 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 918 fprintf(TraceFile, "\tAck:%u Expected:%u\n", ack, expected);
wolfSSL 13:f67a6c6013ca 919 }
wolfSSL 13:f67a6c6013ca 920 }
wolfSSL 13:f67a6c6013ca 921
wolfSSL 13:f67a6c6013ca 922
wolfSSL 13:f67a6c6013ca 923 /* Show relative expected and relative received sequences */
wolfSSL 13:f67a6c6013ca 924 static void TraceRelativeSequence(word32 expected, word32 got)
wolfSSL 13:f67a6c6013ca 925 {
wolfSSL 13:f67a6c6013ca 926 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 927 fprintf(TraceFile, "\tExpected sequence:%u, received sequence:%u\n",
wolfSSL 13:f67a6c6013ca 928 expected, got);
wolfSSL 13:f67a6c6013ca 929 }
wolfSSL 13:f67a6c6013ca 930 }
wolfSSL 13:f67a6c6013ca 931
wolfSSL 13:f67a6c6013ca 932
wolfSSL 13:f67a6c6013ca 933 /* Show server sequence startup from SYN */
wolfSSL 13:f67a6c6013ca 934 static void TraceServerSyn(word32 seq)
wolfSSL 13:f67a6c6013ca 935 {
wolfSSL 13:f67a6c6013ca 936 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 937 fprintf(TraceFile, "\tServer SYN, Sequence Start:%u\n", seq);
wolfSSL 13:f67a6c6013ca 938 }
wolfSSL 13:f67a6c6013ca 939 }
wolfSSL 13:f67a6c6013ca 940
wolfSSL 13:f67a6c6013ca 941
wolfSSL 13:f67a6c6013ca 942 /* Show client sequence startup from SYN */
wolfSSL 13:f67a6c6013ca 943 static void TraceClientSyn(word32 seq)
wolfSSL 13:f67a6c6013ca 944 {
wolfSSL 13:f67a6c6013ca 945 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 946 fprintf(TraceFile, "\tClient SYN, Sequence Start:%u\n", seq);
wolfSSL 13:f67a6c6013ca 947 }
wolfSSL 13:f67a6c6013ca 948 }
wolfSSL 13:f67a6c6013ca 949
wolfSSL 13:f67a6c6013ca 950
wolfSSL 13:f67a6c6013ca 951 /* Show client FIN capture */
wolfSSL 13:f67a6c6013ca 952 static void TraceClientFin(word32 finSeq, word32 relSeq)
wolfSSL 13:f67a6c6013ca 953 {
wolfSSL 13:f67a6c6013ca 954 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 955 fprintf(TraceFile, "\tClient FIN capture:%u, current SEQ:%u\n",
wolfSSL 13:f67a6c6013ca 956 finSeq, relSeq);
wolfSSL 13:f67a6c6013ca 957 }
wolfSSL 13:f67a6c6013ca 958 }
wolfSSL 13:f67a6c6013ca 959
wolfSSL 13:f67a6c6013ca 960
wolfSSL 13:f67a6c6013ca 961 /* Show server FIN capture */
wolfSSL 13:f67a6c6013ca 962 static void TraceServerFin(word32 finSeq, word32 relSeq)
wolfSSL 13:f67a6c6013ca 963 {
wolfSSL 13:f67a6c6013ca 964 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 965 fprintf(TraceFile, "\tServer FIN capture:%u, current SEQ:%u\n",
wolfSSL 13:f67a6c6013ca 966 finSeq, relSeq);
wolfSSL 13:f67a6c6013ca 967 }
wolfSSL 13:f67a6c6013ca 968 }
wolfSSL 13:f67a6c6013ca 969
wolfSSL 13:f67a6c6013ca 970
wolfSSL 13:f67a6c6013ca 971 /* Show number of SSL data bytes decoded, could be 0 (ok) */
wolfSSL 13:f67a6c6013ca 972 static void TraceGotData(int bytes)
wolfSSL 13:f67a6c6013ca 973 {
wolfSSL 13:f67a6c6013ca 974 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 975 fprintf(TraceFile, "\t%d bytes of SSL App data processed\n", bytes);
wolfSSL 13:f67a6c6013ca 976 }
wolfSSL 13:f67a6c6013ca 977 }
wolfSSL 13:f67a6c6013ca 978
wolfSSL 13:f67a6c6013ca 979
wolfSSL 13:f67a6c6013ca 980 /* Show bytes added to old SSL App data */
wolfSSL 13:f67a6c6013ca 981 static void TraceAddedData(int newBytes, int existingBytes)
wolfSSL 13:f67a6c6013ca 982 {
wolfSSL 13:f67a6c6013ca 983 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 984 fprintf(TraceFile,
wolfSSL 13:f67a6c6013ca 985 "\t%d bytes added to %d existing bytes in User Buffer\n",
wolfSSL 13:f67a6c6013ca 986 newBytes, existingBytes);
wolfSSL 13:f67a6c6013ca 987 }
wolfSSL 13:f67a6c6013ca 988 }
wolfSSL 13:f67a6c6013ca 989
wolfSSL 13:f67a6c6013ca 990
wolfSSL 13:f67a6c6013ca 991 /* Show Stale Session */
wolfSSL 13:f67a6c6013ca 992 static void TraceStaleSession(void)
wolfSSL 13:f67a6c6013ca 993 {
wolfSSL 13:f67a6c6013ca 994 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 995 fprintf(TraceFile, "\tFound a stale session\n");
wolfSSL 13:f67a6c6013ca 996 }
wolfSSL 13:f67a6c6013ca 997 }
wolfSSL 13:f67a6c6013ca 998
wolfSSL 13:f67a6c6013ca 999
wolfSSL 13:f67a6c6013ca 1000 /* Show Finding Stale Sessions */
wolfSSL 13:f67a6c6013ca 1001 static void TraceFindingStale(void)
wolfSSL 13:f67a6c6013ca 1002 {
wolfSSL 13:f67a6c6013ca 1003 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 1004 fprintf(TraceFile, "\tTrying to find Stale Sessions\n");
wolfSSL 13:f67a6c6013ca 1005 }
wolfSSL 13:f67a6c6013ca 1006 }
wolfSSL 13:f67a6c6013ca 1007
wolfSSL 13:f67a6c6013ca 1008
wolfSSL 13:f67a6c6013ca 1009 /* Show Removed Session */
wolfSSL 13:f67a6c6013ca 1010 static void TraceRemovedSession(void)
wolfSSL 13:f67a6c6013ca 1011 {
wolfSSL 13:f67a6c6013ca 1012 if (TraceOn) {
wolfSSL 13:f67a6c6013ca 1013 fprintf(TraceFile, "\tRemoved it\n");
wolfSSL 13:f67a6c6013ca 1014 }
wolfSSL 13:f67a6c6013ca 1015 }
wolfSSL 13:f67a6c6013ca 1016
wolfSSL 13:f67a6c6013ca 1017
wolfSSL 13:f67a6c6013ca 1018 /* Set user error string */
wolfSSL 13:f67a6c6013ca 1019 static void SetError(int idx, char* error, SnifferSession* session, int fatal)
wolfSSL 13:f67a6c6013ca 1020 {
wolfSSL 13:f67a6c6013ca 1021 GetError(idx, error);
wolfSSL 13:f67a6c6013ca 1022 Trace(idx);
wolfSSL 13:f67a6c6013ca 1023 if (session && fatal == FATAL_ERROR_STATE)
wolfSSL 13:f67a6c6013ca 1024 session->flags.fatalError = 1;
wolfSSL 13:f67a6c6013ca 1025 }
wolfSSL 13:f67a6c6013ca 1026
wolfSSL 13:f67a6c6013ca 1027
wolfSSL 13:f67a6c6013ca 1028 /* See if this IPV4 network order address has been registered */
wolfSSL 13:f67a6c6013ca 1029 /* return 1 is true, 0 is false */
wolfSSL 13:f67a6c6013ca 1030 static int IsServerRegistered(word32 addr)
wolfSSL 13:f67a6c6013ca 1031 {
wolfSSL 13:f67a6c6013ca 1032 int ret = 0; /* false */
wolfSSL 13:f67a6c6013ca 1033 SnifferServer* sniffer;
wolfSSL 13:f67a6c6013ca 1034
wolfSSL 13:f67a6c6013ca 1035 wc_LockMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 1036
wolfSSL 13:f67a6c6013ca 1037 sniffer = ServerList;
wolfSSL 13:f67a6c6013ca 1038 while (sniffer) {
wolfSSL 13:f67a6c6013ca 1039 if (sniffer->server == addr) {
wolfSSL 13:f67a6c6013ca 1040 ret = 1;
wolfSSL 13:f67a6c6013ca 1041 break;
wolfSSL 13:f67a6c6013ca 1042 }
wolfSSL 13:f67a6c6013ca 1043 sniffer = sniffer->next;
wolfSSL 13:f67a6c6013ca 1044 }
wolfSSL 13:f67a6c6013ca 1045
wolfSSL 13:f67a6c6013ca 1046 wc_UnLockMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 1047
wolfSSL 13:f67a6c6013ca 1048 return ret;
wolfSSL 13:f67a6c6013ca 1049 }
wolfSSL 13:f67a6c6013ca 1050
wolfSSL 13:f67a6c6013ca 1051
wolfSSL 13:f67a6c6013ca 1052 /* See if this port has been registered to watch */
wolfSSL 13:f67a6c6013ca 1053 /* return 1 is true, 0 is false */
wolfSSL 13:f67a6c6013ca 1054 static int IsPortRegistered(word32 port)
wolfSSL 13:f67a6c6013ca 1055 {
wolfSSL 13:f67a6c6013ca 1056 int ret = 0; /* false */
wolfSSL 13:f67a6c6013ca 1057 SnifferServer* sniffer;
wolfSSL 13:f67a6c6013ca 1058
wolfSSL 13:f67a6c6013ca 1059 wc_LockMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 1060
wolfSSL 13:f67a6c6013ca 1061 sniffer = ServerList;
wolfSSL 13:f67a6c6013ca 1062 while (sniffer) {
wolfSSL 13:f67a6c6013ca 1063 if (sniffer->port == (int)port) {
wolfSSL 13:f67a6c6013ca 1064 ret = 1;
wolfSSL 13:f67a6c6013ca 1065 break;
wolfSSL 13:f67a6c6013ca 1066 }
wolfSSL 13:f67a6c6013ca 1067 sniffer = sniffer->next;
wolfSSL 13:f67a6c6013ca 1068 }
wolfSSL 13:f67a6c6013ca 1069
wolfSSL 13:f67a6c6013ca 1070 wc_UnLockMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 1071
wolfSSL 13:f67a6c6013ca 1072 return ret;
wolfSSL 13:f67a6c6013ca 1073 }
wolfSSL 13:f67a6c6013ca 1074
wolfSSL 13:f67a6c6013ca 1075
wolfSSL 13:f67a6c6013ca 1076 /* Get SnifferServer from IP and Port */
wolfSSL 13:f67a6c6013ca 1077 static SnifferServer* GetSnifferServer(IpInfo* ipInfo, TcpInfo* tcpInfo)
wolfSSL 13:f67a6c6013ca 1078 {
wolfSSL 13:f67a6c6013ca 1079 SnifferServer* sniffer;
wolfSSL 13:f67a6c6013ca 1080
wolfSSL 13:f67a6c6013ca 1081 wc_LockMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 1082
wolfSSL 13:f67a6c6013ca 1083 sniffer = ServerList;
wolfSSL 13:f67a6c6013ca 1084 while (sniffer) {
wolfSSL 13:f67a6c6013ca 1085 if (sniffer->port == tcpInfo->srcPort && sniffer->server == ipInfo->src)
wolfSSL 13:f67a6c6013ca 1086 break;
wolfSSL 13:f67a6c6013ca 1087 if (sniffer->port == tcpInfo->dstPort && sniffer->server == ipInfo->dst)
wolfSSL 13:f67a6c6013ca 1088 break;
wolfSSL 13:f67a6c6013ca 1089 sniffer = sniffer->next;
wolfSSL 13:f67a6c6013ca 1090 }
wolfSSL 13:f67a6c6013ca 1091
wolfSSL 13:f67a6c6013ca 1092 wc_UnLockMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 1093
wolfSSL 13:f67a6c6013ca 1094 return sniffer;
wolfSSL 13:f67a6c6013ca 1095 }
wolfSSL 13:f67a6c6013ca 1096
wolfSSL 13:f67a6c6013ca 1097
wolfSSL 13:f67a6c6013ca 1098 /* Hash the Session Info, return hash row */
wolfSSL 13:f67a6c6013ca 1099 static word32 SessionHash(IpInfo* ipInfo, TcpInfo* tcpInfo)
wolfSSL 13:f67a6c6013ca 1100 {
wolfSSL 13:f67a6c6013ca 1101 word32 hash = ipInfo->src * ipInfo->dst;
wolfSSL 13:f67a6c6013ca 1102 hash *= tcpInfo->srcPort * tcpInfo->dstPort;
wolfSSL 13:f67a6c6013ca 1103
wolfSSL 13:f67a6c6013ca 1104 return hash % HASH_SIZE;
wolfSSL 13:f67a6c6013ca 1105 }
wolfSSL 13:f67a6c6013ca 1106
wolfSSL 13:f67a6c6013ca 1107
wolfSSL 13:f67a6c6013ca 1108 /* Get Exisiting SnifferSession from IP and Port */
wolfSSL 13:f67a6c6013ca 1109 static SnifferSession* GetSnifferSession(IpInfo* ipInfo, TcpInfo* tcpInfo)
wolfSSL 13:f67a6c6013ca 1110 {
wolfSSL 13:f67a6c6013ca 1111 SnifferSession* session;
wolfSSL 13:f67a6c6013ca 1112 time_t currTime = time(NULL);
wolfSSL 13:f67a6c6013ca 1113 word32 row = SessionHash(ipInfo, tcpInfo);
wolfSSL 13:f67a6c6013ca 1114
wolfSSL 13:f67a6c6013ca 1115 assert(row <= HASH_SIZE);
wolfSSL 13:f67a6c6013ca 1116
wolfSSL 13:f67a6c6013ca 1117 wc_LockMutex(&SessionMutex);
wolfSSL 13:f67a6c6013ca 1118
wolfSSL 13:f67a6c6013ca 1119 session = SessionTable[row];
wolfSSL 13:f67a6c6013ca 1120 while (session) {
wolfSSL 13:f67a6c6013ca 1121 if (session->server == ipInfo->src && session->client == ipInfo->dst &&
wolfSSL 13:f67a6c6013ca 1122 session->srvPort == tcpInfo->srcPort &&
wolfSSL 13:f67a6c6013ca 1123 session->cliPort == tcpInfo->dstPort)
wolfSSL 13:f67a6c6013ca 1124 break;
wolfSSL 13:f67a6c6013ca 1125 if (session->client == ipInfo->src && session->server == ipInfo->dst &&
wolfSSL 13:f67a6c6013ca 1126 session->cliPort == tcpInfo->srcPort &&
wolfSSL 13:f67a6c6013ca 1127 session->srvPort == tcpInfo->dstPort)
wolfSSL 13:f67a6c6013ca 1128 break;
wolfSSL 13:f67a6c6013ca 1129
wolfSSL 13:f67a6c6013ca 1130 session = session->next;
wolfSSL 13:f67a6c6013ca 1131 }
wolfSSL 13:f67a6c6013ca 1132
wolfSSL 13:f67a6c6013ca 1133 if (session)
wolfSSL 13:f67a6c6013ca 1134 session->lastUsed= currTime; /* keep session alive, remove stale will */
wolfSSL 13:f67a6c6013ca 1135 /* leave alone */
wolfSSL 13:f67a6c6013ca 1136 wc_UnLockMutex(&SessionMutex);
wolfSSL 13:f67a6c6013ca 1137
wolfSSL 13:f67a6c6013ca 1138 /* determine side */
wolfSSL 13:f67a6c6013ca 1139 if (session) {
wolfSSL 13:f67a6c6013ca 1140 if (ipInfo->dst == session->context->server &&
wolfSSL 13:f67a6c6013ca 1141 tcpInfo->dstPort == session->context->port)
wolfSSL 13:f67a6c6013ca 1142 session->flags.side = WOLFSSL_SERVER_END;
wolfSSL 13:f67a6c6013ca 1143 else
wolfSSL 13:f67a6c6013ca 1144 session->flags.side = WOLFSSL_CLIENT_END;
wolfSSL 13:f67a6c6013ca 1145 }
wolfSSL 13:f67a6c6013ca 1146
wolfSSL 13:f67a6c6013ca 1147 return session;
wolfSSL 13:f67a6c6013ca 1148 }
wolfSSL 13:f67a6c6013ca 1149
wolfSSL 13:f67a6c6013ca 1150
wolfSSL 13:f67a6c6013ca 1151 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 1152
wolfSSL 13:f67a6c6013ca 1153 static int LoadKeyFile(byte** keyBuf, word32* keyBufSz,
wolfSSL 13:f67a6c6013ca 1154 const char* keyFile, int typeKey,
wolfSSL 13:f67a6c6013ca 1155 const char* password)
wolfSSL 13:f67a6c6013ca 1156 {
wolfSSL 13:f67a6c6013ca 1157 byte* loadBuf;
wolfSSL 13:f67a6c6013ca 1158 long fileSz = 0;
wolfSSL 13:f67a6c6013ca 1159 XFILE file;
wolfSSL 13:f67a6c6013ca 1160 int ret;
wolfSSL 13:f67a6c6013ca 1161
wolfSSL 13:f67a6c6013ca 1162 if (keyBuf == NULL || keyBufSz == NULL || keyFile == NULL) {
wolfSSL 13:f67a6c6013ca 1163 return -1;
wolfSSL 13:f67a6c6013ca 1164 }
wolfSSL 13:f67a6c6013ca 1165
wolfSSL 13:f67a6c6013ca 1166 file = XFOPEN(keyFile, "rb");
wolfSSL 13:f67a6c6013ca 1167 if (file == XBADFILE) return -1;
wolfSSL 13:f67a6c6013ca 1168 XFSEEK(file, 0, XSEEK_END);
wolfSSL 13:f67a6c6013ca 1169 fileSz = XFTELL(file);
wolfSSL 13:f67a6c6013ca 1170 XREWIND(file);
wolfSSL 13:f67a6c6013ca 1171
wolfSSL 13:f67a6c6013ca 1172 loadBuf = (byte*)malloc(fileSz);
wolfSSL 13:f67a6c6013ca 1173 if (loadBuf == NULL) {
wolfSSL 13:f67a6c6013ca 1174 XFCLOSE(file);
wolfSSL 13:f67a6c6013ca 1175 return -1;
wolfSSL 13:f67a6c6013ca 1176 }
wolfSSL 13:f67a6c6013ca 1177
wolfSSL 13:f67a6c6013ca 1178 ret = (int)XFREAD(loadBuf, 1, fileSz, file);
wolfSSL 13:f67a6c6013ca 1179 XFCLOSE(file);
wolfSSL 13:f67a6c6013ca 1180
wolfSSL 13:f67a6c6013ca 1181 if (ret != fileSz) {
wolfSSL 13:f67a6c6013ca 1182 free(loadBuf);
wolfSSL 13:f67a6c6013ca 1183 return -1;
wolfSSL 13:f67a6c6013ca 1184 }
wolfSSL 13:f67a6c6013ca 1185
wolfSSL 13:f67a6c6013ca 1186 if (typeKey == SSL_FILETYPE_PEM) {
wolfSSL 13:f67a6c6013ca 1187 byte* saveBuf = (byte*)malloc(fileSz);
wolfSSL 13:f67a6c6013ca 1188 int saveBufSz = 0;
wolfSSL 13:f67a6c6013ca 1189
wolfSSL 13:f67a6c6013ca 1190 ret = -1;
wolfSSL 13:f67a6c6013ca 1191 if (saveBuf != NULL) {
wolfSSL 13:f67a6c6013ca 1192 saveBufSz = wolfSSL_KeyPemToDer(loadBuf, (int)fileSz,
wolfSSL 13:f67a6c6013ca 1193 saveBuf, (int)fileSz, password);
wolfSSL 13:f67a6c6013ca 1194 if (saveBufSz < 0) {
wolfSSL 13:f67a6c6013ca 1195 saveBufSz = 0;
wolfSSL 13:f67a6c6013ca 1196 free(saveBuf);
wolfSSL 13:f67a6c6013ca 1197 saveBuf = NULL;
wolfSSL 13:f67a6c6013ca 1198 }
wolfSSL 13:f67a6c6013ca 1199 else
wolfSSL 13:f67a6c6013ca 1200 ret = 0;
wolfSSL 13:f67a6c6013ca 1201 }
wolfSSL 13:f67a6c6013ca 1202
wolfSSL 13:f67a6c6013ca 1203 ForceZero(loadBuf, (word32)fileSz);
wolfSSL 13:f67a6c6013ca 1204 free(loadBuf);
wolfSSL 13:f67a6c6013ca 1205
wolfSSL 13:f67a6c6013ca 1206 if (saveBuf) {
wolfSSL 13:f67a6c6013ca 1207 *keyBuf = saveBuf;
wolfSSL 13:f67a6c6013ca 1208 *keyBufSz = (word32)saveBufSz;
wolfSSL 13:f67a6c6013ca 1209 }
wolfSSL 13:f67a6c6013ca 1210 }
wolfSSL 13:f67a6c6013ca 1211 else {
wolfSSL 13:f67a6c6013ca 1212 *keyBuf = loadBuf;
wolfSSL 13:f67a6c6013ca 1213 *keyBufSz = (word32)fileSz;
wolfSSL 13:f67a6c6013ca 1214 }
wolfSSL 13:f67a6c6013ca 1215
wolfSSL 13:f67a6c6013ca 1216 if (ret < 0) {
wolfSSL 13:f67a6c6013ca 1217 return -1;
wolfSSL 13:f67a6c6013ca 1218 }
wolfSSL 13:f67a6c6013ca 1219
wolfSSL 13:f67a6c6013ca 1220 return ret;
wolfSSL 13:f67a6c6013ca 1221 }
wolfSSL 13:f67a6c6013ca 1222
wolfSSL 13:f67a6c6013ca 1223 #endif
wolfSSL 13:f67a6c6013ca 1224
wolfSSL 13:f67a6c6013ca 1225
wolfSSL 13:f67a6c6013ca 1226 static int SetNamedPrivateKey(const char* name, const char* address, int port,
wolfSSL 13:f67a6c6013ca 1227 const char* keyFile, int typeKey, const char* password, char* error)
wolfSSL 13:f67a6c6013ca 1228 {
wolfSSL 13:f67a6c6013ca 1229 SnifferServer* sniffer;
wolfSSL 13:f67a6c6013ca 1230 int ret;
wolfSSL 13:f67a6c6013ca 1231 int type = (typeKey == FILETYPE_PEM) ? SSL_FILETYPE_PEM :
wolfSSL 13:f67a6c6013ca 1232 SSL_FILETYPE_ASN1;
wolfSSL 13:f67a6c6013ca 1233 int isNew = 0;
wolfSSL 13:f67a6c6013ca 1234 word32 serverIp;
wolfSSL 13:f67a6c6013ca 1235
wolfSSL 13:f67a6c6013ca 1236 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 1237 NamedKey* namedKey = NULL;
wolfSSL 13:f67a6c6013ca 1238 #endif
wolfSSL 13:f67a6c6013ca 1239
wolfSSL 13:f67a6c6013ca 1240 (void)name;
wolfSSL 13:f67a6c6013ca 1241 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 1242 if (name != NULL) {
wolfSSL 13:f67a6c6013ca 1243 namedKey = (NamedKey*)malloc(sizeof(NamedKey));
wolfSSL 13:f67a6c6013ca 1244 if (namedKey == NULL) {
wolfSSL 13:f67a6c6013ca 1245 SetError(MEMORY_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 1246 return -1;
wolfSSL 13:f67a6c6013ca 1247 }
wolfSSL 13:f67a6c6013ca 1248 XMEMSET(namedKey, 0, sizeof(NamedKey));
wolfSSL 13:f67a6c6013ca 1249
wolfSSL 13:f67a6c6013ca 1250 namedKey->nameSz = (word32)XSTRLEN(name);
wolfSSL 13:f67a6c6013ca 1251 XSTRNCPY(namedKey->name, name, sizeof(namedKey->name));
wolfSSL 13:f67a6c6013ca 1252 if (namedKey->nameSz >= sizeof(namedKey->name)) {
wolfSSL 13:f67a6c6013ca 1253 namedKey->nameSz = sizeof(namedKey->name) - 1;
wolfSSL 13:f67a6c6013ca 1254 namedKey->name[namedKey->nameSz] = '\0';
wolfSSL 13:f67a6c6013ca 1255 }
wolfSSL 13:f67a6c6013ca 1256
wolfSSL 13:f67a6c6013ca 1257 ret = LoadKeyFile(&namedKey->key, &namedKey->keySz,
wolfSSL 13:f67a6c6013ca 1258 keyFile, type, password);
wolfSSL 13:f67a6c6013ca 1259 if (ret < 0) {
wolfSSL 13:f67a6c6013ca 1260 SetError(KEY_FILE_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 1261 FreeNamedKey(namedKey);
wolfSSL 13:f67a6c6013ca 1262 return -1;
wolfSSL 13:f67a6c6013ca 1263 }
wolfSSL 13:f67a6c6013ca 1264 }
wolfSSL 13:f67a6c6013ca 1265 #endif
wolfSSL 13:f67a6c6013ca 1266
wolfSSL 13:f67a6c6013ca 1267 serverIp = inet_addr(address);
wolfSSL 13:f67a6c6013ca 1268 sniffer = ServerList;
wolfSSL 13:f67a6c6013ca 1269 while (sniffer != NULL &&
wolfSSL 13:f67a6c6013ca 1270 (sniffer->server != serverIp || sniffer->port != port)) {
wolfSSL 13:f67a6c6013ca 1271 sniffer = sniffer->next;
wolfSSL 13:f67a6c6013ca 1272 }
wolfSSL 13:f67a6c6013ca 1273
wolfSSL 13:f67a6c6013ca 1274 if (sniffer == NULL) {
wolfSSL 13:f67a6c6013ca 1275 isNew = 1;
wolfSSL 13:f67a6c6013ca 1276 sniffer = (SnifferServer*)malloc(sizeof(SnifferServer));
wolfSSL 13:f67a6c6013ca 1277 if (sniffer == NULL) {
wolfSSL 13:f67a6c6013ca 1278 SetError(MEMORY_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 1279 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 1280 FreeNamedKey(namedKey);
wolfSSL 13:f67a6c6013ca 1281 #endif
wolfSSL 13:f67a6c6013ca 1282 return -1;
wolfSSL 13:f67a6c6013ca 1283 }
wolfSSL 13:f67a6c6013ca 1284 InitSnifferServer(sniffer);
wolfSSL 13:f67a6c6013ca 1285
wolfSSL 13:f67a6c6013ca 1286 XSTRNCPY(sniffer->address, address, MAX_SERVER_ADDRESS-1);
wolfSSL 13:f67a6c6013ca 1287 sniffer->address[MAX_SERVER_ADDRESS-1] = '\0';
wolfSSL 13:f67a6c6013ca 1288 sniffer->server = serverIp;
wolfSSL 13:f67a6c6013ca 1289 sniffer->port = port;
wolfSSL 13:f67a6c6013ca 1290
wolfSSL 13:f67a6c6013ca 1291 sniffer->ctx = SSL_CTX_new(TLSv1_client_method());
wolfSSL 13:f67a6c6013ca 1292 if (!sniffer->ctx) {
wolfSSL 13:f67a6c6013ca 1293 SetError(MEMORY_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 1294 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 1295 FreeNamedKey(namedKey);
wolfSSL 13:f67a6c6013ca 1296 #endif
wolfSSL 13:f67a6c6013ca 1297 FreeSnifferServer(sniffer);
wolfSSL 13:f67a6c6013ca 1298 return -1;
wolfSSL 13:f67a6c6013ca 1299 }
wolfSSL 13:f67a6c6013ca 1300 }
wolfSSL 13:f67a6c6013ca 1301
wolfSSL 13:f67a6c6013ca 1302 if (name == NULL) {
wolfSSL 13:f67a6c6013ca 1303 if (password) {
wolfSSL 13:f67a6c6013ca 1304 SSL_CTX_set_default_passwd_cb(sniffer->ctx, SetPassword);
wolfSSL 13:f67a6c6013ca 1305 SSL_CTX_set_default_passwd_cb_userdata(
wolfSSL 13:f67a6c6013ca 1306 sniffer->ctx, (void*)password);
wolfSSL 13:f67a6c6013ca 1307 }
wolfSSL 13:f67a6c6013ca 1308 ret = SSL_CTX_use_PrivateKey_file(sniffer->ctx, keyFile, type);
wolfSSL 13:f67a6c6013ca 1309 if (ret != SSL_SUCCESS) {
wolfSSL 13:f67a6c6013ca 1310 SetError(KEY_FILE_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 1311 if (isNew)
wolfSSL 13:f67a6c6013ca 1312 FreeSnifferServer(sniffer);
wolfSSL 13:f67a6c6013ca 1313 return -1;
wolfSSL 13:f67a6c6013ca 1314 }
wolfSSL 13:f67a6c6013ca 1315 }
wolfSSL 13:f67a6c6013ca 1316 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 1317 else {
wolfSSL 13:f67a6c6013ca 1318 wc_LockMutex(&sniffer->namedKeysMutex);
wolfSSL 13:f67a6c6013ca 1319 namedKey->next = sniffer->namedKeys;
wolfSSL 13:f67a6c6013ca 1320 sniffer->namedKeys = namedKey;
wolfSSL 13:f67a6c6013ca 1321 wc_UnLockMutex(&sniffer->namedKeysMutex);
wolfSSL 13:f67a6c6013ca 1322 }
wolfSSL 13:f67a6c6013ca 1323 #endif
wolfSSL 13:f67a6c6013ca 1324
wolfSSL 13:f67a6c6013ca 1325 if (isNew) {
wolfSSL 13:f67a6c6013ca 1326 sniffer->next = ServerList;
wolfSSL 13:f67a6c6013ca 1327 ServerList = sniffer;
wolfSSL 13:f67a6c6013ca 1328 }
wolfSSL 13:f67a6c6013ca 1329
wolfSSL 13:f67a6c6013ca 1330 return 0;
wolfSSL 13:f67a6c6013ca 1331 }
wolfSSL 13:f67a6c6013ca 1332
wolfSSL 13:f67a6c6013ca 1333
wolfSSL 13:f67a6c6013ca 1334 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 1335
wolfSSL 13:f67a6c6013ca 1336 /* Sets the private key for a specific name, server and port */
wolfSSL 13:f67a6c6013ca 1337 /* returns 0 on success, -1 on error */
wolfSSL 13:f67a6c6013ca 1338 int ssl_SetNamedPrivateKey(const char* name,
wolfSSL 13:f67a6c6013ca 1339 const char* address, int port,
wolfSSL 13:f67a6c6013ca 1340 const char* keyFile, int typeKey,
wolfSSL 13:f67a6c6013ca 1341 const char* password, char* error)
wolfSSL 13:f67a6c6013ca 1342 {
wolfSSL 13:f67a6c6013ca 1343 int ret;
wolfSSL 13:f67a6c6013ca 1344
wolfSSL 13:f67a6c6013ca 1345 TraceHeader();
wolfSSL 13:f67a6c6013ca 1346 TraceSetNamedServer(name, address, port, keyFile);
wolfSSL 13:f67a6c6013ca 1347
wolfSSL 13:f67a6c6013ca 1348 wc_LockMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 1349 ret = SetNamedPrivateKey(name, address, port, keyFile,
wolfSSL 13:f67a6c6013ca 1350 typeKey, password, error);
wolfSSL 13:f67a6c6013ca 1351 wc_UnLockMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 1352
wolfSSL 13:f67a6c6013ca 1353 if (ret == 0)
wolfSSL 13:f67a6c6013ca 1354 Trace(NEW_SERVER_STR);
wolfSSL 13:f67a6c6013ca 1355
wolfSSL 13:f67a6c6013ca 1356 return ret;
wolfSSL 13:f67a6c6013ca 1357 }
wolfSSL 13:f67a6c6013ca 1358
wolfSSL 13:f67a6c6013ca 1359 #endif
wolfSSL 13:f67a6c6013ca 1360
wolfSSL 13:f67a6c6013ca 1361
wolfSSL 13:f67a6c6013ca 1362 /* Sets the private key for a specific server and port */
wolfSSL 13:f67a6c6013ca 1363 /* returns 0 on success, -1 on error */
wolfSSL 13:f67a6c6013ca 1364 int ssl_SetPrivateKey(const char* address, int port, const char* keyFile,
wolfSSL 13:f67a6c6013ca 1365 int typeKey, const char* password, char* error)
wolfSSL 13:f67a6c6013ca 1366 {
wolfSSL 13:f67a6c6013ca 1367 int ret;
wolfSSL 13:f67a6c6013ca 1368
wolfSSL 13:f67a6c6013ca 1369 TraceHeader();
wolfSSL 13:f67a6c6013ca 1370 TraceSetServer(address, port, keyFile);
wolfSSL 13:f67a6c6013ca 1371
wolfSSL 13:f67a6c6013ca 1372 wc_LockMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 1373 ret = SetNamedPrivateKey(NULL, address, port, keyFile,
wolfSSL 13:f67a6c6013ca 1374 typeKey, password, error);
wolfSSL 13:f67a6c6013ca 1375 wc_UnLockMutex(&ServerListMutex);
wolfSSL 13:f67a6c6013ca 1376
wolfSSL 13:f67a6c6013ca 1377 if (ret == 0)
wolfSSL 13:f67a6c6013ca 1378 Trace(NEW_SERVER_STR);
wolfSSL 13:f67a6c6013ca 1379
wolfSSL 13:f67a6c6013ca 1380 return ret;
wolfSSL 13:f67a6c6013ca 1381 }
wolfSSL 13:f67a6c6013ca 1382
wolfSSL 13:f67a6c6013ca 1383
wolfSSL 13:f67a6c6013ca 1384 /* Check IP Header for IPV4, TCP, and a registered server address */
wolfSSL 13:f67a6c6013ca 1385 /* returns 0 on success, -1 on error */
wolfSSL 13:f67a6c6013ca 1386 static int CheckIpHdr(IpHdr* iphdr, IpInfo* info, int length, char* error)
wolfSSL 13:f67a6c6013ca 1387 {
wolfSSL 13:f67a6c6013ca 1388 int version = IP_V(iphdr);
wolfSSL 13:f67a6c6013ca 1389
wolfSSL 13:f67a6c6013ca 1390 TraceIP(iphdr);
wolfSSL 13:f67a6c6013ca 1391 Trace(IP_CHECK_STR);
wolfSSL 13:f67a6c6013ca 1392
wolfSSL 13:f67a6c6013ca 1393 if (version != IPV4) {
wolfSSL 13:f67a6c6013ca 1394 SetError(BAD_IPVER_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 1395 return -1;
wolfSSL 13:f67a6c6013ca 1396 }
wolfSSL 13:f67a6c6013ca 1397
wolfSSL 13:f67a6c6013ca 1398 if (iphdr->protocol != TCP_PROTOCOL) {
wolfSSL 13:f67a6c6013ca 1399 SetError(BAD_PROTO_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 1400 return -1;
wolfSSL 13:f67a6c6013ca 1401 }
wolfSSL 13:f67a6c6013ca 1402
wolfSSL 13:f67a6c6013ca 1403 if (!IsServerRegistered(iphdr->src) && !IsServerRegistered(iphdr->dst)) {
wolfSSL 13:f67a6c6013ca 1404 SetError(SERVER_NOT_REG_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 1405 return -1;
wolfSSL 13:f67a6c6013ca 1406 }
wolfSSL 13:f67a6c6013ca 1407
wolfSSL 13:f67a6c6013ca 1408 info->length = IP_HL(iphdr);
wolfSSL 13:f67a6c6013ca 1409 info->total = ntohs(iphdr->length);
wolfSSL 13:f67a6c6013ca 1410 info->src = iphdr->src;
wolfSSL 13:f67a6c6013ca 1411 info->dst = iphdr->dst;
wolfSSL 13:f67a6c6013ca 1412
wolfSSL 13:f67a6c6013ca 1413 if (info->total == 0)
wolfSSL 13:f67a6c6013ca 1414 info->total = length; /* reassembled may be off */
wolfSSL 13:f67a6c6013ca 1415
wolfSSL 13:f67a6c6013ca 1416 return 0;
wolfSSL 13:f67a6c6013ca 1417 }
wolfSSL 13:f67a6c6013ca 1418
wolfSSL 13:f67a6c6013ca 1419
wolfSSL 13:f67a6c6013ca 1420 /* Check TCP Header for a registered port */
wolfSSL 13:f67a6c6013ca 1421 /* returns 0 on success, -1 on error */
wolfSSL 13:f67a6c6013ca 1422 static int CheckTcpHdr(TcpHdr* tcphdr, TcpInfo* info, char* error)
wolfSSL 13:f67a6c6013ca 1423 {
wolfSSL 13:f67a6c6013ca 1424 TraceTcp(tcphdr);
wolfSSL 13:f67a6c6013ca 1425 Trace(TCP_CHECK_STR);
wolfSSL 13:f67a6c6013ca 1426 info->srcPort = ntohs(tcphdr->srcPort);
wolfSSL 13:f67a6c6013ca 1427 info->dstPort = ntohs(tcphdr->dstPort);
wolfSSL 13:f67a6c6013ca 1428 info->length = TCP_LEN(tcphdr);
wolfSSL 13:f67a6c6013ca 1429 info->sequence = ntohl(tcphdr->sequence);
wolfSSL 13:f67a6c6013ca 1430 info->fin = tcphdr->flags & TCP_FIN;
wolfSSL 13:f67a6c6013ca 1431 info->rst = tcphdr->flags & TCP_RST;
wolfSSL 13:f67a6c6013ca 1432 info->syn = tcphdr->flags & TCP_SYN;
wolfSSL 13:f67a6c6013ca 1433 info->ack = tcphdr->flags & TCP_ACK;
wolfSSL 13:f67a6c6013ca 1434 if (info->ack)
wolfSSL 13:f67a6c6013ca 1435 info->ackNumber = ntohl(tcphdr->ack);
wolfSSL 13:f67a6c6013ca 1436
wolfSSL 13:f67a6c6013ca 1437 if (!IsPortRegistered(info->srcPort) && !IsPortRegistered(info->dstPort)) {
wolfSSL 13:f67a6c6013ca 1438 SetError(SERVER_PORT_NOT_REG_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 1439 return -1;
wolfSSL 13:f67a6c6013ca 1440 }
wolfSSL 13:f67a6c6013ca 1441
wolfSSL 13:f67a6c6013ca 1442 return 0;
wolfSSL 13:f67a6c6013ca 1443 }
wolfSSL 13:f67a6c6013ca 1444
wolfSSL 13:f67a6c6013ca 1445
wolfSSL 13:f67a6c6013ca 1446 /* Decode Record Layer Header */
wolfSSL 13:f67a6c6013ca 1447 static int GetRecordHeader(const byte* input, RecordLayerHeader* rh, int* size)
wolfSSL 13:f67a6c6013ca 1448 {
wolfSSL 13:f67a6c6013ca 1449 XMEMCPY(rh, input, RECORD_HEADER_SZ);
wolfSSL 13:f67a6c6013ca 1450 *size = (rh->length[0] << 8) | rh->length[1];
wolfSSL 13:f67a6c6013ca 1451
wolfSSL 13:f67a6c6013ca 1452 if (*size > (MAX_RECORD_SIZE + COMP_EXTRA + MAX_MSG_EXTRA))
wolfSSL 13:f67a6c6013ca 1453 return LENGTH_ERROR;
wolfSSL 13:f67a6c6013ca 1454
wolfSSL 13:f67a6c6013ca 1455 return 0;
wolfSSL 13:f67a6c6013ca 1456 }
wolfSSL 13:f67a6c6013ca 1457
wolfSSL 13:f67a6c6013ca 1458
wolfSSL 13:f67a6c6013ca 1459 /* Process Client Key Exchange, RSA only */
wolfSSL 13:f67a6c6013ca 1460 static int ProcessClientKeyExchange(const byte* input, int* sslBytes,
wolfSSL 13:f67a6c6013ca 1461 SnifferSession* session, char* error)
wolfSSL 13:f67a6c6013ca 1462 {
wolfSSL 13:f67a6c6013ca 1463 word32 idx = 0;
wolfSSL 13:f67a6c6013ca 1464 RsaKey key;
wolfSSL 13:f67a6c6013ca 1465 int ret;
wolfSSL 13:f67a6c6013ca 1466
wolfSSL 13:f67a6c6013ca 1467 if (session->sslServer->buffers.key == NULL ||
wolfSSL 13:f67a6c6013ca 1468 session->sslServer->buffers.key->buffer == NULL ||
wolfSSL 13:f67a6c6013ca 1469 session->sslServer->buffers.key->length == 0) {
wolfSSL 13:f67a6c6013ca 1470
wolfSSL 13:f67a6c6013ca 1471 SetError(RSA_KEY_MISSING_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1472 return -1;
wolfSSL 13:f67a6c6013ca 1473 }
wolfSSL 13:f67a6c6013ca 1474 ret = wc_InitRsaKey(&key, 0);
wolfSSL 13:f67a6c6013ca 1475 if (ret == 0)
wolfSSL 13:f67a6c6013ca 1476 ret = wc_RsaPrivateKeyDecode(session->sslServer->buffers.key->buffer,
wolfSSL 13:f67a6c6013ca 1477 &idx, &key, session->sslServer->buffers.key->length);
wolfSSL 13:f67a6c6013ca 1478 if (ret == 0) {
wolfSSL 13:f67a6c6013ca 1479 int length = wc_RsaEncryptSize(&key);
wolfSSL 13:f67a6c6013ca 1480
wolfSSL 13:f67a6c6013ca 1481 if (IsTLS(session->sslServer))
wolfSSL 13:f67a6c6013ca 1482 input += 2; /* tls pre length */
wolfSSL 13:f67a6c6013ca 1483
wolfSSL 13:f67a6c6013ca 1484 if (length > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1485 SetError(PARTIAL_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1486 wc_FreeRsaKey(&key);
wolfSSL 13:f67a6c6013ca 1487 return -1;
wolfSSL 13:f67a6c6013ca 1488 }
wolfSSL 13:f67a6c6013ca 1489 #ifdef WC_RSA_BLINDING
wolfSSL 13:f67a6c6013ca 1490 ret = wc_RsaSetRNG(&key, session->sslServer->rng);
wolfSSL 13:f67a6c6013ca 1491 if (ret != 0) {
wolfSSL 13:f67a6c6013ca 1492 SetError(RSA_DECRYPT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1493 return -1;
wolfSSL 13:f67a6c6013ca 1494 }
wolfSSL 13:f67a6c6013ca 1495 #endif
wolfSSL 13:f67a6c6013ca 1496 ret = wc_RsaPrivateDecrypt(input, length,
wolfSSL 13:f67a6c6013ca 1497 session->sslServer->arrays->preMasterSecret,SECRET_LEN, &key);
wolfSSL 13:f67a6c6013ca 1498
wolfSSL 13:f67a6c6013ca 1499 if (ret != SECRET_LEN) {
wolfSSL 13:f67a6c6013ca 1500 SetError(RSA_DECRYPT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1501 wc_FreeRsaKey(&key);
wolfSSL 13:f67a6c6013ca 1502 return -1;
wolfSSL 13:f67a6c6013ca 1503 }
wolfSSL 13:f67a6c6013ca 1504 session->sslServer->arrays->preMasterSz = SECRET_LEN;
wolfSSL 13:f67a6c6013ca 1505
wolfSSL 13:f67a6c6013ca 1506 /* store for client side as well */
wolfSSL 13:f67a6c6013ca 1507 XMEMCPY(session->sslClient->arrays->preMasterSecret,
wolfSSL 13:f67a6c6013ca 1508 session->sslServer->arrays->preMasterSecret, SECRET_LEN);
wolfSSL 13:f67a6c6013ca 1509 session->sslClient->arrays->preMasterSz = SECRET_LEN;
wolfSSL 13:f67a6c6013ca 1510
wolfSSL 13:f67a6c6013ca 1511 #ifdef SHOW_SECRETS
wolfSSL 13:f67a6c6013ca 1512 {
wolfSSL 13:f67a6c6013ca 1513 int i;
wolfSSL 13:f67a6c6013ca 1514 printf("pre master secret: ");
wolfSSL 13:f67a6c6013ca 1515 for (i = 0; i < SECRET_LEN; i++)
wolfSSL 13:f67a6c6013ca 1516 printf("%02x", session->sslServer->arrays->preMasterSecret[i]);
wolfSSL 13:f67a6c6013ca 1517 printf("\n");
wolfSSL 13:f67a6c6013ca 1518 }
wolfSSL 13:f67a6c6013ca 1519 #endif
wolfSSL 13:f67a6c6013ca 1520 }
wolfSSL 13:f67a6c6013ca 1521 else {
wolfSSL 13:f67a6c6013ca 1522 SetError(RSA_DECODE_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1523 wc_FreeRsaKey(&key);
wolfSSL 13:f67a6c6013ca 1524 return -1;
wolfSSL 13:f67a6c6013ca 1525 }
wolfSSL 13:f67a6c6013ca 1526
wolfSSL 13:f67a6c6013ca 1527 if (SetCipherSpecs(session->sslServer) != 0) {
wolfSSL 13:f67a6c6013ca 1528 SetError(BAD_CIPHER_SPEC_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1529 wc_FreeRsaKey(&key);
wolfSSL 13:f67a6c6013ca 1530 return -1;
wolfSSL 13:f67a6c6013ca 1531 }
wolfSSL 13:f67a6c6013ca 1532
wolfSSL 13:f67a6c6013ca 1533 if (SetCipherSpecs(session->sslClient) != 0) {
wolfSSL 13:f67a6c6013ca 1534 SetError(BAD_CIPHER_SPEC_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1535 wc_FreeRsaKey(&key);
wolfSSL 13:f67a6c6013ca 1536 return -1;
wolfSSL 13:f67a6c6013ca 1537 }
wolfSSL 13:f67a6c6013ca 1538
wolfSSL 13:f67a6c6013ca 1539 ret = MakeMasterSecret(session->sslServer);
wolfSSL 13:f67a6c6013ca 1540 ret += MakeMasterSecret(session->sslClient);
wolfSSL 13:f67a6c6013ca 1541 ret += SetKeysSide(session->sslServer, ENCRYPT_AND_DECRYPT_SIDE);
wolfSSL 13:f67a6c6013ca 1542 ret += SetKeysSide(session->sslClient, ENCRYPT_AND_DECRYPT_SIDE);
wolfSSL 13:f67a6c6013ca 1543
wolfSSL 13:f67a6c6013ca 1544 if (ret != 0) {
wolfSSL 13:f67a6c6013ca 1545 SetError(BAD_DERIVE_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1546 return -1;
wolfSSL 13:f67a6c6013ca 1547 }
wolfSSL 13:f67a6c6013ca 1548
wolfSSL 13:f67a6c6013ca 1549 #ifdef SHOW_SECRETS
wolfSSL 13:f67a6c6013ca 1550 {
wolfSSL 13:f67a6c6013ca 1551 int i;
wolfSSL 13:f67a6c6013ca 1552 printf("server master secret: ");
wolfSSL 13:f67a6c6013ca 1553 for (i = 0; i < SECRET_LEN; i++)
wolfSSL 13:f67a6c6013ca 1554 printf("%02x", session->sslServer->arrays->masterSecret[i]);
wolfSSL 13:f67a6c6013ca 1555 printf("\n");
wolfSSL 13:f67a6c6013ca 1556
wolfSSL 13:f67a6c6013ca 1557 printf("client master secret: ");
wolfSSL 13:f67a6c6013ca 1558 for (i = 0; i < SECRET_LEN; i++)
wolfSSL 13:f67a6c6013ca 1559 printf("%02x", session->sslClient->arrays->masterSecret[i]);
wolfSSL 13:f67a6c6013ca 1560 printf("\n");
wolfSSL 13:f67a6c6013ca 1561
wolfSSL 13:f67a6c6013ca 1562 printf("server suite = %d\n", session->sslServer->options.cipherSuite);
wolfSSL 13:f67a6c6013ca 1563 printf("client suite = %d\n", session->sslClient->options.cipherSuite);
wolfSSL 13:f67a6c6013ca 1564 }
wolfSSL 13:f67a6c6013ca 1565 #endif
wolfSSL 13:f67a6c6013ca 1566
wolfSSL 13:f67a6c6013ca 1567 wc_FreeRsaKey(&key);
wolfSSL 13:f67a6c6013ca 1568 return ret;
wolfSSL 13:f67a6c6013ca 1569 }
wolfSSL 13:f67a6c6013ca 1570
wolfSSL 13:f67a6c6013ca 1571
wolfSSL 13:f67a6c6013ca 1572 /* Process Session Ticket */
wolfSSL 13:f67a6c6013ca 1573 static int ProcessSessionTicket(const byte* input, int* sslBytes,
wolfSSL 13:f67a6c6013ca 1574 SnifferSession* session, char* error)
wolfSSL 13:f67a6c6013ca 1575 {
wolfSSL 13:f67a6c6013ca 1576 word16 len;
wolfSSL 13:f67a6c6013ca 1577
wolfSSL 13:f67a6c6013ca 1578 /* make sure can read through hint and len */
wolfSSL 13:f67a6c6013ca 1579 if (TICKET_HINT_LEN + LENGTH_SZ > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1580 SetError(BAD_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1581 return -1;
wolfSSL 13:f67a6c6013ca 1582 }
wolfSSL 13:f67a6c6013ca 1583
wolfSSL 13:f67a6c6013ca 1584 input += TICKET_HINT_LEN; /* skip over hint */
wolfSSL 13:f67a6c6013ca 1585 *sslBytes -= TICKET_HINT_LEN;
wolfSSL 13:f67a6c6013ca 1586
wolfSSL 13:f67a6c6013ca 1587 len = (word16)((input[0] << 8) | input[1]);
wolfSSL 13:f67a6c6013ca 1588 input += LENGTH_SZ;
wolfSSL 13:f67a6c6013ca 1589 *sslBytes -= LENGTH_SZ;
wolfSSL 13:f67a6c6013ca 1590
wolfSSL 13:f67a6c6013ca 1591 /* make sure can read through ticket */
wolfSSL 13:f67a6c6013ca 1592 if (len > *sslBytes || len < ID_LEN) {
wolfSSL 13:f67a6c6013ca 1593 SetError(BAD_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1594 return -1;
wolfSSL 13:f67a6c6013ca 1595 }
wolfSSL 13:f67a6c6013ca 1596
wolfSSL 13:f67a6c6013ca 1597 /* store session with macID as sessionID */
wolfSSL 13:f67a6c6013ca 1598 session->sslServer->options.haveSessionId = 1;
wolfSSL 13:f67a6c6013ca 1599 XMEMCPY(session->sslServer->arrays->sessionID, input + len - ID_LEN,ID_LEN);
wolfSSL 13:f67a6c6013ca 1600
wolfSSL 13:f67a6c6013ca 1601 return 0;
wolfSSL 13:f67a6c6013ca 1602 }
wolfSSL 13:f67a6c6013ca 1603
wolfSSL 13:f67a6c6013ca 1604
wolfSSL 13:f67a6c6013ca 1605 /* Process Server Hello */
wolfSSL 13:f67a6c6013ca 1606 static int ProcessServerHello(int msgSz, const byte* input, int* sslBytes,
wolfSSL 13:f67a6c6013ca 1607 SnifferSession* session, char* error)
wolfSSL 13:f67a6c6013ca 1608 {
wolfSSL 13:f67a6c6013ca 1609 ProtocolVersion pv;
wolfSSL 13:f67a6c6013ca 1610 byte b;
wolfSSL 13:f67a6c6013ca 1611 int toRead = VERSION_SZ + RAN_LEN + ENUM_LEN;
wolfSSL 13:f67a6c6013ca 1612 int doResume = 0;
wolfSSL 13:f67a6c6013ca 1613 int initialBytes = *sslBytes;
wolfSSL 13:f67a6c6013ca 1614
wolfSSL 13:f67a6c6013ca 1615 (void)msgSz;
wolfSSL 13:f67a6c6013ca 1616 (void)initialBytes;
wolfSSL 13:f67a6c6013ca 1617
wolfSSL 13:f67a6c6013ca 1618 /* make sure we didn't miss ClientHello */
wolfSSL 13:f67a6c6013ca 1619 if (session->flags.clientHello == 0) {
wolfSSL 13:f67a6c6013ca 1620 SetError(MISSED_CLIENT_HELLO_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1621 return -1;
wolfSSL 13:f67a6c6013ca 1622 }
wolfSSL 13:f67a6c6013ca 1623
wolfSSL 13:f67a6c6013ca 1624 /* make sure can read through session len */
wolfSSL 13:f67a6c6013ca 1625 if (toRead > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1626 SetError(SERVER_HELLO_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1627 return -1;
wolfSSL 13:f67a6c6013ca 1628 }
wolfSSL 13:f67a6c6013ca 1629
wolfSSL 13:f67a6c6013ca 1630 XMEMCPY(&pv, input, VERSION_SZ);
wolfSSL 13:f67a6c6013ca 1631 input += VERSION_SZ;
wolfSSL 13:f67a6c6013ca 1632 *sslBytes -= VERSION_SZ;
wolfSSL 13:f67a6c6013ca 1633
wolfSSL 13:f67a6c6013ca 1634 session->sslServer->version = pv;
wolfSSL 13:f67a6c6013ca 1635 session->sslClient->version = pv;
wolfSSL 13:f67a6c6013ca 1636
wolfSSL 13:f67a6c6013ca 1637 XMEMCPY(session->sslServer->arrays->serverRandom, input, RAN_LEN);
wolfSSL 13:f67a6c6013ca 1638 XMEMCPY(session->sslClient->arrays->serverRandom, input, RAN_LEN);
wolfSSL 13:f67a6c6013ca 1639 input += RAN_LEN;
wolfSSL 13:f67a6c6013ca 1640 *sslBytes -= RAN_LEN;
wolfSSL 13:f67a6c6013ca 1641
wolfSSL 13:f67a6c6013ca 1642 b = *input++;
wolfSSL 13:f67a6c6013ca 1643 *sslBytes -= 1;
wolfSSL 13:f67a6c6013ca 1644
wolfSSL 13:f67a6c6013ca 1645 /* make sure can read through compression */
wolfSSL 13:f67a6c6013ca 1646 if ( (b + SUITE_LEN + ENUM_LEN) > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1647 SetError(SERVER_HELLO_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1648 return -1;
wolfSSL 13:f67a6c6013ca 1649 }
wolfSSL 13:f67a6c6013ca 1650 if (b) {
wolfSSL 13:f67a6c6013ca 1651 XMEMCPY(session->sslServer->arrays->sessionID, input, ID_LEN);
wolfSSL 13:f67a6c6013ca 1652 session->sslServer->options.haveSessionId = 1;
wolfSSL 13:f67a6c6013ca 1653 }
wolfSSL 13:f67a6c6013ca 1654 input += b;
wolfSSL 13:f67a6c6013ca 1655 *sslBytes -= b;
wolfSSL 13:f67a6c6013ca 1656
wolfSSL 13:f67a6c6013ca 1657 /* cipher suite */
wolfSSL 13:f67a6c6013ca 1658 b = *input++; /* first byte, ECC or not */
wolfSSL 13:f67a6c6013ca 1659 session->sslServer->options.cipherSuite0 = b;
wolfSSL 13:f67a6c6013ca 1660 session->sslClient->options.cipherSuite0 = b;
wolfSSL 13:f67a6c6013ca 1661 b = *input++;
wolfSSL 13:f67a6c6013ca 1662 session->sslServer->options.cipherSuite = b;
wolfSSL 13:f67a6c6013ca 1663 session->sslClient->options.cipherSuite = b;
wolfSSL 13:f67a6c6013ca 1664 *sslBytes -= SUITE_LEN;
wolfSSL 13:f67a6c6013ca 1665
wolfSSL 13:f67a6c6013ca 1666 /* compression */
wolfSSL 13:f67a6c6013ca 1667 b = *input++;
wolfSSL 13:f67a6c6013ca 1668 *sslBytes -= ENUM_LEN;
wolfSSL 13:f67a6c6013ca 1669
wolfSSL 13:f67a6c6013ca 1670 if (b) {
wolfSSL 13:f67a6c6013ca 1671 SetError(BAD_COMPRESSION_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1672 return -1;
wolfSSL 13:f67a6c6013ca 1673 }
wolfSSL 13:f67a6c6013ca 1674
wolfSSL 13:f67a6c6013ca 1675 #ifdef HAVE_EXTENDED_MASTER
wolfSSL 13:f67a6c6013ca 1676 /* extensions */
wolfSSL 13:f67a6c6013ca 1677 if ((initialBytes - *sslBytes) < msgSz) {
wolfSSL 13:f67a6c6013ca 1678 word16 len;
wolfSSL 13:f67a6c6013ca 1679
wolfSSL 13:f67a6c6013ca 1680 /* skip extensions until extended master secret */
wolfSSL 13:f67a6c6013ca 1681 /* make sure can read len */
wolfSSL 13:f67a6c6013ca 1682 if (SUITE_LEN > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1683 SetError(SERVER_HELLO_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1684 return -1;
wolfSSL 13:f67a6c6013ca 1685 }
wolfSSL 13:f67a6c6013ca 1686 len = (word16)((input[0] << 8) | input[1]);
wolfSSL 13:f67a6c6013ca 1687 input += SUITE_LEN;
wolfSSL 13:f67a6c6013ca 1688 *sslBytes -= SUITE_LEN;
wolfSSL 13:f67a6c6013ca 1689 /* make sure can read through all extensions */
wolfSSL 13:f67a6c6013ca 1690 if (len > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1691 SetError(SERVER_HELLO_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1692 return -1;
wolfSSL 13:f67a6c6013ca 1693 }
wolfSSL 13:f67a6c6013ca 1694
wolfSSL 13:f67a6c6013ca 1695 while (len >= EXT_TYPE_SZ + LENGTH_SZ) {
wolfSSL 13:f67a6c6013ca 1696 byte extType[EXT_TYPE_SZ];
wolfSSL 13:f67a6c6013ca 1697 word16 extLen;
wolfSSL 13:f67a6c6013ca 1698
wolfSSL 13:f67a6c6013ca 1699 extType[0] = input[0];
wolfSSL 13:f67a6c6013ca 1700 extType[1] = input[1];
wolfSSL 13:f67a6c6013ca 1701 input += EXT_TYPE_SZ;
wolfSSL 13:f67a6c6013ca 1702 *sslBytes -= EXT_TYPE_SZ;
wolfSSL 13:f67a6c6013ca 1703
wolfSSL 13:f67a6c6013ca 1704 extLen = (word16)((input[0] << 8) | input[1]);
wolfSSL 13:f67a6c6013ca 1705 input += LENGTH_SZ;
wolfSSL 13:f67a6c6013ca 1706 *sslBytes -= LENGTH_SZ;
wolfSSL 13:f67a6c6013ca 1707
wolfSSL 13:f67a6c6013ca 1708 /* make sure can read through individual extension */
wolfSSL 13:f67a6c6013ca 1709 if (extLen > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1710 SetError(SERVER_HELLO_INPUT_STR, error, session,
wolfSSL 13:f67a6c6013ca 1711 FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1712 return -1;
wolfSSL 13:f67a6c6013ca 1713 }
wolfSSL 13:f67a6c6013ca 1714
wolfSSL 13:f67a6c6013ca 1715 if (extType[0] == 0x00 && extType[1] == EXT_MASTER_SECRET) {
wolfSSL 13:f67a6c6013ca 1716 session->flags.expectEms = 1;
wolfSSL 13:f67a6c6013ca 1717 }
wolfSSL 13:f67a6c6013ca 1718
wolfSSL 13:f67a6c6013ca 1719 input += extLen;
wolfSSL 13:f67a6c6013ca 1720 *sslBytes -= extLen;
wolfSSL 13:f67a6c6013ca 1721 len -= extLen + EXT_TYPE_SZ + LENGTH_SZ;
wolfSSL 13:f67a6c6013ca 1722 }
wolfSSL 13:f67a6c6013ca 1723 }
wolfSSL 13:f67a6c6013ca 1724
wolfSSL 13:f67a6c6013ca 1725 if (!session->flags.expectEms) {
wolfSSL 13:f67a6c6013ca 1726 free(session->hash);
wolfSSL 13:f67a6c6013ca 1727 session->hash = NULL;
wolfSSL 13:f67a6c6013ca 1728 }
wolfSSL 13:f67a6c6013ca 1729 #endif
wolfSSL 13:f67a6c6013ca 1730
wolfSSL 13:f67a6c6013ca 1731 if (session->sslServer->options.haveSessionId &&
wolfSSL 13:f67a6c6013ca 1732 XMEMCMP(session->sslServer->arrays->sessionID,
wolfSSL 13:f67a6c6013ca 1733 session->sslClient->arrays->sessionID, ID_LEN) == 0)
wolfSSL 13:f67a6c6013ca 1734 doResume = 1;
wolfSSL 13:f67a6c6013ca 1735 else if (session->sslClient->options.haveSessionId == 0 &&
wolfSSL 13:f67a6c6013ca 1736 session->sslServer->options.haveSessionId == 0 &&
wolfSSL 13:f67a6c6013ca 1737 session->ticketID)
wolfSSL 13:f67a6c6013ca 1738 doResume = 1;
wolfSSL 13:f67a6c6013ca 1739
wolfSSL 13:f67a6c6013ca 1740 if (session->ticketID && doResume) {
wolfSSL 13:f67a6c6013ca 1741 /* use ticketID to retrieve from session, prefer over sessionID */
wolfSSL 13:f67a6c6013ca 1742 XMEMCPY(session->sslServer->arrays->sessionID,session->ticketID,ID_LEN);
wolfSSL 13:f67a6c6013ca 1743 session->sslServer->options.haveSessionId = 1; /* may not have
wolfSSL 13:f67a6c6013ca 1744 actual sessionID */
wolfSSL 13:f67a6c6013ca 1745 }
wolfSSL 13:f67a6c6013ca 1746
wolfSSL 13:f67a6c6013ca 1747 if (doResume ) {
wolfSSL 13:f67a6c6013ca 1748 int ret = 0;
wolfSSL 13:f67a6c6013ca 1749 SSL_SESSION* resume = GetSession(session->sslServer,
wolfSSL 13:f67a6c6013ca 1750 session->sslServer->arrays->masterSecret, 0);
wolfSSL 13:f67a6c6013ca 1751 if (resume == NULL) {
wolfSSL 13:f67a6c6013ca 1752 SetError(BAD_SESSION_RESUME_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1753 return -1;
wolfSSL 13:f67a6c6013ca 1754 }
wolfSSL 13:f67a6c6013ca 1755 /* make sure client has master secret too */
wolfSSL 13:f67a6c6013ca 1756 XMEMCPY(session->sslClient->arrays->masterSecret,
wolfSSL 13:f67a6c6013ca 1757 session->sslServer->arrays->masterSecret, SECRET_LEN);
wolfSSL 13:f67a6c6013ca 1758 session->flags.resuming = 1;
wolfSSL 13:f67a6c6013ca 1759
wolfSSL 13:f67a6c6013ca 1760 Trace(SERVER_DID_RESUMPTION_STR);
wolfSSL 13:f67a6c6013ca 1761 if (SetCipherSpecs(session->sslServer) != 0) {
wolfSSL 13:f67a6c6013ca 1762 SetError(BAD_CIPHER_SPEC_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1763 return -1;
wolfSSL 13:f67a6c6013ca 1764 }
wolfSSL 13:f67a6c6013ca 1765
wolfSSL 13:f67a6c6013ca 1766 if (SetCipherSpecs(session->sslClient) != 0) {
wolfSSL 13:f67a6c6013ca 1767 SetError(BAD_CIPHER_SPEC_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1768 return -1;
wolfSSL 13:f67a6c6013ca 1769 }
wolfSSL 13:f67a6c6013ca 1770
wolfSSL 13:f67a6c6013ca 1771 if (session->sslServer->options.tls) {
wolfSSL 13:f67a6c6013ca 1772 ret = DeriveTlsKeys(session->sslServer);
wolfSSL 13:f67a6c6013ca 1773 ret += DeriveTlsKeys(session->sslClient);
wolfSSL 13:f67a6c6013ca 1774 }
wolfSSL 13:f67a6c6013ca 1775 else {
wolfSSL 13:f67a6c6013ca 1776 ret = DeriveKeys(session->sslServer);
wolfSSL 13:f67a6c6013ca 1777 ret += DeriveKeys(session->sslClient);
wolfSSL 13:f67a6c6013ca 1778 }
wolfSSL 13:f67a6c6013ca 1779 ret += SetKeysSide(session->sslServer, ENCRYPT_AND_DECRYPT_SIDE);
wolfSSL 13:f67a6c6013ca 1780 ret += SetKeysSide(session->sslClient, ENCRYPT_AND_DECRYPT_SIDE);
wolfSSL 13:f67a6c6013ca 1781
wolfSSL 13:f67a6c6013ca 1782 if (ret != 0) {
wolfSSL 13:f67a6c6013ca 1783 SetError(BAD_DERIVE_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1784 return -1;
wolfSSL 13:f67a6c6013ca 1785 }
wolfSSL 13:f67a6c6013ca 1786 }
wolfSSL 13:f67a6c6013ca 1787 #ifdef SHOW_SECRETS
wolfSSL 13:f67a6c6013ca 1788 {
wolfSSL 13:f67a6c6013ca 1789 int i;
wolfSSL 13:f67a6c6013ca 1790 printf("cipher suite = 0x%02x\n",
wolfSSL 13:f67a6c6013ca 1791 session->sslServer->options.cipherSuite);
wolfSSL 13:f67a6c6013ca 1792 printf("server random: ");
wolfSSL 13:f67a6c6013ca 1793 for (i = 0; i < RAN_LEN; i++)
wolfSSL 13:f67a6c6013ca 1794 printf("%02x", session->sslServer->arrays->serverRandom[i]);
wolfSSL 13:f67a6c6013ca 1795 printf("\n");
wolfSSL 13:f67a6c6013ca 1796 }
wolfSSL 13:f67a6c6013ca 1797 #endif
wolfSSL 13:f67a6c6013ca 1798 return 0;
wolfSSL 13:f67a6c6013ca 1799 }
wolfSSL 13:f67a6c6013ca 1800
wolfSSL 13:f67a6c6013ca 1801
wolfSSL 13:f67a6c6013ca 1802 /* Process normal Client Hello */
wolfSSL 13:f67a6c6013ca 1803 static int ProcessClientHello(const byte* input, int* sslBytes,
wolfSSL 13:f67a6c6013ca 1804 SnifferSession* session, char* error)
wolfSSL 13:f67a6c6013ca 1805 {
wolfSSL 13:f67a6c6013ca 1806 byte bLen;
wolfSSL 13:f67a6c6013ca 1807 word16 len;
wolfSSL 13:f67a6c6013ca 1808 int toRead = VERSION_SZ + RAN_LEN + ENUM_LEN;
wolfSSL 13:f67a6c6013ca 1809
wolfSSL 13:f67a6c6013ca 1810 #ifdef HAVE_SNI
wolfSSL 13:f67a6c6013ca 1811 {
wolfSSL 13:f67a6c6013ca 1812 byte name[MAX_SERVER_NAME];
wolfSSL 13:f67a6c6013ca 1813 word32 nameSz = sizeof(name);
wolfSSL 13:f67a6c6013ca 1814 int ret;
wolfSSL 13:f67a6c6013ca 1815
wolfSSL 13:f67a6c6013ca 1816 ret = wolfSSL_SNI_GetFromBuffer(
wolfSSL 13:f67a6c6013ca 1817 input - HANDSHAKE_HEADER_SZ - RECORD_HEADER_SZ,
wolfSSL 13:f67a6c6013ca 1818 *sslBytes + HANDSHAKE_HEADER_SZ + RECORD_HEADER_SZ,
wolfSSL 13:f67a6c6013ca 1819 WOLFSSL_SNI_HOST_NAME, name, &nameSz);
wolfSSL 13:f67a6c6013ca 1820
wolfSSL 13:f67a6c6013ca 1821 if (ret == SSL_SUCCESS) {
wolfSSL 13:f67a6c6013ca 1822 NamedKey* namedKey;
wolfSSL 13:f67a6c6013ca 1823
wolfSSL 13:f67a6c6013ca 1824 if (nameSz >= sizeof(name))
wolfSSL 13:f67a6c6013ca 1825 nameSz = sizeof(name) - 1;
wolfSSL 13:f67a6c6013ca 1826 name[nameSz] = 0;
wolfSSL 13:f67a6c6013ca 1827 wc_LockMutex(&session->context->namedKeysMutex);
wolfSSL 13:f67a6c6013ca 1828 namedKey = session->context->namedKeys;
wolfSSL 13:f67a6c6013ca 1829 while (namedKey != NULL) {
wolfSSL 13:f67a6c6013ca 1830 if (nameSz == namedKey->nameSz &&
wolfSSL 13:f67a6c6013ca 1831 XSTRNCMP((char*)name, namedKey->name, nameSz) == 0) {
wolfSSL 13:f67a6c6013ca 1832 if (wolfSSL_use_PrivateKey_buffer(session->sslServer,
wolfSSL 13:f67a6c6013ca 1833 namedKey->key, namedKey->keySz,
wolfSSL 13:f67a6c6013ca 1834 SSL_FILETYPE_ASN1) != SSL_SUCCESS) {
wolfSSL 13:f67a6c6013ca 1835 wc_UnLockMutex(&session->context->namedKeysMutex);
wolfSSL 13:f67a6c6013ca 1836 SetError(CLIENT_HELLO_LATE_KEY_STR, error, session,
wolfSSL 13:f67a6c6013ca 1837 FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1838 return -1;
wolfSSL 13:f67a6c6013ca 1839 }
wolfSSL 13:f67a6c6013ca 1840 break;
wolfSSL 13:f67a6c6013ca 1841 }
wolfSSL 13:f67a6c6013ca 1842 else
wolfSSL 13:f67a6c6013ca 1843 namedKey = namedKey->next;
wolfSSL 13:f67a6c6013ca 1844 }
wolfSSL 13:f67a6c6013ca 1845 wc_UnLockMutex(&session->context->namedKeysMutex);
wolfSSL 13:f67a6c6013ca 1846 }
wolfSSL 13:f67a6c6013ca 1847 }
wolfSSL 13:f67a6c6013ca 1848 #endif
wolfSSL 13:f67a6c6013ca 1849
wolfSSL 13:f67a6c6013ca 1850 session->flags.clientHello = 1; /* don't process again */
wolfSSL 13:f67a6c6013ca 1851
wolfSSL 13:f67a6c6013ca 1852 /* make sure can read up to session len */
wolfSSL 13:f67a6c6013ca 1853 if (toRead > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1854 SetError(CLIENT_HELLO_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1855 return -1;
wolfSSL 13:f67a6c6013ca 1856 }
wolfSSL 13:f67a6c6013ca 1857
wolfSSL 13:f67a6c6013ca 1858 /* skip, get negotiated one from server hello */
wolfSSL 13:f67a6c6013ca 1859 input += VERSION_SZ;
wolfSSL 13:f67a6c6013ca 1860 *sslBytes -= VERSION_SZ;
wolfSSL 13:f67a6c6013ca 1861
wolfSSL 13:f67a6c6013ca 1862 XMEMCPY(session->sslServer->arrays->clientRandom, input, RAN_LEN);
wolfSSL 13:f67a6c6013ca 1863 XMEMCPY(session->sslClient->arrays->clientRandom, input, RAN_LEN);
wolfSSL 13:f67a6c6013ca 1864
wolfSSL 13:f67a6c6013ca 1865 input += RAN_LEN;
wolfSSL 13:f67a6c6013ca 1866 *sslBytes -= RAN_LEN;
wolfSSL 13:f67a6c6013ca 1867
wolfSSL 13:f67a6c6013ca 1868 /* store session in case trying to resume */
wolfSSL 13:f67a6c6013ca 1869 bLen = *input++;
wolfSSL 13:f67a6c6013ca 1870 *sslBytes -= ENUM_LEN;
wolfSSL 13:f67a6c6013ca 1871 if (bLen) {
wolfSSL 13:f67a6c6013ca 1872 if (ID_LEN > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1873 SetError(CLIENT_HELLO_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1874 return -1;
wolfSSL 13:f67a6c6013ca 1875 }
wolfSSL 13:f67a6c6013ca 1876 Trace(CLIENT_RESUME_TRY_STR);
wolfSSL 13:f67a6c6013ca 1877 XMEMCPY(session->sslClient->arrays->sessionID, input, ID_LEN);
wolfSSL 13:f67a6c6013ca 1878 session->sslClient->options.haveSessionId = 1;
wolfSSL 13:f67a6c6013ca 1879 }
wolfSSL 13:f67a6c6013ca 1880 #ifdef SHOW_SECRETS
wolfSSL 13:f67a6c6013ca 1881 {
wolfSSL 13:f67a6c6013ca 1882 int i;
wolfSSL 13:f67a6c6013ca 1883 printf("client random: ");
wolfSSL 13:f67a6c6013ca 1884 for (i = 0; i < RAN_LEN; i++)
wolfSSL 13:f67a6c6013ca 1885 printf("%02x", session->sslServer->arrays->clientRandom[i]);
wolfSSL 13:f67a6c6013ca 1886 printf("\n");
wolfSSL 13:f67a6c6013ca 1887 }
wolfSSL 13:f67a6c6013ca 1888 #endif
wolfSSL 13:f67a6c6013ca 1889
wolfSSL 13:f67a6c6013ca 1890 input += bLen;
wolfSSL 13:f67a6c6013ca 1891 *sslBytes -= bLen;
wolfSSL 13:f67a6c6013ca 1892
wolfSSL 13:f67a6c6013ca 1893 /* skip cipher suites */
wolfSSL 13:f67a6c6013ca 1894 /* make sure can read len */
wolfSSL 13:f67a6c6013ca 1895 if (SUITE_LEN > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1896 SetError(CLIENT_HELLO_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1897 return -1;
wolfSSL 13:f67a6c6013ca 1898 }
wolfSSL 13:f67a6c6013ca 1899 len = (word16)((input[0] << 8) | input[1]);
wolfSSL 13:f67a6c6013ca 1900 input += SUITE_LEN;
wolfSSL 13:f67a6c6013ca 1901 *sslBytes -= SUITE_LEN;
wolfSSL 13:f67a6c6013ca 1902 /* make sure can read suites + comp len */
wolfSSL 13:f67a6c6013ca 1903 if (len + ENUM_LEN > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1904 SetError(CLIENT_HELLO_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1905 return -1;
wolfSSL 13:f67a6c6013ca 1906 }
wolfSSL 13:f67a6c6013ca 1907 input += len;
wolfSSL 13:f67a6c6013ca 1908 *sslBytes -= len;
wolfSSL 13:f67a6c6013ca 1909
wolfSSL 13:f67a6c6013ca 1910 /* skip compression */
wolfSSL 13:f67a6c6013ca 1911 bLen = *input++;
wolfSSL 13:f67a6c6013ca 1912 *sslBytes -= ENUM_LEN;
wolfSSL 13:f67a6c6013ca 1913 /* make sure can read len */
wolfSSL 13:f67a6c6013ca 1914 if (bLen > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1915 SetError(CLIENT_HELLO_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1916 return -1;
wolfSSL 13:f67a6c6013ca 1917 }
wolfSSL 13:f67a6c6013ca 1918 input += bLen;
wolfSSL 13:f67a6c6013ca 1919 *sslBytes -= bLen;
wolfSSL 13:f67a6c6013ca 1920
wolfSSL 13:f67a6c6013ca 1921 if (*sslBytes == 0) {
wolfSSL 13:f67a6c6013ca 1922 /* no extensions */
wolfSSL 13:f67a6c6013ca 1923 return 0;
wolfSSL 13:f67a6c6013ca 1924 }
wolfSSL 13:f67a6c6013ca 1925
wolfSSL 13:f67a6c6013ca 1926 /* skip extensions until session ticket */
wolfSSL 13:f67a6c6013ca 1927 /* make sure can read len */
wolfSSL 13:f67a6c6013ca 1928 if (SUITE_LEN > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1929 SetError(CLIENT_HELLO_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1930 return -1;
wolfSSL 13:f67a6c6013ca 1931 }
wolfSSL 13:f67a6c6013ca 1932 len = (word16)((input[0] << 8) | input[1]);
wolfSSL 13:f67a6c6013ca 1933 input += SUITE_LEN;
wolfSSL 13:f67a6c6013ca 1934 *sslBytes -= SUITE_LEN;
wolfSSL 13:f67a6c6013ca 1935 /* make sure can read through all extensions */
wolfSSL 13:f67a6c6013ca 1936 if (len > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1937 SetError(CLIENT_HELLO_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1938 return -1;
wolfSSL 13:f67a6c6013ca 1939 }
wolfSSL 13:f67a6c6013ca 1940
wolfSSL 13:f67a6c6013ca 1941 while (len >= EXT_TYPE_SZ + LENGTH_SZ) {
wolfSSL 13:f67a6c6013ca 1942 byte extType[EXT_TYPE_SZ];
wolfSSL 13:f67a6c6013ca 1943 word16 extLen;
wolfSSL 13:f67a6c6013ca 1944
wolfSSL 13:f67a6c6013ca 1945 extType[0] = input[0];
wolfSSL 13:f67a6c6013ca 1946 extType[1] = input[1];
wolfSSL 13:f67a6c6013ca 1947 input += EXT_TYPE_SZ;
wolfSSL 13:f67a6c6013ca 1948 *sslBytes -= EXT_TYPE_SZ;
wolfSSL 13:f67a6c6013ca 1949
wolfSSL 13:f67a6c6013ca 1950 extLen = (word16)((input[0] << 8) | input[1]);
wolfSSL 13:f67a6c6013ca 1951 input += LENGTH_SZ;
wolfSSL 13:f67a6c6013ca 1952 *sslBytes -= LENGTH_SZ;
wolfSSL 13:f67a6c6013ca 1953
wolfSSL 13:f67a6c6013ca 1954 /* make sure can read through individual extension */
wolfSSL 13:f67a6c6013ca 1955 if (extLen > *sslBytes) {
wolfSSL 13:f67a6c6013ca 1956 SetError(CLIENT_HELLO_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1957 return -1;
wolfSSL 13:f67a6c6013ca 1958 }
wolfSSL 13:f67a6c6013ca 1959
wolfSSL 13:f67a6c6013ca 1960 if (extType[0] == 0x00 && extType[1] == TICKET_EXT_ID) {
wolfSSL 13:f67a6c6013ca 1961
wolfSSL 13:f67a6c6013ca 1962 /* make sure can read through ticket if there is a non blank one */
wolfSSL 13:f67a6c6013ca 1963 if (extLen && extLen < ID_LEN) {
wolfSSL 13:f67a6c6013ca 1964 SetError(CLIENT_HELLO_INPUT_STR, error, session,
wolfSSL 13:f67a6c6013ca 1965 FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1966 return -1;
wolfSSL 13:f67a6c6013ca 1967 }
wolfSSL 13:f67a6c6013ca 1968
wolfSSL 13:f67a6c6013ca 1969 if (extLen) {
wolfSSL 13:f67a6c6013ca 1970 if (session->ticketID == 0) {
wolfSSL 13:f67a6c6013ca 1971 session->ticketID = (byte*)malloc(ID_LEN);
wolfSSL 13:f67a6c6013ca 1972 if (session->ticketID == 0) {
wolfSSL 13:f67a6c6013ca 1973 SetError(MEMORY_STR, error, session,
wolfSSL 13:f67a6c6013ca 1974 FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 1975 return -1;
wolfSSL 13:f67a6c6013ca 1976 }
wolfSSL 13:f67a6c6013ca 1977 }
wolfSSL 13:f67a6c6013ca 1978 XMEMCPY(session->ticketID, input + extLen - ID_LEN, ID_LEN);
wolfSSL 13:f67a6c6013ca 1979 }
wolfSSL 13:f67a6c6013ca 1980 }
wolfSSL 13:f67a6c6013ca 1981
wolfSSL 13:f67a6c6013ca 1982 input += extLen;
wolfSSL 13:f67a6c6013ca 1983 *sslBytes -= extLen;
wolfSSL 13:f67a6c6013ca 1984 len -= extLen + EXT_TYPE_SZ + LENGTH_SZ;
wolfSSL 13:f67a6c6013ca 1985 }
wolfSSL 13:f67a6c6013ca 1986
wolfSSL 13:f67a6c6013ca 1987 return 0;
wolfSSL 13:f67a6c6013ca 1988 }
wolfSSL 13:f67a6c6013ca 1989
wolfSSL 13:f67a6c6013ca 1990
wolfSSL 13:f67a6c6013ca 1991 /* Process Finished */
wolfSSL 13:f67a6c6013ca 1992 static int ProcessFinished(const byte* input, int size, int* sslBytes,
wolfSSL 13:f67a6c6013ca 1993 SnifferSession* session, char* error)
wolfSSL 13:f67a6c6013ca 1994 {
wolfSSL 13:f67a6c6013ca 1995 SSL* ssl;
wolfSSL 13:f67a6c6013ca 1996 word32 inOutIdx = 0;
wolfSSL 13:f67a6c6013ca 1997 int ret;
wolfSSL 13:f67a6c6013ca 1998
wolfSSL 13:f67a6c6013ca 1999 if (session->flags.side == WOLFSSL_SERVER_END)
wolfSSL 13:f67a6c6013ca 2000 ssl = session->sslServer;
wolfSSL 13:f67a6c6013ca 2001 else
wolfSSL 13:f67a6c6013ca 2002 ssl = session->sslClient;
wolfSSL 13:f67a6c6013ca 2003
wolfSSL 13:f67a6c6013ca 2004 ret = DoFinished(ssl, input, &inOutIdx, (word32) size, (word32) *sslBytes,
wolfSSL 13:f67a6c6013ca 2005 SNIFF);
wolfSSL 13:f67a6c6013ca 2006 *sslBytes -= (int)inOutIdx;
wolfSSL 13:f67a6c6013ca 2007
wolfSSL 13:f67a6c6013ca 2008 if (ret < 0) {
wolfSSL 13:f67a6c6013ca 2009 SetError(BAD_FINISHED_MSG, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2010 return ret;
wolfSSL 13:f67a6c6013ca 2011 }
wolfSSL 13:f67a6c6013ca 2012
wolfSSL 13:f67a6c6013ca 2013 if (ret == 0 && session->flags.cached == 0) {
wolfSSL 13:f67a6c6013ca 2014 if (session->sslServer->options.haveSessionId) {
wolfSSL 13:f67a6c6013ca 2015 WOLFSSL_SESSION* sess = GetSession(session->sslServer, NULL, 0);
wolfSSL 13:f67a6c6013ca 2016 if (sess == NULL)
wolfSSL 13:f67a6c6013ca 2017 AddSession(session->sslServer); /* don't re add */
wolfSSL 13:f67a6c6013ca 2018 session->flags.cached = 1;
wolfSSL 13:f67a6c6013ca 2019 }
wolfSSL 13:f67a6c6013ca 2020 }
wolfSSL 13:f67a6c6013ca 2021
wolfSSL 13:f67a6c6013ca 2022 /* If receiving a finished message from one side, free the resources
wolfSSL 13:f67a6c6013ca 2023 * from the other side's tracker. */
wolfSSL 13:f67a6c6013ca 2024 if (session->flags.side == WOLFSSL_SERVER_END)
wolfSSL 13:f67a6c6013ca 2025 FreeHandshakeResources(session->sslClient);
wolfSSL 13:f67a6c6013ca 2026 else
wolfSSL 13:f67a6c6013ca 2027 FreeHandshakeResources(session->sslServer);
wolfSSL 13:f67a6c6013ca 2028
wolfSSL 13:f67a6c6013ca 2029 return ret;
wolfSSL 13:f67a6c6013ca 2030 }
wolfSSL 13:f67a6c6013ca 2031
wolfSSL 13:f67a6c6013ca 2032
wolfSSL 13:f67a6c6013ca 2033 /* Process HandShake input */
wolfSSL 13:f67a6c6013ca 2034 static int DoHandShake(const byte* input, int* sslBytes,
wolfSSL 13:f67a6c6013ca 2035 SnifferSession* session, char* error)
wolfSSL 13:f67a6c6013ca 2036 {
wolfSSL 13:f67a6c6013ca 2037 byte type;
wolfSSL 13:f67a6c6013ca 2038 int size;
wolfSSL 13:f67a6c6013ca 2039 int ret = 0;
wolfSSL 13:f67a6c6013ca 2040 int startBytes;
wolfSSL 13:f67a6c6013ca 2041
wolfSSL 13:f67a6c6013ca 2042 if (*sslBytes < HANDSHAKE_HEADER_SZ) {
wolfSSL 13:f67a6c6013ca 2043 SetError(HANDSHAKE_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2044 return -1;
wolfSSL 13:f67a6c6013ca 2045 }
wolfSSL 13:f67a6c6013ca 2046 type = input[0];
wolfSSL 13:f67a6c6013ca 2047 size = (input[1] << 16) | (input[2] << 8) | input[3];
wolfSSL 13:f67a6c6013ca 2048
wolfSSL 13:f67a6c6013ca 2049 input += HANDSHAKE_HEADER_SZ;
wolfSSL 13:f67a6c6013ca 2050 *sslBytes -= HANDSHAKE_HEADER_SZ;
wolfSSL 13:f67a6c6013ca 2051 startBytes = *sslBytes;
wolfSSL 13:f67a6c6013ca 2052
wolfSSL 13:f67a6c6013ca 2053 if (*sslBytes < size) {
wolfSSL 13:f67a6c6013ca 2054 SetError(HANDSHAKE_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2055 return -1;
wolfSSL 13:f67a6c6013ca 2056 }
wolfSSL 13:f67a6c6013ca 2057
wolfSSL 13:f67a6c6013ca 2058 /* A session's arrays are released when the handshake is completed. */
wolfSSL 13:f67a6c6013ca 2059 if (session->sslServer->arrays == NULL &&
wolfSSL 13:f67a6c6013ca 2060 session->sslClient->arrays == NULL) {
wolfSSL 13:f67a6c6013ca 2061
wolfSSL 13:f67a6c6013ca 2062 SetError(NO_SECURE_RENEGOTIATION, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2063 return -1;
wolfSSL 13:f67a6c6013ca 2064 }
wolfSSL 13:f67a6c6013ca 2065
wolfSSL 13:f67a6c6013ca 2066 #ifdef HAVE_EXTENDED_MASTER
wolfSSL 13:f67a6c6013ca 2067 if (session->hash) {
wolfSSL 13:f67a6c6013ca 2068 if (HashUpdate(session->hash, input, size) != 0) {
wolfSSL 13:f67a6c6013ca 2069 SetError(EXTENDED_MASTER_HASH_STR, error,
wolfSSL 13:f67a6c6013ca 2070 session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2071 return -1;
wolfSSL 13:f67a6c6013ca 2072 }
wolfSSL 13:f67a6c6013ca 2073 }
wolfSSL 13:f67a6c6013ca 2074 #endif
wolfSSL 13:f67a6c6013ca 2075
wolfSSL 13:f67a6c6013ca 2076 switch (type) {
wolfSSL 13:f67a6c6013ca 2077 case hello_verify_request:
wolfSSL 13:f67a6c6013ca 2078 Trace(GOT_HELLO_VERIFY_STR);
wolfSSL 13:f67a6c6013ca 2079 break;
wolfSSL 13:f67a6c6013ca 2080 case hello_request:
wolfSSL 13:f67a6c6013ca 2081 Trace(GOT_HELLO_REQUEST_STR);
wolfSSL 13:f67a6c6013ca 2082 break;
wolfSSL 13:f67a6c6013ca 2083 case session_ticket:
wolfSSL 13:f67a6c6013ca 2084 Trace(GOT_SESSION_TICKET_STR);
wolfSSL 13:f67a6c6013ca 2085 ret = ProcessSessionTicket(input, sslBytes, session, error);
wolfSSL 13:f67a6c6013ca 2086 break;
wolfSSL 13:f67a6c6013ca 2087 case server_hello:
wolfSSL 13:f67a6c6013ca 2088 Trace(GOT_SERVER_HELLO_STR);
wolfSSL 13:f67a6c6013ca 2089 ret = ProcessServerHello(size, input, sslBytes, session, error);
wolfSSL 13:f67a6c6013ca 2090 break;
wolfSSL 13:f67a6c6013ca 2091 case certificate_request:
wolfSSL 13:f67a6c6013ca 2092 Trace(GOT_CERT_REQ_STR);
wolfSSL 13:f67a6c6013ca 2093 break;
wolfSSL 13:f67a6c6013ca 2094 case server_key_exchange:
wolfSSL 13:f67a6c6013ca 2095 Trace(GOT_SERVER_KEY_EX_STR);
wolfSSL 13:f67a6c6013ca 2096 /* can't know temp key passively */
wolfSSL 13:f67a6c6013ca 2097 SetError(BAD_CIPHER_SPEC_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2098 ret = -1;
wolfSSL 13:f67a6c6013ca 2099 break;
wolfSSL 13:f67a6c6013ca 2100 case certificate:
wolfSSL 13:f67a6c6013ca 2101 Trace(GOT_CERT_STR);
wolfSSL 13:f67a6c6013ca 2102 break;
wolfSSL 13:f67a6c6013ca 2103 case server_hello_done:
wolfSSL 13:f67a6c6013ca 2104 Trace(GOT_SERVER_HELLO_DONE_STR);
wolfSSL 13:f67a6c6013ca 2105 break;
wolfSSL 13:f67a6c6013ca 2106 case finished:
wolfSSL 13:f67a6c6013ca 2107 Trace(GOT_FINISHED_STR);
wolfSSL 13:f67a6c6013ca 2108 ret = ProcessFinished(input, size, sslBytes, session, error);
wolfSSL 13:f67a6c6013ca 2109 break;
wolfSSL 13:f67a6c6013ca 2110 case client_hello:
wolfSSL 13:f67a6c6013ca 2111 Trace(GOT_CLIENT_HELLO_STR);
wolfSSL 13:f67a6c6013ca 2112 ret = ProcessClientHello(input, sslBytes, session, error);
wolfSSL 13:f67a6c6013ca 2113 break;
wolfSSL 13:f67a6c6013ca 2114 case client_key_exchange:
wolfSSL 13:f67a6c6013ca 2115 Trace(GOT_CLIENT_KEY_EX_STR);
wolfSSL 13:f67a6c6013ca 2116 #ifdef HAVE_EXTENDED_MASTER
wolfSSL 13:f67a6c6013ca 2117 if (session->flags.expectEms && session->hash != NULL) {
wolfSSL 13:f67a6c6013ca 2118 if (HashCopy(session->sslServer->hsHashes,
wolfSSL 13:f67a6c6013ca 2119 session->hash) == 0 &&
wolfSSL 13:f67a6c6013ca 2120 HashCopy(session->sslClient->hsHashes,
wolfSSL 13:f67a6c6013ca 2121 session->hash) == 0) {
wolfSSL 13:f67a6c6013ca 2122
wolfSSL 13:f67a6c6013ca 2123 session->sslServer->options.haveEMS = 1;
wolfSSL 13:f67a6c6013ca 2124 session->sslClient->options.haveEMS = 1;
wolfSSL 13:f67a6c6013ca 2125 }
wolfSSL 13:f67a6c6013ca 2126 else {
wolfSSL 13:f67a6c6013ca 2127 SetError(EXTENDED_MASTER_HASH_STR, error,
wolfSSL 13:f67a6c6013ca 2128 session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2129 ret = -1;
wolfSSL 13:f67a6c6013ca 2130 }
wolfSSL 13:f67a6c6013ca 2131 XMEMSET(session->hash, 0, sizeof(HsHashes));
wolfSSL 13:f67a6c6013ca 2132 free(session->hash);
wolfSSL 13:f67a6c6013ca 2133 session->hash = NULL;
wolfSSL 13:f67a6c6013ca 2134 }
wolfSSL 13:f67a6c6013ca 2135 else {
wolfSSL 13:f67a6c6013ca 2136 session->sslServer->options.haveEMS = 0;
wolfSSL 13:f67a6c6013ca 2137 session->sslClient->options.haveEMS = 0;
wolfSSL 13:f67a6c6013ca 2138 }
wolfSSL 13:f67a6c6013ca 2139 #endif
wolfSSL 13:f67a6c6013ca 2140 if (ret == 0)
wolfSSL 13:f67a6c6013ca 2141 ret = ProcessClientKeyExchange(input, sslBytes, session, error);
wolfSSL 13:f67a6c6013ca 2142 break;
wolfSSL 13:f67a6c6013ca 2143 case certificate_verify:
wolfSSL 13:f67a6c6013ca 2144 Trace(GOT_CERT_VER_STR);
wolfSSL 13:f67a6c6013ca 2145 break;
wolfSSL 13:f67a6c6013ca 2146 case certificate_status:
wolfSSL 13:f67a6c6013ca 2147 Trace(GOT_CERT_STATUS_STR);
wolfSSL 13:f67a6c6013ca 2148 break;
wolfSSL 13:f67a6c6013ca 2149 default:
wolfSSL 13:f67a6c6013ca 2150 SetError(GOT_UNKNOWN_HANDSHAKE_STR, error, session, 0);
wolfSSL 13:f67a6c6013ca 2151 return -1;
wolfSSL 13:f67a6c6013ca 2152 }
wolfSSL 13:f67a6c6013ca 2153
wolfSSL 13:f67a6c6013ca 2154 *sslBytes = startBytes - size; /* actual bytes of full process */
wolfSSL 13:f67a6c6013ca 2155
wolfSSL 13:f67a6c6013ca 2156 return ret;
wolfSSL 13:f67a6c6013ca 2157 }
wolfSSL 13:f67a6c6013ca 2158
wolfSSL 13:f67a6c6013ca 2159
wolfSSL 13:f67a6c6013ca 2160 /* Decrypt input into plain output, 0 on success */
wolfSSL 13:f67a6c6013ca 2161 static int Decrypt(SSL* ssl, byte* output, const byte* input, word32 sz)
wolfSSL 13:f67a6c6013ca 2162 {
wolfSSL 13:f67a6c6013ca 2163 int ret = 0;
wolfSSL 13:f67a6c6013ca 2164
wolfSSL 13:f67a6c6013ca 2165 (void)output;
wolfSSL 13:f67a6c6013ca 2166 (void)input;
wolfSSL 13:f67a6c6013ca 2167 (void)sz;
wolfSSL 13:f67a6c6013ca 2168
wolfSSL 13:f67a6c6013ca 2169 switch (ssl->specs.bulk_cipher_algorithm) {
wolfSSL 13:f67a6c6013ca 2170 #ifdef BUILD_ARC4
wolfSSL 13:f67a6c6013ca 2171 case wolfssl_rc4:
wolfSSL 13:f67a6c6013ca 2172 wc_Arc4Process(ssl->decrypt.arc4, output, input, sz);
wolfSSL 13:f67a6c6013ca 2173 break;
wolfSSL 13:f67a6c6013ca 2174 #endif
wolfSSL 13:f67a6c6013ca 2175
wolfSSL 13:f67a6c6013ca 2176 #ifdef BUILD_DES3
wolfSSL 13:f67a6c6013ca 2177 case wolfssl_triple_des:
wolfSSL 13:f67a6c6013ca 2178 ret = wc_Des3_CbcDecrypt(ssl->decrypt.des3, output, input, sz);
wolfSSL 13:f67a6c6013ca 2179 break;
wolfSSL 13:f67a6c6013ca 2180 #endif
wolfSSL 13:f67a6c6013ca 2181
wolfSSL 13:f67a6c6013ca 2182 #ifdef BUILD_AES
wolfSSL 13:f67a6c6013ca 2183 case wolfssl_aes:
wolfSSL 13:f67a6c6013ca 2184 ret = wc_AesCbcDecrypt(ssl->decrypt.aes, output, input, sz);
wolfSSL 13:f67a6c6013ca 2185 break;
wolfSSL 13:f67a6c6013ca 2186 #endif
wolfSSL 13:f67a6c6013ca 2187
wolfSSL 13:f67a6c6013ca 2188 #ifdef HAVE_HC128
wolfSSL 13:f67a6c6013ca 2189 case wolfssl_hc128:
wolfSSL 13:f67a6c6013ca 2190 wc_Hc128_Process(ssl->decrypt.hc128, output, input, sz);
wolfSSL 13:f67a6c6013ca 2191 break;
wolfSSL 13:f67a6c6013ca 2192 #endif
wolfSSL 13:f67a6c6013ca 2193
wolfSSL 13:f67a6c6013ca 2194 #ifdef BUILD_RABBIT
wolfSSL 13:f67a6c6013ca 2195 case wolfssl_rabbit:
wolfSSL 13:f67a6c6013ca 2196 wc_RabbitProcess(ssl->decrypt.rabbit, output, input, sz);
wolfSSL 13:f67a6c6013ca 2197 break;
wolfSSL 13:f67a6c6013ca 2198 #endif
wolfSSL 13:f67a6c6013ca 2199
wolfSSL 13:f67a6c6013ca 2200 #ifdef HAVE_CAMELLIA
wolfSSL 13:f67a6c6013ca 2201 case wolfssl_camellia:
wolfSSL 13:f67a6c6013ca 2202 wc_CamelliaCbcDecrypt(ssl->decrypt.cam, output, input, sz);
wolfSSL 13:f67a6c6013ca 2203 break;
wolfSSL 13:f67a6c6013ca 2204 #endif
wolfSSL 13:f67a6c6013ca 2205
wolfSSL 13:f67a6c6013ca 2206 #ifdef HAVE_IDEA
wolfSSL 13:f67a6c6013ca 2207 case wolfssl_idea:
wolfSSL 13:f67a6c6013ca 2208 wc_IdeaCbcDecrypt(ssl->decrypt.idea, output, input, sz);
wolfSSL 13:f67a6c6013ca 2209 break;
wolfSSL 13:f67a6c6013ca 2210 #endif
wolfSSL 13:f67a6c6013ca 2211
wolfSSL 13:f67a6c6013ca 2212 #ifdef HAVE_AESGCM
wolfSSL 13:f67a6c6013ca 2213 case wolfssl_aes_gcm:
wolfSSL 13:f67a6c6013ca 2214 if (sz >= (word32)(AESGCM_EXP_IV_SZ + ssl->specs.aead_mac_size))
wolfSSL 13:f67a6c6013ca 2215 {
wolfSSL 13:f67a6c6013ca 2216 /* scratch buffer, sniffer ignores auth tag*/
wolfSSL 13:f67a6c6013ca 2217 byte authTag[WOLFSSL_MIN_AUTH_TAG_SZ];
wolfSSL 13:f67a6c6013ca 2218
wolfSSL 13:f67a6c6013ca 2219 byte nonce[AESGCM_NONCE_SZ];
wolfSSL 13:f67a6c6013ca 2220 XMEMCPY(nonce, ssl->keys.aead_dec_imp_IV, AESGCM_IMP_IV_SZ);
wolfSSL 13:f67a6c6013ca 2221 XMEMCPY(nonce + AESGCM_IMP_IV_SZ, input, AESGCM_EXP_IV_SZ);
wolfSSL 13:f67a6c6013ca 2222
wolfSSL 13:f67a6c6013ca 2223 if (wc_AesGcmEncrypt(ssl->decrypt.aes,
wolfSSL 13:f67a6c6013ca 2224 output,
wolfSSL 13:f67a6c6013ca 2225 input + AESGCM_EXP_IV_SZ,
wolfSSL 13:f67a6c6013ca 2226 sz - AESGCM_EXP_IV_SZ - ssl->specs.aead_mac_size,
wolfSSL 13:f67a6c6013ca 2227 nonce, AESGCM_NONCE_SZ,
wolfSSL 13:f67a6c6013ca 2228 authTag, sizeof(authTag),
wolfSSL 13:f67a6c6013ca 2229 NULL, 0) < 0) {
wolfSSL 13:f67a6c6013ca 2230 Trace(BAD_DECRYPT);
wolfSSL 13:f67a6c6013ca 2231 ret = -1;
wolfSSL 13:f67a6c6013ca 2232 }
wolfSSL 13:f67a6c6013ca 2233 ForceZero(nonce, AESGCM_NONCE_SZ);
wolfSSL 13:f67a6c6013ca 2234 }
wolfSSL 13:f67a6c6013ca 2235 else {
wolfSSL 13:f67a6c6013ca 2236 Trace(BAD_DECRYPT_SIZE);
wolfSSL 13:f67a6c6013ca 2237 ret = -1;
wolfSSL 13:f67a6c6013ca 2238 }
wolfSSL 13:f67a6c6013ca 2239 break;
wolfSSL 13:f67a6c6013ca 2240 #endif
wolfSSL 13:f67a6c6013ca 2241
wolfSSL 13:f67a6c6013ca 2242 default:
wolfSSL 13:f67a6c6013ca 2243 Trace(BAD_DECRYPT_TYPE);
wolfSSL 13:f67a6c6013ca 2244 ret = -1;
wolfSSL 13:f67a6c6013ca 2245 break;
wolfSSL 13:f67a6c6013ca 2246 }
wolfSSL 13:f67a6c6013ca 2247
wolfSSL 13:f67a6c6013ca 2248 return ret;
wolfSSL 13:f67a6c6013ca 2249 }
wolfSSL 13:f67a6c6013ca 2250
wolfSSL 13:f67a6c6013ca 2251
wolfSSL 13:f67a6c6013ca 2252 /* Decrypt input message into output, adjust output steam if needed */
wolfSSL 13:f67a6c6013ca 2253 static const byte* DecryptMessage(SSL* ssl, const byte* input, word32 sz,
wolfSSL 13:f67a6c6013ca 2254 byte* output, int* error, int* advance)
wolfSSL 13:f67a6c6013ca 2255 {
wolfSSL 13:f67a6c6013ca 2256 int ivExtra = 0;
wolfSSL 13:f67a6c6013ca 2257
wolfSSL 13:f67a6c6013ca 2258 int ret = Decrypt(ssl, output, input, sz);
wolfSSL 13:f67a6c6013ca 2259 if (ret != 0) {
wolfSSL 13:f67a6c6013ca 2260 *error = ret;
wolfSSL 13:f67a6c6013ca 2261 return NULL;
wolfSSL 13:f67a6c6013ca 2262 }
wolfSSL 13:f67a6c6013ca 2263 ssl->keys.encryptSz = sz;
wolfSSL 13:f67a6c6013ca 2264 if (ssl->options.tls1_1 && ssl->specs.cipher_type == block) {
wolfSSL 13:f67a6c6013ca 2265 output += ssl->specs.block_size; /* go past TLSv1.1 IV */
wolfSSL 13:f67a6c6013ca 2266 ivExtra = ssl->specs.block_size;
wolfSSL 13:f67a6c6013ca 2267 *advance = ssl->specs.block_size;
wolfSSL 13:f67a6c6013ca 2268 }
wolfSSL 13:f67a6c6013ca 2269
wolfSSL 13:f67a6c6013ca 2270 if (ssl->specs.cipher_type == aead) {
wolfSSL 13:f67a6c6013ca 2271 *advance = ssl->specs.aead_mac_size;
wolfSSL 13:f67a6c6013ca 2272 ssl->keys.padSz = ssl->specs.aead_mac_size;
wolfSSL 13:f67a6c6013ca 2273 }
wolfSSL 13:f67a6c6013ca 2274 else
wolfSSL 13:f67a6c6013ca 2275 ssl->keys.padSz = ssl->specs.hash_size;
wolfSSL 13:f67a6c6013ca 2276
wolfSSL 13:f67a6c6013ca 2277 if (ssl->specs.cipher_type == block)
wolfSSL 13:f67a6c6013ca 2278 ssl->keys.padSz += *(output + sz - ivExtra - 1) + 1;
wolfSSL 13:f67a6c6013ca 2279
wolfSSL 13:f67a6c6013ca 2280 return output;
wolfSSL 13:f67a6c6013ca 2281 }
wolfSSL 13:f67a6c6013ca 2282
wolfSSL 13:f67a6c6013ca 2283
wolfSSL 13:f67a6c6013ca 2284 /* remove session from table, use rowHint if no info (means we have a lock) */
wolfSSL 13:f67a6c6013ca 2285 static void RemoveSession(SnifferSession* session, IpInfo* ipInfo,
wolfSSL 13:f67a6c6013ca 2286 TcpInfo* tcpInfo, word32 rowHint)
wolfSSL 13:f67a6c6013ca 2287 {
wolfSSL 13:f67a6c6013ca 2288 SnifferSession* previous = 0;
wolfSSL 13:f67a6c6013ca 2289 SnifferSession* current;
wolfSSL 13:f67a6c6013ca 2290 word32 row = rowHint;
wolfSSL 13:f67a6c6013ca 2291 int haveLock = 0;
wolfSSL 13:f67a6c6013ca 2292
wolfSSL 13:f67a6c6013ca 2293 if (ipInfo && tcpInfo)
wolfSSL 13:f67a6c6013ca 2294 row = SessionHash(ipInfo, tcpInfo);
wolfSSL 13:f67a6c6013ca 2295 else
wolfSSL 13:f67a6c6013ca 2296 haveLock = 1;
wolfSSL 13:f67a6c6013ca 2297
wolfSSL 13:f67a6c6013ca 2298 assert(row <= HASH_SIZE);
wolfSSL 13:f67a6c6013ca 2299 Trace(REMOVE_SESSION_STR);
wolfSSL 13:f67a6c6013ca 2300
wolfSSL 13:f67a6c6013ca 2301 if (!haveLock)
wolfSSL 13:f67a6c6013ca 2302 wc_LockMutex(&SessionMutex);
wolfSSL 13:f67a6c6013ca 2303
wolfSSL 13:f67a6c6013ca 2304 current = SessionTable[row];
wolfSSL 13:f67a6c6013ca 2305
wolfSSL 13:f67a6c6013ca 2306 while (current) {
wolfSSL 13:f67a6c6013ca 2307 if (current == session) {
wolfSSL 13:f67a6c6013ca 2308 if (previous)
wolfSSL 13:f67a6c6013ca 2309 previous->next = current->next;
wolfSSL 13:f67a6c6013ca 2310 else
wolfSSL 13:f67a6c6013ca 2311 SessionTable[row] = current->next;
wolfSSL 13:f67a6c6013ca 2312 FreeSnifferSession(session);
wolfSSL 13:f67a6c6013ca 2313 TraceRemovedSession();
wolfSSL 13:f67a6c6013ca 2314 break;
wolfSSL 13:f67a6c6013ca 2315 }
wolfSSL 13:f67a6c6013ca 2316 previous = current;
wolfSSL 13:f67a6c6013ca 2317 current = current->next;
wolfSSL 13:f67a6c6013ca 2318 }
wolfSSL 13:f67a6c6013ca 2319
wolfSSL 13:f67a6c6013ca 2320 if (!haveLock)
wolfSSL 13:f67a6c6013ca 2321 wc_UnLockMutex(&SessionMutex);
wolfSSL 13:f67a6c6013ca 2322 }
wolfSSL 13:f67a6c6013ca 2323
wolfSSL 13:f67a6c6013ca 2324
wolfSSL 13:f67a6c6013ca 2325 /* Remove stale sessions from the Session Table, have a lock */
wolfSSL 13:f67a6c6013ca 2326 static void RemoveStaleSessions(void)
wolfSSL 13:f67a6c6013ca 2327 {
wolfSSL 13:f67a6c6013ca 2328 word32 i;
wolfSSL 13:f67a6c6013ca 2329 SnifferSession* session;
wolfSSL 13:f67a6c6013ca 2330
wolfSSL 13:f67a6c6013ca 2331 for (i = 0; i < HASH_SIZE; i++) {
wolfSSL 13:f67a6c6013ca 2332 session = SessionTable[i];
wolfSSL 13:f67a6c6013ca 2333 while (session) {
wolfSSL 13:f67a6c6013ca 2334 SnifferSession* next = session->next;
wolfSSL 13:f67a6c6013ca 2335 if (time(NULL) >= session->lastUsed + WOLFSSL_SNIFFER_TIMEOUT) {
wolfSSL 13:f67a6c6013ca 2336 TraceStaleSession();
wolfSSL 13:f67a6c6013ca 2337 RemoveSession(session, NULL, NULL, i);
wolfSSL 13:f67a6c6013ca 2338 }
wolfSSL 13:f67a6c6013ca 2339 session = next;
wolfSSL 13:f67a6c6013ca 2340 }
wolfSSL 13:f67a6c6013ca 2341 }
wolfSSL 13:f67a6c6013ca 2342 }
wolfSSL 13:f67a6c6013ca 2343
wolfSSL 13:f67a6c6013ca 2344
wolfSSL 13:f67a6c6013ca 2345 /* Create a new Sniffer Session */
wolfSSL 13:f67a6c6013ca 2346 static SnifferSession* CreateSession(IpInfo* ipInfo, TcpInfo* tcpInfo,
wolfSSL 13:f67a6c6013ca 2347 char* error)
wolfSSL 13:f67a6c6013ca 2348 {
wolfSSL 13:f67a6c6013ca 2349 SnifferSession* session = 0;
wolfSSL 13:f67a6c6013ca 2350 int row;
wolfSSL 13:f67a6c6013ca 2351
wolfSSL 13:f67a6c6013ca 2352 Trace(NEW_SESSION_STR);
wolfSSL 13:f67a6c6013ca 2353 /* create a new one */
wolfSSL 13:f67a6c6013ca 2354 session = (SnifferSession*)malloc(sizeof(SnifferSession));
wolfSSL 13:f67a6c6013ca 2355 if (session == NULL) {
wolfSSL 13:f67a6c6013ca 2356 SetError(MEMORY_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 2357 return 0;
wolfSSL 13:f67a6c6013ca 2358 }
wolfSSL 13:f67a6c6013ca 2359 InitSession(session);
wolfSSL 13:f67a6c6013ca 2360 #ifdef HAVE_EXTENDED_MASTER
wolfSSL 13:f67a6c6013ca 2361 {
wolfSSL 13:f67a6c6013ca 2362 HsHashes* newHash = (HsHashes*)malloc(sizeof(HsHashes));
wolfSSL 13:f67a6c6013ca 2363 if (newHash == NULL) {
wolfSSL 13:f67a6c6013ca 2364 SetError(MEMORY_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 2365 free(session);
wolfSSL 13:f67a6c6013ca 2366 return 0;
wolfSSL 13:f67a6c6013ca 2367 }
wolfSSL 13:f67a6c6013ca 2368 if (HashInit(newHash) != 0) {
wolfSSL 13:f67a6c6013ca 2369 SetError(EXTENDED_MASTER_HASH_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 2370 free(session);
wolfSSL 13:f67a6c6013ca 2371 return 0;
wolfSSL 13:f67a6c6013ca 2372 }
wolfSSL 13:f67a6c6013ca 2373 session->hash = newHash;
wolfSSL 13:f67a6c6013ca 2374 }
wolfSSL 13:f67a6c6013ca 2375 #endif
wolfSSL 13:f67a6c6013ca 2376 session->server = ipInfo->dst;
wolfSSL 13:f67a6c6013ca 2377 session->client = ipInfo->src;
wolfSSL 13:f67a6c6013ca 2378 session->srvPort = (word16)tcpInfo->dstPort;
wolfSSL 13:f67a6c6013ca 2379 session->cliPort = (word16)tcpInfo->srcPort;
wolfSSL 13:f67a6c6013ca 2380 session->cliSeqStart = tcpInfo->sequence;
wolfSSL 13:f67a6c6013ca 2381 session->cliExpected = 1; /* relative */
wolfSSL 13:f67a6c6013ca 2382 session->lastUsed= time(NULL);
wolfSSL 13:f67a6c6013ca 2383
wolfSSL 13:f67a6c6013ca 2384 session->context = GetSnifferServer(ipInfo, tcpInfo);
wolfSSL 13:f67a6c6013ca 2385 if (session->context == NULL) {
wolfSSL 13:f67a6c6013ca 2386 SetError(SERVER_NOT_REG_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 2387 free(session);
wolfSSL 13:f67a6c6013ca 2388 return 0;
wolfSSL 13:f67a6c6013ca 2389 }
wolfSSL 13:f67a6c6013ca 2390
wolfSSL 13:f67a6c6013ca 2391 session->sslServer = SSL_new(session->context->ctx);
wolfSSL 13:f67a6c6013ca 2392 if (session->sslServer == NULL) {
wolfSSL 13:f67a6c6013ca 2393 SetError(BAD_NEW_SSL_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2394 free(session);
wolfSSL 13:f67a6c6013ca 2395 return 0;
wolfSSL 13:f67a6c6013ca 2396 }
wolfSSL 13:f67a6c6013ca 2397 session->sslClient = SSL_new(session->context->ctx);
wolfSSL 13:f67a6c6013ca 2398 if (session->sslClient == NULL) {
wolfSSL 13:f67a6c6013ca 2399 SSL_free(session->sslServer);
wolfSSL 13:f67a6c6013ca 2400 session->sslServer = 0;
wolfSSL 13:f67a6c6013ca 2401
wolfSSL 13:f67a6c6013ca 2402 SetError(BAD_NEW_SSL_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2403 free(session);
wolfSSL 13:f67a6c6013ca 2404 return 0;
wolfSSL 13:f67a6c6013ca 2405 }
wolfSSL 13:f67a6c6013ca 2406 /* put server back into server mode */
wolfSSL 13:f67a6c6013ca 2407 session->sslServer->options.side = WOLFSSL_SERVER_END;
wolfSSL 13:f67a6c6013ca 2408
wolfSSL 13:f67a6c6013ca 2409 row = SessionHash(ipInfo, tcpInfo);
wolfSSL 13:f67a6c6013ca 2410
wolfSSL 13:f67a6c6013ca 2411 /* add it to the session table */
wolfSSL 13:f67a6c6013ca 2412 wc_LockMutex(&SessionMutex);
wolfSSL 13:f67a6c6013ca 2413
wolfSSL 13:f67a6c6013ca 2414 session->next = SessionTable[row];
wolfSSL 13:f67a6c6013ca 2415 SessionTable[row] = session;
wolfSSL 13:f67a6c6013ca 2416
wolfSSL 13:f67a6c6013ca 2417 SessionCount++;
wolfSSL 13:f67a6c6013ca 2418
wolfSSL 13:f67a6c6013ca 2419 if ( (SessionCount % HASH_SIZE) == 0) {
wolfSSL 13:f67a6c6013ca 2420 TraceFindingStale();
wolfSSL 13:f67a6c6013ca 2421 RemoveStaleSessions();
wolfSSL 13:f67a6c6013ca 2422 }
wolfSSL 13:f67a6c6013ca 2423
wolfSSL 13:f67a6c6013ca 2424 wc_UnLockMutex(&SessionMutex);
wolfSSL 13:f67a6c6013ca 2425
wolfSSL 13:f67a6c6013ca 2426 /* determine headed side */
wolfSSL 13:f67a6c6013ca 2427 if (ipInfo->dst == session->context->server &&
wolfSSL 13:f67a6c6013ca 2428 tcpInfo->dstPort == session->context->port)
wolfSSL 13:f67a6c6013ca 2429 session->flags.side = WOLFSSL_SERVER_END;
wolfSSL 13:f67a6c6013ca 2430 else
wolfSSL 13:f67a6c6013ca 2431 session->flags.side = WOLFSSL_CLIENT_END;
wolfSSL 13:f67a6c6013ca 2432
wolfSSL 13:f67a6c6013ca 2433 return session;
wolfSSL 13:f67a6c6013ca 2434 }
wolfSSL 13:f67a6c6013ca 2435
wolfSSL 13:f67a6c6013ca 2436
wolfSSL 13:f67a6c6013ca 2437 #ifdef OLD_HELLO_ALLOWED
wolfSSL 13:f67a6c6013ca 2438
wolfSSL 13:f67a6c6013ca 2439 /* Process Old Client Hello Input */
wolfSSL 13:f67a6c6013ca 2440 static int DoOldHello(SnifferSession* session, const byte* sslFrame,
wolfSSL 13:f67a6c6013ca 2441 int* rhSize, int* sslBytes, char* error)
wolfSSL 13:f67a6c6013ca 2442 {
wolfSSL 13:f67a6c6013ca 2443 const byte* input = sslFrame;
wolfSSL 13:f67a6c6013ca 2444 byte b0, b1;
wolfSSL 13:f67a6c6013ca 2445 word32 idx = 0;
wolfSSL 13:f67a6c6013ca 2446 int ret;
wolfSSL 13:f67a6c6013ca 2447
wolfSSL 13:f67a6c6013ca 2448 Trace(GOT_OLD_CLIENT_HELLO_STR);
wolfSSL 13:f67a6c6013ca 2449 session->flags.clientHello = 1; /* don't process again */
wolfSSL 13:f67a6c6013ca 2450 b0 = *input++;
wolfSSL 13:f67a6c6013ca 2451 b1 = *input++;
wolfSSL 13:f67a6c6013ca 2452 *sslBytes -= 2;
wolfSSL 13:f67a6c6013ca 2453 *rhSize = ((b0 & 0x7f) << 8) | b1;
wolfSSL 13:f67a6c6013ca 2454
wolfSSL 13:f67a6c6013ca 2455 if (*rhSize > *sslBytes) {
wolfSSL 13:f67a6c6013ca 2456 SetError(OLD_CLIENT_INPUT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2457 return -1;
wolfSSL 13:f67a6c6013ca 2458 }
wolfSSL 13:f67a6c6013ca 2459
wolfSSL 13:f67a6c6013ca 2460 ret = ProcessOldClientHello(session->sslServer, input, &idx, *sslBytes,
wolfSSL 13:f67a6c6013ca 2461 (word16)*rhSize);
wolfSSL 13:f67a6c6013ca 2462 if (ret < 0 && ret != MATCH_SUITE_ERROR) {
wolfSSL 13:f67a6c6013ca 2463 SetError(BAD_OLD_CLIENT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2464 return -1;
wolfSSL 13:f67a6c6013ca 2465 }
wolfSSL 13:f67a6c6013ca 2466
wolfSSL 13:f67a6c6013ca 2467 Trace(OLD_CLIENT_OK_STR);
wolfSSL 13:f67a6c6013ca 2468 XMEMCPY(session->sslClient->arrays->clientRandom,
wolfSSL 13:f67a6c6013ca 2469 session->sslServer->arrays->clientRandom, RAN_LEN);
wolfSSL 13:f67a6c6013ca 2470
wolfSSL 13:f67a6c6013ca 2471 *sslBytes -= *rhSize;
wolfSSL 13:f67a6c6013ca 2472 return 0;
wolfSSL 13:f67a6c6013ca 2473 }
wolfSSL 13:f67a6c6013ca 2474
wolfSSL 13:f67a6c6013ca 2475 #endif /* OLD_HELLO_ALLOWED */
wolfSSL 13:f67a6c6013ca 2476
wolfSSL 13:f67a6c6013ca 2477
wolfSSL 13:f67a6c6013ca 2478 #if 0
wolfSSL 13:f67a6c6013ca 2479 /* Calculate the TCP checksum, see RFC 1071 */
wolfSSL 13:f67a6c6013ca 2480 /* return 0 for success, -1 on error */
wolfSSL 13:f67a6c6013ca 2481 /* can be called from decode() with
wolfSSL 13:f67a6c6013ca 2482 TcpChecksum(&ipInfo, &tcpInfo, sslBytes, packet + ipInfo.length);
wolfSSL 13:f67a6c6013ca 2483 could also add a 64bit version if type available and using this
wolfSSL 13:f67a6c6013ca 2484 */
wolfSSL 13:f67a6c6013ca 2485 int TcpChecksum(IpInfo* ipInfo, TcpInfo* tcpInfo, int dataLen,
wolfSSL 13:f67a6c6013ca 2486 const byte* packet)
wolfSSL 13:f67a6c6013ca 2487 {
wolfSSL 13:f67a6c6013ca 2488 TcpPseudoHdr pseudo;
wolfSSL 13:f67a6c6013ca 2489 int count = PSEUDO_HDR_SZ;
wolfSSL 13:f67a6c6013ca 2490 const word16* data = (word16*)&pseudo;
wolfSSL 13:f67a6c6013ca 2491 word32 sum = 0;
wolfSSL 13:f67a6c6013ca 2492 word16 checksum;
wolfSSL 13:f67a6c6013ca 2493
wolfSSL 13:f67a6c6013ca 2494 pseudo.src = ipInfo->src;
wolfSSL 13:f67a6c6013ca 2495 pseudo.dst = ipInfo->dst;
wolfSSL 13:f67a6c6013ca 2496 pseudo.rsv = 0;
wolfSSL 13:f67a6c6013ca 2497 pseudo.protocol = TCP_PROTO;
wolfSSL 13:f67a6c6013ca 2498 pseudo.length = htons(tcpInfo->length + dataLen);
wolfSSL 13:f67a6c6013ca 2499
wolfSSL 13:f67a6c6013ca 2500 /* pseudo header sum */
wolfSSL 13:f67a6c6013ca 2501 while (count >= 2) {
wolfSSL 13:f67a6c6013ca 2502 sum += *data++;
wolfSSL 13:f67a6c6013ca 2503 count -= 2;
wolfSSL 13:f67a6c6013ca 2504 }
wolfSSL 13:f67a6c6013ca 2505
wolfSSL 13:f67a6c6013ca 2506 count = tcpInfo->length + dataLen;
wolfSSL 13:f67a6c6013ca 2507 data = (word16*)packet;
wolfSSL 13:f67a6c6013ca 2508
wolfSSL 13:f67a6c6013ca 2509 /* main sum */
wolfSSL 13:f67a6c6013ca 2510 while (count > 1) {
wolfSSL 13:f67a6c6013ca 2511 sum += *data++;
wolfSSL 13:f67a6c6013ca 2512 count -=2;
wolfSSL 13:f67a6c6013ca 2513 }
wolfSSL 13:f67a6c6013ca 2514
wolfSSL 13:f67a6c6013ca 2515 /* get left-over, if any */
wolfSSL 13:f67a6c6013ca 2516 packet = (byte*)data;
wolfSSL 13:f67a6c6013ca 2517 if (count > 0) {
wolfSSL 13:f67a6c6013ca 2518 sum += *packet;
wolfSSL 13:f67a6c6013ca 2519 }
wolfSSL 13:f67a6c6013ca 2520
wolfSSL 13:f67a6c6013ca 2521 /* fold 32bit sum into 16 bits */
wolfSSL 13:f67a6c6013ca 2522 while (sum >> 16)
wolfSSL 13:f67a6c6013ca 2523 sum = (sum & 0xffff) + (sum >> 16);
wolfSSL 13:f67a6c6013ca 2524
wolfSSL 13:f67a6c6013ca 2525 checksum = (word16)~sum;
wolfSSL 13:f67a6c6013ca 2526 /* checksum should now equal 0, since included already calcd checksum */
wolfSSL 13:f67a6c6013ca 2527 /* field, but tcp checksum offloading could negate calculation */
wolfSSL 13:f67a6c6013ca 2528 if (checksum == 0)
wolfSSL 13:f67a6c6013ca 2529 return 0;
wolfSSL 13:f67a6c6013ca 2530 return -1;
wolfSSL 13:f67a6c6013ca 2531 }
wolfSSL 13:f67a6c6013ca 2532 #endif
wolfSSL 13:f67a6c6013ca 2533
wolfSSL 13:f67a6c6013ca 2534
wolfSSL 13:f67a6c6013ca 2535 /* Check IP and TCP headers, set payload */
wolfSSL 13:f67a6c6013ca 2536 /* returns 0 on success, -1 on error */
wolfSSL 13:f67a6c6013ca 2537 static int CheckHeaders(IpInfo* ipInfo, TcpInfo* tcpInfo, const byte* packet,
wolfSSL 13:f67a6c6013ca 2538 int length, const byte** sslFrame, int* sslBytes, char* error)
wolfSSL 13:f67a6c6013ca 2539 {
wolfSSL 13:f67a6c6013ca 2540 TraceHeader();
wolfSSL 13:f67a6c6013ca 2541 TracePacket();
wolfSSL 13:f67a6c6013ca 2542
wolfSSL 13:f67a6c6013ca 2543 /* ip header */
wolfSSL 13:f67a6c6013ca 2544 if (length < IP_HDR_SZ) {
wolfSSL 13:f67a6c6013ca 2545 SetError(PACKET_HDR_SHORT_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 2546 return -1;
wolfSSL 13:f67a6c6013ca 2547 }
wolfSSL 13:f67a6c6013ca 2548 if (CheckIpHdr((IpHdr*)packet, ipInfo, length, error) != 0)
wolfSSL 13:f67a6c6013ca 2549 return -1;
wolfSSL 13:f67a6c6013ca 2550
wolfSSL 13:f67a6c6013ca 2551 /* tcp header */
wolfSSL 13:f67a6c6013ca 2552 if (length < (ipInfo->length + TCP_HDR_SZ)) {
wolfSSL 13:f67a6c6013ca 2553 SetError(PACKET_HDR_SHORT_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 2554 return -1;
wolfSSL 13:f67a6c6013ca 2555 }
wolfSSL 13:f67a6c6013ca 2556 if (CheckTcpHdr((TcpHdr*)(packet + ipInfo->length), tcpInfo, error) != 0)
wolfSSL 13:f67a6c6013ca 2557 return -1;
wolfSSL 13:f67a6c6013ca 2558
wolfSSL 13:f67a6c6013ca 2559 /* setup */
wolfSSL 13:f67a6c6013ca 2560 *sslFrame = packet + ipInfo->length + tcpInfo->length;
wolfSSL 13:f67a6c6013ca 2561 if (*sslFrame > packet + length) {
wolfSSL 13:f67a6c6013ca 2562 SetError(PACKET_HDR_SHORT_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 2563 return -1;
wolfSSL 13:f67a6c6013ca 2564 }
wolfSSL 13:f67a6c6013ca 2565 *sslBytes = (int)(packet + length - *sslFrame);
wolfSSL 13:f67a6c6013ca 2566
wolfSSL 13:f67a6c6013ca 2567 return 0;
wolfSSL 13:f67a6c6013ca 2568 }
wolfSSL 13:f67a6c6013ca 2569
wolfSSL 13:f67a6c6013ca 2570
wolfSSL 13:f67a6c6013ca 2571 /* Create or Find existing session */
wolfSSL 13:f67a6c6013ca 2572 /* returns 0 on success (continue), -1 on error, 1 on success (end) */
wolfSSL 13:f67a6c6013ca 2573 static int CheckSession(IpInfo* ipInfo, TcpInfo* tcpInfo, int sslBytes,
wolfSSL 13:f67a6c6013ca 2574 SnifferSession** session, char* error)
wolfSSL 13:f67a6c6013ca 2575 {
wolfSSL 13:f67a6c6013ca 2576 /* create a new SnifferSession on client SYN */
wolfSSL 13:f67a6c6013ca 2577 if (tcpInfo->syn && !tcpInfo->ack) {
wolfSSL 13:f67a6c6013ca 2578 TraceClientSyn(tcpInfo->sequence);
wolfSSL 13:f67a6c6013ca 2579 *session = CreateSession(ipInfo, tcpInfo, error);
wolfSSL 13:f67a6c6013ca 2580 if (*session == NULL) {
wolfSSL 13:f67a6c6013ca 2581 *session = GetSnifferSession(ipInfo, tcpInfo);
wolfSSL 13:f67a6c6013ca 2582 /* already had existing, so OK */
wolfSSL 13:f67a6c6013ca 2583 if (*session)
wolfSSL 13:f67a6c6013ca 2584 return 1;
wolfSSL 13:f67a6c6013ca 2585
wolfSSL 13:f67a6c6013ca 2586 SetError(MEMORY_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 2587 return -1;
wolfSSL 13:f67a6c6013ca 2588 }
wolfSSL 13:f67a6c6013ca 2589 return 1;
wolfSSL 13:f67a6c6013ca 2590 }
wolfSSL 13:f67a6c6013ca 2591 /* get existing sniffer session */
wolfSSL 13:f67a6c6013ca 2592 else {
wolfSSL 13:f67a6c6013ca 2593 *session = GetSnifferSession(ipInfo, tcpInfo);
wolfSSL 13:f67a6c6013ca 2594 if (*session == NULL) {
wolfSSL 13:f67a6c6013ca 2595 /* don't worry about extraneous RST or duplicate FINs */
wolfSSL 13:f67a6c6013ca 2596 if (tcpInfo->fin || tcpInfo->rst)
wolfSSL 13:f67a6c6013ca 2597 return 1;
wolfSSL 13:f67a6c6013ca 2598 /* don't worry about duplicate ACKs either */
wolfSSL 13:f67a6c6013ca 2599 if (sslBytes == 0 && tcpInfo->ack)
wolfSSL 13:f67a6c6013ca 2600 return 1;
wolfSSL 13:f67a6c6013ca 2601
wolfSSL 13:f67a6c6013ca 2602 SetError(BAD_SESSION_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 2603 return -1;
wolfSSL 13:f67a6c6013ca 2604 }
wolfSSL 13:f67a6c6013ca 2605 }
wolfSSL 13:f67a6c6013ca 2606 return 0;
wolfSSL 13:f67a6c6013ca 2607 }
wolfSSL 13:f67a6c6013ca 2608
wolfSSL 13:f67a6c6013ca 2609
wolfSSL 13:f67a6c6013ca 2610 /* Create a Packet Buffer from *begin - end, adjust new *begin and bytesLeft */
wolfSSL 13:f67a6c6013ca 2611 static PacketBuffer* CreateBuffer(word32* begin, word32 end, const byte* data,
wolfSSL 13:f67a6c6013ca 2612 int* bytesLeft)
wolfSSL 13:f67a6c6013ca 2613 {
wolfSSL 13:f67a6c6013ca 2614 PacketBuffer* pb;
wolfSSL 13:f67a6c6013ca 2615
wolfSSL 13:f67a6c6013ca 2616 int added = end - *begin + 1;
wolfSSL 13:f67a6c6013ca 2617 assert(*begin <= end);
wolfSSL 13:f67a6c6013ca 2618
wolfSSL 13:f67a6c6013ca 2619 pb = (PacketBuffer*)malloc(sizeof(PacketBuffer));
wolfSSL 13:f67a6c6013ca 2620 if (pb == NULL) return NULL;
wolfSSL 13:f67a6c6013ca 2621
wolfSSL 13:f67a6c6013ca 2622 pb->next = 0;
wolfSSL 13:f67a6c6013ca 2623 pb->begin = *begin;
wolfSSL 13:f67a6c6013ca 2624 pb->end = end;
wolfSSL 13:f67a6c6013ca 2625 pb->data = (byte*)malloc(added);
wolfSSL 13:f67a6c6013ca 2626
wolfSSL 13:f67a6c6013ca 2627 if (pb->data == NULL) {
wolfSSL 13:f67a6c6013ca 2628 free(pb);
wolfSSL 13:f67a6c6013ca 2629 return NULL;
wolfSSL 13:f67a6c6013ca 2630 }
wolfSSL 13:f67a6c6013ca 2631 XMEMCPY(pb->data, data, added);
wolfSSL 13:f67a6c6013ca 2632
wolfSSL 13:f67a6c6013ca 2633 *bytesLeft -= added;
wolfSSL 13:f67a6c6013ca 2634 *begin = pb->end + 1;
wolfSSL 13:f67a6c6013ca 2635
wolfSSL 13:f67a6c6013ca 2636 return pb;
wolfSSL 13:f67a6c6013ca 2637 }
wolfSSL 13:f67a6c6013ca 2638
wolfSSL 13:f67a6c6013ca 2639
wolfSSL 13:f67a6c6013ca 2640 /* Add sslFrame to Reassembly List */
wolfSSL 13:f67a6c6013ca 2641 /* returns 1 (end) on success, -1, on error */
wolfSSL 13:f67a6c6013ca 2642 static int AddToReassembly(byte from, word32 seq, const byte* sslFrame,
wolfSSL 13:f67a6c6013ca 2643 int sslBytes, SnifferSession* session, char* error)
wolfSSL 13:f67a6c6013ca 2644 {
wolfSSL 13:f67a6c6013ca 2645 PacketBuffer* add;
wolfSSL 13:f67a6c6013ca 2646 PacketBuffer** front = (from == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2647 &session->cliReassemblyList: &session->srvReassemblyList;
wolfSSL 13:f67a6c6013ca 2648 PacketBuffer* curr = *front;
wolfSSL 13:f67a6c6013ca 2649 PacketBuffer* prev = curr;
wolfSSL 13:f67a6c6013ca 2650
wolfSSL 13:f67a6c6013ca 2651 word32* reassemblyMemory = (from == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2652 &session->cliReassemblyMemory : &session->srvReassemblyMemory;
wolfSSL 13:f67a6c6013ca 2653 word32 startSeq = seq;
wolfSSL 13:f67a6c6013ca 2654 word32 added;
wolfSSL 13:f67a6c6013ca 2655 int bytesLeft = sslBytes; /* could be overlapping fragment */
wolfSSL 13:f67a6c6013ca 2656
wolfSSL 13:f67a6c6013ca 2657 /* if list is empty add full frame to front */
wolfSSL 13:f67a6c6013ca 2658 if (!curr) {
wolfSSL 13:f67a6c6013ca 2659 if (MaxRecoveryMemory != -1 &&
wolfSSL 13:f67a6c6013ca 2660 (int)(*reassemblyMemory + sslBytes) > MaxRecoveryMemory) {
wolfSSL 13:f67a6c6013ca 2661 SetError(REASSEMBLY_MAX_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2662 return -1;
wolfSSL 13:f67a6c6013ca 2663 }
wolfSSL 13:f67a6c6013ca 2664 add = CreateBuffer(&seq, seq + sslBytes - 1, sslFrame, &bytesLeft);
wolfSSL 13:f67a6c6013ca 2665 if (add == NULL) {
wolfSSL 13:f67a6c6013ca 2666 SetError(MEMORY_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2667 return -1;
wolfSSL 13:f67a6c6013ca 2668 }
wolfSSL 13:f67a6c6013ca 2669 *front = add;
wolfSSL 13:f67a6c6013ca 2670 *reassemblyMemory += sslBytes;
wolfSSL 13:f67a6c6013ca 2671 return 1;
wolfSSL 13:f67a6c6013ca 2672 }
wolfSSL 13:f67a6c6013ca 2673
wolfSSL 13:f67a6c6013ca 2674 /* add to front if before current front, up to next->begin */
wolfSSL 13:f67a6c6013ca 2675 if (seq < curr->begin) {
wolfSSL 13:f67a6c6013ca 2676 word32 end = seq + sslBytes - 1;
wolfSSL 13:f67a6c6013ca 2677
wolfSSL 13:f67a6c6013ca 2678 if (end >= curr->begin)
wolfSSL 13:f67a6c6013ca 2679 end = curr->begin - 1;
wolfSSL 13:f67a6c6013ca 2680
wolfSSL 13:f67a6c6013ca 2681 if (MaxRecoveryMemory -1 &&
wolfSSL 13:f67a6c6013ca 2682 (int)(*reassemblyMemory + sslBytes) > MaxRecoveryMemory) {
wolfSSL 13:f67a6c6013ca 2683 SetError(REASSEMBLY_MAX_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2684 return -1;
wolfSSL 13:f67a6c6013ca 2685 }
wolfSSL 13:f67a6c6013ca 2686 add = CreateBuffer(&seq, end, sslFrame, &bytesLeft);
wolfSSL 13:f67a6c6013ca 2687 if (add == NULL) {
wolfSSL 13:f67a6c6013ca 2688 SetError(MEMORY_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2689 return -1;
wolfSSL 13:f67a6c6013ca 2690 }
wolfSSL 13:f67a6c6013ca 2691 add->next = curr;
wolfSSL 13:f67a6c6013ca 2692 *front = add;
wolfSSL 13:f67a6c6013ca 2693 *reassemblyMemory += sslBytes;
wolfSSL 13:f67a6c6013ca 2694 }
wolfSSL 13:f67a6c6013ca 2695
wolfSSL 13:f67a6c6013ca 2696 /* while we have bytes left, try to find a gap to fill */
wolfSSL 13:f67a6c6013ca 2697 while (bytesLeft > 0) {
wolfSSL 13:f67a6c6013ca 2698 /* get previous packet in list */
wolfSSL 13:f67a6c6013ca 2699 while (curr && (seq >= curr->begin)) {
wolfSSL 13:f67a6c6013ca 2700 prev = curr;
wolfSSL 13:f67a6c6013ca 2701 curr = curr->next;
wolfSSL 13:f67a6c6013ca 2702 }
wolfSSL 13:f67a6c6013ca 2703
wolfSSL 13:f67a6c6013ca 2704 /* don't add duplicate data */
wolfSSL 13:f67a6c6013ca 2705 if (prev->end >= seq) {
wolfSSL 13:f67a6c6013ca 2706 if ( (seq + bytesLeft - 1) <= prev->end)
wolfSSL 13:f67a6c6013ca 2707 return 1;
wolfSSL 13:f67a6c6013ca 2708 seq = prev->end + 1;
wolfSSL 13:f67a6c6013ca 2709 bytesLeft = startSeq + sslBytes - seq;
wolfSSL 13:f67a6c6013ca 2710 }
wolfSSL 13:f67a6c6013ca 2711
wolfSSL 13:f67a6c6013ca 2712 if (!curr)
wolfSSL 13:f67a6c6013ca 2713 /* we're at the end */
wolfSSL 13:f67a6c6013ca 2714 added = bytesLeft;
wolfSSL 13:f67a6c6013ca 2715 else
wolfSSL 13:f67a6c6013ca 2716 /* we're in between two frames */
wolfSSL 13:f67a6c6013ca 2717 added = min((word32)bytesLeft, curr->begin - seq);
wolfSSL 13:f67a6c6013ca 2718
wolfSSL 13:f67a6c6013ca 2719 /* data already there */
wolfSSL 13:f67a6c6013ca 2720 if (added == 0)
wolfSSL 13:f67a6c6013ca 2721 continue;
wolfSSL 13:f67a6c6013ca 2722
wolfSSL 13:f67a6c6013ca 2723 if (MaxRecoveryMemory != -1 &&
wolfSSL 13:f67a6c6013ca 2724 (int)(*reassemblyMemory + added) > MaxRecoveryMemory) {
wolfSSL 13:f67a6c6013ca 2725 SetError(REASSEMBLY_MAX_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2726 return -1;
wolfSSL 13:f67a6c6013ca 2727 }
wolfSSL 13:f67a6c6013ca 2728 add = CreateBuffer(&seq, seq + added - 1, &sslFrame[seq - startSeq],
wolfSSL 13:f67a6c6013ca 2729 &bytesLeft);
wolfSSL 13:f67a6c6013ca 2730 if (add == NULL) {
wolfSSL 13:f67a6c6013ca 2731 SetError(MEMORY_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2732 return -1;
wolfSSL 13:f67a6c6013ca 2733 }
wolfSSL 13:f67a6c6013ca 2734 add->next = prev->next;
wolfSSL 13:f67a6c6013ca 2735 prev->next = add;
wolfSSL 13:f67a6c6013ca 2736 *reassemblyMemory += added;
wolfSSL 13:f67a6c6013ca 2737 }
wolfSSL 13:f67a6c6013ca 2738 return 1;
wolfSSL 13:f67a6c6013ca 2739 }
wolfSSL 13:f67a6c6013ca 2740
wolfSSL 13:f67a6c6013ca 2741
wolfSSL 13:f67a6c6013ca 2742 /* Add out of order FIN capture */
wolfSSL 13:f67a6c6013ca 2743 /* returns 1 for success (end) */
wolfSSL 13:f67a6c6013ca 2744 static int AddFinCapture(SnifferSession* session, word32 sequence)
wolfSSL 13:f67a6c6013ca 2745 {
wolfSSL 13:f67a6c6013ca 2746 if (session->flags.side == WOLFSSL_SERVER_END) {
wolfSSL 13:f67a6c6013ca 2747 if (session->finCaputre.cliCounted == 0)
wolfSSL 13:f67a6c6013ca 2748 session->finCaputre.cliFinSeq = sequence;
wolfSSL 13:f67a6c6013ca 2749 }
wolfSSL 13:f67a6c6013ca 2750 else {
wolfSSL 13:f67a6c6013ca 2751 if (session->finCaputre.srvCounted == 0)
wolfSSL 13:f67a6c6013ca 2752 session->finCaputre.srvFinSeq = sequence;
wolfSSL 13:f67a6c6013ca 2753 }
wolfSSL 13:f67a6c6013ca 2754 return 1;
wolfSSL 13:f67a6c6013ca 2755 }
wolfSSL 13:f67a6c6013ca 2756
wolfSSL 13:f67a6c6013ca 2757
wolfSSL 13:f67a6c6013ca 2758 /* Adjust incoming sequence based on side */
wolfSSL 13:f67a6c6013ca 2759 /* returns 0 on success (continue), -1 on error, 1 on success (end) */
wolfSSL 13:f67a6c6013ca 2760 static int AdjustSequence(TcpInfo* tcpInfo, SnifferSession* session,
wolfSSL 13:f67a6c6013ca 2761 int* sslBytes, const byte** sslFrame, char* error)
wolfSSL 13:f67a6c6013ca 2762 {
wolfSSL 13:f67a6c6013ca 2763 word32 seqStart = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2764 session->cliSeqStart :session->srvSeqStart;
wolfSSL 13:f67a6c6013ca 2765 word32 real = tcpInfo->sequence - seqStart;
wolfSSL 13:f67a6c6013ca 2766 word32* expected = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2767 &session->cliExpected : &session->srvExpected;
wolfSSL 13:f67a6c6013ca 2768 PacketBuffer* reassemblyList = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2769 session->cliReassemblyList : session->srvReassemblyList;
wolfSSL 13:f67a6c6013ca 2770 byte skipPartial = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2771 session->flags.srvSkipPartial :
wolfSSL 13:f67a6c6013ca 2772 session->flags.cliSkipPartial;
wolfSSL 13:f67a6c6013ca 2773
wolfSSL 13:f67a6c6013ca 2774 /* handle rollover of sequence */
wolfSSL 13:f67a6c6013ca 2775 if (tcpInfo->sequence < seqStart)
wolfSSL 13:f67a6c6013ca 2776 real = 0xffffffffU - seqStart + tcpInfo->sequence;
wolfSSL 13:f67a6c6013ca 2777
wolfSSL 13:f67a6c6013ca 2778 TraceRelativeSequence(*expected, real);
wolfSSL 13:f67a6c6013ca 2779
wolfSSL 13:f67a6c6013ca 2780 if (real < *expected) {
wolfSSL 13:f67a6c6013ca 2781 Trace(DUPLICATE_STR);
wolfSSL 13:f67a6c6013ca 2782 if (real + *sslBytes > *expected) {
wolfSSL 13:f67a6c6013ca 2783 int overlap = *expected - real;
wolfSSL 13:f67a6c6013ca 2784 Trace(OVERLAP_DUPLICATE_STR);
wolfSSL 13:f67a6c6013ca 2785
wolfSSL 13:f67a6c6013ca 2786 /* adjust to expected, remove duplicate */
wolfSSL 13:f67a6c6013ca 2787 *sslFrame += overlap;
wolfSSL 13:f67a6c6013ca 2788 *sslBytes -= overlap;
wolfSSL 13:f67a6c6013ca 2789
wolfSSL 13:f67a6c6013ca 2790 /* The following conditional block is duplicated below. It is the
wolfSSL 13:f67a6c6013ca 2791 * same action but for a different setup case. If changing this
wolfSSL 13:f67a6c6013ca 2792 * block be sure to also update the block below. */
wolfSSL 13:f67a6c6013ca 2793 if (reassemblyList) {
wolfSSL 13:f67a6c6013ca 2794 word32 newEnd = *expected + *sslBytes;
wolfSSL 13:f67a6c6013ca 2795
wolfSSL 13:f67a6c6013ca 2796 if (newEnd > reassemblyList->begin) {
wolfSSL 13:f67a6c6013ca 2797 Trace(OVERLAP_REASSEMBLY_BEGIN_STR);
wolfSSL 13:f67a6c6013ca 2798
wolfSSL 13:f67a6c6013ca 2799 /* remove bytes already on reassembly list */
wolfSSL 13:f67a6c6013ca 2800 *sslBytes -= newEnd - reassemblyList->begin;
wolfSSL 13:f67a6c6013ca 2801 }
wolfSSL 13:f67a6c6013ca 2802 if (newEnd > reassemblyList->end) {
wolfSSL 13:f67a6c6013ca 2803 Trace(OVERLAP_REASSEMBLY_END_STR);
wolfSSL 13:f67a6c6013ca 2804
wolfSSL 13:f67a6c6013ca 2805 /* may be past reassembly list end (could have more on list)
wolfSSL 13:f67a6c6013ca 2806 so try to add what's past the front->end */
wolfSSL 13:f67a6c6013ca 2807 AddToReassembly(session->flags.side, reassemblyList->end +1,
wolfSSL 13:f67a6c6013ca 2808 *sslFrame + reassemblyList->end - *expected + 1,
wolfSSL 13:f67a6c6013ca 2809 newEnd - reassemblyList->end, session, error);
wolfSSL 13:f67a6c6013ca 2810 }
wolfSSL 13:f67a6c6013ca 2811 }
wolfSSL 13:f67a6c6013ca 2812 }
wolfSSL 13:f67a6c6013ca 2813 else
wolfSSL 13:f67a6c6013ca 2814 return 1;
wolfSSL 13:f67a6c6013ca 2815 }
wolfSSL 13:f67a6c6013ca 2816 else if (real > *expected) {
wolfSSL 13:f67a6c6013ca 2817 Trace(OUT_OF_ORDER_STR);
wolfSSL 13:f67a6c6013ca 2818 if (*sslBytes > 0) {
wolfSSL 13:f67a6c6013ca 2819 int addResult = AddToReassembly(session->flags.side, real,
wolfSSL 13:f67a6c6013ca 2820 *sslFrame, *sslBytes, session, error);
wolfSSL 13:f67a6c6013ca 2821 if (skipPartial) {
wolfSSL 13:f67a6c6013ca 2822 *sslBytes = 0;
wolfSSL 13:f67a6c6013ca 2823 return 0;
wolfSSL 13:f67a6c6013ca 2824 }
wolfSSL 13:f67a6c6013ca 2825 else
wolfSSL 13:f67a6c6013ca 2826 return addResult;
wolfSSL 13:f67a6c6013ca 2827 }
wolfSSL 13:f67a6c6013ca 2828 else if (tcpInfo->fin)
wolfSSL 13:f67a6c6013ca 2829 return AddFinCapture(session, real);
wolfSSL 13:f67a6c6013ca 2830 }
wolfSSL 13:f67a6c6013ca 2831 else if (*sslBytes > 0) {
wolfSSL 13:f67a6c6013ca 2832 if (skipPartial) {
wolfSSL 13:f67a6c6013ca 2833 AddToReassembly(session->flags.side, real,
wolfSSL 13:f67a6c6013ca 2834 *sslFrame, *sslBytes, session, error);
wolfSSL 13:f67a6c6013ca 2835 *expected += *sslBytes;
wolfSSL 13:f67a6c6013ca 2836 *sslBytes = 0;
wolfSSL 13:f67a6c6013ca 2837 if (tcpInfo->fin)
wolfSSL 13:f67a6c6013ca 2838 *expected += 1;
wolfSSL 13:f67a6c6013ca 2839 return 0;
wolfSSL 13:f67a6c6013ca 2840 }
wolfSSL 13:f67a6c6013ca 2841 /* The following conditional block is duplicated above. It is the
wolfSSL 13:f67a6c6013ca 2842 * same action but for a different setup case. If changing this
wolfSSL 13:f67a6c6013ca 2843 * block be sure to also update the block above. */
wolfSSL 13:f67a6c6013ca 2844 else if (reassemblyList) {
wolfSSL 13:f67a6c6013ca 2845 word32 newEnd = *expected + *sslBytes;
wolfSSL 13:f67a6c6013ca 2846
wolfSSL 13:f67a6c6013ca 2847 if (newEnd > reassemblyList->begin) {
wolfSSL 13:f67a6c6013ca 2848 Trace(OVERLAP_REASSEMBLY_BEGIN_STR);
wolfSSL 13:f67a6c6013ca 2849
wolfSSL 13:f67a6c6013ca 2850 /* remove bytes already on reassembly list */
wolfSSL 13:f67a6c6013ca 2851 *sslBytes -= newEnd - reassemblyList->begin;
wolfSSL 13:f67a6c6013ca 2852 }
wolfSSL 13:f67a6c6013ca 2853 if (newEnd > reassemblyList->end) {
wolfSSL 13:f67a6c6013ca 2854 Trace(OVERLAP_REASSEMBLY_END_STR);
wolfSSL 13:f67a6c6013ca 2855
wolfSSL 13:f67a6c6013ca 2856 /* may be past reassembly list end (could have more on list)
wolfSSL 13:f67a6c6013ca 2857 so try to add what's past the front->end */
wolfSSL 13:f67a6c6013ca 2858 AddToReassembly(session->flags.side, reassemblyList->end +1,
wolfSSL 13:f67a6c6013ca 2859 *sslFrame + reassemblyList->end - *expected + 1,
wolfSSL 13:f67a6c6013ca 2860 newEnd - reassemblyList->end, session, error);
wolfSSL 13:f67a6c6013ca 2861 }
wolfSSL 13:f67a6c6013ca 2862 }
wolfSSL 13:f67a6c6013ca 2863 }
wolfSSL 13:f67a6c6013ca 2864 /* got expected sequence */
wolfSSL 13:f67a6c6013ca 2865 *expected += *sslBytes;
wolfSSL 13:f67a6c6013ca 2866 if (tcpInfo->fin)
wolfSSL 13:f67a6c6013ca 2867 *expected += 1;
wolfSSL 13:f67a6c6013ca 2868
wolfSSL 13:f67a6c6013ca 2869 return 0;
wolfSSL 13:f67a6c6013ca 2870 }
wolfSSL 13:f67a6c6013ca 2871
wolfSSL 13:f67a6c6013ca 2872
wolfSSL 13:f67a6c6013ca 2873 static int FindNextRecordInAssembly(SnifferSession* session,
wolfSSL 13:f67a6c6013ca 2874 const byte** sslFrame, int* sslBytes,
wolfSSL 13:f67a6c6013ca 2875 const byte** end, char* error)
wolfSSL 13:f67a6c6013ca 2876 {
wolfSSL 13:f67a6c6013ca 2877 PacketBuffer** front = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2878 &session->cliReassemblyList :
wolfSSL 13:f67a6c6013ca 2879 &session->srvReassemblyList;
wolfSSL 13:f67a6c6013ca 2880 PacketBuffer* curr = *front;
wolfSSL 13:f67a6c6013ca 2881 PacketBuffer* prev = NULL;
wolfSSL 13:f67a6c6013ca 2882 byte* skipPartial = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2883 &session->flags.srvSkipPartial :
wolfSSL 13:f67a6c6013ca 2884 &session->flags.cliSkipPartial;
wolfSSL 13:f67a6c6013ca 2885 word32* reassemblyMemory = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2886 &session->cliReassemblyMemory :
wolfSSL 13:f67a6c6013ca 2887 &session->srvReassemblyMemory;
wolfSSL 13:f67a6c6013ca 2888 SSL* ssl = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2889 session->sslServer :
wolfSSL 13:f67a6c6013ca 2890 session->sslClient;
wolfSSL 13:f67a6c6013ca 2891 ProtocolVersion pv = ssl->version;
wolfSSL 13:f67a6c6013ca 2892 word32* expected = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2893 &session->cliExpected :
wolfSSL 13:f67a6c6013ca 2894 &session->srvExpected;
wolfSSL 13:f67a6c6013ca 2895
wolfSSL 13:f67a6c6013ca 2896 while (curr != NULL) {
wolfSSL 13:f67a6c6013ca 2897 *expected = curr->end + 1;
wolfSSL 13:f67a6c6013ca 2898
wolfSSL 13:f67a6c6013ca 2899 if (curr->data[0] == application_data &&
wolfSSL 13:f67a6c6013ca 2900 curr->data[1] == pv.major &&
wolfSSL 13:f67a6c6013ca 2901 curr->data[2] == pv.minor) {
wolfSSL 13:f67a6c6013ca 2902
wolfSSL 13:f67a6c6013ca 2903 if (ssl->buffers.inputBuffer.length > 0)
wolfSSL 13:f67a6c6013ca 2904 Trace(DROPPING_PARTIAL_RECORD);
wolfSSL 13:f67a6c6013ca 2905
wolfSSL 13:f67a6c6013ca 2906 *sslBytes = curr->end - curr->begin + 1;
wolfSSL 13:f67a6c6013ca 2907 if ( (word32)*sslBytes > ssl->buffers.inputBuffer.bufferSize) {
wolfSSL 13:f67a6c6013ca 2908 if (GrowInputBuffer(ssl, *sslBytes, 0) < 0) {
wolfSSL 13:f67a6c6013ca 2909 SetError(MEMORY_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 2910 return -1;
wolfSSL 13:f67a6c6013ca 2911 }
wolfSSL 13:f67a6c6013ca 2912 }
wolfSSL 13:f67a6c6013ca 2913
wolfSSL 13:f67a6c6013ca 2914 XMEMCPY(ssl->buffers.inputBuffer.buffer, curr->data, *sslBytes);
wolfSSL 13:f67a6c6013ca 2915
wolfSSL 13:f67a6c6013ca 2916 *front = curr->next;
wolfSSL 13:f67a6c6013ca 2917 *reassemblyMemory -= *sslBytes;
wolfSSL 13:f67a6c6013ca 2918 FreePacketBuffer(curr);
wolfSSL 13:f67a6c6013ca 2919
wolfSSL 13:f67a6c6013ca 2920 ssl->buffers.inputBuffer.length = *sslBytes;
wolfSSL 13:f67a6c6013ca 2921 *sslFrame = ssl->buffers.inputBuffer.buffer;
wolfSSL 13:f67a6c6013ca 2922 *end = *sslFrame + *sslBytes;
wolfSSL 13:f67a6c6013ca 2923 *skipPartial = 0;
wolfSSL 13:f67a6c6013ca 2924
wolfSSL 13:f67a6c6013ca 2925 return 0;
wolfSSL 13:f67a6c6013ca 2926 }
wolfSSL 13:f67a6c6013ca 2927 else if (ssl->specs.cipher_type == block) {
wolfSSL 13:f67a6c6013ca 2928 if (ssl->specs.bulk_cipher_algorithm == wolfssl_aes) {
wolfSSL 13:f67a6c6013ca 2929 #ifdef BUILD_AES
wolfSSL 13:f67a6c6013ca 2930 wc_AesSetIV(ssl->decrypt.aes,
wolfSSL 13:f67a6c6013ca 2931 curr->data + curr->end - curr->begin
wolfSSL 13:f67a6c6013ca 2932 - ssl->specs.block_size + 1);
wolfSSL 13:f67a6c6013ca 2933 #endif
wolfSSL 13:f67a6c6013ca 2934 }
wolfSSL 13:f67a6c6013ca 2935 else if (ssl->specs.bulk_cipher_algorithm == wolfssl_triple_des) {
wolfSSL 13:f67a6c6013ca 2936 #ifdef BUILD_DES3
wolfSSL 13:f67a6c6013ca 2937 wc_Des3_SetIV(ssl->decrypt.des3,
wolfSSL 13:f67a6c6013ca 2938 curr->data + curr->end - curr->begin
wolfSSL 13:f67a6c6013ca 2939 - ssl->specs.block_size + 1);
wolfSSL 13:f67a6c6013ca 2940 #endif
wolfSSL 13:f67a6c6013ca 2941 }
wolfSSL 13:f67a6c6013ca 2942 }
wolfSSL 13:f67a6c6013ca 2943
wolfSSL 13:f67a6c6013ca 2944 Trace(DROPPING_LOST_FRAG_STR);
wolfSSL 13:f67a6c6013ca 2945 prev = curr;
wolfSSL 13:f67a6c6013ca 2946 curr = curr->next;
wolfSSL 13:f67a6c6013ca 2947 *reassemblyMemory -= (prev->end - prev->begin + 1);
wolfSSL 13:f67a6c6013ca 2948 FreePacketBuffer(prev);
wolfSSL 13:f67a6c6013ca 2949 }
wolfSSL 13:f67a6c6013ca 2950
wolfSSL 13:f67a6c6013ca 2951 *front = curr;
wolfSSL 13:f67a6c6013ca 2952
wolfSSL 13:f67a6c6013ca 2953 return 0;
wolfSSL 13:f67a6c6013ca 2954 }
wolfSSL 13:f67a6c6013ca 2955
wolfSSL 13:f67a6c6013ca 2956
wolfSSL 13:f67a6c6013ca 2957 static int FixSequence(TcpInfo* tcpInfo, SnifferSession* session)
wolfSSL 13:f67a6c6013ca 2958 {
wolfSSL 13:f67a6c6013ca 2959 word32* expected = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2960 &session->srvExpected : &session->cliExpected;
wolfSSL 13:f67a6c6013ca 2961 PacketBuffer* list = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2962 session->srvReassemblyList :
wolfSSL 13:f67a6c6013ca 2963 session->cliReassemblyList;
wolfSSL 13:f67a6c6013ca 2964 byte* skipPartial = (session->flags.side != WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2965 &session->flags.srvSkipPartial :
wolfSSL 13:f67a6c6013ca 2966 &session->flags.cliSkipPartial;
wolfSSL 13:f67a6c6013ca 2967
wolfSSL 13:f67a6c6013ca 2968 *skipPartial = 1;
wolfSSL 13:f67a6c6013ca 2969 if (list != NULL)
wolfSSL 13:f67a6c6013ca 2970 *expected = list->begin;
wolfSSL 13:f67a6c6013ca 2971 else {
wolfSSL 13:f67a6c6013ca 2972 word32 seqStart = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2973 session->srvSeqStart : session->cliSeqStart;
wolfSSL 13:f67a6c6013ca 2974 word32 real = tcpInfo->ackNumber - seqStart;
wolfSSL 13:f67a6c6013ca 2975
wolfSSL 13:f67a6c6013ca 2976 *expected = real;
wolfSSL 13:f67a6c6013ca 2977 }
wolfSSL 13:f67a6c6013ca 2978
wolfSSL 13:f67a6c6013ca 2979 return 1;
wolfSSL 13:f67a6c6013ca 2980 }
wolfSSL 13:f67a6c6013ca 2981
wolfSSL 13:f67a6c6013ca 2982
wolfSSL 13:f67a6c6013ca 2983 /* Check latest ack number for missing packets
wolfSSL 13:f67a6c6013ca 2984 return 0 ok, <0 on error */
wolfSSL 13:f67a6c6013ca 2985 static int CheckAck(TcpInfo* tcpInfo, SnifferSession* session)
wolfSSL 13:f67a6c6013ca 2986 {
wolfSSL 13:f67a6c6013ca 2987 if (tcpInfo->ack) {
wolfSSL 13:f67a6c6013ca 2988 word32 seqStart = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2989 session->srvSeqStart :session->cliSeqStart;
wolfSSL 13:f67a6c6013ca 2990 word32 real = tcpInfo->ackNumber - seqStart;
wolfSSL 13:f67a6c6013ca 2991 word32 expected = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 2992 session->srvExpected : session->cliExpected;
wolfSSL 13:f67a6c6013ca 2993
wolfSSL 13:f67a6c6013ca 2994 /* handle rollover of sequence */
wolfSSL 13:f67a6c6013ca 2995 if (tcpInfo->ackNumber < seqStart)
wolfSSL 13:f67a6c6013ca 2996 real = 0xffffffffU - seqStart + tcpInfo->ackNumber;
wolfSSL 13:f67a6c6013ca 2997
wolfSSL 13:f67a6c6013ca 2998 TraceAck(real, expected);
wolfSSL 13:f67a6c6013ca 2999
wolfSSL 13:f67a6c6013ca 3000 if (real > expected)
wolfSSL 13:f67a6c6013ca 3001 return -1; /* we missed a packet, ACKing data we never saw */
wolfSSL 13:f67a6c6013ca 3002 }
wolfSSL 13:f67a6c6013ca 3003 return 0;
wolfSSL 13:f67a6c6013ca 3004 }
wolfSSL 13:f67a6c6013ca 3005
wolfSSL 13:f67a6c6013ca 3006
wolfSSL 13:f67a6c6013ca 3007 /* Check TCP Sequence status */
wolfSSL 13:f67a6c6013ca 3008 /* returns 0 on success (continue), -1 on error, 1 on success (end) */
wolfSSL 13:f67a6c6013ca 3009 static int CheckSequence(IpInfo* ipInfo, TcpInfo* tcpInfo,
wolfSSL 13:f67a6c6013ca 3010 SnifferSession* session, int* sslBytes,
wolfSSL 13:f67a6c6013ca 3011 const byte** sslFrame, char* error)
wolfSSL 13:f67a6c6013ca 3012 {
wolfSSL 13:f67a6c6013ca 3013 int actualLen;
wolfSSL 13:f67a6c6013ca 3014 byte* ackFault = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 3015 &session->flags.cliAckFault :
wolfSSL 13:f67a6c6013ca 3016 &session->flags.srvAckFault;
wolfSSL 13:f67a6c6013ca 3017
wolfSSL 13:f67a6c6013ca 3018 /* init SEQ from server to client */
wolfSSL 13:f67a6c6013ca 3019 if (tcpInfo->syn && tcpInfo->ack) {
wolfSSL 13:f67a6c6013ca 3020 session->srvSeqStart = tcpInfo->sequence;
wolfSSL 13:f67a6c6013ca 3021 session->srvExpected = 1;
wolfSSL 13:f67a6c6013ca 3022 TraceServerSyn(tcpInfo->sequence);
wolfSSL 13:f67a6c6013ca 3023 return 1;
wolfSSL 13:f67a6c6013ca 3024 }
wolfSSL 13:f67a6c6013ca 3025
wolfSSL 13:f67a6c6013ca 3026 /* adjust potential ethernet trailer */
wolfSSL 13:f67a6c6013ca 3027 actualLen = ipInfo->total - ipInfo->length - tcpInfo->length;
wolfSSL 13:f67a6c6013ca 3028 if (*sslBytes > actualLen) {
wolfSSL 13:f67a6c6013ca 3029 *sslBytes = actualLen;
wolfSSL 13:f67a6c6013ca 3030 }
wolfSSL 13:f67a6c6013ca 3031
wolfSSL 13:f67a6c6013ca 3032 TraceSequence(tcpInfo->sequence, *sslBytes);
wolfSSL 13:f67a6c6013ca 3033 if (CheckAck(tcpInfo, session) < 0) {
wolfSSL 13:f67a6c6013ca 3034 if (!RecoveryEnabled) {
wolfSSL 13:f67a6c6013ca 3035 UpdateMissedDataSessions();
wolfSSL 13:f67a6c6013ca 3036 SetError(ACK_MISSED_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 3037 return -1;
wolfSSL 13:f67a6c6013ca 3038 }
wolfSSL 13:f67a6c6013ca 3039 else {
wolfSSL 13:f67a6c6013ca 3040 SetError(ACK_MISSED_STR, error, session, 0);
wolfSSL 13:f67a6c6013ca 3041 if (*ackFault == 0) {
wolfSSL 13:f67a6c6013ca 3042 *ackFault = 1;
wolfSSL 13:f67a6c6013ca 3043 UpdateMissedDataSessions();
wolfSSL 13:f67a6c6013ca 3044 }
wolfSSL 13:f67a6c6013ca 3045 return FixSequence(tcpInfo, session);
wolfSSL 13:f67a6c6013ca 3046 }
wolfSSL 13:f67a6c6013ca 3047 }
wolfSSL 13:f67a6c6013ca 3048
wolfSSL 13:f67a6c6013ca 3049 if (*ackFault) {
wolfSSL 13:f67a6c6013ca 3050 Trace(CLEAR_ACK_FAULT);
wolfSSL 13:f67a6c6013ca 3051 *ackFault = 0;
wolfSSL 13:f67a6c6013ca 3052 }
wolfSSL 13:f67a6c6013ca 3053
wolfSSL 13:f67a6c6013ca 3054 return AdjustSequence(tcpInfo, session, sslBytes, sslFrame, error);
wolfSSL 13:f67a6c6013ca 3055 }
wolfSSL 13:f67a6c6013ca 3056
wolfSSL 13:f67a6c6013ca 3057
wolfSSL 13:f67a6c6013ca 3058 /* Check Status before record processing */
wolfSSL 13:f67a6c6013ca 3059 /* returns 0 on success (continue), -1 on error, 1 on success (end) */
wolfSSL 13:f67a6c6013ca 3060 static int CheckPreRecord(IpInfo* ipInfo, TcpInfo* tcpInfo,
wolfSSL 13:f67a6c6013ca 3061 const byte** sslFrame, SnifferSession** session,
wolfSSL 13:f67a6c6013ca 3062 int* sslBytes, const byte** end, char* error)
wolfSSL 13:f67a6c6013ca 3063 {
wolfSSL 13:f67a6c6013ca 3064 word32 length;
wolfSSL 13:f67a6c6013ca 3065 SSL* ssl = ((*session)->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 3066 (*session)->sslServer : (*session)->sslClient;
wolfSSL 13:f67a6c6013ca 3067 byte skipPartial = ((*session)->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 3068 (*session)->flags.srvSkipPartial :
wolfSSL 13:f67a6c6013ca 3069 (*session)->flags.cliSkipPartial;
wolfSSL 13:f67a6c6013ca 3070 /* remove SnifferSession on 2nd FIN or RST */
wolfSSL 13:f67a6c6013ca 3071 if (tcpInfo->fin || tcpInfo->rst) {
wolfSSL 13:f67a6c6013ca 3072 /* flag FIN and RST */
wolfSSL 13:f67a6c6013ca 3073 if (tcpInfo->fin)
wolfSSL 13:f67a6c6013ca 3074 (*session)->flags.finCount += 1;
wolfSSL 13:f67a6c6013ca 3075 else if (tcpInfo->rst)
wolfSSL 13:f67a6c6013ca 3076 (*session)->flags.finCount += 2;
wolfSSL 13:f67a6c6013ca 3077
wolfSSL 13:f67a6c6013ca 3078 if ((*session)->flags.finCount >= 2) {
wolfSSL 13:f67a6c6013ca 3079 RemoveSession(*session, ipInfo, tcpInfo, 0);
wolfSSL 13:f67a6c6013ca 3080 *session = NULL;
wolfSSL 13:f67a6c6013ca 3081 return 1;
wolfSSL 13:f67a6c6013ca 3082 }
wolfSSL 13:f67a6c6013ca 3083 }
wolfSSL 13:f67a6c6013ca 3084
wolfSSL 13:f67a6c6013ca 3085 if ((*session)->flags.fatalError == FATAL_ERROR_STATE) {
wolfSSL 13:f67a6c6013ca 3086 SetError(FATAL_ERROR_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 3087 return -1;
wolfSSL 13:f67a6c6013ca 3088 }
wolfSSL 13:f67a6c6013ca 3089
wolfSSL 13:f67a6c6013ca 3090 if (skipPartial) {
wolfSSL 13:f67a6c6013ca 3091 if (FindNextRecordInAssembly(*session,
wolfSSL 13:f67a6c6013ca 3092 sslFrame, sslBytes, end, error) < 0) {
wolfSSL 13:f67a6c6013ca 3093 return -1;
wolfSSL 13:f67a6c6013ca 3094 }
wolfSSL 13:f67a6c6013ca 3095 }
wolfSSL 13:f67a6c6013ca 3096
wolfSSL 13:f67a6c6013ca 3097 if (*sslBytes == 0) {
wolfSSL 13:f67a6c6013ca 3098 Trace(NO_DATA_STR);
wolfSSL 13:f67a6c6013ca 3099 return 1;
wolfSSL 13:f67a6c6013ca 3100 }
wolfSSL 13:f67a6c6013ca 3101
wolfSSL 13:f67a6c6013ca 3102 /* if current partial data, add to end of partial */
wolfSSL 13:f67a6c6013ca 3103 /* if skipping, the data is already at the end of partial */
wolfSSL 13:f67a6c6013ca 3104 if ( !skipPartial &&
wolfSSL 13:f67a6c6013ca 3105 (length = ssl->buffers.inputBuffer.length) ) {
wolfSSL 13:f67a6c6013ca 3106 Trace(PARTIAL_ADD_STR);
wolfSSL 13:f67a6c6013ca 3107
wolfSSL 13:f67a6c6013ca 3108 if ( (*sslBytes + length) > ssl->buffers.inputBuffer.bufferSize) {
wolfSSL 13:f67a6c6013ca 3109 if (GrowInputBuffer(ssl, *sslBytes, length) < 0) {
wolfSSL 13:f67a6c6013ca 3110 SetError(MEMORY_STR, error, *session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 3111 return -1;
wolfSSL 13:f67a6c6013ca 3112 }
wolfSSL 13:f67a6c6013ca 3113 }
wolfSSL 13:f67a6c6013ca 3114 XMEMCPY(&ssl->buffers.inputBuffer.buffer[length], *sslFrame, *sslBytes);
wolfSSL 13:f67a6c6013ca 3115 *sslBytes += length;
wolfSSL 13:f67a6c6013ca 3116 ssl->buffers.inputBuffer.length = *sslBytes;
wolfSSL 13:f67a6c6013ca 3117 *sslFrame = ssl->buffers.inputBuffer.buffer;
wolfSSL 13:f67a6c6013ca 3118 *end = *sslFrame + *sslBytes;
wolfSSL 13:f67a6c6013ca 3119 }
wolfSSL 13:f67a6c6013ca 3120
wolfSSL 13:f67a6c6013ca 3121 if ((*session)->flags.clientHello == 0 && **sslFrame != handshake) {
wolfSSL 13:f67a6c6013ca 3122 /* Sanity check the packet for an old style client hello. */
wolfSSL 13:f67a6c6013ca 3123 int rhSize = (((*sslFrame)[0] & 0x7f) << 8) | ((*sslFrame)[1]);
wolfSSL 13:f67a6c6013ca 3124
wolfSSL 13:f67a6c6013ca 3125 if ((rhSize <= (*sslBytes - 2)) &&
wolfSSL 13:f67a6c6013ca 3126 (*sslFrame)[2] == OLD_HELLO_ID && (*sslFrame)[3] == SSLv3_MAJOR) {
wolfSSL 13:f67a6c6013ca 3127 #ifdef OLD_HELLO_ALLOWED
wolfSSL 13:f67a6c6013ca 3128 int ret = DoOldHello(*session, *sslFrame, &rhSize, sslBytes, error);
wolfSSL 13:f67a6c6013ca 3129 if (ret < 0)
wolfSSL 13:f67a6c6013ca 3130 return -1; /* error already set */
wolfSSL 13:f67a6c6013ca 3131 if (*sslBytes <= 0)
wolfSSL 13:f67a6c6013ca 3132 return 1;
wolfSSL 13:f67a6c6013ca 3133 #endif
wolfSSL 13:f67a6c6013ca 3134 }
wolfSSL 13:f67a6c6013ca 3135 else {
wolfSSL 13:f67a6c6013ca 3136 #ifdef STARTTLS_ALLOWED
wolfSSL 13:f67a6c6013ca 3137 return 1;
wolfSSL 13:f67a6c6013ca 3138 #endif
wolfSSL 13:f67a6c6013ca 3139 }
wolfSSL 13:f67a6c6013ca 3140 }
wolfSSL 13:f67a6c6013ca 3141
wolfSSL 13:f67a6c6013ca 3142 return 0;
wolfSSL 13:f67a6c6013ca 3143 }
wolfSSL 13:f67a6c6013ca 3144
wolfSSL 13:f67a6c6013ca 3145
wolfSSL 13:f67a6c6013ca 3146 /* See if input on the reassembly list is ready for consuming */
wolfSSL 13:f67a6c6013ca 3147 /* returns 1 for TRUE, 0 for FALSE */
wolfSSL 13:f67a6c6013ca 3148 static int HaveMoreInput(SnifferSession* session, const byte** sslFrame,
wolfSSL 13:f67a6c6013ca 3149 int* sslBytes, const byte** end, char* error)
wolfSSL 13:f67a6c6013ca 3150 {
wolfSSL 13:f67a6c6013ca 3151 /* sequence and reassembly based on from, not to */
wolfSSL 13:f67a6c6013ca 3152 int moreInput = 0;
wolfSSL 13:f67a6c6013ca 3153 PacketBuffer** front = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 3154 &session->cliReassemblyList : &session->srvReassemblyList;
wolfSSL 13:f67a6c6013ca 3155 word32* expected = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 3156 &session->cliExpected : &session->srvExpected;
wolfSSL 13:f67a6c6013ca 3157 /* buffer is on receiving end */
wolfSSL 13:f67a6c6013ca 3158 word32* length = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 3159 &session->sslServer->buffers.inputBuffer.length :
wolfSSL 13:f67a6c6013ca 3160 &session->sslClient->buffers.inputBuffer.length;
wolfSSL 13:f67a6c6013ca 3161 byte** myBuffer = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 3162 &session->sslServer->buffers.inputBuffer.buffer :
wolfSSL 13:f67a6c6013ca 3163 &session->sslClient->buffers.inputBuffer.buffer;
wolfSSL 13:f67a6c6013ca 3164 word32* bufferSize = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 3165 &session->sslServer->buffers.inputBuffer.bufferSize :
wolfSSL 13:f67a6c6013ca 3166 &session->sslClient->buffers.inputBuffer.bufferSize;
wolfSSL 13:f67a6c6013ca 3167 SSL* ssl = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 3168 session->sslServer : session->sslClient;
wolfSSL 13:f67a6c6013ca 3169 word32* reassemblyMemory = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 3170 &session->cliReassemblyMemory : &session->srvReassemblyMemory;
wolfSSL 13:f67a6c6013ca 3171
wolfSSL 13:f67a6c6013ca 3172 while (*front && ((*front)->begin == *expected) ) {
wolfSSL 13:f67a6c6013ca 3173 word32 room = *bufferSize - *length;
wolfSSL 13:f67a6c6013ca 3174 word32 packetLen = (*front)->end - (*front)->begin + 1;
wolfSSL 13:f67a6c6013ca 3175
wolfSSL 13:f67a6c6013ca 3176 if (packetLen > room && *bufferSize < MAX_INPUT_SZ) {
wolfSSL 13:f67a6c6013ca 3177 if (GrowInputBuffer(ssl, packetLen, *length) < 0) {
wolfSSL 13:f67a6c6013ca 3178 SetError(MEMORY_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 3179 return 0;
wolfSSL 13:f67a6c6013ca 3180 }
wolfSSL 13:f67a6c6013ca 3181 room = *bufferSize - *length; /* bufferSize is now bigger */
wolfSSL 13:f67a6c6013ca 3182 }
wolfSSL 13:f67a6c6013ca 3183
wolfSSL 13:f67a6c6013ca 3184 if (packetLen <= room) {
wolfSSL 13:f67a6c6013ca 3185 PacketBuffer* del = *front;
wolfSSL 13:f67a6c6013ca 3186 byte* buf = *myBuffer;
wolfSSL 13:f67a6c6013ca 3187
wolfSSL 13:f67a6c6013ca 3188 XMEMCPY(&buf[*length], (*front)->data, packetLen);
wolfSSL 13:f67a6c6013ca 3189 *length += packetLen;
wolfSSL 13:f67a6c6013ca 3190 *expected += packetLen;
wolfSSL 13:f67a6c6013ca 3191
wolfSSL 13:f67a6c6013ca 3192 /* remove used packet */
wolfSSL 13:f67a6c6013ca 3193 *front = (*front)->next;
wolfSSL 13:f67a6c6013ca 3194
wolfSSL 13:f67a6c6013ca 3195 *reassemblyMemory -= packetLen;
wolfSSL 13:f67a6c6013ca 3196 FreePacketBuffer(del);
wolfSSL 13:f67a6c6013ca 3197
wolfSSL 13:f67a6c6013ca 3198 moreInput = 1;
wolfSSL 13:f67a6c6013ca 3199 }
wolfSSL 13:f67a6c6013ca 3200 else
wolfSSL 13:f67a6c6013ca 3201 break;
wolfSSL 13:f67a6c6013ca 3202 }
wolfSSL 13:f67a6c6013ca 3203 if (moreInput) {
wolfSSL 13:f67a6c6013ca 3204 *sslFrame = *myBuffer;
wolfSSL 13:f67a6c6013ca 3205 *sslBytes = *length;
wolfSSL 13:f67a6c6013ca 3206 *end = *myBuffer + *length;
wolfSSL 13:f67a6c6013ca 3207 }
wolfSSL 13:f67a6c6013ca 3208 return moreInput;
wolfSSL 13:f67a6c6013ca 3209 }
wolfSSL 13:f67a6c6013ca 3210
wolfSSL 13:f67a6c6013ca 3211
wolfSSL 13:f67a6c6013ca 3212
wolfSSL 13:f67a6c6013ca 3213 /* Process Message(s) from sslFrame */
wolfSSL 13:f67a6c6013ca 3214 /* return Number of bytes on success, 0 for no data yet, and -1 on error */
wolfSSL 13:f67a6c6013ca 3215 static int ProcessMessage(const byte* sslFrame, SnifferSession* session,
wolfSSL 13:f67a6c6013ca 3216 int sslBytes, byte** data, const byte* end,
wolfSSL 13:f67a6c6013ca 3217 char* error)
wolfSSL 13:f67a6c6013ca 3218 {
wolfSSL 13:f67a6c6013ca 3219 const byte* sslBegin = sslFrame;
wolfSSL 13:f67a6c6013ca 3220 const byte* recordEnd; /* end of record indicator */
wolfSSL 13:f67a6c6013ca 3221 const byte* inRecordEnd; /* indicator from input stream not decrypt */
wolfSSL 13:f67a6c6013ca 3222 RecordLayerHeader rh;
wolfSSL 13:f67a6c6013ca 3223 int rhSize = 0;
wolfSSL 13:f67a6c6013ca 3224 int ret;
wolfSSL 13:f67a6c6013ca 3225 int errCode = 0;
wolfSSL 13:f67a6c6013ca 3226 int decoded = 0; /* bytes stored for user in data */
wolfSSL 13:f67a6c6013ca 3227 int notEnough; /* notEnough bytes yet flag */
wolfSSL 13:f67a6c6013ca 3228 int decrypted = 0; /* was current msg decrypted */
wolfSSL 13:f67a6c6013ca 3229 SSL* ssl = (session->flags.side == WOLFSSL_SERVER_END) ?
wolfSSL 13:f67a6c6013ca 3230 session->sslServer : session->sslClient;
wolfSSL 13:f67a6c6013ca 3231 doMessage:
wolfSSL 13:f67a6c6013ca 3232 notEnough = 0;
wolfSSL 13:f67a6c6013ca 3233 if (sslBytes < 0) {
wolfSSL 13:f67a6c6013ca 3234 SetError(PACKET_HDR_SHORT_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 3235 return -1;
wolfSSL 13:f67a6c6013ca 3236 }
wolfSSL 13:f67a6c6013ca 3237 if (sslBytes >= RECORD_HEADER_SZ) {
wolfSSL 13:f67a6c6013ca 3238 if (GetRecordHeader(sslFrame, &rh, &rhSize) != 0) {
wolfSSL 13:f67a6c6013ca 3239 SetError(BAD_RECORD_HDR_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 3240 return -1;
wolfSSL 13:f67a6c6013ca 3241 }
wolfSSL 13:f67a6c6013ca 3242 }
wolfSSL 13:f67a6c6013ca 3243 else
wolfSSL 13:f67a6c6013ca 3244 notEnough = 1;
wolfSSL 13:f67a6c6013ca 3245
wolfSSL 13:f67a6c6013ca 3246 if (notEnough || rhSize > (sslBytes - RECORD_HEADER_SZ)) {
wolfSSL 13:f67a6c6013ca 3247 /* don't have enough input yet to process full SSL record */
wolfSSL 13:f67a6c6013ca 3248 Trace(PARTIAL_INPUT_STR);
wolfSSL 13:f67a6c6013ca 3249
wolfSSL 13:f67a6c6013ca 3250 /* store partial if not there already or we advanced */
wolfSSL 13:f67a6c6013ca 3251 if (ssl->buffers.inputBuffer.length == 0 || sslBegin != sslFrame) {
wolfSSL 13:f67a6c6013ca 3252 if (sslBytes > (int)ssl->buffers.inputBuffer.bufferSize) {
wolfSSL 13:f67a6c6013ca 3253 if (GrowInputBuffer(ssl, sslBytes, 0) < 0) {
wolfSSL 13:f67a6c6013ca 3254 SetError(MEMORY_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 3255 return -1;
wolfSSL 13:f67a6c6013ca 3256 }
wolfSSL 13:f67a6c6013ca 3257 }
wolfSSL 13:f67a6c6013ca 3258 XMEMMOVE(ssl->buffers.inputBuffer.buffer, sslFrame, sslBytes);
wolfSSL 13:f67a6c6013ca 3259 ssl->buffers.inputBuffer.length = sslBytes;
wolfSSL 13:f67a6c6013ca 3260 }
wolfSSL 13:f67a6c6013ca 3261 if (HaveMoreInput(session, &sslFrame, &sslBytes, &end, error))
wolfSSL 13:f67a6c6013ca 3262 goto doMessage;
wolfSSL 13:f67a6c6013ca 3263 return decoded;
wolfSSL 13:f67a6c6013ca 3264 }
wolfSSL 13:f67a6c6013ca 3265 sslFrame += RECORD_HEADER_SZ;
wolfSSL 13:f67a6c6013ca 3266 sslBytes -= RECORD_HEADER_SZ;
wolfSSL 13:f67a6c6013ca 3267 recordEnd = sslFrame + rhSize; /* may have more than one record */
wolfSSL 13:f67a6c6013ca 3268 inRecordEnd = recordEnd;
wolfSSL 13:f67a6c6013ca 3269
wolfSSL 13:f67a6c6013ca 3270 /* decrypt if needed */
wolfSSL 13:f67a6c6013ca 3271 if ((session->flags.side == WOLFSSL_SERVER_END &&
wolfSSL 13:f67a6c6013ca 3272 session->flags.serverCipherOn)
wolfSSL 13:f67a6c6013ca 3273 || (session->flags.side == WOLFSSL_CLIENT_END &&
wolfSSL 13:f67a6c6013ca 3274 session->flags.clientCipherOn)) {
wolfSSL 13:f67a6c6013ca 3275 int ivAdvance = 0; /* TLSv1.1 advance amount */
wolfSSL 13:f67a6c6013ca 3276 if (ssl->decrypt.setup != 1) {
wolfSSL 13:f67a6c6013ca 3277 SetError(DECRYPT_KEYS_NOT_SETUP, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 3278 return -1;
wolfSSL 13:f67a6c6013ca 3279 }
wolfSSL 13:f67a6c6013ca 3280 if (CheckAvailableSize(ssl, rhSize) < 0) {
wolfSSL 13:f67a6c6013ca 3281 SetError(MEMORY_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 3282 return -1;
wolfSSL 13:f67a6c6013ca 3283 }
wolfSSL 13:f67a6c6013ca 3284 sslFrame = DecryptMessage(ssl, sslFrame, rhSize,
wolfSSL 13:f67a6c6013ca 3285 ssl->buffers.outputBuffer.buffer, &errCode,
wolfSSL 13:f67a6c6013ca 3286 &ivAdvance);
wolfSSL 13:f67a6c6013ca 3287 recordEnd = sslFrame - ivAdvance + rhSize; /* sslFrame moved so
wolfSSL 13:f67a6c6013ca 3288 should recordEnd */
wolfSSL 13:f67a6c6013ca 3289 decrypted = 1;
wolfSSL 13:f67a6c6013ca 3290 if (errCode != 0) {
wolfSSL 13:f67a6c6013ca 3291 SetError(BAD_DECRYPT, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 3292 return -1;
wolfSSL 13:f67a6c6013ca 3293 }
wolfSSL 13:f67a6c6013ca 3294 }
wolfSSL 13:f67a6c6013ca 3295
wolfSSL 13:f67a6c6013ca 3296 doPart:
wolfSSL 13:f67a6c6013ca 3297
wolfSSL 13:f67a6c6013ca 3298 switch ((enum ContentType)rh.type) {
wolfSSL 13:f67a6c6013ca 3299 case handshake:
wolfSSL 13:f67a6c6013ca 3300 {
wolfSSL 13:f67a6c6013ca 3301 int startIdx = sslBytes;
wolfSSL 13:f67a6c6013ca 3302 int used;
wolfSSL 13:f67a6c6013ca 3303
wolfSSL 13:f67a6c6013ca 3304 Trace(GOT_HANDSHAKE_STR);
wolfSSL 13:f67a6c6013ca 3305 ret = DoHandShake(sslFrame, &sslBytes, session, error);
wolfSSL 13:f67a6c6013ca 3306 if (ret != 0) {
wolfSSL 13:f67a6c6013ca 3307 if (session->flags.fatalError == 0)
wolfSSL 13:f67a6c6013ca 3308 SetError(BAD_HANDSHAKE_STR, error, session,
wolfSSL 13:f67a6c6013ca 3309 FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 3310 return -1;
wolfSSL 13:f67a6c6013ca 3311 }
wolfSSL 13:f67a6c6013ca 3312
wolfSSL 13:f67a6c6013ca 3313 /* DoHandShake now fully decrements sslBytes to remaining */
wolfSSL 13:f67a6c6013ca 3314 used = startIdx - sslBytes;
wolfSSL 13:f67a6c6013ca 3315 sslFrame += used;
wolfSSL 13:f67a6c6013ca 3316 if (decrypted)
wolfSSL 13:f67a6c6013ca 3317 sslFrame += ssl->keys.padSz;
wolfSSL 13:f67a6c6013ca 3318 }
wolfSSL 13:f67a6c6013ca 3319 break;
wolfSSL 13:f67a6c6013ca 3320 case change_cipher_spec:
wolfSSL 13:f67a6c6013ca 3321 if (session->flags.side == WOLFSSL_SERVER_END)
wolfSSL 13:f67a6c6013ca 3322 session->flags.serverCipherOn = 1;
wolfSSL 13:f67a6c6013ca 3323 else
wolfSSL 13:f67a6c6013ca 3324 session->flags.clientCipherOn = 1;
wolfSSL 13:f67a6c6013ca 3325 Trace(GOT_CHANGE_CIPHER_STR);
wolfSSL 13:f67a6c6013ca 3326 ssl->options.handShakeState = HANDSHAKE_DONE;
wolfSSL 13:f67a6c6013ca 3327 ssl->options.handShakeDone = 1;
wolfSSL 13:f67a6c6013ca 3328
wolfSSL 13:f67a6c6013ca 3329 sslFrame += 1;
wolfSSL 13:f67a6c6013ca 3330 sslBytes -= 1;
wolfSSL 13:f67a6c6013ca 3331
wolfSSL 13:f67a6c6013ca 3332 break;
wolfSSL 13:f67a6c6013ca 3333 case application_data:
wolfSSL 13:f67a6c6013ca 3334 Trace(GOT_APP_DATA_STR);
wolfSSL 13:f67a6c6013ca 3335 {
wolfSSL 13:f67a6c6013ca 3336 word32 inOutIdx = 0;
wolfSSL 13:f67a6c6013ca 3337
wolfSSL 13:f67a6c6013ca 3338 ret = DoApplicationData(ssl, (byte*)sslFrame, &inOutIdx);
wolfSSL 13:f67a6c6013ca 3339 if (ret == 0) {
wolfSSL 13:f67a6c6013ca 3340 ret = ssl->buffers.clearOutputBuffer.length;
wolfSSL 13:f67a6c6013ca 3341 TraceGotData(ret);
wolfSSL 13:f67a6c6013ca 3342 if (ret) { /* may be blank message */
wolfSSL 13:f67a6c6013ca 3343 byte* tmpData; /* don't leak on realloc free */
wolfSSL 13:f67a6c6013ca 3344 /* add an extra byte at end of allocation in case user
wolfSSL 13:f67a6c6013ca 3345 * wants to null terminate plaintext */
wolfSSL 13:f67a6c6013ca 3346 tmpData = (byte*)realloc(*data, decoded + ret + 1);
wolfSSL 13:f67a6c6013ca 3347 if (tmpData == NULL) {
wolfSSL 13:f67a6c6013ca 3348 ForceZero(*data, decoded);
wolfSSL 13:f67a6c6013ca 3349 free(*data);
wolfSSL 13:f67a6c6013ca 3350 *data = NULL;
wolfSSL 13:f67a6c6013ca 3351 SetError(MEMORY_STR, error, session,
wolfSSL 13:f67a6c6013ca 3352 FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 3353 return -1;
wolfSSL 13:f67a6c6013ca 3354 }
wolfSSL 13:f67a6c6013ca 3355 *data = tmpData;
wolfSSL 13:f67a6c6013ca 3356 XMEMCPY(*data + decoded,
wolfSSL 13:f67a6c6013ca 3357 ssl->buffers.clearOutputBuffer.buffer, ret);
wolfSSL 13:f67a6c6013ca 3358 TraceAddedData(ret, decoded);
wolfSSL 13:f67a6c6013ca 3359 decoded += ret;
wolfSSL 13:f67a6c6013ca 3360 ssl->buffers.clearOutputBuffer.length = 0;
wolfSSL 13:f67a6c6013ca 3361 }
wolfSSL 13:f67a6c6013ca 3362 }
wolfSSL 13:f67a6c6013ca 3363 else {
wolfSSL 13:f67a6c6013ca 3364 SetError(BAD_APP_DATA_STR, error,session,FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 3365 return -1;
wolfSSL 13:f67a6c6013ca 3366 }
wolfSSL 13:f67a6c6013ca 3367 if (ssl->buffers.outputBuffer.dynamicFlag)
wolfSSL 13:f67a6c6013ca 3368 ShrinkOutputBuffer(ssl);
wolfSSL 13:f67a6c6013ca 3369
wolfSSL 13:f67a6c6013ca 3370 sslFrame += inOutIdx;
wolfSSL 13:f67a6c6013ca 3371 sslBytes -= inOutIdx;
wolfSSL 13:f67a6c6013ca 3372 }
wolfSSL 13:f67a6c6013ca 3373 break;
wolfSSL 13:f67a6c6013ca 3374 case alert:
wolfSSL 13:f67a6c6013ca 3375 Trace(GOT_ALERT_STR);
wolfSSL 13:f67a6c6013ca 3376 sslFrame += rhSize;
wolfSSL 13:f67a6c6013ca 3377 sslBytes -= rhSize;
wolfSSL 13:f67a6c6013ca 3378 break;
wolfSSL 13:f67a6c6013ca 3379 case no_type:
wolfSSL 13:f67a6c6013ca 3380 default:
wolfSSL 13:f67a6c6013ca 3381 SetError(GOT_UNKNOWN_RECORD_STR, error, session, FATAL_ERROR_STATE);
wolfSSL 13:f67a6c6013ca 3382 return -1;
wolfSSL 13:f67a6c6013ca 3383 }
wolfSSL 13:f67a6c6013ca 3384
wolfSSL 13:f67a6c6013ca 3385 /* do we have another msg in record ? */
wolfSSL 13:f67a6c6013ca 3386 if (sslFrame < recordEnd) {
wolfSSL 13:f67a6c6013ca 3387 Trace(ANOTHER_MSG_STR);
wolfSSL 13:f67a6c6013ca 3388 goto doPart;
wolfSSL 13:f67a6c6013ca 3389 }
wolfSSL 13:f67a6c6013ca 3390
wolfSSL 13:f67a6c6013ca 3391 /* back to input stream instead of potential decrypt buffer */
wolfSSL 13:f67a6c6013ca 3392 recordEnd = inRecordEnd;
wolfSSL 13:f67a6c6013ca 3393
wolfSSL 13:f67a6c6013ca 3394 /* do we have more records ? */
wolfSSL 13:f67a6c6013ca 3395 if (recordEnd < end) {
wolfSSL 13:f67a6c6013ca 3396 Trace(ANOTHER_MSG_STR);
wolfSSL 13:f67a6c6013ca 3397 sslFrame = recordEnd;
wolfSSL 13:f67a6c6013ca 3398 sslBytes = (int)(end - recordEnd);
wolfSSL 13:f67a6c6013ca 3399 goto doMessage;
wolfSSL 13:f67a6c6013ca 3400 }
wolfSSL 13:f67a6c6013ca 3401
wolfSSL 13:f67a6c6013ca 3402 /* clear used input */
wolfSSL 13:f67a6c6013ca 3403 ssl->buffers.inputBuffer.length = 0;
wolfSSL 13:f67a6c6013ca 3404
wolfSSL 13:f67a6c6013ca 3405 /* could have more input ready now */
wolfSSL 13:f67a6c6013ca 3406 if (HaveMoreInput(session, &sslFrame, &sslBytes, &end, error))
wolfSSL 13:f67a6c6013ca 3407 goto doMessage;
wolfSSL 13:f67a6c6013ca 3408
wolfSSL 13:f67a6c6013ca 3409 if (ssl->buffers.inputBuffer.dynamicFlag)
wolfSSL 13:f67a6c6013ca 3410 ShrinkInputBuffer(ssl, NO_FORCED_FREE);
wolfSSL 13:f67a6c6013ca 3411
wolfSSL 13:f67a6c6013ca 3412 return decoded;
wolfSSL 13:f67a6c6013ca 3413 }
wolfSSL 13:f67a6c6013ca 3414
wolfSSL 13:f67a6c6013ca 3415
wolfSSL 13:f67a6c6013ca 3416 /* See if we need to process any pending FIN captures */
wolfSSL 13:f67a6c6013ca 3417 static void CheckFinCapture(IpInfo* ipInfo, TcpInfo* tcpInfo,
wolfSSL 13:f67a6c6013ca 3418 SnifferSession* session)
wolfSSL 13:f67a6c6013ca 3419 {
wolfSSL 13:f67a6c6013ca 3420 if (session->finCaputre.cliFinSeq && session->finCaputre.cliFinSeq <=
wolfSSL 13:f67a6c6013ca 3421 session->cliExpected) {
wolfSSL 13:f67a6c6013ca 3422 if (session->finCaputre.cliCounted == 0) {
wolfSSL 13:f67a6c6013ca 3423 session->flags.finCount += 1;
wolfSSL 13:f67a6c6013ca 3424 session->finCaputre.cliCounted = 1;
wolfSSL 13:f67a6c6013ca 3425 TraceClientFin(session->finCaputre.cliFinSeq, session->cliExpected);
wolfSSL 13:f67a6c6013ca 3426 }
wolfSSL 13:f67a6c6013ca 3427 }
wolfSSL 13:f67a6c6013ca 3428
wolfSSL 13:f67a6c6013ca 3429 if (session->finCaputre.srvFinSeq && session->finCaputre.srvFinSeq <=
wolfSSL 13:f67a6c6013ca 3430 session->srvExpected) {
wolfSSL 13:f67a6c6013ca 3431 if (session->finCaputre.srvCounted == 0) {
wolfSSL 13:f67a6c6013ca 3432 session->flags.finCount += 1;
wolfSSL 13:f67a6c6013ca 3433 session->finCaputre.srvCounted = 1;
wolfSSL 13:f67a6c6013ca 3434 TraceServerFin(session->finCaputre.srvFinSeq, session->srvExpected);
wolfSSL 13:f67a6c6013ca 3435 }
wolfSSL 13:f67a6c6013ca 3436 }
wolfSSL 13:f67a6c6013ca 3437
wolfSSL 13:f67a6c6013ca 3438 if (session->flags.finCount >= 2)
wolfSSL 13:f67a6c6013ca 3439 RemoveSession(session, ipInfo, tcpInfo, 0);
wolfSSL 13:f67a6c6013ca 3440 }
wolfSSL 13:f67a6c6013ca 3441
wolfSSL 13:f67a6c6013ca 3442
wolfSSL 13:f67a6c6013ca 3443 /* If session is in fatal error state free resources now
wolfSSL 13:f67a6c6013ca 3444 return true if removed, 0 otherwise */
wolfSSL 13:f67a6c6013ca 3445 static int RemoveFatalSession(IpInfo* ipInfo, TcpInfo* tcpInfo,
wolfSSL 13:f67a6c6013ca 3446 SnifferSession* session, char* error)
wolfSSL 13:f67a6c6013ca 3447 {
wolfSSL 13:f67a6c6013ca 3448 if (session && session->flags.fatalError == FATAL_ERROR_STATE) {
wolfSSL 13:f67a6c6013ca 3449 RemoveSession(session, ipInfo, tcpInfo, 0);
wolfSSL 13:f67a6c6013ca 3450 SetError(FATAL_ERROR_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 3451 return 1;
wolfSSL 13:f67a6c6013ca 3452 }
wolfSSL 13:f67a6c6013ca 3453 return 0;
wolfSSL 13:f67a6c6013ca 3454 }
wolfSSL 13:f67a6c6013ca 3455
wolfSSL 13:f67a6c6013ca 3456
wolfSSL 13:f67a6c6013ca 3457 /* Passes in an IP/TCP packet for decoding (ethernet/localhost frame) removed */
wolfSSL 13:f67a6c6013ca 3458 /* returns Number of bytes on success, 0 for no data yet, and -1 on error */
wolfSSL 13:f67a6c6013ca 3459 int ssl_DecodePacket(const byte* packet, int length, byte** data, char* error)
wolfSSL 13:f67a6c6013ca 3460 {
wolfSSL 13:f67a6c6013ca 3461 TcpInfo tcpInfo;
wolfSSL 13:f67a6c6013ca 3462 IpInfo ipInfo;
wolfSSL 13:f67a6c6013ca 3463 const byte* sslFrame;
wolfSSL 13:f67a6c6013ca 3464 const byte* end = packet + length;
wolfSSL 13:f67a6c6013ca 3465 int sslBytes; /* ssl bytes unconsumed */
wolfSSL 13:f67a6c6013ca 3466 int ret;
wolfSSL 13:f67a6c6013ca 3467 SnifferSession* session = 0;
wolfSSL 13:f67a6c6013ca 3468
wolfSSL 13:f67a6c6013ca 3469 if (CheckHeaders(&ipInfo, &tcpInfo, packet, length, &sslFrame, &sslBytes,
wolfSSL 13:f67a6c6013ca 3470 error) != 0)
wolfSSL 13:f67a6c6013ca 3471 return -1;
wolfSSL 13:f67a6c6013ca 3472
wolfSSL 13:f67a6c6013ca 3473 ret = CheckSession(&ipInfo, &tcpInfo, sslBytes, &session, error);
wolfSSL 13:f67a6c6013ca 3474 if (RemoveFatalSession(&ipInfo, &tcpInfo, session, error)) return -1;
wolfSSL 13:f67a6c6013ca 3475 else if (ret == -1) return -1;
wolfSSL 13:f67a6c6013ca 3476 else if (ret == 1) return 0; /* done for now */
wolfSSL 13:f67a6c6013ca 3477
wolfSSL 13:f67a6c6013ca 3478 ret = CheckSequence(&ipInfo, &tcpInfo, session, &sslBytes, &sslFrame,error);
wolfSSL 13:f67a6c6013ca 3479 if (RemoveFatalSession(&ipInfo, &tcpInfo, session, error)) return -1;
wolfSSL 13:f67a6c6013ca 3480 else if (ret == -1) return -1;
wolfSSL 13:f67a6c6013ca 3481 else if (ret == 1) return 0; /* done for now */
wolfSSL 13:f67a6c6013ca 3482
wolfSSL 13:f67a6c6013ca 3483 ret = CheckPreRecord(&ipInfo, &tcpInfo, &sslFrame, &session, &sslBytes,
wolfSSL 13:f67a6c6013ca 3484 &end, error);
wolfSSL 13:f67a6c6013ca 3485 if (RemoveFatalSession(&ipInfo, &tcpInfo, session, error)) return -1;
wolfSSL 13:f67a6c6013ca 3486 else if (ret == -1) return -1;
wolfSSL 13:f67a6c6013ca 3487 else if (ret == 1) return 0; /* done for now */
wolfSSL 13:f67a6c6013ca 3488
wolfSSL 13:f67a6c6013ca 3489 ret = ProcessMessage(sslFrame, session, sslBytes, data, end, error);
wolfSSL 13:f67a6c6013ca 3490 if (RemoveFatalSession(&ipInfo, &tcpInfo, session, error)) return -1;
wolfSSL 13:f67a6c6013ca 3491 CheckFinCapture(&ipInfo, &tcpInfo, session);
wolfSSL 13:f67a6c6013ca 3492 return ret;
wolfSSL 13:f67a6c6013ca 3493 }
wolfSSL 13:f67a6c6013ca 3494
wolfSSL 13:f67a6c6013ca 3495
wolfSSL 13:f67a6c6013ca 3496 /* Deallocator for the decoded data buffer. */
wolfSSL 13:f67a6c6013ca 3497 /* returns 0 on success, -1 on error */
wolfSSL 13:f67a6c6013ca 3498 int ssl_FreeDecodeBuffer(byte** data, char* error)
wolfSSL 13:f67a6c6013ca 3499 {
wolfSSL 13:f67a6c6013ca 3500 return ssl_FreeZeroDecodeBuffer(data, 0, error);
wolfSSL 13:f67a6c6013ca 3501 }
wolfSSL 13:f67a6c6013ca 3502
wolfSSL 13:f67a6c6013ca 3503
wolfSSL 13:f67a6c6013ca 3504 /* Deallocator for the decoded data buffer, zeros out buffer. */
wolfSSL 13:f67a6c6013ca 3505 /* returns 0 on success, -1 on error */
wolfSSL 13:f67a6c6013ca 3506 int ssl_FreeZeroDecodeBuffer(byte** data, int sz, char* error)
wolfSSL 13:f67a6c6013ca 3507 {
wolfSSL 13:f67a6c6013ca 3508 (void)error;
wolfSSL 13:f67a6c6013ca 3509
wolfSSL 13:f67a6c6013ca 3510 if (sz < 0) {
wolfSSL 13:f67a6c6013ca 3511 return -1;
wolfSSL 13:f67a6c6013ca 3512 }
wolfSSL 13:f67a6c6013ca 3513
wolfSSL 13:f67a6c6013ca 3514 if (data != NULL) {
wolfSSL 13:f67a6c6013ca 3515 ForceZero(*data, (word32)sz);
wolfSSL 13:f67a6c6013ca 3516 free(*data);
wolfSSL 13:f67a6c6013ca 3517 *data = NULL;
wolfSSL 13:f67a6c6013ca 3518 }
wolfSSL 13:f67a6c6013ca 3519
wolfSSL 13:f67a6c6013ca 3520 return 0;
wolfSSL 13:f67a6c6013ca 3521 }
wolfSSL 13:f67a6c6013ca 3522
wolfSSL 13:f67a6c6013ca 3523
wolfSSL 13:f67a6c6013ca 3524 /* Enables (if traceFile)/ Disables debug tracing */
wolfSSL 13:f67a6c6013ca 3525 /* returns 0 on success, -1 on error */
wolfSSL 13:f67a6c6013ca 3526 int ssl_Trace(const char* traceFile, char* error)
wolfSSL 13:f67a6c6013ca 3527 {
wolfSSL 13:f67a6c6013ca 3528 if (traceFile) {
wolfSSL 13:f67a6c6013ca 3529 TraceFile = fopen(traceFile, "a");
wolfSSL 13:f67a6c6013ca 3530 if (!TraceFile) {
wolfSSL 13:f67a6c6013ca 3531 SetError(BAD_TRACE_FILE_STR, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 3532 return -1;
wolfSSL 13:f67a6c6013ca 3533 }
wolfSSL 13:f67a6c6013ca 3534 TraceOn = 1;
wolfSSL 13:f67a6c6013ca 3535 }
wolfSSL 13:f67a6c6013ca 3536 else
wolfSSL 13:f67a6c6013ca 3537 TraceOn = 0;
wolfSSL 13:f67a6c6013ca 3538
wolfSSL 13:f67a6c6013ca 3539 return 0;
wolfSSL 13:f67a6c6013ca 3540 }
wolfSSL 13:f67a6c6013ca 3541
wolfSSL 13:f67a6c6013ca 3542
wolfSSL 13:f67a6c6013ca 3543 /* Enables/Disables Recovery of missed data if later packets allow
wolfSSL 13:f67a6c6013ca 3544 * maxMemory is number of bytes to use for reassembly buffering per session,
wolfSSL 13:f67a6c6013ca 3545 * -1 means unlimited
wolfSSL 13:f67a6c6013ca 3546 * returns 0 on success, -1 on error */
wolfSSL 13:f67a6c6013ca 3547 int ssl_EnableRecovery(int onOff, int maxMemory, char* error)
wolfSSL 13:f67a6c6013ca 3548 {
wolfSSL 13:f67a6c6013ca 3549 (void)error;
wolfSSL 13:f67a6c6013ca 3550
wolfSSL 13:f67a6c6013ca 3551 RecoveryEnabled = onOff;
wolfSSL 13:f67a6c6013ca 3552 if (onOff)
wolfSSL 13:f67a6c6013ca 3553 MaxRecoveryMemory = maxMemory;
wolfSSL 13:f67a6c6013ca 3554
wolfSSL 13:f67a6c6013ca 3555 return 0;
wolfSSL 13:f67a6c6013ca 3556 }
wolfSSL 13:f67a6c6013ca 3557
wolfSSL 13:f67a6c6013ca 3558
wolfSSL 13:f67a6c6013ca 3559
wolfSSL 13:f67a6c6013ca 3560 int ssl_GetSessionStats(unsigned int* active, unsigned int* total,
wolfSSL 13:f67a6c6013ca 3561 unsigned int* peak, unsigned int* maxSessions,
wolfSSL 13:f67a6c6013ca 3562 unsigned int* missedData, unsigned int* reassemblyMem,
wolfSSL 13:f67a6c6013ca 3563 char* error)
wolfSSL 13:f67a6c6013ca 3564 {
wolfSSL 13:f67a6c6013ca 3565 int ret;
wolfSSL 13:f67a6c6013ca 3566
wolfSSL 13:f67a6c6013ca 3567 if (missedData) {
wolfSSL 13:f67a6c6013ca 3568 wc_LockMutex(&RecoveryMutex);
wolfSSL 13:f67a6c6013ca 3569 *missedData = MissedDataSessions;
wolfSSL 13:f67a6c6013ca 3570 wc_UnLockMutex(&RecoveryMutex);
wolfSSL 13:f67a6c6013ca 3571 }
wolfSSL 13:f67a6c6013ca 3572
wolfSSL 13:f67a6c6013ca 3573 if (reassemblyMem) {
wolfSSL 13:f67a6c6013ca 3574 SnifferSession* session;
wolfSSL 13:f67a6c6013ca 3575 int i;
wolfSSL 13:f67a6c6013ca 3576
wolfSSL 13:f67a6c6013ca 3577 *reassemblyMem = 0;
wolfSSL 13:f67a6c6013ca 3578 wc_LockMutex(&SessionMutex);
wolfSSL 13:f67a6c6013ca 3579 for (i = 0; i < HASH_SIZE; i++) {
wolfSSL 13:f67a6c6013ca 3580 session = SessionTable[i];
wolfSSL 13:f67a6c6013ca 3581 while (session) {
wolfSSL 13:f67a6c6013ca 3582 *reassemblyMem += session->cliReassemblyMemory;
wolfSSL 13:f67a6c6013ca 3583 *reassemblyMem += session->srvReassemblyMemory;
wolfSSL 13:f67a6c6013ca 3584 session = session->next;
wolfSSL 13:f67a6c6013ca 3585 }
wolfSSL 13:f67a6c6013ca 3586 }
wolfSSL 13:f67a6c6013ca 3587 wc_UnLockMutex(&SessionMutex);
wolfSSL 13:f67a6c6013ca 3588 }
wolfSSL 13:f67a6c6013ca 3589
wolfSSL 13:f67a6c6013ca 3590 ret = wolfSSL_get_session_stats(active, total, peak, maxSessions);
wolfSSL 13:f67a6c6013ca 3591
wolfSSL 13:f67a6c6013ca 3592 if (ret == SSL_SUCCESS)
wolfSSL 13:f67a6c6013ca 3593 return 0;
wolfSSL 13:f67a6c6013ca 3594 else {
wolfSSL 13:f67a6c6013ca 3595 SetError(BAD_SESSION_STATS, error, NULL, 0);
wolfSSL 13:f67a6c6013ca 3596 return -1;
wolfSSL 13:f67a6c6013ca 3597 }
wolfSSL 13:f67a6c6013ca 3598 }
wolfSSL 13:f67a6c6013ca 3599
wolfSSL 13:f67a6c6013ca 3600
wolfSSL 13:f67a6c6013ca 3601
wolfSSL 13:f67a6c6013ca 3602 #endif /* WOLFSSL_SNIFFER */
wolfSSL 13:f67a6c6013ca 3603 #endif /* WOLFCRYPT_ONLY */
wolfSSL 13:f67a6c6013ca 3604