980 lines
23 KiB
C
980 lines
23 KiB
C
/****************************************************************************
|
|
* crypto/cryptodev.c
|
|
* $OpenBSD: cryptodev.c,v 1.82 2014/08/18 05:11:03 dlg Exp $
|
|
* Copyright (c) 2001 Theo de Raadt
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* Effort sponsored in part by the Defense Advanced Research Projects
|
|
* Agency (DARPA) and Air Force Research Laboratory, Air Force
|
|
* Materiel Command, USAF, under agreement number F30602-01-2-0537.
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/queue.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
#include <poll.h>
|
|
#include <errno.h>
|
|
|
|
#include <nuttx/kmalloc.h>
|
|
#include <nuttx/fs/fs.h>
|
|
#include <nuttx/crypto/crypto.h>
|
|
#include <nuttx/drivers/drivers.h>
|
|
|
|
#include <crypto/xform.h>
|
|
#include <crypto/cryptodev.h>
|
|
#include <crypto/cryptosoft.h>
|
|
|
|
/****************************************************************************
|
|
* Public Data
|
|
****************************************************************************/
|
|
|
|
extern FAR struct cryptocap *crypto_drivers;
|
|
extern int crypto_drivers_num;
|
|
int usercrypto = 1; /* userland may do crypto requests */
|
|
int userasymcrypto = 1; /* userland may do asymmetric crypto reqs */
|
|
#ifdef CONFIG_CRYPTO_CRYPTODEV_SOFTWARE
|
|
int cryptodevallowsoft = 1; /* 0 is only use hardware crypto
|
|
* 1 is use hardware & software crypto
|
|
*/
|
|
#else
|
|
int cryptodevallowsoft = 0;
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Private Types
|
|
****************************************************************************/
|
|
|
|
struct csession
|
|
{
|
|
TAILQ_ENTRY(csession) next;
|
|
uint64_t sid;
|
|
uint32_t ses;
|
|
|
|
uint32_t cipher;
|
|
uint32_t mac;
|
|
bool txform;
|
|
bool thash;
|
|
|
|
caddr_t key;
|
|
int keylen;
|
|
u_char tmp_iv[EALG_MAX_BLOCK_LEN];
|
|
|
|
caddr_t mackey;
|
|
int mackeylen;
|
|
int error;
|
|
};
|
|
|
|
struct fcrypt
|
|
{
|
|
TAILQ_HEAD(csessionlist, csession) csessions;
|
|
int sesn;
|
|
};
|
|
|
|
/****************************************************************************
|
|
* Private Function Prototypes
|
|
****************************************************************************/
|
|
|
|
/* Character driver methods */
|
|
|
|
static ssize_t cryptof_read(FAR struct file *filep,
|
|
FAR char *buffer, size_t len);
|
|
static ssize_t cryptof_write(FAR struct file *filep,
|
|
FAR const char *buffer, size_t len);
|
|
static int cryptof_ioctl(FAR struct file *filep,
|
|
int cmd, unsigned long arg);
|
|
static int cryptof_poll(FAR struct file *filep,
|
|
struct pollfd *fds, bool setup);
|
|
static int cryptof_open(FAR struct file *filep);
|
|
static int cryptof_close(FAR struct file *filep);
|
|
|
|
static int cryptoopen(FAR struct file *filep);
|
|
static ssize_t cryptoread(FAR struct file *filep,
|
|
FAR char *buffer, size_t len);
|
|
static ssize_t cryptowrite(FAR struct file *filep,
|
|
FAR const char *buffer, size_t len);
|
|
static int cryptoclose(FAR struct file *filep);
|
|
static int cryptoioctl(FAR struct file *filep, int cmd, unsigned long arg);
|
|
|
|
/****************************************************************************
|
|
* Private Data
|
|
****************************************************************************/
|
|
|
|
static const struct file_operations g_cryptofops =
|
|
{
|
|
cryptof_open, /* open */
|
|
cryptof_close, /* close */
|
|
cryptof_read, /* read */
|
|
cryptof_write, /* write */
|
|
NULL, /* seek */
|
|
cryptof_ioctl, /* ioctl */
|
|
NULL, /* mmap */
|
|
NULL, /* truncate */
|
|
cryptof_poll /* poll */
|
|
};
|
|
|
|
static const struct file_operations g_cryptoops =
|
|
{
|
|
cryptoopen, /* open */
|
|
cryptoclose, /* close */
|
|
cryptoread, /* read */
|
|
cryptowrite, /* write */
|
|
NULL, /* seek */
|
|
cryptoioctl, /* ioctl */
|
|
NULL, /* mmap */
|
|
NULL, /* truncate */
|
|
NULL /* poll */
|
|
};
|
|
|
|
static struct inode g_cryptoinode =
|
|
{
|
|
.i_crefs = 1,
|
|
.u.i_ops = &g_cryptofops
|
|
};
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
FAR struct csession *csefind(FAR struct fcrypt *, u_int);
|
|
int csedelete(FAR struct fcrypt *, FAR struct csession *);
|
|
FAR struct csession *cseadd(FAR struct fcrypt *, FAR struct csession *);
|
|
FAR struct csession *csecreate(FAR struct fcrypt *, uint64_t,
|
|
caddr_t, uint64_t,
|
|
caddr_t, uint64_t, uint32_t,
|
|
uint32_t, bool, bool);
|
|
int csefree(FAR struct csession *);
|
|
|
|
int cryptodev_op(FAR struct csession *,
|
|
FAR struct crypt_op *);
|
|
int cryptodev_key(FAR struct crypt_kop *);
|
|
int cryptodev_dokey(FAR struct crypt_kop *kop, FAR struct crparam *kvp);
|
|
|
|
int cryptodev_cb(FAR struct cryptop *);
|
|
int cryptodevkey_cb(FAR struct cryptkop *);
|
|
|
|
/* ARGSUSED */
|
|
|
|
static ssize_t cryptof_read(FAR struct file *filep,
|
|
FAR char *buffer, size_t len)
|
|
{
|
|
return -EIO;
|
|
}
|
|
|
|
/* ARGSUSED */
|
|
|
|
static ssize_t cryptof_write(FAR struct file *filep,
|
|
FAR const char *buffer, size_t len)
|
|
{
|
|
return -EIO;
|
|
}
|
|
|
|
/* ARGSUSED */
|
|
|
|
static int cryptof_ioctl(FAR struct file *filep,
|
|
int cmd, unsigned long arg)
|
|
{
|
|
struct cryptoini cria;
|
|
struct cryptoini crie;
|
|
FAR struct fcrypt *fcr = filep->f_priv;
|
|
FAR struct csession *cse;
|
|
FAR struct session_op *sop;
|
|
FAR struct crypt_op *cop;
|
|
bool txform = false;
|
|
bool thash = false;
|
|
uint64_t sid;
|
|
uint32_t ses;
|
|
int error = 0;
|
|
|
|
switch (cmd)
|
|
{
|
|
case CIOCGSESSION:
|
|
sop = (FAR struct session_op *)arg;
|
|
switch (sop->cipher)
|
|
{
|
|
case 0:
|
|
break;
|
|
case CRYPTO_3DES_CBC:
|
|
case CRYPTO_BLF_CBC:
|
|
case CRYPTO_CAST_CBC:
|
|
case CRYPTO_AES_CBC:
|
|
case CRYPTO_AES_CTR:
|
|
case CRYPTO_AES_XTS:
|
|
case CRYPTO_AES_OFB:
|
|
case CRYPTO_AES_CFB_8:
|
|
case CRYPTO_AES_CFB_128:
|
|
case CRYPTO_NULL:
|
|
txform = true;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
switch (sop->mac)
|
|
{
|
|
case 0:
|
|
break;
|
|
case CRYPTO_MD5_HMAC:
|
|
case CRYPTO_SHA1_HMAC:
|
|
case CRYPTO_RIPEMD160_HMAC:
|
|
case CRYPTO_SHA2_256_HMAC:
|
|
case CRYPTO_SHA2_384_HMAC:
|
|
case CRYPTO_SHA2_512_HMAC:
|
|
case CRYPTO_AES_128_GMAC:
|
|
case CRYPTO_MD5:
|
|
case CRYPTO_SHA1:
|
|
case CRYPTO_SHA2_224:
|
|
case CRYPTO_SHA2_256:
|
|
case CRYPTO_SHA2_384:
|
|
case CRYPTO_SHA2_512:
|
|
thash = true;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
bzero(&crie, sizeof(crie));
|
|
bzero(&cria, sizeof(cria));
|
|
|
|
if (txform)
|
|
{
|
|
crie.cri_alg = sop->cipher;
|
|
crie.cri_klen = sop->keylen * 8;
|
|
|
|
crie.cri_key = kmm_malloc(crie.cri_klen / 8);
|
|
if (crie.cri_key == NULL)
|
|
{
|
|
error = -ENOMEM;
|
|
goto bail;
|
|
}
|
|
|
|
memcpy(crie.cri_key, sop->key, crie.cri_klen / 8);
|
|
if (thash)
|
|
{
|
|
crie.cri_next = &cria;
|
|
}
|
|
}
|
|
|
|
if (thash)
|
|
{
|
|
cria.cri_alg = sop->mac;
|
|
cria.cri_sid = -1;
|
|
cria.cri_klen = sop->mackeylen * 8;
|
|
|
|
if (cria.cri_klen)
|
|
{
|
|
cria.cri_key = kmm_malloc(cria.cri_klen / 8);
|
|
if (cria.cri_key == NULL)
|
|
{
|
|
error = -ENOMEM;
|
|
goto bail;
|
|
}
|
|
|
|
memcpy(cria.cri_key, sop->mackey, cria.cri_klen / 8);
|
|
}
|
|
}
|
|
|
|
error = crypto_newsession(&sid, txform ? &crie : &cria,
|
|
!cryptodevallowsoft);
|
|
|
|
if (error)
|
|
{
|
|
goto bail;
|
|
}
|
|
|
|
cse = csecreate(fcr, sid, crie.cri_key, crie.cri_klen,
|
|
cria.cri_key, cria.cri_klen, sop->cipher, sop->mac, txform,
|
|
thash);
|
|
|
|
if (cse == NULL)
|
|
{
|
|
crypto_freesession(sid);
|
|
error = -EINVAL;
|
|
goto bail;
|
|
}
|
|
|
|
sop->ses = cse->ses;
|
|
|
|
bail:
|
|
if (error)
|
|
{
|
|
if (crie.cri_key)
|
|
{
|
|
explicit_bzero(crie.cri_key, crie.cri_klen / 8);
|
|
kmm_free(crie.cri_key);
|
|
}
|
|
|
|
if (cria.cri_key)
|
|
{
|
|
explicit_bzero(cria.cri_key, cria.cri_klen / 8);
|
|
kmm_free(cria.cri_key);
|
|
}
|
|
}
|
|
|
|
break;
|
|
case CIOCFSESSION:
|
|
ses = *(FAR uint32_t *)arg;
|
|
cse = csefind(fcr, ses);
|
|
if (cse == NULL)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
csedelete(fcr, cse);
|
|
error = csefree(cse);
|
|
break;
|
|
case CIOCCRYPT:
|
|
cop = (FAR struct crypt_op *)arg;
|
|
cse = csefind(fcr, cop->ses);
|
|
if (cse == NULL)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
error = cryptodev_op(cse, cop);
|
|
break;
|
|
case CIOCKEY:
|
|
error = cryptodev_key((FAR struct crypt_kop *)arg);
|
|
break;
|
|
case CIOCASYMFEAT:
|
|
error = crypto_getfeat((FAR int *)arg);
|
|
break;
|
|
default:
|
|
error = -ENOTTY;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
int cryptodev_op(FAR struct csession *cse,
|
|
FAR struct crypt_op *cop)
|
|
{
|
|
FAR struct cryptop *crp = NULL;
|
|
FAR struct cryptodesc *crde = NULL;
|
|
FAR struct cryptodesc *crda = NULL;
|
|
int error = OK;
|
|
uint32_t hid;
|
|
|
|
if (cse->txform)
|
|
{
|
|
if (cop->len == 0)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
/* number of requests, not logical and */
|
|
|
|
crp = crypto_getreq(cse->txform + cse->thash);
|
|
if (crp == NULL)
|
|
{
|
|
error = -ENOMEM;
|
|
goto bail;
|
|
}
|
|
|
|
if (cse->thash)
|
|
{
|
|
crda = crp->crp_desc;
|
|
if (cse->txform)
|
|
crde = crda->crd_next;
|
|
}
|
|
else
|
|
{
|
|
if (cse->txform)
|
|
{
|
|
crde = crp->crp_desc;
|
|
}
|
|
else
|
|
{
|
|
error = -EINVAL;
|
|
goto bail;
|
|
}
|
|
}
|
|
|
|
if (crda)
|
|
{
|
|
crda->crd_skip = 0;
|
|
crda->crd_len = cop->len;
|
|
crda->crd_inject = 0;
|
|
|
|
crda->crd_alg = cse->mac;
|
|
crda->crd_key = cse->mackey;
|
|
crda->crd_klen = cse->mackeylen * 8;
|
|
if (cop->flags & COP_FLAG_UPDATE)
|
|
{
|
|
crda->crd_flags |= CRD_F_UPDATE;
|
|
}
|
|
else
|
|
{
|
|
crda->crd_flags &= ~CRD_F_UPDATE;
|
|
}
|
|
}
|
|
|
|
if (crde)
|
|
{
|
|
if (cop->op == COP_ENCRYPT)
|
|
{
|
|
crde->crd_flags |= CRD_F_ENCRYPT;
|
|
}
|
|
else
|
|
{
|
|
crde->crd_flags &= ~CRD_F_ENCRYPT;
|
|
}
|
|
|
|
crde->crd_len = cop->len;
|
|
crde->crd_inject = 0;
|
|
crde->crd_alg = cse->cipher;
|
|
crde->crd_key = cse->key;
|
|
crde->crd_klen = cse->keylen * 8;
|
|
}
|
|
|
|
crp->crp_ilen = cop->len;
|
|
crp->crp_buf = cop->src;
|
|
crp->crp_sid = cse->sid;
|
|
crp->crp_opaque = cse;
|
|
|
|
if (cop->iv)
|
|
{
|
|
if (crde == NULL)
|
|
{
|
|
error = -EINVAL;
|
|
goto bail;
|
|
}
|
|
|
|
crp->crp_iv = cop->iv;
|
|
}
|
|
|
|
if (cop->dst)
|
|
{
|
|
if (crde == NULL)
|
|
{
|
|
error = -EINVAL;
|
|
goto bail;
|
|
}
|
|
|
|
crp->crp_dst = cop->dst;
|
|
}
|
|
|
|
if (cop->mac)
|
|
{
|
|
if (crda == NULL)
|
|
{
|
|
error = -EINVAL;
|
|
goto bail;
|
|
}
|
|
|
|
crp->crp_mac = cop->mac;
|
|
}
|
|
|
|
/* try the fast path first */
|
|
|
|
crp->crp_flags = CRYPTO_F_IOV | CRYPTO_F_NOQUEUE;
|
|
hid = (crp->crp_sid >> 32) & 0xffffffff;
|
|
if (hid >= crypto_drivers_num)
|
|
{
|
|
goto dispatch;
|
|
}
|
|
|
|
if (crypto_drivers[hid].cc_flags & CRYPTOCAP_F_SOFTWARE)
|
|
{
|
|
goto dispatch;
|
|
}
|
|
|
|
if (crypto_drivers[hid].cc_process == NULL)
|
|
{
|
|
goto dispatch;
|
|
}
|
|
|
|
error = crypto_drivers[hid].cc_process(crp);
|
|
if (error)
|
|
{
|
|
/* clear error */
|
|
|
|
crp->crp_etype = 0;
|
|
goto dispatch;
|
|
}
|
|
|
|
goto processed;
|
|
dispatch:
|
|
crp->crp_flags = CRYPTO_F_IOV;
|
|
crypto_invoke(crp);
|
|
processed:
|
|
|
|
if (crde && (cop->flags & COP_FLAG_UPDATE) == 0)
|
|
{
|
|
crde->crd_flags &= ~CRD_F_IV_EXPLICIT;
|
|
}
|
|
|
|
if (cse->error)
|
|
{
|
|
error = cse->error;
|
|
goto bail;
|
|
}
|
|
|
|
if (crp->crp_etype != 0)
|
|
{
|
|
error = crp->crp_etype;
|
|
goto bail;
|
|
}
|
|
|
|
bail:
|
|
if (crp)
|
|
{
|
|
crypto_freereq(crp);
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
int cryptodev_key(FAR struct crypt_kop *kop)
|
|
{
|
|
FAR struct cryptkop *krp = NULL;
|
|
int error = -EINVAL;
|
|
int in;
|
|
int out;
|
|
int size;
|
|
int i;
|
|
|
|
if (kop->crk_iparams + kop->crk_oparams > CRK_MAXPARAM)
|
|
{
|
|
return -EFBIG;
|
|
}
|
|
|
|
in = kop->crk_iparams;
|
|
out = kop->crk_oparams;
|
|
switch (kop->crk_op)
|
|
{
|
|
case CRK_MOD_EXP:
|
|
if (in == 3 && out == 1)
|
|
break;
|
|
return -EINVAL;
|
|
case CRK_MOD_EXP_CRT:
|
|
if (in == 6 && out == 1)
|
|
break;
|
|
return -EINVAL;
|
|
case CRK_DSA_SIGN:
|
|
if (in == 5 && out == 2)
|
|
break;
|
|
return -EINVAL;
|
|
case CRK_DSA_VERIFY:
|
|
if (in == 7 && out == 0)
|
|
break;
|
|
return -EINVAL;
|
|
case CRK_DH_COMPUTE_KEY:
|
|
if (in == 3 && out == 1)
|
|
break;
|
|
return -EINVAL;
|
|
case CRK_RSA_PCKS15_VERIFY:
|
|
if (in == 5 && out == 0)
|
|
break;
|
|
return -EINVAL;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
krp = kmm_zalloc(sizeof *krp);
|
|
krp->krp_op = kop->crk_op;
|
|
krp->krp_status = kop->crk_status;
|
|
krp->krp_iparams = kop->crk_iparams;
|
|
krp->krp_oparams = kop->crk_oparams;
|
|
krp->krp_status = 0;
|
|
|
|
for (i = 0; i < CRK_MAXPARAM; i++)
|
|
{
|
|
krp->krp_param[i].crp_nbits = kop->crk_param[i].crp_nbits;
|
|
if (kop->crk_param[i].crp_nbits > 65536)
|
|
{
|
|
/* XXX how big do we need to support? */
|
|
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < krp->krp_iparams + krp->krp_oparams; i++)
|
|
{
|
|
size = (krp->krp_param[i].crp_nbits + 7) / 8;
|
|
if (size == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
krp->krp_param[i].crp_p = kmm_zalloc(size);
|
|
if (i >= krp->krp_iparams)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
memcpy(krp->krp_param[i].crp_p, kop->crk_param[i].crp_p, size);
|
|
}
|
|
|
|
error = crypto_kinvoke(krp);
|
|
if (error)
|
|
{
|
|
goto fail;
|
|
}
|
|
|
|
if (krp->krp_status != 0)
|
|
{
|
|
error = krp->krp_status;
|
|
goto fail;
|
|
}
|
|
|
|
for (i = krp->krp_iparams; i < krp->krp_iparams + krp->krp_oparams; i++)
|
|
{
|
|
size = (krp->krp_param[i].crp_nbits + 7) / 8;
|
|
if (size == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
memcpy(kop->crk_param[i].crp_p,
|
|
krp->krp_param[i].crp_p, size);
|
|
}
|
|
|
|
fail:
|
|
if (krp)
|
|
{
|
|
kop->crk_status = krp->krp_status;
|
|
for (i = 0; i < CRK_MAXPARAM; i++)
|
|
{
|
|
if (krp->krp_param[i].crp_p)
|
|
{
|
|
explicit_bzero(krp->krp_param[i].crp_p,
|
|
(krp->krp_param[i].crp_nbits + 7) / 8);
|
|
kmm_free(krp->krp_param[i].crp_p);
|
|
}
|
|
}
|
|
|
|
kmm_free(krp);
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
/* ARGSUSED */
|
|
|
|
static int cryptof_poll(FAR struct file *filep,
|
|
struct pollfd *fds, bool setup)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/* ARGSUSED */
|
|
|
|
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);
|
|
filep->f_priv = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Clone csessions into a new fd */
|
|
|
|
static int cryptof_open(FAR struct file *filep)
|
|
{
|
|
FAR struct fcrypt *fcr = filep->f_priv;
|
|
FAR struct fcrypt *fcrd = NULL;
|
|
FAR struct csession *cse;
|
|
FAR struct csession *csed;
|
|
struct cryptoini cria;
|
|
struct cryptoini crie;
|
|
uint64_t sid;
|
|
int ret = 0;
|
|
|
|
if (fcr == NULL)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* A 'struct fcrypt' is bound to the fd of the cryptodev,
|
|
* which stores a list of sessions. Each encryption operation
|
|
* would create a context and get a session id, which can be
|
|
* used to find the specific encryption operation. Therefore,
|
|
* in order to complete the copy operation, it is necessary to
|
|
* create same session based on the copy fd and obtain the newly
|
|
* generated session id.
|
|
*/
|
|
|
|
fcrd = kmm_zalloc(sizeof(struct fcrypt));
|
|
if (fcrd == NULL)
|
|
{
|
|
return -ENOMEM;
|
|
}
|
|
|
|
TAILQ_INIT(&fcrd->csessions);
|
|
TAILQ_FOREACH(cse, &fcr->csessions, next)
|
|
{
|
|
bzero(&crie, sizeof(crie));
|
|
bzero(&cria, sizeof(cria));
|
|
if (cse->txform)
|
|
{
|
|
crie.cri_alg = cse->cipher;
|
|
crie.cri_klen = cse->keylen * 8;
|
|
|
|
crie.cri_key = kmm_malloc(cse->keylen);
|
|
if (crie.cri_key == NULL)
|
|
{
|
|
ret = -ENOMEM;
|
|
goto bail;
|
|
}
|
|
|
|
memcpy(crie.cri_key, cse->key, cse->keylen);
|
|
if (cse->thash)
|
|
{
|
|
crie.cri_next = &cria;
|
|
}
|
|
}
|
|
|
|
if (cse->thash)
|
|
{
|
|
cria.cri_alg = cse->mac;
|
|
cria.cri_sid = cse->sid;
|
|
cria.cri_klen = cse->mackeylen * 8;
|
|
|
|
if (cria.cri_klen)
|
|
{
|
|
cria.cri_key = kmm_malloc(cse->mackeylen);
|
|
if (cria.cri_key == NULL)
|
|
{
|
|
ret = -ENOMEM;
|
|
goto bail;
|
|
}
|
|
|
|
memcpy(cria.cri_key, cse->mackey, cse->mackeylen);
|
|
}
|
|
}
|
|
|
|
ret = crypto_newsession(&sid, cse->txform ? &crie : &cria,
|
|
!cryptodevallowsoft);
|
|
if (ret < 0)
|
|
{
|
|
goto bail;
|
|
}
|
|
|
|
csed = csecreate(fcrd, sid, crie.cri_key, crie.cri_klen,
|
|
cria.cri_key, cria.cri_klen,
|
|
cse->cipher, cse->mac, cse->txform,
|
|
cse->thash);
|
|
if (csed == NULL)
|
|
{
|
|
crypto_freesession(sid);
|
|
ret = -EINVAL;
|
|
goto bail;
|
|
}
|
|
|
|
csed->ses = cse->ses;
|
|
}
|
|
|
|
filep->f_priv = fcrd;
|
|
return 0;
|
|
|
|
bail:
|
|
if (crie.cri_key)
|
|
{
|
|
explicit_bzero(crie.cri_key, crie.cri_klen / 8);
|
|
kmm_free(crie.cri_key);
|
|
}
|
|
|
|
if (cria.cri_key)
|
|
{
|
|
explicit_bzero(cria.cri_key, cria.cri_klen / 8);
|
|
kmm_free(cria.cri_key);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int cryptoopen(FAR struct file *filep)
|
|
{
|
|
if (usercrypto == 0)
|
|
{
|
|
return -ENXIO;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t cryptoread(FAR struct file *filep,
|
|
FAR char *buffer, size_t len)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t cryptowrite(FAR struct file *filep,
|
|
FAR const char *buffer, size_t len)
|
|
{
|
|
return len;
|
|
}
|
|
|
|
static int cryptoclose(FAR struct file *filep)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int cryptoioctl(FAR struct file *filep, int cmd, unsigned long arg)
|
|
{
|
|
FAR struct fcrypt *fcr;
|
|
int fd;
|
|
int error = 0;
|
|
|
|
switch (cmd)
|
|
{
|
|
case CRIOGET:
|
|
fcr = kmm_malloc(sizeof(struct fcrypt));
|
|
TAILQ_INIT(&fcr->csessions);
|
|
|
|
fd = file_allocate(&g_cryptoinode, 0,
|
|
0, fcr, 0, true);
|
|
if (fd < 0)
|
|
{
|
|
kmm_free(fcr);
|
|
return fd;
|
|
}
|
|
|
|
fcr->sesn = 0;
|
|
*(FAR uint32_t *)arg = fd;
|
|
break;
|
|
default:
|
|
error = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
FAR struct csession *csefind(FAR struct fcrypt *fcr, u_int ses)
|
|
{
|
|
FAR struct csession *cse;
|
|
|
|
TAILQ_FOREACH(cse, &fcr->csessions, next)
|
|
if (cse->ses == ses)
|
|
{
|
|
return cse;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int csedelete(FAR struct fcrypt *fcr, FAR struct csession *cse_del)
|
|
{
|
|
FAR struct csession *cse;
|
|
|
|
TAILQ_FOREACH(cse, &fcr->csessions, next)
|
|
{
|
|
if (cse == cse_del)
|
|
{
|
|
TAILQ_REMOVE(&fcr->csessions, cse, next);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
FAR struct csession *cseadd(FAR struct fcrypt *fcr,
|
|
FAR struct csession *cse)
|
|
{
|
|
TAILQ_INSERT_TAIL(&fcr->csessions, cse, next);
|
|
cse->ses = fcr->sesn++;
|
|
return cse;
|
|
}
|
|
|
|
FAR struct csession *csecreate(FAR struct fcrypt *fcr, uint64_t sid,
|
|
caddr_t key, uint64_t keylen,
|
|
caddr_t mackey, uint64_t mackeylen,
|
|
uint32_t cipher, uint32_t mac,
|
|
bool txform, bool thash)
|
|
{
|
|
FAR struct csession *cse;
|
|
|
|
cse = kmm_malloc(sizeof(struct csession));
|
|
if (cse != NULL)
|
|
{
|
|
cse->key = key;
|
|
cse->keylen = keylen / 8;
|
|
cse->mackey = mackey;
|
|
cse->mackeylen = mackeylen / 8;
|
|
cse->sid = sid;
|
|
cse->cipher = cipher;
|
|
cse->mac = mac;
|
|
cse->txform = txform;
|
|
cse->thash = thash;
|
|
cse->error = 0;
|
|
cseadd(fcr, cse);
|
|
}
|
|
|
|
return cse;
|
|
}
|
|
|
|
int csefree(FAR struct csession *cse)
|
|
{
|
|
int error;
|
|
|
|
error = crypto_freesession(cse->sid);
|
|
if (cse->key)
|
|
{
|
|
kmm_free(cse->key);
|
|
}
|
|
|
|
if (cse->mackey)
|
|
{
|
|
kmm_free(cse->mackey);
|
|
}
|
|
|
|
kmm_free(cse);
|
|
return error;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
void devcrypto_register(void)
|
|
{
|
|
register_driver("/dev/crypto", &g_cryptoops, 0666, NULL);
|
|
|
|
#ifdef CONFIG_CRYPTO_CRYPTODEV_SOFTWARE
|
|
swcr_init();
|
|
#endif
|
|
|
|
#ifdef CONFIG_CRYPTO_CRYPTODEV_HARDWARE
|
|
hwcr_init();
|
|
#endif
|
|
}
|