/* Copyright (C) 2007-2010 Open Information Security Foundation * * You can copy, redistribute or modify this Program under the terms of * the GNU General Public License version 2 as published by the Free * Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * version 2 along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA * 02110-1301, USA. */ /** * \file * * \author Victor Julien * \author Gurvinder Singh * * App-layer detection of TLS * * \todo support for the newly find TLS handshake GAP vulnerbility */ #include "suricata-common.h" #include "debug.h" #include "decode.h" #include "threads.h" #include "util-print.h" #include "util-pool.h" #include "stream-tcp-private.h" #include "stream-tcp-reassemble.h" #include "stream-tcp.h" #include "stream.h" #include "app-layer-protos.h" #include "app-layer-parser.h" #include "app-layer-tls.h" #include "conf.h" #include "util-spm.h" #include "util-unittest.h" #include "util-debug.h" #include "flow-private.h" #include "util-byte.h" #define TLS_CHANGE_CIPHER_SPEC 0x14 /**< TLS change cipher spec content type */ #define TLS_ALERT_PROTOCOL 0x15 /**< TLS alert protocol content type */ #define TLS_HANDSHAKE_PROTOCOL 0x16 /**< TLS hansdshake protocol content type */ #define TLS_APPLICATION_PROTOCOL 0x17 /**< TLS application protocol content type */ /** * \brief Function to store the parsed TLS content type received from the client * * \param tls_state Pointer the state in which the value to be stored * \param pstate Application layer tarser state for this session * \param input Pointer the received content type value * \param input_len Length in bytes of the received content type value * \param output Pointer to the list of parsed elements */ static int TLSParseClientContentType(Flow *f, void *tls_state, AppLayerParserState *pstate, uint8_t *input, uint32_t input_len, AppLayerParserResult *output) { SCEnter(); TlsState *state = (TlsState *)tls_state; if (input == NULL) SCReturnInt(-1); if (input_len != 1) { SCReturnInt(-1); } /* check if we received the correct content type */ switch (*input) { case TLS_CHANGE_CIPHER_SPEC: case TLS_ALERT_PROTOCOL: case TLS_HANDSHAKE_PROTOCOL: case TLS_APPLICATION_PROTOCOL: break; default: SCReturnInt(0); } state->client_content_type = *input; SCLogDebug("content_type %02"PRIx8"", state->client_content_type); /* The content type 23 signifies the encryption application protocol has been started and check if we have received the change_cipher_spec before accepting this packet and setting up the flag */ if (state->client_content_type == TLS_APPLICATION_PROTOCOL && (state->flags & TLS_FLAG_CLIENT_CHANGE_CIPHER_SPEC) && (state->flags & TLS_FLAG_SERVER_CHANGE_CIPHER_SPEC)) { pstate->flags |= APP_LAYER_PARSER_DONE; pstate->flags |= APP_LAYER_PARSER_NO_INSPECTION; if (tls.no_reassemble == 1) pstate->flags |= APP_LAYER_PARSER_NO_REASSEMBLY; } /* The content type 0x14 signifies the change_cipher_spec message */ if (state->client_content_type == TLS_CHANGE_CIPHER_SPEC) state->flags |= TLS_FLAG_CLIENT_CHANGE_CIPHER_SPEC; SCReturnInt(0); } /** * \brief Function to store the parsed TLS content version received from the * client * * \param tls_state Pointer the state in which the value to be stored * \param pstate Application layer tarser state for this session * \param input Pointer the received TLS version value * \param input_len Length in bytes of the received version value * \param output Pointer to the list of parsed elements */ static int TLSParseClientVersion(Flow *f, void *tls_state, AppLayerParserState *pstate, uint8_t *input, uint32_t input_len, AppLayerParserResult *output) { SCEnter(); TlsState *state = (TlsState *)tls_state; if (input_len != 2) SCReturnInt(-1); /** \todo there must be an easier way to get from uint8_t * to a uint16_t */ struct u16conv_ { uint16_t u; } *u16conv; u16conv = (struct u16conv_ *)input; switch (ntohs(u16conv->u)) { case 0x0300: state->client_version = SSL_VERSION_3; break; case 0x0301: state->client_version = TLS_VERSION_10; break; case 0x0302: state->client_version = TLS_VERSION_11; break; case 0x0303: state->client_version = TLS_VERSION_12; break; } SCLogDebug("version %04"PRIx16"", state->client_version); SCReturnInt(0); } /** * \brief Function to parse the TLS field in packet received from the client * * \param tls_state Pointer the state in which the value to be stored * \param pstate Application layer tarser state for this session * \param input Pointer the received input data * \param input_len Length in bytes of the received data * \param output Pointer to the list of parsed output elements */ static int TLSParseClientRecord(Flow *f, void *tls_state, AppLayerParserState *pstate, uint8_t *input, uint32_t input_len, AppLayerParserResult *output) { SCEnter(); SCLogDebug("tls_state %p, pstate %p, input %p,input_len %" PRIu32 "", tls_state, pstate, input, input_len); //PrintRawDataFp(stdout, input,input_len); uint16_t max_fields = 3; int16_t u = 0; uint32_t offset = 0; if (pstate == NULL) SCReturnInt(-1); for (u = pstate->parse_field; u < max_fields; u++) { SCLogDebug("u %" PRIu32 "", u); switch(u % 3) { case 0: /* TLS CONTENT TYPE */ { uint8_t *data = input + offset; uint32_t data_len = input_len - offset; int r = AlpParseFieldBySize(output, pstate, TLS_FIELD_CLIENT_CONTENT_TYPE, /* single byte field */1, data, data_len, &offset); SCLogDebug("r = %" PRId32 "", r); if (r == 0) { pstate->parse_field = 0; SCReturnInt(0); } else if (r == -1) { SCLogError(SC_ERR_ALPARSER, "AlpParseFieldBySize failed, " "r %d", r); SCReturnInt(-1); } break; } case 1: /* TLS VERSION */ { uint8_t *data = input + offset; uint32_t data_len = input_len - offset; int r = AlpParseFieldBySize(output, pstate, TLS_FIELD_CLIENT_VERSION, /* 2 byte field */2, data, data_len, &offset); if (r == 0) { pstate->parse_field = 1; SCReturnInt(0); } else if (r == -1) { SCLogError(SC_ERR_ALPARSER, "AlpParseFieldBySize failed, " "r %d", r); SCReturnInt(-1); } break; } case 2: /* TLS Record Message Length */ { uint8_t *data = input + offset; uint32_t data_len = input_len - offset; int r = AlpParseFieldBySize(output, pstate, TLS_FIELD_LENGTH, /* 2 byte field */2, data, data_len, &offset); SCLogDebug("AlpParseFieldBySize returned r %d, offset %"PRIu32"" , r, offset); if (r == 0) { pstate->parse_field = 2; SCReturnInt(0); } else if (r == -1) { SCLogError(SC_ERR_ALPARSER, "AlpParseFieldBySize failed, " "r %d", r); SCReturnInt(-1); } /* Parsing of the record is done. Since we may have more than * one record, we check here if we still have data left *after* * this record. In that case setup the parser to parse that * record as well. */ uint16_t record_len; int ret = ByteExtractUint16(&record_len, BYTE_BIG_ENDIAN, output->tail->data_len, output->tail->data_ptr); if (ret != 2) { SCReturnInt(-1); } /* calulate the point up to where the current record * is in the data */ uint32_t record_offset = (offset + record_len); SCLogDebug("record offset %"PRIu32" (offset %"PRIu32", record_len" " %"PRIu16")", record_offset, offset, record_len); /* if our input buffer is bigger than the data up to and * including the current record, we instruct the parser to * expect another record of 3 fields */ if (input_len <= record_offset) break; max_fields += 3; offset += record_len; break; } } } pstate->parse_field = 0; SCReturnInt(1); } /** * \brief Function to parse the TLS field in packet received from the server * * \param tls_state Pointer the state in which the value to be stored * \param pstate Application layer tarser state for this session * \param input Pointer the received input data * \param input_len Length in bytes of the received data * \param output Pointer to the list of parsed output elements */ static int TLSParseServerRecord(Flow *f, void *tls_state, AppLayerParserState *pstate, uint8_t *input, uint32_t input_len, AppLayerParserResult *output) { SCEnter(); SCLogDebug("tls_state %p, pstate %p, input %p,input_len %" PRIu32 "", tls_state, pstate, input, input_len); //PrintRawDataFp(stdout, input,input_len); uint16_t max_fields = 3; int16_t u = 0; uint32_t offset = 0; if (pstate == NULL) SCReturnInt(-1); for (u = pstate->parse_field; u < max_fields; u++) { SCLogDebug("u %" PRIu32 "", u); switch(u % 3) { case 0: /* TLS CONTENT TYPE */ { uint8_t *data = input + offset; uint32_t data_len = input_len - offset; int r = AlpParseFieldBySize(output, pstate, TLS_FIELD_SERVER_CONTENT_TYPE, /* single byte field */1, data, data_len, &offset); SCLogDebug("r = %" PRId32 "", r); if (r == 0) { pstate->parse_field = 0; SCReturnInt(0); } else if (r == -1) { SCLogError(SC_ERR_ALPARSER, "AlpParseFieldBySize failed, " "r %d", r); SCReturnInt(-1); } break; } case 1: /* TLS VERSION */ { uint8_t *data = input + offset; uint32_t data_len = input_len - offset; int r = AlpParseFieldBySize(output, pstate, TLS_FIELD_SERVER_VERSION,/* 2 byte *field */2, data, data_len, &offset); if (r == 0) { pstate->parse_field = 1; SCReturnInt(0); } else if (r == -1) { SCLogError(SC_ERR_ALPARSER, "AlpParseFieldBySize failed, " "r %d", r); SCReturnInt(-1); } break; } case 2: /* TLS Record Message Length */ { uint8_t *data = input + offset; uint32_t data_len = input_len - offset; int r = AlpParseFieldBySize(output, pstate, TLS_FIELD_LENGTH, /* 2 byte field */2, data, data_len, &offset); if (r == 0) { pstate->parse_field = 2; SCReturnInt(0); } else if (r == -1) { SCLogError(SC_ERR_ALPARSER, "AlpParseFieldBySize failed, " "r %d", r); SCReturnInt(-1); } /* Parsing of the record is done. Since we may have more than * one record, we check here if we still have data left *after* * this record. In that case setup the parser to parse that * record as well. */ uint16_t record_len; int ret = ByteExtractUint16(&record_len, BYTE_BIG_ENDIAN, output->tail->data_len, output->tail->data_ptr); if (ret != 2) { SCReturnInt(-1); } /* calulate the point up to where the current record * is in the data */ uint32_t record_offset = (offset + record_len); SCLogDebug("record offset %"PRIu32" (offset %"PRIu32", record_len" " %"PRIu16")", record_offset, offset, record_len); /* if our input buffer is bigger than the data up to and * including the current record, we instruct the parser to * expect another record of 3 fields */ if (input_len <= record_offset) break; max_fields += 3; offset += record_len; break; } } } pstate->parse_field = 0; SCReturnInt(1); } /** * \brief Function to store the parsed TLS content version received from the * server * * \param tls_state Pointer the state in which the value to be stored * \param pstate Application layer tarser state for this session * \param input Pointer the received TLS version value * \param input_len Length in bytes of the received version value * \param output Pointer to the list of parsed elements */ static int TLSParseServerVersion(Flow *f, void *tls_state, AppLayerParserState *pstate, uint8_t *input, uint32_t input_len, AppLayerParserResult *output) { SCEnter(); TlsState *state = (TlsState *)tls_state; if (input_len != 2) SCReturnInt(-1); /** \todo there must be an easier way to get from uint8_t * to a uint16_t */ struct u16conv_ { uint16_t u; } *u16conv; u16conv = (struct u16conv_ *)input; switch (ntohs(u16conv->u)) { case 0x0300: state->server_version = SSL_VERSION_3; break; case 0x0301: state->server_version = TLS_VERSION_10; break; case 0x0302: state->server_version = TLS_VERSION_11; break; case 0x0303: state->server_version = TLS_VERSION_12; break; } SCLogDebug("version %04"PRIx16"", state->server_version); SCReturnInt(0); } /** * \brief Function to store the parsed TLS content type received from the server * * \param tls_state Pointer the state in which the value to be stored * \param pstate Application layer tarser state for this session * \param input Pointer the received content type value * \param input_len Length in bytes of the received content type value * \param output Pointer to the list of parsed elements */ static int TLSParseServerContentType(Flow *f, void *tls_state, AppLayerParserState *pstate, uint8_t *input, uint32_t input_len, AppLayerParserResult *output) { SCEnter(); TlsState *state = (TlsState *)tls_state; if (input == NULL) SCReturnInt(-1); if (input_len != 1) { SCReturnInt(-1); } /* check if we received the correct content type */ switch (*input) { case TLS_CHANGE_CIPHER_SPEC: case TLS_ALERT_PROTOCOL: case TLS_HANDSHAKE_PROTOCOL: case TLS_APPLICATION_PROTOCOL: break; default: SCReturnInt(0); } state->server_content_type = *input; SCLogDebug("content_type %02"PRIx8"", state->server_content_type); /* The content type 20 signifies the chage cipher spec message has been received and now onwards messages will be encrypted and authenticated */ if (state->server_content_type == TLS_CHANGE_CIPHER_SPEC) { pstate->flags |= APP_LAYER_PARSER_DONE; state->flags |= TLS_FLAG_SERVER_CHANGE_CIPHER_SPEC; } /* The content type 23 signifies the encryption application protocol has been started and check if we have received the change_cipher_spec before accepting this packet and setting up the flag */ if (state->client_content_type == TLS_APPLICATION_PROTOCOL && (state->flags & TLS_FLAG_CLIENT_CHANGE_CIPHER_SPEC) && (state->flags & TLS_FLAG_SERVER_CHANGE_CIPHER_SPEC)) { pstate->flags |= APP_LAYER_PARSER_DONE; pstate->flags |= APP_LAYER_PARSER_NO_INSPECTION; if (tls.no_reassemble == 1) pstate->flags |= APP_LAYER_PARSER_NO_REASSEMBLY; } SCReturnInt(0); } /** \brief Function to allocates the TLS state memory */ static void *TLSStateAlloc(void) { void *s = SCMalloc(sizeof(TlsState)); if (s == NULL) return NULL; memset(s, 0, sizeof(TlsState)); return s; } /** \brief Function to free the TLS state memory */ static void TLSStateFree(void *s) { SCFree(s); } /** \brief Function to register the TLS protocol parsers and other functions */ void RegisterTLSParsers(void) { AppLayerRegisterProto("tls", ALPROTO_TLS, STREAM_TOSERVER, TLSParseClientRecord); AppLayerRegisterParser("tls.client.content_type", ALPROTO_TLS, TLS_FIELD_CLIENT_CONTENT_TYPE, TLSParseClientContentType, "tls"); AppLayerRegisterParser("tls.client.version", ALPROTO_TLS, TLS_FIELD_CLIENT_VERSION, TLSParseClientVersion, "tls"); AppLayerRegisterProto("tls", ALPROTO_TLS, STREAM_TOCLIENT, TLSParseServerRecord); AppLayerRegisterParser("tls.server.content_type", ALPROTO_TLS, TLS_FIELD_SERVER_CONTENT_TYPE, TLSParseServerContentType, "tls"); AppLayerRegisterParser("tls.server.version", ALPROTO_TLS, TLS_FIELD_SERVER_VERSION, TLSParseServerVersion, "tls"); AppLayerRegisterStateFuncs(ALPROTO_TLS, TLSStateAlloc, TLSStateFree); /* Get the value of no reassembly option from the config file */ if(ConfGetBool("tls.no_reassemble", &tls.no_reassemble) != 1) tls.no_reassemble = 1; } /* UNITTESTS */ #ifdef UNITTESTS extern uint16_t AppLayerParserGetStorageId (void); /** \test Send a get request in one chunk. */ static int TLSParserTest01(void) { int result = 1; Flow f; uint8_t tlsbuf[] = { 0x16, 0x03, 0x01 }; uint32_t tlslen = sizeof(tlsbuf); TcpSession ssn; memset(&f, 0, sizeof(f)); memset(&ssn, 0, sizeof(ssn)); f.protoctx = (void *)&ssn; StreamTcpInitConfig(TRUE); FlowL7DataPtrInit(&f); int r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER|STREAM_EOF, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } TlsState *tls_state = f.aldata[AlpGetStateIdx(ALPROTO_TLS)]; if (tls_state == NULL) { printf("no tls state: "); result = 0; goto end; } if (tls_state->client_content_type != 0x16) { printf("expected content_type %" PRIu8 ", got %" PRIu8 ": ", 0x16, tls_state->client_content_type); result = 0; goto end; } if (tls_state->client_version != TLS_VERSION_10) { printf("expected version %04" PRIu16 ", got %04" PRIu16 ": ", TLS_VERSION_10, tls_state->client_version); result = 0; goto end; } end: FlowL7DataPtrFree(&f); StreamTcpFreeConfig(TRUE); return result; } /** \test Send a get request in two chunks. */ static int TLSParserTest02(void) { int result = 1; Flow f; uint8_t tlsbuf1[] = { 0x16 }; uint32_t tlslen1 = sizeof(tlsbuf1); uint8_t tlsbuf2[] = { 0x03, 0x01 }; uint32_t tlslen2 = sizeof(tlsbuf2); TcpSession ssn; memset(&f, 0, sizeof(f)); memset(&ssn, 0, sizeof(ssn)); f.protoctx = (void *)&ssn; StreamTcpInitConfig(TRUE); FlowL7DataPtrInit(&f); int r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf1, tlslen1); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf2, tlslen2); if (r != 0) { printf("toserver chunk 2 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } TlsState *tls_state = f.aldata[AlpGetStateIdx(ALPROTO_TLS)]; if (tls_state == NULL) { printf("no tls state: "); result = 0; goto end; } if (tls_state->client_content_type != 0x16) { printf("expected content_type %" PRIu8 ", got %" PRIu8 ": ", 0x16, tls_state->client_content_type); result = 0; goto end; } if (tls_state->client_version != TLS_VERSION_10) { printf("expected version %04" PRIu16 ", got %04" PRIu16 ": ", TLS_VERSION_10, tls_state->client_version); result = 0; goto end; } end: FlowL7DataPtrFree(&f); StreamTcpFreeConfig(TRUE); return result; } /** \test Send a get request in three chunks. */ static int TLSParserTest03(void) { int result = 1; Flow f; uint8_t tlsbuf1[] = { 0x16 }; uint32_t tlslen1 = sizeof(tlsbuf1); uint8_t tlsbuf2[] = { 0x03 }; uint32_t tlslen2 = sizeof(tlsbuf2); uint8_t tlsbuf3[] = { 0x01 }; uint32_t tlslen3 = sizeof(tlsbuf3); TcpSession ssn; memset(&f, 0, sizeof(f)); memset(&ssn, 0, sizeof(ssn)); f.protoctx = (void *)&ssn; StreamTcpInitConfig(TRUE); FlowL7DataPtrInit(&f); int r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf1, tlslen1); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf2, tlslen2); if (r != 0) { printf("toserver chunk 2 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf3, tlslen3); if (r != 0) { printf("toserver chunk 3 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } TlsState *tls_state = f.aldata[AlpGetStateIdx(ALPROTO_TLS)]; if (tls_state == NULL) { printf("no tls state: "); result = 0; goto end; } if (tls_state->client_content_type != 0x16) { printf("expected content_type %" PRIu8 ", got %" PRIu8 ": ", 0x16, tls_state->client_content_type); result = 0; goto end; } if (tls_state->client_version != TLS_VERSION_10) { printf("expected version %04" PRIu16 ", got %04" PRIu16 ": ", TLS_VERSION_10, tls_state->client_version); result = 0; goto end; } end: FlowL7DataPtrFree(&f); StreamTcpFreeConfig(TRUE); return result; } /** \test Send a get request in three chunks + more data. */ static int TLSParserTest04(void) { int result = 1; Flow f; uint8_t tlsbuf1[] = { 0x16 }; uint32_t tlslen1 = sizeof(tlsbuf1); uint8_t tlsbuf2[] = { 0x03 }; uint32_t tlslen2 = sizeof(tlsbuf2); uint8_t tlsbuf3[] = { 0x01 }; uint32_t tlslen3 = sizeof(tlsbuf3); uint8_t tlsbuf4[] = { 0x01, 0x00, 0x00, 0xad, 0x03, 0x01 }; uint32_t tlslen4 = sizeof(tlsbuf4); TcpSession ssn; memset(&f, 0, sizeof(f)); memset(&ssn, 0, sizeof(ssn)); f.protoctx = (void *)&ssn; StreamTcpInitConfig(TRUE); FlowL7DataPtrInit(&f); int r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf1, tlslen1); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf2, tlslen2); if (r != 0) { printf("toserver chunk 2 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf3, tlslen3); if (r != 0) { printf("toserver chunk 3 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf4, tlslen4); if (r != 0) { printf("toserver chunk 4 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } TlsState *tls_state = f.aldata[AlpGetStateIdx(ALPROTO_TLS)]; if (tls_state == NULL) { printf("no tls state: "); result = 0; goto end; } if (tls_state->client_content_type != 0x16) { printf("expected content_type %" PRIu8 ", got %" PRIu8 ": ", 0x16, tls_state->client_content_type); result = 0; goto end; } if (tls_state->client_version != TLS_VERSION_10) { printf("expected version %04" PRIu16 ", got %04" PRIu16 ": ", TLS_VERSION_10, tls_state->client_version); result = 0; goto end; } end: FlowL7DataPtrFree(&f); StreamTcpFreeConfig(TRUE); return result; } /** \test Test the setting up of no reassembly and no payload inspection flag * after detection of the TLS handshake completion */ static int TLSParserTest05(void) { int result = 1; Flow f; uint8_t tlsbuf[] = { 0x16, 0x03, 0x01, 0x00, 0x01 }; uint32_t tlslen = sizeof(tlsbuf); TcpSession ssn; memset(&f, 0, sizeof(f)); memset(&ssn, 0, sizeof(ssn)); f.protoctx = (void *)&ssn; StreamTcpInitConfig(TRUE); FlowL7DataPtrInit(&f); int r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOCLIENT, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } tlsbuf[0] = 0x14; r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } tlsbuf[0] = 0x14; r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOCLIENT, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } tlsbuf[0] = 0x17; r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } TlsState *tls_state = f.aldata[AlpGetStateIdx(ALPROTO_TLS)]; if (tls_state == NULL) { printf("no tls state: "); result = 0; goto end; } if (tls_state->client_content_type != 0x17) { printf("expected content_type %" PRIu8 ", got %" PRIu8 ": ", 0x17, tls_state->client_content_type); result = 0; goto end; } if (tls_state->client_version != TLS_VERSION_10) { printf("expected version %04" PRIu16 ", got %04" PRIu16 ": ", TLS_VERSION_10, tls_state->client_version); result = 0; goto end; } uint16_t app_layer_sid = AppLayerParserGetStorageId(); AppLayerParserStateStore *parser_state_store = (AppLayerParserStateStore *) f.aldata[app_layer_sid]; AppLayerParserState *parser_state = &parser_state_store->to_server; if (!(parser_state->flags & APP_LAYER_PARSER_NO_INSPECTION) && !(ssn.flags & STREAMTCP_FLAG_NOCLIENT_REASSEMBLY) && !(ssn.flags & STREAMTCP_FLAG_NOSERVER_REASSEMBLY)) { printf("The flags should be set\n"); result = 0; goto end; } if (!(f.flags & FLOW_NOPAYLOAD_INSPECTION)) { printf("The flags should be set\n"); result = 0; goto end; } end: FlowL7DataPtrFree(&f); StreamTcpFreeConfig(TRUE); return result; } /** \test Test the setting up of no reassembly and no payload inspection flag * after detection of the valid TLS handshake completion, the rouge * 0x17 packet will not be considered in the detection process */ static int TLSParserTest06(void) { int result = 1; Flow f; uint8_t tlsbuf[] = { 0x16, 0x03, 0x01, 0x00, 0x01 }; uint32_t tlslen = sizeof(tlsbuf); TcpSession ssn; memset(&f, 0, sizeof(f)); memset(&ssn, 0, sizeof(ssn)); f.protoctx = (void *)&ssn; StreamTcpInitConfig(TRUE); FlowL7DataPtrInit(&f); int r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOCLIENT, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } tlsbuf[0] = 0x14; r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } tlsbuf[0] = 0x17; r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } TlsState *tls_state = f.aldata[AlpGetStateIdx(ALPROTO_TLS)]; if (tls_state == NULL) { printf("no tls state: "); result = 0; goto end; } if (tls_state->client_content_type != 0x17) { printf("expected content_type %" PRIu8 ", got %" PRIu8 ": ", 0x17, tls_state->client_content_type); result = 0; goto end; } if (tls_state->client_version != TLS_VERSION_10) { printf("expected version %04" PRIu16 ", got %04" PRIu16 ": ", TLS_VERSION_10, tls_state->client_version); result = 0; goto end; } uint16_t app_layer_sid = AppLayerParserGetStorageId(); AppLayerParserStateStore *parser_state_store = (AppLayerParserStateStore *) f.aldata[app_layer_sid]; AppLayerParserState *parser_state = &parser_state_store->to_server; if ((parser_state->flags & APP_LAYER_PARSER_NO_INSPECTION) || (ssn.flags & STREAMTCP_FLAG_NOCLIENT_REASSEMBLY) || (ssn.flags & STREAMTCP_FLAG_NOSERVER_REASSEMBLY)) { printf("The flags should not be set\n"); result = 0; goto end; } tlsbuf[0] = 0x14; r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOCLIENT, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } tlsbuf[0] = 0x17; r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } if (!(parser_state->flags & APP_LAYER_PARSER_NO_INSPECTION) && !(ssn.flags & STREAMTCP_FLAG_NOCLIENT_REASSEMBLY) && !(ssn.flags & STREAMTCP_FLAG_NOSERVER_REASSEMBLY)) { printf("The flags should be set\n"); result = 0; goto end; } if (!(f.flags & FLOW_NOPAYLOAD_INSPECTION)) { printf("The flags should be set\n"); result = 0; goto end; } end: FlowL7DataPtrFree(&f); StreamTcpFreeConfig(TRUE); return result; } /** \test multimsg test */ static int TLSParserMultimsgTest01(void) { int result = 1; Flow f; /* 3 msgs */ uint8_t tlsbuf1[] = { 0x16, 0x03, 0x01, 0x00, 0x86, 0x10, 0x00, 0x00, 0x82, 0x00, 0x80, 0xd3, 0x6f, 0x1f, 0x63, 0x82, 0x8d, 0x75, 0x77, 0x8c, 0x91, 0xbc, 0xa1, 0x3d, 0xbb, 0xe1, 0xb5, 0xd3, 0x31, 0x92, 0x59, 0x2b, 0x2c, 0x43, 0x96, 0xa3, 0xaa, 0x23, 0x92, 0xd0, 0x91, 0x2a, 0x5e, 0x10, 0x5b, 0xc8, 0xc1, 0xe2, 0xd3, 0x5c, 0x8b, 0x8c, 0x91, 0x9e, 0xc2, 0xf2, 0x9c, 0x3c, 0x4f, 0x37, 0x1e, 0x20, 0x5e, 0x33, 0xd5, 0xf0, 0xd6, 0xaf, 0x89, 0xf5, 0xcc, 0xb2, 0xcf, 0xc1, 0x60, 0x3a, 0x46, 0xd5, 0x4e, 0x2a, 0xb6, 0x6a, 0xb9, 0xfc, 0x32, 0x8b, 0xe0, 0x6e, 0xa0, 0xed, 0x25, 0xa0, 0xa4, 0x82, 0x81, 0x73, 0x90, 0xbf, 0xb5, 0xde, 0xeb, 0x51, 0x8d, 0xde, 0x5b, 0x6f, 0x94, 0xee, 0xba, 0xe5, 0x69, 0xfa, 0x1a, 0x80, 0x30, 0x54, 0xeb, 0x12, 0x01, 0xb9, 0xfe, 0xbf, 0x82, 0x95, 0x01, 0x7b, 0xb0, 0x97, 0x14, 0xc2, 0x06, 0x3c, 0x69, 0xfb, 0x1c, 0x66, 0x47, 0x17, 0xd9, 0x14, 0x03, 0x01, 0x00, 0x01, 0x01, 0x16, 0x03, 0x01, 0x00, 0x30, 0xf6, 0xbc, 0x0d, 0x6f, 0xe8, 0xbb, 0xaa, 0xbf, 0x14, 0xeb, 0x7b, 0xcc, 0x6c, 0x28, 0xb0, 0xfc, 0xa6, 0x01, 0x2a, 0x97, 0x96, 0x17, 0x5e, 0xe8, 0xb4, 0x4e, 0x78, 0xc9, 0x04, 0x65, 0x53, 0xb6, 0x93, 0x3d, 0xeb, 0x44, 0xee, 0x86, 0xf9, 0x80, 0x49, 0x45, 0x21, 0x34, 0xd1, 0xee, 0xc8, 0x9c }; uint32_t tlslen1 = sizeof(tlsbuf1); TcpSession ssn; memset(&f, 0, sizeof(f)); memset(&ssn, 0, sizeof(ssn)); f.protoctx = (void *)&ssn; StreamTcpInitConfig(TRUE); FlowL7DataPtrInit(&f); int r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf1, tlslen1); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } TlsState *tls_state = f.aldata[AlpGetStateIdx(ALPROTO_TLS)]; if (tls_state == NULL) { printf("no tls state: "); result = 0; goto end; } if (tls_state->client_content_type != 0x16) { printf("expected content_type %" PRIu8 ", got %" PRIu8 ": ", 0x16, tls_state->client_content_type); result = 0; goto end; } if (tls_state->client_version != TLS_VERSION_10) { printf("expected version %04" PRIu16 ", got %04" PRIu16 ": ", TLS_VERSION_10, tls_state->client_version); result = 0; goto end; } end: FlowL7DataPtrFree(&f); StreamTcpFreeConfig(TRUE); return result; } /** \test multimsg test server */ static int TLSParserMultimsgTest02(void) { int result = 1; Flow f; /* 3 msgs */ uint8_t tlsbuf1[] = { 0x16, 0x03, 0x01, 0x00, 0x86, 0x10, 0x00, 0x00, 0x82, 0x00, 0x80, 0xd3, 0x6f, 0x1f, 0x63, 0x82, 0x8d, 0x75, 0x77, 0x8c, 0x91, 0xbc, 0xa1, 0x3d, 0xbb, 0xe1, 0xb5, 0xd3, 0x31, 0x92, 0x59, 0x2b, 0x2c, 0x43, 0x96, 0xa3, 0xaa, 0x23, 0x92, 0xd0, 0x91, 0x2a, 0x5e, 0x10, 0x5b, 0xc8, 0xc1, 0xe2, 0xd3, 0x5c, 0x8b, 0x8c, 0x91, 0x9e, 0xc2, 0xf2, 0x9c, 0x3c, 0x4f, 0x37, 0x1e, 0x20, 0x5e, 0x33, 0xd5, 0xf0, 0xd6, 0xaf, 0x89, 0xf5, 0xcc, 0xb2, 0xcf, 0xc1, 0x60, 0x3a, 0x46, 0xd5, 0x4e, 0x2a, 0xb6, 0x6a, 0xb9, 0xfc, 0x32, 0x8b, 0xe0, 0x6e, 0xa0, 0xed, 0x25, 0xa0, 0xa4, 0x82, 0x81, 0x73, 0x90, 0xbf, 0xb5, 0xde, 0xeb, 0x51, 0x8d, 0xde, 0x5b, 0x6f, 0x94, 0xee, 0xba, 0xe5, 0x69, 0xfa, 0x1a, 0x80, 0x30, 0x54, 0xeb, 0x12, 0x01, 0xb9, 0xfe, 0xbf, 0x82, 0x95, 0x01, 0x7b, 0xb0, 0x97, 0x14, 0xc2, 0x06, 0x3c, 0x69, 0xfb, 0x1c, 0x66, 0x47, 0x17, 0xd9, 0x14, 0x03, 0x01, 0x00, 0x01, 0x01, 0x16, 0x03, 0x01, 0x00, 0x30, 0xf6, 0xbc, 0x0d, 0x6f, 0xe8, 0xbb, 0xaa, 0xbf, 0x14, 0xeb, 0x7b, 0xcc, 0x6c, 0x28, 0xb0, 0xfc, 0xa6, 0x01, 0x2a, 0x97, 0x96, 0x17, 0x5e, 0xe8, 0xb4, 0x4e, 0x78, 0xc9, 0x04, 0x65, 0x53, 0xb6, 0x93, 0x3d, 0xeb, 0x44, 0xee, 0x86, 0xf9, 0x80, 0x49, 0x45, 0x21, 0x34, 0xd1, 0xee, 0xc8, 0x9c }; uint32_t tlslen1 = sizeof(tlsbuf1); TcpSession ssn; memset(&f, 0, sizeof(f)); memset(&ssn, 0, sizeof(ssn)); f.protoctx = (void *)&ssn; StreamTcpInitConfig(TRUE); FlowL7DataPtrInit(&f); int r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOCLIENT, tlsbuf1, tlslen1); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } TlsState *tls_state = f.aldata[AlpGetStateIdx(ALPROTO_TLS)]; if (tls_state == NULL) { printf("no tls state: "); result = 0; goto end; } if (tls_state->server_content_type != 0x16) { printf("expected content_type %" PRIu8 ", got %" PRIu8 ": ", 0x16, tls_state->server_content_type); result = 0; goto end; } if (tls_state->server_version != 0x0301) { printf("expected version %04" PRIu16 ", got %04" PRIu16 ": ", 0x0301, tls_state->server_version); result = 0; goto end; } end: FlowL7DataPtrFree(&f); StreamTcpFreeConfig(TRUE); return result; } /** * \test Test the detection of SSLv3 protocol from the given packet */ static int TLSParserTest07(void) { int result = 1; Flow f; uint8_t tlsbuf[] = { 0x16, 0x03, 0x00, 0x00, 0x6f, 0x01, 0x00, 0x00, 0x6b, 0x03, 0x00, 0x4b, 0x2f, 0xdc, 0x4e, 0xe6, 0x95, 0xf1, 0xa0, 0xc7, 0xcf, 0x8e, 0xf6, 0xeb, 0x22, 0x6d, 0xce, 0x9c, 0x44, 0xfb, 0xc8, 0xa0, 0x44, 0x31, 0x15, 0x4c, 0xe9, 0x97, 0xa7, 0xa1, 0xfe, 0xea, 0xcc, 0x20, 0x4b, 0x5d, 0xfb, 0xa5, 0x63, 0x7a, 0x73, 0x95, 0xf7, 0xff, 0x42, 0xac, 0x8f, 0x46, 0xed, 0xe4, 0xb1, 0x35, 0x35, 0x78, 0x1a, 0x9d, 0xaf, 0x10, 0xc5, 0x52, 0xf3, 0x7b, 0xfb, 0xb5, 0xe9, 0xa8, 0x00, 0x24, 0x00, 0x88, 0x00, 0x87, 0x00, 0x39, 0x00, 0x38, 0x00, 0x84, 0x00, 0x35, 0x00, 0x45, 0x00, 0x44, 0x00, 0x33, 0x00, 0x32, 0x00, 0x96, 0x00, 0x41, 0x00, 0x2f, 0x00, 0x16, 0x00, 0x13, 0xfe, 0xff, 0x00, 0x0a, 0x00, 0x02, 0x01, 0x00 }; uint32_t tlslen = sizeof(tlsbuf); TcpSession ssn; memset(&f, 0, sizeof(f)); memset(&ssn, 0, sizeof(ssn)); f.protoctx = (void *)&ssn; StreamTcpInitConfig(TRUE); FlowL7DataPtrInit(&f); int r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } TlsState *tls_state = f.aldata[AlpGetStateIdx(ALPROTO_TLS)]; if (tls_state == NULL) { printf("no tls state: "); result = 0; goto end; } if (tls_state->client_content_type != 0x16) { printf("expected content_type %" PRIu8 ", got %" PRIu8 ": ", 0x17, tls_state->client_content_type); result = 0; goto end; } if (tls_state->client_version != SSL_VERSION_3) { printf("expected version %04" PRIu16 ", got %04" PRIu16 ": ", SSL_VERSION_3, tls_state->client_version); result = 0; goto end; } end: FlowL7DataPtrFree(&f); StreamTcpFreeConfig(TRUE); return result; } /** \test Test the setting up of no reassembly and no payload inspection flag * after detection of the SSLv3 handshake completion */ static int TLSParserTest08(void) { int result = 1; Flow f; uint8_t tlsbuf[] = { 0x16, 0x03, 0x00, 0x00, 0x01 }; uint32_t tlslen = sizeof(tlsbuf); TcpSession ssn; memset(&f, 0, sizeof(f)); memset(&ssn, 0, sizeof(ssn)); f.protoctx = (void *)&ssn; StreamTcpInitConfig(TRUE); FlowL7DataPtrInit(&f); int r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOCLIENT, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } tlsbuf[0] = 0x14; r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } tlsbuf[0] = 0x14; r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOCLIENT, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } tlsbuf[0] = 0x17; r = AppLayerParse(&f, ALPROTO_TLS, STREAM_TOSERVER, tlsbuf, tlslen); if (r != 0) { printf("toserver chunk 1 returned %" PRId32 ", expected 0: ", r); result = 0; goto end; } TlsState *tls_state = f.aldata[AlpGetStateIdx(ALPROTO_TLS)]; if (tls_state == NULL) { printf("no tls state: "); result = 0; goto end; } if (tls_state->client_content_type != 0x17) { printf("expected content_type %" PRIu8 ", got %" PRIu8 ": ", 0x17, tls_state->client_content_type); result = 0; goto end; } if (tls_state->client_version != SSL_VERSION_3) { printf("expected version %04" PRIu16 ", got %04" PRIu16 ": ", SSL_VERSION_3, tls_state->client_version); result = 0; goto end; } uint16_t app_layer_sid = AppLayerParserGetStorageId(); AppLayerParserStateStore *parser_state_store = (AppLayerParserStateStore *) f.aldata[app_layer_sid]; AppLayerParserState *parser_state = &parser_state_store->to_server; if (!(parser_state->flags & APP_LAYER_PARSER_NO_INSPECTION) && !(ssn.flags & STREAMTCP_FLAG_NOCLIENT_REASSEMBLY) && !(ssn.flags & STREAMTCP_FLAG_NOSERVER_REASSEMBLY)) { printf("The flags should be set\n"); result = 0; goto end; } if (!(f.flags & FLOW_NOPAYLOAD_INSPECTION)) { printf("The flags should be set\n"); result = 0; goto end; } end: FlowL7DataPtrFree(&f); StreamTcpFreeConfig(TRUE); return result; } #endif /* UNITTESTS */ void TLSParserRegisterTests(void) { #ifdef UNITTESTS UtRegisterTest("TLSParserTest01", TLSParserTest01, 1); UtRegisterTest("TLSParserTest02", TLSParserTest02, 1); UtRegisterTest("TLSParserTest03", TLSParserTest03, 1); UtRegisterTest("TLSParserTest04", TLSParserTest04, 1); UtRegisterTest("TLSParserTest05", TLSParserTest05, 1); UtRegisterTest("TLSParserTest06", TLSParserTest06, 1); UtRegisterTest("TLSParserTest07", TLSParserTest07, 1); UtRegisterTest("TLSParserTest08", TLSParserTest08, 1); UtRegisterTest("TLSParserMultimsgTest01", TLSParserMultimsgTest01, 1); UtRegisterTest("TLSParserMultimsgTest02", TLSParserMultimsgTest02, 1); #endif /* UNITTESTS */ }