projects / openwrt / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
openssl: refresh patches
[openwrt/openwrt.git] / package / libs / openssl / patches / 430-e_devcrypto-make-the-dev-crypto-engine-dynamic.patch
1 From 37a5c14aad5051201e4bd18faf1a4b25a824cc30 Mon Sep 17 00:00:00 2001
2 From: Eneas U de Queiroz <cote2004-github@yahoo.com>
3 Date: Tue, 6 Nov 2018 10:57:03 -0200
4 Subject: [PATCH 4/4] e_devcrypto: make the /dev/crypto engine dynamic
5
6 Engine has been moved from crypto/engine/eng_devcrypto.c to
7 engines/e_devcrypto.c.
8
9 Signed-off-by: Eneas U de Queiroz <cote2004-github@yahoo.com>
10
11 --- a/crypto/engine/build.info
12 +++ b/crypto/engine/build.info
13 @@ -6,6 +6,3 @@ SOURCE[../../libcrypto]=\
14 tb_cipher.c tb_digest.c tb_pkmeth.c tb_asnmth.c tb_eckey.c \
15 eng_openssl.c eng_cnf.c eng_dyn.c \
16 eng_rdrand.c
17 -IF[{- !$disabled{devcryptoeng} -}]
18 - SOURCE[../../libcrypto]=eng_devcrypto.c
19 -ENDIF
20 --- a/crypto/init.c
21 +++ b/crypto/init.c
22 @@ -329,18 +329,6 @@ DEFINE_RUN_ONCE_STATIC(ossl_init_engine_
23 engine_load_openssl_int();
24 return 1;
25 }
26 -# ifndef OPENSSL_NO_DEVCRYPTOENG
27 -static CRYPTO_ONCE engine_devcrypto = CRYPTO_ONCE_STATIC_INIT;
28 -DEFINE_RUN_ONCE_STATIC(ossl_init_engine_devcrypto)
29 -{
30 -# ifdef OPENSSL_INIT_DEBUG
31 - fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_devcrypto: "
32 - "engine_load_devcrypto_int()\n");
33 -# endif
34 - engine_load_devcrypto_int();
35 - return 1;
36 -}
37 -# endif
38
39 # ifndef OPENSSL_NO_RDRAND
40 static CRYPTO_ONCE engine_rdrand = CRYPTO_ONCE_STATIC_INIT;
41 @@ -365,6 +353,18 @@ DEFINE_RUN_ONCE_STATIC(ossl_init_engine_
42 return 1;
43 }
44 # ifndef OPENSSL_NO_STATIC_ENGINE
45 +# ifndef OPENSSL_NO_DEVCRYPTOENG
46 +static CRYPTO_ONCE engine_devcrypto = CRYPTO_ONCE_STATIC_INIT;
47 +DEFINE_RUN_ONCE_STATIC(ossl_init_engine_devcrypto)
48 +{
49 +# ifdef OPENSSL_INIT_DEBUG
50 + fprintf(stderr, "OPENSSL_INIT: ossl_init_engine_devcrypto: "
51 + "engine_load_devcrypto_int()\n");
52 +# endif
53 + engine_load_devcrypto_int();
54 + return 1;
55 +}
56 +# endif
57 # if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
58 static CRYPTO_ONCE engine_padlock = CRYPTO_ONCE_STATIC_INIT;
59 DEFINE_RUN_ONCE_STATIC(ossl_init_engine_padlock)
60 @@ -713,11 +713,6 @@ int OPENSSL_init_crypto(uint64_t opts, c
61 if ((opts & OPENSSL_INIT_ENGINE_OPENSSL)
62 && !RUN_ONCE(&engine_openssl, ossl_init_engine_openssl))
63 return 0;
64 -# if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_DEVCRYPTOENG)
65 - if ((opts & OPENSSL_INIT_ENGINE_CRYPTODEV)
66 - && !RUN_ONCE(&engine_devcrypto, ossl_init_engine_devcrypto))
67 - return 0;
68 -# endif
69 # ifndef OPENSSL_NO_RDRAND
70 if ((opts & OPENSSL_INIT_ENGINE_RDRAND)
71 && !RUN_ONCE(&engine_rdrand, ossl_init_engine_rdrand))
72 @@ -727,6 +722,11 @@ int OPENSSL_init_crypto(uint64_t opts, c
73 && !RUN_ONCE(&engine_dynamic, ossl_init_engine_dynamic))
74 return 0;
75 # ifndef OPENSSL_NO_STATIC_ENGINE
76 +# ifndef OPENSSL_NO_DEVCRYPTOENG
77 + if ((opts & OPENSSL_INIT_ENGINE_CRYPTODEV)
78 + && !RUN_ONCE(&engine_devcrypto, ossl_init_engine_devcrypto))
79 + return 0;
80 +# endif
81 # if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
82 if ((opts & OPENSSL_INIT_ENGINE_PADLOCK)
83 && !RUN_ONCE(&engine_padlock, ossl_init_engine_padlock))
84 --- a/engines/build.info
85 +++ b/engines/build.info
86 @@ -10,6 +10,9 @@ IF[{- !$disabled{"engine"} -}]
87 IF[{- !$disabled{afalgeng} -}]
88 SOURCE[../libcrypto]=e_afalg.c
89 ENDIF
90 + IF[{- !$disabled{"devcryptoeng"} -}]
91 + SOURCE[../libcrypto]=e_devcrypto.c
92 + ENDIF
93 ELSE
94 ENGINES=padlock
95 SOURCE[padlock]=e_padlock.c {- $target{padlock_asm_src} -}
96 @@ -27,6 +30,12 @@ IF[{- !$disabled{"engine"} -}]
97 DEPEND[afalg]=../libcrypto
98 INCLUDE[afalg]= ../include
99 ENDIF
100 + IF[{- !$disabled{"devcryptoeng"} -}]
101 + ENGINES=devcrypto
102 + SOURCE[devcrypto]=e_devcrypto.c
103 + DEPEND[devcrypto]=../libcrypto
104 + INCLUDE[devcrypto]=../include
105 + ENDIF
106
107 ENGINES_NO_INST=ossltest dasync
108 SOURCE[dasync]=e_dasync.c
109 --- a/crypto/engine/eng_devcrypto.c
110 +++ /dev/null
111 @@ -1,1264 +0,0 @@
112 -/*
113 - * Copyright 2017-2019 The OpenSSL Project Authors. All Rights Reserved.
114 - *
115 - * Licensed under the OpenSSL license (the "License"). You may not use
116 - * this file except in compliance with the License. You can obtain a copy
117 - * in the file LICENSE in the source distribution or at
118 - * https://www.openssl.org/source/license.html
119 - */
120 -
121 -#include "e_os.h"
122 -#include <string.h>
123 -#include <sys/types.h>
124 -#include <sys/stat.h>
125 -#include <fcntl.h>
126 -#include <sys/ioctl.h>
127 -#include <unistd.h>
128 -#include <assert.h>
129 -
130 -#include <openssl/conf.h>
131 -#include <openssl/evp.h>
132 -#include <openssl/err.h>
133 -#include <openssl/engine.h>
134 -#include <openssl/objects.h>
135 -#include <crypto/cryptodev.h>
136 -
137 -#include "internal/engine.h"
138 -
139 -/* #define ENGINE_DEVCRYPTO_DEBUG */
140 -
141 -#ifdef CRYPTO_ALGORITHM_MIN
142 -# define CHECK_BSD_STYLE_MACROS
143 -#endif
144 -
145 -/*
146 - * ONE global file descriptor for all sessions. This allows operations
147 - * such as digest session data copying (see digest_copy()), but is also
148 - * saner... why re-open /dev/crypto for every session?
149 - */
150 -static int cfd;
151 -#define DEVCRYPTO_REQUIRE_ACCELERATED 0 /* require confirmation of acceleration */
152 -#define DEVCRYPTO_USE_SOFTWARE 1 /* allow software drivers */
153 -#define DEVCRYPTO_REJECT_SOFTWARE 2 /* only disallow confirmed software drivers */
154 -
155 -#define DEVCRYPTO_DEFAULT_USE_SOFDTRIVERS DEVCRYPTO_REJECT_SOFTWARE
156 -static int use_softdrivers = DEVCRYPTO_DEFAULT_USE_SOFDTRIVERS;
157 -
158 -/*
159 - * cipher/digest status & acceleration definitions
160 - * Make sure the defaults are set to 0
161 - */
162 -struct driver_info_st {
163 - enum devcrypto_status_t {
164 - DEVCRYPTO_STATUS_FAILURE = -3, /* unusable for other reason */
165 - DEVCRYPTO_STATUS_NO_CIOCCPHASH = -2, /* hash state copy not supported */
166 - DEVCRYPTO_STATUS_NO_CIOCGSESSION = -1, /* session open failed */
167 - DEVCRYPTO_STATUS_UNKNOWN = 0, /* not tested yet */
168 - DEVCRYPTO_STATUS_USABLE = 1 /* algo can be used */
169 - } status;
170 -
171 - enum devcrypto_accelerated_t {
172 - DEVCRYPTO_NOT_ACCELERATED = -1, /* software implemented */
173 - DEVCRYPTO_ACCELERATION_UNKNOWN = 0, /* acceleration support unkown */
174 - DEVCRYPTO_ACCELERATED = 1 /* hardware accelerated */
175 - } accelerated;
176 -
177 - char *driver_name;
178 -};
179 -
180 -static int clean_devcrypto_session(struct session_op *sess) {
181 - if (ioctl(cfd, CIOCFSESSION, &sess->ses) < 0) {
182 - SYSerr(SYS_F_IOCTL, errno);
183 - return 0;
184 - }
185 - memset(sess, 0, sizeof(struct session_op));
186 - return 1;
187 -}
188 -
189 -/******************************************************************************
190 - *
191 - * Ciphers
192 - *
193 - * Because they all do the same basic operation, we have only one set of
194 - * method functions for them all to share, and a mapping table between
195 - * NIDs and cryptodev IDs, with all the necessary size data.
196 - *
197 - *****/
198 -
199 -struct cipher_ctx {
200 - struct session_op sess;
201 - int op; /* COP_ENCRYPT or COP_DECRYPT */
202 - unsigned long mode; /* EVP_CIPH_*_MODE */
203 -
204 - /* to handle ctr mode being a stream cipher */
205 - unsigned char partial[EVP_MAX_BLOCK_LENGTH];
206 - unsigned int blocksize, num;
207 -};
208 -
209 -static const struct cipher_data_st {
210 - int nid;
211 - int blocksize;
212 - int keylen;
213 - int ivlen;
214 - int flags;
215 - int devcryptoid;
216 -} cipher_data[] = {
217 -#ifndef OPENSSL_NO_DES
218 - { NID_des_cbc, 8, 8, 8, EVP_CIPH_CBC_MODE, CRYPTO_DES_CBC },
219 - { NID_des_ede3_cbc, 8, 24, 8, EVP_CIPH_CBC_MODE, CRYPTO_3DES_CBC },
220 -#endif
221 -#ifndef OPENSSL_NO_BF
222 - { NID_bf_cbc, 8, 16, 8, EVP_CIPH_CBC_MODE, CRYPTO_BLF_CBC },
223 -#endif
224 -#ifndef OPENSSL_NO_CAST
225 - { NID_cast5_cbc, 8, 16, 8, EVP_CIPH_CBC_MODE, CRYPTO_CAST_CBC },
226 -#endif
227 - { NID_aes_128_cbc, 16, 128 / 8, 16, EVP_CIPH_CBC_MODE, CRYPTO_AES_CBC },
228 - { NID_aes_192_cbc, 16, 192 / 8, 16, EVP_CIPH_CBC_MODE, CRYPTO_AES_CBC },
229 - { NID_aes_256_cbc, 16, 256 / 8, 16, EVP_CIPH_CBC_MODE, CRYPTO_AES_CBC },
230 -#ifndef OPENSSL_NO_RC4
231 - { NID_rc4, 1, 16, 0, EVP_CIPH_STREAM_CIPHER, CRYPTO_ARC4 },
232 -#endif
233 -#if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_AES_CTR)
234 - { NID_aes_128_ctr, 16, 128 / 8, 16, EVP_CIPH_CTR_MODE, CRYPTO_AES_CTR },
235 - { NID_aes_192_ctr, 16, 192 / 8, 16, EVP_CIPH_CTR_MODE, CRYPTO_AES_CTR },
236 - { NID_aes_256_ctr, 16, 256 / 8, 16, EVP_CIPH_CTR_MODE, CRYPTO_AES_CTR },
237 -#endif
238 -#if 0 /* Not yet supported */
239 - { NID_aes_128_xts, 16, 128 / 8 * 2, 16, EVP_CIPH_XTS_MODE, CRYPTO_AES_XTS },
240 - { NID_aes_256_xts, 16, 256 / 8 * 2, 16, EVP_CIPH_XTS_MODE, CRYPTO_AES_XTS },
241 -#endif
242 -#if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_AES_ECB)
243 - { NID_aes_128_ecb, 16, 128 / 8, 0, EVP_CIPH_ECB_MODE, CRYPTO_AES_ECB },
244 - { NID_aes_192_ecb, 16, 192 / 8, 0, EVP_CIPH_ECB_MODE, CRYPTO_AES_ECB },
245 - { NID_aes_256_ecb, 16, 256 / 8, 0, EVP_CIPH_ECB_MODE, CRYPTO_AES_ECB },
246 -#endif
247 -#if 0 /* Not yet supported */
248 - { NID_aes_128_gcm, 16, 128 / 8, 16, EVP_CIPH_GCM_MODE, CRYPTO_AES_GCM },
249 - { NID_aes_192_gcm, 16, 192 / 8, 16, EVP_CIPH_GCM_MODE, CRYPTO_AES_GCM },
250 - { NID_aes_256_gcm, 16, 256 / 8, 16, EVP_CIPH_GCM_MODE, CRYPTO_AES_GCM },
251 -#endif
252 -#ifndef OPENSSL_NO_CAMELLIA
253 - { NID_camellia_128_cbc, 16, 128 / 8, 16, EVP_CIPH_CBC_MODE,
254 - CRYPTO_CAMELLIA_CBC },
255 - { NID_camellia_192_cbc, 16, 192 / 8, 16, EVP_CIPH_CBC_MODE,
256 - CRYPTO_CAMELLIA_CBC },
257 - { NID_camellia_256_cbc, 16, 256 / 8, 16, EVP_CIPH_CBC_MODE,
258 - CRYPTO_CAMELLIA_CBC },
259 -#endif
260 -};
261 -
262 -static size_t find_cipher_data_index(int nid)
263 -{
264 - size_t i;
265 -
266 - for (i = 0; i < OSSL_NELEM(cipher_data); i++)
267 - if (nid == cipher_data[i].nid)
268 - return i;
269 - return (size_t)-1;
270 -}
271 -
272 -static size_t get_cipher_data_index(int nid)
273 -{
274 - size_t i = find_cipher_data_index(nid);
275 -
276 - if (i != (size_t)-1)
277 - return i;
278 -
279 - /*
280 - * Code further down must make sure that only NIDs in the table above
281 - * are used. If any other NID reaches this function, there's a grave
282 - * coding error further down.
283 - */
284 - assert("Code that never should be reached" == NULL);
285 - return -1;
286 -}
287 -
288 -static const struct cipher_data_st *get_cipher_data(int nid)
289 -{
290 - return &cipher_data[get_cipher_data_index(nid)];
291 -}
292 -
293 -/*
294 - * Following are the three necessary functions to map OpenSSL functionality
295 - * with cryptodev.
296 - */
297 -
298 -static int cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
299 - const unsigned char *iv, int enc)
300 -{
301 - struct cipher_ctx *cipher_ctx =
302 - (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
303 - const struct cipher_data_st *cipher_d =
304 - get_cipher_data(EVP_CIPHER_CTX_nid(ctx));
305 -
306 - /* cleanup a previous session */
307 - if (cipher_ctx->sess.ses != 0 &&
308 - clean_devcrypto_session(&cipher_ctx->sess) == 0)
309 - return 0;
310 -
311 - cipher_ctx->sess.cipher = cipher_d->devcryptoid;
312 - cipher_ctx->sess.keylen = cipher_d->keylen;
313 - cipher_ctx->sess.key = (void *)key;
314 - cipher_ctx->op = enc ? COP_ENCRYPT : COP_DECRYPT;
315 - cipher_ctx->mode = cipher_d->flags & EVP_CIPH_MODE;
316 - cipher_ctx->blocksize = cipher_d->blocksize;
317 - if (ioctl(cfd, CIOCGSESSION, &cipher_ctx->sess) < 0) {
318 - SYSerr(SYS_F_IOCTL, errno);
319 - return 0;
320 - }
321 -
322 - return 1;
323 -}
324 -
325 -static int cipher_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
326 - const unsigned char *in, size_t inl)
327 -{
328 - struct cipher_ctx *cipher_ctx =
329 - (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
330 - struct crypt_op cryp;
331 - unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
332 -#if !defined(COP_FLAG_WRITE_IV)
333 - unsigned char saved_iv[EVP_MAX_IV_LENGTH];
334 - const unsigned char *ivptr;
335 - size_t nblocks, ivlen;
336 -#endif
337 -
338 - memset(&cryp, 0, sizeof(cryp));
339 - cryp.ses = cipher_ctx->sess.ses;
340 - cryp.len = inl;
341 - cryp.src = (void *)in;
342 - cryp.dst = (void *)out;
343 - cryp.iv = (void *)iv;
344 - cryp.op = cipher_ctx->op;
345 -#if !defined(COP_FLAG_WRITE_IV)
346 - cryp.flags = 0;
347 -
348 - ivlen = EVP_CIPHER_CTX_iv_length(ctx);
349 - if (ivlen > 0)
350 - switch (cipher_ctx->mode) {
351 - case EVP_CIPH_CBC_MODE:
352 - assert(inl >= ivlen);
353 - if (!EVP_CIPHER_CTX_encrypting(ctx)) {
354 - ivptr = in + inl - ivlen;
355 - memcpy(saved_iv, ivptr, ivlen);
356 - }
357 - break;
358 -
359 - case EVP_CIPH_CTR_MODE:
360 - break;
361 -
362 - default: /* should not happen */
363 - return 0;
364 - }
365 -#else
366 - cryp.flags = COP_FLAG_WRITE_IV;
367 -#endif
368 -
369 - if (ioctl(cfd, CIOCCRYPT, &cryp) < 0) {
370 - SYSerr(SYS_F_IOCTL, errno);
371 - return 0;
372 - }
373 -
374 -#if !defined(COP_FLAG_WRITE_IV)
375 - if (ivlen > 0)
376 - switch (cipher_ctx->mode) {
377 - case EVP_CIPH_CBC_MODE:
378 - assert(inl >= ivlen);
379 - if (EVP_CIPHER_CTX_encrypting(ctx))
380 - ivptr = out + inl - ivlen;
381 - else
382 - ivptr = saved_iv;
383 -
384 - memcpy(iv, ivptr, ivlen);
385 - break;
386 -
387 - case EVP_CIPH_CTR_MODE:
388 - nblocks = (inl + cipher_ctx->blocksize - 1)
389 - / cipher_ctx->blocksize;
390 - do {
391 - ivlen--;
392 - nblocks += iv[ivlen];
393 - iv[ivlen] = (uint8_t) nblocks;
394 - nblocks >>= 8;
395 - } while (ivlen);
396 - break;
397 -
398 - default: /* should not happen */
399 - return 0;
400 - }
401 -#endif
402 -
403 - return 1;
404 -}
405 -
406 -static int ctr_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
407 - const unsigned char *in, size_t inl)
408 -{
409 - struct cipher_ctx *cipher_ctx =
410 - (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
411 - size_t nblocks, len;
412 -
413 - /* initial partial block */
414 - while (cipher_ctx->num && inl) {
415 - (*out++) = *(in++) ^ cipher_ctx->partial[cipher_ctx->num];
416 - --inl;
417 - cipher_ctx->num = (cipher_ctx->num + 1) % cipher_ctx->blocksize;
418 - }
419 -
420 - /* full blocks */
421 - if (inl > (unsigned int) cipher_ctx->blocksize) {
422 - nblocks = inl/cipher_ctx->blocksize;
423 - len = nblocks * cipher_ctx->blocksize;
424 - if (cipher_do_cipher(ctx, out, in, len) < 1)
425 - return 0;
426 - inl -= len;
427 - out += len;
428 - in += len;
429 - }
430 -
431 - /* final partial block */
432 - if (inl) {
433 - memset(cipher_ctx->partial, 0, cipher_ctx->blocksize);
434 - if (cipher_do_cipher(ctx, cipher_ctx->partial, cipher_ctx->partial,
435 - cipher_ctx->blocksize) < 1)
436 - return 0;
437 - while (inl--) {
438 - out[cipher_ctx->num] = in[cipher_ctx->num]
439 - ^ cipher_ctx->partial[cipher_ctx->num];
440 - cipher_ctx->num++;
441 - }
442 - }
443 -
444 - return 1;
445 -}
446 -
447 -static int cipher_ctrl(EVP_CIPHER_CTX *ctx, int type, int p1, void* p2)
448 -{
449 - struct cipher_ctx *cipher_ctx =
450 - (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
451 - EVP_CIPHER_CTX *to_ctx = (EVP_CIPHER_CTX *)p2;
452 - struct cipher_ctx *to_cipher_ctx;
453 -
454 - switch (type) {
455 - case EVP_CTRL_COPY:
456 - if (cipher_ctx == NULL)
457 - return 1;
458 - /* when copying the context, a new session needs to be initialized */
459 - to_cipher_ctx =
460 - (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(to_ctx);
461 - memset(&to_cipher_ctx->sess, 0, sizeof(to_cipher_ctx->sess));
462 - return cipher_init(to_ctx, cipher_ctx->sess.key, EVP_CIPHER_CTX_iv(ctx),
463 - (cipher_ctx->op == COP_ENCRYPT));
464 -
465 - case EVP_CTRL_INIT:
466 - memset(&cipher_ctx->sess, 0, sizeof(cipher_ctx->sess));
467 - return 1;
468 -
469 - default:
470 - break;
471 - }
472 -
473 - return -1;
474 -}
475 -
476 -static int cipher_cleanup(EVP_CIPHER_CTX *ctx)
477 -{
478 - struct cipher_ctx *cipher_ctx =
479 - (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
480 -
481 - return clean_devcrypto_session(&cipher_ctx->sess);
482 -}
483 -
484 -/*
485 - * Keep tables of known nids, associated methods, selected ciphers, and driver
486 - * info.
487 - * Note that known_cipher_nids[] isn't necessarily indexed the same way as
488 - * cipher_data[] above, which the other tables are.
489 - */
490 -static int known_cipher_nids[OSSL_NELEM(cipher_data)];
491 -static int known_cipher_nids_amount = -1; /* -1 indicates not yet initialised */
492 -static EVP_CIPHER *known_cipher_methods[OSSL_NELEM(cipher_data)] = { NULL, };
493 -static int selected_ciphers[OSSL_NELEM(cipher_data)];
494 -static struct driver_info_st cipher_driver_info[OSSL_NELEM(cipher_data)];
495 -
496 -
497 -static int devcrypto_test_cipher(size_t cipher_data_index)
498 -{
499 - return (cipher_driver_info[cipher_data_index].status == DEVCRYPTO_STATUS_USABLE
500 - && selected_ciphers[cipher_data_index] == 1
501 - && (cipher_driver_info[cipher_data_index].accelerated
502 - == DEVCRYPTO_ACCELERATED
503 - || use_softdrivers == DEVCRYPTO_USE_SOFTWARE
504 - || (cipher_driver_info[cipher_data_index].accelerated
505 - != DEVCRYPTO_NOT_ACCELERATED
506 - && use_softdrivers == DEVCRYPTO_REJECT_SOFTWARE)));
507 -}
508 -
509 -static void prepare_cipher_methods(void)
510 -{
511 - size_t i;
512 - struct session_op sess;
513 - unsigned long cipher_mode;
514 -#ifdef CIOCGSESSINFO
515 - struct session_info_op siop;
516 -#endif
517 -
518 - memset(&cipher_driver_info, 0, sizeof(cipher_driver_info));
519 -
520 - memset(&sess, 0, sizeof(sess));
521 - sess.key = (void *)"01234567890123456789012345678901234567890123456789";
522 -
523 - for (i = 0, known_cipher_nids_amount = 0;
524 - i < OSSL_NELEM(cipher_data); i++) {
525 -
526 - selected_ciphers[i] = 1;
527 - /*
528 - * Check that the cipher is usable
529 - */
530 - sess.cipher = cipher_data[i].devcryptoid;
531 - sess.keylen = cipher_data[i].keylen;
532 - if (ioctl(cfd, CIOCGSESSION, &sess) < 0) {
533 - cipher_driver_info[i].status = DEVCRYPTO_STATUS_NO_CIOCGSESSION;
534 - continue;
535 - }
536 -
537 - cipher_mode = cipher_data[i].flags & EVP_CIPH_MODE;
538 -
539 - if ((known_cipher_methods[i] =
540 - EVP_CIPHER_meth_new(cipher_data[i].nid,
541 - cipher_mode == EVP_CIPH_CTR_MODE ? 1 :
542 - cipher_data[i].blocksize,
543 - cipher_data[i].keylen)) == NULL
544 - || !EVP_CIPHER_meth_set_iv_length(known_cipher_methods[i],
545 - cipher_data[i].ivlen)
546 - || !EVP_CIPHER_meth_set_flags(known_cipher_methods[i],
547 - cipher_data[i].flags
548 - | EVP_CIPH_CUSTOM_COPY
549 - | EVP_CIPH_CTRL_INIT
550 - | EVP_CIPH_FLAG_DEFAULT_ASN1)
551 - || !EVP_CIPHER_meth_set_init(known_cipher_methods[i], cipher_init)
552 - || !EVP_CIPHER_meth_set_do_cipher(known_cipher_methods[i],
553 - cipher_mode == EVP_CIPH_CTR_MODE ?
554 - ctr_do_cipher :
555 - cipher_do_cipher)
556 - || !EVP_CIPHER_meth_set_ctrl(known_cipher_methods[i], cipher_ctrl)
557 - || !EVP_CIPHER_meth_set_cleanup(known_cipher_methods[i],
558 - cipher_cleanup)
559 - || !EVP_CIPHER_meth_set_impl_ctx_size(known_cipher_methods[i],
560 - sizeof(struct cipher_ctx))) {
561 - cipher_driver_info[i].status = DEVCRYPTO_STATUS_FAILURE;
562 - EVP_CIPHER_meth_free(known_cipher_methods[i]);
563 - known_cipher_methods[i] = NULL;
564 - } else {
565 - cipher_driver_info[i].status = DEVCRYPTO_STATUS_USABLE;
566 -#ifdef CIOCGSESSINFO
567 - siop.ses = sess.ses;
568 - if (ioctl(cfd, CIOCGSESSINFO, &siop) < 0) {
569 - cipher_driver_info[i].accelerated = DEVCRYPTO_ACCELERATION_UNKNOWN;
570 - } else {
571 - cipher_driver_info[i].driver_name =
572 - OPENSSL_strndup(siop.cipher_info.cra_driver_name,
573 - CRYPTODEV_MAX_ALG_NAME);
574 - if (!(siop.flags & SIOP_FLAG_KERNEL_DRIVER_ONLY))
575 - cipher_driver_info[i].accelerated = DEVCRYPTO_NOT_ACCELERATED;
576 - else
577 - cipher_driver_info[i].accelerated = DEVCRYPTO_ACCELERATED;
578 - }
579 -#endif /* CIOCGSESSINFO */
580 - }
581 - ioctl(cfd, CIOCFSESSION, &sess.ses);
582 - if (devcrypto_test_cipher(i)) {
583 - known_cipher_nids[known_cipher_nids_amount++] =
584 - cipher_data[i].nid;
585 - }
586 - }
587 -}
588 -
589 -static void rebuild_known_cipher_nids(ENGINE *e)
590 -{
591 - size_t i;
592 -
593 - for (i = 0, known_cipher_nids_amount = 0; i < OSSL_NELEM(cipher_data); i++) {
594 - if (devcrypto_test_cipher(i))
595 - known_cipher_nids[known_cipher_nids_amount++] = cipher_data[i].nid;
596 - }
597 - ENGINE_unregister_ciphers(e);
598 - ENGINE_register_ciphers(e);
599 -}
600 -
601 -static const EVP_CIPHER *get_cipher_method(int nid)
602 -{
603 - size_t i = get_cipher_data_index(nid);
604 -
605 - if (i == (size_t)-1)
606 - return NULL;
607 - return known_cipher_methods[i];
608 -}
609 -
610 -static int get_cipher_nids(const int **nids)
611 -{
612 - *nids = known_cipher_nids;
613 - return known_cipher_nids_amount;
614 -}
615 -
616 -static void destroy_cipher_method(int nid)
617 -{
618 - size_t i = get_cipher_data_index(nid);
619 -
620 - EVP_CIPHER_meth_free(known_cipher_methods[i]);
621 - known_cipher_methods[i] = NULL;
622 -}
623 -
624 -static void destroy_all_cipher_methods(void)
625 -{
626 - size_t i;
627 -
628 - for (i = 0; i < OSSL_NELEM(cipher_data); i++) {
629 - destroy_cipher_method(cipher_data[i].nid);
630 - OPENSSL_free(cipher_driver_info[i].driver_name);
631 - cipher_driver_info[i].driver_name = NULL;
632 - }
633 -}
634 -
635 -static int devcrypto_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
636 - const int **nids, int nid)
637 -{
638 - if (cipher == NULL)
639 - return get_cipher_nids(nids);
640 -
641 - *cipher = get_cipher_method(nid);
642 -
643 - return *cipher != NULL;
644 -}
645 -
646 -static void devcrypto_select_all_ciphers(int *cipher_list)
647 -{
648 - size_t i;
649 -
650 - for (i = 0; i < OSSL_NELEM(cipher_data); i++)
651 - cipher_list[i] = 1;
652 -}
653 -
654 -static int cryptodev_select_cipher_cb(const char *str, int len, void *usr)
655 -{
656 - int *cipher_list = (int *)usr;
657 - char *name;
658 - const EVP_CIPHER *EVP;
659 - size_t i;
660 -
661 - if (len == 0)
662 - return 1;
663 - if (usr == NULL || (name = OPENSSL_strndup(str, len)) == NULL)
664 - return 0;
665 - EVP = EVP_get_cipherbyname(name);
666 - if (EVP == NULL)
667 - fprintf(stderr, "devcrypto: unknown cipher %s\n", name);
668 - else if ((i = find_cipher_data_index(EVP_CIPHER_nid(EVP))) != (size_t)-1)
669 - cipher_list[i] = 1;
670 - else
671 - fprintf(stderr, "devcrypto: cipher %s not available\n", name);
672 - OPENSSL_free(name);
673 - return 1;
674 -}
675 -
676 -static void dump_cipher_info(void)
677 -{
678 - size_t i;
679 - const char *name;
680 -
681 - fprintf (stderr, "Information about ciphers supported by the /dev/crypto"
682 - " engine:\n");
683 -#ifndef CIOCGSESSINFO
684 - fprintf(stderr, "CIOCGSESSINFO (session info call) unavailable\n");
685 -#endif
686 - for (i = 0; i < OSSL_NELEM(cipher_data); i++) {
687 - name = OBJ_nid2sn(cipher_data[i].nid);
688 - fprintf (stderr, "Cipher %s, NID=%d, /dev/crypto info: id=%d, ",
689 - name ? name : "unknown", cipher_data[i].nid,
690 - cipher_data[i].devcryptoid);
691 - if (cipher_driver_info[i].status == DEVCRYPTO_STATUS_NO_CIOCGSESSION ) {
692 - fprintf (stderr, "CIOCGSESSION (session open call) failed\n");
693 - continue;
694 - }
695 - fprintf (stderr, "driver=%s ", cipher_driver_info[i].driver_name ?
696 - cipher_driver_info[i].driver_name : "unknown");
697 - if (cipher_driver_info[i].accelerated == DEVCRYPTO_ACCELERATED)
698 - fprintf(stderr, "(hw accelerated)");
699 - else if (cipher_driver_info[i].accelerated == DEVCRYPTO_NOT_ACCELERATED)
700 - fprintf(stderr, "(software)");
701 - else
702 - fprintf(stderr, "(acceleration status unknown)");
703 - if (cipher_driver_info[i].status == DEVCRYPTO_STATUS_FAILURE)
704 - fprintf (stderr, ". Cipher setup failed");
705 - fprintf(stderr, "\n");
706 - }
707 - fprintf(stderr, "\n");
708 -}
709 -
710 -/*
711 - * We only support digests if the cryptodev implementation supports multiple
712 - * data updates and session copying. Otherwise, we would be forced to maintain
713 - * a cache, which is perilous if there's a lot of data coming in (if someone
714 - * wants to checksum an OpenSSL tarball, for example).
715 - */
716 -#if defined(CIOCCPHASH) && defined(COP_FLAG_UPDATE) && defined(COP_FLAG_FINAL)
717 -#define IMPLEMENT_DIGEST
718 -
719 -/******************************************************************************
720 - *
721 - * Digests
722 - *
723 - * Because they all do the same basic operation, we have only one set of
724 - * method functions for them all to share, and a mapping table between
725 - * NIDs and cryptodev IDs, with all the necessary size data.
726 - *
727 - *****/
728 -
729 -struct digest_ctx {
730 - struct session_op sess;
731 - /* This signals that the init function was called, not that it succeeded. */
732 - int init_called;
733 - unsigned char digest_res[HASH_MAX_LEN];
734 -};
735 -
736 -static const struct digest_data_st {
737 - int nid;
738 - int blocksize;
739 - int digestlen;
740 - int devcryptoid;
741 -} digest_data[] = {
742 -#ifndef OPENSSL_NO_MD5
743 - { NID_md5, /* MD5_CBLOCK */ 64, 16, CRYPTO_MD5 },
744 -#endif
745 - { NID_sha1, SHA_CBLOCK, 20, CRYPTO_SHA1 },
746 -#ifndef OPENSSL_NO_RMD160
747 -# if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_RIPEMD160)
748 - { NID_ripemd160, /* RIPEMD160_CBLOCK */ 64, 20, CRYPTO_RIPEMD160 },
749 -# endif
750 -#endif
751 -#if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_SHA2_224)
752 - { NID_sha224, SHA256_CBLOCK, 224 / 8, CRYPTO_SHA2_224 },
753 -#endif
754 -#if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_SHA2_256)
755 - { NID_sha256, SHA256_CBLOCK, 256 / 8, CRYPTO_SHA2_256 },
756 -#endif
757 -#if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_SHA2_384)
758 - { NID_sha384, SHA512_CBLOCK, 384 / 8, CRYPTO_SHA2_384 },
759 -#endif
760 -#if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_SHA2_512)
761 - { NID_sha512, SHA512_CBLOCK, 512 / 8, CRYPTO_SHA2_512 },
762 -#endif
763 -};
764 -
765 -static size_t find_digest_data_index(int nid)
766 -{
767 - size_t i;
768 -
769 - for (i = 0; i < OSSL_NELEM(digest_data); i++)
770 - if (nid == digest_data[i].nid)
771 - return i;
772 - return (size_t)-1;
773 -}
774 -
775 -static size_t get_digest_data_index(int nid)
776 -{
777 - size_t i = find_digest_data_index(nid);
778 -
779 - if (i != (size_t)-1)
780 - return i;
781 -
782 - /*
783 - * Code further down must make sure that only NIDs in the table above
784 - * are used. If any other NID reaches this function, there's a grave
785 - * coding error further down.
786 - */
787 - assert("Code that never should be reached" == NULL);
788 - return -1;
789 -}
790 -
791 -static const struct digest_data_st *get_digest_data(int nid)
792 -{
793 - return &digest_data[get_digest_data_index(nid)];
794 -}
795 -
796 -/*
797 - * Following are the five necessary functions to map OpenSSL functionality
798 - * with cryptodev: init, update, final, cleanup, and copy.
799 - */
800 -
801 -static int digest_init(EVP_MD_CTX *ctx)
802 -{
803 - struct digest_ctx *digest_ctx =
804 - (struct digest_ctx *)EVP_MD_CTX_md_data(ctx);
805 - const struct digest_data_st *digest_d =
806 - get_digest_data(EVP_MD_CTX_type(ctx));
807 -
808 - digest_ctx->init_called = 1;
809 -
810 - memset(&digest_ctx->sess, 0, sizeof(digest_ctx->sess));
811 - digest_ctx->sess.mac = digest_d->devcryptoid;
812 - if (ioctl(cfd, CIOCGSESSION, &digest_ctx->sess) < 0) {
813 - SYSerr(SYS_F_IOCTL, errno);
814 - return 0;
815 - }
816 -
817 - return 1;
818 -}
819 -
820 -static int digest_op(struct digest_ctx *ctx, const void *src, size_t srclen,
821 - void *res, unsigned int flags)
822 -{
823 - struct crypt_op cryp;
824 -
825 - memset(&cryp, 0, sizeof(cryp));
826 - cryp.ses = ctx->sess.ses;
827 - cryp.len = srclen;
828 - cryp.src = (void *)src;
829 - cryp.dst = NULL;
830 - cryp.mac = res;
831 - cryp.flags = flags;
832 - return ioctl(cfd, CIOCCRYPT, &cryp);
833 -}
834 -
835 -static int digest_update(EVP_MD_CTX *ctx, const void *data, size_t count)
836 -{
837 - struct digest_ctx *digest_ctx =
838 - (struct digest_ctx *)EVP_MD_CTX_md_data(ctx);
839 -
840 - if (count == 0)
841 - return 1;
842 -
843 - if (digest_ctx == NULL)
844 - return 0;
845 -
846 - if (EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_ONESHOT)) {
847 - if (digest_op(digest_ctx, data, count, digest_ctx->digest_res, 0) >= 0)
848 - return 1;
849 - } else if (digest_op(digest_ctx, data, count, NULL, COP_FLAG_UPDATE) >= 0) {
850 - return 1;
851 - }
852 -
853 - SYSerr(SYS_F_IOCTL, errno);
854 - return 0;
855 -}
856 -
857 -static int digest_final(EVP_MD_CTX *ctx, unsigned char *md)
858 -{
859 - struct digest_ctx *digest_ctx =
860 - (struct digest_ctx *)EVP_MD_CTX_md_data(ctx);
861 -
862 - if (md == NULL || digest_ctx == NULL)
863 - return 0;
864 -
865 - if (EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_ONESHOT)) {
866 - memcpy(md, digest_ctx->digest_res, EVP_MD_CTX_size(ctx));
867 - } else if (digest_op(digest_ctx, NULL, 0, md, COP_FLAG_FINAL) < 0) {
868 - SYSerr(SYS_F_IOCTL, errno);
869 - return 0;
870 - }
871 -
872 - return 1;
873 -}
874 -
875 -static int digest_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from)
876 -{
877 - struct digest_ctx *digest_from =
878 - (struct digest_ctx *)EVP_MD_CTX_md_data(from);
879 - struct digest_ctx *digest_to =
880 - (struct digest_ctx *)EVP_MD_CTX_md_data(to);
881 - struct cphash_op cphash;
882 -
883 - if (digest_from == NULL || digest_from->init_called != 1)
884 - return 1;
885 -
886 - if (!digest_init(to)) {
887 - SYSerr(SYS_F_IOCTL, errno);
888 - return 0;
889 - }
890 -
891 - cphash.src_ses = digest_from->sess.ses;
892 - cphash.dst_ses = digest_to->sess.ses;
893 - if (ioctl(cfd, CIOCCPHASH, &cphash) < 0) {
894 - SYSerr(SYS_F_IOCTL, errno);
895 - return 0;
896 - }
897 - return 1;
898 -}
899 -
900 -static int digest_cleanup(EVP_MD_CTX *ctx)
901 -{
902 - struct digest_ctx *digest_ctx =
903 - (struct digest_ctx *)EVP_MD_CTX_md_data(ctx);
904 -
905 - if (digest_ctx == NULL)
906 - return 1;
907 -
908 - return clean_devcrypto_session(&digest_ctx->sess);
909 -}
910 -
911 -/*
912 - * Keep tables of known nids, associated methods, selected digests, and
913 - * driver info.
914 - * Note that known_digest_nids[] isn't necessarily indexed the same way as
915 - * digest_data[] above, which the other tables are.
916 - */
917 -static int known_digest_nids[OSSL_NELEM(digest_data)];
918 -static int known_digest_nids_amount = -1; /* -1 indicates not yet initialised */
919 -static EVP_MD *known_digest_methods[OSSL_NELEM(digest_data)] = { NULL, };
920 -static int selected_digests[OSSL_NELEM(digest_data)];
921 -static struct driver_info_st digest_driver_info[OSSL_NELEM(digest_data)];
922 -
923 -static int devcrypto_test_digest(size_t digest_data_index)
924 -{
925 - return (digest_driver_info[digest_data_index].status == DEVCRYPTO_STATUS_USABLE
926 - && selected_digests[digest_data_index] == 1
927 - && (digest_driver_info[digest_data_index].accelerated
928 - == DEVCRYPTO_ACCELERATED
929 - || use_softdrivers == DEVCRYPTO_USE_SOFTWARE
930 - || (digest_driver_info[digest_data_index].accelerated
931 - != DEVCRYPTO_NOT_ACCELERATED
932 - && use_softdrivers == DEVCRYPTO_REJECT_SOFTWARE)));
933 -}
934 -
935 -static void rebuild_known_digest_nids(ENGINE *e)
936 -{
937 - size_t i;
938 -
939 - for (i = 0, known_digest_nids_amount = 0; i < OSSL_NELEM(digest_data); i++) {
940 - if (devcrypto_test_digest(i))
941 - known_digest_nids[known_digest_nids_amount++] = digest_data[i].nid;
942 - }
943 - ENGINE_unregister_digests(e);
944 - ENGINE_register_digests(e);
945 -}
946 -
947 -static void prepare_digest_methods(void)
948 -{
949 - size_t i;
950 - struct session_op sess1, sess2;
951 -#ifdef CIOCGSESSINFO
952 - struct session_info_op siop;
953 -#endif
954 - struct cphash_op cphash;
955 -
956 - memset(&digest_driver_info, 0, sizeof(digest_driver_info));
957 -
958 - memset(&sess1, 0, sizeof(sess1));
959 - memset(&sess2, 0, sizeof(sess2));
960 -
961 - for (i = 0, known_digest_nids_amount = 0; i < OSSL_NELEM(digest_data);
962 - i++) {
963 -
964 - selected_digests[i] = 1;
965 -
966 - /*
967 - * Check that the digest is usable
968 - */
969 - sess1.mac = digest_data[i].devcryptoid;
970 - sess2.ses = 0;
971 - if (ioctl(cfd, CIOCGSESSION, &sess1) < 0) {
972 - digest_driver_info[i].status = DEVCRYPTO_STATUS_NO_CIOCGSESSION;
973 - goto finish;
974 - }
975 -
976 -#ifdef CIOCGSESSINFO
977 - /* gather hardware acceleration info from the driver */
978 - siop.ses = sess1.ses;
979 - if (ioctl(cfd, CIOCGSESSINFO, &siop) < 0) {
980 - digest_driver_info[i].accelerated = DEVCRYPTO_ACCELERATION_UNKNOWN;
981 - } else {
982 - digest_driver_info[i].driver_name =
983 - OPENSSL_strndup(siop.hash_info.cra_driver_name,
984 - CRYPTODEV_MAX_ALG_NAME);
985 - if (siop.flags & SIOP_FLAG_KERNEL_DRIVER_ONLY)
986 - digest_driver_info[i].accelerated = DEVCRYPTO_ACCELERATED;
987 - else
988 - digest_driver_info[i].accelerated = DEVCRYPTO_NOT_ACCELERATED;
989 - }
990 -#endif
991 -
992 - /* digest must be capable of hash state copy */
993 - sess2.mac = sess1.mac;
994 - if (ioctl(cfd, CIOCGSESSION, &sess2) < 0) {
995 - digest_driver_info[i].status = DEVCRYPTO_STATUS_FAILURE;
996 - goto finish;
997 - }
998 - cphash.src_ses = sess1.ses;
999 - cphash.dst_ses = sess2.ses;
1000 - if (ioctl(cfd, CIOCCPHASH, &cphash) < 0) {
1001 - digest_driver_info[i].status = DEVCRYPTO_STATUS_NO_CIOCCPHASH;
1002 - goto finish;
1003 - }
1004 - if ((known_digest_methods[i] = EVP_MD_meth_new(digest_data[i].nid,
1005 - NID_undef)) == NULL
1006 - || !EVP_MD_meth_set_input_blocksize(known_digest_methods[i],
1007 - digest_data[i].blocksize)
1008 - || !EVP_MD_meth_set_result_size(known_digest_methods[i],
1009 - digest_data[i].digestlen)
1010 - || !EVP_MD_meth_set_init(known_digest_methods[i], digest_init)
1011 - || !EVP_MD_meth_set_update(known_digest_methods[i], digest_update)
1012 - || !EVP_MD_meth_set_final(known_digest_methods[i], digest_final)
1013 - || !EVP_MD_meth_set_copy(known_digest_methods[i], digest_copy)
1014 - || !EVP_MD_meth_set_cleanup(known_digest_methods[i], digest_cleanup)
1015 - || !EVP_MD_meth_set_app_datasize(known_digest_methods[i],
1016 - sizeof(struct digest_ctx))) {
1017 - digest_driver_info[i].status = DEVCRYPTO_STATUS_FAILURE;
1018 - EVP_MD_meth_free(known_digest_methods[i]);
1019 - known_digest_methods[i] = NULL;
1020 - goto finish;
1021 - }
1022 - digest_driver_info[i].status = DEVCRYPTO_STATUS_USABLE;
1023 -finish:
1024 - ioctl(cfd, CIOCFSESSION, &sess1.ses);
1025 - if (sess2.ses != 0)
1026 - ioctl(cfd, CIOCFSESSION, &sess2.ses);
1027 - if (devcrypto_test_digest(i))
1028 - known_digest_nids[known_digest_nids_amount++] = digest_data[i].nid;
1029 - }
1030 -}
1031 -
1032 -static const EVP_MD *get_digest_method(int nid)
1033 -{
1034 - size_t i = get_digest_data_index(nid);
1035 -
1036 - if (i == (size_t)-1)
1037 - return NULL;
1038 - return known_digest_methods[i];
1039 -}
1040 -
1041 -static int get_digest_nids(const int **nids)
1042 -{
1043 - *nids = known_digest_nids;
1044 - return known_digest_nids_amount;
1045 -}
1046 -
1047 -static void destroy_digest_method(int nid)
1048 -{
1049 - size_t i = get_digest_data_index(nid);
1050 -
1051 - EVP_MD_meth_free(known_digest_methods[i]);
1052 - known_digest_methods[i] = NULL;
1053 -}
1054 -
1055 -static void destroy_all_digest_methods(void)
1056 -{
1057 - size_t i;
1058 -
1059 - for (i = 0; i < OSSL_NELEM(digest_data); i++) {
1060 - destroy_digest_method(digest_data[i].nid);
1061 - OPENSSL_free(digest_driver_info[i].driver_name);
1062 - digest_driver_info[i].driver_name = NULL;
1063 - }
1064 -}
1065 -
1066 -static int devcrypto_digests(ENGINE *e, const EVP_MD **digest,
1067 - const int **nids, int nid)
1068 -{
1069 - if (digest == NULL)
1070 - return get_digest_nids(nids);
1071 -
1072 - *digest = get_digest_method(nid);
1073 -
1074 - return *digest != NULL;
1075 -}
1076 -
1077 -static void devcrypto_select_all_digests(int *digest_list)
1078 -{
1079 - size_t i;
1080 -
1081 - for (i = 0; i < OSSL_NELEM(digest_data); i++)
1082 - digest_list[i] = 1;
1083 -}
1084 -
1085 -static int cryptodev_select_digest_cb(const char *str, int len, void *usr)
1086 -{
1087 - int *digest_list = (int *)usr;
1088 - char *name;
1089 - const EVP_MD *EVP;
1090 - size_t i;
1091 -
1092 - if (len == 0)
1093 - return 1;
1094 - if (usr == NULL || (name = OPENSSL_strndup(str, len)) == NULL)
1095 - return 0;
1096 - EVP = EVP_get_digestbyname(name);
1097 - if (EVP == NULL)
1098 - fprintf(stderr, "devcrypto: unknown digest %s\n", name);
1099 - else if ((i = find_digest_data_index(EVP_MD_type(EVP))) != (size_t)-1)
1100 - digest_list[i] = 1;
1101 - else
1102 - fprintf(stderr, "devcrypto: digest %s not available\n", name);
1103 - OPENSSL_free(name);
1104 - return 1;
1105 -}
1106 -
1107 -static void dump_digest_info(void)
1108 -{
1109 - size_t i;
1110 - const char *name;
1111 -
1112 - fprintf (stderr, "Information about digests supported by the /dev/crypto"
1113 - " engine:\n");
1114 -#ifndef CIOCGSESSINFO
1115 - fprintf(stderr, "CIOCGSESSINFO (session info call) unavailable\n");
1116 -#endif
1117 -
1118 - for (i = 0; i < OSSL_NELEM(digest_data); i++) {
1119 - name = OBJ_nid2sn(digest_data[i].nid);
1120 - fprintf (stderr, "Digest %s, NID=%d, /dev/crypto info: id=%d, driver=%s",
1121 - name ? name : "unknown", digest_data[i].nid,
1122 - digest_data[i].devcryptoid,
1123 - digest_driver_info[i].driver_name ? digest_driver_info[i].driver_name : "unknown");
1124 - if (digest_driver_info[i].status == DEVCRYPTO_STATUS_NO_CIOCGSESSION) {
1125 - fprintf (stderr, ". CIOCGSESSION (session open) failed\n");
1126 - continue;
1127 - }
1128 - if (digest_driver_info[i].accelerated == DEVCRYPTO_ACCELERATED)
1129 - fprintf(stderr, " (hw accelerated)");
1130 - else if (digest_driver_info[i].accelerated == DEVCRYPTO_NOT_ACCELERATED)
1131 - fprintf(stderr, " (software)");
1132 - else
1133 - fprintf(stderr, " (acceleration status unknown)");
1134 - if (cipher_driver_info[i].status == DEVCRYPTO_STATUS_FAILURE)
1135 - fprintf (stderr, ". Cipher setup failed\n");
1136 - else if (digest_driver_info[i].status == DEVCRYPTO_STATUS_NO_CIOCCPHASH)
1137 - fprintf(stderr, ", CIOCCPHASH failed\n");
1138 - else
1139 - fprintf(stderr, ", CIOCCPHASH capable\n");
1140 - }
1141 - fprintf(stderr, "\n");
1142 -}
1143 -
1144 -#endif
1145 -
1146 -/******************************************************************************
1147 - *
1148 - * CONTROL COMMANDS
1149 - *
1150 - *****/
1151 -
1152 -#define DEVCRYPTO_CMD_USE_SOFTDRIVERS ENGINE_CMD_BASE
1153 -#define DEVCRYPTO_CMD_CIPHERS (ENGINE_CMD_BASE + 1)
1154 -#define DEVCRYPTO_CMD_DIGESTS (ENGINE_CMD_BASE + 2)
1155 -#define DEVCRYPTO_CMD_DUMP_INFO (ENGINE_CMD_BASE + 3)
1156 -
1157 -/* Helper macros for CPP string composition */
1158 -#ifndef OPENSSL_MSTR
1159 -# define OPENSSL_MSTR_HELPER(x) #x
1160 -# define OPENSSL_MSTR(x) OPENSSL_MSTR_HELPER(x)
1161 -#endif
1162 -
1163 -static const ENGINE_CMD_DEFN devcrypto_cmds[] = {
1164 -#ifdef CIOCGSESSINFO
1165 - {DEVCRYPTO_CMD_USE_SOFTDRIVERS,
1166 - "USE_SOFTDRIVERS",
1167 - "specifies whether to use software (not accelerated) drivers ("
1168 - OPENSSL_MSTR(DEVCRYPTO_REQUIRE_ACCELERATED) "=use only accelerated drivers, "
1169 - OPENSSL_MSTR(DEVCRYPTO_USE_SOFTWARE) "=allow all drivers, "
1170 - OPENSSL_MSTR(DEVCRYPTO_REJECT_SOFTWARE)
1171 - "=use if acceleration can't be determined) [default="
1172 - OPENSSL_MSTR(DEVCRYPTO_DEFAULT_USE_SOFDTRIVERS) "]",
1173 - ENGINE_CMD_FLAG_NUMERIC},
1174 -#endif
1175 -
1176 - {DEVCRYPTO_CMD_CIPHERS,
1177 - "CIPHERS",
1178 - "either ALL, NONE, or a comma-separated list of ciphers to enable [default=ALL]",
1179 - ENGINE_CMD_FLAG_STRING},
1180 -
1181 -#ifdef IMPLEMENT_DIGEST
1182 - {DEVCRYPTO_CMD_DIGESTS,
1183 - "DIGESTS",
1184 - "either ALL, NONE, or a comma-separated list of digests to enable [default=ALL]",
1185 - ENGINE_CMD_FLAG_STRING},
1186 -#endif
1187 -
1188 - {DEVCRYPTO_CMD_DUMP_INFO,
1189 - "DUMP_INFO",
1190 - "dump info about each algorithm to stderr; use 'openssl engine -pre DUMP_INFO devcrypto'",
1191 - ENGINE_CMD_FLAG_NO_INPUT},
1192 -
1193 - {0, NULL, NULL, 0}
1194 -};
1195 -
1196 -static int devcrypto_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void))
1197 -{
1198 - int *new_list;
1199 - switch (cmd) {
1200 -#ifdef CIOCGSESSINFO
1201 - case DEVCRYPTO_CMD_USE_SOFTDRIVERS:
1202 - switch (i) {
1203 - case DEVCRYPTO_REQUIRE_ACCELERATED:
1204 - case DEVCRYPTO_USE_SOFTWARE:
1205 - case DEVCRYPTO_REJECT_SOFTWARE:
1206 - break;
1207 - default:
1208 - fprintf(stderr, "devcrypto: invalid value (%ld) for USE_SOFTDRIVERS\n", i);
1209 - return 0;
1210 - }
1211 - if (use_softdrivers == i)
1212 - return 1;
1213 - use_softdrivers = i;
1214 -#ifdef IMPLEMENT_DIGEST
1215 - rebuild_known_digest_nids(e);
1216 -#endif
1217 - rebuild_known_cipher_nids(e);
1218 - return 1;
1219 -#endif /* CIOCGSESSINFO */
1220 -
1221 - case DEVCRYPTO_CMD_CIPHERS:
1222 - if (p == NULL)
1223 - return 1;
1224 - if (strcasecmp((const char *)p, "ALL") == 0) {
1225 - devcrypto_select_all_ciphers(selected_ciphers);
1226 - } else if (strcasecmp((const char*)p, "NONE") == 0) {
1227 - memset(selected_ciphers, 0, sizeof(selected_ciphers));
1228 - } else {
1229 - new_list=OPENSSL_zalloc(sizeof(selected_ciphers));
1230 - if (!CONF_parse_list(p, ',', 1, cryptodev_select_cipher_cb, new_list)) {
1231 - OPENSSL_free(new_list);
1232 - return 0;
1233 - }
1234 - memcpy(selected_ciphers, new_list, sizeof(selected_ciphers));
1235 - OPENSSL_free(new_list);
1236 - }
1237 - rebuild_known_cipher_nids(e);
1238 - return 1;
1239 -
1240 -#ifdef IMPLEMENT_DIGEST
1241 - case DEVCRYPTO_CMD_DIGESTS:
1242 - if (p == NULL)
1243 - return 1;
1244 - if (strcasecmp((const char *)p, "ALL") == 0) {
1245 - devcrypto_select_all_digests(selected_digests);
1246 - } else if (strcasecmp((const char*)p, "NONE") == 0) {
1247 - memset(selected_digests, 0, sizeof(selected_digests));
1248 - } else {
1249 - new_list=OPENSSL_zalloc(sizeof(selected_digests));
1250 - if (!CONF_parse_list(p, ',', 1, cryptodev_select_digest_cb, new_list)) {
1251 - OPENSSL_free(new_list);
1252 - return 0;
1253 - }
1254 - memcpy(selected_digests, new_list, sizeof(selected_digests));
1255 - OPENSSL_free(new_list);
1256 - }
1257 - rebuild_known_digest_nids(e);
1258 - return 1;
1259 -#endif /* IMPLEMENT_DIGEST */
1260 -
1261 - case DEVCRYPTO_CMD_DUMP_INFO:
1262 - dump_cipher_info();
1263 -#ifdef IMPLEMENT_DIGEST
1264 - dump_digest_info();
1265 -#endif
1266 - return 1;
1267 -
1268 - default:
1269 - break;
1270 - }
1271 - return 0;
1272 -}
1273 -
1274 -/******************************************************************************
1275 - *
1276 - * LOAD / UNLOAD
1277 - *
1278 - *****/
1279 -
1280 -static int devcrypto_unload(ENGINE *e)
1281 -{
1282 - destroy_all_cipher_methods();
1283 -#ifdef IMPLEMENT_DIGEST
1284 - destroy_all_digest_methods();
1285 -#endif
1286 -
1287 - close(cfd);
1288 -
1289 - return 1;
1290 -}
1291 -/*
1292 - * This engine is always built into libcrypto, so it doesn't offer any
1293 - * ability to be dynamically loadable.
1294 - */
1295 -void engine_load_devcrypto_int()
1296 -{
1297 - ENGINE *e = NULL;
1298 -
1299 - if ((cfd = open("/dev/crypto", O_RDWR, 0)) < 0) {
1300 -#ifndef ENGINE_DEVCRYPTO_DEBUG
1301 - if (errno != ENOENT)
1302 -#endif
1303 - fprintf(stderr, "Could not open /dev/crypto: %s\n", strerror(errno));
1304 - return;
1305 - }
1306 -
1307 - if ((e = ENGINE_new()) == NULL
1308 - || !ENGINE_set_destroy_function(e, devcrypto_unload)) {
1309 - ENGINE_free(e);
1310 - /*
1311 - * We know that devcrypto_unload() won't be called when one of the
1312 - * above two calls have failed, so we close cfd explicitly here to
1313 - * avoid leaking resources.
1314 - */
1315 - close(cfd);
1316 - return;
1317 - }
1318 -
1319 - prepare_cipher_methods();
1320 -#ifdef IMPLEMENT_DIGEST
1321 - prepare_digest_methods();
1322 -#endif
1323 -
1324 - if (!ENGINE_set_id(e, "devcrypto")
1325 - || !ENGINE_set_name(e, "/dev/crypto engine")
1326 - || !ENGINE_set_cmd_defns(e, devcrypto_cmds)
1327 - || !ENGINE_set_ctrl_function(e, devcrypto_ctrl)
1328 -
1329 -/*
1330 - * Asymmetric ciphers aren't well supported with /dev/crypto. Among the BSD
1331 - * implementations, it seems to only exist in FreeBSD, and regarding the
1332 - * parameters in its crypt_kop, the manual crypto(4) has this to say:
1333 - *
1334 - * The semantics of these arguments are currently undocumented.
1335 - *
1336 - * Reading through the FreeBSD source code doesn't give much more than
1337 - * their CRK_MOD_EXP implementation for ubsec.
1338 - *
1339 - * It doesn't look much better with cryptodev-linux. They have the crypt_kop
1340 - * structure as well as the command (CRK_*) in cryptodev.h, but no support
1341 - * seems to be implemented at all for the moment.
1342 - *
1343 - * At the time of writing, it seems impossible to write proper support for
1344 - * FreeBSD's asym features without some very deep knowledge and access to
1345 - * specific kernel modules.
1346 - *
1347 - * /Richard Levitte, 2017-05-11
1348 - */
1349 -#if 0
1350 -# ifndef OPENSSL_NO_RSA
1351 - || !ENGINE_set_RSA(e, devcrypto_rsa)
1352 -# endif
1353 -# ifndef OPENSSL_NO_DSA
1354 - || !ENGINE_set_DSA(e, devcrypto_dsa)
1355 -# endif
1356 -# ifndef OPENSSL_NO_DH
1357 - || !ENGINE_set_DH(e, devcrypto_dh)
1358 -# endif
1359 -# ifndef OPENSSL_NO_EC
1360 - || !ENGINE_set_EC(e, devcrypto_ec)
1361 -# endif
1362 -#endif
1363 - || !ENGINE_set_ciphers(e, devcrypto_ciphers)
1364 -#ifdef IMPLEMENT_DIGEST
1365 - || !ENGINE_set_digests(e, devcrypto_digests)
1366 -#endif
1367 - ) {
1368 - ENGINE_free(e);
1369 - return;
1370 - }
1371 -
1372 - ENGINE_add(e);
1373 - ENGINE_free(e); /* Loose our local reference */
1374 - ERR_clear_error();
1375 -}
1376 --- /dev/null
1377 +++ b/engines/e_devcrypto.c
1378 @@ -0,0 +1,1315 @@
1379 +/*
1380 + * Copyright 2017-2019 The OpenSSL Project Authors. All Rights Reserved.
1381 + *
1382 + * Licensed under the OpenSSL license (the "License"). You may not use
1383 + * this file except in compliance with the License. You can obtain a copy
1384 + * in the file LICENSE in the source distribution or at
1385 + * https://www.openssl.org/source/license.html
1386 + */
1387 +
1388 +#include "../e_os.h"
1389 +#include <string.h>
1390 +#include <sys/types.h>
1391 +#include <sys/stat.h>
1392 +#include <fcntl.h>
1393 +#include <sys/ioctl.h>
1394 +#include <unistd.h>
1395 +#include <assert.h>
1396 +
1397 +#include <openssl/conf.h>
1398 +#include <openssl/evp.h>
1399 +#include <openssl/err.h>
1400 +#include <openssl/engine.h>
1401 +#include <openssl/objects.h>
1402 +#include <crypto/cryptodev.h>
1403 +
1404 +/* #define ENGINE_DEVCRYPTO_DEBUG */
1405 +
1406 +#ifdef CRYPTO_ALGORITHM_MIN
1407 +# define CHECK_BSD_STYLE_MACROS
1408 +#endif
1409 +
1410 +#define engine_devcrypto_id "devcrypto"
1411 +
1412 +/*
1413 + * ONE global file descriptor for all sessions. This allows operations
1414 + * such as digest session data copying (see digest_copy()), but is also
1415 + * saner... why re-open /dev/crypto for every session?
1416 + */
1417 +static int cfd = -1;
1418 +#define DEVCRYPTO_REQUIRE_ACCELERATED 0 /* require confirmation of acceleration */
1419 +#define DEVCRYPTO_USE_SOFTWARE 1 /* allow software drivers */
1420 +#define DEVCRYPTO_REJECT_SOFTWARE 2 /* only disallow confirmed software drivers */
1421 +
1422 +#define DEVCRYPTO_DEFAULT_USE_SOFTDRIVERS DEVCRYPTO_REJECT_SOFTWARE
1423 +static int use_softdrivers = DEVCRYPTO_DEFAULT_USE_SOFTDRIVERS;
1424 +
1425 +/*
1426 + * cipher/digest status & acceleration definitions
1427 + * Make sure the defaults are set to 0
1428 + */
1429 +struct driver_info_st {
1430 + enum devcrypto_status_t {
1431 + DEVCRYPTO_STATUS_FAILURE = -3, /* unusable for other reason */
1432 + DEVCRYPTO_STATUS_NO_CIOCCPHASH = -2, /* hash state copy not supported */
1433 + DEVCRYPTO_STATUS_NO_CIOCGSESSION = -1, /* session open failed */
1434 + DEVCRYPTO_STATUS_UNKNOWN = 0, /* not tested yet */
1435 + DEVCRYPTO_STATUS_USABLE = 1 /* algo can be used */
1436 + } status;
1437 +
1438 + enum devcrypto_accelerated_t {
1439 + DEVCRYPTO_NOT_ACCELERATED = -1, /* software implemented */
1440 + DEVCRYPTO_ACCELERATION_UNKNOWN = 0, /* acceleration support unkown */
1441 + DEVCRYPTO_ACCELERATED = 1 /* hardware accelerated */
1442 + } accelerated;
1443 +
1444 + char *driver_name;
1445 +};
1446 +
1447 +#ifdef OPENSSL_NO_DYNAMIC_ENGINE
1448 +void engine_load_devcrypto_int(void);
1449 +#endif
1450 +
1451 +static int clean_devcrypto_session(struct session_op *sess) {
1452 + if (ioctl(cfd, CIOCFSESSION, &sess->ses) < 0) {
1453 + SYSerr(SYS_F_IOCTL, errno);
1454 + return 0;
1455 + }
1456 + memset(sess, 0, sizeof(struct session_op));
1457 + return 1;
1458 +}
1459 +
1460 +/******************************************************************************
1461 + *
1462 + * Ciphers
1463 + *
1464 + * Because they all do the same basic operation, we have only one set of
1465 + * method functions for them all to share, and a mapping table between
1466 + * NIDs and cryptodev IDs, with all the necessary size data.
1467 + *
1468 + *****/
1469 +
1470 +struct cipher_ctx {
1471 + struct session_op sess;
1472 + int op; /* COP_ENCRYPT or COP_DECRYPT */
1473 + unsigned long mode; /* EVP_CIPH_*_MODE */
1474 +
1475 + /* to handle ctr mode being a stream cipher */
1476 + unsigned char partial[EVP_MAX_BLOCK_LENGTH];
1477 + unsigned int blocksize, num;
1478 +};
1479 +
1480 +static const struct cipher_data_st {
1481 + int nid;
1482 + int blocksize;
1483 + int keylen;
1484 + int ivlen;
1485 + int flags;
1486 + int devcryptoid;
1487 +} cipher_data[] = {
1488 +#ifndef OPENSSL_NO_DES
1489 + { NID_des_cbc, 8, 8, 8, EVP_CIPH_CBC_MODE, CRYPTO_DES_CBC },
1490 + { NID_des_ede3_cbc, 8, 24, 8, EVP_CIPH_CBC_MODE, CRYPTO_3DES_CBC },
1491 +#endif
1492 +#ifndef OPENSSL_NO_BF
1493 + { NID_bf_cbc, 8, 16, 8, EVP_CIPH_CBC_MODE, CRYPTO_BLF_CBC },
1494 +#endif
1495 +#ifndef OPENSSL_NO_CAST
1496 + { NID_cast5_cbc, 8, 16, 8, EVP_CIPH_CBC_MODE, CRYPTO_CAST_CBC },
1497 +#endif
1498 + { NID_aes_128_cbc, 16, 128 / 8, 16, EVP_CIPH_CBC_MODE, CRYPTO_AES_CBC },
1499 + { NID_aes_192_cbc, 16, 192 / 8, 16, EVP_CIPH_CBC_MODE, CRYPTO_AES_CBC },
1500 + { NID_aes_256_cbc, 16, 256 / 8, 16, EVP_CIPH_CBC_MODE, CRYPTO_AES_CBC },
1501 +#ifndef OPENSSL_NO_RC4
1502 + { NID_rc4, 1, 16, 0, EVP_CIPH_STREAM_CIPHER, CRYPTO_ARC4 },
1503 +#endif
1504 +#if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_AES_CTR)
1505 + { NID_aes_128_ctr, 16, 128 / 8, 16, EVP_CIPH_CTR_MODE, CRYPTO_AES_CTR },
1506 + { NID_aes_192_ctr, 16, 192 / 8, 16, EVP_CIPH_CTR_MODE, CRYPTO_AES_CTR },
1507 + { NID_aes_256_ctr, 16, 256 / 8, 16, EVP_CIPH_CTR_MODE, CRYPTO_AES_CTR },
1508 +#endif
1509 +#if 0 /* Not yet supported */
1510 + { NID_aes_128_xts, 16, 128 / 8 * 2, 16, EVP_CIPH_XTS_MODE, CRYPTO_AES_XTS },
1511 + { NID_aes_256_xts, 16, 256 / 8 * 2, 16, EVP_CIPH_XTS_MODE, CRYPTO_AES_XTS },
1512 +#endif
1513 +#if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_AES_ECB)
1514 + { NID_aes_128_ecb, 16, 128 / 8, 0, EVP_CIPH_ECB_MODE, CRYPTO_AES_ECB },
1515 + { NID_aes_192_ecb, 16, 192 / 8, 0, EVP_CIPH_ECB_MODE, CRYPTO_AES_ECB },
1516 + { NID_aes_256_ecb, 16, 256 / 8, 0, EVP_CIPH_ECB_MODE, CRYPTO_AES_ECB },
1517 +#endif
1518 +#if 0 /* Not yet supported */
1519 + { NID_aes_128_gcm, 16, 128 / 8, 16, EVP_CIPH_GCM_MODE, CRYPTO_AES_GCM },
1520 + { NID_aes_192_gcm, 16, 192 / 8, 16, EVP_CIPH_GCM_MODE, CRYPTO_AES_GCM },
1521 + { NID_aes_256_gcm, 16, 256 / 8, 16, EVP_CIPH_GCM_MODE, CRYPTO_AES_GCM },
1522 +#endif
1523 +#ifndef OPENSSL_NO_CAMELLIA
1524 + { NID_camellia_128_cbc, 16, 128 / 8, 16, EVP_CIPH_CBC_MODE,
1525 + CRYPTO_CAMELLIA_CBC },
1526 + { NID_camellia_192_cbc, 16, 192 / 8, 16, EVP_CIPH_CBC_MODE,
1527 + CRYPTO_CAMELLIA_CBC },
1528 + { NID_camellia_256_cbc, 16, 256 / 8, 16, EVP_CIPH_CBC_MODE,
1529 + CRYPTO_CAMELLIA_CBC },
1530 +#endif
1531 +};
1532 +
1533 +static size_t find_cipher_data_index(int nid)
1534 +{
1535 + size_t i;
1536 +
1537 + for (i = 0; i < OSSL_NELEM(cipher_data); i++)
1538 + if (nid == cipher_data[i].nid)
1539 + return i;
1540 + return (size_t)-1;
1541 +}
1542 +
1543 +static size_t get_cipher_data_index(int nid)
1544 +{
1545 + size_t i = find_cipher_data_index(nid);
1546 +
1547 + if (i != (size_t)-1)
1548 + return i;
1549 +
1550 + /*
1551 + * Code further down must make sure that only NIDs in the table above
1552 + * are used. If any other NID reaches this function, there's a grave
1553 + * coding error further down.
1554 + */
1555 + assert("Code that never should be reached" == NULL);
1556 + return -1;
1557 +}
1558 +
1559 +static const struct cipher_data_st *get_cipher_data(int nid)
1560 +{
1561 + return &cipher_data[get_cipher_data_index(nid)];
1562 +}
1563 +
1564 +/*
1565 + * Following are the three necessary functions to map OpenSSL functionality
1566 + * with cryptodev.
1567 + */
1568 +
1569 +static int cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
1570 + const unsigned char *iv, int enc)
1571 +{
1572 + struct cipher_ctx *cipher_ctx =
1573 + (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
1574 + const struct cipher_data_st *cipher_d =
1575 + get_cipher_data(EVP_CIPHER_CTX_nid(ctx));
1576 +
1577 + /* cleanup a previous session */
1578 + if (cipher_ctx->sess.ses != 0 &&
1579 + clean_devcrypto_session(&cipher_ctx->sess) == 0)
1580 + return 0;
1581 +
1582 + cipher_ctx->sess.cipher = cipher_d->devcryptoid;
1583 + cipher_ctx->sess.keylen = cipher_d->keylen;
1584 + cipher_ctx->sess.key = (void *)key;
1585 + cipher_ctx->op = enc ? COP_ENCRYPT : COP_DECRYPT;
1586 + cipher_ctx->mode = cipher_d->flags & EVP_CIPH_MODE;
1587 + cipher_ctx->blocksize = cipher_d->blocksize;
1588 + if (ioctl(cfd, CIOCGSESSION, &cipher_ctx->sess) < 0) {
1589 + SYSerr(SYS_F_IOCTL, errno);
1590 + return 0;
1591 + }
1592 +
1593 + return 1;
1594 +}
1595 +
1596 +static int cipher_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1597 + const unsigned char *in, size_t inl)
1598 +{
1599 + struct cipher_ctx *cipher_ctx =
1600 + (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
1601 + struct crypt_op cryp;
1602 + unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
1603 +#if !defined(COP_FLAG_WRITE_IV)
1604 + unsigned char saved_iv[EVP_MAX_IV_LENGTH];
1605 + const unsigned char *ivptr;
1606 + size_t nblocks, ivlen;
1607 +#endif
1608 +
1609 + memset(&cryp, 0, sizeof(cryp));
1610 + cryp.ses = cipher_ctx->sess.ses;
1611 + cryp.len = inl;
1612 + cryp.src = (void *)in;
1613 + cryp.dst = (void *)out;
1614 + cryp.iv = (void *)iv;
1615 + cryp.op = cipher_ctx->op;
1616 +#if !defined(COP_FLAG_WRITE_IV)
1617 + cryp.flags = 0;
1618 +
1619 + ivlen = EVP_CIPHER_CTX_iv_length(ctx);
1620 + if (ivlen > 0)
1621 + switch (cipher_ctx->mode) {
1622 + case EVP_CIPH_CBC_MODE:
1623 + assert(inl >= ivlen);
1624 + if (!EVP_CIPHER_CTX_encrypting(ctx)) {
1625 + ivptr = in + inl - ivlen;
1626 + memcpy(saved_iv, ivptr, ivlen);
1627 + }
1628 + break;
1629 +
1630 + case EVP_CIPH_CTR_MODE:
1631 + break;
1632 +
1633 + default: /* should not happen */
1634 + return 0;
1635 + }
1636 +#else
1637 + cryp.flags = COP_FLAG_WRITE_IV;
1638 +#endif
1639 +
1640 + if (ioctl(cfd, CIOCCRYPT, &cryp) < 0) {
1641 + SYSerr(SYS_F_IOCTL, errno);
1642 + return 0;
1643 + }
1644 +
1645 +#if !defined(COP_FLAG_WRITE_IV)
1646 + if (ivlen > 0)
1647 + switch (cipher_ctx->mode) {
1648 + case EVP_CIPH_CBC_MODE:
1649 + assert(inl >= ivlen);
1650 + if (EVP_CIPHER_CTX_encrypting(ctx))
1651 + ivptr = out + inl - ivlen;
1652 + else
1653 + ivptr = saved_iv;
1654 +
1655 + memcpy(iv, ivptr, ivlen);
1656 + break;
1657 +
1658 + case EVP_CIPH_CTR_MODE:
1659 + nblocks = (inl + cipher_ctx->blocksize - 1)
1660 + / cipher_ctx->blocksize;
1661 + do {
1662 + ivlen--;
1663 + nblocks += iv[ivlen];
1664 + iv[ivlen] = (uint8_t) nblocks;
1665 + nblocks >>= 8;
1666 + } while (ivlen);
1667 + break;
1668 +
1669 + default: /* should not happen */
1670 + return 0;
1671 + }
1672 +#endif
1673 +
1674 + return 1;
1675 +}
1676 +
1677 +static int ctr_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1678 + const unsigned char *in, size_t inl)
1679 +{
1680 + struct cipher_ctx *cipher_ctx =
1681 + (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
1682 + size_t nblocks, len;
1683 +
1684 + /* initial partial block */
1685 + while (cipher_ctx->num && inl) {
1686 + (*out++) = *(in++) ^ cipher_ctx->partial[cipher_ctx->num];
1687 + --inl;
1688 + cipher_ctx->num = (cipher_ctx->num + 1) % cipher_ctx->blocksize;
1689 + }
1690 +
1691 + /* full blocks */
1692 + if (inl > (unsigned int) cipher_ctx->blocksize) {
1693 + nblocks = inl/cipher_ctx->blocksize;
1694 + len = nblocks * cipher_ctx->blocksize;
1695 + if (cipher_do_cipher(ctx, out, in, len) < 1)
1696 + return 0;
1697 + inl -= len;
1698 + out += len;
1699 + in += len;
1700 + }
1701 +
1702 + /* final partial block */
1703 + if (inl) {
1704 + memset(cipher_ctx->partial, 0, cipher_ctx->blocksize);
1705 + if (cipher_do_cipher(ctx, cipher_ctx->partial, cipher_ctx->partial,
1706 + cipher_ctx->blocksize) < 1)
1707 + return 0;
1708 + while (inl--) {
1709 + out[cipher_ctx->num] = in[cipher_ctx->num]
1710 + ^ cipher_ctx->partial[cipher_ctx->num];
1711 + cipher_ctx->num++;
1712 + }
1713 + }
1714 +
1715 + return 1;
1716 +}
1717 +
1718 +static int cipher_ctrl(EVP_CIPHER_CTX *ctx, int type, int p1, void* p2)
1719 +{
1720 + struct cipher_ctx *cipher_ctx =
1721 + (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
1722 + EVP_CIPHER_CTX *to_ctx = (EVP_CIPHER_CTX *)p2;
1723 + struct cipher_ctx *to_cipher_ctx;
1724 +
1725 + switch (type) {
1726 +
1727 + case EVP_CTRL_COPY:
1728 + if (cipher_ctx == NULL)
1729 + return 1;
1730 + /* when copying the context, a new session needs to be initialized */
1731 + to_cipher_ctx =
1732 + (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(to_ctx);
1733 + memset(&to_cipher_ctx->sess, 0, sizeof(to_cipher_ctx->sess));
1734 + return cipher_init(to_ctx, cipher_ctx->sess.key, EVP_CIPHER_CTX_iv(ctx),
1735 + (cipher_ctx->op == COP_ENCRYPT));
1736 +
1737 + case EVP_CTRL_INIT:
1738 + memset(&cipher_ctx->sess, 0, sizeof(cipher_ctx->sess));
1739 + return 1;
1740 +
1741 + default:
1742 + break;
1743 + }
1744 +
1745 + return -1;
1746 +}
1747 +
1748 +static int cipher_cleanup(EVP_CIPHER_CTX *ctx)
1749 +{
1750 + struct cipher_ctx *cipher_ctx =
1751 + (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx);
1752 +
1753 + return clean_devcrypto_session(&cipher_ctx->sess);
1754 +}
1755 +
1756 +/*
1757 + * Keep tables of known nids, associated methods, selected ciphers, and driver
1758 + * info.
1759 + * Note that known_cipher_nids[] isn't necessarily indexed the same way as
1760 + * cipher_data[] above, which the other tables are.
1761 + */
1762 +static int known_cipher_nids[OSSL_NELEM(cipher_data)];
1763 +static int known_cipher_nids_amount = -1; /* -1 indicates not yet initialised */
1764 +static EVP_CIPHER *known_cipher_methods[OSSL_NELEM(cipher_data)] = { NULL, };
1765 +static int selected_ciphers[OSSL_NELEM(cipher_data)];
1766 +static struct driver_info_st cipher_driver_info[OSSL_NELEM(cipher_data)];
1767 +
1768 +
1769 +static int devcrypto_test_cipher(size_t cipher_data_index)
1770 +{
1771 + return (cipher_driver_info[cipher_data_index].status == DEVCRYPTO_STATUS_USABLE
1772 + && selected_ciphers[cipher_data_index] == 1
1773 + && (cipher_driver_info[cipher_data_index].accelerated
1774 + == DEVCRYPTO_ACCELERATED
1775 + || use_softdrivers == DEVCRYPTO_USE_SOFTWARE
1776 + || (cipher_driver_info[cipher_data_index].accelerated
1777 + != DEVCRYPTO_NOT_ACCELERATED
1778 + && use_softdrivers == DEVCRYPTO_REJECT_SOFTWARE)));
1779 +}
1780 +
1781 +static void prepare_cipher_methods(void)
1782 +{
1783 + size_t i;
1784 + struct session_op sess;
1785 + unsigned long cipher_mode;
1786 +#ifdef CIOCGSESSINFO
1787 + struct session_info_op siop;
1788 +#endif
1789 +
1790 + memset(&cipher_driver_info, 0, sizeof(cipher_driver_info));
1791 +
1792 + memset(&sess, 0, sizeof(sess));
1793 + sess.key = (void *)"01234567890123456789012345678901234567890123456789";
1794 +
1795 + for (i = 0, known_cipher_nids_amount = 0;
1796 + i < OSSL_NELEM(cipher_data); i++) {
1797 +
1798 + selected_ciphers[i] = 1;
1799 + /*
1800 + * Check that the cipher is usable
1801 + */
1802 + sess.cipher = cipher_data[i].devcryptoid;
1803 + sess.keylen = cipher_data[i].keylen;
1804 + if (ioctl(cfd, CIOCGSESSION, &sess) < 0) {
1805 + cipher_driver_info[i].status = DEVCRYPTO_STATUS_NO_CIOCGSESSION;
1806 + continue;
1807 + }
1808 +
1809 + cipher_mode = cipher_data[i].flags & EVP_CIPH_MODE;
1810 +
1811 + if ((known_cipher_methods[i] =
1812 + EVP_CIPHER_meth_new(cipher_data[i].nid,
1813 + cipher_mode == EVP_CIPH_CTR_MODE ? 1 :
1814 + cipher_data[i].blocksize,
1815 + cipher_data[i].keylen)) == NULL
1816 + || !EVP_CIPHER_meth_set_iv_length(known_cipher_methods[i],
1817 + cipher_data[i].ivlen)
1818 + || !EVP_CIPHER_meth_set_flags(known_cipher_methods[i],
1819 + cipher_data[i].flags
1820 + | EVP_CIPH_CUSTOM_COPY
1821 + | EVP_CIPH_CTRL_INIT
1822 + | EVP_CIPH_FLAG_DEFAULT_ASN1)
1823 + || !EVP_CIPHER_meth_set_init(known_cipher_methods[i], cipher_init)
1824 + || !EVP_CIPHER_meth_set_do_cipher(known_cipher_methods[i],
1825 + cipher_mode == EVP_CIPH_CTR_MODE ?
1826 + ctr_do_cipher :
1827 + cipher_do_cipher)
1828 + || !EVP_CIPHER_meth_set_ctrl(known_cipher_methods[i], cipher_ctrl)
1829 + || !EVP_CIPHER_meth_set_cleanup(known_cipher_methods[i],
1830 + cipher_cleanup)
1831 + || !EVP_CIPHER_meth_set_impl_ctx_size(known_cipher_methods[i],
1832 + sizeof(struct cipher_ctx))) {
1833 + cipher_driver_info[i].status = DEVCRYPTO_STATUS_FAILURE;
1834 + EVP_CIPHER_meth_free(known_cipher_methods[i]);
1835 + known_cipher_methods[i] = NULL;
1836 + } else {
1837 + cipher_driver_info[i].status = DEVCRYPTO_STATUS_USABLE;
1838 +#ifdef CIOCGSESSINFO
1839 + siop.ses = sess.ses;
1840 + if (ioctl(cfd, CIOCGSESSINFO, &siop) < 0) {
1841 + cipher_driver_info[i].accelerated = DEVCRYPTO_ACCELERATION_UNKNOWN;
1842 + } else {
1843 + cipher_driver_info[i].driver_name =
1844 + OPENSSL_strndup(siop.cipher_info.cra_driver_name,
1845 + CRYPTODEV_MAX_ALG_NAME);
1846 + if (!(siop.flags & SIOP_FLAG_KERNEL_DRIVER_ONLY))
1847 + cipher_driver_info[i].accelerated = DEVCRYPTO_NOT_ACCELERATED;
1848 + else
1849 + cipher_driver_info[i].accelerated = DEVCRYPTO_ACCELERATED;
1850 + }
1851 +#endif /* CIOCGSESSINFO */
1852 + }
1853 + ioctl(cfd, CIOCFSESSION, &sess.ses);
1854 + if (devcrypto_test_cipher(i)) {
1855 + known_cipher_nids[known_cipher_nids_amount++] =
1856 + cipher_data[i].nid;
1857 + }
1858 + }
1859 +}
1860 +
1861 +static void rebuild_known_cipher_nids(ENGINE *e)
1862 +{
1863 + size_t i;
1864 +
1865 + for (i = 0, known_cipher_nids_amount = 0; i < OSSL_NELEM(cipher_data); i++) {
1866 + if (devcrypto_test_cipher(i))
1867 + known_cipher_nids[known_cipher_nids_amount++] = cipher_data[i].nid;
1868 + }
1869 + ENGINE_unregister_ciphers(e);
1870 + ENGINE_register_ciphers(e);
1871 +}
1872 +
1873 +static const EVP_CIPHER *get_cipher_method(int nid)
1874 +{
1875 + size_t i = get_cipher_data_index(nid);
1876 +
1877 + if (i == (size_t)-1)
1878 + return NULL;
1879 + return known_cipher_methods[i];
1880 +}
1881 +
1882 +static int get_cipher_nids(const int **nids)
1883 +{
1884 + *nids = known_cipher_nids;
1885 + return known_cipher_nids_amount;
1886 +}
1887 +
1888 +static void destroy_cipher_method(int nid)
1889 +{
1890 + size_t i = get_cipher_data_index(nid);
1891 +
1892 + EVP_CIPHER_meth_free(known_cipher_methods[i]);
1893 + known_cipher_methods[i] = NULL;
1894 +}
1895 +
1896 +static void destroy_all_cipher_methods(void)
1897 +{
1898 + size_t i;
1899 +
1900 + for (i = 0; i < OSSL_NELEM(cipher_data); i++) {
1901 + destroy_cipher_method(cipher_data[i].nid);
1902 + OPENSSL_free(cipher_driver_info[i].driver_name);
1903 + cipher_driver_info[i].driver_name = NULL;
1904 + }
1905 +}
1906 +
1907 +static int devcrypto_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
1908 + const int **nids, int nid)
1909 +{
1910 + if (cipher == NULL)
1911 + return get_cipher_nids(nids);
1912 +
1913 + *cipher = get_cipher_method(nid);
1914 +
1915 + return *cipher != NULL;
1916 +}
1917 +
1918 +static void devcrypto_select_all_ciphers(int *cipher_list)
1919 +{
1920 + size_t i;
1921 +
1922 + for (i = 0; i < OSSL_NELEM(cipher_data); i++)
1923 + cipher_list[i] = 1;
1924 +}
1925 +
1926 +static int cryptodev_select_cipher_cb(const char *str, int len, void *usr)
1927 +{
1928 + int *cipher_list = (int *)usr;
1929 + char *name;
1930 + const EVP_CIPHER *EVP;
1931 + size_t i;
1932 +
1933 + if (len == 0)
1934 + return 1;
1935 + if (usr == NULL || (name = OPENSSL_strndup(str, len)) == NULL)
1936 + return 0;
1937 + EVP = EVP_get_cipherbyname(name);
1938 + if (EVP == NULL)
1939 + fprintf(stderr, "devcrypto: unknown cipher %s\n", name);
1940 + else if ((i = find_cipher_data_index(EVP_CIPHER_nid(EVP))) != (size_t)-1)
1941 + cipher_list[i] = 1;
1942 + else
1943 + fprintf(stderr, "devcrypto: cipher %s not available\n", name);
1944 + OPENSSL_free(name);
1945 + return 1;
1946 +}
1947 +
1948 +static void dump_cipher_info(void)
1949 +{
1950 + size_t i;
1951 + const char *name;
1952 +
1953 + fprintf (stderr, "Information about ciphers supported by the /dev/crypto"
1954 + " engine:\n");
1955 +#ifndef CIOCGSESSINFO
1956 + fprintf(stderr, "CIOCGSESSINFO (session info call) unavailable\n");
1957 +#endif
1958 + for (i = 0; i < OSSL_NELEM(cipher_data); i++) {
1959 + name = OBJ_nid2sn(cipher_data[i].nid);
1960 + fprintf (stderr, "Cipher %s, NID=%d, /dev/crypto info: id=%d, ",
1961 + name ? name : "unknown", cipher_data[i].nid,
1962 + cipher_data[i].devcryptoid);
1963 + if (cipher_driver_info[i].status == DEVCRYPTO_STATUS_NO_CIOCGSESSION ) {
1964 + fprintf (stderr, "CIOCGSESSION (session open call) failed\n");
1965 + continue;
1966 + }
1967 + fprintf (stderr, "driver=%s ", cipher_driver_info[i].driver_name ?
1968 + cipher_driver_info[i].driver_name : "unknown");
1969 + if (cipher_driver_info[i].accelerated == DEVCRYPTO_ACCELERATED)
1970 + fprintf(stderr, "(hw accelerated)");
1971 + else if (cipher_driver_info[i].accelerated == DEVCRYPTO_NOT_ACCELERATED)
1972 + fprintf(stderr, "(software)");
1973 + else
1974 + fprintf(stderr, "(acceleration status unknown)");
1975 + if (cipher_driver_info[i].status == DEVCRYPTO_STATUS_FAILURE)
1976 + fprintf (stderr, ". Cipher setup failed");
1977 + fprintf(stderr, "\n");
1978 + }
1979 + fprintf(stderr, "\n");
1980 +}
1981 +
1982 +/*
1983 + * We only support digests if the cryptodev implementation supports multiple
1984 + * data updates and session copying. Otherwise, we would be forced to maintain
1985 + * a cache, which is perilous if there's a lot of data coming in (if someone
1986 + * wants to checksum an OpenSSL tarball, for example).
1987 + */
1988 +#if defined(CIOCCPHASH) && defined(COP_FLAG_UPDATE) && defined(COP_FLAG_FINAL)
1989 +#define IMPLEMENT_DIGEST
1990 +
1991 +/******************************************************************************
1992 + *
1993 + * Digests
1994 + *
1995 + * Because they all do the same basic operation, we have only one set of
1996 + * method functions for them all to share, and a mapping table between
1997 + * NIDs and cryptodev IDs, with all the necessary size data.
1998 + *
1999 + *****/
2000 +
2001 +struct digest_ctx {
2002 + struct session_op sess;
2003 + /* This signals that the init function was called, not that it succeeded. */
2004 + int init_called;
2005 + unsigned char digest_res[HASH_MAX_LEN];
2006 +};
2007 +
2008 +static const struct digest_data_st {
2009 + int nid;
2010 + int blocksize;
2011 + int digestlen;
2012 + int devcryptoid;
2013 +} digest_data[] = {
2014 +#ifndef OPENSSL_NO_MD5
2015 + { NID_md5, /* MD5_CBLOCK */ 64, 16, CRYPTO_MD5 },
2016 +#endif
2017 + { NID_sha1, SHA_CBLOCK, 20, CRYPTO_SHA1 },
2018 +#ifndef OPENSSL_NO_RMD160
2019 +# if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_RIPEMD160)
2020 + { NID_ripemd160, /* RIPEMD160_CBLOCK */ 64, 20, CRYPTO_RIPEMD160 },
2021 +# endif
2022 +#endif
2023 +#if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_SHA2_224)
2024 + { NID_sha224, SHA256_CBLOCK, 224 / 8, CRYPTO_SHA2_224 },
2025 +#endif
2026 +#if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_SHA2_256)
2027 + { NID_sha256, SHA256_CBLOCK, 256 / 8, CRYPTO_SHA2_256 },
2028 +#endif
2029 +#if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_SHA2_384)
2030 + { NID_sha384, SHA512_CBLOCK, 384 / 8, CRYPTO_SHA2_384 },
2031 +#endif
2032 +#if !defined(CHECK_BSD_STYLE_MACROS) || defined(CRYPTO_SHA2_512)
2033 + { NID_sha512, SHA512_CBLOCK, 512 / 8, CRYPTO_SHA2_512 },
2034 +#endif
2035 +};
2036 +
2037 +static size_t find_digest_data_index(int nid)
2038 +{
2039 + size_t i;
2040 +
2041 + for (i = 0; i < OSSL_NELEM(digest_data); i++)
2042 + if (nid == digest_data[i].nid)
2043 + return i;
2044 + return (size_t)-1;
2045 +}
2046 +
2047 +static size_t get_digest_data_index(int nid)
2048 +{
2049 + size_t i = find_digest_data_index(nid);
2050 +
2051 + if (i != (size_t)-1)
2052 + return i;
2053 +
2054 + /*
2055 + * Code further down must make sure that only NIDs in the table above
2056 + * are used. If any other NID reaches this function, there's a grave
2057 + * coding error further down.
2058 + */
2059 + assert("Code that never should be reached" == NULL);
2060 + return -1;
2061 +}
2062 +
2063 +static const struct digest_data_st *get_digest_data(int nid)
2064 +{
2065 + return &digest_data[get_digest_data_index(nid)];
2066 +}
2067 +
2068 +/*
2069 + * Following are the five necessary functions to map OpenSSL functionality
2070 + * with cryptodev: init, update, final, cleanup, and copy.
2071 + */
2072 +
2073 +static int digest_init(EVP_MD_CTX *ctx)
2074 +{
2075 + struct digest_ctx *digest_ctx =
2076 + (struct digest_ctx *)EVP_MD_CTX_md_data(ctx);
2077 + const struct digest_data_st *digest_d =
2078 + get_digest_data(EVP_MD_CTX_type(ctx));
2079 +
2080 + digest_ctx->init_called = 1;
2081 +
2082 + memset(&digest_ctx->sess, 0, sizeof(digest_ctx->sess));
2083 + digest_ctx->sess.mac = digest_d->devcryptoid;
2084 + if (ioctl(cfd, CIOCGSESSION, &digest_ctx->sess) < 0) {
2085 + SYSerr(SYS_F_IOCTL, errno);
2086 + return 0;
2087 + }
2088 + return 1;
2089 +}
2090 +
2091 +static int digest_op(struct digest_ctx *ctx, const void *src, size_t srclen,
2092 + void *res, unsigned int flags)
2093 +{
2094 + struct crypt_op cryp;
2095 +
2096 + memset(&cryp, 0, sizeof(cryp));
2097 + cryp.ses = ctx->sess.ses;
2098 + cryp.len = srclen;
2099 + cryp.src = (void *)src;
2100 + cryp.dst = NULL;
2101 + cryp.mac = res;
2102 + cryp.flags = flags;
2103 + return ioctl(cfd, CIOCCRYPT, &cryp);
2104 +}
2105 +
2106 +static int digest_update(EVP_MD_CTX *ctx, const void *data, size_t count)
2107 +{
2108 + struct digest_ctx *digest_ctx =
2109 + (struct digest_ctx *)EVP_MD_CTX_md_data(ctx);
2110 +
2111 + if (count == 0)
2112 + return 1;
2113 +
2114 + if (digest_ctx == NULL)
2115 + return 0;
2116 +
2117 + if (EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_ONESHOT)) {
2118 + if (digest_op(digest_ctx, data, count, digest_ctx->digest_res, 0) >= 0)
2119 + return 1;
2120 + } else if (digest_op(digest_ctx, data, count, NULL, COP_FLAG_UPDATE) >= 0) {
2121 + return 1;
2122 + }
2123 +
2124 + SYSerr(SYS_F_IOCTL, errno);
2125 + return 0;
2126 +}
2127 +
2128 +static int digest_final(EVP_MD_CTX *ctx, unsigned char *md)
2129 +{
2130 + struct digest_ctx *digest_ctx =
2131 + (struct digest_ctx *)EVP_MD_CTX_md_data(ctx);
2132 +
2133 + if (md == NULL || digest_ctx == NULL)
2134 + return 0;
2135 +
2136 + if (EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_ONESHOT)) {
2137 + memcpy(md, digest_ctx->digest_res, EVP_MD_CTX_size(ctx));
2138 + } else if (digest_op(digest_ctx, NULL, 0, md, COP_FLAG_FINAL) < 0) {
2139 + SYSerr(SYS_F_IOCTL, errno);
2140 + return 0;
2141 + }
2142 +
2143 + return 1;
2144 +}
2145 +
2146 +static int digest_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from)
2147 +{
2148 + struct digest_ctx *digest_from =
2149 + (struct digest_ctx *)EVP_MD_CTX_md_data(from);
2150 + struct digest_ctx *digest_to =
2151 + (struct digest_ctx *)EVP_MD_CTX_md_data(to);
2152 + struct cphash_op cphash;
2153 +
2154 + if (digest_from == NULL || digest_from->init_called != 1)
2155 + return 1;
2156 +
2157 + if (!digest_init(to)) {
2158 + SYSerr(SYS_F_IOCTL, errno);
2159 + return 0;
2160 + }
2161 +
2162 + cphash.src_ses = digest_from->sess.ses;
2163 + cphash.dst_ses = digest_to->sess.ses;
2164 + if (ioctl(cfd, CIOCCPHASH, &cphash) < 0) {
2165 + SYSerr(SYS_F_IOCTL, errno);
2166 + return 0;
2167 + }
2168 + return 1;
2169 +}
2170 +
2171 +static int digest_cleanup(EVP_MD_CTX *ctx)
2172 +{
2173 + struct digest_ctx *digest_ctx =
2174 + (struct digest_ctx *)EVP_MD_CTX_md_data(ctx);
2175 +
2176 + if (digest_ctx == NULL)
2177 + return 1;
2178 +
2179 + return clean_devcrypto_session(&digest_ctx->sess);
2180 +}
2181 +
2182 +/*
2183 + * Keep tables of known nids, associated methods, selected digests, and
2184 + * driver info.
2185 + * Note that known_digest_nids[] isn't necessarily indexed the same way as
2186 + * digest_data[] above, which the other tables are.
2187 + */
2188 +static int known_digest_nids[OSSL_NELEM(digest_data)];
2189 +static int known_digest_nids_amount = -1; /* -1 indicates not yet initialised */
2190 +static EVP_MD *known_digest_methods[OSSL_NELEM(digest_data)] = { NULL, };
2191 +static int selected_digests[OSSL_NELEM(digest_data)];
2192 +static struct driver_info_st digest_driver_info[OSSL_NELEM(digest_data)];
2193 +
2194 +static int devcrypto_test_digest(size_t digest_data_index)
2195 +{
2196 + return (digest_driver_info[digest_data_index].status == DEVCRYPTO_STATUS_USABLE
2197 + && selected_digests[digest_data_index] == 1
2198 + && (digest_driver_info[digest_data_index].accelerated
2199 + == DEVCRYPTO_ACCELERATED
2200 + || use_softdrivers == DEVCRYPTO_USE_SOFTWARE
2201 + || (digest_driver_info[digest_data_index].accelerated
2202 + != DEVCRYPTO_NOT_ACCELERATED
2203 + && use_softdrivers == DEVCRYPTO_REJECT_SOFTWARE)));
2204 +}
2205 +
2206 +static void rebuild_known_digest_nids(ENGINE *e)
2207 +{
2208 + size_t i;
2209 +
2210 + for (i = 0, known_digest_nids_amount = 0; i < OSSL_NELEM(digest_data); i++) {
2211 + if (devcrypto_test_digest(i))
2212 + known_digest_nids[known_digest_nids_amount++] = digest_data[i].nid;
2213 + }
2214 + ENGINE_unregister_digests(e);
2215 + ENGINE_register_digests(e);
2216 +}
2217 +
2218 +static void prepare_digest_methods(void)
2219 +{
2220 + size_t i;
2221 + struct session_op sess1, sess2;
2222 +#ifdef CIOCGSESSINFO
2223 + struct session_info_op siop;
2224 +#endif
2225 + struct cphash_op cphash;
2226 +
2227 + memset(&digest_driver_info, 0, sizeof(digest_driver_info));
2228 +
2229 + memset(&sess1, 0, sizeof(sess1));
2230 + memset(&sess2, 0, sizeof(sess2));
2231 +
2232 + for (i = 0, known_digest_nids_amount = 0; i < OSSL_NELEM(digest_data);
2233 + i++) {
2234 +
2235 + selected_digests[i] = 1;
2236 +
2237 + /*
2238 + * Check that the digest is usable
2239 + */
2240 + sess1.mac = digest_data[i].devcryptoid;
2241 + sess2.ses = 0;
2242 + if (ioctl(cfd, CIOCGSESSION, &sess1) < 0) {
2243 + digest_driver_info[i].status = DEVCRYPTO_STATUS_NO_CIOCGSESSION;
2244 + goto finish;
2245 + }
2246 +
2247 +#ifdef CIOCGSESSINFO
2248 + /* gather hardware acceleration info from the driver */
2249 + siop.ses = sess1.ses;
2250 + if (ioctl(cfd, CIOCGSESSINFO, &siop) < 0) {
2251 + digest_driver_info[i].accelerated = DEVCRYPTO_ACCELERATION_UNKNOWN;
2252 + } else {
2253 + digest_driver_info[i].driver_name =
2254 + OPENSSL_strndup(siop.hash_info.cra_driver_name,
2255 + CRYPTODEV_MAX_ALG_NAME);
2256 + if (siop.flags & SIOP_FLAG_KERNEL_DRIVER_ONLY)
2257 + digest_driver_info[i].accelerated = DEVCRYPTO_ACCELERATED;
2258 + else
2259 + digest_driver_info[i].accelerated = DEVCRYPTO_NOT_ACCELERATED;
2260 + }
2261 +#endif
2262 +
2263 + /* digest must be capable of hash state copy */
2264 + sess2.mac = sess1.mac;
2265 + if (ioctl(cfd, CIOCGSESSION, &sess2) < 0) {
2266 + digest_driver_info[i].status = DEVCRYPTO_STATUS_FAILURE;
2267 + goto finish;
2268 + }
2269 + cphash.src_ses = sess1.ses;
2270 + cphash.dst_ses = sess2.ses;
2271 + if (ioctl(cfd, CIOCCPHASH, &cphash) < 0) {
2272 + digest_driver_info[i].status = DEVCRYPTO_STATUS_NO_CIOCCPHASH;
2273 + goto finish;
2274 + }
2275 + if ((known_digest_methods[i] = EVP_MD_meth_new(digest_data[i].nid,
2276 + NID_undef)) == NULL
2277 + || !EVP_MD_meth_set_input_blocksize(known_digest_methods[i],
2278 + digest_data[i].blocksize)
2279 + || !EVP_MD_meth_set_result_size(known_digest_methods[i],
2280 + digest_data[i].digestlen)
2281 + || !EVP_MD_meth_set_init(known_digest_methods[i], digest_init)
2282 + || !EVP_MD_meth_set_update(known_digest_methods[i], digest_update)
2283 + || !EVP_MD_meth_set_final(known_digest_methods[i], digest_final)
2284 + || !EVP_MD_meth_set_copy(known_digest_methods[i], digest_copy)
2285 + || !EVP_MD_meth_set_cleanup(known_digest_methods[i], digest_cleanup)
2286 + || !EVP_MD_meth_set_app_datasize(known_digest_methods[i],
2287 + sizeof(struct digest_ctx))) {
2288 + digest_driver_info[i].status = DEVCRYPTO_STATUS_FAILURE;
2289 + EVP_MD_meth_free(known_digest_methods[i]);
2290 + known_digest_methods[i] = NULL;
2291 + goto finish;
2292 + }
2293 + digest_driver_info[i].status = DEVCRYPTO_STATUS_USABLE;
2294 +finish:
2295 + ioctl(cfd, CIOCFSESSION, &sess1.ses);
2296 + if (sess2.ses != 0)
2297 + ioctl(cfd, CIOCFSESSION, &sess2.ses);
2298 + if (devcrypto_test_digest(i))
2299 + known_digest_nids[known_digest_nids_amount++] = digest_data[i].nid;
2300 + }
2301 +}
2302 +
2303 +static const EVP_MD *get_digest_method(int nid)
2304 +{
2305 + size_t i = get_digest_data_index(nid);
2306 +
2307 + if (i == (size_t)-1)
2308 + return NULL;
2309 + return known_digest_methods[i];
2310 +}
2311 +
2312 +static int get_digest_nids(const int **nids)
2313 +{
2314 + *nids = known_digest_nids;
2315 + return known_digest_nids_amount;
2316 +}
2317 +
2318 +static void destroy_digest_method(int nid)
2319 +{
2320 + size_t i = get_digest_data_index(nid);
2321 +
2322 + EVP_MD_meth_free(known_digest_methods[i]);
2323 + known_digest_methods[i] = NULL;
2324 +}
2325 +
2326 +static void destroy_all_digest_methods(void)
2327 +{
2328 + size_t i;
2329 +
2330 + for (i = 0; i < OSSL_NELEM(digest_data); i++) {
2331 + destroy_digest_method(digest_data[i].nid);
2332 + OPENSSL_free(digest_driver_info[i].driver_name);
2333 + digest_driver_info[i].driver_name = NULL;
2334 + }
2335 +}
2336 +
2337 +static int devcrypto_digests(ENGINE *e, const EVP_MD **digest,
2338 + const int **nids, int nid)
2339 +{
2340 + if (digest == NULL)
2341 + return get_digest_nids(nids);
2342 +
2343 + *digest = get_digest_method(nid);
2344 +
2345 + return *digest != NULL;
2346 +}
2347 +
2348 +static void devcrypto_select_all_digests(int *digest_list)
2349 +{
2350 + size_t i;
2351 +
2352 + for (i = 0; i < OSSL_NELEM(digest_data); i++)
2353 + digest_list[i] = 1;
2354 +}
2355 +
2356 +static int cryptodev_select_digest_cb(const char *str, int len, void *usr)
2357 +{
2358 + int *digest_list = (int *)usr;
2359 + char *name;
2360 + const EVP_MD *EVP;
2361 + size_t i;
2362 +
2363 + if (len == 0)
2364 + return 1;
2365 + if (usr == NULL || (name = OPENSSL_strndup(str, len)) == NULL)
2366 + return 0;
2367 + EVP = EVP_get_digestbyname(name);
2368 + if (EVP == NULL)
2369 + fprintf(stderr, "devcrypto: unknown digest %s\n", name);
2370 + else if ((i = find_digest_data_index(EVP_MD_type(EVP))) != (size_t)-1)
2371 + digest_list[i] = 1;
2372 + else
2373 + fprintf(stderr, "devcrypto: digest %s not available\n", name);
2374 + OPENSSL_free(name);
2375 + return 1;
2376 +}
2377 +
2378 +static void dump_digest_info(void)
2379 +{
2380 + size_t i;
2381 + const char *name;
2382 +
2383 + fprintf (stderr, "Information about digests supported by the /dev/crypto"
2384 + " engine:\n");
2385 +#ifndef CIOCGSESSINFO
2386 + fprintf(stderr, "CIOCGSESSINFO (session info call) unavailable\n");
2387 +#endif
2388 +
2389 + for (i = 0; i < OSSL_NELEM(digest_data); i++) {
2390 + name = OBJ_nid2sn(digest_data[i].nid);
2391 + fprintf (stderr, "Digest %s, NID=%d, /dev/crypto info: id=%d, driver=%s",
2392 + name ? name : "unknown", digest_data[i].nid,
2393 + digest_data[i].devcryptoid,
2394 + digest_driver_info[i].driver_name ? digest_driver_info[i].driver_name : "unknown");
2395 + if (digest_driver_info[i].status == DEVCRYPTO_STATUS_NO_CIOCGSESSION) {
2396 + fprintf (stderr, ". CIOCGSESSION (session open) failed\n");
2397 + continue;
2398 + }
2399 + if (digest_driver_info[i].accelerated == DEVCRYPTO_ACCELERATED)
2400 + fprintf(stderr, " (hw accelerated)");
2401 + else if (digest_driver_info[i].accelerated == DEVCRYPTO_NOT_ACCELERATED)
2402 + fprintf(stderr, " (software)");
2403 + else
2404 + fprintf(stderr, " (acceleration status unknown)");
2405 + if (cipher_driver_info[i].status == DEVCRYPTO_STATUS_FAILURE)
2406 + fprintf (stderr, ". Cipher setup failed\n");
2407 + else if (digest_driver_info[i].status == DEVCRYPTO_STATUS_NO_CIOCCPHASH)
2408 + fprintf(stderr, ", CIOCCPHASH failed\n");
2409 + else
2410 + fprintf(stderr, ", CIOCCPHASH capable\n");
2411 + }
2412 + fprintf(stderr, "\n");
2413 +}
2414 +
2415 +#endif
2416 +
2417 +/******************************************************************************
2418 + *
2419 + * CONTROL COMMANDS
2420 + *
2421 + *****/
2422 +
2423 +#define DEVCRYPTO_CMD_USE_SOFTDRIVERS ENGINE_CMD_BASE
2424 +#define DEVCRYPTO_CMD_CIPHERS (ENGINE_CMD_BASE + 1)
2425 +#define DEVCRYPTO_CMD_DIGESTS (ENGINE_CMD_BASE + 2)
2426 +#define DEVCRYPTO_CMD_DUMP_INFO (ENGINE_CMD_BASE + 3)
2427 +
2428 +/* Helper macros for CPP string composition */
2429 +#ifndef OPENSSL_MSTR
2430 +# define OPENSSL_MSTR_HELPER(x) #x
2431 +# define OPENSSL_MSTR(x) OPENSSL_MSTR_HELPER(x)
2432 +#endif
2433 +
2434 +static const ENGINE_CMD_DEFN devcrypto_cmds[] = {
2435 +#ifdef CIOCGSESSINFO
2436 + {DEVCRYPTO_CMD_USE_SOFTDRIVERS,
2437 + "USE_SOFTDRIVERS",
2438 + "specifies whether to use software (not accelerated) drivers ("
2439 + OPENSSL_MSTR(DEVCRYPTO_REQUIRE_ACCELERATED) "=use only accelerated drivers, "
2440 + OPENSSL_MSTR(DEVCRYPTO_USE_SOFTWARE) "=allow all drivers, "
2441 + OPENSSL_MSTR(DEVCRYPTO_REJECT_SOFTWARE)
2442 + "=use if acceleration can't be determined) [default="
2443 + OPENSSL_MSTR(DEVCRYPTO_DEFAULT_USE_SOFTDRIVERS) "]",
2444 + ENGINE_CMD_FLAG_NUMERIC},
2445 +#endif
2446 +
2447 + {DEVCRYPTO_CMD_CIPHERS,
2448 + "CIPHERS",
2449 + "either ALL, NONE, or a comma-separated list of ciphers to enable [default=ALL]",
2450 + ENGINE_CMD_FLAG_STRING},
2451 +
2452 +#ifdef IMPLEMENT_DIGEST
2453 + {DEVCRYPTO_CMD_DIGESTS,
2454 + "DIGESTS",
2455 + "either ALL, NONE, or a comma-separated list of digests to enable [default=ALL]",
2456 + ENGINE_CMD_FLAG_STRING},
2457 +#endif
2458 +
2459 + {DEVCRYPTO_CMD_DUMP_INFO,
2460 + "DUMP_INFO",
2461 + "dump info about each algorithm to stderr; use 'openssl engine -pre DUMP_INFO devcrypto'",
2462 + ENGINE_CMD_FLAG_NO_INPUT},
2463 +
2464 + {0, NULL, NULL, 0}
2465 +};
2466 +
2467 +static int devcrypto_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void))
2468 +{
2469 + int *new_list;
2470 + switch (cmd) {
2471 +#ifdef CIOCGSESSINFO
2472 + case DEVCRYPTO_CMD_USE_SOFTDRIVERS:
2473 + switch (i) {
2474 + case DEVCRYPTO_REQUIRE_ACCELERATED:
2475 + case DEVCRYPTO_USE_SOFTWARE:
2476 + case DEVCRYPTO_REJECT_SOFTWARE:
2477 + break;
2478 + default:
2479 + fprintf(stderr, "devcrypto: invalid value (%ld) for USE_SOFTDRIVERS\n", i);
2480 + return 0;
2481 + }
2482 + if (use_softdrivers == i)
2483 + return 1;
2484 + use_softdrivers = i;
2485 +#ifdef IMPLEMENT_DIGEST
2486 + rebuild_known_digest_nids(e);
2487 +#endif
2488 + rebuild_known_cipher_nids(e);
2489 + return 1;
2490 +#endif /* CIOCGSESSINFO */
2491 +
2492 + case DEVCRYPTO_CMD_CIPHERS:
2493 + if (p == NULL)
2494 + return 1;
2495 + if (strcasecmp((const char *)p, "ALL") == 0) {
2496 + devcrypto_select_all_ciphers(selected_ciphers);
2497 + } else if (strcasecmp((const char*)p, "NONE") == 0) {
2498 + memset(selected_ciphers, 0, sizeof(selected_ciphers));
2499 + } else {
2500 + new_list=OPENSSL_zalloc(sizeof(selected_ciphers));
2501 + if (!CONF_parse_list(p, ',', 1, cryptodev_select_cipher_cb, new_list)) {
2502 + OPENSSL_free(new_list);
2503 + return 0;
2504 + }
2505 + memcpy(selected_ciphers, new_list, sizeof(selected_ciphers));
2506 + OPENSSL_free(new_list);
2507 + }
2508 + rebuild_known_cipher_nids(e);
2509 + return 1;
2510 +
2511 +#ifdef IMPLEMENT_DIGEST
2512 + case DEVCRYPTO_CMD_DIGESTS:
2513 + if (p == NULL)
2514 + return 1;
2515 + if (strcasecmp((const char *)p, "ALL") == 0) {
2516 + devcrypto_select_all_digests(selected_digests);
2517 + } else if (strcasecmp((const char*)p, "NONE") == 0) {
2518 + memset(selected_digests, 0, sizeof(selected_digests));
2519 + } else {
2520 + new_list=OPENSSL_zalloc(sizeof(selected_digests));
2521 + if (!CONF_parse_list(p, ',', 1, cryptodev_select_digest_cb, new_list)) {
2522 + OPENSSL_free(new_list);
2523 + return 0;
2524 + }
2525 + memcpy(selected_digests, new_list, sizeof(selected_digests));
2526 + OPENSSL_free(new_list);
2527 + }
2528 + rebuild_known_digest_nids(e);
2529 + return 1;
2530 +#endif /* IMPLEMENT_DIGEST */
2531 +
2532 + case DEVCRYPTO_CMD_DUMP_INFO:
2533 + dump_cipher_info();
2534 +#ifdef IMPLEMENT_DIGEST
2535 + dump_digest_info();
2536 +#endif
2537 + return 1;
2538 +
2539 + default:
2540 + break;
2541 + }
2542 + return 0;
2543 +}
2544 +
2545 +/******************************************************************************
2546 + *
2547 + * LOAD / UNLOAD
2548 + *
2549 + *****/
2550 +
2551 +/*
2552 + * Opens /dev/crypto
2553 + */
2554 +static int open_devcrypto(void)
2555 +{
2556 + if (cfd >= 0)
2557 + return 1;
2558 +
2559 + if ((cfd = open("/dev/crypto", O_RDWR, 0)) < 0) {
2560 +#ifndef ENGINE_DEVCRYPTO_DEBUG
2561 + if (errno != ENOENT)
2562 +#endif
2563 + fprintf(stderr, "Could not open /dev/crypto: %s\n", strerror(errno));
2564 + return 0;
2565 + }
2566 +
2567 + return 1;
2568 +}
2569 +
2570 +static int close_devcrypto(void)
2571 +{
2572 + int ret;
2573 +
2574 + if (cfd < 0)
2575 + return 1;
2576 + ret = close(cfd);
2577 + cfd = -1;
2578 + if (ret != 0) {
2579 + fprintf(stderr, "Error closing /dev/crypto: %s\n", strerror(errno));
2580 + return 0;
2581 + }
2582 + return 1;
2583 +}
2584 +
2585 +static int devcrypto_unload(ENGINE *e)
2586 +{
2587 + destroy_all_cipher_methods();
2588 +#ifdef IMPLEMENT_DIGEST
2589 + destroy_all_digest_methods();
2590 +#endif
2591 +
2592 + close_devcrypto();
2593 +
2594 + return 1;
2595 +}
2596 +
2597 +static int bind_devcrypto(ENGINE *e) {
2598 +
2599 + if (!ENGINE_set_id(e, engine_devcrypto_id)
2600 + || !ENGINE_set_name(e, "/dev/crypto engine")
2601 + || !ENGINE_set_destroy_function(e, devcrypto_unload)
2602 + || !ENGINE_set_cmd_defns(e, devcrypto_cmds)
2603 + || !ENGINE_set_ctrl_function(e, devcrypto_ctrl))
2604 + return 0;
2605 +
2606 + prepare_cipher_methods();
2607 +#ifdef IMPLEMENT_DIGEST
2608 + prepare_digest_methods();
2609 +#endif
2610 +
2611 + return (ENGINE_set_ciphers(e, devcrypto_ciphers)
2612 +#ifdef IMPLEMENT_DIGEST
2613 + && ENGINE_set_digests(e, devcrypto_digests)
2614 +#endif
2615 +/*
2616 + * Asymmetric ciphers aren't well supported with /dev/crypto. Among the BSD
2617 + * implementations, it seems to only exist in FreeBSD, and regarding the
2618 + * parameters in its crypt_kop, the manual crypto(4) has this to say:
2619 + *
2620 + * The semantics of these arguments are currently undocumented.
2621 + *
2622 + * Reading through the FreeBSD source code doesn't give much more than
2623 + * their CRK_MOD_EXP implementation for ubsec.
2624 + *
2625 + * It doesn't look much better with cryptodev-linux. They have the crypt_kop
2626 + * structure as well as the command (CRK_*) in cryptodev.h, but no support
2627 + * seems to be implemented at all for the moment.
2628 + *
2629 + * At the time of writing, it seems impossible to write proper support for
2630 + * FreeBSD's asym features without some very deep knowledge and access to
2631 + * specific kernel modules.
2632 + *
2633 + * /Richard Levitte, 2017-05-11
2634 + */
2635 +#if 0
2636 +# ifndef OPENSSL_NO_RSA
2637 + && ENGINE_set_RSA(e, devcrypto_rsa)
2638 +# endif
2639 +# ifndef OPENSSL_NO_DSA
2640 + && ENGINE_set_DSA(e, devcrypto_dsa)
2641 +# endif
2642 +# ifndef OPENSSL_NO_DH
2643 + && ENGINE_set_DH(e, devcrypto_dh)
2644 +# endif
2645 +# ifndef OPENSSL_NO_EC
2646 + && ENGINE_set_EC(e, devcrypto_ec)
2647 +# endif
2648 +#endif
2649 + );
2650 +}
2651 +
2652 +#ifdef OPENSSL_NO_DYNAMIC_ENGINE
2653 +/*
2654 + * In case this engine is built into libcrypto, then it doesn't offer any
2655 + * ability to be dynamically loadable.
2656 + */
2657 +void engine_load_devcrypto_int(void)
2658 +{
2659 + ENGINE *e = NULL;
2660 +
2661 + if (!open_devcrypto())
2662 + return;
2663 +
2664 + if ((e = ENGINE_new()) == NULL
2665 + || !bind_devcrypto(e)) {
2666 + close_devcrypto();
2667 + ENGINE_free(e);
2668 + return;
2669 + }
2670 +
2671 + ENGINE_add(e);
2672 + ENGINE_free(e); /* Loose our local reference */
2673 + ERR_clear_error();
2674 +}
2675 +
2676 +#else
2677 +
2678 +static int bind_helper(ENGINE *e, const char *id)
2679 +{
2680 + if ((id && (strcmp(id, engine_devcrypto_id) != 0))
2681 + || !open_devcrypto())
2682 + return 0;
2683 + if (!bind_devcrypto(e)) {
2684 + close_devcrypto();
2685 + return 0;
2686 + }
2687 + return 1;
2688 +}
2689 +
2690 +IMPLEMENT_DYNAMIC_CHECK_FN()
2691 +IMPLEMENT_DYNAMIC_BIND_FN(bind_helper)
2692 +
2693 +#endif
OpenWrt Source Repository