cederom commented on code in PR #4092:
URL: https://github.com/apache/nuttx-apps/pull/4092#discussion_r4643331674


##########
testing/drivers/crypto/keyid.c:
##########
@@ -0,0 +1,1122 @@
+/****************************************************************************
+ * apps/testing/drivers/crypto/keyid.c
+ *
+ * SPDX-License-Identifier: ISC
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ ****************************************************************************/
+
+/* Exercise the cryptodev key id interface: with SOP_F_KEYID the key
+ * fields of a session, and the key params of an asymmetric operation,
+ * carry a key id of the software key store in place of the key itself.
+ * Every case runs the full lifecycle of the ids it uses: allocate,
+ * import, operate, delete.
+ */
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/param.h>
+#include <crypto/cryptodev.h>
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#define MOD_1024_LEN  128
+#define PLAIN_LEN     24
+#define PADDING_LEN   (MOD_1024_LEN - PLAIN_LEN)
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+typedef struct crypto_context_s
+{
+  int fd;
+  int cryptodev_fd;
+}
+crypto_context_t;
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/* AES-CBC vector from RFC 3602 */
+
+static const char g_aescbc_key[16] =
+  "\x06\xa9\x21\x40\x36\xb8\xa1\x5b\x51\x2e\x03\xd5\x34\x12\x00\x06";
+static const char g_aescbc_iv[16] =
+  "\x3d\xaf\xba\x42\x9d\x9e\xb4\x30\xb4\x22\xda\x80\x2c\x9f\xac\x41";
+static const char g_aescbc_plain[] = "Single block msg";
+static const char g_aescbc_cipher[16] =
+  "\xe3\x53\x77\x9c\x10\x79\xae\xb8\x27\x08\x94\x2d\xbe\x77\x18\x1a";
+
+/* HMAC-SHA256 vector as carried by the hmac test */
+
+static const char g_hmac_key[16] =
+  "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b";
+static const char g_hmac_data[] = "Hi There";
+static const char g_hmac_mac[32] =
+  "\x49\x2c\xe0\x20\xfe\x25\x34\xa5\x78\x9d\xc3\x84\x88\x06\xc7\x8f"
+  "\x4f\x67\x11\x39\x7f\x08\xe7\xe7\xa1\x2c\xa5\xa4\x48\x3c\x8a\xa6";
+
+/* AES-128-CMAC vector from the NIST SP 800-38B examples */
+
+static const unsigned char g_cmac_key[16] =
+{
+    0x2b, 0x7e, 0x15, 0x16,     0x28, 0xae, 0xd2, 0xa6,
+    0xab, 0xf7, 0x15, 0x88,     0x09, 0xcf, 0x4f, 0x3c
+};
+static const unsigned char g_cmac_message[64] =
+{
+    0x6b, 0xc1, 0xbe, 0xe2,     0x2e, 0x40, 0x9f, 0x96,
+    0xe9, 0x3d, 0x7e, 0x11,     0x73, 0x93, 0x17, 0x2a,
+    0xae, 0x2d, 0x8a, 0x57,     0x1e, 0x03, 0xac, 0x9c,
+    0x9e, 0xb7, 0x6f, 0xac,     0x45, 0xaf, 0x8e, 0x51,
+    0x30, 0xc8, 0x1c, 0x46,     0xa3, 0x5c, 0xe4, 0x11,
+    0xe5, 0xfb, 0xc1, 0x19,     0x1a, 0x0a, 0x52, 0xef,
+    0xf6, 0x9f, 0x24, 0x45,     0xdf, 0x4f, 0x9b, 0x17,
+    0xad, 0x2b, 0x41, 0x7b,     0xe6, 0x6c, 0x37, 0x10
+};
+static const unsigned char g_cmac_mac[16] =
+{
+    0x51, 0xf0, 0xbe, 0xbf,     0x7e, 0x3b, 0x9d, 0x92,
+    0xfc, 0x49, 0x74, 0x17,     0x79, 0x36, 0x3c, 0xfe
+};
+
+/* Example RSA-1024 keypair, as in the rsa test */
+
+static const char g_rsa_n_1024[] =
+"9292758453063D803DD603D5E777D788"
+"8ED1D5BF35786190FA2F23EBC0848AEA"
+"DDA92CA6C3D80B32C4D109BE0F36D6AE"
+"7130B9CED7ACDF54CFC7555AC14EEBAB"
+"93A89813FBF3C4F8066D2D800F7C38A8"
+"1AE31942917403FF4946B0A83D3D3E05"
+"EE57C6F5F5606FB5D4BC6CD34EE0801A"
+"5E94BB77B07507233A0BC7BAC8F90F79";
+
+static const char g_rsa_e_1024[] = "10001";
+
+static const char g_rsa_d_1024[] =
+"24BF6185468786FDD303083D25E64EFC"
+"66CA472BC44D253102F8B4A9D3BFA750"
+"91386C0077937FE33FA3252D28855837"
+"AE1B484A8A9A45F7EE8C0C634F99E8CD"
+"DF79C5CE07EE72C7F123142198164234"
+"CABB724CF78B8173B9F880FC86322407"
+"AF1FEDFDDE2BEB674CA15F3E81A1521E"
+"071513A1E85B5DFA031F21ECAE91A34D";
+
+static const unsigned char g_message[PLAIN_LEN] =
+"\xAA\xBB\xCC\x03\x02\x01\x00\xFF\xFF\xFF\xFF\xFF"
+"\x11\x22\x33\x0A\x0B\x0C\xCC\xDD\xDD\xDD\xDD\xDD";
+
+static const unsigned char g_sha256_message[32] =
+{
+  0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
+  0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23,
+  0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
+  0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad
+};
+
+static const unsigned char g_lifecycle_data[32] =
+{
+  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+  0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+  0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
+};
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+static void crypto_free(FAR crypto_context_t *ctx)
+{
+  if (ctx->cryptodev_fd != 0)
+    {
+      close(ctx->cryptodev_fd);
+      ctx->cryptodev_fd = 0;
+    }
+
+  if (ctx->fd != 0)
+    {
+      close(ctx->fd);
+      ctx->fd = 0;
+    }
+}
+
+static int crypto_init(FAR crypto_context_t *ctx)
+{
+  memset(ctx, 0, sizeof(crypto_context_t));
+  if ((ctx->fd = open("/dev/crypto", O_RDWR, 0)) < 0)
+    {
+      perror("/dev/crypto");
+      crypto_free(ctx);
+      return 1;
+    }
+
+  if (ioctl(ctx->fd, CRIOGET, &ctx->cryptodev_fd) == -1)
+    {
+      perror("CRIOGET");
+      crypto_free(ctx);
+      return 1;
+    }
+
+  return 0;
+}
+
+/* Run one key management operation.  The key id is always param[0];
+ * import and export also use buf as param[1].
+ */
+
+static int keyid_op(FAR crypto_context_t *ctx, int op,
+                    FAR uint32_t *keyid, FAR void *buf, size_t buflen)
+{
+  struct crypt_kop cryptk;
+
+  memset(&cryptk, 0, sizeof(cryptk));
+  cryptk.crk_op = op;
+  cryptk.crk_param[0].crp_p = (caddr_t)keyid;
+  cryptk.crk_param[0].crp_nbits = sizeof(uint32_t) * 8;
+
+  switch (op)
+    {
+      case CRK_ALLOCATE_KEY:
+        cryptk.crk_iparams = 0;
+        cryptk.crk_oparams = 1;
+        break;
+      case CRK_IMPORT_KEY:
+        cryptk.crk_iparams = 2;
+        cryptk.crk_oparams = 0;
+        cryptk.crk_param[1].crp_p = (caddr_t)buf;
+        cryptk.crk_param[1].crp_nbits = buflen * 8;
+        break;
+      case CRK_EXPORT_KEY:
+        cryptk.crk_iparams = 1;
+        cryptk.crk_oparams = 1;
+        cryptk.crk_param[1].crp_p = (caddr_t)buf;
+        cryptk.crk_param[1].crp_nbits = buflen * 8;
+        break;
+      case CRK_DELETE_KEY:
+      case CRK_SAVE_KEY:
+      case CRK_LOAD_KEY:
+      case CRK_UNLOAD_KEY:
+        cryptk.crk_iparams = 1;
+        cryptk.crk_oparams = 0;
+        break;
+      default:
+        return -EINVAL;
+    }
+
+  if (ioctl(ctx->cryptodev_fd, CIOCKEY, &cryptk) == -1)
+    {
+      perror("CIOCKEY");
+      return -1;
+    }
+
+  return cryptk.crk_status;
+}
+
+static void mpi_get_digit(FAR uint8_t *d, char c)
+{
+  if (c >= '0' && c <= '9')
+    {
+      *d = c - '0';
+    }
+
+  if (c >= 'A' && c <= 'F')
+    {
+      *d = c - 'A' + 10;
+    }
+
+  if (c >= 'a' && c <= 'f')
+    {
+      *d = c - 'a' + 10;
+    }
+}
+
+/* Decode a big-endian hex string into the little-endian byte order
+ * cryptodev carries, and return the length in bytes.
+ */
+
+static size_t mpi_from_string(FAR unsigned char *buf, FAR const char *s)
+{
+  size_t slen = strlen(s);
+  size_t i;
+  int j;
+  uint8_t d = 0;
+
+  for (i = slen, j = 0; i > 0; i--, j++)
+    {
+      mpi_get_digit(&d, s[i - 1]);
+      buf[j / 2] |= d << ((j % 2) << 2);
+    }
+
+  return (slen + 1) / 2;
+}
+
+/* Reverse the byte order, between the little-endian integers of the
+ * cryptodev interface and the big-endian ones of the test vectors.
+ */
+
+static void mpi_reverse(FAR unsigned char *dst,
+                        FAR const unsigned char *src, size_t len)
+{
+  size_t i;
+
+  for (i = 0; i < len; i++)
+    {
+      dst[i] = src[len - 1 - i];
+    }
+}
+
+static int match(FAR const void *a, FAR const void *b, size_t len)
+{
+  if (memcmp(a, b, len) == 0)
+    {
+      return 0;
+    }
+
+  printf("mismatch:\n");
+  return -1;
+}
+
+/* Case 1: the key id lifecycle, allocate to delete, with the import
+ * and export in between.
+ */
+
+static int test_lifecycle(FAR crypto_context_t *ctx)
+{
+  unsigned char buf[sizeof(g_lifecycle_data)];
+  uint32_t keyid = 0;
+  int ret;
+
+  ret = keyid_op(ctx, CRK_ALLOCATE_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid allocate failed\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_IMPORT_KEY, &keyid,
+                 (FAR void *)g_lifecycle_data, sizeof(g_lifecycle_data));
+  if (ret != 0)
+    {
+      printf("keyid import failed\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_EXPORT_KEY, &keyid, buf, sizeof(buf));
+  if (ret != 0)
+    {
+      printf("keyid export failed\n");
+      return -1;
+    }
+
+  if (match(g_lifecycle_data, buf, sizeof(g_lifecycle_data)) != 0)
+    {
+      printf("keyid export mismatch\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_SAVE_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid save failed\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_LOAD_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid load failed\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_UNLOAD_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid unload failed\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_DELETE_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid delete failed\n");
+      return -1;
+    }
+
+  printf("keyid lifecycle success\n");
+  return 0;
+}
+
+/* Case 2: AES-CBC with the cipher key referenced by id */
+
+static int aescbc_crypt(FAR crypto_context_t *ctx, uint32_t keyid,
+                        FAR const char *iv, FAR const char *in,
+                        FAR unsigned char *out, size_t len, int encrypt)
+{
+  struct session_op session;
+  struct crypt_op cryp;
+
+  memset(&session, 0, sizeof(session));
+  session.cipher = CRYPTO_AES_CBC;
+  session.key = (caddr_t)&keyid;
+  session.keylen = sizeof(keyid);
+  session.op = encrypt ? COP_ENCRYPT : COP_DECRYPT;
+  session.flags = SOP_F_KEYID;
+  if (ioctl(ctx->cryptodev_fd, CIOCGSESSION, &session) == -1)
+    {
+      perror("CIOCGSESSION");
+      return -1;
+    }
+
+  memset(&cryp, 0, sizeof(cryp));
+  cryp.ses = session.ses;
+  cryp.op = encrypt ? COP_ENCRYPT : COP_DECRYPT;
+  cryp.flags = 0;
+  cryp.len = len;
+  cryp.olen = len;
+  cryp.ivlen = 16;
+  cryp.src = (caddr_t)in;
+  cryp.dst = (caddr_t)out;
+  cryp.iv = (caddr_t)iv;
+  cryp.mac = 0;
+  if (ioctl(ctx->cryptodev_fd, CIOCCRYPT, &cryp) == -1)
+    {
+      perror("CIOCCRYPT");
+      return -1;
+    }
+
+  if (ioctl(ctx->cryptodev_fd, CIOCFSESSION, &session.ses) == -1)
+    {
+      perror("CIOCFSESSION");
+      return -1;
+    }
+
+  return 0;
+}
+
+static int test_aescbc(FAR crypto_context_t *ctx)
+{
+  unsigned char buf[16];
+  uint32_t keyid = 0;
+  int ret;
+
+  ret = keyid_op(ctx, CRK_ALLOCATE_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid allocate failed\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_IMPORT_KEY, &keyid, (FAR void *)g_aescbc_key,
+                 sizeof(g_aescbc_key));
+  if (ret != 0)
+    {
+      printf("keyid import failed\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_SAVE_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid save failed\n");
+      return -1;
+    }
+
+  ret = aescbc_crypt(ctx, keyid, g_aescbc_iv, g_aescbc_plain, buf,
+                     sizeof(buf), 1);
+  if (ret != 0)
+    {
+      printf("aescbc encrypt failed\n");
+      return -1;
+    }
+
+  if (match(g_aescbc_cipher, buf, sizeof(buf)) != 0)
+    {
+      printf("aescbc encrypt mismatch\n");
+      return -1;
+    }
+
+  ret = aescbc_crypt(ctx, keyid, g_aescbc_iv, g_aescbc_cipher, buf,
+                     sizeof(buf), 0);
+  if (ret != 0)
+    {
+      printf("aescbc decrypt failed\n");
+      return -1;
+    }
+
+  if (match(g_aescbc_plain, buf, sizeof(buf)) != 0)
+    {
+      printf("aescbc decrypt mismatch\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_DELETE_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid delete failed\n");
+      return -1;
+    }
+
+  printf("aescbc keyid success\n");
+  return 0;
+}
+
+/* Case 3: HMAC-SHA256 with the mac key referenced by id */
+
+static int hmac_keyid(FAR crypto_context_t *ctx, uint32_t keyid,
+                      FAR const char *data, size_t len,
+                      FAR unsigned char *out, size_t outlen)
+{
+  struct session_op session;
+  struct crypt_op cryp;
+
+  memset(&session, 0, sizeof(session));
+  session.mac = CRYPTO_SHA2_256_HMAC;
+  session.mackey = (caddr_t)&keyid;
+  session.mackeylen = sizeof(keyid);
+  session.flags = SOP_F_KEYID;
+  if (ioctl(ctx->cryptodev_fd, CIOCGSESSION, &session) == -1)
+    {
+      perror("CIOCGSESSION");
+      return -1;
+    }
+
+  memset(&cryp, 0, sizeof(cryp));
+  cryp.ses = session.ses;
+  cryp.op = COP_ENCRYPT;
+  cryp.flags = 0;
+  cryp.len = len;
+  cryp.olen = outlen;
+  cryp.src = (caddr_t)data;
+  cryp.mac = (caddr_t)out;
+  if (ioctl(ctx->cryptodev_fd, CIOCCRYPT, &cryp) == -1)
+    {
+      perror("CIOCCRYPT");
+      return -1;
+    }
+
+  if (ioctl(ctx->cryptodev_fd, CIOCFSESSION, &session.ses) == -1)
+    {
+      perror("CIOCFSESSION");
+      return -1;
+    }
+
+  return 0;
+}
+
+static int test_hmac(FAR crypto_context_t *ctx)
+{
+  unsigned char buf[32];
+  uint32_t keyid = 0;
+  int ret;
+
+  ret = keyid_op(ctx, CRK_ALLOCATE_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid allocate failed\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_IMPORT_KEY, &keyid, (FAR void *)g_hmac_key,
+                 sizeof(g_hmac_key));
+  if (ret != 0)
+    {
+      printf("keyid import failed\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_SAVE_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid save failed\n");
+      return -1;
+    }
+
+  ret = hmac_keyid(ctx, keyid, g_hmac_data, strlen(g_hmac_data),
+                   buf, sizeof(buf));
+  if (ret != 0)
+    {
+      printf("hmac failed\n");
+      return -1;
+    }
+
+  if (match(g_hmac_mac, buf, sizeof(buf)) != 0)
+    {
+      printf("hmac mismatch\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_DELETE_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid delete failed\n");
+      return -1;
+    }
+
+  printf("hmac keyid success\n");
+  return 0;
+}
+
+/* Case 4: AES-CMAC with the mac key referenced by id */
+
+static int aescmac_keyid(FAR crypto_context_t *ctx, uint32_t keyid,
+                         FAR const unsigned char *message, size_t len,
+                         FAR unsigned char *output, size_t outlen)
+{
+  struct session_op session;
+  struct crypt_op cryp;
+
+  memset(&session, 0, sizeof(session));
+  session.cipher = CRYPTO_AES_CMAC;
+  session.key = (caddr_t)&keyid;
+  session.keylen = sizeof(keyid);
+  session.mac = CRYPTO_AES_128_CMAC;
+  session.mackey = (caddr_t)&keyid;
+  session.mackeylen = sizeof(keyid);
+  session.flags = SOP_F_KEYID;
+  if (ioctl(ctx->cryptodev_fd, CIOCGSESSION, &session) == -1)
+    {
+      perror("CIOCGSESSION");
+      return -1;
+    }
+
+  memset(&cryp, 0, sizeof(cryp));
+  cryp.ses = session.ses;
+  cryp.op = COP_ENCRYPT;
+  cryp.flags = 0;
+  cryp.len = len;
+  cryp.olen = outlen;
+  cryp.src = (caddr_t)message;
+  cryp.mac = (caddr_t)output;
+  if (ioctl(ctx->cryptodev_fd, CIOCCRYPT, &cryp) == -1)
+    {
+      perror("CIOCCRYPT");
+      return -1;
+    }
+
+  if (ioctl(ctx->cryptodev_fd, CIOCFSESSION, &session.ses) == -1)
+    {
+      perror("CIOCFSESSION");
+      return -1;
+    }
+
+  return 0;
+}
+
+static int test_aescmac(FAR crypto_context_t *ctx)
+{
+  unsigned char buf[16];
+  uint32_t keyid = 0;
+  int ret;
+
+  ret = keyid_op(ctx, CRK_ALLOCATE_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid allocate failed\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_IMPORT_KEY, &keyid, (FAR void *)g_cmac_key,
+                 sizeof(g_cmac_key));
+  if (ret != 0)
+    {
+      printf("keyid import failed\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_SAVE_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid save failed\n");
+      return -1;
+    }
+
+  ret = aescmac_keyid(ctx, keyid, g_cmac_message, sizeof(g_cmac_message),
+                      buf, sizeof(buf));
+  if (ret != 0)
+    {
+      printf("aescmac failed\n");
+      return -1;
+    }
+
+  if (match(g_cmac_mac, buf, sizeof(buf)) != 0)
+    {
+      printf("aescmac mismatch\n");
+      return -1;
+    }
+
+  ret = keyid_op(ctx, CRK_DELETE_KEY, &keyid, NULL, 0);
+  if (ret != 0)
+    {
+      printf("keyid delete failed\n");
+      return -1;
+    }
+
+  printf("aescmac keyid success\n");
+  return 0;
+}
+
+/* Case 5: ECDSA over a generated key pair, both keys referenced by id */
+
+static int ecdsa_genkey_keyid(FAR crypto_context_t *ctx,

Review Comment:
   Keygen is inconsistent with the other key-id calls. ecdsa_genkey_keyid 
passes the private and public key IDs but doesn’t set crk_flags = SOP_F_KEYID, 
while sign and verify do. Master’s cryptodev does accept 
CRK_GENERATE_SECP256R1_KEY with 2 in-params. Is this intentional?



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to