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 */