From 6afaae156a9ab9de79474367d8873407f3b12a71 Mon Sep 17 00:00:00 2001 From: Neale Ranns Date: Wed, 17 Jul 2019 15:07:14 +0000 Subject: ipsec: GCM, Anti-replay and ESN fixess Type: fix Several Fixes: 1 - Anti-replay did not work with GCM becuase it overwrote the sequence number in the ESP header. To fix i added the seq num to the per-packet data so it is preserved 2 - The high sequence number was not byte swapped during ESP encrypt. 3 - openssl engine was the only one to return FAIL_DECRYPT for bad GCM the others return BAD_HMAC. removed the former 4 - improved tracing to show the low and high seq numbers 5 - documented the anti-replay window checks 6 - fixed scapy patch for ESN support for GCM 7 - tests for anti-reply (w/ and w/o ESN) for each crypto algo Change-Id: Id65d96b6d1d4dd821b2ab557e87468fff6d70e5b Signed-off-by: Neale Ranns --- src/plugins/crypto_openssl/main.c | 2 +- src/plugins/dpdk/ipsec/esp_decrypt.c | 6 +- src/vnet/crypto/crypto.h | 3 +- src/vnet/ipsec/ah_decrypt.c | 4 +- src/vnet/ipsec/esp_decrypt.c | 29 +++++--- src/vnet/ipsec/esp_encrypt.c | 9 ++- src/vnet/ipsec/ipsec_sa.h | 129 ++++++++++++++++++++++++++++------- 7 files changed, 135 insertions(+), 47 deletions(-) (limited to 'src') diff --git a/src/plugins/crypto_openssl/main.c b/src/plugins/crypto_openssl/main.c index fd749d04926..7362d6bd16e 100644 --- a/src/plugins/crypto_openssl/main.c +++ b/src/plugins/crypto_openssl/main.c @@ -169,7 +169,7 @@ openssl_ops_dec_gcm (vlib_main_t * vm, vnet_crypto_op_t * ops[], u32 n_ops, else { n_fail++; - op->status = VNET_CRYPTO_OP_STATUS_FAIL_DECRYPT; + op->status = VNET_CRYPTO_OP_STATUS_FAIL_BAD_HMAC; } } return n_ops - n_fail; diff --git a/src/plugins/dpdk/ipsec/esp_decrypt.c b/src/plugins/dpdk/ipsec/esp_decrypt.c index 4982db7ee6d..a82f63e6e5b 100644 --- a/src/plugins/dpdk/ipsec/esp_decrypt.c +++ b/src/plugins/dpdk/ipsec/esp_decrypt.c @@ -235,7 +235,8 @@ dpdk_esp_decrypt_inline (vlib_main_t * vm, } /* anti-replay check */ - if (ipsec_sa_anti_replay_check (sa0, &esp0->seq)) + if (ipsec_sa_anti_replay_check + (sa0, clib_host_to_net_u32 (esp0->seq))) { clib_warning ("failed anti-replay check"); if (is_ip6) @@ -549,7 +550,8 @@ dpdk_esp_decrypt_post_inline (vlib_main_t * vm, iv_size = cipher_alg->iv_len; - ipsec_sa_anti_replay_advance (sa0, esp0->seq); + ipsec_sa_anti_replay_advance (sa0, + clib_host_to_net_u32 (esp0->seq)); /* if UDP encapsulation is used adjust the address of the IP header */ if (ipsec_sa_is_set_UDP_ENCAP (sa0) diff --git a/src/vnet/crypto/crypto.h b/src/vnet/crypto/crypto.h index 9c15d53a6c1..9326a078f8a 100644 --- a/src/vnet/crypto/crypto.h +++ b/src/vnet/crypto/crypto.h @@ -65,8 +65,7 @@ typedef enum _(PENDING, "pending") \ _(COMPLETED, "completed") \ _(FAIL_NO_HANDLER, "no-handler") \ - _(FAIL_BAD_HMAC, "bad-hmac") \ - _(FAIL_DECRYPT, "decrypt-fail") + _(FAIL_BAD_HMAC, "bad-hmac") typedef enum { diff --git a/src/vnet/ipsec/ah_decrypt.c b/src/vnet/ipsec/ah_decrypt.c index 741fa91b95c..bc6b5c4ec9d 100644 --- a/src/vnet/ipsec/ah_decrypt.c +++ b/src/vnet/ipsec/ah_decrypt.c @@ -203,7 +203,7 @@ ah_decrypt_inline (vlib_main_t * vm, pd->seq = clib_host_to_net_u32 (ah0->seq_no); /* anti-replay check */ - if (ipsec_sa_anti_replay_check (sa0, &ah0->seq_no)) + if (ipsec_sa_anti_replay_check (sa0, pd->seq)) { b[0]->error = node->errors[AH_DECRYPT_ERROR_REPLAY]; next[0] = AH_DECRYPT_NEXT_DROP; @@ -303,7 +303,7 @@ ah_decrypt_inline (vlib_main_t * vm, if (PREDICT_TRUE (sa0->integ_alg != IPSEC_INTEG_ALG_NONE)) { - ipsec_sa_anti_replay_advance (sa0, clib_host_to_net_u32 (pd->seq)); + ipsec_sa_anti_replay_advance (sa0, pd->seq); } u16 ah_hdr_len = sizeof (ah_header_t) + pd->icv_size diff --git a/src/vnet/ipsec/esp_decrypt.c b/src/vnet/ipsec/esp_decrypt.c index 48f08f42e33..c2b9bf4dc0c 100644 --- a/src/vnet/ipsec/esp_decrypt.c +++ b/src/vnet/ipsec/esp_decrypt.c @@ -67,6 +67,8 @@ static char *esp_decrypt_error_strings[] = { typedef struct { u32 seq; + u32 sa_seq; + u32 sa_seq_hi; ipsec_crypto_alg_t crypto_alg; ipsec_integ_alg_t integ_alg; } esp_decrypt_trace_t; @@ -79,9 +81,11 @@ format_esp_decrypt_trace (u8 * s, va_list * args) CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); esp_decrypt_trace_t *t = va_arg (*args, esp_decrypt_trace_t *); - s = format (s, "esp: crypto %U integrity %U seq %u", - format_ipsec_crypto_alg, t->crypto_alg, - format_ipsec_integ_alg, t->integ_alg, t->seq); + s = + format (s, + "esp: crypto %U integrity %U pkt-seq %d sa-seq %u sa-seq-hi %u", + format_ipsec_crypto_alg, t->crypto_alg, format_ipsec_integ_alg, + t->integ_alg, t->seq, t->sa_seq, t->sa_seq_hi); return s; } @@ -99,12 +103,13 @@ typedef struct u64 sa_data; }; + u32 seq; i16 current_data; i16 current_length; u16 hdr_sz; } esp_decrypt_packet_data_t; -STATIC_ASSERT_SIZEOF (esp_decrypt_packet_data_t, 2 * sizeof (u64)); +STATIC_ASSERT_SIZEOF (esp_decrypt_packet_data_t, 3 * sizeof (u64)); #define ESP_ENCRYPT_PD_F_FD_TRANSPORT (1 << 2) @@ -177,6 +182,7 @@ esp_decrypt_inline (vlib_main_t * vm, pd->current_length = b[0]->current_length; pd->hdr_sz = pd->current_data - vnet_buffer (b[0])->l3_hdr_offset; payload = b[0]->data + pd->current_data; + pd->seq = clib_host_to_net_u32 (((esp_header_t *) payload)->seq); /* we need 4 extra bytes for HMAC calculation when ESN are used */ if (ipsec_sa_is_set_USE_ESN (sa0) && pd->icv_sz && @@ -188,7 +194,7 @@ esp_decrypt_inline (vlib_main_t * vm, } /* anti-reply check */ - if (ipsec_sa_anti_replay_check (sa0, &((esp_header_t *) payload)->seq)) + if (ipsec_sa_anti_replay_check (sa0, pd->seq)) { b[0]->error = node->errors[ESP_DECRYPT_ERROR_REPLAY]; next[0] = ESP_DECRYPT_NEXT_DROP; @@ -221,10 +227,11 @@ esp_decrypt_inline (vlib_main_t * vm, op->len = len; if (ipsec_sa_is_set_USE_ESN (sa0)) { - /* shift ICV for 4 bytes to insert ESN */ + /* shift ICV by 4 bytes to insert ESN */ + u32 seq_hi = clib_host_to_net_u32 (sa0->seq_hi); u8 tmp[ESP_MAX_ICV_SIZE], sz = sizeof (sa0->seq_hi); clib_memcpy_fast (tmp, payload + len, ESP_MAX_ICV_SIZE); - clib_memcpy_fast (payload + len, &sa0->seq_hi, sz); + clib_memcpy_fast (payload + len, &seq_hi, sz); clib_memcpy_fast (payload + len + sz, tmp, ESP_MAX_ICV_SIZE); op->len += sz; op->digest += sz; @@ -368,9 +375,8 @@ esp_decrypt_inline (vlib_main_t * vm, goto trace; sa0 = vec_elt_at_index (im->sad, pd->sa_index); - u8 *payload = b[0]->data + pd->current_data; - ipsec_sa_anti_replay_advance (sa0, ((esp_header_t *) payload)->seq); + ipsec_sa_anti_replay_advance (sa0, pd->seq); esp_footer_t *f = (esp_footer_t *) (b[0]->data + pd->current_data + pd->current_length - sizeof (*f) - @@ -485,13 +491,14 @@ esp_decrypt_inline (vlib_main_t * vm, if (PREDICT_FALSE (b[0]->flags & VLIB_BUFFER_IS_TRACED)) { esp_decrypt_trace_t *tr; - u8 *payload = b[0]->data + pd->current_data; tr = vlib_add_trace (vm, node, b[0], sizeof (*tr)); sa0 = pool_elt_at_index (im->sad, vnet_buffer (b[0])->ipsec.sad_index); tr->crypto_alg = sa0->crypto_alg; tr->integ_alg = sa0->integ_alg; - tr->seq = clib_host_to_net_u32 (((esp_header_t *) payload)->seq); + tr->seq = pd->seq; + tr->sa_seq = sa0->last_seq; + tr->sa_seq_hi = sa0->seq_hi; } /* next */ diff --git a/src/vnet/ipsec/esp_encrypt.c b/src/vnet/ipsec/esp_encrypt.c index 041b268975d..47c079d95d2 100644 --- a/src/vnet/ipsec/esp_encrypt.c +++ b/src/vnet/ipsec/esp_encrypt.c @@ -65,6 +65,7 @@ typedef struct u32 sa_index; u32 spi; u32 seq; + u32 sa_seq_hi; u8 udp_encap; ipsec_crypto_alg_t crypto_alg; ipsec_integ_alg_t integ_alg; @@ -80,8 +81,9 @@ format_esp_encrypt_trace (u8 * s, va_list * args) s = format (s, - "esp: sa-index %d spi %u (0x%08x) seq %u crypto %U integrity %U%s", - t->sa_index, t->spi, t->spi, t->seq, format_ipsec_crypto_alg, + "esp: sa-index %d spi %u (0x%08x) seq %u sa-seq-hi %u crypto %U integrity %U%s", + t->sa_index, t->spi, t->spi, t->seq, t->sa_seq_hi, + format_ipsec_crypto_alg, t->crypto_alg, format_ipsec_integ_alg, t->integ_alg, t->udp_encap ? " udp-encap-enabled" : ""); return s; @@ -521,7 +523,8 @@ esp_encrypt_inline (vlib_main_t * vm, vlib_node_runtime_t * node, sizeof (*tr)); tr->sa_index = sa_index0; tr->spi = sa0->spi; - tr->seq = sa0->seq - 1; + tr->seq = sa0->seq; + tr->sa_seq_hi = sa0->seq_hi; tr->udp_encap = ipsec_sa_is_set_UDP_ENCAP (sa0); tr->crypto_alg = sa0->crypto_alg; tr->integ_alg = sa0->integ_alg; diff --git a/src/vnet/ipsec/ipsec_sa.h b/src/vnet/ipsec/ipsec_sa.h index 811f4cabcf0..86d76b3ac0a 100644 --- a/src/vnet/ipsec/ipsec_sa.h +++ b/src/vnet/ipsec/ipsec_sa.h @@ -19,8 +19,6 @@ #include #include -#define IPSEC_SA_ANTI_REPLAY_WINDOW_SIZE (64) - #define foreach_ipsec_crypto_alg \ _ (0, NONE, "none") \ _ (1, AES_CBC_128, "aes-cbc-128") \ @@ -232,18 +230,34 @@ extern uword unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args); extern uword unformat_ipsec_key (unformat_input_t * input, va_list * args); +/* + * Anti Replay definitions + */ + +#define IPSEC_SA_ANTI_REPLAY_WINDOW_SIZE (64) +#define IPSEC_SA_ANTI_REPLAY_WINDOW_MAX_INDEX (IPSEC_SA_ANTI_REPLAY_WINDOW_SIZE-1) + +/* + * sequence number less than the lower bound are outside of the window + * From RFC4303 Appendix A: + * Bl = Tl - W + 1 + */ +#define IPSEC_SA_ANTI_REPLAY_WINDOW_LOWER_BOUND(_tl) (_tl - IPSEC_SA_ANTI_REPLAY_WINDOW_SIZE + 1) + +/* + * Anti replay check. + * inputs need to be in host byte order. + */ always_inline int -ipsec_sa_anti_replay_check (ipsec_sa_t * sa, u32 * seqp) +ipsec_sa_anti_replay_check (ipsec_sa_t * sa, u32 seq) { - u32 seq, diff, tl, th; + u32 diff, tl, th; + if ((sa->flags & IPSEC_SA_FLAG_USE_ANTI_REPLAY) == 0) return 0; - seq = clib_net_to_host_u32 (*seqp); - - if ((sa->flags & IPSEC_SA_FLAG_USE_ESN) == 0) + if (!ipsec_sa_is_set_USE_ESN (sa)) { - if (PREDICT_TRUE (seq > sa->last_seq)) return 0; @@ -261,50 +275,113 @@ ipsec_sa_anti_replay_check (ipsec_sa_t * sa, u32 * seqp) th = sa->last_seq_hi; diff = tl - seq; - if (PREDICT_TRUE (tl >= (IPSEC_SA_ANTI_REPLAY_WINDOW_SIZE - 1))) + if (PREDICT_TRUE (tl >= (IPSEC_SA_ANTI_REPLAY_WINDOW_MAX_INDEX))) { - if (seq >= (tl - IPSEC_SA_ANTI_REPLAY_WINDOW_SIZE + 1)) + /* + * the last sequence number VPP recieved is more than one + * window size greater than zero. + * Case A from RFC4303 Appendix A. + */ + if (seq < IPSEC_SA_ANTI_REPLAY_WINDOW_LOWER_BOUND (tl)) + { + /* + * the received sequence number is lower than the lower bound + * of the window, this could mean either a replay packet or that + * the high sequence number has wrapped. if it decrypts corrently + * then it's the latter. + */ + sa->seq_hi = th + 1; + return 0; + } + else { + /* + * the recieved sequence number greater than the low + * end of the window. + */ sa->seq_hi = th; if (seq <= tl) + /* + * The recieved seq number is within bounds of the window + * check if it's a duplicate + */ return (sa->replay_window & (1ULL << diff)) ? 1 : 0; else + /* + * The received sequence number is greater than the window + * upper bound. this packet will move the window along, assuming + * it decrypts correctly. + */ return 0; } - else - { - sa->seq_hi = th + 1; - return 0; - } } else { - if (seq >= (tl - IPSEC_SA_ANTI_REPLAY_WINDOW_SIZE + 1)) + /* + * the last sequence number VPP recieved is within one window + * size of zero, i.e. 0 < TL < WINDOW_SIZE, the lower bound is thus a + * large sequence number. + * Note that the check below uses unsiged integer arthimetic, so the + * RHS will be a larger number. + * Case B from RFC4303 Appendix A. + */ + if (seq < IPSEC_SA_ANTI_REPLAY_WINDOW_LOWER_BOUND (tl)) { - sa->seq_hi = th - 1; - return (sa->replay_window & (1ULL << diff)) ? 1 : 0; + /* + * the sequence number is less than the lower bound. + */ + if (seq <= tl) + { + /* + * the packet is within the window upper bound. + * check for duplicates. + */ + sa->seq_hi = th; + return (sa->replay_window & (1ULL << diff)) ? 1 : 0; + } + else + { + /* + * the packet is less the window lower bound or greater than + * the higher bound, depending on how you look at it... + * We're assuming, given that the last sequence number received, + * TL < WINDOW_SIZE, that a largeer seq num is more likely to be + * a packet that moves the window forward, than a packet that has + * wrapped the high sequence again. If it were the latter then + * we've lost close to 2^32 packets. + */ + sa->seq_hi = th; + return 0; + } } else { - sa->seq_hi = th; - if (seq <= tl) - return (sa->replay_window & (1ULL << diff)) ? 1 : 0; - else - return 0; + /* + * the packet seq number is between the lower bound (a large nubmer) + * and MAX_SEQ_NUM. This is in the window since the window upper bound + * tl > 0. + * However, since TL is the other side of 0 to the received + * packet, the SA has moved on to a higher sequence number. + */ + sa->seq_hi = th - 1; + return (sa->replay_window & (1ULL << diff)) ? 1 : 0; } } return 0; } +/* + * Anti replay window advance + * inputs need to be in host byte order. + */ always_inline void -ipsec_sa_anti_replay_advance (ipsec_sa_t * sa, u32 seqp) +ipsec_sa_anti_replay_advance (ipsec_sa_t * sa, u32 seq) { - u32 pos, seq; + u32 pos; if (PREDICT_TRUE (sa->flags & IPSEC_SA_FLAG_USE_ANTI_REPLAY) == 0) return; - seq = clib_host_to_net_u32 (seqp); if (PREDICT_TRUE (sa->flags & IPSEC_SA_FLAG_USE_ESN)) { int wrap = sa->seq_hi - sa->last_seq_hi; -- cgit 1.2.3-korg