code.ossystems Code Review - meta-freescale.git/blob

   1 From eccd6277b067cd85094eb057225cc0a983300b9f Mon Sep 17 00:00:00 2001
   2 From: Yashpal Dutta <yashpal.dutta@freescale.com>
   3 Date: Fri, 7 Mar 2014 07:53:53 +0545
   4 Subject: [PATCH 06/15] ECC_KEYGEN and DLC_KEYGEN supported in cryptodev module
   5
   6 Upstream-status: Pending
   7
   8 Signed-off-by: Yashpal Dutta <yashpal.dutta@freescale.com>
   9 ---
  10  cryptlib.c         |  2 ++
  11  crypto/cryptodev.h |  5 +++-
  12  ioctl.c            | 29 +++++++++++++++++--
  13  main.c             | 85 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
  14  4 files changed, 118 insertions(+), 3 deletions(-)
  15
  16 diff --git a/cryptlib.c b/cryptlib.c
  17 index 6900028..47cd568 100644
  18 --- a/cryptlib.c
  19 +++ b/cryptlib.c
  20 @@ -452,6 +452,8 @@ int cryptodev_pkc_offload(struct cryptodev_pkc  *pkc)
  21         case DSA_VERIFY:
  22         case ECDSA_SIGN:
  23         case ECDSA_VERIFY:
  24 +       case DLC_KEYGEN:
  25 +       case ECC_KEYGEN:
  26                 pkc->s = crypto_alloc_pkc("pkc(dsa)",
  27                          CRYPTO_ALG_TYPE_PKC_DSA, 0);
  28                 break;
  29 diff --git a/crypto/cryptodev.h b/crypto/cryptodev.h
  30 index 4436fbf..275a55c 100644
  31 --- a/crypto/cryptodev.h
  32 +++ b/crypto/cryptodev.h
  33 @@ -268,6 +268,8 @@ enum cryptodev_crk_op_t {
  34         CRK_DSA_SIGN = 2,
  35         CRK_DSA_VERIFY = 3,
  36         CRK_DH_COMPUTE_KEY = 4,
  37 +       CRK_DSA_GENERATE_KEY = 5,
  38 +       CRK_DH_GENERATE_KEY = 6,
  39         CRK_ALGORITHM_ALL
  40  };
  41
  42 @@ -280,7 +282,8 @@ enum cryptodev_crk_op_t {
  43  #define CRF_DSA_SIGN           (1 << CRK_DSA_SIGN)
  44  #define CRF_DSA_VERIFY         (1 << CRK_DSA_VERIFY)
  45  #define CRF_DH_COMPUTE_KEY     (1 << CRK_DH_COMPUTE_KEY)
  46 -
  47 +#define CRF_DSA_GENERATE_KEY   (1 << CRK_DSA_GENERATE_KEY)
  48 +#define CRF_DH_GENERATE_KEY    (1 << CRK_DH_GENERATE_KEY)
  49
  50  /* ioctl's. Compatible with old linux cryptodev.h
  51   */
  52 diff --git a/ioctl.c b/ioctl.c
  53 index e2f407f..1f0741a 100644
  54 --- a/ioctl.c
  55 +++ b/ioctl.c
  56 @@ -726,6 +726,23 @@ static int crypto_async_fetch_asym(struct cryptodev_pkc *pkc)
  57                                      dh_req->z, dh_req->z_len);
  58         }
  59         break;
  60 +       case CRK_DSA_GENERATE_KEY:
  61 +       case CRK_DH_GENERATE_KEY:
  62 +       {
  63 +               struct keygen_req_s *key_req = &pkc_req->req_u.keygen;
  64 +
  65 +               if (pkc_req->type == ECC_KEYGEN) {
  66 +                       copy_to_user(ckop->crk_param[4].crp_p, key_req->pub_key,
  67 +                                    key_req->pub_key_len);
  68 +                       copy_to_user(ckop->crk_param[5].crp_p,
  69 +                                    key_req->priv_key, key_req->priv_key_len);
  70 +               } else {
  71 +                       copy_to_user(ckop->crk_param[3].crp_p,
  72 +                                    key_req->pub_key, key_req->pub_key_len);
  73 +                       copy_to_user(ckop->crk_param[4].crp_p,
  74 +                                    key_req->priv_key, key_req->priv_key_len);
  75 +               }
  76 +       }
  77         default:
  78                 ret = -EINVAL;
  79         }
  80 @@ -939,8 +956,9 @@ cryptodev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg_)
  81
  82         switch (cmd) {
  83         case CIOCASYMFEAT:
  84 -               return put_user(CRF_MOD_EXP_CRT |  CRF_MOD_EXP |
  85 -                       CRF_DSA_SIGN | CRF_DSA_VERIFY | CRF_DH_COMPUTE_KEY, p);
  86 +               return put_user(CRF_MOD_EXP_CRT |  CRF_MOD_EXP | CRF_DSA_SIGN |
  87 +                       CRF_DSA_VERIFY | CRF_DH_COMPUTE_KEY |
  88 +                       CRF_DSA_GENERATE_KEY, p);
  89         case CRIOGET:
  90                 fd = clonefd(filp);
  91                 ret = put_user(fd, p);
  92 @@ -1084,7 +1102,14 @@ cryptodev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg_)
  93                 if (cookie_list.cookie_available)
  94                         copy_to_user(arg, &cookie_list,
  95                                      sizeof(struct pkc_cookie_list_s));
  96 +               else {
  97 +                       struct pkc_cookie_list_s *user_ck_list = (void *)arg;
  98 +
  99 +                       put_user(0, &(user_ck_list->cookie_available));
 100 +               }
 101 +               ret = cookie_list.cookie_available;
 102         }
 103 +
 104         return ret;
 105         default:
 106                 return -EINVAL;
 107 diff --git a/main.c b/main.c
 108 index 0b7951e..c901bc7 100644
 109 --- a/main.c
 110 +++ b/main.c
 111 @@ -342,6 +342,85 @@ err:
 112         return rc;
 113  }
 114
 115 +int crypto_kop_keygen(struct cryptodev_pkc *pkc)
 116 +{
 117 +       struct kernel_crypt_kop *kop = &pkc->kop;
 118 +       struct crypt_kop *cop = &kop->kop;
 119 +       struct pkc_request *pkc_req;
 120 +       struct keygen_req_s *key_req;
 121 +       int rc, buf_size;
 122 +       uint8_t *buf;
 123 +
 124 +       if (!cop->crk_param[0].crp_nbits || !cop->crk_param[1].crp_nbits ||
 125 +           !cop->crk_param[2].crp_nbits || !cop->crk_param[3].crp_nbits ||
 126 +           !cop->crk_param[4].crp_nbits)
 127 +               return -EINVAL;
 128 +
 129 +       pkc_req = &pkc->req;
 130 +       key_req = &pkc_req->req_u.keygen;
 131 +       key_req->q_len = (cop->crk_param[0].crp_nbits + 7)/8;
 132 +       key_req->r_len = (cop->crk_param[1].crp_nbits + 7)/8;
 133 +       key_req->g_len = (cop->crk_param[2].crp_nbits + 7)/8;
 134 +       if (cop->crk_iparams == 3) {
 135 +               key_req->pub_key_len = (cop->crk_param[3].crp_nbits + 7)/8;
 136 +               key_req->priv_key_len = (cop->crk_param[4].crp_nbits + 7)/8;
 137 +               buf_size = key_req->q_len + key_req->r_len + key_req->g_len +
 138 +                       key_req->pub_key_len + key_req->priv_key_len;
 139 +               pkc_req->type = DLC_KEYGEN;
 140 +       } else {
 141 +               key_req->ab_len = (cop->crk_param[3].crp_nbits + 7)/8;
 142 +               key_req->pub_key_len = (cop->crk_param[4].crp_nbits + 7)/8;
 143 +               key_req->priv_key_len = (cop->crk_param[5].crp_nbits + 7)/8;
 144 +               buf_size = key_req->q_len + key_req->r_len + key_req->g_len +
 145 +                       key_req->pub_key_len + key_req->priv_key_len +
 146 +                       key_req->ab_len;
 147 +               pkc_req->type = ECC_KEYGEN;
 148 +               pkc_req->curve_type = cop->curve_type;
 149 +       }
 150 +
 151 +       buf = kzalloc(buf_size, GFP_DMA);
 152 +       if (!buf)
 153 +               return -ENOMEM;
 154 +
 155 +       key_req->q = buf;
 156 +       key_req->r = key_req->q + key_req->q_len;
 157 +       key_req->g = key_req->r + key_req->r_len;
 158 +       key_req->pub_key = key_req->g + key_req->g_len;
 159 +       key_req->priv_key = key_req->pub_key + key_req->pub_key_len;
 160 +       copy_from_user(key_req->q, cop->crk_param[0].crp_p, key_req->q_len);
 161 +       copy_from_user(key_req->r, cop->crk_param[1].crp_p, key_req->r_len);
 162 +       copy_from_user(key_req->g, cop->crk_param[2].crp_p, key_req->g_len);
 163 +       if (cop->crk_iparams == 3) {
 164 +               copy_from_user(key_req->pub_key, cop->crk_param[3].crp_p,
 165 +                              key_req->pub_key_len);
 166 +               copy_from_user(key_req->priv_key, cop->crk_param[4].crp_p,
 167 +                              key_req->priv_key_len);
 168 +       } else {
 169 +               key_req->ab = key_req->priv_key + key_req->priv_key_len;
 170 +               copy_from_user(key_req->ab, cop->crk_param[3].crp_p,
 171 +                              key_req->ab_len);
 172 +               copy_from_user(key_req->pub_key, cop->crk_param[4].crp_p,
 173 +                              key_req->pub_key_len);
 174 +               copy_from_user(key_req->priv_key, cop->crk_param[5].crp_p,
 175 +                              key_req->priv_key_len);
 176 +       }
 177 +
 178 +       rc = cryptodev_pkc_offload(pkc);
 179 +       if (pkc->type == SYNCHRONOUS) {
 180 +               if (rc)
 181 +                       goto err;
 182 +       } else {
 183 +               if (rc != -EINPROGRESS && !rc)
 184 +                       goto err;
 185 +
 186 +               pkc->cookie = buf;
 187 +               return rc;
 188 +       }
 189 +err:
 190 +       kfree(buf);
 191 +       return rc;
 192 +}
 193 +
 194  int crypto_kop_dh_key(struct cryptodev_pkc *pkc)
 195  {
 196         struct kernel_crypt_kop *kop = &pkc->kop;
 197 @@ -554,6 +633,12 @@ int crypto_run_asym(struct cryptodev_pkc *pkc)
 198                         goto err;
 199                 ret = crypto_kop_dh_key(pkc);
 200                 break;
 201 +       case CRK_DH_GENERATE_KEY:
 202 +       case CRK_DSA_GENERATE_KEY:
 203 +               if ((kop->kop.crk_iparams != 3 && kop->kop.crk_iparams != 4))
 204 +                       goto err;
 205 +               ret = crypto_kop_keygen(pkc);
 206 +               break;
 207         }
 208  err:
 209         return ret;
 210 --
 211 2.3.5
 212