ikev2: add SA dump API

Type: feature
Ticket: VPP-1897

Change-Id: I0245aceeb344efd29b1f9217c35889a8bbe1f744
Signed-off-by: jan_cavojsky <Jan.Cavojsky@pantheon.tech>
Signed-off-by: Filip Tehlar <ftehlar@cisco.com>

5 files changed, 907 insertions, 6 deletions

diff --git a/src/plugins/ikev2/ikev2.api b/src/plugins/ikev2/ikev2.api
index 2a1a6d6365b..1e1dbf9589d 100644
--- a/src/plugins/ikev2/ikev2.api
+++ b/src/plugins/ikev2/ikev2.api
@@ -1,6 +1,6 @@
 /* Hey Emacs use -*- mode: C -*- */
 /*
- * Copyright (c) 2015-2016 Cisco and/or its affiliates.
+ * Copyright (c) 2015-2020 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -64,6 +64,129 @@ define ikev2_profile_details
   option status="in_progress";
 };
 
+/** \brief Dump all SAs
+    @param client_index - opaque cookie to identify the sender
+    @param context - sender context, to match reply w/ request
+*/
+define ikev2_sa_dump
+{
+  u32 client_index;
+  u32 context;
+
+  option status = "in_progress";
+};
+
+/** \brief Details about IKE SA
+    @param context - sender context, to match reply w/ request
+    @param retval - return code
+    @param sa - SA data
+*/
+define ikev2_sa_details
+{
+  u32 context;
+  i32 retval;
+
+  vl_api_ikev2_sa_t sa;
+  option status = "in_progress";
+};
+
+/** \brief Dump child SA of specific SA
+    @param client_index - opaque cookie to identify the sender
+    @param context - sender context, to match reply w/ request
+    @param sa_index - index of specific sa
+*/
+define ikev2_child_sa_dump
+{
+  u32 client_index;
+  u32 context;
+
+  u32 sa_index;
+  option vat_help = "sa_index <index>";
+  option status = "in_progress";
+};
+
+/** \brief Child SA details
+    @param context - sender context, to match reply w/ request
+    @param retval - return code
+    @param child_sa - child SA data
+*/
+define ikev2_child_sa_details
+{
+  u32 context;
+  i32 retval;
+
+  vl_api_ikev2_child_sa_t child_sa;
+  option status = "in_progress";
+};
+
+/** \brief get specific nonce
+    @param client_index - opaque cookie to identify the sender
+    @param context - sender context, to match reply w/ request
+    @param is_initiator - specify type initiator|responder of nonce
+    @param sa_index - index of specific sa
+*/
+define ikev2_nonce_get
+{
+  u32 client_index;
+  u32 context;
+
+  bool is_initiator;
+  u32 sa_index;
+  option vat_help = "initiator|responder sa_index <index>";
+  option status = "in_progress";
+};
+
+/** \brief reply on specific nonce
+    @param context - sender context, to match reply w/ request
+    @param retval - return code
+    @param data_len - nonce length
+    @param nonce - nonce data
+*/
+
+define ikev2_nonce_get_reply
+{
+  u32 context;
+  i32 retval;
+
+  u32 data_len;
+  u8 nonce[data_len];
+  option status = "in_progress";
+};
+
+/** \brief dump traffic selectors
+    @param client_index - opaque cookie to identify the sender
+    @param context - sender context, to match reply w/ request
+    @param is_initiator - specify type initiator|responder of nonce
+    @param sa_index - index of specific sa
+    @param child_sa_index - index of specific sa child of specific sa
+*/
+
+define ikev2_traffic_selector_dump
+{
+  u32 client_index;
+  u32 context;
+
+  bool is_initiator;
+  u32 sa_index;
+  u32 child_sa_index;
+  option vat_help = "initiator|responder sa_index <index> child_sa_index <index>";
+  option status = "in_progress";
+};
+
+/** \brief details on specific traffic selector
+    @param context - sender context, to match reply w/ request
+    @param retval - return code
+    @param ts - traffic selector data
+*/
+
+define ikev2_traffic_selector_details
+{
+  u32 context;
+  i32 retval;
+
+  vl_api_ikev2_ts_t ts;
+  option status = "in_progress";
+};
 
 /** \brief IKEv2: Add/delete profile
     @param client_index - opaque cookie to identify the sender
diff --git a/src/plugins/ikev2/ikev2_api.c b/src/plugins/ikev2/ikev2_api.c
index f1ff40a8a0a..c73505b2421 100644
--- a/src/plugins/ikev2/ikev2_api.c
+++ b/src/plugins/ikev2/ikev2_api.c
@@ -32,6 +32,7 @@
 
 
 #define vl_endianfun		/* define message structures */
+#include <plugins/ikev2/ikev2.api.h>
 #include <plugins/ikev2/ikev2_types.api.h>
 #undef vl_endianfun
 
@@ -42,6 +43,19 @@ extern ikev2_main_t ikev2_main;
 #define REPLY_MSG_ID_BASE ikev2_main.msg_id_base
 #include <vlibapi/api_helper_macros.h>
 
+static u32
+ikev2_encode_sa_index (u32 sai, u32 ti)
+{
+  return (ti << 16) | sai;
+}
+
+static void
+ikev2_decode_sa_index (u32 api_sai, u32 * sai, u32 * ti)
+{
+  *sai = api_sai & 0xffff;
+  *ti = api_sai >> 16;
+}
+
 static void
 cp_ike_transforms (vl_api_ikev2_ike_transforms_t * vl_api_ts,
 		   ikev2_transforms_set * ts)
@@ -105,6 +119,18 @@ cp_responder (vl_api_ikev2_responder_t * vl_api_responder,
   ip4_address_encode (&responder->ip4, vl_api_responder->ip4);
 }
 
+void
+cp_sa_transform (vl_api_ikev2_sa_transform_t * vl_tr,
+		 ikev2_sa_transform_t * tr)
+{
+  vl_tr->transform_type = tr->type;
+  vl_tr->key_len = tr->key_len;
+  vl_tr->key_trunc = tr->key_trunc;
+  vl_tr->block_size = tr->block_size;
+  vl_tr->dh_group = tr->dh_group;
+  vl_tr->transform_id = tr->encr_type;
+}
+
 static void
 send_profile (ikev2_profile_t * profile, vl_api_registration_t * reg,
 	      u32 context)
@@ -169,6 +195,257 @@ vl_api_ikev2_profile_dump_t_handler (vl_api_ikev2_profile_dump_t * mp)
 }
 
 static void
+send_sa (ikev2_sa_t * sa, vl_api_ikev2_sa_dump_t * mp, u32 api_sa_index)
+{
+  vl_api_ikev2_sa_details_t *rmp = 0;
+  int rv = 0;
+  ikev2_sa_transform_t *tr;
+
+  /* *INDENT-OFF* */
+  REPLY_MACRO2_ZERO (VL_API_IKEV2_SA_DETAILS,
+  {
+    vl_api_ikev2_sa_t *rsa = &rmp->sa;
+    vl_api_ikev2_keys_t* k = &rsa->keys;
+    rsa->profile_index = rsa->profile_index;
+    rsa->sa_index = api_sa_index;
+    ip4_address_encode (&sa->iaddr, rsa->iaddr);
+    ip4_address_encode (&sa->raddr, rsa->raddr);
+    rsa->ispi = sa->ispi;
+    rsa->rspi = sa->rspi;
+    cp_id(&rsa->i_id, &sa->i_id);
+    cp_id(&rsa->r_id, &sa->r_id);
+
+    tr = ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
+    if (tr)
+      cp_sa_transform (&rsa->encryption, tr);
+
+    tr = ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
+    if (tr)
+      cp_sa_transform (&rsa->prf, tr);
+
+    tr = ikev2_sa_get_td_for_type (sa->r_proposals,
+                                   IKEV2_TRANSFORM_TYPE_INTEG);
+    if (tr)
+      cp_sa_transform (&rsa->integrity, tr);
+
+    tr = ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_DH);
+    if (tr)
+      cp_sa_transform (&rsa->dh, tr);
+
+    k->sk_d_len = vec_len (sa->sk_d);
+    clib_memcpy (&k->sk_d, sa->sk_d, k->sk_d_len);
+
+    k->sk_ai_len = vec_len (sa->sk_ai);
+    clib_memcpy (&k->sk_ai, sa->sk_ai, k->sk_ai_len);
+
+    k->sk_ar_len = vec_len (sa->sk_ar);
+    clib_memcpy (&k->sk_ar, sa->sk_ar, k->sk_ar_len);
+
+    k->sk_ei_len = vec_len (sa->sk_ei);
+    clib_memcpy (&k->sk_ei, sa->sk_ei, k->sk_ei_len);
+
+    k->sk_er_len = vec_len (sa->sk_er);
+    clib_memcpy (&k->sk_er, sa->sk_er, k->sk_er_len);
+
+    k->sk_pi_len = vec_len (sa->sk_pi);
+    clib_memcpy (&k->sk_pi, sa->sk_pi, k->sk_pi_len);
+
+    k->sk_pr_len = vec_len (sa->sk_pr);
+    clib_memcpy (&k->sk_pr, sa->sk_pr, k->sk_pr_len);
+
+    vl_api_ikev2_sa_t_endian(rsa);
+  });
+  /* *INDENT-ON* */
+}
+
+static void
+vl_api_ikev2_sa_dump_t_handler (vl_api_ikev2_sa_dump_t * mp)
+{
+  ikev2_main_t *km = &ikev2_main;
+  ikev2_main_per_thread_data_t *tkm;
+  ikev2_sa_t *sa;
+
+  vec_foreach (tkm, km->per_thread_data)
+  {
+    /* *INDENT-OFF* */
+    pool_foreach (sa, tkm->sas,
+    ({
+      u32 api_sa_index = ikev2_encode_sa_index (sa - tkm->sas,
+                                              tkm - km->per_thread_data);
+      send_sa (sa, mp, api_sa_index);
+    }));
+    /* *INDENT-ON* */
+  }
+}
+
+
+static void
+send_child_sa (ikev2_child_sa_t * child,
+	       vl_api_ikev2_child_sa_dump_t * mp, u32 child_sa_index,
+	       u32 sa_index)
+{
+  vl_api_ikev2_child_sa_details_t *rmp = 0;
+  int rv = 0;
+  ikev2_sa_transform_t *tr;
+
+  /* *INDENT-OFF* */
+  REPLY_MACRO2_ZERO (VL_API_IKEV2_CHILD_SA_DETAILS,
+  {
+    vl_api_ikev2_keys_t *k = &rmp->child_sa.keys;
+    rmp->child_sa.child_sa_index = child_sa_index;
+    rmp->child_sa.sa_index = sa_index;
+    rmp->child_sa.i_spi =
+      child->i_proposals ? child->i_proposals[0].spi : 0;
+    rmp->child_sa.r_spi =
+      child->r_proposals ? child->r_proposals[0].spi : 0;
+
+    tr = ikev2_sa_get_td_for_type (child->r_proposals,
+                                   IKEV2_TRANSFORM_TYPE_ENCR);
+    if (tr)
+      cp_sa_transform (&rmp->child_sa.encryption, tr);
+
+    tr = ikev2_sa_get_td_for_type (child->r_proposals,
+                                   IKEV2_TRANSFORM_TYPE_INTEG);
+    if (tr)
+      cp_sa_transform (&rmp->child_sa.integrity, tr);
+
+    tr = ikev2_sa_get_td_for_type (child->r_proposals,
+                                   IKEV2_TRANSFORM_TYPE_ESN);
+    if (tr)
+      cp_sa_transform (&rmp->child_sa.esn, tr);
+
+    k->sk_ei_len = vec_len (child->sk_ei);
+    clib_memcpy (&k->sk_ei, child->sk_ei, k->sk_ei_len);
+
+    k->sk_er_len = vec_len (child->sk_er);
+    clib_memcpy (&k->sk_er, child->sk_er, k->sk_er_len);
+
+    if (vec_len (child->sk_ai))
+      {
+        k->sk_ai_len = vec_len (child->sk_ai);
+        clib_memcpy (&k->sk_ai, child->sk_ai,
+		     k->sk_ai_len);
+
+        k->sk_ar_len = vec_len (child->sk_ar);
+        clib_memcpy (&k->sk_ar, child->sk_ar,
+		     k->sk_ar_len);
+      }
+
+    vl_api_ikev2_child_sa_t_endian (&rmp->child_sa);
+  });
+  /* *INDENT-ON* */
+}
+
+static void
+vl_api_ikev2_child_sa_dump_t_handler (vl_api_ikev2_child_sa_dump_t * mp)
+{
+  ikev2_main_t *im = &ikev2_main;
+  ikev2_main_per_thread_data_t *tkm;
+  ikev2_sa_t *sa;
+  ikev2_child_sa_t *child;
+  u32 sai = ~0, ti = ~0;
+
+  ikev2_decode_sa_index (clib_net_to_host_u32 (mp->sa_index), &sai, &ti);
+
+  if (vec_len (im->per_thread_data) <= ti)
+    return;
+
+  tkm = vec_elt_at_index (im->per_thread_data, ti);
+
+  if (pool_len (tkm->sas) <= sai || pool_is_free_index (tkm->sas, sai))
+    return;
+
+  sa = pool_elt_at_index (tkm->sas, sai);
+
+  vec_foreach (child, sa->childs)
+  {
+    u32 child_sa_index = child - sa->childs;
+    send_child_sa (child, mp, child_sa_index, sai);
+  }
+}
+
+static void
+  vl_api_ikev2_traffic_selector_dump_t_handler
+  (vl_api_ikev2_traffic_selector_dump_t * mp)
+{
+  ikev2_main_t *im = &ikev2_main;
+  ikev2_main_per_thread_data_t *tkm;
+  ikev2_sa_t *sa;
+  ikev2_child_sa_t *child;
+  ikev2_ts_t *ts;
+  u32 sai = ~0, ti = ~0;
+
+  u32 api_sa_index = clib_net_to_host_u32 (mp->sa_index);
+  u32 child_sa_index = clib_net_to_host_u32 (mp->child_sa_index);
+  ikev2_decode_sa_index (api_sa_index, &sai, &ti);
+
+  if (vec_len (im->per_thread_data) <= ti)
+    return;
+
+  tkm = vec_elt_at_index (im->per_thread_data, ti);
+
+  if (pool_len (tkm->sas) <= sai || pool_is_free_index (tkm->sas, sai))
+    return;
+
+  sa = pool_elt_at_index (tkm->sas, sai);
+
+  if (vec_len (sa->childs) <= child_sa_index)
+    return;
+
+  child = vec_elt_at_index (sa->childs, child_sa_index);
+
+  vec_foreach (ts, mp->is_initiator ? child->tsi : child->tsr)
+  {
+    vl_api_ikev2_traffic_selector_details_t *rmp = 0;
+    int rv = 0;
+
+    /* *INDENT-OFF* */
+    REPLY_MACRO2_ZERO (VL_API_IKEV2_TRAFFIC_SELECTOR_DETAILS,
+    {
+      rmp->ts.sa_index = api_sa_index;
+      rmp->ts.child_sa_index = child_sa_index;
+      cp_ts (&rmp->ts, ts, mp->is_initiator);
+      vl_api_ikev2_ts_t_endian (&rmp->ts);
+    });
+    /* *INDENT-ON* */
+  }
+}
+
+static void
+vl_api_ikev2_nonce_get_t_handler (vl_api_ikev2_nonce_get_t * mp)
+{
+  ikev2_main_t *im = &ikev2_main;
+  ikev2_main_per_thread_data_t *tkm;
+  ikev2_sa_t *sa;
+  u32 sai = ~0, ti = ~0;
+
+  ikev2_decode_sa_index (clib_net_to_host_u32 (mp->sa_index), &sai, &ti);
+
+  if (vec_len (im->per_thread_data) <= ti)
+    return;
+
+  tkm = vec_elt_at_index (im->per_thread_data, ti);
+
+  if (pool_len (tkm->sas) <= sai || pool_is_free_index (tkm->sas, sai))
+    return;
+
+  sa = pool_elt_at_index (tkm->sas, sai);
+
+  u8 *nonce = mp->is_initiator ? sa->i_nonce : sa->r_nonce;
+  vl_api_ikev2_nonce_get_reply_t *rmp = 0;
+  int data_len = vec_len (nonce);
+  int rv = 0;
+
+  /* *INDENT-OFF* */
+  REPLY_MACRO3_ZERO (VL_API_IKEV2_NONCE_GET_REPLY, data_len,
+  {
+    rmp->data_len = clib_host_to_net_u32 (data_len);
+    clib_memcpy (rmp->nonce, nonce, data_len);
+  });
+  /* *INDENT-ON* */
+}
+
+static void
 vl_api_ikev2_plugin_get_version_t_handler (vl_api_ikev2_plugin_get_version_t *
 					   mp)
 {
diff --git a/src/plugins/ikev2/ikev2_test.c b/src/plugins/ikev2/ikev2_test.c
index fae47726783..222f01ad123 100644
--- a/src/plugins/ikev2/ikev2_test.c
+++ b/src/plugins/ikev2/ikev2_test.c
@@ -34,6 +34,10 @@
 #include <ikev2/ikev2.api_types.h>
 #include <vpp/api/vpe.api_types.h>
 
+#define vl_endianfun		/* define message structures */
+#include <plugins/ikev2/ikev2.api.h>
+#undef vl_endianfun
+
 typedef struct
 {
   /* API message ID base */
@@ -93,15 +97,24 @@ MACRO_FORMAT (auth_method)
 #define _(v,f,str) case IKEV2_ID_TYPE_##f: t = str; break;
   MACRO_FORMAT (id_type)
 #undef _
+#define _(v,f,str) case IKEV2_TRANSFORM_TYPE_##f: t = str; break;
+  MACRO_FORMAT (transform_type)
+#undef _
 #define _(v,f,str) case IKEV2_TRANSFORM_ENCR_TYPE_##f: t = str; break;
   MACRO_FORMAT (transform_encr_type)
 #undef _
+#define _(v,f,str) case IKEV2_TRANSFORM_PRF_TYPE_##f: t = str; break;
+  MACRO_FORMAT (transform_prf_type)
+#undef _
 #define _(v,f,str) case IKEV2_TRANSFORM_INTEG_TYPE_##f: t = str; break;
   MACRO_FORMAT (transform_integ_type)
 #undef _
 #define _(v,f,str) case IKEV2_TRANSFORM_DH_TYPE_##f: t = str; break;
   MACRO_FORMAT (transform_dh_type)
 #undef _
+#define _(v,f,str) case IKEV2_TRANSFORM_ESN_TYPE_##f: t = str; break;
+  MACRO_FORMAT (transform_esn_type)
+#undef _
      u8 *format_ikev2_id_type_and_data (u8 * s, va_list * args)
 {
   vl_api_ikev2_id_t *id = va_arg (*args, vl_api_ikev2_id_t *);
@@ -134,6 +147,50 @@ MACRO_FORMAT (auth_method)
   return s;
 }
 
+u8 *
+format_ikev2_sa_transform (u8 * s, va_list * args)
+{
+  vl_api_ikev2_sa_transform_t *tr =
+    va_arg (*args, vl_api_ikev2_sa_transform_t *);
+
+  if (!tr)
+    return s;
+
+  if (tr->transform_type >= IKEV2_TRANSFORM_NUM_TYPES)
+    return s;
+
+  s = format (s, "%U:", format_ikev2_transform_type, tr->transform_type);
+
+  switch (tr->transform_type)
+    {
+    case IKEV2_TRANSFORM_TYPE_ENCR:
+      s =
+	format (s, "%U", format_ikev2_transform_encr_type, tr->transform_id);
+      break;
+    case IKEV2_TRANSFORM_TYPE_PRF:
+      s = format (s, "%U", format_ikev2_transform_prf_type, tr->transform_id);
+      break;
+    case IKEV2_TRANSFORM_TYPE_INTEG:
+      s =
+	format (s, "%U", format_ikev2_transform_integ_type, tr->transform_id);
+      break;
+    case IKEV2_TRANSFORM_TYPE_DH:
+      s = format (s, "%U", format_ikev2_transform_dh_type, tr->transform_id);
+      break;
+    case IKEV2_TRANSFORM_TYPE_ESN:
+      s = format (s, "%U", format_ikev2_transform_esn_type, tr->transform_id);
+      break;
+    default:
+      break;
+    }
+
+  if (tr->transform_type == IKEV2_TRANSFORM_TYPE_ENCR &&
+      tr->transform_id == IKEV2_TRANSFORM_ENCR_TYPE_AES_CBC && tr->key_len)
+    s = format (s, "-%u", tr->key_len * 8);
+
+  return s;
+}
+
 static int
 api_ikev2_profile_dump (vat_main_t * vam)
 {
@@ -155,8 +212,6 @@ api_ikev2_profile_dump (vat_main_t * vam)
   mp_ping->_vl_msg_id = htons (ik->ping_id);
   mp_ping->client_index = vam->my_client_index;
 
-  fformat (vam->ofp, "Sending ping id=%d\n", ik->ping_id);
-
   vam->result_ready = 0;
   S (mp_ping);
 
@@ -260,6 +315,298 @@ static void vl_api_ikev2_profile_details_t_handler
 }
 
 static int
+api_ikev2_sa_dump (vat_main_t * vam)
+{
+  ikev2_test_main_t *im = &ikev2_test_main;
+  vl_api_ikev2_sa_dump_t *mp;
+  vl_api_control_ping_t *mp_ping;
+  int ret;
+
+  /* Construct the API message */
+  M (IKEV2_SA_DUMP, mp);
+
+  /* send it... */
+  S (mp);
+
+  /* Use a control ping for synchronization */
+  if (!im->ping_id)
+    im->ping_id = vl_msg_api_get_msg_index ((u8 *) (VL_API_CONTROL_PING_CRC));
+  mp_ping = vl_msg_api_alloc_as_if_client (sizeof (*mp_ping));
+  mp_ping->_vl_msg_id = htons (im->ping_id);
+  mp_ping->client_index = vam->my_client_index;
+  vam->result_ready = 0;
+
+  S (mp_ping);
+
+  /* Wait for a reply... */
+  W (ret);
+  return ret;
+}
+
+static void
+vl_api_ikev2_sa_details_t_handler (vl_api_ikev2_sa_details_t * mp)
+{
+  vat_main_t *vam = ikev2_test_main.vat_main;
+  vl_api_ikev2_sa_t *sa = &mp->sa;
+  ip4_address_t iaddr;
+  ip4_address_t raddr;
+  vl_api_ikev2_keys_t *k = &sa->keys;
+  vl_api_ikev2_sa_t_endian (sa);
+
+  ip4_address_decode (sa->iaddr, &iaddr);
+  ip4_address_decode (sa->raddr, &raddr);
+
+  fformat (vam->ofp, "profile index %d sa index: %d\n",
+	   mp->sa.profile_index, mp->sa.sa_index);
+  fformat (vam->ofp, " iip %U ispi %lx rip %U rspi %lx\n", format_ip4_address,
+	   &iaddr, sa->ispi, format_ip4_address, &raddr, sa->rspi);
+  fformat (vam->ofp, " %U ", format_ikev2_sa_transform, &sa->encryption);
+  fformat (vam->ofp, "%U ", format_ikev2_sa_transform, &sa->prf);
+  fformat (vam->ofp, "%U ", format_ikev2_sa_transform, &sa->integrity);
+  fformat (vam->ofp, "%U \n", format_ikev2_sa_transform, &sa->dh);
+
+  fformat (vam->ofp, "  SK_d    %U\n",
+	   format_hex_bytes, k->sk_d, k->sk_d_len);
+
+  fformat (vam->ofp, "  SK_a  i:%U\n        r:%U\n",
+	   format_hex_bytes, k->sk_ai, k->sk_ai_len, format_hex_bytes,
+	   k->sk_ar, k->sk_ar_len);
+
+  fformat (vam->ofp, "  SK_e  i:%U\n        r:%U\n", format_hex_bytes,
+	   k->sk_ei, k->sk_ei_len, format_hex_bytes, k->sk_er, k->sk_er_len);
+
+  fformat (vam->ofp, "  SK_p  i:%U\n        r:%U\n", format_hex_bytes,
+	   k->sk_pi, k->sk_pi_len, format_hex_bytes, k->sk_pr, k->sk_pr_len);
+
+  fformat (vam->ofp, "  identifier (i) %U\n",
+	   format_ikev2_id_type_and_data, &sa->i_id);
+  fformat (vam->ofp, "  identifier (r) %U\n",
+	   format_ikev2_id_type_and_data, &sa->r_id);
+
+  vam->result_ready = 1;
+}
+
+static int
+api_ikev2_child_sa_dump (vat_main_t * vam)
+{
+  unformat_input_t *i = vam->input;
+  ikev2_test_main_t *im = &ikev2_test_main;
+  vl_api_ikev2_child_sa_dump_t *mp;
+  vl_api_control_ping_t *mp_ping;
+  int ret;
+  u32 sa_index = ~0;
+
+  while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (i, "sa_index %d", &sa_index))
+	;
+      else
+	{
+	  errmsg ("parse error '%U'", format_unformat_error, i);
+	  return -99;
+	}
+    }
+
+  if (sa_index == ~0)
+    return -99;
+
+  /* Construct the API message */
+  M (IKEV2_CHILD_SA_DUMP, mp);
+
+  mp->sa_index = clib_net_to_host_u32 (sa_index);
+
+  /* send it... */
+  S (mp);
+
+  /* Use a control ping for synchronization */
+  if (!im->ping_id)
+    im->ping_id = vl_msg_api_get_msg_index ((u8 *) (VL_API_CONTROL_PING_CRC));
+  mp_ping = vl_msg_api_alloc_as_if_client (sizeof (*mp_ping));
+  mp_ping->_vl_msg_id = htons (im->ping_id);
+  mp_ping->client_index = vam->my_client_index;
+  vam->result_ready = 0;
+
+  S (mp_ping);
+
+  /* Wait for a reply... */
+  W (ret);
+  return ret;
+}
+
+static void
+vl_api_ikev2_child_sa_details_t_handler (vl_api_ikev2_child_sa_details_t * mp)
+{
+  vat_main_t *vam = ikev2_test_main.vat_main;
+  vl_api_ikev2_child_sa_t *child_sa = &mp->child_sa;
+  vl_api_ikev2_keys_t *k = &child_sa->keys;
+  vl_api_ikev2_child_sa_t_endian (child_sa);
+
+  fformat (vam->ofp, "  child sa %u:\n", child_sa->child_sa_index);
+
+  fformat (vam->ofp, "    %U ", format_ikev2_sa_transform,
+	   &child_sa->encryption);
+  fformat (vam->ofp, "%U ", format_ikev2_sa_transform, &child_sa->integrity);
+  fformat (vam->ofp, "%U \n", format_ikev2_sa_transform, &child_sa->esn);
+
+  fformat (vam->ofp, "    spi(i) %lx spi(r) %lx\n",
+	   child_sa->i_spi, child_sa->r_spi);
+
+  fformat (vam->ofp, "    SK_e  i:%U\n          r:%U\n",
+	   format_hex_bytes, k->sk_ei, k->sk_ei_len,
+	   format_hex_bytes, k->sk_er, k->sk_er_len);
+  if (k->sk_ai_len)
+    {
+      fformat (vam->ofp, "    SK_a  i:%U\n          r:%U\n",
+	       format_hex_bytes, k->sk_ai, k->sk_ai_len,
+	       format_hex_bytes, k->sk_ar, k->sk_ar_len);
+    }
+  vam->result_ready = 1;
+}
+
+static int
+api_ikev2_traffic_selector_dump (vat_main_t * vam)
+{
+  unformat_input_t *i = vam->input;
+  ikev2_test_main_t *im = &ikev2_test_main;
+  vl_api_ikev2_traffic_selector_dump_t *mp;
+  vl_api_control_ping_t *mp_ping;
+  int is_initiator = ~0;
+  int sa_index = ~0;
+  int child_sa_index = ~0;
+  int ret;
+
+  while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (i, "initiator"))
+	is_initiator = 1;
+      else if (unformat (i, "responder"))
+	is_initiator = 0;
+      else if (unformat (i, "sa_index %d", &sa_index))
+	;
+      else if (unformat (i, "child_sa_index %d", &child_sa_index))
+	;
+      else
+	{
+	  errmsg ("parse error '%U'", format_unformat_error, i);
+	  return -99;
+	}
+    }
+
+  if (child_sa_index == ~0 || sa_index == ~0 || is_initiator == ~0)
+    return -99;
+
+  /* Construct the API message */
+  M (IKEV2_TRAFFIC_SELECTOR_DUMP, mp);
+
+  mp->is_initiator = is_initiator;
+  mp->sa_index = clib_host_to_net_u32 (sa_index);
+  mp->child_sa_index = clib_host_to_net_u32 (child_sa_index);
+
+  /* send it... */
+  S (mp);
+
+  /* Use a control ping for synchronization */
+  if (!im->ping_id)
+    im->ping_id = vl_msg_api_get_msg_index ((u8 *) (VL_API_CONTROL_PING_CRC));
+  mp_ping = vl_msg_api_alloc_as_if_client (sizeof (*mp_ping));
+  mp_ping->_vl_msg_id = htons (im->ping_id);
+  mp_ping->client_index = vam->my_client_index;
+  vam->result_ready = 0;
+
+  S (mp_ping);
+
+  /* Wait for a reply... */
+  W (ret);
+  return ret;
+}
+
+static void
+  vl_api_ikev2_traffic_selector_details_t_handler
+  (vl_api_ikev2_traffic_selector_details_t * mp)
+{
+  vat_main_t *vam = ikev2_test_main.vat_main;
+  vl_api_ikev2_ts_t *ts = &mp->ts;
+  ip4_address_t start_addr;
+  ip4_address_t end_addr;
+  vl_api_ikev2_ts_t_endian (ts);
+
+  ip4_address_decode (ts->start_addr, &start_addr);
+  ip4_address_decode (ts->end_addr, &end_addr);
+
+  fformat (vam->ofp, " %s protocol_id %u addr "
+	   "%U - %U port %u - %u\n",
+	   ts->is_local, ts->protocol_id,
+	   format_ip4_address, &start_addr,
+	   format_ip4_address, &end_addr, ts->start_port, ts->end_port);
+  vam->result_ready = 1;
+}
+
+static int
+api_ikev2_nonce_get (vat_main_t * vam)
+{
+  unformat_input_t *i = vam->input;
+  ikev2_test_main_t *im = &ikev2_test_main;
+  vl_api_ikev2_nonce_get_t *mp;
+  vl_api_control_ping_t *mp_ping;
+  u32 is_initiator = ~0;
+  u32 sa_index = ~0;
+  int ret;
+
+  while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (i, "initiator"))
+	is_initiator = 1;
+      else if (unformat (i, "responder"))
+	is_initiator = 0;
+      else if (unformat (i, "sa_index %d", &sa_index))
+	;
+      else
+	{
+	  errmsg ("parse error '%U'", format_unformat_error, i);
+	  return -99;
+	}
+    }
+
+  if (sa_index == ~0 || is_initiator == ~0)
+    return -99;
+
+  /* Construct the API message */
+  M (IKEV2_NONCE_GET, mp);
+
+  mp->is_initiator = is_initiator;
+  mp->sa_index = clib_host_to_net_u32 (sa_index);
+
+  /* send it... */
+  S (mp);
+
+  /* Use a control ping for synchronization */
+  if (!im->ping_id)
+    im->ping_id = vl_msg_api_get_msg_index ((u8 *) (VL_API_CONTROL_PING_CRC));
+  mp_ping = vl_msg_api_alloc_as_if_client (sizeof (*mp_ping));
+  mp_ping->_vl_msg_id = htons (im->ping_id);
+  mp_ping->client_index = vam->my_client_index;
+  vam->result_ready = 0;
+
+  S (mp_ping);
+
+  /* Wait for a reply... */
+  W (ret);
+  return ret;
+}
+
+static void
+vl_api_ikev2_nonce_get_reply_t_handler (vl_api_ikev2_nonce_get_reply_t * mp)
+{
+  vat_main_t *vam = ikev2_test_main.vat_main;
+  mp->data_len = clib_net_to_host_u32 (mp->data_len);
+
+  fformat (vam->ofp, "  nonce:%U\n",
+	   format_hex_bytes, mp->nonce, mp->data_len);
+
+  vam->result_ready = 1;
+}
+
+static int
 api_ikev2_plugin_get_version (vat_main_t * vam)
 {
   ikev2_test_main_t *sm = &ikev2_test_main;
diff --git a/src/plugins/ikev2/ikev2_types.api b/src/plugins/ikev2/ikev2_types.api
index bee48f8cef0..58297c05e9c 100644
--- a/src/plugins/ikev2/ikev2_types.api
+++ b/src/plugins/ikev2/ikev2_types.api
@@ -1,6 +1,6 @@
 /* Hey Emacs use -*- mode: C -*- */
 /*
- * Copyright (c) 2015-2016 Cisco and/or its affiliates.
+ * Copyright (c) 2015-2020 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -27,6 +27,9 @@ typedef ikev2_id
 
 typedef ikev2_ts
 {
+  u32 sa_index;
+  u32 child_sa_index;
+
   bool is_local;
   u8 protocol_id;
   u16 start_port;
@@ -83,3 +86,65 @@ typedef ikev2_profile
   bool udp_encap;
   vl_api_ikev2_auth_t auth;
 };
+
+typedef ikev2_sa_transform
+{
+  u8 transform_type;
+  u16 transform_id;
+  u16 key_len;
+  u16 key_trunc;
+  u16 block_size;
+  u8 dh_group;
+};
+
+typedef ikev2_keys
+{
+  u8 sk_d[64];
+  u8 sk_d_len;
+  u8 sk_ai[64];
+  u8 sk_ai_len;
+  u8 sk_ar[64];
+  u8 sk_ar_len;
+  u8 sk_ei[64];
+  u8 sk_ei_len;
+  u8 sk_er[64];
+  u8 sk_er_len;
+  u8 sk_pi[64];
+  u8 sk_pi_len;
+  u8 sk_pr[64];
+  u8 sk_pr_len;
+};
+
+typedef ikev2_child_sa
+{
+  u32 sa_index;
+  u32 child_sa_index;
+  u32 i_spi;
+  u32 r_spi;
+  vl_api_ikev2_keys_t keys;
+  vl_api_ikev2_sa_transform_t encryption;
+  vl_api_ikev2_sa_transform_t integrity;
+  vl_api_ikev2_sa_transform_t esn;
+};
+
+typedef ikev2_sa
+{
+  u32 sa_index;
+  u32 profile_index;
+
+  u64 ispi;
+  u64 rspi;
+  vl_api_ip4_address_t  iaddr;
+  vl_api_ip4_address_t  raddr;
+
+  vl_api_ikev2_keys_t keys;
+
+  /* ID */
+  vl_api_ikev2_id_t i_id;
+  vl_api_ikev2_id_t r_id;
+
+  vl_api_ikev2_sa_transform_t encryption;
+  vl_api_ikev2_sa_transform_t integrity;
+  vl_api_ikev2_sa_transform_t prf;
+  vl_api_ikev2_sa_transform_t dh;
+};
diff --git a/src/plugins/ikev2/test/test_ikev2.py b/src/plugins/ikev2/test/test_ikev2.py
index 02d1bde8f3d..6116ebb29a7 100644
--- a/src/plugins/ikev2/test/test_ikev2.py
+++ b/src/plugins/ikev2/test/test_ikev2.py
@@ -415,6 +415,8 @@ class IKEv2SA(object):
         c = self.child_sas[0]
         ts1 = ikev2.IPv4TrafficSelector(
                 IP_protocol_ID=0,
+                start_port=0,
+                end_port=0xffff,
                 starting_address_v4=c.local_ts['start_addr'],
                 ending_address_v4=c.local_ts['end_addr'])
         ts2 = ikev2.IPv4TrafficSelector(
@@ -692,7 +694,7 @@ class TemplateResponder(VppTestCase):
         plain = self.sa.hmac_and_decrypt(ike)
         self.sa.calc_child_keys()
 
-    def verify_child_sas(self):
+    def verify_ipsec_sas(self):
         sas = self.vapi.ipsec_sa_dump()
         self.assertEqual(len(sas), 2)
         sa0 = sas[0].entry
@@ -726,10 +728,97 @@ class TemplateResponder(VppTestCase):
             self.assertEqual(sa0.salt.to_bytes(4, 'little'), c.salt_er)
             self.assertEqual(sa1.salt.to_bytes(4, 'little'), c.salt_ei)
 
+    def verify_keymat(self, api_keys, keys, name):
+        km = getattr(keys, name)
+        api_km = getattr(api_keys, name)
+        api_km_len = getattr(api_keys, name + '_len')
+        self.assertEqual(len(km), api_km_len)
+        self.assertEqual(km, api_km[:api_km_len])
+
+    def verify_id(self, api_id, exp_id):
+        self.assertEqual(api_id.type, IDType.value(exp_id.type))
+        self.assertEqual(api_id.data_len, exp_id.data_len)
+        self.assertEqual(bytes(api_id.data, 'ascii'), exp_id.type)
+
+    def verify_ike_sas(self):
+        r = self.vapi.ikev2_sa_dump()
+        self.assertEqual(len(r), 1)
+        sa = r[0].sa
+        self.assertEqual(self.sa.ispi, (sa.ispi).to_bytes(8, 'little'))
+        self.assertEqual(self.sa.rspi, (sa.rspi).to_bytes(8, 'big'))
+        self.assertEqual(sa.iaddr, IPv4Address(self.pg0.remote_ip4))
+        self.assertEqual(sa.raddr, IPv4Address(self.pg0.local_ip4))
+        self.verify_keymat(sa.keys, self.sa, 'sk_d')
+        self.verify_keymat(sa.keys, self.sa, 'sk_ai')
+        self.verify_keymat(sa.keys, self.sa, 'sk_ar')
+        self.verify_keymat(sa.keys, self.sa, 'sk_ei')
+        self.verify_keymat(sa.keys, self.sa, 'sk_er')
+        self.verify_keymat(sa.keys, self.sa, 'sk_pi')
+        self.verify_keymat(sa.keys, self.sa, 'sk_pr')
+
+        self.assertEqual(sa.i_id.type, self.sa.id_type)
+        self.assertEqual(sa.r_id.type, self.sa.id_type)
+        self.assertEqual(sa.i_id.data_len, len(self.sa.i_id))
+        self.assertEqual(sa.r_id.data_len, len(self.sa.r_id))
+        self.assertEqual(bytes(sa.i_id.data, 'ascii'), self.sa.i_id)
+        self.assertEqual(bytes(sa.r_id.data, 'ascii'), self.sa.r_id)
+
+        r = self.vapi.ikev2_child_sa_dump(sa_index=sa.sa_index)
+        self.assertEqual(len(r), 1)
+        csa = r[0].child_sa
+        self.assertEqual(csa.sa_index, sa.sa_index)
+        c = self.sa.child_sas[0]
+        if hasattr(c, 'sk_ai'):
+            self.verify_keymat(csa.keys, c, 'sk_ai')
+            self.verify_keymat(csa.keys, c, 'sk_ar')
+        self.verify_keymat(csa.keys, c, 'sk_ei')
+        self.verify_keymat(csa.keys, c, 'sk_er')
+
+        tsi, tsr = self.sa.generate_ts()
+        tsi = tsi[0]
+        tsr = tsr[0]
+        r = self.vapi.ikev2_traffic_selector_dump(
+                is_initiator=True, sa_index=sa.sa_index,
+                child_sa_index=csa.child_sa_index)
+        self.assertEqual(len(r), 1)
+        ts = r[0].ts
+        self.verify_ts(r[0].ts, tsi[0], True)
+
+        r = self.vapi.ikev2_traffic_selector_dump(
+                is_initiator=False, sa_index=sa.sa_index,
+                child_sa_index=csa.child_sa_index)
+        self.assertEqual(len(r), 1)
+        self.verify_ts(r[0].ts, tsr[0], False)
+
+        n = self.vapi.ikev2_nonce_get(is_initiator=True,
+                                      sa_index=sa.sa_index)
+        self.verify_nonce(n, self.sa.i_nonce)
+        n = self.vapi.ikev2_nonce_get(is_initiator=False,
+                                      sa_index=sa.sa_index)
+        self.verify_nonce(n, self.sa.r_nonce)
+
+    def verify_nonce(self, api_nonce, nonce):
+        self.assertEqual(api_nonce.data_len, len(nonce))
+        self.assertEqual(api_nonce.nonce, nonce)
+
+    def verify_ts(self, api_ts, ts, is_initiator):
+        if is_initiator:
+            self.assertTrue(api_ts.is_local)
+        else:
+            self.assertFalse(api_ts.is_local)
+        self.assertEqual(api_ts.start_addr,
+                         IPv4Address(ts.starting_address_v4))
+        self.assertEqual(api_ts.end_addr,
+                         IPv4Address(ts.ending_address_v4))
+        self.assertEqual(api_ts.start_port, ts.start_port)
+        self.assertEqual(api_ts.end_port, ts.end_port)
+        self.assertEqual(api_ts.protocol_id, ts.IP_protocol_ID)
+
     def test_responder(self):
         self.send_sa_init(self.sa.natt)
         self.send_sa_auth()
-        self.verify_child_sas()
+        self.verify_ipsec_sas()
+        self.verify_ike_sas()
 
 
 class Ikev2Params(object):