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

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