Changeset 32096


Ignore:
Timestamp:
May 19, 2017, 5:16:05 AM (5 days ago)
Author:
brainslayer
Message:

update cryptodev

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/router/openssl/crypto/engine/eng_cryptodev.c

    r30696 r32096  
    33 * Copyright (c) 2002 Theo de Raadt
    44 * Copyright (c) 2002 Markus Friedl
     5 * Copyright (c) 2012 Nikos Mavrogiannopoulos
    56 * All rights reserved.
    67 *
     
    3536#if (defined(__unix__) || defined(unix)) && !defined(USG) && \
    3637        (defined(OpenBSD) || defined(__FreeBSD__))
    37 # include <sys/param.h>
    38 # if (OpenBSD >= 200112) || ((__FreeBSD_version >= 470101 && __FreeBSD_version < 500000) || __FreeBSD_version >= 500041)
    39 #  define HAVE_CRYPTODEV
    40 # endif
    41 # if (OpenBSD >= 200110)
    42 #  define HAVE_SYSLOG_R
    43 # endif
     38#include <sys/param.h>
     39#if (OpenBSD >= 200112) || ((__FreeBSD_version >= 470101 && __FreeBSD_version < 500000) || __FreeBSD_version >= 500041)
     40#define HAVE_CRYPTODEV
     41#endif
     42#if (OpenBSD >= 200110)
     43#define HAVE_SYSLOG_R
     44#endif
    4445#endif
    4546
     
    4849void ENGINE_load_cryptodev(void)
    4950{
    50     /* This is a NOP on platforms without /dev/crypto */
    51     return;
     51        /* This is a NOP on platforms without /dev/crypto */
     52        return;
    5253}
    5354
    5455#else
    5556
    56 # include <sys/types.h>
    57 # include <crypto/cryptodev.h>
    58 # include <openssl/dh.h>
    59 # include <openssl/dsa.h>
    60 # include <openssl/err.h>
    61 # include <openssl/rsa.h>
    62 # include <sys/ioctl.h>
    63 # include <errno.h>
    64 # include <stdio.h>
    65 # include <unistd.h>
    66 # include <fcntl.h>
    67 # include <stdarg.h>
    68 # include <syslog.h>
    69 # include <errno.h>
    70 # include <string.h>
     57#include <sys/types.h>
     58#include <crypto/cryptodev.h>
     59#include <openssl/dh.h>
     60#include <openssl/dsa.h>
     61#include <openssl/err.h>
     62#include <openssl/rsa.h>
     63#include <sys/ioctl.h>
     64#include <errno.h>
     65#include <stdio.h>
     66#include <unistd.h>
     67#include <fcntl.h>
     68#include <stdarg.h>
     69#include <syslog.h>
     70#include <errno.h>
     71#include <string.h>
    7172
    7273struct dev_crypto_state {
    73     struct session_op d_sess;
    74     int d_fd;
    75 # ifdef USE_CRYPTODEV_DIGESTS
    76     char dummy_mac_key[HASH_MAX_LEN];
    77     unsigned char digest_res[HASH_MAX_LEN];
    78     char *mac_data;
    79     int mac_len;
    80 # endif
     74        struct session_op d_sess;
     75        int d_fd;
     76
     77#ifdef USE_CRYPTODEV_DIGESTS
     78        unsigned char digest_res[HASH_MAX_LEN];
     79        char *mac_data;
     80        int mac_len;
     81#endif
    8182};
    8283
     
    8788static int get_dev_crypto(void);
    8889static int get_cryptodev_ciphers(const int **cnids);
    89 # ifdef USE_CRYPTODEV_DIGESTS
     90#ifdef USE_CRYPTODEV_DIGESTS
    9091static int get_cryptodev_digests(const int **cnids);
    91 # endif
     92#endif
    9293static int cryptodev_usable_ciphers(const int **nids);
    9394static int cryptodev_usable_digests(const int **nids);
    94 static int cryptodev_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
    95                             const unsigned char *in, size_t inl);
    96 static int cryptodev_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
    97                               const unsigned char *iv, int enc);
    98 static int cryptodev_cleanup(EVP_CIPHER_CTX *ctx);
    99 static int cryptodev_engine_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
    100                                     const int **nids, int nid);
    101 static int cryptodev_engine_digests(ENGINE *e, const EVP_MD **digest,
    102                                     const int **nids, int nid);
    103 static int bn2crparam(const BIGNUM *a, struct crparam *crp);
    104 static int crparam2bn(struct crparam *crp, BIGNUM *a);
     95static int cryptodev_cipher(EVP_CIPHER_CTX * ctx, unsigned char *out, const unsigned char *in, size_t inl);
     96static int cryptodev_init_key(EVP_CIPHER_CTX * ctx, const unsigned char *key, const unsigned char *iv, int enc);
     97static int cryptodev_cleanup(EVP_CIPHER_CTX * ctx);
     98static int cryptodev_engine_ciphers(ENGINE * e, const EVP_CIPHER ** cipher, const int **nids, int nid);
     99static int cryptodev_engine_digests(ENGINE * e, const EVP_MD ** digest, const int **nids, int nid);
     100static int bn2crparam(const BIGNUM * a, struct crparam *crp);
     101static int crparam2bn(struct crparam *crp, BIGNUM * a);
    105102static void zapparams(struct crypt_kop *kop);
    106 static int cryptodev_asym(struct crypt_kop *kop, int rlen, BIGNUM *r,
    107                           int slen, BIGNUM *s);
    108 
    109 static int cryptodev_bn_mod_exp(BIGNUM *r, const BIGNUM *a,
    110                                 const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
    111                                 BN_MONT_CTX *m_ctx);
    112 static int cryptodev_rsa_nocrt_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa,
    113                                        BN_CTX *ctx);
    114 static int cryptodev_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa,
    115                                  BN_CTX *ctx);
    116 static int cryptodev_dsa_bn_mod_exp(DSA *dsa, BIGNUM *r, BIGNUM *a,
    117                                     const BIGNUM *p, const BIGNUM *m,
    118                                     BN_CTX *ctx, BN_MONT_CTX *m_ctx);
    119 static int cryptodev_dsa_dsa_mod_exp(DSA *dsa, BIGNUM *t1, BIGNUM *g,
    120                                      BIGNUM *u1, BIGNUM *pub_key, BIGNUM *u2,
    121                                      BIGNUM *p, BN_CTX *ctx,
    122                                      BN_MONT_CTX *mont);
    123 static DSA_SIG *cryptodev_dsa_do_sign(const unsigned char *dgst, int dlen,
    124                                       DSA *dsa);
    125 static int cryptodev_dsa_verify(const unsigned char *dgst, int dgst_len,
    126                                 DSA_SIG *sig, DSA *dsa);
    127 static int cryptodev_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a,
    128                                 const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
    129                                 BN_MONT_CTX *m_ctx);
    130 static int cryptodev_dh_compute_key(unsigned char *key, const BIGNUM *pub_key,
    131                                     DH *dh);
    132 static int cryptodev_ctrl(ENGINE *e, int cmd, long i, void *p,
    133                           void (*f) (void));
     103static int cryptodev_asym(struct crypt_kop *kop, int rlen, BIGNUM * r, int slen, BIGNUM * s);
     104
     105static int cryptodev_bn_mod_exp(BIGNUM * r, const BIGNUM * a, const BIGNUM * p, const BIGNUM * m, BN_CTX * ctx, BN_MONT_CTX * m_ctx);
     106static int cryptodev_rsa_nocrt_mod_exp(BIGNUM * r0, const BIGNUM * I, RSA * rsa, BN_CTX * ctx);
     107static int cryptodev_rsa_mod_exp(BIGNUM * r0, const BIGNUM * I, RSA * rsa, BN_CTX * ctx);
     108static int cryptodev_dsa_bn_mod_exp(DSA * dsa, BIGNUM * r, BIGNUM * a, const BIGNUM * p, const BIGNUM * m, BN_CTX * ctx, BN_MONT_CTX * m_ctx);
     109static int cryptodev_dsa_dsa_mod_exp(DSA * dsa, BIGNUM * t1, BIGNUM * g, BIGNUM * u1, BIGNUM * pub_key, BIGNUM * u2, BIGNUM * p, BN_CTX * ctx, BN_MONT_CTX * mont);
     110static DSA_SIG *cryptodev_dsa_do_sign(const unsigned char *dgst, int dlen, DSA * dsa);
     111static int cryptodev_dsa_verify(const unsigned char *dgst, int dgst_len, DSA_SIG * sig, DSA * dsa);
     112static int cryptodev_mod_exp_dh(const DH * dh, BIGNUM * r, const BIGNUM * a, const BIGNUM * p, const BIGNUM * m, BN_CTX * ctx, BN_MONT_CTX * m_ctx);
     113static int cryptodev_dh_compute_key(unsigned char *key, const BIGNUM * pub_key, DH * dh);
     114static int cryptodev_ctrl(ENGINE * e, int cmd, long i, void *p, void (*f) (void));
    134115void ENGINE_load_cryptodev(void);
    135116
    136117static const ENGINE_CMD_DEFN cryptodev_defns[] = {
    137     {0, NULL, NULL, 0}
     118        {0, NULL, NULL, 0}
    138119};
    139120
    140121static struct {
    141     int id;
    142     int nid;
    143     int ivmax;
    144     int keylen;
     122        int id;
     123        int nid;
     124        int ivmax;
     125        int keylen;
    145126} ciphers[] = {
    146     {
    147         CRYPTO_ARC4, NID_rc4, 0, 16,
    148     },
    149     {
    150         CRYPTO_DES_CBC, NID_des_cbc, 8, 8,
    151     },
    152     {
    153         CRYPTO_3DES_CBC, NID_des_ede3_cbc, 8, 24,
    154     },
    155     {
    156         CRYPTO_AES_CBC, NID_aes_128_cbc, 16, 16,
    157     },
    158     {
    159         CRYPTO_AES_CBC, NID_aes_192_cbc, 16, 24,
    160     },
    161     {
    162         CRYPTO_AES_CBC, NID_aes_256_cbc, 16, 32,
    163     },
    164     { CRYPTO_AES_CBC,           NID_aes_512_cbc,        16,     64, },
    165 # ifdef CRYPTO_AES_CTR
    166     {
    167         CRYPTO_AES_CTR, NID_aes_128_ctr, 14, 16,
    168     },
    169     {
    170         CRYPTO_AES_CTR, NID_aes_192_ctr, 14, 24,
    171     },
    172     {
    173         CRYPTO_AES_CTR, NID_aes_256_ctr, 14, 32,
    174     },
    175 # endif
    176     {
    177         CRYPTO_BLF_CBC, NID_bf_cbc, 8, 16,
    178     },
    179     {
    180         CRYPTO_CAST_CBC, NID_cast5_cbc, 8, 16,
    181     },
    182     {
    183         CRYPTO_SKIPJACK_CBC, NID_undef, 0, 0,
    184     },
    185     {
    186         0, NID_undef, 0, 0,
    187     },
    188 };
    189 
    190 # ifdef USE_CRYPTODEV_DIGESTS
     127        {
     128        CRYPTO_ARC4, NID_rc4, 0, 16,}, {
     129        CRYPTO_DES_CBC, NID_des_cbc, 8, 8,}, {
     130        CRYPTO_3DES_CBC, NID_des_ede3_cbc, 8, 24,}, {
     131        CRYPTO_AES_CBC, NID_aes_128_cbc, 16, 16,}, {
     132        CRYPTO_AES_CBC, NID_aes_192_cbc, 16, 24,}, {
     133        CRYPTO_AES_CBC, NID_aes_256_cbc, 16, 32,},
     134#ifdef CRYPTO_AES_CTR
     135        {
     136        CRYPTO_AES_CTR, NID_aes_128_ctr, 14, 16,}, {
     137        CRYPTO_AES_CTR, NID_aes_192_ctr, 14, 24,}, {
     138        CRYPTO_AES_CTR, NID_aes_256_ctr, 14, 32,},
     139#endif
     140        {
     141        CRYPTO_BLF_CBC, NID_bf_cbc, 8, 16,}, {
     142        CRYPTO_CAST_CBC, NID_cast5_cbc, 8, 16,}, {
     143        CRYPTO_SKIPJACK_CBC, NID_undef, 0, 0,}, {
     1440, NID_undef, 0, 0,},};
     145
     146#ifdef USE_CRYPTODEV_DIGESTS
    191147static struct {
    192     int id;
    193     int nid;
    194     int keylen;
     148        int id;
     149        int nid;
     150        int digestlen;
    195151} digests[] = {
    196     {
    197         CRYPTO_MD5_HMAC, NID_hmacWithMD5, 16
    198     },
    199     {
    200         CRYPTO_SHA1_HMAC, NID_hmacWithSHA1, 20
    201     },
    202     {
    203         CRYPTO_RIPEMD160_HMAC, NID_ripemd160, 16
    204         /* ? */
    205     },
    206     {
    207         CRYPTO_MD5_KPDK, NID_undef, 0
    208     },
    209     {
    210         CRYPTO_SHA1_KPDK, NID_undef, 0
    211     },
    212     {
    213         CRYPTO_MD5, NID_md5, 16
    214     },
    215     {
    216         CRYPTO_SHA1, NID_sha1, 20
    217     },
    218     {
    219         0, NID_undef, 0
    220     },
    221 };
    222 # endif
     152#if 0
     153        /* HMAC is not supported */
     154        {
     155        CRYPTO_MD5_HMAC, NID_hmacWithMD5, 16}, {
     156        CRYPTO_SHA1_HMAC, NID_hmacWithSHA1, 20}, {
     157        CRYPTO_SHA2_256_HMAC, NID_hmacWithSHA256, 32}, {
     158        CRYPTO_SHA2_384_HMAC, NID_hmacWithSHA384, 48}, {
     159        CRYPTO_SHA2_512_HMAC, NID_hmacWithSHA512, 64},
     160#endif
     161        {
     162        CRYPTO_MD5, NID_md5, 16}, {
     163        CRYPTO_SHA1, NID_sha1, 20}, {
     164        CRYPTO_SHA2_256, NID_sha256, 32}, {
     165        CRYPTO_SHA2_384, NID_sha384, 48}, {
     166        CRYPTO_SHA2_512, NID_sha512, 64}, {
     1670, NID_undef, 0},};
     168#endif
    223169
    224170/*
     
    227173static int open_dev_crypto(void)
    228174{
    229     static int fd = -1;
    230 
    231     if (fd == -1) {
    232         if ((fd = open("/dev/crypto", O_RDWR, 0)) == -1)
    233             return (-1);
    234         /* close on exec */
    235         if (fcntl(fd, F_SETFD, 1) == -1) {
    236             close(fd);
    237             fd = -1;
    238             return (-1);
    239         }
    240     }
    241     return (fd);
     175        static int fd = -1;
     176
     177        if (fd == -1) {
     178                if ((fd = open("/dev/crypto", O_RDWR, 0)) == -1)
     179                        return (-1);
     180                /* close on exec */
     181                if (fcntl(fd, F_SETFD, 1) == -1) {
     182                        close(fd);
     183                        fd = -1;
     184                        return (-1);
     185                }
     186        }
     187        return (fd);
    242188}
    243189
    244190static int get_dev_crypto(void)
    245191{
    246     int fd, retfd;
    247 
    248     if ((fd = open_dev_crypto()) == -1)
    249         return (-1);
    250 # ifndef CRIOGET_NOT_NEEDED
    251     if (ioctl(fd, CRIOGET, &retfd) == -1)
    252         return (-1);
    253 
    254     /* close on exec */
    255     if (fcntl(retfd, F_SETFD, 1) == -1) {
    256         close(retfd);
    257         return (-1);
    258     }
    259 # else
    260     retfd = fd;
    261 # endif
    262     return (retfd);
     192        int fd, retfd;
     193
     194        if ((fd = open_dev_crypto()) == -1)
     195                return (-1);
     196#ifndef CRIOGET_NOT_NEEDED
     197        if (ioctl(fd, CRIOGET, &retfd) == -1)
     198                return (-1);
     199
     200        /* close on exec */
     201        if (fcntl(retfd, F_SETFD, 1) == -1) {
     202                close(retfd);
     203                return (-1);
     204        }
     205#else
     206        retfd = fd;
     207#endif
     208        return (retfd);
    263209}
    264210
    265211static void put_dev_crypto(int fd)
    266212{
    267 # ifndef CRIOGET_NOT_NEEDED
    268     close(fd);
    269 # endif
     213#ifndef CRIOGET_NOT_NEEDED
     214        close(fd);
     215#endif
    270216}
    271217
     
    273219static int get_asym_dev_crypto(void)
    274220{
    275     static int fd = -1;
    276 
    277     if (fd == -1)
    278         fd = get_dev_crypto();
    279     return fd;
     221        static int fd = -1;
     222
     223        if (fd == -1)
     224                fd = get_dev_crypto();
     225        return fd;
    280226}
    281227
     
    288234static int get_cryptodev_ciphers(const int **cnids)
    289235{
    290     static int nids[CRYPTO_ALGORITHM_MAX];
    291     struct session_op sess;
    292     int fd, i, count = 0;
    293 
    294     if ((fd = get_dev_crypto()) < 0) {
    295         *cnids = NULL;
    296         return (0);
    297     }
    298     memset(&sess, 0, sizeof(sess));
    299     sess.key = (caddr_t) "123456789abcdefghijklmno";
    300 
    301     for (i = 0; ciphers[i].id && count < CRYPTO_ALGORITHM_MAX; i++) {
    302         if (ciphers[i].nid == NID_undef)
    303             continue;
    304         sess.cipher = ciphers[i].id;
    305         sess.keylen = ciphers[i].keylen;
    306         sess.mac = 0;
    307         if (ioctl(fd, CIOCGSESSION, &sess) != -1 &&
    308             ioctl(fd, CIOCFSESSION, &sess.ses) != -1)
    309             nids[count++] = ciphers[i].nid;
    310     }
    311     put_dev_crypto(fd);
    312 
    313     if (count > 0)
    314         *cnids = nids;
    315     else
    316         *cnids = NULL;
    317     return (count);
    318 }
    319 
    320 # ifdef USE_CRYPTODEV_DIGESTS
     236        static int nids[CRYPTO_ALGORITHM_MAX];
     237        struct session_op sess;
     238        int fd, i, count = 0;
     239        unsigned char fake_key[CRYPTO_CIPHER_MAX_KEY_LEN];
     240
     241        if ((fd = get_dev_crypto()) < 0) {
     242                *cnids = NULL;
     243                return (0);
     244        }
     245        memset(&sess, 0, sizeof(sess));
     246        sess.key = (void *)fake_key;
     247
     248        for (i = 0; ciphers[i].id && count < CRYPTO_ALGORITHM_MAX; i++) {
     249                if (ciphers[i].nid == NID_undef)
     250                        continue;
     251                sess.cipher = ciphers[i].id;
     252                sess.keylen = ciphers[i].keylen;
     253                sess.mac = 0;
     254                if (ioctl(fd, CIOCGSESSION, &sess) != -1 && ioctl(fd, CIOCFSESSION, &sess.ses) != -1)
     255                        nids[count++] = ciphers[i].nid;
     256        }
     257        put_dev_crypto(fd);
     258
     259        if (count > 0)
     260                *cnids = nids;
     261        else
     262                *cnids = NULL;
     263        return (count);
     264}
     265
     266#ifdef USE_CRYPTODEV_DIGESTS
    321267/*
    322268 * Find out what digests /dev/crypto will let us have a session for.
     
    327273static int get_cryptodev_digests(const int **cnids)
    328274{
    329     static int nids[CRYPTO_ALGORITHM_MAX];
    330     struct session_op sess;
    331     int fd, i, count = 0;
    332 
    333     if ((fd = get_dev_crypto()) < 0) {
    334         *cnids = NULL;
    335         return (0);
    336     }
    337     memset(&sess, 0, sizeof(sess));
    338     sess.mackey = (caddr_t) "123456789abcdefghijklmno";
    339     for (i = 0; digests[i].id && count < CRYPTO_ALGORITHM_MAX; i++) {
    340         if (digests[i].nid == NID_undef)
    341             continue;
    342         sess.mac = digests[i].id;
    343         sess.mackeylen = digests[i].keylen;
    344         sess.cipher = 0;
    345         if (ioctl(fd, CIOCGSESSION, &sess) != -1 &&
    346             ioctl(fd, CIOCFSESSION, &sess.ses) != -1)
    347             nids[count++] = digests[i].nid;
    348     }
    349     put_dev_crypto(fd);
    350 
    351     if (count > 0)
    352         *cnids = nids;
    353     else
    354         *cnids = NULL;
    355     return (count);
    356 }
    357 # endif                         /* 0 */
     275        static int nids[CRYPTO_ALGORITHM_MAX];
     276        unsigned char fake_key[CRYPTO_CIPHER_MAX_KEY_LEN];
     277        struct session_op sess;
     278        int fd, i, count = 0;
     279
     280        if ((fd = get_dev_crypto()) < 0) {
     281                *cnids = NULL;
     282                return (0);
     283        }
     284        memset(&sess, 0, sizeof(sess));
     285        sess.mackey = fake_key;
     286        for (i = 0; digests[i].id && count < CRYPTO_ALGORITHM_MAX; i++) {
     287                if (digests[i].nid == NID_undef)
     288                        continue;
     289                sess.mac = digests[i].id;
     290                sess.mackeylen = 8;
     291                sess.cipher = 0;
     292                if (ioctl(fd, CIOCGSESSION, &sess) != -1 && ioctl(fd, CIOCFSESSION, &sess.ses) != -1)
     293                        nids[count++] = digests[i].nid;
     294        }
     295        put_dev_crypto(fd);
     296
     297        if (count > 0)
     298                *cnids = nids;
     299        else
     300                *cnids = NULL;
     301        return (count);
     302}
     303#endif                          /* 0 */
    358304
    359305/*
     
    380326static int cryptodev_usable_ciphers(const int **nids)
    381327{
    382     return (get_cryptodev_ciphers(nids));
     328        return (get_cryptodev_ciphers(nids));
    383329}
    384330
    385331static int cryptodev_usable_digests(const int **nids)
    386332{
    387 # ifdef USE_CRYPTODEV_DIGESTS
    388     return (get_cryptodev_digests(nids));
    389 # else
    390     /*
    391      * XXXX just disable all digests for now, because it sucks.
    392      * we need a better way to decide this - i.e. I may not
    393      * want digests on slow cards like hifn on fast machines,
    394      * but might want them on slow or loaded machines, etc.
    395      * will also want them when using crypto cards that don't
    396      * suck moose gonads - would be nice to be able to decide something
    397      * as reasonable default without having hackery that's card dependent.
    398      * of course, the default should probably be just do everything,
    399      * with perhaps a sysctl to turn algoritms off (or have them off
    400      * by default) on cards that generally suck like the hifn.
    401      */
    402     *nids = NULL;
    403     return (0);
    404 # endif
    405 }
    406 
    407 static int
    408 cryptodev_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
    409                  const unsigned char *in, size_t inl)
    410 {
    411     struct crypt_op cryp;
    412     struct dev_crypto_state *state = ctx->cipher_data;
    413     struct session_op *sess = &state->d_sess;
    414     const void *iiv;
    415     unsigned char save_iv[EVP_MAX_IV_LENGTH];
    416 
    417     if (state->d_fd < 0)
    418         return (0);
    419     if (!inl)
    420         return (1);
    421     if ((inl % ctx->cipher->block_size) != 0)
    422         return (0);
    423 
    424     memset(&cryp, 0, sizeof(cryp));
    425 
    426     cryp.ses = sess->ses;
    427     cryp.flags = 0;
    428     cryp.len = inl;
    429     cryp.src = (caddr_t) in;
    430     cryp.dst = (caddr_t) out;
    431     cryp.mac = 0;
    432 
    433     cryp.op = ctx->encrypt ? COP_ENCRYPT : COP_DECRYPT;
    434 
    435     if (ctx->cipher->iv_len) {
    436         cryp.iv = (caddr_t) ctx->iv;
    437         if (!ctx->encrypt) {
    438             iiv = in + inl - ctx->cipher->iv_len;
    439             memcpy(save_iv, iiv, ctx->cipher->iv_len);
    440         }
    441     } else
    442         cryp.iv = NULL;
    443 
    444     if (ioctl(state->d_fd, CIOCCRYPT, &cryp) == -1) {
    445         /*
    446          * XXX need better errror handling this can fail for a number of
    447          * different reasons.
    448          */
    449         return (0);
    450     }
    451 
    452     if (ctx->cipher->iv_len) {
    453         if (ctx->encrypt)
    454             iiv = out + inl - ctx->cipher->iv_len;
    455         else
    456             iiv = save_iv;
    457         memcpy(ctx->iv, iiv, ctx->cipher->iv_len);
    458     }
    459     return (1);
    460 }
    461 
    462 static int
    463 cryptodev_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
    464                    const unsigned char *iv, int enc)
    465 {
    466     struct dev_crypto_state *state = ctx->cipher_data;
    467     struct session_op *sess = &state->d_sess;
    468     int cipher = -1, i;
    469 
    470     for (i = 0; ciphers[i].id; i++)
    471         if (ctx->cipher->nid == ciphers[i].nid &&
    472             ctx->cipher->iv_len <= ciphers[i].ivmax &&
    473             ctx->key_len == ciphers[i].keylen) {
    474             cipher = ciphers[i].id;
    475             break;
    476         }
    477 
    478     if (!ciphers[i].id) {
    479         state->d_fd = -1;
    480         return (0);
    481     }
    482 
    483     memset(sess, 0, sizeof(struct session_op));
    484 
    485     if ((state->d_fd = get_dev_crypto()) < 0)
    486         return (0);
    487 
    488     sess->key = (caddr_t) key;
    489     sess->keylen = ctx->key_len;
    490     sess->cipher = cipher;
    491 
    492     if (ioctl(state->d_fd, CIOCGSESSION, sess) == -1) {
    493         put_dev_crypto(state->d_fd);
    494         state->d_fd = -1;
    495         return (0);
    496     }
    497     return (1);
     333#ifdef USE_CRYPTODEV_DIGESTS
     334        return (get_cryptodev_digests(nids));
     335#else
     336        /*
     337         * XXXX just disable all digests for now, because it sucks.
     338         * we need a better way to decide this - i.e. I may not
     339         * want digests on slow cards like hifn on fast machines,
     340         * but might want them on slow or loaded machines, etc.
     341         * will also want them when using crypto cards that don't
     342         * suck moose gonads - would be nice to be able to decide something
     343         * as reasonable default without having hackery that's card dependent.
     344         * of course, the default should probably be just do everything,
     345         * with perhaps a sysctl to turn algoritms off (or have them off
     346         * by default) on cards that generally suck like the hifn.
     347         */
     348        *nids = NULL;
     349        return (0);
     350#endif
     351}
     352
     353static int cryptodev_cipher(EVP_CIPHER_CTX * ctx, unsigned char *out, const unsigned char *in, size_t inl)
     354{
     355        struct crypt_op cryp;
     356        struct dev_crypto_state *state = ctx->cipher_data;
     357        struct session_op *sess = &state->d_sess;
     358        const void *iiv;
     359        unsigned char save_iv[EVP_MAX_IV_LENGTH];
     360
     361        if (state->d_fd < 0)
     362                return (0);
     363        if (!inl)
     364                return (1);
     365        if ((inl % ctx->cipher->block_size) != 0)
     366                return (0);
     367
     368        memset(&cryp, 0, sizeof(cryp));
     369
     370        cryp.ses = sess->ses;
     371        cryp.flags = 0;
     372        cryp.len = inl;
     373        cryp.src = (void *)in;
     374        cryp.dst = (void *)out;
     375        cryp.mac = 0;
     376
     377        cryp.op = ctx->encrypt ? COP_ENCRYPT : COP_DECRYPT;
     378
     379        if (ctx->cipher->iv_len) {
     380                cryp.iv = (void *)ctx->iv;
     381                if (!ctx->encrypt) {
     382                        iiv = in + inl - ctx->cipher->iv_len;
     383                        memcpy(save_iv, iiv, ctx->cipher->iv_len);
     384                }
     385        } else
     386                cryp.iv = NULL;
     387
     388        if (ioctl(state->d_fd, CIOCCRYPT, &cryp) == -1) {
     389                /*
     390                 * XXX need better errror handling this can fail for a number of
     391                 * different reasons.
     392                 */
     393                return (0);
     394        }
     395
     396        if (ctx->cipher->iv_len) {
     397                if (ctx->encrypt)
     398                        iiv = out + inl - ctx->cipher->iv_len;
     399                else
     400                        iiv = save_iv;
     401                memcpy(ctx->iv, iiv, ctx->cipher->iv_len);
     402        }
     403        return (1);
     404}
     405
     406static int cryptodev_init_key(EVP_CIPHER_CTX * ctx, const unsigned char *key, const unsigned char *iv, int enc)
     407{
     408        struct dev_crypto_state *state = ctx->cipher_data;
     409        struct session_op *sess = &state->d_sess;
     410        int cipher = -1, i;
     411
     412        for (i = 0; ciphers[i].id; i++)
     413                if (ctx->cipher->nid == ciphers[i].nid && ctx->cipher->iv_len <= ciphers[i].ivmax && ctx->key_len == ciphers[i].keylen) {
     414                        cipher = ciphers[i].id;
     415                        break;
     416                }
     417
     418        if (!ciphers[i].id) {
     419                state->d_fd = -1;
     420                return (0);
     421        }
     422
     423        memset(sess, 0, sizeof(struct session_op));
     424
     425        if ((state->d_fd = get_dev_crypto()) < 0)
     426                return (0);
     427
     428        sess->key = (void *)key;
     429        sess->keylen = ctx->key_len;
     430        sess->cipher = cipher;
     431
     432        if (ioctl(state->d_fd, CIOCGSESSION, sess) == -1) {
     433                put_dev_crypto(state->d_fd);
     434                state->d_fd = -1;
     435                return (0);
     436        }
     437        return (1);
    498438}
    499439
     
    502442 * session, and close the session.
    503443 */
    504 static int cryptodev_cleanup(EVP_CIPHER_CTX *ctx)
    505 {
    506     int ret = 0;
    507     struct dev_crypto_state *state = ctx->cipher_data;
    508     struct session_op *sess = &state->d_sess;
    509 
    510     if (state->d_fd < 0)
    511         return (0);
    512 
    513     /*
    514     * XXX if this ioctl fails, someting's wrong. the invoker may have called
    515     * us with a bogus ctx, or we could have a device that for whatever
    516     * reason just doesn't want to play ball - it's not clear what's right
    517     * here - should this be an error? should it just increase a counter,
    518     * hmm. For right now, we return 0 - I don't believe that to be "right".
    519     * we could call the gorpy openssl lib error handlers that print messages
    520     * to users of the library. hmm..
    521     */
    522 
    523     if (ioctl(state->d_fd, CIOCFSESSION, &sess->ses) == -1) {
    524         ret = 0;
    525     } else {
    526         ret = 1;
    527     }
    528     put_dev_crypto(state->d_fd);
    529     state->d_fd = -1;
    530 
    531     return (ret);
     444static int cryptodev_cleanup(EVP_CIPHER_CTX * ctx)
     445{
     446        int ret = 0;
     447        struct dev_crypto_state *state = ctx->cipher_data;
     448        struct session_op *sess = &state->d_sess;
     449
     450        if (state->d_fd < 0)
     451                return (0);
     452
     453        /*
     454        * XXX if this ioctl fails, someting's wrong. the invoker may have called
     455        * us with a bogus ctx, or we could have a device that for whatever
     456        * reason just doesn't want to play ball - it's not clear what's right
     457        * here - should this be an error? should it just increase a counter,
     458        * hmm. For right now, we return 0 - I don't believe that to be "right".
     459        * we could call the gorpy openssl lib error handlers that print messages
     460        * to users of the library. hmm..
     461        */
     462
     463        if (ioctl(state->d_fd, CIOCFSESSION, &sess->ses) == -1) {
     464                ret = 0;
     465        } else {
     466                ret = 1;
     467        }
     468        put_dev_crypto(state->d_fd);
     469        state->d_fd = -1;
     470
     471        return (ret);
    532472}
    533473
     
    537477 */
    538478
     479static int cryptodev_cipher_ctrl(EVP_CIPHER_CTX * ctx, int type, int p1, void *p2)
     480{
     481        struct dev_crypto_state *state = ctx->cipher_data;
     482        struct session_op *sess = &state->d_sess;
     483
     484        if (type == EVP_CTRL_COPY) {
     485                EVP_CIPHER_CTX *out = p2;
     486                return cryptodev_init_key(out, sess->key, ctx->iv, 0);
     487        }
     488
     489        return 0;
     490}
     491
    539492/* RC4 */
    540493const EVP_CIPHER cryptodev_rc4 = {
    541     NID_rc4,
    542     1, 16, 0,
    543     EVP_CIPH_VARIABLE_LENGTH,
    544     cryptodev_init_key,
    545     cryptodev_cipher,
    546     cryptodev_cleanup,
    547     sizeof(struct dev_crypto_state),
    548     NULL,
    549     NULL,
    550     NULL
     494        NID_rc4,
     495        1, 16, 0,
     496        EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CUSTOM_COPY,
     497        cryptodev_init_key,
     498        cryptodev_cipher,
     499        cryptodev_cleanup,
     500        sizeof(struct dev_crypto_state),
     501        NULL,
     502        NULL,
     503        cryptodev_cipher_ctrl
    551504};
    552505
    553506/* DES CBC EVP */
    554507const EVP_CIPHER cryptodev_des_cbc = {
    555     NID_des_cbc,
    556     8, 8, 8,
    557     EVP_CIPH_CBC_MODE,
    558     cryptodev_init_key,
    559     cryptodev_cipher,
    560     cryptodev_cleanup,
    561     sizeof(struct dev_crypto_state),
    562     EVP_CIPHER_set_asn1_iv,
    563     EVP_CIPHER_get_asn1_iv,
    564     NULL
    565 };
    566 
    567 /* 3DES CBC EVP */
    568 const EVP_CIPHER cryptodev_3des_cbc = {
    569     NID_des_ede3_cbc,
    570     8, 24, 8,
    571     EVP_CIPH_CBC_MODE,
    572     cryptodev_init_key,
    573     cryptodev_cipher,
    574     cryptodev_cleanup,
    575     sizeof(struct dev_crypto_state),
    576     EVP_CIPHER_set_asn1_iv,
    577     EVP_CIPHER_get_asn1_iv,
    578     NULL
    579 };
    580 
    581 const EVP_CIPHER cryptodev_bf_cbc = {
    582     NID_bf_cbc,
    583     8, 16, 8,
    584     EVP_CIPH_CBC_MODE,
    585     cryptodev_init_key,
    586     cryptodev_cipher,
    587     cryptodev_cleanup,
    588     sizeof(struct dev_crypto_state),
    589     EVP_CIPHER_set_asn1_iv,
    590     EVP_CIPHER_get_asn1_iv,
    591     NULL
    592 };
    593 
    594 const EVP_CIPHER cryptodev_cast_cbc = {
    595     NID_cast5_cbc,
    596     8, 16, 8,
    597     EVP_CIPH_CBC_MODE,
    598     cryptodev_init_key,
    599     cryptodev_cipher,
    600     cryptodev_cleanup,
    601     sizeof(struct dev_crypto_state),
    602     EVP_CIPHER_set_asn1_iv,
    603     EVP_CIPHER_get_asn1_iv,
    604     NULL
    605 };
    606 
    607 const EVP_CIPHER cryptodev_aes_cbc = {
    608     NID_aes_128_cbc,
    609     16, 16, 16,
    610     EVP_CIPH_CBC_MODE,
    611     cryptodev_init_key,
    612     cryptodev_cipher,
    613     cryptodev_cleanup,
    614     sizeof(struct dev_crypto_state),
    615     EVP_CIPHER_set_asn1_iv,
    616     EVP_CIPHER_get_asn1_iv,
    617     NULL
    618 };
    619 
    620 const EVP_CIPHER cryptodev_aes_192_cbc = {
    621     NID_aes_192_cbc,
    622     16, 24, 16,
    623     EVP_CIPH_CBC_MODE,
    624     cryptodev_init_key,
    625     cryptodev_cipher,
    626     cryptodev_cleanup,
    627     sizeof(struct dev_crypto_state),
    628     EVP_CIPHER_set_asn1_iv,
    629     EVP_CIPHER_get_asn1_iv,
    630     NULL
    631 };
    632 
    633 const EVP_CIPHER cryptodev_aes_256_cbc = {
    634     NID_aes_256_cbc,
    635     16, 32, 16,
    636     EVP_CIPH_CBC_MODE,
    637     cryptodev_init_key,
    638     cryptodev_cipher,
    639     cryptodev_cleanup,
    640     sizeof(struct dev_crypto_state),
    641     EVP_CIPHER_set_asn1_iv,
    642     EVP_CIPHER_get_asn1_iv,
    643     NULL
    644 };
    645 
    646 const EVP_CIPHER cryptodev_aes_512_cbc = {
    647         NID_aes_512_cbc,
    648         16, 64, 16,
    649         EVP_CIPH_CBC_MODE,
     508        NID_des_cbc,
     509        8, 8, 8,
     510        EVP_CIPH_CBC_MODE | EVP_CIPH_CUSTOM_COPY,
    650511        cryptodev_init_key,
    651512        cryptodev_cipher,
     
    654515        EVP_CIPHER_set_asn1_iv,
    655516        EVP_CIPHER_get_asn1_iv,
    656         NULL
    657 };
    658 
    659 
    660 # ifdef CRYPTO_AES_CTR
     517        cryptodev_cipher_ctrl
     518};
     519
     520/* 3DES CBC EVP */
     521const EVP_CIPHER cryptodev_3des_cbc = {
     522        NID_des_ede3_cbc,
     523        8, 24, 8,
     524        EVP_CIPH_CBC_MODE | EVP_CIPH_CUSTOM_COPY,
     525        cryptodev_init_key,
     526        cryptodev_cipher,
     527        cryptodev_cleanup,
     528        sizeof(struct dev_crypto_state),
     529        EVP_CIPHER_set_asn1_iv,
     530        EVP_CIPHER_get_asn1_iv,
     531        cryptodev_cipher_ctrl
     532};
     533
     534const EVP_CIPHER cryptodev_bf_cbc = {
     535        NID_bf_cbc,
     536        8, 16, 8,
     537        EVP_CIPH_CBC_MODE | EVP_CIPH_CUSTOM_COPY,
     538        cryptodev_init_key,
     539        cryptodev_cipher,
     540        cryptodev_cleanup,
     541        sizeof(struct dev_crypto_state),
     542        EVP_CIPHER_set_asn1_iv,
     543        EVP_CIPHER_get_asn1_iv,
     544        cryptodev_cipher_ctrl
     545};
     546
     547const EVP_CIPHER cryptodev_cast_cbc = {
     548        NID_cast5_cbc,
     549        8, 16, 8,
     550        EVP_CIPH_CBC_MODE | EVP_CIPH_CUSTOM_COPY,
     551        cryptodev_init_key,
     552        cryptodev_cipher,
     553        cryptodev_cleanup,
     554        sizeof(struct dev_crypto_state),
     555        EVP_CIPHER_set_asn1_iv,
     556        EVP_CIPHER_get_asn1_iv,
     557        cryptodev_cipher_ctrl
     558};
     559
     560const EVP_CIPHER cryptodev_aes_cbc = {
     561        NID_aes_128_cbc,
     562        16, 16, 16,
     563        EVP_CIPH_CBC_MODE | EVP_CIPH_CUSTOM_COPY,
     564        cryptodev_init_key,
     565        cryptodev_cipher,
     566        cryptodev_cleanup,
     567        sizeof(struct dev_crypto_state),
     568        EVP_CIPHER_set_asn1_iv,
     569        EVP_CIPHER_get_asn1_iv,
     570        cryptodev_cipher_ctrl
     571};
     572
     573const EVP_CIPHER cryptodev_aes_192_cbc = {
     574        NID_aes_192_cbc,
     575        16, 24, 16,
     576        EVP_CIPH_CBC_MODE | EVP_CIPH_CUSTOM_COPY,
     577        cryptodev_init_key,
     578        cryptodev_cipher,
     579        cryptodev_cleanup,
     580        sizeof(struct dev_crypto_state),
     581        EVP_CIPHER_set_asn1_iv,
     582        EVP_CIPHER_get_asn1_iv,
     583        cryptodev_cipher_ctrl
     584};
     585
     586const EVP_CIPHER cryptodev_aes_256_cbc = {
     587        NID_aes_256_cbc,
     588        16, 32, 16,
     589        EVP_CIPH_CBC_MODE | EVP_CIPH_CUSTOM_COPY,
     590        cryptodev_init_key,
     591        cryptodev_cipher,
     592        cryptodev_cleanup,
     593        sizeof(struct dev_crypto_state),
     594        EVP_CIPHER_set_asn1_iv,
     595        EVP_CIPHER_get_asn1_iv,
     596        cryptodev_cipher_ctrl
     597};
     598
     599#ifdef CRYPTO_AES_CTR
    661600const EVP_CIPHER cryptodev_aes_ctr = {
    662     NID_aes_128_ctr,
    663     16, 16, 14,
    664     EVP_CIPH_CTR_MODE,
    665     cryptodev_init_key,
    666     cryptodev_cipher,
    667     cryptodev_cleanup,
    668     sizeof(struct dev_crypto_state),
    669     EVP_CIPHER_set_asn1_iv,
    670     EVP_CIPHER_get_asn1_iv,
    671     NULL
     601        NID_aes_128_ctr,
     602        16, 16, 14,
     603        EVP_CIPH_CTR_MODE| EVP_CIPH_CUSTOM_COPY,
     604        cryptodev_init_key,
     605        cryptodev_cipher,
     606        cryptodev_cleanup,
     607        sizeof(struct dev_crypto_state),
     608        EVP_CIPHER_set_asn1_iv,
     609        EVP_CIPHER_get_asn1_iv,
     610        cryptodev_cipher_ctrl
     611
    672612};
    673613
    674614const EVP_CIPHER cryptodev_aes_ctr_192 = {
    675     NID_aes_192_ctr,
    676     16, 24, 14,
    677     EVP_CIPH_CTR_MODE,
    678     cryptodev_init_key,
    679     cryptodev_cipher,
    680     cryptodev_cleanup,
    681     sizeof(struct dev_crypto_state),
    682     EVP_CIPHER_set_asn1_iv,
    683     EVP_CIPHER_get_asn1_iv,
    684     NULL
     615        NID_aes_192_ctr,
     616        16, 24, 14,
     617        EVP_CIPH_CTR_MODE| EVP_CIPH_CUSTOM_COPY,
     618        cryptodev_init_key,
     619        cryptodev_cipher,
     620        cryptodev_cleanup,
     621        sizeof(struct dev_crypto_state),
     622        EVP_CIPHER_set_asn1_iv,
     623        EVP_CIPHER_get_asn1_iv,
     624        cryptodev_cipher_ctrl
     625
    685626};
    686627
    687628const EVP_CIPHER cryptodev_aes_ctr_256 = {
    688     NID_aes_256_ctr,
    689     16, 32, 14,
    690     EVP_CIPH_CTR_MODE,
    691     cryptodev_init_key,
    692     cryptodev_cipher,
    693     cryptodev_cleanup,
    694     sizeof(struct dev_crypto_state),
    695     EVP_CIPHER_set_asn1_iv,
    696     EVP_CIPHER_get_asn1_iv,
    697     NULL
    698 };
    699 # endif
     629        NID_aes_256_ctr,
     630        16, 32, 14,
     631        EVP_CIPH_CTR_MODE| EVP_CIPH_CUSTOM_COPY,
     632        cryptodev_init_key,
     633        cryptodev_cipher,
     634        cryptodev_cleanup,
     635        sizeof(struct dev_crypto_state),
     636        EVP_CIPHER_set_asn1_iv,
     637        EVP_CIPHER_get_asn1_iv,
     638        cryptodev_cipher_ctrl
     639
     640};
     641#endif
    700642/*
    701643 * Registered by the ENGINE when used to find out how to deal with
     
    703645 * top level - note, that list is restricted by what we answer with
    704646 */
    705 static int
    706 cryptodev_engine_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
    707                          const int **nids, int nid)
    708 {
    709     if (!cipher)
    710         return (cryptodev_usable_ciphers(nids));
    711 
    712     switch (nid) {
    713     case NID_rc4:
    714         *cipher = &cryptodev_rc4;
    715         break;
    716     case NID_des_ede3_cbc:
    717         *cipher = &cryptodev_3des_cbc;
    718         break;
    719     case NID_des_cbc:
    720         *cipher = &cryptodev_des_cbc;
    721         break;
    722     case NID_bf_cbc:
    723         *cipher = &cryptodev_bf_cbc;
    724         break;
    725     case NID_cast5_cbc:
    726         *cipher = &cryptodev_cast_cbc;
    727         break;
    728     case NID_aes_128_cbc:
    729         *cipher = &cryptodev_aes_cbc;
    730         break;
    731     case NID_aes_192_cbc:
    732         *cipher = &cryptodev_aes_192_cbc;
    733         break;
    734     case NID_aes_256_cbc:
    735         *cipher = &cryptodev_aes_256_cbc;
    736         break;
    737         case NID_aes_512_cbc:
    738                 *cipher = &cryptodev_aes_512_cbc;
    739                 break;
    740 # ifdef CRYPTO_AES_CTR
    741     case NID_aes_128_ctr:
    742         *cipher = &cryptodev_aes_ctr;
    743         break;
    744     case NID_aes_192_ctr:
    745         *cipher = &cryptodev_aes_ctr_192;
    746         break;
    747     case NID_aes_256_ctr:
    748         *cipher = &cryptodev_aes_ctr_256;
    749         break;
    750 # endif
    751     default:
    752         *cipher = NULL;
    753         break;
    754     }
    755     return (*cipher != NULL);
    756 }
    757 
    758 # ifdef USE_CRYPTODEV_DIGESTS
     647static int cryptodev_engine_ciphers(ENGINE * e, const EVP_CIPHER ** cipher, const int **nids, int nid)
     648{
     649        if (!cipher)
     650                return (cryptodev_usable_ciphers(nids));
     651
     652        switch (nid) {
     653        case NID_rc4:
     654                *cipher = &cryptodev_rc4;
     655                break;
     656        case NID_des_ede3_cbc:
     657                *cipher = &cryptodev_3des_cbc;
     658                break;
     659        case NID_des_cbc:
     660                *cipher = &cryptodev_des_cbc;
     661                break;
     662        case NID_bf_cbc:
     663                *cipher = &cryptodev_bf_cbc;
     664                break;
     665        case NID_cast5_cbc:
     666                *cipher = &cryptodev_cast_cbc;
     667                break;
     668        case NID_aes_128_cbc:
     669                *cipher = &cryptodev_aes_cbc;
     670                break;
     671        case NID_aes_192_cbc:
     672                *cipher = &cryptodev_aes_192_cbc;
     673                break;
     674        case NID_aes_256_cbc:
     675                *cipher = &cryptodev_aes_256_cbc;
     676                break;
     677#ifdef CRYPTO_AES_CTR
     678        case NID_aes_128_ctr:
     679                *cipher = &cryptodev_aes_ctr;
     680                break;
     681        case NID_aes_192_ctr:
     682                *cipher = &cryptodev_aes_ctr_192;
     683                break;
     684        case NID_aes_256_ctr:
     685                *cipher = &cryptodev_aes_ctr_256;
     686                break;
     687#endif
     688        default:
     689                *cipher = NULL;
     690                break;
     691        }
     692        return (*cipher != NULL);
     693}
     694
     695#ifdef USE_CRYPTODEV_DIGESTS
    759696
    760697/* convert digest type to cryptodev */
    761698static int digest_nid_to_cryptodev(int nid)
    762699{
    763     int i;
    764 
    765     for (i = 0; digests[i].id; i++)
    766         if (digests[i].nid == nid)
    767             return (digests[i].id);
    768     return (0);
    769 }
    770 
    771 static int digest_key_length(int nid)
    772 {
    773     int i;
    774 
    775     for (i = 0; digests[i].id; i++)
    776         if (digests[i].nid == nid)
    777             return digests[i].keylen;
    778     return (0);
    779 }
    780 
    781 static int cryptodev_digest_init(EVP_MD_CTX *ctx)
    782 {
    783     struct dev_crypto_state *state = ctx->md_data;
    784     struct session_op *sess = &state->d_sess;
    785     int digest;
    786 
    787     if ((digest = digest_nid_to_cryptodev(ctx->digest->type)) == NID_undef) {
    788         printf("cryptodev_digest_init: Can't get digest \n");
    789         return (0);
    790     }
    791 
    792     memset(state, 0, sizeof(struct dev_crypto_state));
    793 
    794     if ((state->d_fd = get_dev_crypto()) < 0) {
    795         printf("cryptodev_digest_init: Can't get Dev \n");
    796         return (0);
    797     }
    798 
    799     sess->mackey = state->dummy_mac_key;
    800     sess->mackeylen = digest_key_length(ctx->digest->type);
    801     sess->mac = digest;
    802 
    803     if (ioctl(state->d_fd, CIOCGSESSION, sess) < 0) {
    804         put_dev_crypto(state->d_fd);
    805         state->d_fd = -1;
    806         printf("cryptodev_digest_init: Open session failed\n");
    807         return (0);
    808     }
    809 
    810     return (1);
    811 }
    812 
    813 static int cryptodev_digest_update(EVP_MD_CTX *ctx, const void *data,
    814                                    size_t count)
    815 {
    816     struct crypt_op cryp;
    817     struct dev_crypto_state *state = ctx->md_data;
    818     struct session_op *sess = &state->d_sess;
    819 
    820     if (!data || state->d_fd < 0) {
    821         printf("cryptodev_digest_update: illegal inputs \n");
    822         return (0);
    823     }
    824 
    825     if (!count) {
    826         return (0);
    827     }
    828 
    829     if (!(ctx->flags & EVP_MD_CTX_FLAG_ONESHOT)) {
    830         /* if application doesn't support one buffer */
    831         state->mac_data =
    832             OPENSSL_realloc(state->mac_data, state->mac_len + count);
    833 
    834         if (!state->mac_data) {
    835             printf("cryptodev_digest_update: realloc failed\n");
    836             return (0);
    837         }
    838 
    839         memcpy(state->mac_data + state->mac_len, data, count);
    840         state->mac_len += count;
    841 
    842         return (1);
    843     }
    844 
    845     memset(&cryp, 0, sizeof(cryp));
    846 
    847     cryp.ses = sess->ses;
    848     cryp.flags = 0;
    849     cryp.len = count;
    850     cryp.src = (caddr_t) data;
    851     cryp.dst = NULL;
    852     cryp.mac = (caddr_t) state->digest_res;
    853     if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) {
    854         printf("cryptodev_digest_update: digest failed\n");
    855         return (0);
    856     }
    857     return (1);
    858 }
    859 
    860 static int cryptodev_digest_final(EVP_MD_CTX *ctx, unsigned char *md)
    861 {
    862     struct crypt_op cryp;
    863     struct dev_crypto_state *state = ctx->md_data;
    864     struct session_op *sess = &state->d_sess;
    865 
    866     int ret = 1;
    867 
    868     if (!md || state->d_fd < 0) {
    869         printf("cryptodev_digest_final: illegal input\n");
    870         return (0);
    871     }
    872 
    873     if (!(ctx->flags & EVP_MD_CTX_FLAG_ONESHOT)) {
    874         /* if application doesn't support one buffer */
    875         memset(&cryp, 0, sizeof(cryp));
    876         cryp.ses = sess->ses;
    877         cryp.flags = 0;
    878         cryp.len = state->mac_len;
    879         cryp.src = state->mac_data;
    880         cryp.dst = NULL;
    881         cryp.mac = (caddr_t) md;
    882         if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) {
    883             printf("cryptodev_digest_final: digest failed\n");
    884             return (0);
    885         }
    886 
    887         return 1;
    888     }
    889 
    890     memcpy(md, state->digest_res, ctx->digest->md_size);
    891 
    892     return (ret);
    893 }
    894 
    895 static int cryptodev_digest_cleanup(EVP_MD_CTX *ctx)
    896 {
    897     int ret = 1;
    898     struct dev_crypto_state *state = ctx->md_data;
    899     struct session_op *sess = &state->d_sess;
    900 
    901     if (state == NULL)
    902         return 0;
    903 
    904     if (state->d_fd < 0) {
    905         printf("cryptodev_digest_cleanup: illegal input\n");
    906         return (0);
    907     }
    908 
    909     if (state->mac_data) {
    910         OPENSSL_free(state->mac_data);
    911         state->mac_data = NULL;
    912         state->mac_len = 0;
    913     }
    914 
    915     if (ioctl(state->d_fd, CIOCFSESSION, &sess->ses) < 0) {
    916         printf("cryptodev_digest_cleanup: failed to close session\n");
    917         ret = 0;
    918     } else {
    919         ret = 1;
    920     }
    921     put_dev_crypto(state->d_fd);
    922     state->d_fd = -1;
    923 
    924     return (ret);
    925 }
    926 
    927 static int cryptodev_digest_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from)
    928 {
    929     struct dev_crypto_state *fstate = from->md_data;
    930     struct dev_crypto_state *dstate = to->md_data;
    931     struct session_op *sess;
    932     int digest;
    933 
    934     if (dstate == NULL || fstate == NULL)
    935         return 1;
    936 
    937     memcpy(dstate, fstate, sizeof(struct dev_crypto_state));
    938 
    939     sess = &dstate->d_sess;
    940 
    941     digest = digest_nid_to_cryptodev(to->digest->type);
    942 
    943     sess->mackey = dstate->dummy_mac_key;
    944     sess->mackeylen = digest_key_length(to->digest->type);
    945     sess->mac = digest;
    946 
    947     dstate->d_fd = get_dev_crypto();
    948 
    949     if (ioctl(dstate->d_fd, CIOCGSESSION, sess) < 0) {
    950         put_dev_crypto(dstate->d_fd);
    951         dstate->d_fd = -1;
    952         printf("cryptodev_digest_init: Open session failed\n");
    953         return (0);
    954     }
    955 
    956     dstate->mac_len = fstate->mac_len;
    957     if (fstate->mac_len != 0) {
    958         if (fstate->mac_data != NULL) {
    959             dstate->mac_data = OPENSSL_malloc(fstate->mac_len);
    960             if (dstate->mac_data == NULL) {
    961                 printf("cryptodev_digest_init: malloc failed\n");
    962                 return 0;
    963             }
    964             memcpy(dstate->mac_data, fstate->mac_data, fstate->mac_len);
    965         }
    966     }
    967 
    968     return 1;
    969 }
    970 
    971 const EVP_MD cryptodev_sha1 = {
    972     NID_sha1,
    973     NID_undef,
    974     SHA_DIGEST_LENGTH,
    975     EVP_MD_FLAG_ONESHOT,
    976     cryptodev_digest_init,
    977     cryptodev_digest_update,
    978     cryptodev_digest_final,
    979     cryptodev_digest_copy,
    980     cryptodev_digest_cleanup,
    981     EVP_PKEY_NULL_method,
    982     SHA_CBLOCK,
    983     sizeof(struct dev_crypto_state),
    984 };
    985 
    986 const EVP_MD cryptodev_md5 = {
    987     NID_md5,
    988     NID_undef,
    989     16 /* MD5_DIGEST_LENGTH */ ,
    990     EVP_MD_FLAG_ONESHOT,
    991     cryptodev_digest_init,
    992     cryptodev_digest_update,
    993     cryptodev_digest_final,
    994     cryptodev_digest_copy,
    995     cryptodev_digest_cleanup,
    996     EVP_PKEY_NULL_method,
    997     64 /* MD5_CBLOCK */ ,
    998     sizeof(struct dev_crypto_state),
    999 };
    1000 
    1001 # endif                         /* USE_CRYPTODEV_DIGESTS */
    1002 
    1003 static int
    1004 cryptodev_engine_digests(ENGINE *e, const EVP_MD **digest,
    1005                          const int **nids, int nid)
    1006 {
    1007     if (!digest)
    1008         return (cryptodev_usable_digests(nids));
    1009 
    1010     switch (nid) {
    1011 # ifdef USE_CRYPTODEV_DIGESTS
    1012     case NID_md5:
    1013         *digest = &cryptodev_md5;
    1014         break;
    1015     case NID_sha1:
    1016         *digest = &cryptodev_sha1;
    1017         break;
    1018     default:
    1019 # endif                         /* USE_CRYPTODEV_DIGESTS */
    1020         *digest = NULL;
    1021         break;
    1022     }
    1023     return (*digest != NULL);
     700        int i;
     701
     702        for (i = 0; digests[i].id; i++)
     703                if (digests[i].nid == nid)
     704                        return (digests[i].id);
     705        return (0);
     706}
     707
     708static int cryptodev_digest_init(EVP_MD_CTX * ctx)
     709{
     710        struct dev_crypto_state *state = ctx->md_data;
     711        struct session_op *sess = &state->d_sess;
     712        int digest;
     713
     714        if ((digest = digest_nid_to_cryptodev(ctx->digest->type)) == NID_undef) {
     715                printf("cryptodev_digest_init: Can't get digest \n");
     716                return (0);
     717        }
     718        memset(state, 0, sizeof(struct dev_crypto_state));
     719
     720        if ((state->d_fd = get_dev_crypto()) < 0) {
     721                printf("cryptodev_digest_init: Can't get Dev \n");
     722                return (0);
     723        }
     724
     725        sess->mackey = NULL;
     726        sess->mackeylen = 0;
     727        sess->mac = digest;
     728
     729        if (ioctl(state->d_fd, CIOCGSESSION, sess) < 0) {
     730                put_dev_crypto(state->d_fd);
     731                state->d_fd = -1;
     732                printf("cryptodev_digest_init: Open session failed\n");
     733                return (0);
     734        }
     735
     736        return (1);
     737}
     738
     739static int cryptodev_digest_update(EVP_MD_CTX * ctx, const void *data, size_t count)
     740{
     741        struct dev_crypto_state *state = ctx->md_data;
     742        struct crypt_op cryp;
     743        struct session_op *sess = &state->d_sess;
     744
     745        if (!data || state->d_fd < 0) {
     746                printf("cryptodev_digest_update: illegal inputs \n");
     747                return (0);
     748        }
     749
     750        if (!count) {
     751                return (1);
     752        }
     753
     754        if (!(ctx->flags & EVP_MD_CTX_FLAG_ONESHOT)) {
     755                /* if application doesn't support one buffer */
     756                state->mac_data = OPENSSL_realloc(state->mac_data, state->mac_len + count);
     757
     758                if (!state->mac_data) {
     759                        printf("cryptodev_digest_update: realloc failed\n");
     760                        return (0);
     761                }
     762
     763                memcpy(state->mac_data + state->mac_len, data, count);
     764                state->mac_len += count;
     765
     766                return (1);
     767        }
     768
     769        memset(&cryp, 0, sizeof(cryp));
     770
     771        cryp.ses = sess->ses;
     772        cryp.flags = 0;
     773        cryp.len = count;
     774        cryp.src = (void *)data;
     775        cryp.dst = NULL;
     776        cryp.mac = (void *)state->digest_res;
     777        if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) {
     778                printf("cryptodev_digest_update: digest failed\n");
     779                return (0);
     780        }
     781        return (1);
     782}
     783
     784static int cryptodev_digest_final(EVP_MD_CTX * ctx, unsigned char *md)
     785{
     786        struct crypt_op cryp;
     787        struct dev_crypto_state *state = ctx->md_data;
     788        struct session_op *sess = &state->d_sess;
     789
     790        if (!md || state->d_fd < 0) {
     791                printf("cryptodev_digest_final: illegal input\n");
     792                return (0);
     793        }
     794
     795        if (!(ctx->flags & EVP_MD_CTX_FLAG_ONESHOT)) {
     796                /* if application doesn't support one buffer */
     797                memset(&cryp, 0, sizeof(cryp));
     798                cryp.ses = sess->ses;
     799                cryp.flags = 0;
     800                cryp.len = state->mac_len;
     801                cryp.src = state->mac_data;
     802                cryp.dst = NULL;
     803                cryp.mac = (void *)md;
     804                if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) {
     805                        printf("cryptodev_digest_final: digest failed\n");
     806                        return (0);
     807                }
     808
     809                return 1;
     810        }
     811
     812        memcpy(md, state->digest_res, ctx->digest->md_size);
     813
     814        return 1;
     815}
     816
     817static int cryptodev_digest_cleanup(EVP_MD_CTX * ctx)
     818{
     819        int ret = 1;
     820        struct dev_crypto_state *state = ctx->md_data;
     821        struct session_op *sess = &state->d_sess;
     822
     823        if (state == NULL)
     824                return 0;
     825
     826        if (state->d_fd < 0) {
     827                printf("cryptodev_digest_cleanup: illegal input\n");
     828                return (0);
     829        }
     830
     831        if (state->mac_data) {
     832                OPENSSL_free(state->mac_data);
     833                state->mac_data = NULL;
     834                state->mac_len = 0;
     835        }
     836
     837        if (ioctl(state->d_fd, CIOCFSESSION, &sess->ses) < 0) {
     838                printf("cryptodev_digest_cleanup: failed to close session\n");
     839                ret = 0;
     840        } else {
     841                ret = 1;
     842        }
     843        put_dev_crypto(state->d_fd);
     844        state->d_fd = -1;
     845
     846        return (ret);
     847}
     848
     849static int cryptodev_digest_copy(EVP_MD_CTX * to, const EVP_MD_CTX * from)
     850{
     851        struct dev_crypto_state *fstate = from->md_data;
     852        struct dev_crypto_state *dstate = to->md_data;
     853        struct session_op *sess;
     854        int digest;
     855
     856        if (dstate == NULL || fstate == NULL)
     857                return 1;
     858
     859        memcpy(dstate, fstate, sizeof(struct dev_crypto_state));
     860
     861        sess = &dstate->d_sess;
     862
     863        digest = digest_nid_to_cryptodev(to->digest->type);
     864
     865        sess->mackey = NULL;
     866        sess->mackeylen = 0;
     867        sess->mac = digest;
     868
     869        dstate->d_fd = get_dev_crypto();
     870
     871        if (ioctl(dstate->d_fd, CIOCGSESSION, sess) < 0) {
     872                put_dev_crypto(dstate->d_fd);
     873                dstate->d_fd = -1;
     874                printf("cryptodev_digest_init: Open session failed\n");
     875                return (0);
     876        }
     877
     878        dstate->mac_len = fstate->mac_len;
     879        if (fstate->mac_len != 0) {
     880                if (fstate->mac_data != NULL) {
     881                        dstate->mac_data = OPENSSL_malloc(fstate->mac_len);
     882                        if (dstate->mac_data == NULL) {
     883                                printf("cryptodev_digest_init: malloc failed\n");
     884                                return 0;
     885                        }
     886                        memcpy(dstate->mac_data, fstate->mac_data, fstate->mac_len);
     887                }
     888        }
     889
     890        return 1;
     891}
     892
     893static const EVP_MD cryptodev_sha1 = {
     894        NID_sha1,
     895        NID_sha1WithRSAEncryption,
     896        SHA_DIGEST_LENGTH,
     897#if defined(EVP_MD_FLAG_PKEY_METHOD_SIGNATURE) && defined(EVP_MD_FLAG_DIGALGID_ABSENT)
     898        EVP_MD_FLAG_PKEY_METHOD_SIGNATURE | EVP_MD_FLAG_DIGALGID_ABSENT |
     899#endif
     900            EVP_MD_FLAG_ONESHOT,
     901        cryptodev_digest_init,
     902        cryptodev_digest_update,
     903        cryptodev_digest_final,
     904        cryptodev_digest_copy,
     905        cryptodev_digest_cleanup,
     906        EVP_PKEY_RSA_method,
     907        SHA_CBLOCK,
     908        sizeof(EVP_MD *) + sizeof(struct dev_crypto_state),
     909};
     910
     911static const EVP_MD cryptodev_sha256 = {
     912        NID_sha256,
     913        NID_sha256WithRSAEncryption,
     914        SHA256_DIGEST_LENGTH,
     915#if defined(EVP_MD_FLAG_PKEY_METHOD_SIGNATURE) && defined(EVP_MD_FLAG_DIGALGID_ABSENT)
     916        EVP_MD_FLAG_PKEY_METHOD_SIGNATURE | EVP_MD_FLAG_DIGALGID_ABSENT |
     917#endif
     918            EVP_MD_FLAG_ONESHOT,
     919        cryptodev_digest_init,
     920        cryptodev_digest_update,
     921        cryptodev_digest_final,
     922        cryptodev_digest_copy,
     923        cryptodev_digest_cleanup,
     924        EVP_PKEY_RSA_method,
     925        SHA256_CBLOCK,
     926        sizeof(EVP_MD *) + sizeof(struct dev_crypto_state),
     927};
     928
     929static const EVP_MD cryptodev_sha224 = {
     930        NID_sha224,
     931        NID_sha224WithRSAEncryption,
     932        SHA224_DIGEST_LENGTH,
     933#if defined(EVP_MD_FLAG_PKEY_METHOD_SIGNATURE) && defined(EVP_MD_FLAG_DIGALGID_ABSENT)
     934        EVP_MD_FLAG_PKEY_METHOD_SIGNATURE | EVP_MD_FLAG_DIGALGID_ABSENT |
     935#endif
     936            EVP_MD_FLAG_ONESHOT,
     937        cryptodev_digest_init,
     938        cryptodev_digest_update,
     939        cryptodev_digest_final,
     940        cryptodev_digest_copy,
     941        cryptodev_digest_cleanup,
     942        EVP_PKEY_RSA_method,
     943        SHA256_CBLOCK,
     944        sizeof(EVP_MD *) + sizeof(struct dev_crypto_state),
     945};
     946
     947static const EVP_MD cryptodev_sha384 = {
     948        NID_sha384,
     949        NID_sha384WithRSAEncryption,
     950        SHA384_DIGEST_LENGTH,
     951#if defined(EVP_MD_FLAG_PKEY_METHOD_SIGNATURE) && defined(EVP_MD_FLAG_DIGALGID_ABSENT)
     952        EVP_MD_FLAG_PKEY_METHOD_SIGNATURE | EVP_MD_FLAG_DIGALGID_ABSENT |
     953#endif
     954            EVP_MD_FLAG_ONESHOT,
     955        cryptodev_digest_init,
     956        cryptodev_digest_update,
     957        cryptodev_digest_final,
     958        cryptodev_digest_copy,
     959        cryptodev_digest_cleanup,
     960        EVP_PKEY_RSA_method,
     961        SHA512_CBLOCK,
     962        sizeof(EVP_MD *) + sizeof(struct dev_crypto_state),
     963};
     964
     965static const EVP_MD cryptodev_sha512 = {
     966        NID_sha512,
     967        NID_sha512WithRSAEncryption,
     968        SHA512_DIGEST_LENGTH,
     969#if defined(EVP_MD_FLAG_PKEY_METHOD_SIGNATURE) && defined(EVP_MD_FLAG_DIGALGID_ABSENT)
     970        EVP_MD_FLAG_PKEY_METHOD_SIGNATURE | EVP_MD_FLAG_DIGALGID_ABSENT |
     971#endif
     972            EVP_MD_FLAG_ONESHOT,
     973        cryptodev_digest_init,
     974        cryptodev_digest_update,
     975        cryptodev_digest_final,
     976        cryptodev_digest_copy,
     977        cryptodev_digest_cleanup,
     978        EVP_PKEY_RSA_method,
     979        SHA512_CBLOCK,
     980        sizeof(EVP_MD *) + sizeof(struct dev_crypto_state),
     981};
     982
     983static const EVP_MD cryptodev_md5 = {
     984        NID_md5,
     985        NID_md5WithRSAEncryption,
     986        16 /* MD5_DIGEST_LENGTH */ ,
     987#if defined(EVP_MD_FLAG_PKEY_METHOD_SIGNATURE) && defined(EVP_MD_FLAG_DIGALGID_ABSENT)
     988        EVP_MD_FLAG_PKEY_METHOD_SIGNATURE | EVP_MD_FLAG_DIGALGID_ABSENT |
     989#endif
     990            EVP_MD_FLAG_ONESHOT,
     991        cryptodev_digest_init,
     992        cryptodev_digest_update,
     993        cryptodev_digest_final,
     994        cryptodev_digest_copy,
     995        cryptodev_digest_cleanup,
     996        EVP_PKEY_RSA_method,
     997        64 /* MD5_CBLOCK */ ,
     998        sizeof(EVP_MD *) + sizeof(struct dev_crypto_state),
     999};
     1000
     1001#endif                          /* USE_CRYPTODEV_DIGESTS */
     1002
     1003static int cryptodev_engine_digests(ENGINE * e, const EVP_MD ** digest, const int **nids, int nid)
     1004{
     1005        if (!digest)
     1006                return (cryptodev_usable_digests(nids));
     1007
     1008        switch (nid) {
     1009#ifdef USE_CRYPTODEV_DIGESTS
     1010        case NID_md5:
     1011                *digest = &cryptodev_md5;
     1012                break;
     1013        case NID_sha1:
     1014                *digest = &cryptodev_sha1;
     1015                break;
     1016        case NID_sha224:
     1017                *digest = &cryptodev_sha224;
     1018                break;
     1019        case NID_sha256:
     1020                *digest = &cryptodev_sha256;
     1021                break;
     1022        case NID_sha384:
     1023                *digest = &cryptodev_sha384;
     1024                break;
     1025        case NID_sha512:
     1026                *digest = &cryptodev_sha512;
     1027                break;
     1028        default:
     1029#endif                          /* USE_CRYPTODEV_DIGESTS */
     1030                *digest = NULL;
     1031                break;
     1032        }
     1033        return (*digest != NULL);
    10241034}
    10251035
     
    10291039 * crp->crp_p.
    10301040 */
    1031 static int bn2crparam(const BIGNUM *a, struct crparam *crp)
    1032 {
    1033     int i, j, k;
    1034     ssize_t bytes, bits;
    1035     u_char *b;
    1036 
    1037     crp->crp_p = NULL;
    1038     crp->crp_nbits = 0;
    1039 
    1040     bits = BN_num_bits(a);
    1041     bytes = (bits + 7) / 8;
    1042 
    1043     b = malloc(bytes);
    1044     if (b == NULL)
    1045         return (1);
    1046     memset(b, 0, bytes);
    1047 
    1048     crp->crp_p = (caddr_t) b;
    1049     crp->crp_nbits = bits;
    1050 
    1051     for (i = 0, j = 0; i < a->top; i++) {
    1052         for (k = 0; k < BN_BITS2 / 8; k++) {
    1053             if ((j + k) >= bytes)
    1054                 return (0);
    1055             b[j + k] = a->d[i] >> (k * 8);
    1056         }
    1057         j += BN_BITS2 / 8;
    1058     }
    1059     return (0);
     1041static int bn2crparam(const BIGNUM * a, struct crparam *crp)
     1042{
     1043        int i, j, k;
     1044        ssize_t bytes, bits;
     1045        u_char *b;
     1046
     1047        crp->crp_p = NULL;
     1048        crp->crp_nbits = 0;
     1049
     1050        bits = BN_num_bits(a);
     1051        bytes = (bits + 7) / 8;
     1052
     1053        b = malloc(bytes);
     1054        if (b == NULL)
     1055                return (1);
     1056        memset(b, 0, bytes);
     1057
     1058        crp->crp_p = (void *)b;
     1059        crp->crp_nbits = bits;
     1060
     1061        for (i = 0, j = 0; i < a->top; i++) {
     1062                for (k = 0; k < BN_BITS2 / 8; k++) {
     1063                        if ((j + k) >= bytes)
     1064                                return (0);
     1065                        b[j + k] = a->d[i] >> (k * 8);
     1066                }
     1067                j += BN_BITS2 / 8;
     1068        }
     1069        return (0);
    10601070}
    10611071
    10621072/* Convert a /dev/crypto parameter to a BIGNUM */
    1063 static int crparam2bn(struct crparam *crp, BIGNUM *a)
    1064 {
    1065     u_int8_t *pd;
    1066     int i, bytes;
    1067 
    1068     bytes = (crp->crp_nbits + 7) / 8;
    1069 
    1070     if (bytes == 0)
    1071         return (-1);
    1072 
    1073     if ((pd = (u_int8_t *) malloc(bytes)) == NULL)
    1074         return (-1);
    1075 
    1076     for (i = 0; i < bytes; i++)
    1077         pd[i] = crp->crp_p[bytes - i - 1];
    1078 
    1079     BN_bin2bn(pd, bytes, a);
    1080     free(pd);
    1081 
    1082     return (0);
     1073static int crparam2bn(struct crparam *crp, BIGNUM * a)
     1074{
     1075        u_int8_t *pd;
     1076        int i, bytes;
     1077
     1078        bytes = (crp->crp_nbits + 7) / 8;
     1079
     1080        if (bytes == 0)
     1081                return (-1);
     1082
     1083        if ((pd = (u_int8_t *)malloc(bytes)) == NULL)
     1084                return (-1);
     1085
     1086        for (i = 0; i < bytes; i++)
     1087                pd[i] = crp->crp_p[bytes - i - 1];
     1088
     1089        BN_bin2bn(pd, bytes, a);
     1090        free(pd);
     1091
     1092        return (0);
    10831093}
    10841094
    10851095static void zapparams(struct crypt_kop *kop)
    10861096{
    1087     int i;
    1088 
    1089     for (i = 0; i < kop->crk_iparams + kop->crk_oparams; i++) {
    1090         OPENSSL_free(kop->crk_param[i].crp_p);
    1091         kop->crk_param[i].crp_p = NULL;
    1092         kop->crk_param[i].crp_nbits = 0;
    1093     }
    1094 }
    1095 
    1096 static int
    1097 cryptodev_asym(struct crypt_kop *kop, int rlen, BIGNUM *r, int slen,
    1098                BIGNUM *s)
    1099 {
    1100     int fd, ret = -1;
    1101 
    1102     if ((fd = get_asym_dev_crypto()) < 0)
    1103         return ret;
    1104 
    1105     if (r) {
    1106         kop->crk_param[kop->crk_iparams].crp_p = OPENSSL_malloc(rlen);
    1107         if (kop->crk_param[kop->crk_iparams].crp_p == NULL)
    1108             return ret;
    1109         memset(kop->crk_param[kop->crk_iparams].crp_p, 0, (size_t)rlen);
    1110         kop->crk_param[kop->crk_iparams].crp_nbits = rlen * 8;
    1111         kop->crk_oparams++;
    1112     }
    1113     if (s) {
    1114         kop->crk_param[kop->crk_iparams + 1].crp_p = OPENSSL_malloc(slen);
    1115         /* No need to free the kop->crk_iparams parameter if it was allocated,
    1116          * callers of this routine have to free allocated parameters through
    1117          * zapparams both in case of success and failure
    1118          */
    1119         if (kop->crk_param[kop->crk_iparams+1].crp_p == NULL)
    1120             return ret;
    1121         memset(kop->crk_param[kop->crk_iparams + 1].crp_p, 0, (size_t)slen);
    1122         kop->crk_param[kop->crk_iparams + 1].crp_nbits = slen * 8;
    1123         kop->crk_oparams++;
    1124     }
    1125 
    1126     if (ioctl(fd, CIOCKEY, kop) == 0) {
    1127         if (r)
    1128             crparam2bn(&kop->crk_param[kop->crk_iparams], r);
    1129         if (s)
    1130             crparam2bn(&kop->crk_param[kop->crk_iparams + 1], s);
    1131         ret = 0;
    1132     }
    1133 
    1134     return ret;
    1135 }
    1136 
    1137 static int
    1138 cryptodev_bn_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
    1139                      const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
    1140 {
    1141     struct crypt_kop kop;
    1142     int ret = 1;
    1143 
    1144     /*
    1145      * Currently, we know we can do mod exp iff we can do any asymmetric
    1146      * operations at all.
    1147      */
    1148     if (cryptodev_asymfeat == 0) {
    1149         ret = BN_mod_exp(r, a, p, m, ctx);
    1150         return (ret);
    1151     }
    1152 
    1153     memset(&kop, 0, sizeof kop);
    1154     kop.crk_op = CRK_MOD_EXP;
    1155 
    1156     /* inputs: a^p % m */
    1157     if (bn2crparam(a, &kop.crk_param[0]))
    1158         goto err;
    1159     if (bn2crparam(p, &kop.crk_param[1]))
    1160         goto err;
    1161     if (bn2crparam(m, &kop.crk_param[2]))
    1162         goto err;
    1163     kop.crk_iparams = 3;
    1164 
    1165     if (cryptodev_asym(&kop, BN_num_bytes(m), r, 0, NULL)) {
    1166         const RSA_METHOD *meth = RSA_PKCS1_SSLeay();
    1167         printf("OCF asym process failed, Running in software\n");
    1168         ret = meth->bn_mod_exp(r, a, p, m, ctx, in_mont);
    1169 
    1170     } else if (ECANCELED == kop.crk_status) {
    1171         const RSA_METHOD *meth = RSA_PKCS1_SSLeay();
    1172         printf("OCF hardware operation cancelled. Running in Software\n");
    1173         ret = meth->bn_mod_exp(r, a, p, m, ctx, in_mont);
    1174     }
    1175     /* else cryptodev operation worked ok ==> ret = 1 */
    1176 
    1177  err:
    1178     zapparams(&kop);
    1179     return (ret);
    1180 }
    1181 
    1182 static int
    1183 cryptodev_rsa_nocrt_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa,
    1184                             BN_CTX *ctx)
    1185 {
    1186     int r;
    1187     ctx = BN_CTX_new();
    1188     r = cryptodev_bn_mod_exp(r0, I, rsa->d, rsa->n, ctx, NULL);
    1189     BN_CTX_free(ctx);
    1190     return (r);
    1191 }
    1192 
    1193 static int
    1194 cryptodev_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx)
    1195 {
    1196     struct crypt_kop kop;
    1197     int ret = 1;
    1198 
    1199     if (!rsa->p || !rsa->q || !rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp) {
    1200         /* XXX 0 means failure?? */
    1201         return (0);
    1202     }
    1203 
    1204     memset(&kop, 0, sizeof kop);
    1205     kop.crk_op = CRK_MOD_EXP_CRT;
    1206     /* inputs: rsa->p rsa->q I rsa->dmp1 rsa->dmq1 rsa->iqmp */
    1207     if (bn2crparam(rsa->p, &kop.crk_param[0]))
    1208         goto err;
    1209     if (bn2crparam(rsa->q, &kop.crk_param[1]))
    1210         goto err;
    1211     if (bn2crparam(I, &kop.crk_param[2]))
    1212         goto err;
    1213     if (bn2crparam(rsa->dmp1, &kop.crk_param[3]))
    1214         goto err;
    1215     if (bn2crparam(rsa->dmq1, &kop.crk_param[4]))
    1216         goto err;
    1217     if (bn2crparam(rsa->iqmp, &kop.crk_param[5]))
    1218         goto err;
    1219     kop.crk_iparams = 6;
    1220 
    1221     if (cryptodev_asym(&kop, BN_num_bytes(rsa->n), r0, 0, NULL)) {
    1222         const RSA_METHOD *meth = RSA_PKCS1_SSLeay();
    1223         printf("OCF asym process failed, running in Software\n");
    1224         ret = (*meth->rsa_mod_exp) (r0, I, rsa, ctx);
    1225 
    1226     } else if (ECANCELED == kop.crk_status) {
    1227         const RSA_METHOD *meth = RSA_PKCS1_SSLeay();
    1228         printf("OCF hardware operation cancelled. Running in Software\n");
    1229         ret = (*meth->rsa_mod_exp) (r0, I, rsa, ctx);
    1230     }
    1231     /* else cryptodev operation worked ok ==> ret = 1 */
    1232 
    1233  err:
    1234     zapparams(&kop);
    1235     return (ret);
     1097        int i;
     1098
     1099        for (i = 0; i < kop->crk_iparams + kop->crk_oparams; i++) {
     1100                OPENSSL_free(kop->crk_param[i].crp_p);
     1101                kop->crk_param[i].crp_p = NULL;
     1102                kop->crk_param[i].crp_nbits = 0;
     1103        }
     1104}
     1105
     1106static int cryptodev_asym(struct crypt_kop *kop, int rlen, BIGNUM * r, int slen, BIGNUM * s)
     1107{
     1108        int fd, ret = -1;
     1109
     1110        if ((fd = get_asym_dev_crypto()) < 0)
     1111                return ret;
     1112
     1113        if (r) {
     1114                kop->crk_param[kop->crk_iparams].crp_p = OPENSSL_malloc(rlen);
     1115                if (kop->crk_param[kop->crk_iparams].crp_p == NULL)
     1116                        return ret;
     1117                memset(kop->crk_param[kop->crk_iparams].crp_p, 0, (size_t)rlen);
     1118                kop->crk_param[kop->crk_iparams].crp_nbits = rlen * 8;
     1119                kop->crk_oparams++;
     1120        }
     1121        if (s) {
     1122                kop->crk_param[kop->crk_iparams + 1].crp_p = OPENSSL_malloc(slen);
     1123                /* No need to free the kop->crk_iparams parameter if it was allocated,
     1124                 * callers of this routine have to free allocated parameters through
     1125                 * zapparams both in case of success and failure
     1126                 */
     1127                if (kop->crk_param[kop->crk_iparams + 1].crp_p == NULL)
     1128                        return ret;
     1129                memset(kop->crk_param[kop->crk_iparams + 1].crp_p, 0, (size_t)slen);
     1130                kop->crk_param[kop->crk_iparams + 1].crp_nbits = slen * 8;
     1131                kop->crk_oparams++;
     1132        }
     1133
     1134        if (ioctl(fd, CIOCKEY, kop) == 0) {
     1135                if (r)
     1136                        crparam2bn(&kop->crk_param[kop->crk_iparams], r);
     1137                if (s)
     1138                        crparam2bn(&kop->crk_param[kop->crk_iparams + 1], s);
     1139                ret = 0;
     1140        }
     1141
     1142        return ret;
     1143}
     1144
     1145static int cryptodev_bn_mod_exp(BIGNUM * r, const BIGNUM * a, const BIGNUM * p, const BIGNUM * m, BN_CTX * ctx, BN_MONT_CTX * in_mont)
     1146{
     1147        struct crypt_kop kop;
     1148        int ret = 1;
     1149
     1150        /*
     1151         * Currently, we know we can do mod exp iff we can do any asymmetric
     1152         * operations at all.
     1153         */
     1154        if (cryptodev_asymfeat == 0) {
     1155                ret = BN_mod_exp(r, a, p, m, ctx);
     1156                return (ret);
     1157        }
     1158
     1159        memset(&kop, 0, sizeof kop);
     1160        kop.crk_op = CRK_MOD_EXP;
     1161
     1162        /* inputs: a^p % m */
     1163        if (bn2crparam(a, &kop.crk_param[0]))
     1164                goto err;
     1165        if (bn2crparam(p, &kop.crk_param[1]))
     1166                goto err;
     1167        if (bn2crparam(m, &kop.crk_param[2]))
     1168                goto err;
     1169        kop.crk_iparams = 3;
     1170
     1171        if (cryptodev_asym(&kop, BN_num_bytes(m), r, 0, NULL)) {
     1172                const RSA_METHOD *meth = RSA_PKCS1_SSLeay();
     1173                printf("OCF asym process failed, Running in software\n");
     1174                ret = meth->bn_mod_exp(r, a, p, m, ctx, in_mont);
     1175
     1176        } else if (ECANCELED == kop.crk_status) {
     1177                const RSA_METHOD *meth = RSA_PKCS1_SSLeay();
     1178                printf("OCF hardware operation cancelled. Running in Software\n");
     1179                ret = meth->bn_mod_exp(r, a, p, m, ctx, in_mont);
     1180        }
     1181        /* else cryptodev operation worked ok ==> ret = 1 */
     1182
     1183err:
     1184        zapparams(&kop);
     1185        return (ret);
     1186}
     1187
     1188static int cryptodev_rsa_nocrt_mod_exp(BIGNUM * r0, const BIGNUM * I, RSA * rsa, BN_CTX * ctx)
     1189{
     1190        int r;
     1191        ctx = BN_CTX_new();
     1192        r = cryptodev_bn_mod_exp(r0, I, rsa->d, rsa->n, ctx, NULL);
     1193        BN_CTX_free(ctx);
     1194        return (r);
     1195}
     1196
     1197static int cryptodev_rsa_mod_exp(BIGNUM * r0, const BIGNUM * I, RSA * rsa, BN_CTX * ctx)
     1198{
     1199        struct crypt_kop kop;
     1200        int ret = 1;
     1201
     1202        if (!rsa->p || !rsa->q || !rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp) {
     1203                /* XXX 0 means failure?? */
     1204                return (0);
     1205        }
     1206
     1207        memset(&kop, 0, sizeof kop);
     1208        kop.crk_op = CRK_MOD_EXP_CRT;
     1209        /* inputs: rsa->p rsa->q I rsa->dmp1 rsa->dmq1 rsa->iqmp */
     1210        if (bn2crparam(rsa->p, &kop.crk_param[0]))
     1211                goto err;
     1212        if (bn2crparam(rsa->q, &kop.crk_param[1]))
     1213                goto err;
     1214        if (bn2crparam(I, &kop.crk_param[2]))
     1215                goto err;
     1216        if (bn2crparam(rsa->dmp1, &kop.crk_param[3]))
     1217                goto err;
     1218        if (bn2crparam(rsa->dmq1, &kop.crk_param[4]))
     1219                goto err;
     1220        if (bn2crparam(rsa->iqmp, &kop.crk_param[5]))
     1221                goto err;
     1222        kop.crk_iparams = 6;
     1223
     1224        if (cryptodev_asym(&kop, BN_num_bytes(rsa->n), r0, 0, NULL)) {
     1225                const RSA_METHOD *meth = RSA_PKCS1_SSLeay();
     1226                printf("OCF asym process failed, running in Software\n");
     1227                ret = (*meth->rsa_mod_exp) (r0, I, rsa, ctx);
     1228
     1229        } else if (ECANCELED == kop.crk_status) {
     1230                const RSA_METHOD *meth = RSA_PKCS1_SSLeay();
     1231                printf("OCF hardware operation cancelled. Running in Software\n");
     1232                ret = (*meth->rsa_mod_exp) (r0, I, rsa, ctx);
     1233        }
     1234        /* else cryptodev operation worked ok ==> ret = 1 */
     1235
     1236err:
     1237        zapparams(&kop);
     1238        return (ret);
    12361239}
    12371240
    12381241static RSA_METHOD cryptodev_rsa = {
    1239     "cryptodev RSA method",
    1240     NULL,                       /* rsa_pub_enc */
    1241     NULL,                       /* rsa_pub_dec */
    1242     NULL,                       /* rsa_priv_enc */
    1243     NULL,                       /* rsa_priv_dec */
    1244     NULL,
    1245     NULL,
    1246     NULL,                       /* init */
    1247     NULL,                       /* finish */
    1248     0,                          /* flags */
    1249     NULL,                       /* app_data */
    1250     NULL,                       /* rsa_sign */
    1251     NULL                        /* rsa_verify */
    1252 };
    1253 
    1254 static int
    1255 cryptodev_dsa_bn_mod_exp(DSA *dsa, BIGNUM *r, BIGNUM *a, const BIGNUM *p,
    1256                          const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
    1257 {
    1258     return (cryptodev_bn_mod_exp(r, a, p, m, ctx, m_ctx));
    1259 }
    1260 
    1261 static int
    1262 cryptodev_dsa_dsa_mod_exp(DSA *dsa, BIGNUM *t1, BIGNUM *g,
    1263                           BIGNUM *u1, BIGNUM *pub_key, BIGNUM *u2, BIGNUM *p,
    1264                           BN_CTX *ctx, BN_MONT_CTX *mont)
    1265 {
    1266     BIGNUM t2;
    1267     int ret = 0;
    1268 
    1269     BN_init(&t2);
    1270 
    1271     /* v = ( g^u1 * y^u2 mod p ) mod q */
    1272     /* let t1 = g ^ u1 mod p */
    1273     ret = 0;
    1274 
    1275     if (!dsa->meth->bn_mod_exp(dsa, t1, dsa->g, u1, dsa->p, ctx, mont))
    1276         goto err;
    1277 
    1278     /* let t2 = y ^ u2 mod p */
    1279     if (!dsa->meth->bn_mod_exp(dsa, &t2, dsa->pub_key, u2, dsa->p, ctx, mont))
    1280         goto err;
    1281     /* let u1 = t1 * t2 mod p */
    1282     if (!BN_mod_mul(u1, t1, &t2, dsa->p, ctx))
    1283         goto err;
    1284 
    1285     BN_copy(t1, u1);
    1286 
    1287     ret = 1;
    1288  err:
    1289     BN_free(&t2);
    1290     return (ret);
    1291 }
    1292 
    1293 static DSA_SIG *cryptodev_dsa_do_sign(const unsigned char *dgst, int dlen,
    1294                                       DSA *dsa)
    1295 {
    1296     struct crypt_kop kop;
    1297     BIGNUM *r = NULL, *s = NULL;
    1298     DSA_SIG *dsaret = NULL;
    1299 
    1300     if ((r = BN_new()) == NULL)
    1301         goto err;
    1302     if ((s = BN_new()) == NULL) {
    1303         BN_free(r);
    1304         goto err;
    1305     }
    1306 
    1307     memset(&kop, 0, sizeof kop);
    1308     kop.crk_op = CRK_DSA_SIGN;
    1309 
    1310     /* inputs: dgst dsa->p dsa->q dsa->g dsa->priv_key */
    1311     kop.crk_param[0].crp_p = (caddr_t) dgst;
    1312     kop.crk_param[0].crp_nbits = dlen * 8;
    1313     if (bn2crparam(dsa->p, &kop.crk_param[1]))
    1314         goto err;
    1315     if (bn2crparam(dsa->q, &kop.crk_param[2]))
    1316         goto err;
    1317     if (bn2crparam(dsa->g, &kop.crk_param[3]))
    1318         goto err;
    1319     if (bn2crparam(dsa->priv_key, &kop.crk_param[4]))
    1320         goto err;
    1321     kop.crk_iparams = 5;
    1322 
    1323     if (cryptodev_asym(&kop, BN_num_bytes(dsa->q), r,
    1324                        BN_num_bytes(dsa->q), s) == 0) {
    1325         dsaret = DSA_SIG_new();
    1326         if (dsaret == NULL)
    1327             goto err;
    1328         dsaret->r = r;
    1329         dsaret->s = s;
    1330         r = s = NULL;
    1331     } else {
    1332         const DSA_METHOD *meth = DSA_OpenSSL();
    1333         dsaret = (meth->dsa_do_sign) (dgst, dlen, dsa);
    1334     }
    1335  err:
    1336     BN_free(r);
    1337     BN_free(s);
    1338     kop.crk_param[0].crp_p = NULL;
    1339     zapparams(&kop);
    1340     return (dsaret);
    1341 }
    1342 
    1343 static int
    1344 cryptodev_dsa_verify(const unsigned char *dgst, int dlen,
    1345                      DSA_SIG *sig, DSA *dsa)
    1346 {
    1347     struct crypt_kop kop;
    1348     int dsaret = 1;
    1349 
    1350     memset(&kop, 0, sizeof kop);
    1351     kop.crk_op = CRK_DSA_VERIFY;
    1352 
    1353     /* inputs: dgst dsa->p dsa->q dsa->g dsa->pub_key sig->r sig->s */
    1354     kop.crk_param[0].crp_p = (caddr_t) dgst;
    1355     kop.crk_param[0].crp_nbits = dlen * 8;
    1356     if (bn2crparam(dsa->p, &kop.crk_param[1]))
    1357         goto err;
    1358     if (bn2crparam(dsa->q, &kop.crk_param[2]))
    1359         goto err;
    1360     if (bn2crparam(dsa->g, &kop.crk_param[3]))
    1361         goto err;
    1362     if (bn2crparam(dsa->pub_key, &kop.crk_param[4]))
    1363         goto err;
    1364     if (bn2crparam(sig->r, &kop.crk_param[5]))
    1365         goto err;
    1366     if (bn2crparam(sig->s, &kop.crk_param[6]))
    1367         goto err;
    1368     kop.crk_iparams = 7;
    1369 
    1370     if (cryptodev_asym(&kop, 0, NULL, 0, NULL) == 0) {
    1371         /*
    1372          * OCF success value is 0, if not zero, change dsaret to fail
    1373          */
    1374         if (0 != kop.crk_status)
    1375             dsaret = 0;
    1376     } else {
    1377         const DSA_METHOD *meth = DSA_OpenSSL();
    1378 
    1379         dsaret = (meth->dsa_do_verify) (dgst, dlen, sig, dsa);
    1380     }
    1381  err:
    1382     kop.crk_param[0].crp_p = NULL;
    1383     zapparams(&kop);
    1384     return (dsaret);
     1242        "cryptodev RSA method",
     1243        NULL,                   /* rsa_pub_enc */
     1244        NULL,                   /* rsa_pub_dec */
     1245        NULL,                   /* rsa_priv_enc */
     1246        NULL,                   /* rsa_priv_dec */
     1247        NULL,
     1248        NULL,
     1249        NULL,                   /* init */
     1250        NULL,                   /* finish */
     1251        0,                      /* flags */
     1252        NULL,                   /* app_data */
     1253        NULL,                   /* rsa_sign */
     1254        NULL                    /* rsa_verify */
     1255};
     1256
     1257static int cryptodev_dsa_bn_mod_exp(DSA * dsa, BIGNUM * r, BIGNUM * a, const BIGNUM * p, const BIGNUM * m, BN_CTX * ctx, BN_MONT_CTX * m_ctx)
     1258{
     1259        return (cryptodev_bn_mod_exp(r, a, p, m, ctx, m_ctx));
     1260}
     1261
     1262static int cryptodev_dsa_dsa_mod_exp(DSA * dsa, BIGNUM * t1, BIGNUM * g, BIGNUM * u1, BIGNUM * pub_key, BIGNUM * u2, BIGNUM * p, BN_CTX * ctx, BN_MONT_CTX * mont)
     1263{
     1264        BIGNUM t2;
     1265        int ret = 0;
     1266
     1267        BN_init(&t2);
     1268
     1269        /* v = ( g^u1 * y^u2 mod p ) mod q */
     1270        /* let t1 = g ^ u1 mod p */
     1271        ret = 0;
     1272
     1273        if (!dsa->meth->bn_mod_exp(dsa, t1, dsa->g, u1, dsa->p, ctx, mont))
     1274                goto err;
     1275
     1276        /* let t2 = y ^ u2 mod p */
     1277        if (!dsa->meth->bn_mod_exp(dsa, &t2, dsa->pub_key, u2, dsa->p, ctx, mont))
     1278                goto err;
     1279        /* let u1 = t1 * t2 mod p */
     1280        if (!BN_mod_mul(u1, t1, &t2, dsa->p, ctx))
     1281                goto err;
     1282
     1283        BN_copy(t1, u1);
     1284
     1285        ret = 1;
     1286err:
     1287        BN_free(&t2);
     1288        return (ret);
     1289}
     1290
     1291static DSA_SIG *cryptodev_dsa_do_sign(const unsigned char *dgst, int dlen, DSA * dsa)
     1292{
     1293        struct crypt_kop kop;
     1294        BIGNUM *r = NULL, *s = NULL;
     1295        DSA_SIG *dsaret = NULL;
     1296
     1297        if ((r = BN_new()) == NULL)
     1298                goto err;
     1299        if ((s = BN_new()) == NULL) {
     1300                BN_free(r);
     1301                goto err;
     1302        }
     1303
     1304        memset(&kop, 0, sizeof kop);
     1305        kop.crk_op = CRK_DSA_SIGN;
     1306
     1307        /* inputs: dgst dsa->p dsa->q dsa->g dsa->priv_key */
     1308        kop.crk_param[0].crp_p = (void *)dgst;
     1309        kop.crk_param[0].crp_nbits = dlen * 8;
     1310        if (bn2crparam(dsa->p, &kop.crk_param[1]))
     1311                goto err;
     1312        if (bn2crparam(dsa->q, &kop.crk_param[2]))
     1313                goto err;
     1314        if (bn2crparam(dsa->g, &kop.crk_param[3]))
     1315                goto err;
     1316        if (bn2crparam(dsa->priv_key, &kop.crk_param[4]))
     1317                goto err;
     1318        kop.crk_iparams = 5;
     1319
     1320        if (cryptodev_asym(&kop, BN_num_bytes(dsa->q), r, BN_num_bytes(dsa->q), s) == 0) {
     1321                dsaret = DSA_SIG_new();
     1322                if (dsaret == NULL)
     1323                        goto err;
     1324                dsaret->r = r;
     1325                dsaret->s = s;
     1326                r = s = NULL;
     1327        } else {
     1328                const DSA_METHOD *meth = DSA_OpenSSL();
     1329                dsaret = (meth->dsa_do_sign) (dgst, dlen, dsa);
     1330        }
     1331err:
     1332        BN_free(r);
     1333        BN_free(s);
     1334        kop.crk_param[0].crp_p = NULL;
     1335        zapparams(&kop);
     1336        return (dsaret);
     1337}
     1338
     1339static int cryptodev_dsa_verify(const unsigned char *dgst, int dlen, DSA_SIG * sig, DSA * dsa)
     1340{
     1341        struct crypt_kop kop;
     1342        int dsaret = 1;
     1343
     1344        memset(&kop, 0, sizeof kop);
     1345        kop.crk_op = CRK_DSA_VERIFY;
     1346
     1347        /* inputs: dgst dsa->p dsa->q dsa->g dsa->pub_key sig->r sig->s */
     1348        kop.crk_param[0].crp_p = (void *)dgst;
     1349        kop.crk_param[0].crp_nbits = dlen * 8;
     1350        if (bn2crparam(dsa->p, &kop.crk_param[1]))
     1351                goto err;
     1352        if (bn2crparam(dsa->q, &kop.crk_param[2]))
     1353                goto err;
     1354        if (bn2crparam(dsa->g, &kop.crk_param[3]))
     1355                goto err;
     1356        if (bn2crparam(dsa->pub_key, &kop.crk_param[4]))
     1357                goto err;
     1358        if (bn2crparam(sig->r, &kop.crk_param[5]))
     1359                goto err;
     1360        if (bn2crparam(sig->s, &kop.crk_param[6]))
     1361                goto err;
     1362        kop.crk_iparams = 7;
     1363
     1364        if (cryptodev_asym(&kop, 0, NULL, 0, NULL) == 0) {
     1365                /*
     1366                 * OCF success value is 0, if not zero, change dsaret to fail
     1367                 */
     1368                if (0 != kop.crk_status)
     1369                        dsaret = 0;
     1370        } else {
     1371                const DSA_METHOD *meth = DSA_OpenSSL();
     1372
     1373                dsaret = (meth->dsa_do_verify) (dgst, dlen, sig, dsa);
     1374        }
     1375err:
     1376        kop.crk_param[0].crp_p = NULL;
     1377        zapparams(&kop);
     1378        return (dsaret);
    13851379}
    13861380
    13871381static DSA_METHOD cryptodev_dsa = {
    1388     "cryptodev DSA method",
    1389     NULL,
    1390     NULL,                       /* dsa_sign_setup */
    1391     NULL,
    1392     NULL,                       /* dsa_mod_exp */
    1393     NULL,
    1394     NULL,                       /* init */
    1395     NULL,                       /* finish */
    1396     0,                          /* flags */
    1397     NULL                        /* app_data */
    1398 };
    1399 
    1400 static int
    1401 cryptodev_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a,
    1402                      const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
    1403                      BN_MONT_CTX *m_ctx)
    1404 {
    1405     return (cryptodev_bn_mod_exp(r, a, p, m, ctx, m_ctx));
    1406 }
    1407 
    1408 static int
    1409 cryptodev_dh_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
    1410 {
    1411     struct crypt_kop kop;
    1412     int dhret = 1;
    1413     int fd, keylen;
    1414 
    1415     if ((fd = get_asym_dev_crypto()) < 0) {
    1416         const DH_METHOD *meth = DH_OpenSSL();
    1417 
    1418         return ((meth->compute_key) (key, pub_key, dh));
    1419     }
    1420 
    1421     keylen = BN_num_bits(dh->p);
    1422 
    1423     memset(&kop, 0, sizeof kop);
    1424     kop.crk_op = CRK_DH_COMPUTE_KEY;
    1425 
    1426     /* inputs: dh->priv_key pub_key dh->p key */
    1427     if (bn2crparam(dh->priv_key, &kop.crk_param[0]))
    1428         goto err;
    1429     if (bn2crparam(pub_key, &kop.crk_param[1]))
    1430         goto err;
    1431     if (bn2crparam(dh->p, &kop.crk_param[2]))
    1432         goto err;
    1433     kop.crk_iparams = 3;
    1434 
    1435     kop.crk_param[3].crp_p = (caddr_t) key;
    1436     kop.crk_param[3].crp_nbits = keylen * 8;
    1437     kop.crk_oparams = 1;
    1438 
    1439     if (ioctl(fd, CIOCKEY, &kop) == -1) {
    1440         const DH_METHOD *meth = DH_OpenSSL();
    1441 
    1442         dhret = (meth->compute_key) (key, pub_key, dh);
    1443     }
    1444  err:
    1445     kop.crk_param[3].crp_p = NULL;
    1446     zapparams(&kop);
    1447     return (dhret);
     1382        "cryptodev DSA method",
     1383        NULL,
     1384        NULL,                   /* dsa_sign_setup */
     1385        NULL,
     1386        NULL,                   /* dsa_mod_exp */
     1387        NULL,
     1388        NULL,                   /* init */
     1389        NULL,                   /* finish */
     1390        0,                      /* flags */
     1391        NULL                    /* app_data */
     1392};
     1393
     1394static int cryptodev_mod_exp_dh(const DH * dh, BIGNUM * r, const BIGNUM * a, const BIGNUM * p, const BIGNUM * m, BN_CTX * ctx, BN_MONT_CTX * m_ctx)
     1395{
     1396        return (cryptodev_bn_mod_exp(r, a, p, m, ctx, m_ctx));
     1397}
     1398
     1399static int cryptodev_dh_compute_key(unsigned char *key, const BIGNUM * pub_key, DH * dh)
     1400{
     1401        struct crypt_kop kop;
     1402        int dhret = 1;
     1403        int fd, keylen;
     1404
     1405        if ((fd = get_asym_dev_crypto()) < 0) {
     1406                const DH_METHOD *meth = DH_OpenSSL();
     1407
     1408                return ((meth->compute_key) (key, pub_key, dh));
     1409        }
     1410
     1411        keylen = BN_num_bits(dh->p);
     1412
     1413        memset(&kop, 0, sizeof kop);
     1414        kop.crk_op = CRK_DH_COMPUTE_KEY;
     1415
     1416        /* inputs: dh->priv_key pub_key dh->p key */
     1417        if (bn2crparam(dh->priv_key, &kop.crk_param[0]))
     1418                goto err;
     1419        if (bn2crparam(pub_key, &kop.crk_param[1]))
     1420                goto err;
     1421        if (bn2crparam(dh->p, &kop.crk_param[2]))
     1422                goto err;
     1423        kop.crk_iparams = 3;
     1424
     1425        kop.crk_param[3].crp_p = (void *)key;
     1426        kop.crk_param[3].crp_nbits = keylen;
     1427        kop.crk_oparams = 1;
     1428        dhret = keylen / 8;
     1429
     1430        if (ioctl(fd, CIOCKEY, &kop) == -1) {
     1431                const DH_METHOD *meth = DH_OpenSSL();
     1432
     1433                dhret = (meth->compute_key) (key, pub_key, dh);
     1434        }
     1435err:
     1436        kop.crk_param[3].crp_p = NULL;
     1437        zapparams(&kop);
     1438        return (dhret);
    14481439}
    14491440
    14501441static DH_METHOD cryptodev_dh = {
    1451     "cryptodev DH method",
    1452     NULL,                       /* cryptodev_dh_generate_key */
    1453     NULL,
    1454     NULL,
    1455     NULL,
    1456     NULL,
    1457     0,                          /* flags */
    1458     NULL                        /* app_data */
     1442        "cryptodev DH method",
     1443        NULL,                   /* cryptodev_dh_generate_key */
     1444        NULL,
     1445        NULL,
     1446        NULL,
     1447        NULL,
     1448        0,                      /* flags */
     1449        NULL                    /* app_data */
    14591450};
    14601451
     
    14631454 * but I expect we'll want some options soon.
    14641455 */
    1465 static int
    1466 cryptodev_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void))
    1467 {
    1468 # ifdef HAVE_SYSLOG_R
    1469     struct syslog_data sd = SYSLOG_DATA_INIT;
    1470 # endif
    1471 
    1472     switch (cmd) {
    1473     default:
    1474 # ifdef HAVE_SYSLOG_R
    1475         syslog_r(LOG_ERR, &sd, "cryptodev_ctrl: unknown command %d", cmd);
    1476 # else
    1477         syslog(LOG_ERR, "cryptodev_ctrl: unknown command %d", cmd);
    1478 # endif
    1479         break;
    1480     }
    1481     return (1);
     1456static int cryptodev_ctrl(ENGINE * e, int cmd, long i, void *p, void (*f) (void))
     1457{
     1458#ifdef HAVE_SYSLOG_R
     1459        struct syslog_data sd = SYSLOG_DATA_INIT;
     1460#endif
     1461
     1462        switch (cmd) {
     1463        default:
     1464#ifdef HAVE_SYSLOG_R
     1465                syslog_r(LOG_ERR, &sd, "cryptodev_ctrl: unknown command %d", cmd);
     1466#else
     1467                syslog(LOG_ERR, "cryptodev_ctrl: unknown command %d", cmd);
     1468#endif
     1469                break;
     1470        }
     1471        return (1);
    14821472}
    14831473
    14841474void ENGINE_load_cryptodev(void)
    14851475{
    1486     ENGINE *engine = ENGINE_new();
    1487     int fd;
    1488 
    1489     if (engine == NULL)
    1490         return;
    1491     if ((fd = get_dev_crypto()) < 0) {
    1492         ENGINE_free(engine);
    1493         return;
    1494     }
    1495 
    1496     /*
    1497      * find out what asymmetric crypto algorithms we support
    1498      */
    1499     if (ioctl(fd, CIOCASYMFEAT, &cryptodev_asymfeat) == -1) {
    1500         put_dev_crypto(fd);
    1501         ENGINE_free(engine);
    1502         return;
    1503     }
    1504     put_dev_crypto(fd);
    1505 
    1506     if (!ENGINE_set_id(engine, "cryptodev") ||
    1507         !ENGINE_set_name(engine, "BSD cryptodev engine") ||
    1508         !ENGINE_set_ciphers(engine, cryptodev_engine_ciphers) ||
    1509         !ENGINE_set_digests(engine, cryptodev_engine_digests) ||
    1510         !ENGINE_set_ctrl_function(engine, cryptodev_ctrl) ||
    1511         !ENGINE_set_cmd_defns(engine, cryptodev_defns)) {
    1512         ENGINE_free(engine);
    1513         return;
    1514     }
    1515 
    1516     if (ENGINE_set_RSA(engine, &cryptodev_rsa)) {
    1517         const RSA_METHOD *rsa_meth = RSA_PKCS1_SSLeay();
    1518 
    1519         cryptodev_rsa.bn_mod_exp = rsa_meth->bn_mod_exp;
    1520         cryptodev_rsa.rsa_mod_exp = rsa_meth->rsa_mod_exp;
    1521         cryptodev_rsa.rsa_pub_enc = rsa_meth->rsa_pub_enc;
    1522         cryptodev_rsa.rsa_pub_dec = rsa_meth->rsa_pub_dec;
    1523         cryptodev_rsa.rsa_priv_enc = rsa_meth->rsa_priv_enc;
    1524         cryptodev_rsa.rsa_priv_dec = rsa_meth->rsa_priv_dec;
    1525         if (cryptodev_asymfeat & CRF_MOD_EXP) {
    1526             cryptodev_rsa.bn_mod_exp = cryptodev_bn_mod_exp;
    1527             if (cryptodev_asymfeat & CRF_MOD_EXP_CRT)
    1528                 cryptodev_rsa.rsa_mod_exp = cryptodev_rsa_mod_exp;
    1529             else
    1530                 cryptodev_rsa.rsa_mod_exp = cryptodev_rsa_nocrt_mod_exp;
    1531         }
    1532     }
    1533 
    1534     if (ENGINE_set_DSA(engine, &cryptodev_dsa)) {
    1535         const DSA_METHOD *meth = DSA_OpenSSL();
    1536 
    1537         memcpy(&cryptodev_dsa, meth, sizeof(DSA_METHOD));
    1538         if (cryptodev_asymfeat & CRF_DSA_SIGN)
    1539             cryptodev_dsa.dsa_do_sign = cryptodev_dsa_do_sign;
    1540         if (cryptodev_asymfeat & CRF_MOD_EXP) {
    1541             cryptodev_dsa.bn_mod_exp = cryptodev_dsa_bn_mod_exp;
    1542             cryptodev_dsa.dsa_mod_exp = cryptodev_dsa_dsa_mod_exp;
    1543         }
    1544         if (cryptodev_asymfeat & CRF_DSA_VERIFY)
    1545             cryptodev_dsa.dsa_do_verify = cryptodev_dsa_verify;
    1546     }
    1547 
    1548     if (ENGINE_set_DH(engine, &cryptodev_dh)) {
    1549         const DH_METHOD *dh_meth = DH_OpenSSL();
    1550 
    1551         cryptodev_dh.generate_key = dh_meth->generate_key;
    1552         cryptodev_dh.compute_key = dh_meth->compute_key;
    1553         cryptodev_dh.bn_mod_exp = dh_meth->bn_mod_exp;
    1554         if (cryptodev_asymfeat & CRF_MOD_EXP) {
    1555             cryptodev_dh.bn_mod_exp = cryptodev_mod_exp_dh;
    1556             if (cryptodev_asymfeat & CRF_DH_COMPUTE_KEY)
    1557                 cryptodev_dh.compute_key = cryptodev_dh_compute_key;
    1558         }
    1559     }
    1560 
    1561     ENGINE_add(engine);
    1562     ENGINE_free(engine);
    1563     ERR_clear_error();
    1564 }
    1565 
    1566 #endif                          /* HAVE_CRYPTODEV */
     1476        ENGINE *engine = ENGINE_new();
     1477        int fd;
     1478
     1479        if (engine == NULL)
     1480                return;
     1481        if ((fd = get_dev_crypto()) < 0) {
     1482                ENGINE_free(engine);
     1483                return;
     1484        }
     1485
     1486        /*
     1487         * find out what asymmetric crypto algorithms we support
     1488         */
     1489        if (ioctl(fd, CIOCASYMFEAT, &cryptodev_asymfeat) == -1) {
     1490                put_dev_crypto(fd);
     1491                ENGINE_free(engine);
     1492                return;
     1493        }
     1494        put_dev_crypto(fd);
     1495
     1496        if (!ENGINE_set_id(engine, "cryptodev") ||
     1497            !ENGINE_set_name(engine, "cryptodev engine") ||
     1498            !ENGINE_set_ciphers(engine, cryptodev_engine_ciphers) ||
     1499            !ENGINE_set_digests(engine, cryptodev_engine_digests) || !ENGINE_set_ctrl_function(engine, cryptodev_ctrl) || !ENGINE_set_cmd_defns(engine, cryptodev_defns)) {
     1500                ENGINE_free(engine);
     1501                return;
     1502        }
     1503
     1504        if (ENGINE_set_RSA(engine, &cryptodev_rsa)) {
     1505                const RSA_METHOD *rsa_meth = RSA_PKCS1_SSLeay();
     1506
     1507                cryptodev_rsa.bn_mod_exp = rsa_meth->bn_mod_exp;
     1508                cryptodev_rsa.rsa_mod_exp = rsa_meth->rsa_mod_exp;
     1509                cryptodev_rsa.rsa_pub_enc = rsa_meth->rsa_pub_enc;
     1510                cryptodev_rsa.rsa_pub_dec = rsa_meth->rsa_pub_dec;
     1511                cryptodev_rsa.rsa_priv_enc = rsa_meth->rsa_priv_enc;
     1512                cryptodev_rsa.rsa_priv_dec = rsa_meth->rsa_priv_dec;
     1513                if (cryptodev_asymfeat & CRF_MOD_EXP) {
     1514                        cryptodev_rsa.bn_mod_exp = cryptodev_bn_mod_exp;
     1515                        if (cryptodev_asymfeat & CRF_MOD_EXP_CRT)
     1516                                cryptodev_rsa.rsa_mod_exp = cryptodev_rsa_mod_exp;
     1517                        else
     1518                                cryptodev_rsa.rsa_mod_exp = cryptodev_rsa_nocrt_mod_exp;
     1519                }
     1520        }
     1521
     1522        if (ENGINE_set_DSA(engine, &cryptodev_dsa)) {
     1523                const DSA_METHOD *meth = DSA_OpenSSL();
     1524
     1525                memcpy(&cryptodev_dsa, meth, sizeof(DSA_METHOD));
     1526                if (cryptodev_asymfeat & CRF_DSA_SIGN)
     1527                        cryptodev_dsa.dsa_do_sign = cryptodev_dsa_do_sign;
     1528                if (cryptodev_asymfeat & CRF_MOD_EXP) {
     1529                        cryptodev_dsa.bn_mod_exp = cryptodev_dsa_bn_mod_exp;
     1530                        cryptodev_dsa.dsa_mod_exp = cryptodev_dsa_dsa_mod_exp;
     1531                }
     1532                if (cryptodev_asymfeat & CRF_DSA_VERIFY)
     1533                        cryptodev_dsa.dsa_do_verify = cryptodev_dsa_verify;
     1534        }
     1535
     1536        if (ENGINE_set_DH(engine, &cryptodev_dh)) {
     1537                const DH_METHOD *dh_meth = DH_OpenSSL();
     1538
     1539                cryptodev_dh.generate_key = dh_meth->generate_key;
     1540                cryptodev_dh.compute_key = dh_meth->compute_key;
     1541                cryptodev_dh.bn_mod_exp = dh_meth->bn_mod_exp;
     1542                if (cryptodev_asymfeat & CRF_MOD_EXP) {
     1543                        cryptodev_dh.bn_mod_exp = cryptodev_mod_exp_dh;
     1544                        if (cryptodev_asymfeat & CRF_DH_COMPUTE_KEY)
     1545                                cryptodev_dh.compute_key = cryptodev_dh_compute_key;
     1546                }
     1547        }
     1548
     1549        ENGINE_add(engine);
     1550        ENGINE_free(engine);
     1551        ERR_clear_error();
     1552}
     1553
     1554#endif                          /* HAVE_CRYPTODEV */
Note: See TracChangeset for help on using the changeset viewer.