suricata
app-layer-ssl.c
Go to the documentation of this file.
1 /* Copyright (C) 2007-2024 Open Information Security Foundation
2  *
3  * You can copy, redistribute or modify this Program under the terms of
4  * the GNU General Public License version 2 as published by the Free
5  * Software Foundation.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * version 2 along with this program; if not, write to the Free Software
14  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
15  * 02110-1301, USA.
16  */
17 
18 /**
19  * \file
20  *
21  * \author Anoop Saldanha <anoopsaldanha@gmail.com>
22  * \author Pierre Chifflier <pierre.chifflier@ssi.gouv.fr>
23  * \author Mats Klepsland <mats.klepsland@gmail.com>
24  *
25  */
26 
27 #include "suricata-common.h"
28 #include "decode.h"
29 
30 #include "app-layer.h"
31 #include "app-layer-detect-proto.h"
32 #include "app-layer-protos.h"
33 #include "app-layer-parser.h"
34 #include "app-layer-frames.h"
35 #include "app-layer-events.h"
36 #include "app-layer-ssl.h"
37 
38 #include "conf.h"
39 
40 #include "feature.h"
41 
42 #include "util-debug.h"
43 #include "util-ja3.h"
44 #include "util-enum.h"
45 #include "util-validate.h"
46 
47 static SCEnumCharMap tls_state_client_table[] = {
48  {
49  "client_in_progress",
50  TLS_STATE_CLIENT_IN_PROGRESS,
51  },
52  {
53  "client_hello_done",
54  TLS_STATE_CLIENT_HELLO_DONE,
55  },
56  {
57  "client_cert_done",
58  TLS_STATE_CLIENT_CERT_DONE,
59  },
60  {
61  "client_handshake_done",
62  TLS_STATE_CLIENT_HANDSHAKE_DONE,
63  },
64  {
65  "client_finished",
66  TLS_STATE_CLIENT_FINISHED,
67  },
68  { NULL, -1 },
69 };
70 
71 static SCEnumCharMap tls_state_server_table[] = {
72  {
73  "server_in_progress",
74  TLS_STATE_SERVER_IN_PROGRESS,
75  },
76  {
77  "server_hello",
78  TLS_STATE_SERVER_HELLO,
79  },
80  {
81  "server_cert_done",
82  TLS_STATE_SERVER_CERT_DONE,
83  },
84  {
85  "server_hello_done",
86  TLS_STATE_SERVER_HELLO_DONE,
87  },
88  {
89  "server_handshake_done",
90  TLS_STATE_SERVER_HANDSHAKE_DONE,
91  },
92  {
93  "server_finished",
94  TLS_STATE_SERVER_FINISHED,
95  },
96  { NULL, -1 },
97 };
98 
99 SCEnumCharMap tls_frame_table[] = {
100  {
101  "pdu",
102  TLS_FRAME_PDU,
103  },
104  {
105  "hdr",
106  TLS_FRAME_HDR,
107  },
108  {
109  "data",
110  TLS_FRAME_DATA,
111  },
112  {
113  "alert",
114  TLS_FRAME_ALERT_DATA,
115  },
116  {
117  "heartbeat",
118  TLS_FRAME_HB_DATA,
119  },
120  {
121  "ssl2.hdr",
122  TLS_FRAME_SSLV2_HDR,
123  },
124  {
125  "ssl2.pdu",
126  TLS_FRAME_SSLV2_PDU,
127  },
128  { NULL, -1 },
129 };
130 
131 SCEnumCharMap tls_decoder_event_table[] = {
132  /* TLS protocol messages */
133  { "INVALID_SSLV2_HEADER", TLS_DECODER_EVENT_INVALID_SSLV2_HEADER },
134  { "INVALID_TLS_HEADER", TLS_DECODER_EVENT_INVALID_TLS_HEADER },
135  { "INVALID_RECORD_VERSION", TLS_DECODER_EVENT_INVALID_RECORD_VERSION },
136  { "INVALID_RECORD_TYPE", TLS_DECODER_EVENT_INVALID_RECORD_TYPE },
137  { "INVALID_RECORD_LENGTH", TLS_DECODER_EVENT_INVALID_RECORD_LENGTH },
138  { "INVALID_HANDSHAKE_MESSAGE", TLS_DECODER_EVENT_INVALID_HANDSHAKE_MESSAGE },
139  { "HEARTBEAT_MESSAGE", TLS_DECODER_EVENT_HEARTBEAT },
140  { "INVALID_HEARTBEAT_MESSAGE", TLS_DECODER_EVENT_INVALID_HEARTBEAT },
141  { "OVERFLOW_HEARTBEAT_MESSAGE", TLS_DECODER_EVENT_OVERFLOW_HEARTBEAT },
142  { "DATALEAK_HEARTBEAT_MISMATCH", TLS_DECODER_EVENT_DATALEAK_HEARTBEAT_MISMATCH },
143  { "HANDSHAKE_INVALID_LENGTH", TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH },
144  { "MULTIPLE_SNI_EXTENSIONS", TLS_DECODER_EVENT_MULTIPLE_SNI_EXTENSIONS },
145  { "INVALID_SNI_TYPE", TLS_DECODER_EVENT_INVALID_SNI_TYPE },
146  { "INVALID_SNI_LENGTH", TLS_DECODER_EVENT_INVALID_SNI_LENGTH },
147  { "TOO_MANY_RECORDS_IN_PACKET", TLS_DECODER_EVENT_TOO_MANY_RECORDS_IN_PACKET },
148  { "INVALID_ALERT_MESSAGE", TLS_DECODER_EVENT_INVALID_ALERT },
149  /* certificate decoding messages */
150  { "INVALID_CERTIFICATE", TLS_DECODER_EVENT_INVALID_CERTIFICATE },
151  { "CERTIFICATE_INVALID_LENGTH", TLS_DECODER_EVENT_CERTIFICATE_INVALID_LENGTH },
152  { "CERTIFICATE_INVALID_VERSION", TLS_DECODER_EVENT_CERTIFICATE_INVALID_VERSION },
153  { "CERTIFICATE_INVALID_SERIAL", TLS_DECODER_EVENT_CERTIFICATE_INVALID_SERIAL },
154  { "CERTIFICATE_INVALID_ALGORITHMIDENTIFIER",
155  TLS_DECODER_EVENT_CERTIFICATE_INVALID_ALGORITHMIDENTIFIER },
156  { "CERTIFICATE_INVALID_X509NAME", TLS_DECODER_EVENT_CERTIFICATE_INVALID_X509NAME },
157  { "CERTIFICATE_INVALID_DATE", TLS_DECODER_EVENT_CERTIFICATE_INVALID_DATE },
158  { "CERTIFICATE_INVALID_EXTENSIONS", TLS_DECODER_EVENT_CERTIFICATE_INVALID_EXTENSIONS },
159  { "CERTIFICATE_INVALID_DER", TLS_DECODER_EVENT_CERTIFICATE_INVALID_DER },
160  { "CERTIFICATE_INVALID_SUBJECT", TLS_DECODER_EVENT_CERTIFICATE_INVALID_SUBJECT },
161  { "CERTIFICATE_INVALID_ISSUER", TLS_DECODER_EVENT_CERTIFICATE_INVALID_ISSUER },
162  { "CERTIFICATE_INVALID_VALIDITY", TLS_DECODER_EVENT_CERTIFICATE_INVALID_VALIDITY },
163  { "ERROR_MESSAGE_ENCOUNTERED", TLS_DECODER_EVENT_ERROR_MSG_ENCOUNTERED },
164  /* used as a generic error event */
165  { "INVALID_SSL_RECORD", TLS_DECODER_EVENT_INVALID_SSL_RECORD },
166  { NULL, -1 },
167 };
168 
169 enum {
170  /* X.509 error codes, returned by decoder
171  * THESE CONSTANTS MUST MATCH rust/src/x509/mod.rs ! */
172  ERR_INVALID_CERTIFICATE=1,
173  ERR_INVALID_LENGTH,
174  ERR_INVALID_VERSION,
175  ERR_INVALID_SERIAL,
176  ERR_INVALID_ALGORITHMIDENTIFIER,
177  ERR_INVALID_X509NAME,
178  ERR_INVALID_DATE,
179  ERR_INVALID_EXTENSIONS,
180  ERR_INVALID_DER,
181 
182  /* error getting data */
183  ERR_EXTRACT_SUBJECT,
184  ERR_EXTRACT_ISSUER,
185  ERR_EXTRACT_VALIDITY,
186 };
187 
188 /* JA3 and JA4 fingerprints are disabled by default */
189 #define SSL_CONFIG_DEFAULT_JA3 0
190 #ifdef HAVE_JA4
191 #define SSL_CONFIG_DEFAULT_JA4 0
192 #endif
193 
194 enum SslConfigEncryptHandling {
195  SSL_CNF_ENC_HANDLE_TRACK_ONLY = 0, /**< disable raw content, continue tracking */
196  SSL_CNF_ENC_HANDLE_BYPASS = 1, /**< skip processing of flow, bypass if possible */
197  SSL_CNF_ENC_HANDLE_FULL = 2, /**< handle fully like any other proto */
198 };
199 
200 typedef struct SslConfig_ {
201  enum SslConfigEncryptHandling encrypt_mode;
202  /** dynamic setting for ja3 and ja4: can be enabled on demand if not
203  * explicitly disabled. */
204  SC_ATOMIC_DECLARE(int, enable_ja3);
205  bool disable_ja3; /**< ja3 explicitly disabled. Don't enable on demand. */
206  SC_ATOMIC_DECLARE(int, enable_ja4);
207  bool disable_ja4; /**< ja4 explicitly disabled. Don't enable on demand. */
208 } SslConfig;
209 
210 SslConfig ssl_config;
211 
212 /* SSLv3 record types */
213 #define SSLV3_CHANGE_CIPHER_SPEC 20
214 #define SSLV3_ALERT_PROTOCOL 21
215 #define SSLV3_HANDSHAKE_PROTOCOL 22
216 #define SSLV3_APPLICATION_PROTOCOL 23
217 #define SSLV3_HEARTBEAT_PROTOCOL 24
218 
219 /* SSLv3 handshake protocol types */
220 #define SSLV3_HS_HELLO_REQUEST 0
221 #define SSLV3_HS_CLIENT_HELLO 1
222 #define SSLV3_HS_SERVER_HELLO 2
223 #define SSLV3_HS_NEW_SESSION_TICKET 4
224 #define SSLV3_HS_CERTIFICATE 11
225 #define SSLV3_HS_SERVER_KEY_EXCHANGE 12
226 #define SSLV3_HS_CERTIFICATE_REQUEST 13
227 #define SSLV3_HS_SERVER_HELLO_DONE 14
228 #define SSLV3_HS_CERTIFICATE_VERIFY 15
229 #define SSLV3_HS_CLIENT_KEY_EXCHANGE 16
230 #define SSLV3_HS_FINISHED 20
231 #define SSLV3_HS_CERTIFICATE_URL 21
232 #define SSLV3_HS_CERTIFICATE_STATUS 22
233 
234 /* SSLv2 protocol message types */
235 #define SSLV2_MT_ERROR 0
236 #define SSLV2_MT_CLIENT_HELLO 1
237 #define SSLV2_MT_CLIENT_MASTER_KEY 2
238 #define SSLV2_MT_CLIENT_FINISHED 3
239 #define SSLV2_MT_SERVER_HELLO 4
240 #define SSLV2_MT_SERVER_VERIFY 5
241 #define SSLV2_MT_SERVER_FINISHED 6
242 #define SSLV2_MT_REQUEST_CERTIFICATE 7
243 #define SSLV2_MT_CLIENT_CERTIFICATE 8
244 
245 #define SSLV3_RECORD_HDR_LEN 5
246 /** max length according to RFC 5246 6.2.2 is 2^14 + 1024 */
247 #define SSLV3_RECORD_MAX_LEN ((1 << 14) + 1024)
248 
249 #define SSLV3_CLIENT_HELLO_VERSION_LEN 2
250 #define SSLV3_CLIENT_HELLO_RANDOM_LEN 32
251 
252 /* TLS heartbeat protocol types */
253 #define TLS_HB_REQUEST 1
254 #define TLS_HB_RESPONSE 2
255 
256 #define SSL_RECORD_MINIMUM_LENGTH 6
257 
258 #define SHA1_STRING_LENGTH 60
259 
260 #define HAS_SPACE(n) ((uint64_t)(input - initial_input) + (uint64_t)(n) <= (uint64_t)(input_len))
261 
262 struct SSLDecoderResult {
263  int retval; // nr bytes consumed from input, or < 0 on error
264  uint32_t needed; // more bytes needed
265 };
266 #define SSL_DECODER_ERROR(e) \
267  (struct SSLDecoderResult) \
268  { \
269  (e), 0 \
270  }
271 #define SSL_DECODER_OK(c) \
272  (struct SSLDecoderResult) \
273  { \
274  (uint32_t)(c), 0 \
275  }
276 #define SSL_DECODER_INCOMPLETE(c, n) \
277  (struct SSLDecoderResult) \
278  { \
279  (uint32_t)(c), (n) \
280  }
281 
282 static inline int SafeMemcpy(void *dst, size_t dst_offset, size_t dst_size,
283  const void *src, size_t src_offset, size_t src_size, size_t src_tocopy) WARN_UNUSED;
284 
285 static inline int SafeMemcpy(void *dst, size_t dst_offset, size_t dst_size,
286  const void *src, size_t src_offset, size_t src_size, size_t src_tocopy)
287 {
288  DEBUG_VALIDATE_BUG_ON(dst_offset >= dst_size);
289  DEBUG_VALIDATE_BUG_ON(src_offset >= src_size);
290  DEBUG_VALIDATE_BUG_ON(src_tocopy > (src_size - src_offset));
291  DEBUG_VALIDATE_BUG_ON(src_tocopy > (dst_size - dst_offset));
292 
293  if (dst_offset < dst_size && src_offset < src_size &&
294  src_tocopy <= (src_size - src_offset) &&
295  src_tocopy <= (dst_size - dst_offset)) {
296  memcpy(dst + dst_offset, src + src_offset, src_tocopy);
297  return 0;
298  }
299  return -1;
300 }
301 
302 #ifdef DEBUG_VALIDATION
303 #define ValidateRecordState(connp) \
304  do { \
305  DEBUG_VALIDATE_BUG_ON(((connp)->record_length + SSLV3_RECORD_HDR_LEN) < \
306  (connp)->bytes_processed); \
307  } while(0);
308 #else
309 #define ValidateRecordState(...)
310 #endif
311 
312 #define SSLParserHSReset(connp) \
313  do { \
314  (connp)->handshake_type = 0; \
315  (connp)->message_length = 0; \
316  } while (0)
317 
318 #define SSLParserReset(state) \
319  do { \
320  SCLogDebug("resetting state"); \
321  (state)->curr_connp->bytes_processed = 0; \
322  SSLParserHSReset((state)->curr_connp); \
323  } while(0)
324 
325 #define SSLSetEvent(ssl_state, event) \
326  do { \
327  SCLogDebug("setting event %u", (event)); \
328  if ((ssl_state) == NULL) { \
329  SCLogDebug("could not set decoder event %u", event); \
330  } else { \
331  SCAppLayerDecoderEventsSetEventRaw(&(ssl_state)->tx_data.events, (event)); \
332  (ssl_state)->events++; \
333  } \
334  } while (0)
335 
336 static void *SSLGetTx(void *state, uint64_t tx_id)
337 {
338  SSLState *ssl_state = (SSLState *)state;
339  return ssl_state;
340 }
341 
342 static uint64_t SSLGetTxCnt(void *state)
343 {
344  /* single tx */
345  return 1;
346 }
347 
348 static void UpdateClientState(SSLState *ssl_state, enum TlsStateClient s)
349 {
350 #ifdef DEBUG
351  enum TlsStateClient old = ssl_state->client_state;
352 #endif
353  ssl_state->client_state = s;
354 #ifdef DEBUG
355  SCLogDebug("toserver: state updated to %u from %u", s, old);
356 #endif
357 }
358 
359 static void UpdateServerState(SSLState *ssl_state, enum TlsStateServer s)
360 {
361 #ifdef DEBUG
362  enum TlsStateServer old = ssl_state->server_state;
363 #endif
364  ssl_state->server_state = s;
365 #ifdef DEBUG
366  SCLogDebug("toclient: state updated to %u from %u", s, old);
367 #endif
368 }
369 
370 static int SSLGetAlstateProgress(void *tx, uint8_t direction)
371 {
372  SSLState *ssl_state = (SSLState *)tx;
373  if (direction & STREAM_TOCLIENT) {
374  return ssl_state->server_state;
375  } else {
376  return ssl_state->client_state;
377  }
378 }
379 
380 static AppLayerTxData *SSLGetTxData(void *vtx)
381 {
382  SSLState *ssl_state = (SSLState *)vtx;
383  return &ssl_state->tx_data;
384 }
385 
386 static AppLayerStateData *SSLGetStateData(void *vstate)
387 {
388  SSLState *ssl_state = (SSLState *)vstate;
389  return &ssl_state->state_data;
390 }
391 
392 static void TlsDecodeHSCertificateErrSetEvent(SSLState *ssl_state, uint32_t err)
393 {
394  switch(err) {
395  case ERR_EXTRACT_VALIDITY:
396  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_CERTIFICATE_INVALID_VALIDITY);
397  break;
398  case ERR_EXTRACT_ISSUER:
399  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_CERTIFICATE_INVALID_ISSUER);
400  break;
401  case ERR_EXTRACT_SUBJECT:
402  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_CERTIFICATE_INVALID_SUBJECT);
403  break;
404  case ERR_INVALID_DER:
405  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_CERTIFICATE_INVALID_DER);
406  break;
407  case ERR_INVALID_EXTENSIONS:
408  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_CERTIFICATE_INVALID_EXTENSIONS);
409  break;
410  case ERR_INVALID_DATE:
411  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_CERTIFICATE_INVALID_DATE);
412  break;
413  case ERR_INVALID_X509NAME:
414  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_CERTIFICATE_INVALID_X509NAME);
415  break;
416  case ERR_INVALID_ALGORITHMIDENTIFIER:
417  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_CERTIFICATE_INVALID_ALGORITHMIDENTIFIER);
418  break;
419  case ERR_INVALID_SERIAL:
420  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_CERTIFICATE_INVALID_SERIAL);
421  break;
422  case ERR_INVALID_VERSION:
423  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_CERTIFICATE_INVALID_VERSION);
424  break;
425  case ERR_INVALID_LENGTH:
426  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_CERTIFICATE_INVALID_LENGTH);
427  break;
428  case ERR_INVALID_CERTIFICATE:
429  default:
430  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_CERTIFICATE);
431  break;
432  }
433 }
434 
435 static inline int TlsDecodeHSCertificateFingerprint(
436  SSLStateConnp *connp, const uint8_t *input, uint32_t cert_len)
437 {
438  if (unlikely(connp->cert0_fingerprint != NULL))
439  return 0;
440 
441  connp->cert0_fingerprint = SCCalloc(1, SHA1_STRING_LENGTH);
442  if (connp->cert0_fingerprint == NULL)
443  return -1;
444 
445  uint8_t hash[SC_SHA1_LEN];
446  if (SCSha1HashBuffer(input, cert_len, hash, sizeof(hash)) == 1) {
447  SCToHex_sep(
448  (uint8_t *)connp->cert0_fingerprint, SHA1_STRING_LENGTH, ':', hash, SC_SHA1_LEN);
449  }
450  return 0;
451 }
452 
453 static inline int TlsDecodeHSCertificateAddCertToChain(
454  SSLStateConnp *connp, const uint8_t *input, uint32_t cert_len)
455 {
456  SSLCertsChain *cert = SCCalloc(1, sizeof(SSLCertsChain));
457  if (cert == NULL)
458  return -1;
459 
460  cert->cert_data = (uint8_t *)input;
461  cert->cert_len = cert_len;
462  TAILQ_INSERT_TAIL(&connp->certs, cert, next);
463 
464  return 0;
465 }
466 
467 static int TlsDecodeHSCertificate(SSLState *ssl_state, SSLStateConnp *connp,
468  const uint8_t *const initial_input, const uint32_t input_len, const int certn)
469 {
470  const uint8_t *input = (uint8_t *)initial_input;
471  uint32_t err_code = 0;
472  X509 *x509 = NULL;
473  int rc = 0;
474 
475  if (!(HAS_SPACE(3)))
476  goto invalid_cert;
477 
478  uint32_t cert_len = *input << 16 | *(input + 1) << 8 | *(input + 2);
479  input += 3;
480 
481  if (!(HAS_SPACE(cert_len)))
482  goto invalid_cert;
483 
484  /* only store fields from the first certificate in the chain */
485  if (certn == 0 && connp->cert0_subject == NULL && connp->cert0_issuerdn == NULL &&
486  connp->cert0_serial == NULL) {
487  x509 = SCX509Decode(input, cert_len, &err_code);
488  if (x509 == NULL) {
489  TlsDecodeHSCertificateErrSetEvent(ssl_state, err_code);
490  goto next;
491  }
492 
493  SCX509GetSubject(x509, &connp->cert0_subject, &connp->cert0_subject_len);
494  if (connp->cert0_subject == NULL) {
495  err_code = ERR_EXTRACT_SUBJECT;
496  goto error;
497  }
498 
499  SCX509GetIssuer(x509, &connp->cert0_issuerdn, &connp->cert0_issuerdn_len);
500  if (connp->cert0_issuerdn == NULL) {
501  err_code = ERR_EXTRACT_ISSUER;
502  goto error;
503  }
504 
505  connp->cert0_sans_num = SCX509GetSubjectAltNameLen(x509);
506  connp->cert0_sans = SCCalloc(connp->cert0_sans_num, sizeof(SSLSubjectAltName));
507  if (connp->cert0_sans == NULL) {
508  goto error;
509  }
510  for (uint16_t i = 0; i < connp->cert0_sans_num; i++) {
511  SCX509GetSubjectAltNameAt(
512  x509, i, &connp->cert0_sans[i].san, &connp->cert0_sans[i].san_len);
513  }
514 
515  SCX509GetSerial(x509, &connp->cert0_serial, &connp->cert0_serial_len);
516  if (connp->cert0_serial == NULL) {
517  err_code = ERR_INVALID_SERIAL;
518  goto error;
519  }
520 
521  rc = SCX509GetValidity(x509, &connp->cert0_not_before, &connp->cert0_not_after);
522  if (rc != 0) {
523  err_code = ERR_EXTRACT_VALIDITY;
524  goto error;
525  }
526 
527  SCX509Free(x509);
528  x509 = NULL;
529 
530  rc = TlsDecodeHSCertificateFingerprint(connp, input, cert_len);
531  if (rc != 0) {
532  SCLogDebug("TlsDecodeHSCertificateFingerprint failed with %d", rc);
533  goto error;
534  }
535  }
536 
537  rc = TlsDecodeHSCertificateAddCertToChain(connp, input, cert_len);
538  if (rc != 0) {
539  SCLogDebug("TlsDecodeHSCertificateAddCertToChain failed with %d", rc);
540  goto error;
541  }
542 
543 next:
544  input += cert_len;
545  return (int)(input - initial_input);
546 
547 error:
548  if (err_code != 0)
549  TlsDecodeHSCertificateErrSetEvent(ssl_state, err_code);
550  if (x509 != NULL)
551  SCX509Free(x509);
552 
553  return -1;
554 
555 invalid_cert:
556  SCLogDebug("TLS invalid certificate");
557  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_CERTIFICATE);
558  return -1;
559 }
560 
561 /** \internal
562  * \brief parse cert data in a certificate handshake message
563  * will be called with all data.
564  * \retval consumed bytes consumed or -1 on error
565  */
566 static int TlsDecodeHSCertificates(SSLState *ssl_state, SSLStateConnp *connp,
567  const uint8_t *const initial_input, const uint32_t input_len)
568 {
569  const uint8_t *input = (uint8_t *)initial_input;
570 
571  if (!(HAS_SPACE(3)))
572  return -1;
573 
574  const uint32_t cert_chain_len = *input << 16 | *(input + 1) << 8 | *(input + 2);
575  input += 3;
576 
577  if (!(HAS_SPACE(cert_chain_len)))
578  return -1;
579 
580  if (connp->certs_buffer != NULL) {
581  // TODO should we set an event here?
582  return -1;
583  }
584 
585  connp->certs_buffer = SCCalloc(1, cert_chain_len);
586  if (connp->certs_buffer == NULL) {
587  return -1;
588  }
589  connp->certs_buffer_size = cert_chain_len;
590  memcpy(connp->certs_buffer, input, cert_chain_len);
591 
592  int cert_cnt = 0;
593  uint32_t processed_len = 0;
594  /* coverity[tainted_data] */
595  while (processed_len < cert_chain_len) {
596  int rc = TlsDecodeHSCertificate(ssl_state, connp, connp->certs_buffer + processed_len,
597  connp->certs_buffer_size - processed_len, cert_cnt);
598  if (rc <= 0) { // 0 should be impossible, but lets be defensive
599  return -1;
600  }
601  DEBUG_VALIDATE_BUG_ON(processed_len + (uint32_t)rc > cert_chain_len);
602  if (processed_len + (uint32_t)rc > cert_chain_len) {
603  return -1;
604  }
605 
606  processed_len += (uint32_t)rc;
607  }
608 
609  return processed_len + 3;
610 }
611 
612 /**
613  * \inline
614  * \brief Check if value is GREASE.
615  *
616  * http://tools.ietf.org/html/draft-davidben-tls-grease-00
617  *
618  * \param value Value to check.
619  *
620  * \retval 1 if is GREASE.
621  * \retval 0 if not is GREASE.
622  */
623 static inline int TLSDecodeValueIsGREASE(const uint16_t value)
624 {
625  switch (value)
626  {
627  case 0x0a0a:
628  case 0x1a1a:
629  case 0x2a2a:
630  case 0x3a3a:
631  case 0x4a4a:
632  case 0x5a5a:
633  case 0x6a6a:
634  case 0x7a7a:
635  case 0x8a8a:
636  case 0x9a9a:
637  case 0xaaaa:
638  case 0xbaba:
639  case 0xcaca:
640  case 0xdada:
641  case 0xeaea:
642  case 0xfafa:
643  return 1;
644  default:
645  return 0;
646  }
647 }
648 
649 static inline int TLSDecodeHSHelloVersion(SSLState *ssl_state,
650  const uint8_t * const initial_input,
651  const uint32_t input_len)
652 {
653  uint8_t *input = (uint8_t *)initial_input;
654 
655  if (!(HAS_SPACE(SSLV3_CLIENT_HELLO_VERSION_LEN))) {
656  SCLogDebug("TLS handshake invalid length");
657  SSLSetEvent(ssl_state,
658  TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH);
659  return -1;
660  }
661 
662  uint16_t version = (uint16_t)(*input << 8) | *(input + 1);
663  ssl_state->curr_connp->version = version;
664 
665  if (ssl_state->current_flags &
666  (SSL_AL_FLAG_STATE_CLIENT_HELLO | SSL_AL_FLAG_STATE_SERVER_HELLO)) {
667  SCTLSHandshakeSetTLSVersion(ssl_state->curr_connp->hs, version);
668  }
669 
670  /* TLSv1.3 draft1 to draft21 use the version field as earlier TLS
671  versions, instead of using the supported versions extension. */
672  if ((ssl_state->current_flags & SSL_AL_FLAG_STATE_SERVER_HELLO) &&
673  ((ssl_state->curr_connp->version == TLS_VERSION_13) ||
674  (((ssl_state->curr_connp->version >> 8) & 0xff) == 0x7f))) {
675  ssl_state->flags |= SSL_AL_FLAG_LOG_WITHOUT_CERT;
676  }
677 
678  /* Catch some early TLSv1.3 draft implementations that does not conform
679  to the draft version. */
680  if ((ssl_state->curr_connp->version >= 0x7f01) &&
681  (ssl_state->curr_connp->version < 0x7f10)) {
682  ssl_state->curr_connp->version = TLS_VERSION_13_PRE_DRAFT16;
683  }
684 
685  /* TLSv1.3 drafts from draft1 to draft15 use 0x0304 (TLSv1.3) as the
686  version number, which makes it hard to accurately pinpoint the
687  exact draft version. */
688  else if (ssl_state->curr_connp->version == TLS_VERSION_13) {
689  ssl_state->curr_connp->version = TLS_VERSION_13_PRE_DRAFT16;
690  }
691 
692  if (SC_ATOMIC_GET(ssl_config.enable_ja3) && ssl_state->curr_connp->ja3_str == NULL) {
693  ssl_state->curr_connp->ja3_str = Ja3BufferInit();
694  if (ssl_state->curr_connp->ja3_str == NULL)
695  return -1;
696 
697  int rc = Ja3BufferAddValue(&ssl_state->curr_connp->ja3_str, version);
698  if (rc != 0)
699  return -1;
700  }
701 
702  input += SSLV3_CLIENT_HELLO_VERSION_LEN;
703 
704  return (int)(input - initial_input);
705 }
706 
707 static inline int TLSDecodeHSHelloRandom(SSLState *ssl_state,
708  const uint8_t * const initial_input,
709  const uint32_t input_len)
710 {
711  uint8_t *input = (uint8_t *)initial_input;
712 
713  if (!(HAS_SPACE(SSLV3_CLIENT_HELLO_RANDOM_LEN))) {
714  SCLogDebug("TLS handshake invalid length");
715  SSLSetEvent(ssl_state,
716  TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH);
717  return -1;
718  }
719 
720  if (ssl_state->current_flags & SSL_AL_FLAG_STATE_SERVER_HELLO) {
721  memcpy(ssl_state->server_connp.random, input, TLS_RANDOM_LEN);
722  ssl_state->flags |= TLS_TS_RANDOM_SET;
723  } else if (ssl_state->current_flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) {
724  memcpy(ssl_state->client_connp.random, input, TLS_RANDOM_LEN);
725  ssl_state->flags |= TLS_TC_RANDOM_SET;
726  }
727 
728  /* Skip random */
729  input += SSLV3_CLIENT_HELLO_RANDOM_LEN;
730 
731  return (int)(input - initial_input);
732 }
733 
734 static inline int TLSDecodeHSHelloSessionID(SSLState *ssl_state,
735  const uint8_t * const initial_input,
736  const uint32_t input_len)
737 {
738  uint8_t *input = (uint8_t *)initial_input;
739 
740  if (!(HAS_SPACE(1)))
741  goto invalid_length;
742 
743  uint8_t session_id_length = *input;
744  input += 1;
745 
746  if (!(HAS_SPACE(session_id_length)))
747  goto invalid_length;
748 
749  if (session_id_length != 0 && ssl_state->curr_connp->session_id == NULL) {
750  ssl_state->curr_connp->session_id = SCMalloc(session_id_length);
751 
752  if (unlikely(ssl_state->curr_connp->session_id == NULL)) {
753  return -1;
754  }
755 
756  if (SafeMemcpy(ssl_state->curr_connp->session_id, 0, session_id_length,
757  input, 0, input_len, session_id_length) != 0) {
758  return -1;
759  }
760  ssl_state->curr_connp->session_id_length = session_id_length;
761 
762  if ((ssl_state->current_flags & SSL_AL_FLAG_STATE_SERVER_HELLO) &&
763  ssl_state->client_connp.session_id != NULL &&
764  ssl_state->server_connp.session_id != NULL) {
765  if ((ssl_state->client_connp.session_id_length ==
766  ssl_state->server_connp.session_id_length) &&
767  (memcmp(ssl_state->server_connp.session_id,
768  ssl_state->client_connp.session_id, session_id_length) == 0)) {
769  ssl_state->flags |= SSL_AL_FLAG_SESSION_RESUMED;
770  }
771  }
772  }
773 
774  input += session_id_length;
775 
776  return (int)(input - initial_input);
777 
778 invalid_length:
779  SCLogDebug("TLS handshake invalid length");
780  SSLSetEvent(ssl_state,
781  TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH);
782  return -1;
783 }
784 
785 static inline int TLSDecodeHSHelloCipherSuites(SSLState *ssl_state,
786  const uint8_t * const initial_input,
787  const uint32_t input_len)
788 {
789  const uint8_t *input = initial_input;
790 
791  if (!(HAS_SPACE(2)))
792  goto invalid_length;
793 
794  uint16_t cipher_suites_length;
795 
796  if (ssl_state->current_flags & SSL_AL_FLAG_STATE_SERVER_HELLO) {
797  cipher_suites_length = 2;
798  } else if (ssl_state->current_flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) {
799  cipher_suites_length = (uint16_t)(*input << 8) | *(input + 1);
800  input += 2;
801  } else {
802  return -1;
803  }
804 
805  if (!(HAS_SPACE(cipher_suites_length)))
806  goto invalid_length;
807 
808  /* Cipher suites length should always be divisible by 2 */
809  if ((cipher_suites_length % 2) != 0) {
810  goto invalid_length;
811  }
812 
813  const bool enable_ja3 =
814  SC_ATOMIC_GET(ssl_config.enable_ja3) && ssl_state->curr_connp->ja3_hash == NULL;
815 
816  JA3Buffer *ja3_cipher_suites = NULL;
817 
818  if (enable_ja3) {
819  ja3_cipher_suites = Ja3BufferInit();
820  if (ja3_cipher_suites == NULL)
821  return -1;
822  }
823 
824  uint16_t processed_len = 0;
825  /* coverity[tainted_data] */
826  while (processed_len < cipher_suites_length) {
827  if (!(HAS_SPACE(2))) {
828  if (enable_ja3) {
829  Ja3BufferFree(&ja3_cipher_suites);
830  }
831  goto invalid_length;
832  }
833 
834  uint16_t cipher_suite = (uint16_t)(*input << 8) | *(input + 1);
835  input += 2;
836 
837  if (TLSDecodeValueIsGREASE(cipher_suite) != 1) {
838  if (ssl_state->current_flags &
839  (SSL_AL_FLAG_STATE_CLIENT_HELLO | SSL_AL_FLAG_STATE_SERVER_HELLO)) {
840  SCTLSHandshakeAddCipher(ssl_state->curr_connp->hs, cipher_suite);
841  }
842  if (enable_ja3) {
843  int rc = Ja3BufferAddValue(&ja3_cipher_suites, cipher_suite);
844  if (rc != 0) {
845  return -1;
846  }
847  }
848  }
849  processed_len += 2;
850  }
851 
852  if (enable_ja3) {
853  int rc = Ja3BufferAppendBuffer(&ssl_state->curr_connp->ja3_str, &ja3_cipher_suites);
854  if (rc == -1) {
855  return -1;
856  }
857  }
858 
859  return (int)(input - initial_input);
860 
861 invalid_length:
862  SCLogDebug("TLS handshake invalid length");
863  SSLSetEvent(ssl_state,
864  TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH);
865  return -1;
866 }
867 
868 static inline int TLSDecodeHSHelloCompressionMethods(SSLState *ssl_state,
869  const uint8_t * const initial_input,
870  const uint32_t input_len)
871 {
872  const uint8_t *input = initial_input;
873 
874  if (!(HAS_SPACE(1)))
875  goto invalid_length;
876 
877  /* Skip compression methods */
878  if (ssl_state->current_flags & SSL_AL_FLAG_STATE_SERVER_HELLO) {
879  input += 1;
880  } else {
881  uint8_t compression_methods_length = *input;
882  input += 1;
883 
884  if (!(HAS_SPACE(compression_methods_length)))
885  goto invalid_length;
886 
887  input += compression_methods_length;
888  }
889 
890  return (int)(input - initial_input);
891 
892 invalid_length:
893  SCLogDebug("TLS handshake invalid_length");
894  SSLSetEvent(ssl_state,
895  TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH);
896  return -1;
897 }
898 
899 static inline int TLSDecodeHSHelloExtensionSni(SSLState *ssl_state,
900  const uint8_t * const initial_input,
901  const uint32_t input_len)
902 {
903  uint8_t *input = (uint8_t *)initial_input;
904 
905  /* Empty extension */
906  if (input_len == 0)
907  return 0;
908 
909  if (!(HAS_SPACE(2)))
910  goto invalid_length;
911 
912  /* Skip sni_list_length */
913  input += 2;
914 
915  if (!(HAS_SPACE(1)))
916  goto invalid_length;
917 
918  uint8_t sni_type = *input;
919  input += 1;
920 
921  /* Currently the only type allowed is host_name
922  (RFC6066 section 3). */
923  if (sni_type != SSL_SNI_TYPE_HOST_NAME) {
924  SCLogDebug("Unknown SNI type");
925  SSLSetEvent(ssl_state,
926  TLS_DECODER_EVENT_INVALID_SNI_TYPE);
927  return -1;
928  }
929 
930  if (!(HAS_SPACE(2)))
931  goto invalid_length;
932 
933  uint16_t sni_len = (uint16_t)(*input << 8) | *(input + 1);
934  input += 2;
935 
936  /* host_name contains the fully qualified domain name,
937  and should therefore be limited by the maximum domain
938  name length. */
939  if (!(HAS_SPACE(sni_len)) || sni_len > 255 || sni_len == 0) {
940  SSLSetEvent(ssl_state,
941  TLS_DECODER_EVENT_INVALID_SNI_LENGTH);
942  return -1;
943  }
944 
945  /* There must not be more than one extension of the same
946  type (RFC5246 section 7.4.1.4). */
947  if (ssl_state->curr_connp->sni) {
948  SCLogDebug("Multiple SNI extensions");
949  SSLSetEvent(ssl_state,
950  TLS_DECODER_EVENT_MULTIPLE_SNI_EXTENSIONS);
951  input += sni_len;
952  return (int)(input - initial_input);
953  }
954 
955  ssl_state->curr_connp->sni_len = sni_len;
956  ssl_state->curr_connp->sni = SCMalloc(sni_len);
957  if (unlikely(ssl_state->curr_connp->sni == NULL))
958  return -1;
959 
960  const size_t consumed = input - initial_input;
961  if (SafeMemcpy(ssl_state->curr_connp->sni, 0, sni_len, initial_input, consumed, input_len,
962  sni_len) != 0) {
963  SCFree(ssl_state->curr_connp->sni);
964  ssl_state->curr_connp->sni = NULL;
965  return -1;
966  }
967  input += sni_len;
968 
969  return (int)(input - initial_input);
970 
971 invalid_length:
972  SCLogDebug("TLS handshake invalid length");
973  SSLSetEvent(ssl_state,
974  TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH);
975 
976 
977  return -1;
978 }
979 
980 static inline int TLSDecodeHSHelloExtensionSupportedVersions(SSLState *ssl_state,
981  const uint8_t * const initial_input,
982  const uint32_t input_len)
983 {
984  const uint8_t *input = initial_input;
985 
986  /* Empty extension */
987  if (input_len == 0)
988  return 0;
989 
990  if (ssl_state->current_flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) {
991  if (!(HAS_SPACE(1)))
992  goto invalid_length;
993 
994  uint8_t supported_ver_len = *input;
995  input += 1;
996 
997  if (supported_ver_len < 2)
998  goto invalid_length;
999 
1000  if (!(HAS_SPACE(supported_ver_len)))
1001  goto invalid_length;
1002 
1003  /* Use the first (and preferred) valid version as client version,
1004  * skip over GREASE and other possible noise. */
1005  uint16_t i = 0;
1006  while (i + 1 < (uint16_t)supported_ver_len) {
1007  uint16_t ver = (uint16_t)(input[i] << 8) | input[i + 1];
1008  if (TLSVersionValid(ver)) {
1009  ssl_state->curr_connp->version = ver;
1010  SCTLSHandshakeSetTLSVersion(ssl_state->curr_connp->hs, ver);
1011  break;
1012  }
1013  i += 2;
1014  }
1015 
1016  /* Set a flag to indicate that we have seen this extension */
1017  ssl_state->flags |= SSL_AL_FLAG_CH_VERSION_EXTENSION;
1018 
1019  input += supported_ver_len;
1020  }
1021  else if (ssl_state->current_flags & SSL_AL_FLAG_STATE_SERVER_HELLO) {
1022  if (!(HAS_SPACE(2)))
1023  goto invalid_length;
1024 
1025  uint16_t ver = (uint16_t)(*input << 8) | *(input + 1);
1026 
1027  if ((ssl_state->flags & SSL_AL_FLAG_CH_VERSION_EXTENSION) &&
1028  (ver > TLS_VERSION_12)) {
1029  ssl_state->flags |= SSL_AL_FLAG_LOG_WITHOUT_CERT;
1030  }
1031 
1032  ssl_state->curr_connp->version = ver;
1033  input += 2;
1034  }
1035 
1036  return (int)(input - initial_input);
1037 
1038 invalid_length:
1039  SCLogDebug("TLS handshake invalid length");
1040  SSLSetEvent(ssl_state,
1041  TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH);
1042 
1043  return -1;
1044 }
1045 
1046 static inline int TLSDecodeHSHelloExtensionEllipticCurves(SSLState *ssl_state,
1047  const uint8_t *const initial_input, const uint32_t input_len,
1048  JA3Buffer **ja3_elliptic_curves)
1049 {
1050  const uint8_t *input = initial_input;
1051 
1052  /* Empty extension */
1053  if (input_len == 0)
1054  return 0;
1055 
1056  if (!(HAS_SPACE(2)))
1057  goto invalid_length;
1058 
1059  uint16_t elliptic_curves_len = (uint16_t)(*input << 8) | *(input + 1);
1060  input += 2;
1061 
1062  if (!(HAS_SPACE(elliptic_curves_len)))
1063  goto invalid_length;
1064 
1065  if ((ssl_state->current_flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) &&
1066  *ja3_elliptic_curves != NULL) {
1067  uint16_t ec_processed_len = 0;
1068  /* coverity[tainted_data] */
1069  while (ec_processed_len < elliptic_curves_len)
1070  {
1071  if (!(HAS_SPACE(2)))
1072  goto invalid_length;
1073 
1074  uint16_t elliptic_curve = (uint16_t)(*input << 8) | *(input + 1);
1075  input += 2;
1076 
1077  if (TLSDecodeValueIsGREASE(elliptic_curve) != 1) {
1078  int rc = Ja3BufferAddValue(ja3_elliptic_curves, elliptic_curve);
1079  if (rc != 0)
1080  return -1;
1081  }
1082 
1083  ec_processed_len += 2;
1084  }
1085 
1086  } else {
1087  /* Skip elliptic curves */
1088  input += elliptic_curves_len;
1089  }
1090 
1091  return (int)(input - initial_input);
1092 
1093 invalid_length:
1094  SCLogDebug("TLS handshake invalid length");
1095  SSLSetEvent(ssl_state,
1096  TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH);
1097 
1098  return -1;
1099 }
1100 
1101 static inline int TLSDecodeHSHelloExtensionEllipticCurvePF(SSLState *ssl_state,
1102  const uint8_t *const initial_input, const uint32_t input_len,
1103  JA3Buffer **ja3_elliptic_curves_pf)
1104 {
1105  const uint8_t *input = initial_input;
1106 
1107  /* Empty extension */
1108  if (input_len == 0)
1109  return 0;
1110 
1111  if (!(HAS_SPACE(1)))
1112  goto invalid_length;
1113 
1114  uint8_t ec_pf_len = *input;
1115  input += 1;
1116 
1117  if (!(HAS_SPACE(ec_pf_len)))
1118  goto invalid_length;
1119 
1120  if ((ssl_state->current_flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) &&
1121  *ja3_elliptic_curves_pf != NULL) {
1122  uint8_t ec_pf_processed_len = 0;
1123  /* coverity[tainted_data] */
1124  while (ec_pf_processed_len < ec_pf_len)
1125  {
1126  uint8_t elliptic_curve_pf = *input;
1127  input += 1;
1128 
1129  if (TLSDecodeValueIsGREASE(elliptic_curve_pf) != 1) {
1130  int rc = Ja3BufferAddValue(ja3_elliptic_curves_pf, elliptic_curve_pf);
1131  if (rc != 0)
1132  return -1;
1133  }
1134 
1135  ec_pf_processed_len += 1;
1136  }
1137 
1138  } else {
1139  /* Skip elliptic curve point formats */
1140  input += ec_pf_len;
1141  }
1142 
1143  return (int)(input - initial_input);
1144 
1145 invalid_length:
1146  SCLogDebug("TLS handshake invalid length");
1147  SSLSetEvent(ssl_state,
1148  TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH);
1149 
1150  return -1;
1151 }
1152 
1153 static inline int TLSDecodeHSHelloExtensionSigAlgorithms(
1154  SSLState *ssl_state, const uint8_t *const initial_input, const uint32_t input_len)
1155 {
1156  const uint8_t *input = initial_input;
1157 
1158  /* Empty extension */
1159  if (input_len == 0)
1160  return 0;
1161 
1162  if (!(HAS_SPACE(2)))
1163  goto invalid_length;
1164 
1165  uint16_t sigalgo_len = (uint16_t)(*input << 8) | *(input + 1);
1166  input += 2;
1167 
1168  /* Signature algorithms length should always be divisible by 2 */
1169  if ((sigalgo_len % 2) != 0) {
1170  goto invalid_length;
1171  }
1172 
1173  if (!(HAS_SPACE(sigalgo_len)))
1174  goto invalid_length;
1175 
1176  if (ssl_state->current_flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) {
1177  uint16_t sigalgo_processed_len = 0;
1178  while (sigalgo_processed_len < sigalgo_len) {
1179  uint16_t sigalgo = (uint16_t)(*input << 8) | *(input + 1);
1180  input += 2;
1181  sigalgo_processed_len += 2;
1182 
1183  SCTLSHandshakeAddSigAlgo(ssl_state->curr_connp->hs, sigalgo);
1184  }
1185  } else {
1186  /* Skip signature algorithms */
1187  input += sigalgo_len;
1188  }
1189 
1190  return (int)(input - initial_input);
1191 
1192 invalid_length:
1193  SCLogDebug("Signature algorithm list invalid length");
1194  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH);
1195 
1196  return -1;
1197 }
1198 
1199 static inline int TLSDecodeHSHelloExtensionALPN(
1200  SSLState *ssl_state, const uint8_t *const initial_input, const uint32_t input_len)
1201 {
1202  const uint8_t *input = initial_input;
1203 
1204  /* Empty extension */
1205  if (input_len == 0)
1206  return 0;
1207 
1208  if (!(HAS_SPACE(2)))
1209  goto invalid_length;
1210 
1211  uint16_t alpn_len = (uint16_t)(*input << 8) | *(input + 1);
1212  input += 2;
1213 
1214  if (!(HAS_SPACE(alpn_len)))
1215  goto invalid_length;
1216 
1217  /* We use 32 bits here to avoid potentially overflowing a value that
1218  needs to be compared to an unsigned 16-bit value. */
1219  uint32_t alpn_processed_len = 0;
1220  while (alpn_processed_len < alpn_len) {
1221  uint8_t protolen = *input;
1222  input += 1;
1223  alpn_processed_len += 1;
1224 
1225  if (!(HAS_SPACE(protolen)))
1226  goto invalid_length;
1227 
1228  /* Check if reading another protolen bytes would exceed the
1229  overall ALPN length; if so, skip and continue */
1230  if (alpn_processed_len + protolen > ((uint32_t)alpn_len)) {
1231  input += alpn_len - alpn_processed_len;
1232  break;
1233  }
1234  SCTLSHandshakeAddALPN(ssl_state->curr_connp->hs, (const char *)input, protolen);
1235 
1236  alpn_processed_len += protolen;
1237  input += protolen;
1238  }
1239 
1240  return (int)(input - initial_input);
1241 
1242 invalid_length:
1243  SCLogDebug("ALPN list invalid length");
1244  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH);
1245 
1246  return -1;
1247 }
1248 
1249 static inline int TLSDecodeHSHelloExtensions(SSLState *ssl_state,
1250  const uint8_t * const initial_input,
1251  const uint32_t input_len)
1252 {
1253  const uint8_t *input = initial_input;
1254 
1255  int ret;
1256  int rc;
1257  // if ja3_hash is already computed, do not use new hello to augment ja3_str
1258  const bool ja3 =
1259  (SC_ATOMIC_GET(ssl_config.enable_ja3) == 1) && ssl_state->curr_connp->ja3_hash == NULL;
1260 
1261  JA3Buffer *ja3_extensions = NULL;
1262  JA3Buffer *ja3_elliptic_curves = NULL;
1263  JA3Buffer *ja3_elliptic_curves_pf = NULL;
1264 
1265  if (ja3) {
1266  ja3_extensions = Ja3BufferInit();
1267  if (ja3_extensions == NULL)
1268  goto error;
1269 
1270  if (ssl_state->current_flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) {
1271  ja3_elliptic_curves = Ja3BufferInit();
1272  if (ja3_elliptic_curves == NULL)
1273  goto error;
1274 
1275  ja3_elliptic_curves_pf = Ja3BufferInit();
1276  if (ja3_elliptic_curves_pf == NULL)
1277  goto error;
1278  }
1279  }
1280 
1281  /* Extensions are optional (RFC5246 section 7.4.1.2) */
1282  if (!(HAS_SPACE(2)))
1283  goto end;
1284 
1285  uint16_t extensions_len = (uint16_t)(*input << 8) | *(input + 1);
1286  input += 2;
1287 
1288  if (!(HAS_SPACE(extensions_len)))
1289  goto invalid_length;
1290 
1291  uint32_t processed_len = 0;
1292  /* coverity[tainted_data] */
1293  while (processed_len < (uint32_t)extensions_len) {
1294  if (!(HAS_SPACE(2)))
1295  goto invalid_length;
1296 
1297  uint16_t ext_type = (uint16_t)(*input << 8) | *(input + 1);
1298  input += 2;
1299 
1300  if (!(HAS_SPACE(2)))
1301  goto invalid_length;
1302 
1303  uint16_t ext_len = (uint16_t)(*input << 8) | *(input + 1);
1304  input += 2;
1305 
1306  if (!(HAS_SPACE(ext_len)))
1307  goto invalid_length;
1308 
1309  if (processed_len + 4UL + (uint32_t)ext_len > (uint32_t)extensions_len)
1310  goto invalid_length;
1311 
1312  switch (ext_type) {
1313  case SSL_EXTENSION_SNI:
1314  {
1315  /* coverity[tainted_data] */
1316  ret = TLSDecodeHSHelloExtensionSni(ssl_state, input,
1317  ext_len);
1318  if (ret < 0)
1319  goto end;
1320 
1321  input += ext_len;
1322 
1323  break;
1324  }
1325 
1326  case SSL_EXTENSION_ELLIPTIC_CURVES:
1327  {
1328  /* coverity[tainted_data] */
1329  ret = TLSDecodeHSHelloExtensionEllipticCurves(
1330  ssl_state, input, ext_len, &ja3_elliptic_curves);
1331  if (ret < 0)
1332  goto error;
1333 
1334  input += ext_len;
1335 
1336  break;
1337  }
1338 
1339  case SSL_EXTENSION_EC_POINT_FORMATS:
1340  {
1341  /* coverity[tainted_data] */
1342  ret = TLSDecodeHSHelloExtensionEllipticCurvePF(
1343  ssl_state, input, ext_len, &ja3_elliptic_curves_pf);
1344  if (ret < 0)
1345  goto error;
1346 
1347  input += ext_len;
1348 
1349  break;
1350  }
1351 
1352  case SSL_EXTENSION_SIGNATURE_ALGORITHMS: {
1353  /* coverity[tainted_data] */
1354  ret = TLSDecodeHSHelloExtensionSigAlgorithms(ssl_state, input, ext_len);
1355  if (ret < 0)
1356  goto end;
1357 
1358  input += ext_len;
1359 
1360  break;
1361  }
1362 
1363  case SSL_EXTENSION_ALPN: {
1364  /* coverity[tainted_data] */
1365  ret = TLSDecodeHSHelloExtensionALPN(ssl_state, input, ext_len);
1366  if (ret < 0)
1367  goto end;
1368 
1369  input += ext_len;
1370 
1371  break;
1372  }
1373 
1374  case SSL_EXTENSION_EARLY_DATA:
1375  {
1376  if (ssl_state->current_flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) {
1377  /* Used by 0-RTT to indicate that encrypted data will
1378  be sent right after the ClientHello record. */
1379  ssl_state->flags |= SSL_AL_FLAG_EARLY_DATA;
1380  }
1381 
1382  input += ext_len;
1383 
1384  break;
1385  }
1386 
1387  case SSL_EXTENSION_SUPPORTED_VERSIONS:
1388  {
1389  ret = TLSDecodeHSHelloExtensionSupportedVersions(ssl_state, input,
1390  ext_len);
1391  if (ret < 0)
1392  goto end;
1393 
1394  input += ext_len;
1395 
1396  break;
1397  }
1398 
1399  case SSL_EXTENSION_SESSION_TICKET:
1400  {
1401  if (ssl_state->current_flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) {
1402  /* This has to be verified later on by checking if a
1403  certificate record has been sent by the server. */
1404  ssl_state->flags |= SSL_AL_FLAG_SESSION_RESUMED;
1405  }
1406 
1407  input += ext_len;
1408 
1409  break;
1410  }
1411 
1412  default:
1413  {
1414  input += ext_len;
1415  break;
1416  }
1417  }
1418 
1419  if (ja3) {
1420  if (TLSDecodeValueIsGREASE(ext_type) != 1) {
1421  rc = Ja3BufferAddValue(&ja3_extensions, ext_type);
1422  if (rc != 0)
1423  goto error;
1424  }
1425  }
1426 
1427  if (ssl_state->current_flags &
1428  (SSL_AL_FLAG_STATE_CLIENT_HELLO | SSL_AL_FLAG_STATE_SERVER_HELLO)) {
1429  if (TLSDecodeValueIsGREASE(ext_type) != 1) {
1430  SCTLSHandshakeAddExtension(ssl_state->curr_connp->hs, ext_type);
1431  }
1432  }
1433 
1434  processed_len += (uint32_t)ext_len + 4UL;
1435  }
1436 
1437 end:
1438  if (ja3) {
1439  rc = Ja3BufferAppendBuffer(&ssl_state->curr_connp->ja3_str,
1440  &ja3_extensions);
1441  if (rc == -1)
1442  goto error;
1443 
1444  if (ssl_state->current_flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) {
1445  rc = Ja3BufferAppendBuffer(&ssl_state->curr_connp->ja3_str,
1446  &ja3_elliptic_curves);
1447  if (rc == -1)
1448  goto error;
1449 
1450  rc = Ja3BufferAppendBuffer(&ssl_state->curr_connp->ja3_str,
1451  &ja3_elliptic_curves_pf);
1452  if (rc == -1)
1453  goto error;
1454  }
1455  }
1456 
1457  return (int)(input - initial_input);
1458 
1459 invalid_length:
1460  SCLogDebug("TLS handshake invalid length");
1461  SSLSetEvent(ssl_state,
1462  TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH);
1463 
1464 error:
1465  if (ja3_extensions != NULL)
1466  Ja3BufferFree(&ja3_extensions);
1467  if (ja3_elliptic_curves != NULL)
1468  Ja3BufferFree(&ja3_elliptic_curves);
1469  if (ja3_elliptic_curves_pf != NULL)
1470  Ja3BufferFree(&ja3_elliptic_curves_pf);
1471 
1472  return -1;
1473 }
1474 
1475 static int TLSDecodeHandshakeHello(SSLState *ssl_state,
1476  const uint8_t * const input,
1477  const uint32_t input_len)
1478 {
1479  int ret;
1480  uint32_t parsed = 0;
1481 
1482  ret = TLSDecodeHSHelloVersion(ssl_state, input, input_len);
1483  if (ret < 0)
1484  goto end;
1485 
1486  parsed += ret;
1487 
1488  ret = TLSDecodeHSHelloRandom(ssl_state, input + parsed, input_len - parsed);
1489  if (ret < 0)
1490  goto end;
1491 
1492  parsed += ret;
1493 
1494  /* The session id field in the server hello record was removed in
1495  TLSv1.3 draft1, but was readded in draft22. */
1496  if ((ssl_state->current_flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) ||
1497  ((ssl_state->current_flags & SSL_AL_FLAG_STATE_SERVER_HELLO) &&
1498  ((ssl_state->flags & SSL_AL_FLAG_LOG_WITHOUT_CERT) == 0))) {
1499  ret = TLSDecodeHSHelloSessionID(ssl_state, input + parsed,
1500  input_len - parsed);
1501  if (ret < 0)
1502  goto end;
1503 
1504  parsed += ret;
1505  }
1506 
1507  ret = TLSDecodeHSHelloCipherSuites(ssl_state, input + parsed,
1508  input_len - parsed);
1509  if (ret < 0)
1510  goto end;
1511 
1512  parsed += ret;
1513 
1514  /* The compression methods field in the server hello record was
1515  removed in TLSv1.3 draft1, but was readded in draft22. */
1516  if ((ssl_state->current_flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) ||
1517  ((ssl_state->current_flags & SSL_AL_FLAG_STATE_SERVER_HELLO) &&
1518  ((ssl_state->flags & SSL_AL_FLAG_LOG_WITHOUT_CERT) == 0))) {
1519  ret = TLSDecodeHSHelloCompressionMethods(ssl_state, input + parsed,
1520  input_len - parsed);
1521  if (ret < 0)
1522  goto end;
1523 
1524  parsed += ret;
1525  }
1526 
1527  ret = TLSDecodeHSHelloExtensions(ssl_state, input + parsed,
1528  input_len - parsed);
1529  if (ret < 0)
1530  goto end;
1531 
1532  if (SC_ATOMIC_GET(ssl_config.enable_ja3) && ssl_state->curr_connp->ja3_hash == NULL) {
1533  ssl_state->curr_connp->ja3_hash = Ja3GenerateHash(ssl_state->curr_connp->ja3_str);
1534  }
1535 
1536  if (ssl_state->curr_connp == &ssl_state->client_connp) {
1537  UpdateClientState(ssl_state, TLS_STATE_CLIENT_HELLO_DONE);
1538  } else {
1539  UpdateServerState(ssl_state, TLS_STATE_SERVER_HELLO);
1540  }
1541 end:
1542  return 0;
1543 }
1544 
1545 #ifdef DEBUG_VALIDATION
1546 static inline bool
1547 RecordAlreadyProcessed(const SSLStateConnp *curr_connp)
1548 {
1549  return ((curr_connp->record_length + SSLV3_RECORD_HDR_LEN) <
1550  curr_connp->bytes_processed);
1551 }
1552 #endif
1553 
1554 static inline int SSLv3ParseHandshakeTypeCertificate(SSLState *ssl_state, SSLStateConnp *connp,
1555  const uint8_t *const initial_input, const uint32_t input_len)
1556 {
1557  int rc = TlsDecodeHSCertificates(ssl_state, connp, initial_input, input_len);
1558  SCLogDebug("rc %d", rc);
1559  if (rc > 0) {
1560  DEBUG_VALIDATE_BUG_ON(rc > (int)input_len);
1561  SSLParserHSReset(connp);
1562  } else if (rc < 0) {
1563  SCLogDebug("error parsing cert, reset state");
1564  SSLParserHSReset(connp);
1565  /* fall through to still consume the cert bytes */
1566  }
1567  if (connp == &ssl_state->client_connp) {
1568  UpdateClientState(ssl_state, TLS_STATE_CLIENT_CERT_DONE);
1569  } else {
1570  UpdateServerState(ssl_state, TLS_STATE_SERVER_CERT_DONE);
1571  }
1572  return input_len;
1573 }
1574 
1575 static int SupportedHandshakeType(const uint8_t type)
1576 {
1577  switch (type) {
1578  case SSLV3_HS_CLIENT_HELLO:
1579  case SSLV3_HS_SERVER_HELLO:
1580  case SSLV3_HS_SERVER_KEY_EXCHANGE:
1581  case SSLV3_HS_CLIENT_KEY_EXCHANGE:
1582  case SSLV3_HS_CERTIFICATE:
1583  case SSLV3_HS_HELLO_REQUEST:
1584  case SSLV3_HS_CERTIFICATE_REQUEST:
1585  case SSLV3_HS_CERTIFICATE_VERIFY:
1586  case SSLV3_HS_FINISHED:
1587  case SSLV3_HS_CERTIFICATE_URL:
1588  case SSLV3_HS_CERTIFICATE_STATUS:
1589  case SSLV3_HS_NEW_SESSION_TICKET:
1590  case SSLV3_HS_SERVER_HELLO_DONE:
1591  return true;
1592  break;
1593 
1594  default:
1595  return false;
1596  break;
1597  }
1598 }
1599 
1600 /**
1601  * \param input_len length of bytes after record header. Can be 0 (e.g. for server hello done).
1602  * \retval parsed number of consumed bytes
1603  * \retval < 0 error
1604  */
1605 static int SSLv3ParseHandshakeType(SSLState *ssl_state, const uint8_t *input,
1606  uint32_t input_len, uint8_t direction)
1607 {
1608  const uint8_t *initial_input = input;
1609  int rc;
1610 
1611  DEBUG_VALIDATE_BUG_ON(RecordAlreadyProcessed(ssl_state->curr_connp));
1612 
1613  switch (ssl_state->curr_connp->handshake_type) {
1614  case SSLV3_HS_CLIENT_HELLO:
1615  ssl_state->current_flags = SSL_AL_FLAG_STATE_CLIENT_HELLO;
1616 
1617  if (ssl_state->curr_connp->hs == NULL)
1618  ssl_state->curr_connp->hs = SCTLSHandshakeNew();
1619 
1620  rc = TLSDecodeHandshakeHello(ssl_state, input, input_len);
1621  if (rc < 0)
1622  return rc;
1623  break;
1624 
1625  case SSLV3_HS_SERVER_HELLO:
1626  ssl_state->current_flags = SSL_AL_FLAG_STATE_SERVER_HELLO;
1627 
1628  DEBUG_VALIDATE_BUG_ON(ssl_state->curr_connp->message_length != input_len);
1629  if (ssl_state->curr_connp->hs == NULL)
1630  ssl_state->curr_connp->hs = SCTLSHandshakeNew();
1631 
1632  rc = TLSDecodeHandshakeHello(ssl_state, input, input_len);
1633  if (rc < 0)
1634  return rc;
1635  break;
1636 
1637  case SSLV3_HS_SERVER_KEY_EXCHANGE:
1638  ssl_state->current_flags = SSL_AL_FLAG_STATE_SERVER_KEYX;
1639  break;
1640 
1641  case SSLV3_HS_CLIENT_KEY_EXCHANGE:
1642  ssl_state->current_flags = SSL_AL_FLAG_STATE_CLIENT_KEYX;
1643  break;
1644 
1645  case SSLV3_HS_CERTIFICATE:
1646  rc = SSLv3ParseHandshakeTypeCertificate(ssl_state,
1647  direction ? &ssl_state->server_connp : &ssl_state->client_connp, initial_input,
1648  input_len);
1649  if (rc < 0)
1650  return rc;
1651  break;
1652 
1653  case SSLV3_HS_HELLO_REQUEST:
1654  break;
1655  case SSLV3_HS_CERTIFICATE_REQUEST:
1656  if (direction) {
1657  ssl_state->current_flags = SSL_AL_FLAG_NEED_CLIENT_CERT;
1658  }
1659  break;
1660  case SSLV3_HS_CERTIFICATE_VERIFY:
1661  case SSLV3_HS_FINISHED:
1662  case SSLV3_HS_CERTIFICATE_URL:
1663  case SSLV3_HS_CERTIFICATE_STATUS:
1664  break;
1665  case SSLV3_HS_NEW_SESSION_TICKET:
1666  SCLogDebug("new session ticket");
1667  break;
1668  case SSLV3_HS_SERVER_HELLO_DONE:
1669  if (direction) {
1670  UpdateServerState(ssl_state, TLS_STATE_SERVER_HELLO_DONE);
1671  }
1672  break;
1673  default:
1674  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_SSL_RECORD);
1675  return -1;
1676  }
1677 
1678  ssl_state->flags |= ssl_state->current_flags;
1679 
1680  SCLogDebug("message: length %u", ssl_state->curr_connp->message_length);
1681  SCLogDebug("input_len %u ssl_state->curr_connp->bytes_processed %u", input_len, ssl_state->curr_connp->bytes_processed);
1682 
1683  return input_len;
1684 }
1685 
1686 static int SSLv3ParseHandshakeProtocol(SSLState *ssl_state, const uint8_t *input,
1687  uint32_t input_len, uint8_t direction)
1688 {
1689  const uint8_t *initial_input = input;
1690 
1691  if (input_len == 0 || ssl_state->curr_connp->bytes_processed ==
1692  (ssl_state->curr_connp->record_length + SSLV3_RECORD_HDR_LEN)) {
1693  SCReturnInt(0);
1694  }
1695 
1696  while (input_len) {
1697  SCLogDebug("input_len %u", input_len);
1698 
1699  if (ssl_state->curr_connp->hs_buffer != NULL) {
1700  SCLogDebug("partial handshake record in place");
1701  const uint32_t need = ssl_state->curr_connp->hs_buffer_message_size -
1702  ssl_state->curr_connp->hs_buffer_offset;
1703  const uint32_t add = MIN(need, input_len);
1704 
1705  /* grow buffer to next multiple of 4k that fits all data we have */
1706  if (ssl_state->curr_connp->hs_buffer_offset + add >
1707  ssl_state->curr_connp->hs_buffer_size) {
1708  const uint32_t avail = ssl_state->curr_connp->hs_buffer_offset + add;
1709  const uint32_t new_size = avail + (4096 - (avail % 4096));
1710  SCLogDebug("new_size %u, avail %u", new_size, avail);
1711  void *ptr = SCRealloc(ssl_state->curr_connp->hs_buffer, new_size);
1712  if (ptr == NULL)
1713  return -1;
1714  ssl_state->curr_connp->hs_buffer = ptr;
1715  ssl_state->curr_connp->hs_buffer_size = new_size;
1716  }
1717 
1718  SCLogDebug("ssl_state->curr_connp->hs_buffer_offset %u "
1719  "ssl_state->curr_connp->hs_buffer_size %u",
1720  ssl_state->curr_connp->hs_buffer_offset, ssl_state->curr_connp->hs_buffer_size);
1721  SCLogDebug("to add %u total %u", add, ssl_state->curr_connp->hs_buffer_offset + add);
1722 
1723  if (SafeMemcpy(ssl_state->curr_connp->hs_buffer,
1724  ssl_state->curr_connp->hs_buffer_offset,
1725  ssl_state->curr_connp->hs_buffer_size, input, 0, add, add) != 0) {
1726  SCLogDebug("copy failed");
1727  return -1;
1728  }
1729  ssl_state->curr_connp->hs_buffer_offset += add;
1730 
1731  if (ssl_state->curr_connp->hs_buffer_message_size <=
1732  ssl_state->curr_connp->hs_buffer_offset) {
1733  DEBUG_VALIDATE_BUG_ON(ssl_state->curr_connp->hs_buffer_message_size !=
1734  ssl_state->curr_connp->hs_buffer_offset);
1735 
1736  ssl_state->curr_connp->handshake_type =
1737  ssl_state->curr_connp->hs_buffer_message_type;
1738  ssl_state->curr_connp->message_length =
1739  ssl_state->curr_connp->hs_buffer_message_size;
1740 
1741  SCLogDebug("got all data now: handshake_type %u message_length %u",
1742  ssl_state->curr_connp->handshake_type,
1743  ssl_state->curr_connp->message_length);
1744 
1745  int retval = SSLv3ParseHandshakeType(ssl_state, ssl_state->curr_connp->hs_buffer,
1746  ssl_state->curr_connp->hs_buffer_offset, direction);
1747  if (retval < 0) {
1748  SSLParserHSReset(ssl_state->curr_connp);
1749  return (retval);
1750  }
1751  SCLogDebug("retval %d", retval);
1752 
1753  /* data processed, reset buffer */
1754  SCFree(ssl_state->curr_connp->hs_buffer);
1755  ssl_state->curr_connp->hs_buffer = NULL;
1756  ssl_state->curr_connp->hs_buffer_size = 0;
1757  ssl_state->curr_connp->hs_buffer_message_size = 0;
1758  ssl_state->curr_connp->hs_buffer_message_type = 0;
1759  ssl_state->curr_connp->hs_buffer_offset = 0;
1760  } else {
1761  SCLogDebug("partial data");
1762  }
1763 
1764  input += add;
1765  input_len -= add;
1766  SCLogDebug("input_len %u", input_len);
1767  SSLParserHSReset(ssl_state->curr_connp);
1768  continue;
1769  }
1770 
1771  SCLogDebug("bytes_processed %u", ssl_state->curr_connp->bytes_processed);
1772  SCLogDebug("input %p input_len %u", input, input_len);
1773 
1774  if (input_len < 4) {
1775  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_SSL_RECORD);
1776  SCReturnInt(-1);
1777  }
1778 
1779  ssl_state->curr_connp->handshake_type = input[0];
1780  ssl_state->curr_connp->message_length = input[1] << 16 | input[2] << 8 | input[3];
1781  SCLogDebug("handshake_type %u message len %u input %p input_len %u",
1782  ssl_state->curr_connp->handshake_type, ssl_state->curr_connp->message_length, input,
1783  input_len);
1784  input += 4;
1785  input_len -= 4;
1786 
1787  const uint32_t record_len = ssl_state->curr_connp->message_length;
1788  /* see if we support this type. We check here to not use the fragment
1789  * handling on things we don't support. */
1790  const bool supported_type = SupportedHandshakeType(ssl_state->curr_connp->handshake_type);
1791  SCLogDebug("supported_type %s handshake_type %u/%02x", supported_type ? "true" : "false",
1792  ssl_state->curr_connp->handshake_type, ssl_state->curr_connp->handshake_type);
1793  if (!supported_type) {
1794  uint32_t avail_record_len = MIN(input_len, record_len);
1795  input += avail_record_len;
1796  input_len -= avail_record_len;
1797 
1798  SSLParserHSReset(ssl_state->curr_connp);
1799 
1800  if ((direction && (ssl_state->flags & SSL_AL_FLAG_SERVER_CHANGE_CIPHER_SPEC)) ||
1801  (!direction && (ssl_state->flags & SSL_AL_FLAG_CLIENT_CHANGE_CIPHER_SPEC))) {
1802  // after Change Cipher Spec we get Encrypted Handshake Messages
1803  } else {
1804  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_HANDSHAKE_MESSAGE);
1805  }
1806  continue;
1807  }
1808 
1809  /* if the message length exceeds our input_len, we have a tls fragment. */
1810  if (record_len > input_len) {
1811  const uint32_t avail = input_len;
1812  const uint32_t size = avail + (4096 - (avail % 4096));
1813  SCLogDebug("initial buffer size %u, based on input %u", size, avail);
1814  ssl_state->curr_connp->hs_buffer = SCCalloc(1, size);
1815  if (ssl_state->curr_connp->hs_buffer == NULL) {
1816  return -1;
1817  }
1818  ssl_state->curr_connp->hs_buffer_size = size;
1819  ssl_state->curr_connp->hs_buffer_message_size = record_len;
1820  ssl_state->curr_connp->hs_buffer_message_type = ssl_state->curr_connp->handshake_type;
1821 
1822  if (input_len > 0) {
1823  if (SafeMemcpy(ssl_state->curr_connp->hs_buffer, 0,
1824  ssl_state->curr_connp->hs_buffer_size, input, 0, input_len,
1825  input_len) != 0) {
1826  return -1;
1827  }
1828  ssl_state->curr_connp->hs_buffer_offset = input_len;
1829  }
1830  SCLogDebug("opened record buffer %p size %u offset %u type %u msg_size %u",
1831  ssl_state->curr_connp->hs_buffer, ssl_state->curr_connp->hs_buffer_size,
1832  ssl_state->curr_connp->hs_buffer_offset,
1833  ssl_state->curr_connp->hs_buffer_message_type,
1834  ssl_state->curr_connp->hs_buffer_message_size);
1835  input += input_len;
1836  SSLParserHSReset(ssl_state->curr_connp);
1837  return (int)(input - initial_input);
1838 
1839  } else {
1840  /* full record, parse it now */
1841  int retval = SSLv3ParseHandshakeType(
1842  ssl_state, input, ssl_state->curr_connp->message_length, direction);
1843  if (retval < 0 || retval > (int)input_len) {
1844  DEBUG_VALIDATE_BUG_ON(retval > (int)input_len);
1845  return (retval);
1846  }
1847  SCLogDebug("retval %d input_len %u", retval, input_len);
1848  input += retval;
1849  input_len -= retval;
1850 
1851  SSLParserHSReset(ssl_state->curr_connp);
1852  }
1853  SCLogDebug("input_len left %u", input_len);
1854  }
1855  return (int)(input - initial_input);
1856 }
1857 
1858 /**
1859  * \internal
1860  * \brief TLS Alert parser
1861  *
1862  * \param sslstate Pointer to the SSL state.
1863  * \param input Pointer to the received input data.
1864  * \param input_len Length in bytes of the received data.
1865  * \param direction 1 toclient, 0 toserver
1866  *
1867  * \retval The number of bytes parsed on success, 0 if nothing parsed, -1 on failure.
1868  */
1869 static int SSLv3ParseAlertProtocol(
1870  SSLState *ssl_state, const uint8_t *input, uint32_t input_len, uint8_t direction)
1871 {
1872  if (input_len < 2) {
1873  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_ALERT);
1874  return -1;
1875  }
1876 
1877  /* assume a record > 2 to be an encrypted alert record */
1878  if (input_len == 2) {
1879  uint8_t level = input[0];
1880  // uint8_t desc = input[1];
1881 
1882  /* if level Fatal, we consider the tx finished */
1883  if (level == 2) {
1884  UpdateClientState(ssl_state, TLS_STATE_CLIENT_FINISHED);
1885  UpdateServerState(ssl_state, TLS_STATE_SERVER_FINISHED);
1886  }
1887  }
1888  return 0;
1889 }
1890 
1891 /**
1892  * \internal
1893  * \brief TLS Heartbeat parser (see RFC 6520)
1894  *
1895  * \param sslstate Pointer to the SSL state.
1896  * \param input Pointer to the received input data.
1897  * \param input_len Length in bytes of the received data.
1898  * \param direction 1 toclient, 0 toserver
1899  *
1900  * \retval The number of bytes parsed on success, 0 if nothing parsed, -1 on failure.
1901  */
1902 static int SSLv3ParseHeartbeatProtocol(SSLState *ssl_state, const uint8_t *input,
1903  uint32_t input_len, uint8_t direction)
1904 {
1905  uint8_t hb_type;
1906  uint16_t payload_len;
1907  uint32_t padding_len;
1908 
1909  /* expect at least 3 bytes: heartbeat type (1) + length (2) */
1910  if (input_len < 3) {
1911  return 0;
1912  }
1913 
1914  hb_type = *input++;
1915 
1916  if (!(ssl_state->flags & SSL_AL_FLAG_CHANGE_CIPHER_SPEC)) {
1917  if (!(hb_type == TLS_HB_REQUEST || hb_type == TLS_HB_RESPONSE)) {
1918  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_HEARTBEAT);
1919  return -1;
1920  }
1921  }
1922 
1923  if ((ssl_state->flags & SSL_AL_FLAG_HB_INFLIGHT) == 0) {
1924  ssl_state->flags |= SSL_AL_FLAG_HB_INFLIGHT;
1925 
1926  if (direction) {
1927  SCLogDebug("HeartBeat Record type sent in the toclient direction!");
1928  ssl_state->flags |= SSL_AL_FLAG_HB_SERVER_INIT;
1929  } else {
1930  SCLogDebug("HeartBeat Record type sent in the toserver direction!");
1931  ssl_state->flags |= SSL_AL_FLAG_HB_CLIENT_INIT;
1932  }
1933 
1934  /* if we reach this point, then we can assume that the HB request
1935  is encrypted. If so, let's set the HB record length */
1936  if (ssl_state->flags & SSL_AL_FLAG_CHANGE_CIPHER_SPEC) {
1937  ssl_state->hb_record_len = ssl_state->curr_connp->record_length;
1938  SCLogDebug("Encrypted HeartBeat Request In-flight. Storing len %u",
1939  ssl_state->hb_record_len);
1940  return (ssl_state->curr_connp->record_length - 3);
1941  }
1942 
1943  payload_len = (uint16_t)(*input << 8) | *(input + 1);
1944 
1945  /* check that the requested payload length is really present in
1946  the record (CVE-2014-0160) */
1947  if ((uint32_t)(payload_len+3) > ssl_state->curr_connp->record_length) {
1948  SCLogDebug("We have a short record in HeartBeat Request");
1949  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_OVERFLOW_HEARTBEAT);
1950  return -1;
1951  }
1952 
1953  /* check the padding length. It must be at least 16 bytes
1954  (RFC 6520, section 4) */
1955  padding_len = ssl_state->curr_connp->record_length - payload_len - 3;
1956  if (padding_len < 16) {
1957  SCLogDebug("We have a short record in HeartBeat Request");
1958  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_HEARTBEAT);
1959  return -1;
1960  }
1961 
1962  /* we don't have the payload */
1963  if (input_len < payload_len + padding_len) {
1964  return 0;
1965  }
1966 
1967  /* OpenSSL still seems to discard multiple in-flight
1968  heartbeats although some tools send multiple at once */
1969  } else if (direction == 1 && (ssl_state->flags & SSL_AL_FLAG_HB_INFLIGHT) &&
1970  (ssl_state->flags & SSL_AL_FLAG_HB_SERVER_INIT)) {
1971  SCLogDebug("Multiple in-flight server initiated HeartBeats");
1972  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_HEARTBEAT);
1973  return -1;
1974 
1975  } else if (direction == 0 && (ssl_state->flags & SSL_AL_FLAG_HB_INFLIGHT) &&
1976  (ssl_state->flags & SSL_AL_FLAG_HB_CLIENT_INIT)) {
1977  SCLogDebug("Multiple in-flight client initiated HeartBeats");
1978  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_HEARTBEAT);
1979  return -1;
1980 
1981  } else {
1982  /* we have a HB record in the opposite direction of the request,
1983  let's reset our flags */
1984  ssl_state->flags &= ~SSL_AL_FLAG_HB_INFLIGHT;
1985  ssl_state->flags &= ~SSL_AL_FLAG_HB_SERVER_INIT;
1986  ssl_state->flags &= ~SSL_AL_FLAG_HB_CLIENT_INIT;
1987 
1988  /* if we reach this point, then we can assume that the HB request
1989  is encrypted. If so, let's set the HB record length */
1990  if (ssl_state->flags & SSL_AL_FLAG_CHANGE_CIPHER_SPEC) {
1991  /* check to see if the encrypted response is longer than the
1992  encrypted request */
1993  if (ssl_state->hb_record_len > 0 && ssl_state->hb_record_len <
1994  ssl_state->curr_connp->record_length) {
1995  SCLogDebug("My heart is bleeding.. OpenSSL HeartBleed response (%u)",
1996  ssl_state->hb_record_len);
1997  SSLSetEvent(ssl_state,
1998  TLS_DECODER_EVENT_DATALEAK_HEARTBEAT_MISMATCH);
1999  ssl_state->hb_record_len = 0;
2000  return -1;
2001  }
2002  }
2003 
2004  /* reset the HB record length in case we have a legit HB followed
2005  by a bad one */
2006  ssl_state->hb_record_len = 0;
2007  }
2008 
2009  /* skip the HeartBeat, 3 bytes were already parsed,
2010  e.g |18 03 02| for TLS 1.2 */
2011  return (ssl_state->curr_connp->record_length - 3);
2012 }
2013 
2014 static int SSLv3ParseRecord(uint8_t direction, SSLState *ssl_state,
2015  const uint8_t *input, uint32_t input_len)
2016 {
2017  const uint8_t *initial_input = input;
2018 
2019  if (input_len == 0) {
2020  return 0;
2021  }
2022 
2023  uint8_t skip_version = 0;
2024 
2025  /* Only set SSL/TLS version here if it has not already been set in
2026  client/server hello. */
2027  if (direction == 0) {
2028  if ((ssl_state->flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) &&
2029  (ssl_state->client_connp.version != TLS_VERSION_UNKNOWN)) {
2030  skip_version = 1;
2031  }
2032  } else {
2033  if ((ssl_state->flags & SSL_AL_FLAG_STATE_SERVER_HELLO) &&
2034  (ssl_state->server_connp.version != TLS_VERSION_UNKNOWN)) {
2035  skip_version = 1;
2036  }
2037  }
2038 
2039  switch (ssl_state->curr_connp->bytes_processed) {
2040  case 0:
2041  if (input_len >= 5) {
2042  ssl_state->curr_connp->content_type = input[0];
2043  if (!skip_version) {
2044  ssl_state->curr_connp->version = (uint16_t)(input[1] << 8) | input[2];
2045  }
2046  ssl_state->curr_connp->record_length = input[3] << 8;
2047  ssl_state->curr_connp->record_length |= input[4];
2048  ssl_state->curr_connp->bytes_processed += SSLV3_RECORD_HDR_LEN;
2049  return SSLV3_RECORD_HDR_LEN;
2050  } else {
2051  ssl_state->curr_connp->content_type = *(input++);
2052  if (--input_len == 0)
2053  break;
2054  }
2055 
2056  /* fall through */
2057  case 1:
2058  if (!skip_version) {
2059  ssl_state->curr_connp->version = (uint16_t)(*(input++) << 8);
2060  } else {
2061  input++;
2062  }
2063  if (--input_len == 0)
2064  break;
2065 
2066  /* fall through */
2067  case 2:
2068  if (!skip_version) {
2069  ssl_state->curr_connp->version |= *(input++);
2070  } else {
2071  input++;
2072  }
2073  if (--input_len == 0)
2074  break;
2075 
2076  /* fall through */
2077  case 3:
2078  ssl_state->curr_connp->record_length = *(input++) << 8;
2079  if (--input_len == 0)
2080  break;
2081 
2082  /* fall through */
2083  case 4:
2084  ssl_state->curr_connp->record_length |= *(input++);
2085  if (--input_len == 0)
2086  break;
2087 
2088  /* fall through */
2089  }
2090 
2091  ssl_state->curr_connp->bytes_processed += (input - initial_input);
2092 
2093  return (int)(input - initial_input);
2094 }
2095 
2096 static int SSLv2ParseRecord(uint8_t direction, SSLState *ssl_state,
2097  const uint8_t *input, uint32_t input_len)
2098 {
2099  const uint8_t *initial_input = input;
2100 
2101  if (input_len == 0) {
2102  return 0;
2103  }
2104 
2105  if (ssl_state->curr_connp->record_lengths_length == 2) {
2106  switch (ssl_state->curr_connp->bytes_processed) {
2107  case 0:
2108  if (input_len >= ssl_state->curr_connp->record_lengths_length + 1) {
2109  ssl_state->curr_connp->record_length = (0x7f & input[0]) << 8 | input[1];
2110  ssl_state->curr_connp->content_type = input[2];
2111  ssl_state->curr_connp->version = SSL_VERSION_2;
2112  ssl_state->curr_connp->bytes_processed += 3;
2113  return 3;
2114  } else {
2115  ssl_state->curr_connp->record_length = (0x7f & *(input++)) << 8;
2116  if (--input_len == 0)
2117  break;
2118  }
2119 
2120  /* fall through */
2121  case 1:
2122  ssl_state->curr_connp->record_length |= *(input++);
2123  if (--input_len == 0)
2124  break;
2125 
2126  /* fall through */
2127  case 2:
2128  ssl_state->curr_connp->content_type = *(input++);
2129  ssl_state->curr_connp->version = SSL_VERSION_2;
2130  if (--input_len == 0)
2131  break;
2132 
2133  /* fall through */
2134  }
2135 
2136  } else {
2137  switch (ssl_state->curr_connp->bytes_processed) {
2138  case 0:
2139  if (input_len >= ssl_state->curr_connp->record_lengths_length + 1) {
2140  ssl_state->curr_connp->record_length = (0x3f & input[0]) << 8 | input[1];
2141  ssl_state->curr_connp->content_type = input[3];
2142  ssl_state->curr_connp->version = SSL_VERSION_2;
2143  ssl_state->curr_connp->bytes_processed += 4;
2144  return 4;
2145  } else {
2146  ssl_state->curr_connp->record_length = (0x3f & *(input++)) << 8;
2147  if (--input_len == 0)
2148  break;
2149  }
2150 
2151  /* fall through */
2152  case 1:
2153  ssl_state->curr_connp->record_length |= *(input++);
2154  if (--input_len == 0)
2155  break;
2156 
2157  /* fall through */
2158  case 2:
2159  /* padding */
2160  input++;
2161  if (--input_len == 0)
2162  break;
2163 
2164  /* fall through */
2165  case 3:
2166  ssl_state->curr_connp->content_type = *(input++);
2167  ssl_state->curr_connp->version = SSL_VERSION_2;
2168  if (--input_len == 0)
2169  break;
2170 
2171  /* fall through */
2172  }
2173  }
2174 
2175  ssl_state->curr_connp->bytes_processed += (input - initial_input);
2176 
2177  return (int)(input - initial_input);
2178 }
2179 
2180 static struct SSLDecoderResult SSLv2Decode(uint8_t direction, SSLState *ssl_state,
2181  AppLayerParserState *pstate, const uint8_t *input, uint32_t input_len,
2182  const StreamSlice stream_slice)
2183 {
2184  const uint8_t *initial_input = input;
2185 
2186  if (ssl_state->curr_connp->bytes_processed == 0) {
2187  if (input[0] & 0x80) {
2188  ssl_state->curr_connp->record_lengths_length = 2;
2189  } else {
2190  ssl_state->curr_connp->record_lengths_length = 3;
2191  }
2192 
2193  SCLogDebug("record start: ssl2.hdr frame");
2194  AppLayerFrameNewByPointer(ssl_state->f, &stream_slice, input,
2195  ssl_state->curr_connp->record_lengths_length + 1, direction, TLS_FRAME_SSLV2_HDR);
2196  }
2197 
2198  SCLogDebug("direction %u ssl_state->curr_connp->record_lengths_length + 1 %u, "
2199  "ssl_state->curr_connp->bytes_processed %u",
2200  direction, ssl_state->curr_connp->record_lengths_length + 1,
2201  ssl_state->curr_connp->bytes_processed);
2202  /* the +1 is because we read one extra byte inside SSLv2ParseRecord
2203  to read the msg_type */
2204  if (ssl_state->curr_connp->bytes_processed <
2205  (ssl_state->curr_connp->record_lengths_length + 1)) {
2206  const int retval = SSLv2ParseRecord(direction, ssl_state, input, input_len);
2207  SCLogDebug("retval %d ssl_state->curr_connp->record_length %u", retval,
2208  ssl_state->curr_connp->record_length);
2209  if (retval < 0 || retval > (int)input_len) {
2210  DEBUG_VALIDATE_BUG_ON(retval > (int)input_len);
2211  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_SSLV2_HEADER);
2212  return SSL_DECODER_ERROR(-1);
2213  }
2214 
2215  AppLayerFrameNewByPointer(ssl_state->f, &stream_slice, input,
2216  ssl_state->curr_connp->record_lengths_length + ssl_state->curr_connp->record_length,
2217  direction, TLS_FRAME_SSLV2_PDU);
2218  SCLogDebug("record start: ssl2.pdu frame");
2219 
2220  input += retval;
2221  input_len -= retval;
2222  }
2223 
2224  /* if we don't have the full record, we return incomplete */
2225  if (ssl_state->curr_connp->record_lengths_length + ssl_state->curr_connp->record_length >
2226  input_len + ssl_state->curr_connp->bytes_processed) {
2227  uint32_t needed = ssl_state->curr_connp->record_length;
2228  SCLogDebug("record len %u input_len %u parsed %u: need %u bytes more data",
2229  ssl_state->curr_connp->record_length, input_len, (uint32_t)(input - initial_input),
2230  needed);
2231  return SSL_DECODER_INCOMPLETE((input - initial_input), needed);
2232  }
2233 
2234  if (input_len == 0) {
2235  return SSL_DECODER_OK((input - initial_input));
2236  }
2237 
2238  /* record_length should never be zero */
2239  if (ssl_state->curr_connp->record_length == 0) {
2240  SCLogDebug("SSLv2 record length is zero");
2241  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_SSLV2_HEADER);
2242  return SSL_DECODER_ERROR(-1);
2243  }
2244 
2245  /* record_lengths_length should never be zero */
2246  if (ssl_state->curr_connp->record_lengths_length == 0) {
2247  SCLogDebug("SSLv2 record lengths length is zero");
2248  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_SSLV2_HEADER);
2249  return SSL_DECODER_ERROR(-1);
2250  }
2251 
2252  switch (ssl_state->curr_connp->content_type) {
2253  case SSLV2_MT_ERROR:
2254  SCLogDebug("SSLV2_MT_ERROR msg_type received. Error encountered "
2255  "in establishing the sslv2 session, may be version");
2256  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_ERROR_MSG_ENCOUNTERED);
2257 
2258  break;
2259 
2260  case SSLV2_MT_CLIENT_HELLO:
2261  /* record_length does not count the msg_type byte. CLIENT_HELLO
2262  * body starts with 3 fixed fields: client_version (2) +
2263  * cipher_spec_length (2) + session_id_length (2). We need at
2264  * least those 6 bytes after the msg_type, so record_length
2265  * must be >= 7. */
2266  if (input_len < 6 || ssl_state->curr_connp->record_length < 7) {
2267  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_SSL_RECORD);
2268  return SSL_DECODER_ERROR(-1);
2269  }
2270 
2271  ssl_state->current_flags = SSL_AL_FLAG_STATE_CLIENT_HELLO;
2272  ssl_state->current_flags |= SSL_AL_FLAG_SSL_CLIENT_HS;
2273  UpdateClientState(ssl_state, TLS_STATE_CLIENT_HELLO_DONE);
2274 
2275  const uint16_t version = (uint16_t)(input[0] << 8) | input[1];
2276  SCLogDebug("SSLv2: version %04x", version);
2277  ssl_state->curr_connp->version = version;
2278  uint16_t session_id_length = (input[5]) | (uint16_t)(input[4] << 8);
2279  input += 6;
2280  input_len -= 6;
2281  ssl_state->curr_connp->bytes_processed += 6;
2282  if (session_id_length == 0) {
2283  ssl_state->current_flags |= SSL_AL_FLAG_SSL_NO_SESSION_ID;
2284  }
2285  break;
2286 
2287  case SSLV2_MT_CLIENT_MASTER_KEY:
2288  if (!(ssl_state->flags & SSL_AL_FLAG_SSL_CLIENT_HS)) {
2289  SCLogDebug("Client hello is not seen before master key "
2290  "message!");
2291  }
2292  ssl_state->current_flags = SSL_AL_FLAG_SSL_CLIENT_MASTER_KEY;
2293 
2294  break;
2295 
2296  case SSLV2_MT_CLIENT_CERTIFICATE:
2297  if (direction == 1) {
2298  SCLogDebug("Incorrect SSL Record type sent in the toclient "
2299  "direction!");
2300  } else {
2301  ssl_state->current_flags = SSL_AL_FLAG_STATE_CLIENT_KEYX;
2302  }
2303  UpdateServerState(ssl_state, TLS_STATE_SERVER_CERT_DONE);
2304 
2305  /* fall through */
2306  case SSLV2_MT_SERVER_VERIFY:
2307  case SSLV2_MT_SERVER_FINISHED:
2308  if (direction == 0 &&
2309  !(ssl_state->curr_connp->content_type &
2310  SSLV2_MT_CLIENT_CERTIFICATE)) {
2311  SCLogDebug("Incorrect SSL Record type sent in the toserver "
2312  "direction!");
2313  }
2314 
2315  /* fall through */
2316  case SSLV2_MT_CLIENT_FINISHED:
2317  case SSLV2_MT_REQUEST_CERTIFICATE:
2318  /* both client hello and server hello must be seen */
2319  if ((ssl_state->flags & SSL_AL_FLAG_SSL_CLIENT_HS) &&
2320  (ssl_state->flags & SSL_AL_FLAG_SSL_SERVER_HS)) {
2321 
2322  if (direction == 0) {
2323  if (ssl_state->flags & SSL_AL_FLAG_SSL_NO_SESSION_ID) {
2324  ssl_state->current_flags |= SSL_AL_FLAG_SSL_CLIENT_SSN_ENCRYPTED;
2325  SCLogDebug("SSLv2 client side has started the encryption");
2326  } else if (ssl_state->flags & SSL_AL_FLAG_SSL_CLIENT_MASTER_KEY) {
2327  ssl_state->current_flags = SSL_AL_FLAG_SSL_CLIENT_SSN_ENCRYPTED;
2328  SCLogDebug("SSLv2 client side has started the encryption");
2329  }
2330  } else {
2331  ssl_state->current_flags = SSL_AL_FLAG_SSL_SERVER_SSN_ENCRYPTED;
2332  SCLogDebug("SSLv2 Server side has started the encryption");
2333  }
2334 
2335  if ((ssl_state->flags & SSL_AL_FLAG_SSL_CLIENT_SSN_ENCRYPTED) &&
2336  (ssl_state->flags & SSL_AL_FLAG_SSL_SERVER_SSN_ENCRYPTED))
2337  {
2338  if (ssl_config.encrypt_mode != SSL_CNF_ENC_HANDLE_FULL) {
2339  SCAppLayerParserStateSetFlag(pstate, APP_LAYER_PARSER_NO_INSPECTION);
2340  }
2341 
2342  if (ssl_config.encrypt_mode == SSL_CNF_ENC_HANDLE_BYPASS) {
2343  SCAppLayerParserStateSetFlag(pstate, APP_LAYER_PARSER_NO_REASSEMBLY);
2344  SCAppLayerParserStateSetFlag(pstate, APP_LAYER_PARSER_BYPASS_READY);
2345  }
2346  SCLogDebug("SSLv2 No reassembly & inspection has been set");
2347  }
2348  }
2349 
2350  break;
2351 
2352  case SSLV2_MT_SERVER_HELLO:
2353  ssl_state->current_flags = SSL_AL_FLAG_STATE_SERVER_HELLO;
2354  ssl_state->current_flags |= SSL_AL_FLAG_SSL_SERVER_HS;
2355  UpdateServerState(ssl_state, TLS_STATE_SERVER_HELLO);
2356 
2357  break;
2358  }
2359 
2360  ssl_state->flags |= ssl_state->current_flags;
2361 
2362  if (ssl_state->curr_connp->bytes_processed >
2363  ssl_state->curr_connp->record_length + ssl_state->curr_connp->record_lengths_length) {
2364  SCLogDebug("SSLv2 bytes_processed (%u) exceeds record+hdr "
2365  "len (record_length=%u, lengths_length=%u)",
2366  ssl_state->curr_connp->bytes_processed, ssl_state->curr_connp->record_length,
2367  ssl_state->curr_connp->record_lengths_length);
2368  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_SSL_RECORD);
2369  return SSL_DECODER_ERROR(-1);
2370  }
2371 
2372  if (input_len + ssl_state->curr_connp->bytes_processed >=
2373  (ssl_state->curr_connp->record_length +
2374  ssl_state->curr_connp->record_lengths_length)) {
2375 
2376  /* looks like we have another record after this */
2377  uint32_t diff = ssl_state->curr_connp->record_length +
2378  ssl_state->curr_connp->record_lengths_length + -
2379  ssl_state->curr_connp->bytes_processed;
2380  input += diff;
2381  SSLParserReset(ssl_state);
2382 
2383  /* we still don't have the entire record for the one we are
2384  currently parsing */
2385  } else {
2386  input += input_len;
2387  ssl_state->curr_connp->bytes_processed += input_len;
2388  }
2389  return SSL_DECODER_OK((input - initial_input));
2390 }
2391 
2392 static struct SSLDecoderResult SSLv3Decode(uint8_t direction, SSLState *ssl_state,
2393  AppLayerParserState *pstate, const uint8_t *input, const uint32_t input_len,
2394  const StreamSlice stream_slice)
2395 {
2396  uint32_t parsed = 0;
2397  uint32_t record_len; /* slice of input_len for the current record */
2398  const bool first_call = (ssl_state->curr_connp->bytes_processed == 0);
2399 
2400  if (ssl_state->curr_connp->bytes_processed < SSLV3_RECORD_HDR_LEN) {
2401  const uint16_t prev_version = ssl_state->curr_connp->version;
2402 
2403  int retval = SSLv3ParseRecord(direction, ssl_state, input, input_len);
2404  if (retval < 0 || retval > (int)input_len) {
2405  DEBUG_VALIDATE_BUG_ON(retval > (int)input_len);
2406  SCLogDebug("SSLv3ParseRecord returned %d", retval);
2407  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_TLS_HEADER);
2408  return SSL_DECODER_ERROR(-1);
2409  }
2410  parsed = retval;
2411 
2412  SCLogDebug("%s input %p record_length %u", (direction == 0) ? "toserver" : "toclient",
2413  input, ssl_state->curr_connp->record_length);
2414 
2415  /* first the hdr frame at our first chance */
2416  if (first_call) {
2417  AppLayerFrameNewByPointer(ssl_state->f, &stream_slice, input, SSLV3_RECORD_HDR_LEN,
2418  direction, TLS_FRAME_HDR);
2419  }
2420 
2421  /* parser is streaming for the initial header, then switches to incomplete
2422  * API: so if we don't have the hdr yet, return consumed bytes and wait
2423  * until we are called again with new data. */
2424  if (ssl_state->curr_connp->bytes_processed < SSLV3_RECORD_HDR_LEN) {
2425  SCLogDebug(
2426  "incomplete header, return %u bytes consumed and wait for more data", parsed);
2427  return SSL_DECODER_OK(parsed);
2428  }
2429 
2430  /* pdu frame needs record length, so only create it when hdr fully parsed. */
2431  AppLayerFrameNewByPointer(ssl_state->f, &stream_slice, input,
2432  ssl_state->curr_connp->record_length + retval, direction, TLS_FRAME_PDU);
2433  record_len = MIN(input_len - parsed, ssl_state->curr_connp->record_length);
2434  SCLogDebug(
2435  "record_len %u (input_len %u, parsed %u, ssl_state->curr_connp->record_length %u)",
2436  record_len, input_len, parsed, ssl_state->curr_connp->record_length);
2437 
2438  bool unknown_record = false;
2439  switch (ssl_state->curr_connp->content_type) {
2440  case SSLV3_CHANGE_CIPHER_SPEC:
2441  case SSLV3_ALERT_PROTOCOL:
2442  case SSLV3_HANDSHAKE_PROTOCOL:
2443  case SSLV3_APPLICATION_PROTOCOL:
2444  case SSLV3_HEARTBEAT_PROTOCOL:
2445  break;
2446  default:
2447  unknown_record = true;
2448  break;
2449  }
2450 
2451  /* unknown record type. For TLS 1.0, 1.1 and 1.2 this is ok. For the rest it is fatal. Based
2452  * on Wireshark logic. */
2453  if (prev_version == TLS_VERSION_10 || prev_version == TLS_VERSION_11) {
2454  if (unknown_record) {
2455  SCLogDebug("unknown record, ignore it");
2456  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_RECORD_TYPE);
2457 
2458  ssl_state->curr_connp->bytes_processed = 0; // TODO review this reset logic
2459  ssl_state->curr_connp->content_type = 0;
2460  ssl_state->curr_connp->record_length = 0;
2461  // restore last good version
2462  ssl_state->curr_connp->version = prev_version;
2463  return SSL_DECODER_OK(input_len); // consume everything
2464  }
2465  } else {
2466  if (unknown_record) {
2467  SCLogDebug("unknown record, fatal");
2468  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_RECORD_TYPE);
2469  return SSL_DECODER_ERROR(-1);
2470  }
2471  }
2472 
2473  /* record_length should never be zero */
2474  if (ssl_state->curr_connp->record_length == 0) {
2475  SCLogDebug("SSLv3 Record length is 0");
2476  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_RECORD_LENGTH);
2477  return SSL_DECODER_ERROR(-1);
2478  }
2479 
2480  if (!TLSVersionValid(ssl_state->curr_connp->version)) {
2481  SCLogDebug("ssl_state->curr_connp->version %04x", ssl_state->curr_connp->version);
2482  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_RECORD_VERSION);
2483  return SSL_DECODER_ERROR(-1);
2484  }
2485 
2486  if (ssl_state->curr_connp->bytes_processed == SSLV3_RECORD_HDR_LEN &&
2487  ssl_state->curr_connp->record_length > SSLV3_RECORD_MAX_LEN) {
2488  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_RECORD_LENGTH);
2489  return SSL_DECODER_ERROR(-1);
2490  }
2491  DEBUG_VALIDATE_BUG_ON(ssl_state->curr_connp->bytes_processed > SSLV3_RECORD_HDR_LEN);
2492  } else {
2493  ValidateRecordState(ssl_state->curr_connp);
2494 
2495  record_len = (ssl_state->curr_connp->record_length + SSLV3_RECORD_HDR_LEN)- ssl_state->curr_connp->bytes_processed;
2496  record_len = MIN(input_len, record_len);
2497  }
2498  SCLogDebug("record length %u processed %u got %u",
2499  ssl_state->curr_connp->record_length, ssl_state->curr_connp->bytes_processed, record_len);
2500 
2501  /* if we don't have the full record, we return incomplete */
2502  if (ssl_state->curr_connp->record_length > input_len - parsed) {
2503  /* no need to use incomplete api buffering for application
2504  * records that we'll not use anyway. */
2505  if (ssl_state->curr_connp->content_type == SSLV3_APPLICATION_PROTOCOL) {
2506  SCLogDebug("application record");
2507  } else {
2508  uint32_t needed = ssl_state->curr_connp->record_length;
2509  SCLogDebug("record len %u input_len %u parsed %u: need %u bytes more data",
2510  ssl_state->curr_connp->record_length, input_len, parsed, needed);
2511  DEBUG_VALIDATE_BUG_ON(needed > SSLV3_RECORD_MAX_LEN);
2512  return SSL_DECODER_INCOMPLETE(parsed, needed);
2513  }
2514  }
2515 
2516  if (record_len == 0) {
2517  return SSL_DECODER_OK(parsed);
2518  }
2519 
2520  AppLayerFrameNewByPointer(ssl_state->f, &stream_slice, input + parsed,
2521  ssl_state->curr_connp->record_length, direction, TLS_FRAME_DATA);
2522 
2523  switch (ssl_state->curr_connp->content_type) {
2524  /* we don't need any data from these types */
2525  case SSLV3_CHANGE_CIPHER_SPEC:
2526  ssl_state->flags |= SSL_AL_FLAG_CHANGE_CIPHER_SPEC;
2527 
2528  if (direction) {
2529  ssl_state->flags |= SSL_AL_FLAG_SERVER_CHANGE_CIPHER_SPEC;
2530  } else {
2531  ssl_state->flags |= SSL_AL_FLAG_CLIENT_CHANGE_CIPHER_SPEC;
2532 
2533  // TODO TLS 1.3
2534  UpdateClientState(ssl_state, TLS_STATE_CLIENT_HANDSHAKE_DONE);
2535  }
2536  break;
2537 
2538  case SSLV3_ALERT_PROTOCOL: {
2539  AppLayerFrameNewByPointer(ssl_state->f, &stream_slice, input + parsed,
2540  ssl_state->curr_connp->record_length, direction, TLS_FRAME_ALERT_DATA);
2541 
2542  int retval = SSLv3ParseAlertProtocol(ssl_state, input + parsed, record_len, direction);
2543  if (retval < 0) {
2544  SCLogDebug("SSLv3ParseAlertProtocol returned %d", retval);
2545  return SSL_DECODER_ERROR(-1);
2546  }
2547  break;
2548  }
2549  case SSLV3_APPLICATION_PROTOCOL:
2550  /* In TLSv1.3 early data (0-RTT) could be sent before the
2551  handshake is complete (rfc8446, section 2.3). We should
2552  therefore not mark the handshake as done before we have
2553  seen the ServerHello record. */
2554  if ((ssl_state->flags & SSL_AL_FLAG_EARLY_DATA) &&
2555  ((ssl_state->flags & SSL_AL_FLAG_STATE_SERVER_HELLO) == 0))
2556  break;
2557 
2558  /* if we see (encrypted) application data, then this means the
2559  handshake must be done */
2560  if (ssl_state->curr_connp == &ssl_state->client_connp) {
2561  UpdateClientState(ssl_state, TLS_STATE_CLIENT_HANDSHAKE_DONE);
2562  } else {
2563  UpdateServerState(ssl_state, TLS_STATE_SERVER_HANDSHAKE_DONE);
2564  }
2565 
2566  if (ssl_config.encrypt_mode != SSL_CNF_ENC_HANDLE_FULL) {
2567  SCLogDebug("setting APP_LAYER_PARSER_NO_INSPECTION_PAYLOAD");
2568  SCAppLayerParserStateSetFlag(pstate, APP_LAYER_PARSER_NO_INSPECTION_PAYLOAD);
2569  }
2570 
2571  /* Encrypted data, reassembly not asked, bypass asked, let's sacrifice
2572  * heartbeat lke inspection to be able to be able to bypass the flow */
2573  if (ssl_config.encrypt_mode == SSL_CNF_ENC_HANDLE_BYPASS) {
2574  SCLogDebug("setting APP_LAYER_PARSER_NO_REASSEMBLY");
2575  SCAppLayerParserStateSetFlag(pstate, APP_LAYER_PARSER_NO_REASSEMBLY);
2576  SCAppLayerParserStateSetFlag(pstate, APP_LAYER_PARSER_NO_INSPECTION);
2577  SCAppLayerParserStateSetFlag(pstate, APP_LAYER_PARSER_BYPASS_READY);
2578  }
2579  break;
2580 
2581  case SSLV3_HANDSHAKE_PROTOCOL: {
2582  if (ssl_state->flags & SSL_AL_FLAG_CHANGE_CIPHER_SPEC) {
2583  /* In TLSv1.3, ChangeCipherSpec is only used for middlebox
2584  compatibility (rfc8446, appendix D.4). */
2585  // Client hello flags is needed to have a valid version
2586  if ((ssl_state->flags & SSL_AL_FLAG_STATE_CLIENT_HELLO) &&
2587  (ssl_state->client_connp.version > TLS_VERSION_12) &&
2588  ((ssl_state->flags & SSL_AL_FLAG_STATE_SERVER_HELLO) == 0)) {
2589  /* do nothing */
2590  } else {
2591  // if we started parsing this, we must stop
2592  break;
2593  }
2594  }
2595 
2596  if (ssl_state->curr_connp->record_length < 4) {
2597  SSLParserReset(ssl_state);
2598  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_SSL_RECORD);
2599  SCLogDebug("record len < 4 => %u", ssl_state->curr_connp->record_length);
2600  return SSL_DECODER_ERROR(-1);
2601  }
2602 
2603  int retval = SSLv3ParseHandshakeProtocol(ssl_state, input + parsed,
2604  record_len, direction);
2605  SCLogDebug("retval %d", retval);
2606  if (retval < 0 || retval > (int)record_len) {
2607  DEBUG_VALIDATE_BUG_ON(retval > (int)record_len);
2608  SSLSetEvent(ssl_state, TLS_DECODER_EVENT_INVALID_HANDSHAKE_MESSAGE);
2609  SCLogDebug("SSLv3ParseHandshakeProtocol returned %d", retval);
2610  return SSL_DECODER_ERROR(-1);
2611  }
2612  ValidateRecordState(ssl_state->curr_connp);
2613  break;
2614  }
2615  case SSLV3_HEARTBEAT_PROTOCOL: {
2616  AppLayerFrameNewByPointer(ssl_state->f, &stream_slice, input + parsed,
2617  ssl_state->curr_connp->record_length, direction, TLS_FRAME_HB_DATA);
2618  int retval = SSLv3ParseHeartbeatProtocol(ssl_state, input + parsed,
2619  record_len, direction);
2620  if (retval < 0) {
2621  SCLogDebug("SSLv3ParseHeartbeatProtocol returned %d", retval);
2622  return SSL_DECODER_ERROR(-1);
2623  }
2624  break;
2625  }
2626  default:
2627  // should be unreachable now that we check after header parsing
2628  DEBUG_VALIDATE_BUG_ON(1);
2629  SCLogDebug("unsupported record type");
2630  return SSL_DECODER_ERROR(-1);
2631  }
2632 
2633  parsed += record_len;
2634  ssl_state->curr_connp->bytes_processed += record_len;
2635 
2636  if (ssl_state->curr_connp->bytes_processed >=
2637  ssl_state->curr_connp->record_length + SSLV3_RECORD_HDR_LEN) {
2638  SCLogDebug("record complete, trigger RAW");
2639  SCAppLayerParserTriggerRawStreamInspection(
2640  ssl_state->f, direction == 0 ? STREAM_TOSERVER : STREAM_TOCLIENT);
2641  SSLParserReset(ssl_state);
2642  ValidateRecordState(ssl_state->curr_connp);
2643  return SSL_DECODER_OK(parsed);
2644 
2645  } else {
2646  /* we still don't have the entire record for the one we are
2647  currently parsing */
2648  ValidateRecordState(ssl_state->curr_connp);
2649  return SSL_DECODER_OK(parsed);
2650  }
2651 }
2652 
2653 /**
2654  * \internal
2655  * \brief SSLv2, SSLv23, SSLv3, TLSv1.1, TLSv1.2, TLSv1.3 parser.
2656  *
2657  * On parsing error, this should be the only function that should reset
2658  * the parser state, to avoid multiple functions in the chain resetting
2659  * the parser state.
2660  *
2661  * \param direction 0 for toserver, 1 for toclient.
2662  * \param alstate Pointer to the state.
2663  * \param pstate Application layer parser state for this session.
2664  * \param output Pointer to the list of parsed output elements.
2665  *
2666  * \todo On reaching an inconsistent state, check if the input has
2667  * another new record, instead of just returning after the reset
2668  *
2669  * \retval >=0 On success.
2670  */
2671 static AppLayerResult SSLDecode(Flow *f, uint8_t direction, void *alstate,
2672  AppLayerParserState *pstate, StreamSlice stream_slice)
2673 {
2674  SSLState *ssl_state = (SSLState *)alstate;
2675  ssl_state->tx_data.updated_tc = true;
2676  ssl_state->tx_data.updated_ts = true;
2677  uint32_t counter = 0;
2678  ssl_state->f = f;
2679  const uint8_t *input = StreamSliceGetData(&stream_slice);
2680  const uint8_t *init_input = input;
2681  int32_t input_len = (int32_t)StreamSliceGetDataLen(&stream_slice);
2682 
2683  if ((input == NULL || input_len == 0) &&
2684  ((direction == 0 && SCAppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TS)) ||
2685  (direction == 1 &&
2686  SCAppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TC)))) {
2687  /* flag session as finished if APP_LAYER_PARSER_EOF is set */
2688  if (direction == 0)
2689  UpdateClientState(ssl_state, TLS_STATE_CLIENT_FINISHED);
2690  else
2691  UpdateServerState(ssl_state, TLS_STATE_SERVER_FINISHED);
2692  SCReturnStruct(APP_LAYER_OK);
2693  } else if (input == NULL || input_len == 0) {
2694  SCReturnStruct(APP_LAYER_ERROR);
2695  }
2696 
2697  if (direction == 0)
2698  ssl_state->curr_connp = &ssl_state->client_connp;
2699  else
2700  ssl_state->curr_connp = &ssl_state->server_connp;
2701 
2702  /* If entering on a new record, reset the current flags. */
2703  if (ssl_state->curr_connp->bytes_processed == 0) {
2704  ssl_state->current_flags = 0;
2705  }
2706 
2707  /* if we have more than one record */
2708  uint32_t max_records = MAX((input_len / SSL_RECORD_MINIMUM_LENGTH),1);
2709  while (input_len > 0) {
2710  if (counter > max_records) {
2711  SCLogDebug("Looks like we have looped quite a bit. Reset state "
2712  "and get out of here");
2713  SSLParserReset(ssl_state);
2714  SSLSetEvent(ssl_state,
2715  TLS_DECODER_EVENT_TOO_MANY_RECORDS_IN_PACKET);
2716  return APP_LAYER_ERROR;
2717  }
2718 
2719  /* ssl_state->bytes_processed is zero for a fresh record or
2720  positive to indicate a record currently being parsed */
2721 
2722  if (ssl_state->curr_connp->bytes_processed == 0) {
2723  if ((input[0] & 0x80) || (input[0] & 0x40)) {
2724  /* only SSLv2, has one of the top 2 bits set */
2725  ssl_state->curr_connp->version = SSL_VERSION_2;
2726  SCLogDebug("SSLv2 detected");
2727  } else if (ssl_state->curr_connp->version == SSL_VERSION_2) {
2728  ssl_state->curr_connp->version = TLS_VERSION_UNKNOWN;
2729  SCLogDebug("SSL/TLS version reset");
2730  }
2731  }
2732  SCLogDebug("record %u: bytes_processed %u, version %02X, input_len %u", counter,
2733  ssl_state->curr_connp->bytes_processed, ssl_state->curr_connp->version, input_len);
2734 
2735  if (ssl_state->curr_connp->version == SSL_VERSION_2) {
2736  if (ssl_state->curr_connp->bytes_processed == 0) {
2737  SCLogDebug("New SSLv2 record parsing");
2738  } else {
2739  SCLogDebug("Continuing parsing SSLv2 record");
2740  }
2741  struct SSLDecoderResult r =
2742  SSLv2Decode(direction, ssl_state, pstate, input, input_len, stream_slice);
2743  if (r.retval < 0 || r.retval > input_len) {
2744  DEBUG_VALIDATE_BUG_ON(r.retval > input_len);
2745  SCLogDebug("Error parsing SSLv2. Resetting parser "
2746  "state. Let's get outta here");
2747  SSLParserReset(ssl_state);
2748  SSLSetEvent(ssl_state,
2749  TLS_DECODER_EVENT_INVALID_SSL_RECORD);
2750  return APP_LAYER_ERROR;
2751  } else if (r.needed) {
2752  input += r.retval;
2753  SCLogDebug("returning consumed %" PRIuMAX " needed %u",
2754  (uintmax_t)(input - init_input), r.needed);
2755  SCReturnStruct(APP_LAYER_INCOMPLETE((uint32_t)(input - init_input), r.needed));
2756  }
2757  input_len -= r.retval;
2758  input += r.retval;
2759  SCLogDebug("SSLv2 decoder consumed %d bytes: %u left", r.retval, input_len);
2760  } else {
2761  if (ssl_state->curr_connp->bytes_processed == 0) {
2762  SCLogDebug("New TLS record: record_length %u",
2763  ssl_state->curr_connp->record_length);
2764  } else {
2765  SCLogDebug("Continuing parsing TLS record: record_length %u, bytes_processed %u",
2766  ssl_state->curr_connp->record_length, ssl_state->curr_connp->bytes_processed);
2767  }
2768  struct SSLDecoderResult r =
2769  SSLv3Decode(direction, ssl_state, pstate, input, input_len, stream_slice);
2770  if (r.retval < 0 || r.retval > input_len) {
2771  DEBUG_VALIDATE_BUG_ON(r.retval > input_len);
2772  SCLogDebug("Error parsing TLS. Resetting parser "
2773  "state. Let's get outta here");
2774  SSLParserReset(ssl_state);
2775  return APP_LAYER_ERROR;
2776  } else if (r.needed) {
2777  input += r.retval;
2778  SCLogDebug("returning consumed %" PRIuMAX " needed %u",
2779  (uintmax_t)(input - init_input), r.needed);
2780  SCReturnStruct(APP_LAYER_INCOMPLETE((uint32_t)(input - init_input), r.needed));
2781  }
2782  input_len -= r.retval;
2783  input += r.retval;
2784  SCLogDebug("TLS decoder consumed %d bytes: %u left", r.retval, input_len);
2785 
2786  if (ssl_state->curr_connp->bytes_processed == SSLV3_RECORD_HDR_LEN
2787  && ssl_state->curr_connp->record_length == 0) {
2788  SCLogDebug("TLS empty record");
2789  /* empty record */
2790  SSLParserReset(ssl_state);
2791  }
2792  }
2793  counter++;
2794  } /* while (input_len) */
2795 
2796  /* mark handshake as done if we have subject and issuer */
2797  if ((ssl_state->flags & SSL_AL_FLAG_NEED_CLIENT_CERT) &&
2798  ssl_state->client_connp.cert0_subject && ssl_state->client_connp.cert0_issuerdn) {
2799  /* update both sides to keep existing behavior */
2800  UpdateClientState(ssl_state, TLS_STATE_CLIENT_HANDSHAKE_DONE);
2801  UpdateServerState(ssl_state, TLS_STATE_SERVER_HANDSHAKE_DONE);
2802  } else if ((ssl_state->flags & SSL_AL_FLAG_NEED_CLIENT_CERT) == 0 &&
2803  ssl_state->server_connp.cert0_subject && ssl_state->server_connp.cert0_issuerdn) {
2804  /* update both sides to keep existing behavior */
2805  UpdateClientState(ssl_state, TLS_STATE_CLIENT_HANDSHAKE_DONE);
2806  UpdateServerState(ssl_state, TLS_STATE_SERVER_HANDSHAKE_DONE);
2807  }
2808 
2809  /* flag session as finished if APP_LAYER_PARSER_EOF is set */
2810  if (SCAppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TS) &&
2811  SCAppLayerParserStateIssetFlag(pstate, APP_LAYER_PARSER_EOF_TC)) {
2812  /* update both sides to keep existing behavior */
2813  UpdateClientState(ssl_state, TLS_STATE_CLIENT_FINISHED);
2814  UpdateServerState(ssl_state, TLS_STATE_SERVER_FINISHED);
2815  }
2816 
2817  return APP_LAYER_OK;
2818 }
2819 
2820 static AppLayerResult SSLParseClientRecord(Flow *f, void *alstate, AppLayerParserState *pstate,
2821  StreamSlice stream_slice, void *local_data)
2822 {
2823  return SSLDecode(f, 0 /* toserver */, alstate, pstate, stream_slice);
2824 }
2825 
2826 static AppLayerResult SSLParseServerRecord(Flow *f, void *alstate, AppLayerParserState *pstate,
2827  StreamSlice stream_slice, void *local_data)
2828 {
2829  return SSLDecode(f, 1 /* toclient */, alstate, pstate, stream_slice);
2830 }
2831 
2832 /**
2833  * \internal
2834  * \brief Function to allocate the SSL state memory.
2835  */
2836 static void *SSLStateAlloc(void *orig_state, AppProto proto_orig)
2837 {
2838  SSLState *ssl_state = SCCalloc(1, sizeof(SSLState));
2839  if (unlikely(ssl_state == NULL))
2840  return NULL;
2841  TAILQ_INIT(&ssl_state->server_connp.certs);
2842  TAILQ_INIT(&ssl_state->client_connp.certs);
2843 
2844  return (void *)ssl_state;
2845 }
2846 
2847 static void SSLStateCertSANFree(SSLStateConnp *connp)
2848 {
2849  if (connp->cert0_sans) {
2850  for (uint16_t i = 0; i < connp->cert0_sans_num; i++) {
2851  SCX509ArrayFree(connp->cert0_sans[i].san, connp->cert0_sans[i].san_len);
2852  }
2853  SCFree(connp->cert0_sans);
2854  }
2855 }
2856 
2857 /**
2858  * \internal
2859  * \brief Function to free the SSL state memory.
2860  */
2861 static void SSLStateFree(void *p)
2862 {
2863  SSLState *ssl_state = (SSLState *)p;
2864  SSLCertsChain *item;
2865 
2866  if (ssl_state->client_connp.cert0_subject)
2867  SCX509ArrayFree(
2868  ssl_state->client_connp.cert0_subject, ssl_state->client_connp.cert0_subject_len);
2869  if (ssl_state->client_connp.cert0_issuerdn)
2870  SCX509ArrayFree(
2871  ssl_state->client_connp.cert0_issuerdn, ssl_state->client_connp.cert0_issuerdn_len);
2872  if (ssl_state->client_connp.cert0_serial)
2873  SCX509ArrayFree(
2874  ssl_state->client_connp.cert0_serial, ssl_state->client_connp.cert0_serial_len);
2875  if (ssl_state->client_connp.cert0_fingerprint)
2876  SCFree(ssl_state->client_connp.cert0_fingerprint);
2877  if (ssl_state->client_connp.sni)
2878  SCFree(ssl_state->client_connp.sni);
2879  if (ssl_state->client_connp.session_id)
2880  SCFree(ssl_state->client_connp.session_id);
2881  if (ssl_state->client_connp.hs_buffer)
2882  SCFree(ssl_state->client_connp.hs_buffer);
2883 
2884  if (ssl_state->server_connp.cert0_subject)
2885  SCX509ArrayFree(
2886  ssl_state->server_connp.cert0_subject, ssl_state->server_connp.cert0_subject_len);
2887  if (ssl_state->server_connp.cert0_issuerdn)
2888  SCX509ArrayFree(
2889  ssl_state->server_connp.cert0_issuerdn, ssl_state->server_connp.cert0_issuerdn_len);
2890  if (ssl_state->server_connp.cert0_serial)
2891  SCX509ArrayFree(
2892  ssl_state->server_connp.cert0_serial, ssl_state->server_connp.cert0_serial_len);
2893  if (ssl_state->server_connp.cert0_fingerprint)
2894  SCFree(ssl_state->server_connp.cert0_fingerprint);
2895  if (ssl_state->server_connp.sni)
2896  SCFree(ssl_state->server_connp.sni);
2897  if (ssl_state->server_connp.session_id)
2898  SCFree(ssl_state->server_connp.session_id);
2899 
2900  if (ssl_state->client_connp.hs)
2901  SCTLSHandshakeFree(ssl_state->client_connp.hs);
2902  if (ssl_state->client_connp.ja3_str)
2903  Ja3BufferFree(&ssl_state->client_connp.ja3_str);
2904  if (ssl_state->client_connp.ja3_hash)
2905  SCFree(ssl_state->client_connp.ja3_hash);
2906  if (ssl_state->server_connp.hs)
2907  SCTLSHandshakeFree(ssl_state->server_connp.hs);
2908  if (ssl_state->server_connp.ja3_str)
2909  Ja3BufferFree(&ssl_state->server_connp.ja3_str);
2910  if (ssl_state->server_connp.ja3_hash)
2911  SCFree(ssl_state->server_connp.ja3_hash);
2912  if (ssl_state->server_connp.hs_buffer)
2913  SCFree(ssl_state->server_connp.hs_buffer);
2914 
2915  SSLStateCertSANFree(&ssl_state->server_connp);
2916  SSLStateCertSANFree(&ssl_state->client_connp);
2917 
2918  SCAppLayerTxDataCleanup(&ssl_state->tx_data);
2919 
2920  /* Free certificate chain */
2921  if (ssl_state->server_connp.certs_buffer)
2922  SCFree(ssl_state->server_connp.certs_buffer);
2923  while ((item = TAILQ_FIRST(&ssl_state->server_connp.certs))) {
2924  TAILQ_REMOVE(&ssl_state->server_connp.certs, item, next);
2925  SCFree(item);
2926  }
2927  TAILQ_INIT(&ssl_state->server_connp.certs);
2928  /* Free certificate chain */
2929  if (ssl_state->client_connp.certs_buffer)
2930  SCFree(ssl_state->client_connp.certs_buffer);
2931  while ((item = TAILQ_FIRST(&ssl_state->client_connp.certs))) {
2932  TAILQ_REMOVE(&ssl_state->client_connp.certs, item, next);
2933  SCFree(item);
2934  }
2935  TAILQ_INIT(&ssl_state->client_connp.certs);
2936 
2937  SCFree(ssl_state);
2938 }
2939 
2940 static void SSLStateTransactionFree(void *state, uint64_t tx_id)
2941 {
2942  /* do nothing */
2943 }
2944 
2945 static AppProto SSLProbingParser(
2946  const Flow *f, uint8_t direction, const uint8_t *input, uint32_t ilen, uint8_t *rdir)
2947 {
2948  /* probably a rst/fin sending an eof */
2949  if (ilen < 3)
2950  return ALPROTO_UNKNOWN;
2951 
2952  /* for now just the 3 byte header ones */
2953  /* \todo Detect the 2 byte ones */
2954  if ((input[0] & 0x80) && (input[2] == 0x01)) {
2955  return ALPROTO_TLS;
2956  }
2957 
2958  return ALPROTO_FAILED;
2959 }
2960 
2961 static int SSLStateGetStateIdByName(const char *name, const uint8_t direction)
2962 {
2963  SCEnumCharMap *map =
2964  direction == STREAM_TOSERVER ? tls_state_client_table : tls_state_server_table;
2965 
2966  int id = SCMapEnumNameToValue(name, map);
2967  if (id < 0) {
2968  return -1;
2969  }
2970  return id;
2971 }
2972 
2973 static const char *SSLStateGetStateNameById(const int id, const uint8_t direction)
2974 {
2975  SCEnumCharMap *map =
2976  direction == STREAM_TOSERVER ? tls_state_client_table : tls_state_server_table;
2977  const char *name = SCMapEnumValueToName(id, map);
2978  return name;
2979 }
2980 
2981 static int SSLStateGetFrameIdByName(const char *frame_name)
2982 {
2983  int id = SCMapEnumNameToValue(frame_name, tls_frame_table);
2984  if (id < 0) {
2985  return -1;
2986  }
2987  return id;
2988 }
2989 
2990 static const char *SSLStateGetFrameNameById(const uint8_t frame_id)
2991 {
2992  const char *name = SCMapEnumValueToName(frame_id, tls_frame_table);
2993  return name;
2994 }
2995 
2996 static int SSLStateGetEventInfo(
2997  const char *event_name, uint8_t *event_id, AppLayerEventType *event_type)
2998 {
2999  if (SCAppLayerGetEventIdByName(event_name, tls_decoder_event_table, event_id) == 0) {
3000  *event_type = APP_LAYER_EVENT_TYPE_TRANSACTION;
3001  return 0;
3002  }
3003  return -1;
3004 }
3005 
3006 static int SSLStateGetEventInfoById(
3007  uint8_t event_id, const char **event_name, AppLayerEventType *event_type)
3008 {
3009  *event_name = SCMapEnumValueToName(event_id, tls_decoder_event_table);
3010  if (*event_name == NULL) {
3011  SCLogError("event \"%d\" not present in "
3012  "ssl's enum map table.",
3013  event_id);
3014  /* yes this is fatal */
3015  return -1;
3016  }
3017 
3018  *event_type = APP_LAYER_EVENT_TYPE_TRANSACTION;
3019 
3020  return 0;
3021 }
3022 
3023 static int SSLRegisterPatternsForProtocolDetection(void)
3024 {
3025  if (SCAppLayerProtoDetectPMRegisterPatternCSwPP(IPPROTO_TCP, ALPROTO_TLS, "|01 00 02|", 5, 2,
3026  STREAM_TOSERVER, SSLProbingParser, 0, 3) < 0) {
3027  return -1;
3028  }
3029 
3030  /** SSLv3 */
3031  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3032  IPPROTO_TCP, ALPROTO_TLS, "|01 03 00|", 3, 0, STREAM_TOSERVER) < 0) {
3033  return -1;
3034  }
3035  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3036  IPPROTO_TCP, ALPROTO_TLS, "|16 03 00|", 3, 0, STREAM_TOSERVER) < 0) {
3037  return -1;
3038  }
3039 
3040  /** TLSv1 */
3041  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3042  IPPROTO_TCP, ALPROTO_TLS, "|01 03 01|", 3, 0, STREAM_TOSERVER) < 0) {
3043  return -1;
3044  }
3045  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3046  IPPROTO_TCP, ALPROTO_TLS, "|16 03 01|", 3, 0, STREAM_TOSERVER) < 0) {
3047  return -1;
3048  }
3049 
3050  /** TLSv1.1 */
3051  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3052  IPPROTO_TCP, ALPROTO_TLS, "|01 03 02|", 3, 0, STREAM_TOSERVER) < 0) {
3053  return -1;
3054  }
3055  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3056  IPPROTO_TCP, ALPROTO_TLS, "|16 03 02|", 3, 0, STREAM_TOSERVER) < 0) {
3057  return -1;
3058  }
3059 
3060  /** TLSv1.2 */
3061  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3062  IPPROTO_TCP, ALPROTO_TLS, "|01 03 03|", 3, 0, STREAM_TOSERVER) < 0) {
3063  return -1;
3064  }
3065  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3066  IPPROTO_TCP, ALPROTO_TLS, "|16 03 03|", 3, 0, STREAM_TOSERVER) < 0) {
3067  return -1;
3068  }
3069 
3070  /***** toclient direction *****/
3071 
3072  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3073  IPPROTO_TCP, ALPROTO_TLS, "|15 03 00|", 3, 0, STREAM_TOCLIENT) < 0) {
3074  return -1;
3075  }
3076  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3077  IPPROTO_TCP, ALPROTO_TLS, "|16 03 00|", 3, 0, STREAM_TOCLIENT) < 0) {
3078  return -1;
3079  }
3080  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3081  IPPROTO_TCP, ALPROTO_TLS, "|17 03 00|", 3, 0, STREAM_TOCLIENT) < 0) {
3082  return -1;
3083  }
3084 
3085  /** TLSv1 */
3086  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3087  IPPROTO_TCP, ALPROTO_TLS, "|15 03 01|", 3, 0, STREAM_TOCLIENT) < 0) {
3088  return -1;
3089  }
3090  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3091  IPPROTO_TCP, ALPROTO_TLS, "|16 03 01|", 3, 0, STREAM_TOCLIENT) < 0) {
3092  return -1;
3093  }
3094  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3095  IPPROTO_TCP, ALPROTO_TLS, "|17 03 01|", 3, 0, STREAM_TOCLIENT) < 0) {
3096  return -1;
3097  }
3098 
3099  /** TLSv1.1 */
3100  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3101  IPPROTO_TCP, ALPROTO_TLS, "|15 03 02|", 3, 0, STREAM_TOCLIENT) < 0) {
3102  return -1;
3103  }
3104  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3105  IPPROTO_TCP, ALPROTO_TLS, "|16 03 02|", 3, 0, STREAM_TOCLIENT) < 0) {
3106  return -1;
3107  }
3108  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3109  IPPROTO_TCP, ALPROTO_TLS, "|17 03 02|", 3, 0, STREAM_TOCLIENT) < 0) {
3110  return -1;
3111  }
3112 
3113  /** TLSv1.2 */
3114  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3115  IPPROTO_TCP, ALPROTO_TLS, "|15 03 03|", 3, 0, STREAM_TOCLIENT) < 0) {
3116  return -1;
3117  }
3118  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3119  IPPROTO_TCP, ALPROTO_TLS, "|16 03 03|", 3, 0, STREAM_TOCLIENT) < 0) {
3120  return -1;
3121  }
3122  if (SCAppLayerProtoDetectPMRegisterPatternCS(
3123  IPPROTO_TCP, ALPROTO_TLS, "|17 03 03|", 3, 0, STREAM_TOCLIENT) < 0) {
3124  return -1;
3125  }
3126 
3127  /* Subsection - SSLv2 style record by client, but informing the server
3128  * the max version it supports.
3129  * Updated by Anoop Saldanha. Disabled it for now. We'll get back to
3130  * it after some tests */
3131 #if 0
3132  if (SCAppLayerProtoDetectPMRegisterPatternCS(IPPROTO_TCP, ALPROTO_TLS,
3133  "|01 03 00|", 5, 2, STREAM_TOSERVER) < 0)
3134  {
3135  return -1;
3136  }
3137  if (SCAppLayerProtoDetectPMRegisterPatternCS(IPPROTO_TCP, ALPROTO_TLS,
3138  "|00 02|", 7, 5, STREAM_TOCLIENT) < 0)
3139  {
3140  return -1;
3141  }
3142 #endif
3143 
3144  return 0;
3145 }
3146 
3147 #ifdef HAVE_JA3
3148 static void CheckJA3Enabled(void)
3149 {
3150  const char *strval = NULL;
3151  /* Check if we should generate JA3 fingerprints */
3152  int enable_ja3 = SSL_CONFIG_DEFAULT_JA3;
3153  if (SCConfGetNonNull("app-layer.protocols.tls.ja3-fingerprints", &strval) != 1) {
3154  enable_ja3 = SSL_CONFIG_DEFAULT_JA3;
3155  } else if (strcmp(strval, "auto") == 0) {
3156  enable_ja3 = SSL_CONFIG_DEFAULT_JA3;
3157  } else if (SCConfValIsFalse(strval)) {
3158  enable_ja3 = 0;
3159  ssl_config.disable_ja3 = true;
3160  } else if (SCConfValIsTrue(strval)) {
3161  enable_ja3 = true;
3162  }
3163  SC_ATOMIC_SET(ssl_config.enable_ja3, enable_ja3);
3164  if (!ssl_config.disable_ja3 && !g_disable_hashing) {
3165  /* The feature is available, i.e. _could_ be activated by a rule or
3166  even is enabled in the configuration. */
3167  ProvidesFeature(FEATURE_JA3);
3168  }
3169 }
3170 #endif /* HAVE_JA3 */
3171 
3172 #ifdef HAVE_JA4
3173 static void CheckJA4Enabled(void)
3174 {
3175  const char *strval = NULL;
3176  /* Check if we should generate JA4 fingerprints */
3177  int enable_ja4 = SSL_CONFIG_DEFAULT_JA4;
3178  if (SCConfGetNonNull("app-layer.protocols.tls.ja4-fingerprints", &strval) != 1) {
3179  enable_ja4 = SSL_CONFIG_DEFAULT_JA4;
3180  } else if (strcmp(strval, "auto") == 0) {
3181  enable_ja4 = SSL_CONFIG_DEFAULT_JA4;
3182  } else if (SCConfValIsFalse(strval)) {
3183  enable_ja4 = 0;
3184  ssl_config.disable_ja4 = true;
3185  } else if (SCConfValIsTrue(strval)) {
3186  enable_ja4 = true;
3187  }
3188  SC_ATOMIC_SET(ssl_config.enable_ja4, enable_ja4);
3189  if (!ssl_config.disable_ja4 && !g_disable_hashing) {
3190  /* The feature is available, i.e. _could_ be activated by a rule or
3191  even is enabled in the configuration. */
3192  ProvidesFeature(FEATURE_JA4);
3193  }
3194 }
3195 #endif /* HAVE_JA4 */
3196 
3197 /**
3198  * \brief Function to register the SSL protocol parser and other functions
3199  */
3200 void RegisterSSLParsers(void)
3201 {
3202  const char *proto_name = "tls";
3203 
3204  SC_ATOMIC_INIT(ssl_config.enable_ja3);
3205 
3206  /** SSLv2 and SSLv23*/
3207  if (SCAppLayerProtoDetectConfProtoDetectionEnabled("tcp", proto_name)) {
3208  AppLayerProtoDetectRegisterProtocol(ALPROTO_TLS, proto_name);
3209 
3210  if (SSLRegisterPatternsForProtocolDetection() < 0)
3211  return;
3212 
3213  if (RunmodeIsUnittests()) {
3214  SCAppLayerProtoDetectPPRegister(
3215  IPPROTO_TCP, "443", ALPROTO_TLS, 0, 3, STREAM_TOSERVER, SSLProbingParser, NULL);
3216  } else {
3217  if (SCAppLayerProtoDetectPPParseConfPorts("tcp", IPPROTO_TCP, proto_name, ALPROTO_TLS,
3218  0, 3, SSLProbingParser, NULL) == 0) {
3219  SCLogConfig("no TLS config found, "
3220  "enabling TLS detection on port 443.");
3221  SCAppLayerProtoDetectPPRegister(IPPROTO_TCP, "443", ALPROTO_TLS, 0, 3,
3222  STREAM_TOSERVER, SSLProbingParser, NULL);
3223  }
3224  }
3225  } else {
3226  SCLogConfig("Protocol detection and parser disabled for %s protocol",
3227  proto_name);
3228  return;
3229  }
3230 
3231  if (SCAppLayerParserConfParserEnabled("tcp", proto_name)) {
3232  AppLayerParserRegisterParser(IPPROTO_TCP, ALPROTO_TLS, STREAM_TOSERVER,
3233  SSLParseClientRecord);
3234 
3235  AppLayerParserRegisterParser(IPPROTO_TCP, ALPROTO_TLS, STREAM_TOCLIENT,
3236  SSLParseServerRecord);
3237  AppLayerParserRegisterGetStateFuncs(
3238  IPPROTO_TCP, ALPROTO_TLS, SSLStateGetStateIdByName, SSLStateGetStateNameById);
3239  AppLayerParserRegisterGetFrameFuncs(
3240  IPPROTO_TCP, ALPROTO_TLS, SSLStateGetFrameIdByName, SSLStateGetFrameNameById);
3241  AppLayerParserRegisterGetEventInfo(IPPROTO_TCP, ALPROTO_TLS, SSLStateGetEventInfo);
3242  AppLayerParserRegisterGetEventInfoById(IPPROTO_TCP, ALPROTO_TLS, SSLStateGetEventInfoById);
3243 
3244  AppLayerParserRegisterStateFuncs(IPPROTO_TCP, ALPROTO_TLS, SSLStateAlloc, SSLStateFree);
3245 
3246  SCAppLayerParserRegisterParserAcceptableDataDirection(
3247  IPPROTO_TCP, ALPROTO_TLS, STREAM_TOSERVER);
3248 
3249  AppLayerParserRegisterTxFreeFunc(IPPROTO_TCP, ALPROTO_TLS, SSLStateTransactionFree);
3250 
3251  AppLayerParserRegisterGetTx(IPPROTO_TCP, ALPROTO_TLS, SSLGetTx);
3252  AppLayerParserRegisterTxDataFunc(IPPROTO_TCP, ALPROTO_TLS, SSLGetTxData);
3253  AppLayerParserRegisterStateDataFunc(IPPROTO_TCP, ALPROTO_TLS, SSLGetStateData);
3254 
3255  AppLayerParserRegisterGetTxCnt(IPPROTO_TCP, ALPROTO_TLS, SSLGetTxCnt);
3256 
3257  AppLayerParserRegisterGetStateProgressFunc(IPPROTO_TCP, ALPROTO_TLS, SSLGetAlstateProgress);
3258 
3259  AppLayerParserRegisterStateProgressCompletionStatus(
3260  ALPROTO_TLS, TLS_STATE_CLIENT_FINISHED, TLS_STATE_SERVER_FINISHED);
3261 
3262  SCConfNode *enc_handle = SCConfGetNode("app-layer.protocols.tls.encryption-handling");
3263  if (enc_handle != NULL && enc_handle->val != NULL) {
3264  SCLogDebug("have app-layer.protocols.tls.encryption-handling = %s", enc_handle->val);
3265  if (strcmp(enc_handle->val, "full") == 0) {
3266  ssl_config.encrypt_mode = SSL_CNF_ENC_HANDLE_FULL;
3267  } else if (strcmp(enc_handle->val, "bypass") == 0) {
3268  ssl_config.encrypt_mode = SSL_CNF_ENC_HANDLE_BYPASS;
3269  } else if (strcmp(enc_handle->val, "track-only") == 0) {
3270  ssl_config.encrypt_mode = SSL_CNF_ENC_HANDLE_TRACK_ONLY;
3271  } else if (strcmp(enc_handle->val, "default") == 0) {
3272  SCLogWarning("app-layer.protocols.tls.encryption-handling = default is deprecated "
3273  "and will be removed in Suricata 9, use \"track-only\" instead, "
3274  "(see ticket #7642)");
3275  ssl_config.encrypt_mode = SSL_CNF_ENC_HANDLE_TRACK_ONLY;
3276  } else {
3277  ssl_config.encrypt_mode = SSL_CNF_ENC_HANDLE_TRACK_ONLY;
3278  }
3279  } else {
3280  /* Get the value of no reassembly option from the config file */
3281  if (SCConfGetNode("app-layer.protocols.tls.no-reassemble") == NULL) {
3282  int value = 0;
3283  if (SCConfGetBool("tls.no-reassemble", &value) == 1 && value == 1)
3284  ssl_config.encrypt_mode = SSL_CNF_ENC_HANDLE_BYPASS;
3285  } else {
3286  int value = 0;
3287  if (SCConfGetBool("app-layer.protocols.tls.no-reassemble", &value) == 1 &&
3288  value == 1)
3289  ssl_config.encrypt_mode = SSL_CNF_ENC_HANDLE_BYPASS;
3290  }
3291  }
3292  SCLogDebug("ssl_config.encrypt_mode %u", ssl_config.encrypt_mode);
3293 
3294 #ifdef HAVE_JA3
3295  CheckJA3Enabled();
3296 #endif /* HAVE_JA3 */
3297 #ifdef HAVE_JA4
3298  CheckJA4Enabled();
3299 #endif /* HAVE_JA4 */
3300 
3301  if (g_disable_hashing) {
3302  if (SC_ATOMIC_GET(ssl_config.enable_ja3)) {
3303  SCLogWarning("MD5 calculation has been disabled, disabling JA3");
3304  SC_ATOMIC_SET(ssl_config.enable_ja3, 0);
3305  }
3306  if (SC_ATOMIC_GET(ssl_config.enable_ja4)) {
3307  SCLogWarning("Hashing has been disabled, disabling JA4");
3308  SC_ATOMIC_SET(ssl_config.enable_ja4, 0);
3309  }
3310  } else {
3311  if (RunmodeIsUnittests()) {
3312 #ifdef HAVE_JA3
3313  SC_ATOMIC_SET(ssl_config.enable_ja3, 1);
3314 #endif /* HAVE_JA3 */
3315 #ifdef HAVE_JA4
3316  SC_ATOMIC_SET(ssl_config.enable_ja4, 1);
3317 #endif /* HAVE_JA4 */
3318  }
3319  }
3320  } else {
3321  SCLogConfig("Parser disabled for %s protocol. Protocol detection still on.", proto_name);
3322  }
3323 }
3324 
3325 /**
3326  * \brief if not explicitly disabled in config, enable ja3 support
3327  *
3328  * Implemented using atomic to allow rule reloads to do this at
3329  * runtime.
3330  */
3331 void SSLEnableJA3(void)
3332 {
3333  if (g_disable_hashing || ssl_config.disable_ja3) {
3334  return;
3335  }
3336  if (SC_ATOMIC_GET(ssl_config.enable_ja3)) {
3337  return;
3338  }
3339  SC_ATOMIC_SET(ssl_config.enable_ja3, 1);
3340 }
3341 
3342 /**
3343  * \brief if not explicitly disabled in config, enable ja4 support
3344  *
3345  * Implemented using atomic to allow rule reloads to do this at
3346  * runtime.
3347  */
3348 void SSLEnableJA4(void)
3349 {
3350  // only caller has #ifdef HAVE_JA4
3351  if (g_disable_hashing || ssl_config.disable_ja4) {
3352  return;
3353  }
3354  if (SC_ATOMIC_GET(ssl_config.enable_ja4)) {
3355  return;
3356  }
3357  SC_ATOMIC_SET(ssl_config.enable_ja4, 1);
3358 }
3359 
3360 /**
3361  * \brief return whether ja3 is effectively enabled
3362  *
3363  * This means that it either has been enabled explicitly or has been
3364  * enabled by having loaded a rule while not being explicitly disabled.
3365  *
3366  * \retval true if enabled, false otherwise
3367  */
3368 bool SSLJA3IsEnabled(void)
3369 {
3370  return SC_ATOMIC_GET(ssl_config.enable_ja3);
3371 }
3372 
3373 /**
3374  * \brief return whether ja4 is effectively enabled
3375  *
3376  * This means that it either has been enabled explicitly or has been
3377  * enabled by having loaded a rule while not being explicitly disabled.
3378  *
3379  * \retval true if enabled, false otherwise
3380  */
3381 bool SSLJA4IsEnabled(void)
3382 {
3383  return SC_ATOMIC_GET(ssl_config.enable_ja4);
3384 }
SSLV3_CHANGE_CIPHER_SPEC
#define SSLV3_CHANGE_CIPHER_SPEC
Definition: app-layer-ssl.c:213
ERR_INVALID_SERIAL
@ ERR_INVALID_SERIAL
Definition: app-layer-ssl.c:175
tls_frame_table
SCEnumCharMap tls_frame_table[]
Definition: app-layer-ssl.c:99
StreamSlice
Definition: app-layer-parser.h:120
TLS_DECODER_EVENT_CERTIFICATE_INVALID_ISSUER
@ TLS_DECODER_EVENT_CERTIFICATE_INVALID_ISSUER
Definition: app-layer-ssl.h:72
AppLayerParserRegisterGetStateProgressFunc
void AppLayerParserRegisterGetStateProgressFunc(uint8_t ipproto, AppProto alproto, int(*StateGetProgress)(void *alstate, uint8_t direction))
Definition: app-layer-parser.c:536
SSLState_
SSLv[2.0|3.[0|1|2|3]] state structure.
Definition: app-layer-ssl.h:237
SslConfig_::disable_ja3
bool disable_ja3
Definition: app-layer-ssl.c:205
SSL_EXTENSION_EC_POINT_FORMATS
#define SSL_EXTENSION_EC_POINT_FORMATS
Definition: app-layer-ssl.h:149
SSLSubjectAltName_::san_len
uint32_t san_len
Definition: app-layer-ssl.h:170
SCConfValIsTrue
int SCConfValIsTrue(const char *val)
Check if a value is true.
Definition: conf.c:578
SCAppLayerParserStateIssetFlag
uint16_t SCAppLayerParserStateIssetFlag(AppLayerParserState *pstate, uint16_t flag)
Definition: app-layer-parser.c:2105
JA3Buffer_
Definition: util-ja3.h:31
TLS_DECODER_EVENT_DATALEAK_HEARTBEAT_MISMATCH
@ TLS_DECODER_EVENT_DATALEAK_HEARTBEAT_MISMATCH
Definition: app-layer-ssl.h:54
SSLCertsChain_::cert_len
uint32_t cert_len
Definition: app-layer-ssl.h:164
TLS_DECODER_EVENT_HEARTBEAT
@ TLS_DECODER_EVENT_HEARTBEAT
Definition: app-layer-ssl.h:51
TLS_HB_RESPONSE
#define TLS_HB_RESPONSE
Definition: app-layer-ssl.c:254
SHA1_STRING_LENGTH
#define SHA1_STRING_LENGTH
Definition: app-layer-ssl.c:258
TAILQ_INIT
#define TAILQ_INIT(head)
Definition: queue.h:262
TLS_DECODER_EVENT_OVERFLOW_HEARTBEAT
@ TLS_DECODER_EVENT_OVERFLOW_HEARTBEAT
Definition: app-layer-ssl.h:53
SC_ATOMIC_INIT
#define SC_ATOMIC_INIT(name)
wrapper for initializing an atomic variable.
Definition: util-atomic.h:314
TLS_DECODER_EVENT_ERROR_MSG_ENCOUNTERED
@ TLS_DECODER_EVENT_ERROR_MSG_ENCOUNTERED
Definition: app-layer-ssl.h:74
ERR_EXTRACT_SUBJECT
@ ERR_EXTRACT_SUBJECT
Definition: app-layer-ssl.c:183
SSLV3_HS_FINISHED
#define SSLV3_HS_FINISHED
Definition: app-layer-ssl.c:230
SSLState_::hb_record_len
uint32_t hb_record_len
Definition: app-layer-ssl.h:247
unlikely
#define unlikely(expr)
Definition: util-optimize.h:35
SSL_EXTENSION_ELLIPTIC_CURVES
#define SSL_EXTENSION_ELLIPTIC_CURVES
Definition: app-layer-ssl.h:148
SC_ATOMIC_SET
#define SC_ATOMIC_SET(name, val)
Set the value for the atomic variable.
Definition: util-atomic.h:386
SSLStateConnp_::message_length
uint32_t message_length
Definition: app-layer-ssl.h:180
SSLState_::client_connp
SSLStateConnp client_connp
Definition: app-layer-ssl.h:258
TLS_DECODER_EVENT_INVALID_HANDSHAKE_MESSAGE
@ TLS_DECODER_EVENT_INVALID_HANDSHAKE_MESSAGE
Definition: app-layer-ssl.h:50
TLS_FRAME_DATA
@ TLS_FRAME_DATA
Definition: app-layer-ssl.h:36
ALPROTO_TLS
@ ALPROTO_TLS
Definition: app-layer-protos.h:39
SSLEnableJA4
void SSLEnableJA4(void)
if not explicitly disabled in config, enable ja4 support
Definition: app-layer-ssl.c:3348
SCLogDebug
#define SCLogDebug(...)
Definition: util-debug.h:282
SSL_AL_FLAG_EARLY_DATA
#define SSL_AL_FLAG_EARLY_DATA
Definition: app-layer-ssl.h:133
SSLStateConnp_::bytes_processed
uint32_t bytes_processed
Definition: app-layer-ssl.h:188
SCAppLayerTxDataCleanup
void SCAppLayerTxDataCleanup(AppLayerTxData *txd)
Definition: app-layer-parser.c:823
next
struct HtpBodyChunk_ * next
Definition: app-layer-htp.h:0
SSLV2_MT_SERVER_FINISHED
#define SSLV2_MT_SERVER_FINISHED
Definition: app-layer-ssl.c:241
SSLState_::server_connp
SSLStateConnp server_connp
Definition: app-layer-ssl.h:259
SSLStateConnp_::cert0_not_before
int64_t cert0_not_before
Definition: app-layer-ssl.h:199
name
const char * name
Definition: detect-engine-proto.c:48
SSL_AL_FLAG_SESSION_RESUMED
#define SSL_AL_FLAG_SESSION_RESUMED
Definition: app-layer-ssl.h:122
AppProto
uint16_t AppProto
Definition: app-layer-protos.h:87
ValidateRecordState
#define ValidateRecordState(...)
Definition: app-layer-ssl.c:309
SSLStateConnp_
Definition: app-layer-ssl.h:173
SSLStateConnp_::ja3_hash
char * ja3_hash
Definition: app-layer-ssl.h:219
SSL_CONFIG_DEFAULT_JA3
#define SSL_CONFIG_DEFAULT_JA3
Definition: app-layer-ssl.c:189
type
uint8_t type
Definition: decode-sctp.h:0
SCAppLayerParserStateSetFlag
void SCAppLayerParserStateSetFlag(AppLayerParserState *pstate, uint16_t flag)
Definition: app-layer-parser.c:2097
SSLStateConnp_::session_id_length
uint16_t session_id_length
Definition: app-layer-ssl.h:190
AppLayerStateData
Definition: app-layer-parser.h:149
tls_decoder_event_table
SCEnumCharMap tls_decoder_event_table[]
Definition: app-layer-ssl.c:131
Flow_
Flow data structure.
Definition: flow.h:355
SSL_EXTENSION_SUPPORTED_VERSIONS
#define SSL_EXTENSION_SUPPORTED_VERSIONS
Definition: app-layer-ssl.h:154
SSLState_::f
Flow * f
Definition: app-layer-ssl.h:238
SSL_AL_FLAG_STATE_SERVER_HELLO
#define SSL_AL_FLAG_STATE_SERVER_HELLO
Definition: app-layer-ssl.h:111
SC_SHA1_LEN
#define SC_SHA1_LEN
Definition: util-file.h:107
SSLV3_HS_SERVER_HELLO
#define SSLV3_HS_SERVER_HELLO
Definition: app-layer-ssl.c:222
AppLayerParserRegisterStateProgressCompletionStatus
void AppLayerParserRegisterStateProgressCompletionStatus(AppProto alproto, const int ts, const int tc)
Definition: app-layer-parser.c:584
SSLState_::tx_data
AppLayerTxData tx_data
Definition: app-layer-ssl.h:241
SSLParserHSReset
#define SSLParserHSReset(connp)
Definition: app-layer-ssl.c:312
SSLV3_HS_CERTIFICATE
#define SSLV3_HS_CERTIFICATE
Definition: app-layer-ssl.c:224
ERR_INVALID_X509NAME
@ ERR_INVALID_X509NAME
Definition: app-layer-ssl.c:177
AppLayerParserRegisterTxFreeFunc
void AppLayerParserRegisterTxFreeFunc(uint8_t ipproto, AppProto alproto, void(*StateTransactionFree)(void *, uint64_t))
Definition: app-layer-parser.c:546
SSLV3_HEARTBEAT_PROTOCOL
#define SSLV3_HEARTBEAT_PROTOCOL
Definition: app-layer-ssl.c:217
SSLV2_MT_SERVER_HELLO
#define SSLV2_MT_SERVER_HELLO
Definition: app-layer-ssl.c:239
SSLState_::curr_connp
SSLStateConnp * curr_connp
Definition: app-layer-ssl.h:253
Ja3BufferAddValue
int Ja3BufferAddValue(JA3Buffer **buffer, uint32_t value)
Definition: util-ja3.c:314
SSLV3_HS_CERTIFICATE_URL
#define SSLV3_HS_CERTIFICATE_URL
Definition: app-layer-ssl.c:231
TLS_STATE_SERVER_HELLO_DONE
@ TLS_STATE_SERVER_HELLO_DONE
Definition: app-layer-ssl.h:90
MIN
#define MIN(x, y)
Definition: suricata-common.h:416
SCConfGetBool
int SCConfGetBool(const char *name, int *val)
Retrieve a configuration value as a boolean.
Definition: conf.c:524
AppLayerParserRegisterGetStateFuncs
void AppLayerParserRegisterGetStateFuncs(uint8_t ipproto, AppProto alproto, AppLayerParserGetStateIdByNameFn GetIdByNameFunc, AppLayerParserGetStateNameByIdFn GetNameByIdFunc)
Definition: app-layer-parser.c:643
util-ja3.h
SCConfValIsFalse
int SCConfValIsFalse(const char *val)
Check if a value is false.
Definition: conf.c:603
ERR_INVALID_ALGORITHMIDENTIFIER
@ ERR_INVALID_ALGORITHMIDENTIFIER
Definition: app-layer-ssl.c:176
SSL_AL_FLAG_STATE_SERVER_KEYX
#define SSL_AL_FLAG_STATE_SERVER_KEYX
Definition: app-layer-ssl.h:113
SSLState_::state_data
AppLayerStateData state_data
Definition: app-layer-ssl.h:240
TAILQ_INSERT_TAIL
#define TAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:294
p
Packet * p
Definition: fuzz_iprep.c:21
SSLV3_HS_CERTIFICATE_VERIFY
#define SSLV3_HS_CERTIFICATE_VERIFY
Definition: app-layer-ssl.c:228
TLS_DECODER_EVENT_INVALID_TLS_HEADER
@ TLS_DECODER_EVENT_INVALID_TLS_HEADER
Definition: app-layer-ssl.h:46
SSL_CNF_ENC_HANDLE_TRACK_ONLY
@ SSL_CNF_ENC_HANDLE_TRACK_ONLY
Definition: app-layer-ssl.c:195
MAX
#define MAX(x, y)
Definition: suricata-common.h:420
SSLStateConnp_::hs_buffer_message_type
uint8_t hs_buffer_message_type
Definition: app-layer-ssl.h:226
TLS_DECODER_EVENT_INVALID_SSL_RECORD
@ TLS_DECODER_EVENT_INVALID_SSL_RECORD
Definition: app-layer-ssl.h:75
TLS_DECODER_EVENT_TOO_MANY_RECORDS_IN_PACKET
@ TLS_DECODER_EVENT_TOO_MANY_RECORDS_IN_PACKET
Definition: app-layer-ssl.h:59
TLS_DECODER_EVENT_MULTIPLE_SNI_EXTENSIONS
@ TLS_DECODER_EVENT_MULTIPLE_SNI_EXTENSIONS
Definition: app-layer-ssl.h:56
SSLStateConnp_::record_lengths_length
uint32_t record_lengths_length
Definition: app-layer-ssl.h:177
SSLSubjectAltName_::san
uint8_t * san
Definition: app-layer-ssl.h:169
TLS_FRAME_SSLV2_HDR
@ TLS_FRAME_SSLV2_HDR
Definition: app-layer-ssl.h:39
SSL_AL_FLAG_CHANGE_CIPHER_SPEC
#define SSL_AL_FLAG_CHANGE_CIPHER_SPEC
Definition: app-layer-ssl.h:99
SCAppLayerProtoDetectPMRegisterPatternCSwPP
int SCAppLayerProtoDetectPMRegisterPatternCSwPP(uint8_t ipproto, AppProto alproto, const char *pattern, uint16_t depth, uint16_t offset, uint8_t direction, ProbingParserFPtr PPFunc, uint16_t pp_min_depth, uint16_t pp_max_depth)
Definition: app-layer-detect-proto.c:1651
ERR_INVALID_DATE
@ ERR_INVALID_DATE
Definition: app-layer-ssl.c:178
SSLStateConnp_::hs_buffer_size
uint32_t hs_buffer_size
Definition: app-layer-ssl.h:228
TLS_DECODER_EVENT_CERTIFICATE_INVALID_DER
@ TLS_DECODER_EVENT_CERTIFICATE_INVALID_DER
Definition: app-layer-ssl.h:70
TLS_DECODER_EVENT_CERTIFICATE_INVALID_LENGTH
@ TLS_DECODER_EVENT_CERTIFICATE_INVALID_LENGTH
Definition: app-layer-ssl.h:63
TLS_FRAME_HB_DATA
@ TLS_FRAME_HB_DATA
Definition: app-layer-ssl.h:38
SSL_AL_FLAG_SSL_CLIENT_MASTER_KEY
#define SSL_AL_FLAG_SSL_CLIENT_MASTER_KEY
Definition: app-layer-ssl.h:104
SSL_AL_FLAG_SSL_CLIENT_SSN_ENCRYPTED
#define SSL_AL_FLAG_SSL_CLIENT_SSN_ENCRYPTED
Definition: app-layer-ssl.h:105
SSLStateConnp_::cert0_not_after
int64_t cert0_not_after
Definition: app-layer-ssl.h:200
SCAppLayerProtoDetectConfProtoDetectionEnabled
int SCAppLayerProtoDetectConfProtoDetectionEnabled(const char *ipproto, const char *alproto)
Given a protocol name, checks if proto detection is enabled in the conf file.
Definition: app-layer-detect-proto.c:1995
ERR_INVALID_LENGTH
@ ERR_INVALID_LENGTH
Definition: app-layer-ssl.c:173
SSLState_::current_flags
uint32_t current_flags
Definition: app-layer-ssl.h:251
SSLStateConnp_::cert0_sans
SSLSubjectAltName * cert0_sans
Definition: app-layer-ssl.h:203
AppLayerResult
Definition: app-layer-parser.h:114
SSL_AL_FLAG_HB_SERVER_INIT
#define SSL_AL_FLAG_HB_SERVER_INIT
Definition: app-layer-ssl.h:119
SCAppLayerParserTriggerRawStreamInspection
void SCAppLayerParserTriggerRawStreamInspection(Flow *f, int direction)
Definition: app-layer-parser.c:1813
TLS_DECODER_EVENT_CERTIFICATE_INVALID_VALIDITY
@ TLS_DECODER_EVENT_CERTIFICATE_INVALID_VALIDITY
Definition: app-layer-ssl.h:73
SSLV2_MT_SERVER_VERIFY
#define SSLV2_MT_SERVER_VERIFY
Definition: app-layer-ssl.c:240
app-layer-detect-proto.h
SSLDecoderResult::needed
uint32_t needed
Definition: app-layer-ssl.c:264
Ja3BufferInit
JA3Buffer * Ja3BufferInit(void)
Allocate new buffer.
Definition: util-ja3.c:39
APP_LAYER_INCOMPLETE
#define APP_LAYER_INCOMPLETE(c, n)
Definition: app-layer-parser.h:70
Ja3BufferFree
void Ja3BufferFree(JA3Buffer **buffer)
Free allocated buffer.
Definition: util-ja3.c:54
TAILQ_REMOVE
#define TAILQ_REMOVE(head, elm, field)
Definition: queue.h:312
feature.h
decode.h
util-debug.h
TLS_STATE_CLIENT_HANDSHAKE_DONE
@ TLS_STATE_CLIENT_HANDSHAKE_DONE
Definition: app-layer-ssl.h:82
TAILQ_FIRST
#define TAILQ_FIRST(head)
Definition: queue.h:250
AppLayerParserState_
Definition: app-layer-parser.c:148
TLS_HB_REQUEST
#define TLS_HB_REQUEST
Definition: app-layer-ssl.c:253
SSLJA3IsEnabled
bool SSLJA3IsEnabled(void)
return whether ja3 is effectively enabled
Definition: app-layer-ssl.c:3368
TLS_TC_RANDOM_SET
#define TLS_TC_RANDOM_SET
Definition: app-layer-ssl.h:139
AppLayerTxData
Definition: app-layer-parser.h:166
SCAppLayerParserConfParserEnabled
int SCAppLayerParserConfParserEnabled(const char *ipproto, const char *alproto_name)
check if a parser is enabled in the config Returns enabled always if: were running unittests
Definition: app-layer-parser.c:377
TLS_DECODER_EVENT_INVALID_RECORD_TYPE
@ TLS_DECODER_EVENT_INVALID_RECORD_TYPE
Definition: app-layer-ssl.h:48
ERR_INVALID_CERTIFICATE
@ ERR_INVALID_CERTIFICATE
Definition: app-layer-ssl.c:172
SSLState_::client_state
enum TlsStateClient client_state
Definition: app-layer-ssl.h:255
APP_LAYER_EVENT_TYPE_TRANSACTION
@ APP_LAYER_EVENT_TYPE_TRANSACTION
Definition: app-layer-events.h:55
AppLayerEventType
AppLayerEventType
Definition: app-layer-events.h:54
Ja3BufferAppendBuffer
int Ja3BufferAppendBuffer(JA3Buffer **buffer1, JA3Buffer **buffer2)
Definition: util-ja3.c:309
SSLStateConnp_::handshake_type
uint8_t handshake_type
Definition: app-layer-ssl.h:185
SSLV2_MT_REQUEST_CERTIFICATE
#define SSLV2_MT_REQUEST_CERTIFICATE
Definition: app-layer-ssl.c:242
SSLDecoderResult::retval
int retval
Definition: app-layer-ssl.c:263
SSLStateConnp_::hs_buffer_offset
uint32_t hs_buffer_offset
Definition: app-layer-ssl.h:229
SSLStateConnp_::certs_buffer
uint8_t * certs_buffer
Definition: app-layer-ssl.h:213
TLS_STATE_CLIENT_HELLO_DONE
@ TLS_STATE_CLIENT_HELLO_DONE
Definition: app-layer-ssl.h:80
TLS_DECODER_EVENT_INVALID_RECORD_VERSION
@ TLS_DECODER_EVENT_INVALID_RECORD_VERSION
Definition: app-layer-ssl.h:47
TlsStateServer
TlsStateServer
Definition: app-layer-ssl.h:86
TLS_DECODER_EVENT_CERTIFICATE_INVALID_DATE
@ TLS_DECODER_EVENT_CERTIFICATE_INVALID_DATE
Definition: app-layer-ssl.h:68
SSLCertsChain_
Definition: app-layer-ssl.h:162
SSLStateConnp_::cert0_serial_len
uint32_t cert0_serial_len
Definition: app-layer-ssl.h:198
AppLayerParserRegisterGetFrameFuncs
void AppLayerParserRegisterGetFrameFuncs(uint8_t ipproto, AppProto alproto, AppLayerParserGetFrameIdByNameFn GetIdByNameFunc, AppLayerParserGetFrameNameByIdFn GetNameByIdFunc)
Definition: app-layer-parser.c:653
TLS_DECODER_EVENT_CERTIFICATE_INVALID_SERIAL
@ TLS_DECODER_EVENT_CERTIFICATE_INVALID_SERIAL
Definition: app-layer-ssl.h:65
SSLParserReset
#define SSLParserReset(state)
Definition: app-layer-ssl.c:318
SCConfGetNonNull
int SCConfGetNonNull(const char *name, const char **vptr)
Retrieve the non-null value of a configuration node.
Definition: conf.c:381
TlsStateClient
TlsStateClient
Definition: app-layer-ssl.h:78
TLS_DECODER_EVENT_CERTIFICATE_INVALID_SUBJECT
@ TLS_DECODER_EVENT_CERTIFICATE_INVALID_SUBJECT
Definition: app-layer-ssl.h:71
TLS_TS_RANDOM_SET
#define TLS_TS_RANDOM_SET
Definition: app-layer-ssl.h:136
AppLayerParserRegisterStateFuncs
void AppLayerParserRegisterStateFuncs(uint8_t ipproto, AppProto alproto, void *(*StateAlloc)(void *, AppProto), void(*StateFree)(void *))
Definition: app-layer-parser.c:485
SSL_AL_FLAG_STATE_CLIENT_HELLO
#define SSL_AL_FLAG_STATE_CLIENT_HELLO
Definition: app-layer-ssl.h:110
TLS_STATE_SERVER_FINISHED
@ TLS_STATE_SERVER_FINISHED
Definition: app-layer-ssl.h:92
SCLogWarning
#define SCLogWarning(...)
Macro used to log WARNING messages.
Definition: util-debug.h:262
TLS_RANDOM_LEN
#define TLS_RANDOM_LEN
Definition: app-layer-ssl.h:160
SSLStateConnp_::cert0_serial
uint8_t * cert0_serial
Definition: app-layer-ssl.h:197
SslConfig_::SC_ATOMIC_DECLARE
SC_ATOMIC_DECLARE(int, enable_ja3)
app-layer-parser.h
TLS_STATE_CLIENT_IN_PROGRESS
@ TLS_STATE_CLIENT_IN_PROGRESS
Definition: app-layer-ssl.h:79
TLS_FRAME_SSLV2_PDU
@ TLS_FRAME_SSLV2_PDU
Definition: app-layer-ssl.h:40
AppLayerParserRegisterGetEventInfo
void AppLayerParserRegisterGetEventInfo(uint8_t ipproto, AppProto alproto, int(*StateGetEventInfo)(const char *event_name, uint8_t *event_id, AppLayerEventType *event_type))
Definition: app-layer-parser.c:663
SslConfigEncryptHandling
SslConfigEncryptHandling
Definition: app-layer-ssl.c:194
SSL_AL_FLAG_HB_CLIENT_INIT
#define SSL_AL_FLAG_HB_CLIENT_INIT
Definition: app-layer-ssl.h:118
SSL_AL_FLAG_STATE_CLIENT_KEYX
#define SSL_AL_FLAG_STATE_CLIENT_KEYX
Definition: app-layer-ssl.h:112
SSLV3_RECORD_HDR_LEN
#define SSLV3_RECORD_HDR_LEN
Definition: app-layer-ssl.c:245
SSLV2_MT_CLIENT_MASTER_KEY
#define SSLV2_MT_CLIENT_MASTER_KEY
Definition: app-layer-ssl.c:237
SSL_EXTENSION_ALPN
#define SSL_EXTENSION_ALPN
Definition: app-layer-ssl.h:151
TLS_DECODER_EVENT_INVALID_SSLV2_HEADER
@ TLS_DECODER_EVENT_INVALID_SSLV2_HEADER
Definition: app-layer-ssl.h:45
TLS_DECODER_EVENT_INVALID_RECORD_LENGTH
@ TLS_DECODER_EVENT_INVALID_RECORD_LENGTH
Definition: app-layer-ssl.h:49
conf.h
ERR_EXTRACT_ISSUER
@ ERR_EXTRACT_ISSUER
Definition: app-layer-ssl.c:184
SSL_AL_FLAG_CH_VERSION_EXTENSION
#define SSL_AL_FLAG_CH_VERSION_EXTENSION
Definition: app-layer-ssl.h:125
SSLStateConnp_::cert0_issuerdn
uint8_t * cert0_issuerdn
Definition: app-layer-ssl.h:195
SSLState_::server_state
enum TlsStateServer server_state
Definition: app-layer-ssl.h:256
SSLEnableJA3
void SSLEnableJA3(void)
if not explicitly disabled in config, enable ja3 support
Definition: app-layer-ssl.c:3331
SSLStateConnp_::record_length
uint32_t record_length
Definition: app-layer-ssl.h:175
SslConfig_
Definition: app-layer-ssl.c:200
SSLV2_MT_CLIENT_HELLO
#define SSLV2_MT_CLIENT_HELLO
Definition: app-layer-ssl.c:236
AppLayerProtoDetectRegisterProtocol
void AppLayerProtoDetectRegisterProtocol(AppProto alproto, const char *alproto_name)
Registers a protocol for protocol detection phase.
Definition: app-layer-detect-proto.c:1782
TLS_STATE_SERVER_CERT_DONE
@ TLS_STATE_SERVER_CERT_DONE
Definition: app-layer-ssl.h:89
SSLV3_APPLICATION_PROTOCOL
#define SSLV3_APPLICATION_PROTOCOL
Definition: app-layer-ssl.c:216
SSLV3_ALERT_PROTOCOL
#define SSLV3_ALERT_PROTOCOL
Definition: app-layer-ssl.c:214
SSLV2_MT_CLIENT_CERTIFICATE
#define SSLV2_MT_CLIENT_CERTIFICATE
Definition: app-layer-ssl.c:243
SSLStateConnp_::sni
uint8_t * sni
Definition: app-layer-ssl.h:206
SSLCertsChain_::cert_data
uint8_t * cert_data
Definition: app-layer-ssl.h:163
SSLStateConnp_::cert0_sans_num
uint16_t cert0_sans_num
Definition: app-layer-ssl.h:204
RunmodeIsUnittests
int RunmodeIsUnittests(void)
Definition: suricata.c:292
SSLStateConnp_::certs_buffer_size
uint32_t certs_buffer_size
Definition: app-layer-ssl.h:214
AppLayerParserRegisterParser
int AppLayerParserRegisterParser(uint8_t ipproto, AppProto alproto, uint8_t direction, AppLayerParserFPtr Parser)
Register app layer parser for the protocol.
Definition: app-layer-parser.c:452
TLS_DECODER_EVENT_INVALID_HEARTBEAT
@ TLS_DECODER_EVENT_INVALID_HEARTBEAT
Definition: app-layer-ssl.h:52
SSL_AL_FLAG_NEED_CLIENT_CERT
#define SSL_AL_FLAG_NEED_CLIENT_CERT
Definition: app-layer-ssl.h:141
SSLV3_HS_CLIENT_KEY_EXCHANGE
#define SSLV3_HS_CLIENT_KEY_EXCHANGE
Definition: app-layer-ssl.c:229
SSL_AL_FLAG_SERVER_CHANGE_CIPHER_SPEC
#define SSL_AL_FLAG_SERVER_CHANGE_CIPHER_SPEC
Definition: app-layer-ssl.h:96
SCRealloc
#define SCRealloc(ptr, sz)
Definition: util-mem.h:50
HAS_SPACE
#define HAS_SPACE(n)
Definition: app-layer-ssl.c:260
SCAppLayerProtoDetectPPRegister
void SCAppLayerProtoDetectPPRegister(uint8_t ipproto, const char *portstr, AppProto alproto, uint16_t min_depth, uint16_t max_depth, uint8_t direction, ProbingParserFPtr ProbingParser1, ProbingParserFPtr ProbingParser2)
register parser at a port
Definition: app-layer-detect-proto.c:1541
AppLayerParserRegisterGetTx
void AppLayerParserRegisterGetTx(uint8_t ipproto, AppProto alproto, void *(StateGetTx)(void *alstate, uint64_t tx_id))
Definition: app-layer-parser.c:566
TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH
@ TLS_DECODER_EVENT_HANDSHAKE_INVALID_LENGTH
Definition: app-layer-ssl.h:55
SSLDecoderResult
Definition: app-layer-ssl.c:262
APP_LAYER_OK
#define APP_LAYER_OK
Definition: app-layer-parser.h:58
TLS_DECODER_EVENT_CERTIFICATE_INVALID_VERSION
@ TLS_DECODER_EVENT_CERTIFICATE_INVALID_VERSION
Definition: app-layer-ssl.h:64
SSLStateConnp_::random
uint8_t random[TLS_RANDOM_LEN]
Definition: app-layer-ssl.h:192
SSLV3_RECORD_MAX_LEN
#define SSLV3_RECORD_MAX_LEN
Definition: app-layer-ssl.c:247
app-layer-frames.h
SSL_DECODER_ERROR
#define SSL_DECODER_ERROR(e)
Definition: app-layer-ssl.c:266
SSL_AL_FLAG_SSL_CLIENT_HS
#define SSL_AL_FLAG_SSL_CLIENT_HS
Definition: app-layer-ssl.h:102
SCMapEnumValueToName
const char * SCMapEnumValueToName(int enum_value, SCEnumCharMap *table)
Maps an enum value to a string name, from the supplied table.
Definition: util-enum.c:68
SCReturnStruct
#define SCReturnStruct(x)
Definition: util-debug.h:304
ERR_EXTRACT_VALIDITY
@ ERR_EXTRACT_VALIDITY
Definition: app-layer-ssl.c:185
TLS_DECODER_EVENT_INVALID_CERTIFICATE
@ TLS_DECODER_EVENT_INVALID_CERTIFICATE
Definition: app-layer-ssl.h:62
RegisterSSLParsers
void RegisterSSLParsers(void)
Function to register the SSL protocol parser and other functions.
Definition: app-layer-ssl.c:3200
SSLStateConnp_::cert0_subject_len
uint32_t cert0_subject_len
Definition: app-layer-ssl.h:194
SSLV3_CLIENT_HELLO_VERSION_LEN
#define SSLV3_CLIENT_HELLO_VERSION_LEN
Definition: app-layer-ssl.c:249
SCMapEnumNameToValue
int SCMapEnumNameToValue(const char *enum_name, SCEnumCharMap *table)
Maps a string name to an enum value from the supplied table. Please specify the last element of any m...
Definition: util-enum.c:40
SSL_DECODER_OK
#define SSL_DECODER_OK(c)
Definition: app-layer-ssl.c:271
suricata-common.h
TLS_FRAME_PDU
@ TLS_FRAME_PDU
Definition: app-layer-ssl.h:34
SSL_EXTENSION_SESSION_TICKET
#define SSL_EXTENSION_SESSION_TICKET
Definition: app-layer-ssl.h:152
SSL_EXTENSION_SIGNATURE_ALGORITHMS
#define SSL_EXTENSION_SIGNATURE_ALGORITHMS
Definition: app-layer-ssl.h:150
AppLayerTxData::updated_tc
bool updated_tc
Definition: app-layer-parser.h:173
Ja3GenerateHash
char * Ja3GenerateHash(JA3Buffer *buffer)
Definition: util-ja3.c:319
SSL_EXTENSION_EARLY_DATA
#define SSL_EXTENSION_EARLY_DATA
Definition: app-layer-ssl.h:153
SCEnumCharMap_
Definition: util-enum.h:27
SCAppLayerParserRegisterParserAcceptableDataDirection
void SCAppLayerParserRegisterParserAcceptableDataDirection(uint8_t ipproto, AppProto alproto, uint8_t direction)
Definition: app-layer-parser.c:464
version
uint8_t version
Definition: decode-gre.h:1
SSLStateConnp_::content_type
uint8_t content_type
Definition: app-layer-ssl.h:183
SSLSetEvent
#define SSLSetEvent(ssl_state, event)
Definition: app-layer-ssl.c:325
AppLayerParserRegisterStateDataFunc
void AppLayerParserRegisterStateDataFunc(uint8_t ipproto, AppProto alproto, AppLayerStateData *(*GetStateData)(void *state))
Definition: app-layer-parser.c:684
SSLStateConnp_::hs_buffer_message_size
uint32_t hs_buffer_message_size
Definition: app-layer-ssl.h:227
TLS_DECODER_EVENT_CERTIFICATE_INVALID_ALGORITHMIDENTIFIER
@ TLS_DECODER_EVENT_CERTIFICATE_INVALID_ALGORITHMIDENTIFIER
Definition: app-layer-ssl.h:66
SSL_DECODER_INCOMPLETE
#define SSL_DECODER_INCOMPLETE(c, n)
Definition: app-layer-ssl.c:276
AppLayerParserRegisterTxDataFunc
void AppLayerParserRegisterTxDataFunc(uint8_t ipproto, AppProto alproto, AppLayerTxData *(*GetTxData)(void *tx))
Definition: app-layer-parser.c:674
TLS_DECODER_EVENT_INVALID_SNI_TYPE
@ TLS_DECODER_EVENT_INVALID_SNI_TYPE
Definition: app-layer-ssl.h:57
AppLayerFrameNewByPointer
Frame * AppLayerFrameNewByPointer(Flow *f, const StreamSlice *stream_slice, const uint8_t *frame_start, const int64_t len, int dir, uint8_t frame_type)
create new frame using a pointer to start of the frame
Definition: app-layer-frames.c:465
FEATURE_JA4
#define FEATURE_JA4
Definition: feature.h:30
SslConfig_::encrypt_mode
enum SslConfigEncryptHandling encrypt_mode
Definition: app-layer-ssl.c:201
TLS_STATE_CLIENT_CERT_DONE
@ TLS_STATE_CLIENT_CERT_DONE
Definition: app-layer-ssl.h:81
SSLV3_HS_HELLO_REQUEST
#define SSLV3_HS_HELLO_REQUEST
Definition: app-layer-ssl.c:220
app-layer-events.h
SSL_AL_FLAG_CLIENT_CHANGE_CIPHER_SPEC
#define SSL_AL_FLAG_CLIENT_CHANGE_CIPHER_SPEC
Definition: app-layer-ssl.h:98
SSLV3_HS_CERTIFICATE_REQUEST
#define SSLV3_HS_CERTIFICATE_REQUEST
Definition: app-layer-ssl.c:226
util-validate.h
SSL_SNI_TYPE_HOST_NAME
#define SSL_SNI_TYPE_HOST_NAME
Definition: app-layer-ssl.h:157
SCMalloc
#define SCMalloc(sz)
Definition: util-mem.h:47
SCLogConfig
struct SCLogConfig_ SCLogConfig
Holds the config state used by the logging api.
SSLV2_MT_CLIENT_FINISHED
#define SSLV2_MT_CLIENT_FINISHED
Definition: app-layer-ssl.c:238
ssl_config
SslConfig ssl_config
Definition: app-layer-ssl.c:210
SCAppLayerProtoDetectPMRegisterPatternCS
int SCAppLayerProtoDetectPMRegisterPatternCS(uint8_t ipproto, AppProto alproto, const char *pattern, uint16_t depth, uint16_t offset, uint8_t direction)
Registers a case-sensitive pattern for protocol detection.
Definition: app-layer-detect-proto.c:1640
SCConfGetNode
SCConfNode * SCConfGetNode(const char *name)
Get a SCConfNode by name.
Definition: conf.c:184
SCLogError
#define SCLogError(...)
Macro used to log ERROR messages.
Definition: util-debug.h:274
SCFree
#define SCFree(p)
Definition: util-mem.h:61
SCAppLayerProtoDetectPPParseConfPorts
int SCAppLayerProtoDetectPPParseConfPorts(const char *ipproto_name, uint8_t ipproto, const char *alproto_name, AppProto alproto, uint16_t min_depth, uint16_t max_depth, ProbingParserFPtr ProbingParserTs, ProbingParserFPtr ProbingParserTc)
Definition: app-layer-detect-proto.c:1577
SSLSubjectAltName_
Definition: app-layer-ssl.h:168
TLS_STATE_SERVER_IN_PROGRESS
@ TLS_STATE_SERVER_IN_PROGRESS
Definition: app-layer-ssl.h:87
TLS_DECODER_EVENT_CERTIFICATE_INVALID_X509NAME
@ TLS_DECODER_EVENT_CERTIFICATE_INVALID_X509NAME
Definition: app-layer-ssl.h:67
src
uint16_t src
Definition: app-layer-dnp3.h:5
payload_len
uint16_t payload_len
Definition: stream-tcp-private.h:1
SSLV2_MT_ERROR
#define SSLV2_MT_ERROR
Definition: app-layer-ssl.c:235
SSL_AL_FLAG_SSL_SERVER_SSN_ENCRYPTED
#define SSL_AL_FLAG_SSL_SERVER_SSN_ENCRYPTED
Definition: app-layer-ssl.h:106
SSLV3_HANDSHAKE_PROTOCOL
#define SSLV3_HANDSHAKE_PROTOCOL
Definition: app-layer-ssl.c:215
SSLJA4IsEnabled
bool SSLJA4IsEnabled(void)
return whether ja4 is effectively enabled
Definition: app-layer-ssl.c:3381
WARN_UNUSED
#define WARN_UNUSED
Definition: bindgen.h:33
SslConfig_::disable_ja4
bool disable_ja4
Definition: app-layer-ssl.c:207
ALPROTO_UNKNOWN
@ ALPROTO_UNKNOWN
Definition: app-layer-protos.h:29
ALPROTO_FAILED
@ ALPROTO_FAILED
Definition: app-layer-protos.h:33
SSLV3_HS_CLIENT_HELLO
#define SSLV3_HS_CLIENT_HELLO
Definition: app-layer-ssl.c:221
TLS_DECODER_EVENT_CERTIFICATE_INVALID_EXTENSIONS
@ TLS_DECODER_EVENT_CERTIFICATE_INVALID_EXTENSIONS
Definition: app-layer-ssl.h:69
SSLV3_CLIENT_HELLO_RANDOM_LEN
#define SSLV3_CLIENT_HELLO_RANDOM_LEN
Definition: app-layer-ssl.c:250
ProvidesFeature
void ProvidesFeature(const char *feature_name)
Definition: feature.c:106
SslConfig_::SC_ATOMIC_DECLARE
SC_ATOMIC_DECLARE(int, enable_ja4)
app-layer-protos.h
TLS_DECODER_EVENT_INVALID_SNI_LENGTH
@ TLS_DECODER_EVENT_INVALID_SNI_LENGTH
Definition: app-layer-ssl.h:58
ERR_INVALID_DER
@ ERR_INVALID_DER
Definition: app-layer-ssl.c:180
AppLayerParserRegisterGetTxCnt
void AppLayerParserRegisterGetTxCnt(uint8_t ipproto, AppProto alproto, uint64_t(*StateGetTxCnt)(void *alstate))
Definition: app-layer-parser.c:556
SSL_CNF_ENC_HANDLE_BYPASS
@ SSL_CNF_ENC_HANDLE_BYPASS
Definition: app-layer-ssl.c:196
APP_LAYER_ERROR
#define APP_LAYER_ERROR
Definition: app-layer-parser.h:62
SslConfig
struct SslConfig_ SslConfig
SSLStateConnp_::hs
HandshakeParams * hs
Definition: app-layer-ssl.h:221
FEATURE_JA3
#define FEATURE_JA3
Definition: feature.h:29
SSLStateConnp_::cert0_issuerdn_len
uint32_t cert0_issuerdn_len
Definition: app-layer-ssl.h:196
AppLayerParserRegisterGetEventInfoById
void AppLayerParserRegisterGetEventInfoById(uint8_t ipproto, AppProto alproto, int(*StateGetEventInfoById)(uint8_t event_id, const char **event_name, AppLayerEventType *event_type))
Definition: app-layer-parser.c:599
TLS_FRAME_ALERT_DATA
@ TLS_FRAME_ALERT_DATA
Definition: app-layer-ssl.h:37
SSL_AL_FLAG_SSL_NO_SESSION_ID
#define SSL_AL_FLAG_SSL_NO_SESSION_ID
Definition: app-layer-ssl.h:107
TLS_STATE_SERVER_HELLO
@ TLS_STATE_SERVER_HELLO
Definition: app-layer-ssl.h:88
SSLStateConnp_::session_id
char * session_id
Definition: app-layer-ssl.h:209
TLS_FRAME_HDR
@ TLS_FRAME_HDR
Definition: app-layer-ssl.h:35
SC_ATOMIC_GET
#define SC_ATOMIC_GET(name)
Get the value from the atomic variable.
Definition: util-atomic.h:375
dst
uint16_t dst
Definition: app-layer-dnp3.h:4
TLS_DECODER_EVENT_INVALID_ALERT
@ TLS_DECODER_EVENT_INVALID_ALERT
Definition: app-layer-ssl.h:60
SSL_EXTENSION_SNI
#define SSL_EXTENSION_SNI
Definition: app-layer-ssl.h:147
SSLStateConnp_::cert0_fingerprint
char * cert0_fingerprint
Definition: app-layer-ssl.h:201
SSL_RECORD_MINIMUM_LENGTH
#define SSL_RECORD_MINIMUM_LENGTH
Definition: app-layer-ssl.c:256
SSLStateConnp_::sni_len
uint16_t sni_len
Definition: app-layer-ssl.h:207
SSLStateConnp_::ja3_str
JA3Buffer * ja3_str
Definition: app-layer-ssl.h:218
TLS_STATE_SERVER_HANDSHAKE_DONE
@ TLS_STATE_SERVER_HANDSHAKE_DONE
Definition: app-layer-ssl.h:91
SCCalloc
#define SCCalloc(nm, sz)
Definition: util-mem.h:53
ERR_INVALID_EXTENSIONS
@ ERR_INVALID_EXTENSIONS
Definition: app-layer-ssl.c:179
SSLV3_HS_SERVER_HELLO_DONE
#define SSLV3_HS_SERVER_HELLO_DONE
Definition: app-layer-ssl.c:227
util-enum.h
SCReturnInt
#define SCReturnInt(x)
Definition: util-debug.h:288
SCConfNode_
Definition: conf.h:37
SSLStateConnp_::hs_buffer
uint8_t * hs_buffer
Definition: app-layer-ssl.h:225
SCConfNode_::val
char * val
Definition: conf.h:39
ERR_INVALID_VERSION
@ ERR_INVALID_VERSION
Definition: app-layer-ssl.c:174
TLS_STATE_CLIENT_FINISHED
@ TLS_STATE_CLIENT_FINISHED
Definition: app-layer-ssl.h:83
DEBUG_VALIDATE_BUG_ON
#define DEBUG_VALIDATE_BUG_ON(exp)
Definition: util-validate.h:109
app-layer-ssl.h
SSLV3_HS_NEW_SESSION_TICKET
#define SSLV3_HS_NEW_SESSION_TICKET
Definition: app-layer-ssl.c:223
SCAppLayerGetEventIdByName
int SCAppLayerGetEventIdByName(const char *event_name, SCEnumCharMap *table, uint8_t *event_id)
Definition: app-layer-events.c:30
SSL_AL_FLAG_LOG_WITHOUT_CERT
#define SSL_AL_FLAG_LOG_WITHOUT_CERT
Definition: app-layer-ssl.h:129
SSLV3_HS_CERTIFICATE_STATUS
#define SSLV3_HS_CERTIFICATE_STATUS
Definition: app-layer-ssl.c:232
SSL_AL_FLAG_HB_INFLIGHT
#define SSL_AL_FLAG_HB_INFLIGHT
Definition: app-layer-ssl.h:117
SSL_AL_FLAG_SSL_SERVER_HS
#define SSL_AL_FLAG_SSL_SERVER_HS
Definition: app-layer-ssl.h:103
AppLayerTxData::updated_ts
bool updated_ts
Definition: app-layer-parser.h:174
app-layer.h
SSL_CNF_ENC_HANDLE_FULL
@ SSL_CNF_ENC_HANDLE_FULL
Definition: app-layer-ssl.c:197
SSLStateConnp_::cert0_subject
uint8_t * cert0_subject
Definition: app-layer-ssl.h:193
SSLState_::flags
uint32_t flags
Definition: app-layer-ssl.h:244
SSLStateConnp_::version
uint16_t version
Definition: app-layer-ssl.h:182
SSLV3_HS_SERVER_KEY_EXCHANGE
#define SSLV3_HS_SERVER_KEY_EXCHANGE
Definition: app-layer-ssl.c:225
g_disable_hashing
bool g_disable_hashing
Definition: suricata.c:218