This is an automated email from the ASF dual-hosted git repository.

xiaoxiang781216 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/nuttx.git


The following commit(s) were added to refs/heads/master by this push:
     new e29cddd161c crypto: add session clone
e29cddd161c is described below

commit e29cddd161ced0b057e44a5bf84baee5f3cd7751
Author: makejian <[email protected]>
AuthorDate: Tue Nov 17 15:11:33 2026 +0800

    crypto: add session clone
    
    Add a way to fork a running crypto session. CIOCCLONE, issued on a
    cloned /dev/crypto descriptor, returns a new descriptor that holds an
    independent copy of every session of the source descriptor, with the
    same user-visible session ids and the intermediate state included:
    after updating a digest halfway, the source and the clone can be
    finished separately and produce the same MAC.
    
    The driver table grows a cc_clone hook, registered through the new
    crypto_register2(). crypto_register() keeps its signature and registers
    no clone hook, so existing drivers are unchanged. crypto_clonesession()
    dispatches to the hook of the driver that owns the source session and
    returns -ENOTSUP when that driver has none.
    
    cryptosoft implements the hook with swcr_clone(), which deep copies
    every node of a session: hash, HMAC and MAC contexts, cipher key
    schedules and stream state. The cri_sid special case in
    swcr_newsession() is removed; copying the running state of another
    session through cri_sid only worked for plain hashes on one driver,
    while CIOCCLONE does the same job for every algorithm.
    
    Signed-off-by: makejian <[email protected]>
---
 crypto/crypto.c             |  57 ++++++++++++
 crypto/cryptodev.c          | 154 ++++++++++++++++++++++++++++++---
 crypto/cryptosoft.c         | 206 ++++++++++++++++++++++++++++++++++++++------
 include/crypto/cryptodev.h  |   8 ++
 include/crypto/cryptosoft.h |   1 +
 5 files changed, 387 insertions(+), 39 deletions(-)

diff --git a/crypto/crypto.c b/crypto/crypto.c
index c3b6b22c209..bc8e6c943c8 100644
--- a/crypto/crypto.c
+++ b/crypto/crypto.c
@@ -216,6 +216,47 @@ int crypto_newsession(FAR uint64_t *sid,
   return err;
 }
 
+/* Clone a running session, intermediate state included, on the driver
+ * that owns it.
+ */
+
+int crypto_clonesession(uint64_t src, FAR uint64_t *sid)
+{
+  uint32_t hid = (src >> 32) & 0xffffffff;
+  uint32_t lid;
+  int err;
+
+  if (crypto_drivers == NULL || sid == NULL)
+    {
+      return -EINVAL;
+    }
+
+  nxmutex_lock(&g_crypto_lock);
+
+  if (hid >= crypto_drivers_num ||
+      (crypto_drivers[hid].cc_flags & CRYPTOCAP_F_CLEANUP))
+    {
+      nxmutex_unlock(&g_crypto_lock);
+      return -ENOENT;
+    }
+
+  if (crypto_drivers[hid].cc_clone == NULL)
+    {
+      nxmutex_unlock(&g_crypto_lock);
+      return -ENOTSUP;
+    }
+
+  err = crypto_drivers[hid].cc_clone(src, &lid);
+  if (err == 0)
+    {
+      *sid = ((uint64_t)hid << 32) | lid;
+      crypto_drivers[hid].cc_sessions++;
+    }
+
+  nxmutex_unlock(&g_crypto_lock);
+  return err;
+}
+
 /* Delete an existing session (or a reserved session on an unregistered
  * driver).
  */
@@ -399,6 +440,20 @@ int crypto_register(uint32_t driverid, FAR int *alg,
                                        FAR struct cryptoini *),
                     CODE int (*freeses)(uint64_t),
                     CODE int (*process)(FAR struct cryptop *))
+{
+  return crypto_register2(driverid, alg, newses, freeses, process, NULL);
+}
+
+/* Register a crypto driver with all of its symmetric methods, session
+ * cloning included.
+ */
+
+int crypto_register2(uint32_t driverid, FAR int *alg,
+                     CODE int (*newses)(FAR uint32_t *,
+                                        FAR struct cryptoini *),
+                     CODE int (*freeses)(uint64_t),
+                     CODE int (*process)(FAR struct cryptop *),
+                     CODE int (*clone)(uint64_t, FAR uint32_t *))
 {
   int i;
 
@@ -423,6 +478,7 @@ int crypto_register(uint32_t driverid, FAR int *alg,
   crypto_drivers[driverid].cc_newsession = newses;
   crypto_drivers[driverid].cc_process = process;
   crypto_drivers[driverid].cc_freesession = freeses;
+  crypto_drivers[driverid].cc_clone = clone;
   crypto_drivers[driverid].cc_sessions = 0; /* Unmark */
 
   nxmutex_unlock(&g_crypto_lock);
@@ -706,6 +762,7 @@ int up_cryptoinitialize(void)
 {
 #ifdef CONFIG_CRYPTO_ALGTEST
   int ret = crypto_test();
+
   if (ret)
     {
       crypterr("ERROR: crypto test failed\n");
diff --git a/crypto/cryptodev.c b/crypto/cryptodev.c
index 6e52e14ab43..95231bd57f9 100644
--- a/crypto/cryptodev.c
+++ b/crypto/cryptodev.c
@@ -141,6 +141,8 @@ static int cryptodev_key(FAR struct fcrypt *, FAR struct 
crypt_kop *);
 static int cryptodevkey_cb(FAR struct cryptkop *);
 static int cryptodev_getkeystatus(FAR struct fcrypt *,
                                   FAR struct crypt_kop *);
+static void fcrypt_free(FAR struct fcrypt *);
+static int cryptodev_clone(FAR struct fcrypt *, FAR struct fcrypt **);
 
 /****************************************************************************
  * Private Data
@@ -207,6 +209,7 @@ static int cryptof_ioctl(FAR struct file *filep,
   struct cryptoini cria;
   struct cryptoini crie;
   FAR struct fcrypt *fcr = filep->f_priv;
+  FAR struct fcrypt *fcrd;
   FAR struct csession *cse;
   FAR struct session_op *sop;
   FAR struct crypt_op *cop;
@@ -215,6 +218,7 @@ static int cryptof_ioctl(FAR struct file *filep,
   uint64_t sid;
   uint32_t ses;
   int error = 0;
+  int fd;
 
   switch (cmd)
     {
@@ -388,6 +392,23 @@ bail:
       case CIOCASYMFEAT:
         error = crypto_getfeat((FAR int *)arg);
         break;
+      case CIOCCLONE:
+        error = cryptodev_clone(fcr, &fcrd);
+        if (error < 0)
+          {
+            break;
+          }
+
+        fd = file_allocate_from_inode(&g_cryptoinode, 0, 0, fcrd, 0);
+        if (fd < 0)
+          {
+            fcrypt_free(fcrd);
+            error = fd;
+            break;
+          }
+
+        *(FAR uint32_t *)arg = fd;
+        break;
       default:
         error = -ENOTTY;
     }
@@ -857,6 +878,123 @@ static int cryptodev_getkeystatus(struct fcrypt *fcr, 
struct crypt_kop *ret)
   return OK;
 }
 
+/* Free a cloned descriptor together with its sessions. */
+
+static void fcrypt_free(FAR struct fcrypt *fcr)
+{
+  FAR struct csession *cse;
+
+  while ((cse = TAILQ_FIRST(&fcr->csessions)))
+    {
+      TAILQ_REMOVE(&fcr->csessions, cse, next);
+      (void)csefree(cse);
+    }
+
+  kmm_free(fcr);
+}
+
+/* Duplicate every session of src, intermediate state included, into a
+ * new fcrypt that keeps the same user-visible session ids.
+ */
+
+static int cryptodev_clone(FAR struct fcrypt *src, FAR struct fcrypt **dst)
+{
+  FAR struct fcrypt *fcrd;
+  FAR struct csession *cse;
+  FAR struct csession *csed;
+  caddr_t key;
+  caddr_t mackey;
+  uint64_t sid;
+  int ret;
+
+  fcrd = kmm_zalloc(sizeof(struct fcrypt));
+  if (fcrd == NULL)
+    {
+      return -ENOMEM;
+    }
+
+  TAILQ_INIT(&fcrd->csessions);
+  TAILQ_INIT(&fcrd->crpk_ret);
+
+  TAILQ_FOREACH(cse, &src->csessions, next)
+    {
+      ret = crypto_clonesession(cse->sid, &sid);
+      if (ret < 0)
+        {
+          goto bail;
+        }
+
+      /* csecreate takes ownership of the key copies. */
+
+      key = NULL;
+      if (cse->keylen > 0)
+        {
+          key = kmm_malloc(cse->keylen);
+        }
+
+      mackey = NULL;
+      if (cse->mackeylen > 0)
+        {
+          mackey = kmm_malloc(cse->mackeylen);
+        }
+
+      if ((cse->keylen > 0 && key == NULL) ||
+          (cse->mackeylen > 0 && mackey == NULL))
+        {
+          if (key != NULL)
+            {
+              kmm_free(key);
+            }
+
+          crypto_freesession(sid);
+          ret = -ENOMEM;
+          goto bail;
+        }
+
+      if (key != NULL)
+        {
+          memcpy(key, cse->key, cse->keylen);
+        }
+
+      if (mackey != NULL)
+        {
+          memcpy(mackey, cse->mackey, cse->mackeylen);
+        }
+
+      csed = csecreate(fcrd, sid, key, (uint64_t)cse->keylen * 8,
+                       mackey, (uint64_t)cse->mackeylen * 8, cse->cipher,
+                       cse->mac, cse->txform, cse->thash);
+      if (csed == NULL)
+        {
+          if (key != NULL)
+            {
+              explicit_bzero(key, cse->keylen);
+              kmm_free(key);
+            }
+
+          if (mackey != NULL)
+            {
+              explicit_bzero(mackey, cse->mackeylen);
+              kmm_free(mackey);
+            }
+
+          crypto_freesession(sid);
+          ret = -ENOMEM;
+          goto bail;
+        }
+
+      csed->ses = cse->ses;
+    }
+
+  fcrd->sesn = src->sesn;
+  *dst = fcrd;
+  return 0;
+
+bail:
+  fcrypt_free(fcrd);
+  return ret;
+}
+
 /* ARGSUSED */
 
 static int cryptof_poll(FAR struct file *filep,
@@ -896,21 +1034,15 @@ static int cryptof_poll(FAR struct file *filep,
 
 static int cryptof_close(FAR struct file *filep)
 {
-  FAR struct fcrypt *fcr = filep->f_priv;
-  FAR struct csession *cse;
-
-  while ((cse = TAILQ_FIRST(&fcr->csessions)))
-    {
-      TAILQ_REMOVE(&fcr->csessions, cse, next);
-      (void)csefree(cse);
-    }
-
-  kmm_free(fcr);
+  fcrypt_free(filep->f_priv);
   filep->f_priv = NULL;
   return 0;
 }
 
-/* Clone csessions into a new fd */
+/* Reopen of a cloned descriptor: recreate the sessions of the fd being
+ * duplicated from their parameters, with fresh state.  This is not
+ * CIOCCLONE, which copies the intermediate state of a running session.
+ */
 
 static int cryptof_open(FAR struct file *filep)
 {
diff --git a/crypto/cryptosoft.c b/crypto/cryptosoft.c
index 7d8a264c008..9c4a82d67c6 100644
--- a/crypto/cryptosoft.c
+++ b/crypto/cryptosoft.c
@@ -1550,22 +1550,14 @@ int swcr_compdec(FAR struct cryptodesc *crd, FAR struct 
swcr_data *sw,
   return 0;
 }
 
-/* Generate a new software session. */
+/* Reserve a free slot in swcr_sessions, growing it if needed.
+ * Returns the slot index, or 0 on allocation failure.
+ */
 
-int swcr_newsession(FAR uint32_t *sid, FAR struct cryptoini *cri)
+static uint32_t swcr_allocsid(void)
 {
   FAR struct swcr_data **swd;
-  FAR const struct auth_hash *axf;
-  FAR const struct enc_xform *txf;
-  uint8_t hmackey[HMAC_MAX_BLOCK_LEN];
-  int keylen;
-  uint32_t i;
-  int k;
-
-  if (sid == NULL || cri == NULL)
-    {
-      return -EINVAL;
-    }
+  uint32_t i = 0;
 
   if (swcr_sessions)
     {
@@ -1604,7 +1596,7 @@ int swcr_newsession(FAR uint32_t *sid, FAR struct 
cryptoini *cri)
               swcr_sesnum /= 2;
             }
 
-          return -ENOBUFS;
+          return 0;
         }
 
       /* Copy existing sessions */
@@ -1619,6 +1611,32 @@ int swcr_newsession(FAR uint32_t *sid, FAR struct 
cryptoini *cri)
       swcr_sessions = swd;
     }
 
+  return i;
+}
+
+/* Generate a new software session. */
+
+int swcr_newsession(FAR uint32_t *sid, FAR struct cryptoini *cri)
+{
+  FAR struct swcr_data **swd;
+  FAR const struct auth_hash *axf;
+  FAR const struct enc_xform *txf;
+  uint8_t hmackey[HMAC_MAX_BLOCK_LEN];
+  int keylen;
+  uint32_t i;
+  int k;
+
+  if (sid == NULL || cri == NULL)
+    {
+      return -EINVAL;
+    }
+
+  i = swcr_allocsid();
+  if (i == 0)
+    {
+      return -ENOBUFS;
+    }
+
   swd = &swcr_sessions[i];
   *sid = i;
 
@@ -1829,18 +1847,6 @@ int swcr_newsession(FAR uint32_t *sid, FAR struct 
cryptoini *cri)
             axf->init((*swd)->sw_ictx);
             (*swd)->sw_axf = axf;
             bcopy((*swd)->sw_ictx, &(*swd)->sw_ctx, axf->ctxsize);
-
-            if (cri->cri_sid != -1)
-              {
-                if (swcr_sessions[cri->cri_sid] == NULL)
-                  {
-                    swcr_freesession(i);
-                    return -EINVAL;
-                  }
-
-                bcopy(&swcr_sessions[cri->cri_sid]->sw_ctx, &(*swd)->sw_ctx,
-                      axf->ctxsize);
-              }
             break;
 
           case CRYPTO_AES_128_GMAC:
@@ -2014,6 +2020,150 @@ int swcr_freesession(uint64_t tid)
   return 0;
 }
 
+/* Deep-copy one session node; the xform/axf tables are shared constants. */
+
+static int swcr_clonedata(FAR struct swcr_data *dst,
+                          FAR const struct swcr_data *src)
+{
+  FAR const struct auth_hash *axf;
+  FAR const struct enc_xform *txf;
+
+  memcpy(dst, src, sizeof(*dst));
+  dst->sw_next = NULL;
+
+  switch (src->sw_alg)
+    {
+      case CRYPTO_3DES_CBC:
+      case CRYPTO_BLF_CBC:
+      case CRYPTO_CAST_CBC:
+      case CRYPTO_RIJNDAEL128_CBC:
+      case CRYPTO_AES_CTR:
+      case CRYPTO_AES_CTR_SSH:
+      case CRYPTO_AES_XTS:
+      case CRYPTO_AES_GCM_16:
+      case CRYPTO_AES_GMAC:
+      case CRYPTO_AES_CMAC:
+      case CRYPTO_AES_OFB:
+      case CRYPTO_AES_CFB_8:
+      case CRYPTO_AES_CFB_128:
+      case CRYPTO_CHACHA20:
+      case CRYPTO_CHACHA20_DJB:
+      case CRYPTO_CHACHA20_POLY1305:
+      case CRYPTO_NULL:
+        txf = src->sw_exf;
+        dst->sw_kschedule = NULL;
+        if (src->sw_kschedule == NULL || txf->ctxsize == 0)
+          {
+            return OK;
+          }
+
+        dst->sw_kschedule = kmm_malloc(txf->ctxsize);
+        if (dst->sw_kschedule == NULL)
+          {
+            return -ENOBUFS;
+          }
+
+        memcpy(dst->sw_kschedule, src->sw_kschedule, txf->ctxsize);
+        return OK;
+
+      case CRYPTO_MD5_HMAC:
+      case CRYPTO_SHA1_HMAC:
+      case CRYPTO_RIPEMD160_HMAC:
+      case CRYPTO_SHA2_224_HMAC:
+      case CRYPTO_SHA2_256_HMAC:
+      case CRYPTO_SHA2_384_HMAC:
+      case CRYPTO_SHA2_512_HMAC:
+      case CRYPTO_PBKDF2_HMAC_SHA1:
+      case CRYPTO_PBKDF2_HMAC_SHA256:
+        axf = src->sw_axf;
+        dst->sw_ictx = NULL;
+        dst->sw_octx = kmm_malloc(axf->ctxsize);
+        if (dst->sw_octx == NULL)
+          {
+            return -ENOBUFS;
+          }
+
+        memcpy(dst->sw_octx, src->sw_octx, axf->ctxsize);
+        goto ictx;
+
+      case CRYPTO_AES_128_GMAC:
+      case CRYPTO_AES_192_GMAC:
+      case CRYPTO_AES_256_GMAC:
+      case CRYPTO_AES_128_CMAC:
+      case CRYPTO_CHACHA20_POLY1305_MAC:
+      case CRYPTO_MD5:
+      case CRYPTO_POLY1305:
+      case CRYPTO_RIPEMD160:
+      case CRYPTO_SHA1:
+      case CRYPTO_SHA2_224:
+      case CRYPTO_SHA2_256:
+      case CRYPTO_SHA2_384:
+      case CRYPTO_SHA2_512:
+      case CRYPTO_CRC32:
+        axf = src->sw_axf;
+        dst->sw_octx = NULL;
+
+        ictx:
+        dst->sw_ictx = kmm_malloc(axf->ctxsize);
+        if (dst->sw_ictx == NULL)
+          {
+            return -ENOBUFS;
+          }
+
+        memcpy(dst->sw_ictx, src->sw_ictx, axf->ctxsize);
+        return OK;
+
+      default:
+        return OK;
+    }
+}
+
+/* Clone a running session, including any partially processed state. */
+
+int swcr_clone(uint64_t tid, FAR uint32_t *sid)
+{
+  FAR const struct swcr_data *src;
+  FAR struct swcr_data **dst;
+  uint32_t old = (uint32_t)tid;
+  uint32_t i;
+  int ret;
+
+  if (sid == NULL || old == 0 || old >= swcr_sesnum ||
+      swcr_sessions == NULL || swcr_sessions[old] == NULL)
+    {
+      return -EINVAL;
+    }
+
+  i = swcr_allocsid();
+  if (i == 0)
+    {
+      return -ENOBUFS;
+    }
+
+  dst = &swcr_sessions[i];
+  for (src = swcr_sessions[old]; src; src = src->sw_next)
+    {
+      *dst = kmm_zalloc(sizeof(struct swcr_data));
+      if (*dst == NULL)
+        {
+          swcr_freesession(i);
+          return -ENOBUFS;
+        }
+
+      ret = swcr_clonedata(*dst, src);
+      if (ret < 0)
+        {
+          swcr_freesession(i);
+          return ret;
+        }
+
+      dst = &(*dst)->sw_next;
+    }
+
+  *sid = i;
+  return OK;
+}
+
 /* Process a software request. */
 
 int swcr_process(struct cryptop *crp)
@@ -2651,8 +2801,8 @@ void swcr_init(void)
   algs[CRYPTO_PBKDF2_HMAC_SHA256] = CRYPTO_ALG_FLAG_SUPPORTED;
   algs[CRYPTO_ESN] = CRYPTO_ALG_FLAG_SUPPORTED;
 
-  crypto_register(swcr_id, algs, swcr_newsession,
-                  swcr_freesession, swcr_process);
+  crypto_register2(swcr_id, algs, swcr_newsession,
+                   swcr_freesession, swcr_process, swcr_clone);
 
   memset(kalgs, 0, sizeof(kalgs));
   kalgs[CRK_MOD_EXP] = CRYPTO_ALG_FLAG_SUPPORTED;
diff --git a/include/crypto/cryptodev.h b/include/crypto/cryptodev.h
index adddb019738..b13981e1a95 100644
--- a/include/crypto/cryptodev.h
+++ b/include/crypto/cryptodev.h
@@ -409,6 +409,7 @@ struct cryptocap
   CODE int (*cc_newsession)(FAR uint32_t *, FAR struct cryptoini *);
   CODE int (*cc_process)(FAR struct cryptop *);
   CODE int (*cc_freesession)(uint64_t);
+  CODE int (*cc_clone)(uint64_t, FAR uint32_t *);
   CODE int (*cc_kprocess)(FAR struct cryptkop *);
   FAR void *priv;
 };
@@ -484,13 +485,20 @@ extern const uint8_t hmac_opad_buffer[HMAC_MAX_BLOCK_LEN];
 #define CIOCKEY                 104
 #define CIOCKEYRET              105
 #define CIOCASYMFEAT            106
+#define CIOCCLONE               107
 
 int crypto_newsession(FAR uint64_t *, FAR struct cryptoini *, int);
+int crypto_clonesession(uint64_t, FAR uint64_t *);
 int crypto_freesession(uint64_t);
 int crypto_register(uint32_t, FAR int *,
                     CODE int (*)(FAR uint32_t *, FAR struct cryptoini *),
                     CODE int (*)(uint64_t),
                     CODE int (*)(FAR struct cryptop *));
+int crypto_register2(uint32_t, FAR int *,
+                     CODE int (*)(FAR uint32_t *, FAR struct cryptoini *),
+                     CODE int (*)(uint64_t),
+                     CODE int (*)(FAR struct cryptop *),
+                     CODE int (*)(uint64_t, FAR uint32_t *));
 int crypto_kregister(uint32_t, FAR int *,
                      CODE int (*)(FAR struct cryptkop *));
 int crypto_unregister(uint32_t, int);
diff --git a/include/crypto/cryptosoft.h b/include/crypto/cryptosoft.h
index dd9aef9ebc0..8aa544f8046 100644
--- a/include/crypto/cryptosoft.h
+++ b/include/crypto/cryptosoft.h
@@ -97,6 +97,7 @@ int swcr_process(FAR struct cryptop *);
 int swcr_kprocess(FAR struct cryptkop *);
 int swcr_newsession(FAR uint32_t *, FAR struct cryptoini *);
 int swcr_freesession(uint64_t);
+int swcr_clone(uint64_t, FAR uint32_t *);
 void swcr_init(void);
 
 /* Software key management */

Reply via email to