e_afalg.c@ 83531

Last change on this file since 83531 was 83531, checked in by vboxsync, 5 years ago
setting svn:sync-process=export for openssl-1.1.1f, all files except tests
File size: 24.3 KB

Line
1	/*
2	* Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved.
3	*
4	* Licensed under the OpenSSL license (the "License"). You may not use
5	* this file except in compliance with the License. You can obtain a copy
6	* in the file LICENSE in the source distribution or at
7	* https://www.openssl.org/source/license.html
8	*/
9
10	/* Required for vmsplice */
11	#ifndef _GNU_SOURCE
12	# define _GNU_SOURCE
13	#endif
14	#include <stdio.h>
15	#include <string.h>
16	#include <unistd.h>
17
18	#include <openssl/engine.h>
19	#include <openssl/async.h>
20	#include <openssl/err.h>
21	#include "internal/nelem.h"
22
23	#include <sys/socket.h>
24	#include <linux/version.h>
25	#define K_MAJ 4
26	#define K_MIN1 1
27	#define K_MIN2 0
28	#if LINUX_VERSION_CODE < KERNEL_VERSION(K_MAJ, K_MIN1, K_MIN2) \|\| \
29	!defined(AF_ALG)
30	# ifndef PEDANTIC
31	# warning "AFALG ENGINE requires Kernel Headers >= 4.1.0"
32	# warning "Skipping Compilation of AFALG engine"
33	# endif
34	void engine_load_afalg_int(void);
35	void engine_load_afalg_int(void)
36	{
37	}
38	#else
39
40	# include <linux/if_alg.h>
41	# include <fcntl.h>
42	# include <sys/utsname.h>
43
44	# include <linux/aio_abi.h>
45	# include <sys/syscall.h>
46	# include <errno.h>
47
48	# include "e_afalg.h"
49	# include "e_afalg_err.c"
50
51	# ifndef SOL_ALG
52	# define SOL_ALG 279
53	# endif
54
55	# ifdef ALG_ZERO_COPY
56	# ifndef SPLICE_F_GIFT
57	# define SPLICE_F_GIFT (0x08)
58	# endif
59	# endif
60
61	# define ALG_AES_IV_LEN 16
62	# define ALG_IV_LEN(len) (sizeof(struct af_alg_iv) + (len))
63	# define ALG_OP_TYPE unsigned int
64	# define ALG_OP_LEN (sizeof(ALG_OP_TYPE))
65
66	# ifdef OPENSSL_NO_DYNAMIC_ENGINE
67	void engine_load_afalg_int(void);
68	# endif
69
70	/* Local Linkage Functions */
71	static int afalg_init_aio(afalg_aio *aio);
72	static int afalg_fin_cipher_aio(afalg_aio *ptr, int sfd,
73	unsigned char *buf, size_t len);
74	static int afalg_create_sk(afalg_ctx actx, const char ciphertype,
75	const char *ciphername);
76	static int afalg_destroy(ENGINE *e);
77	static int afalg_init(ENGINE *e);
78	static int afalg_finish(ENGINE *e);
79	static const EVP_CIPHER *afalg_aes_cbc(int nid);
80	static cbc_handles *get_cipher_handle(int nid);
81	static int afalg_ciphers(ENGINE e, const EVP_CIPHER *cipher,
82	const int **nids, int nid);
83	static int afalg_cipher_init(EVP_CIPHER_CTX ctx, const unsigned char key,
84	const unsigned char *iv, int enc);
85	static int afalg_do_cipher(EVP_CIPHER_CTX ctx, unsigned char out,
86	const unsigned char *in, size_t inl);
87	static int afalg_cipher_cleanup(EVP_CIPHER_CTX *ctx);
88	static int afalg_chk_platform(void);
89
90	/* Engine Id and Name */
91	static const char *engine_afalg_id = "afalg";
92	static const char *engine_afalg_name = "AFALG engine support";
93
94	static int afalg_cipher_nids[] = {
95	NID_aes_128_cbc,
96	NID_aes_192_cbc,
97	NID_aes_256_cbc,
98	};
99
100	static cbc_handles cbc_handle[] = {{AES_KEY_SIZE_128, NULL},
101	{AES_KEY_SIZE_192, NULL},
102	{AES_KEY_SIZE_256, NULL}};
103
104	static ossl_inline int io_setup(unsigned n, aio_context_t *ctx)
105	{
106	return syscall(__NR_io_setup, n, ctx);
107	}
108
109	static ossl_inline int eventfd(int n)
110	{
111	return syscall(__NR_eventfd2, n, 0);
112	}
113
114	static ossl_inline int io_destroy(aio_context_t ctx)
115	{
116	return syscall(__NR_io_destroy, ctx);
117	}
118
119	static ossl_inline int io_read(aio_context_t ctx, long n, struct iocb **iocb)
120	{
121	return syscall(__NR_io_submit, ctx, n, iocb);
122	}
123
124	static ossl_inline int io_getevents(aio_context_t ctx, long min, long max,
125	struct io_event *events,
126	struct timespec *timeout)
127	{
128	return syscall(__NR_io_getevents, ctx, min, max, events, timeout);
129	}
130
131	static void afalg_waitfd_cleanup(ASYNC_WAIT_CTX ctx, const void key,
132	OSSL_ASYNC_FD waitfd, void *custom)
133	{
134	close(waitfd);
135	}
136
137	static int afalg_setup_async_event_notification(afalg_aio *aio)
138	{
139	ASYNC_JOB *job;
140	ASYNC_WAIT_CTX *waitctx;
141	void *custom = NULL;
142	int ret;
143
144	if ((job = ASYNC_get_current_job()) != NULL) {
145	/* Async mode */
146	waitctx = ASYNC_get_wait_ctx(job);
147	if (waitctx == NULL) {
148	ALG_WARN("%s(%d): ASYNC_get_wait_ctx error", __FILE__, __LINE__);
149	return 0;
150	}
151	/* Get waitfd from ASYNC_WAIT_CTX if it is already set */
152	ret = ASYNC_WAIT_CTX_get_fd(waitctx, engine_afalg_id,
153	&aio->efd, &custom);
154	if (ret == 0) {
155	/*
156	* waitfd is not set in ASYNC_WAIT_CTX, create a new one
157	* and set it. efd will be signaled when AIO operation completes
158	*/
159	aio->efd = eventfd(0);
160	if (aio->efd == -1) {
161	ALG_PERR("%s(%d): Failed to get eventfd : ", __FILE__,
162	__LINE__);
163	AFALGerr(AFALG_F_AFALG_SETUP_ASYNC_EVENT_NOTIFICATION,
164	AFALG_R_EVENTFD_FAILED);
165	return 0;
166	}
167	ret = ASYNC_WAIT_CTX_set_wait_fd(waitctx, engine_afalg_id,
168	aio->efd, custom,
169	afalg_waitfd_cleanup);
170	if (ret == 0) {
171	ALG_WARN("%s(%d): Failed to set wait fd", __FILE__, __LINE__);
172	close(aio->efd);
173	return 0;
174	}
175	/* make fd non-blocking in async mode */
176	if (fcntl(aio->efd, F_SETFL, O_NONBLOCK) != 0) {
177	ALG_WARN("%s(%d): Failed to set event fd as NONBLOCKING",
178	__FILE__, __LINE__);
179	}
180	}
181	aio->mode = MODE_ASYNC;
182	} else {
183	/* Sync mode */
184	aio->efd = eventfd(0);
185	if (aio->efd == -1) {
186	ALG_PERR("%s(%d): Failed to get eventfd : ", __FILE__, __LINE__);
187	AFALGerr(AFALG_F_AFALG_SETUP_ASYNC_EVENT_NOTIFICATION,
188	AFALG_R_EVENTFD_FAILED);
189	return 0;
190	}
191	aio->mode = MODE_SYNC;
192	}
193	return 1;
194	}
195
196	static int afalg_init_aio(afalg_aio *aio)
197	{
198	int r = -1;
199
200	/* Initialise for AIO */
201	aio->aio_ctx = 0;
202	r = io_setup(MAX_INFLIGHTS, &aio->aio_ctx);
203	if (r < 0) {
204	ALG_PERR("%s(%d): io_setup error : ", __FILE__, __LINE__);
205	AFALGerr(AFALG_F_AFALG_INIT_AIO, AFALG_R_IO_SETUP_FAILED);
206	return 0;
207	}
208
209	memset(aio->cbt, 0, sizeof(aio->cbt));
210	aio->efd = -1;
211	aio->mode = MODE_UNINIT;
212
213	return 1;
214	}
215
216	static int afalg_fin_cipher_aio(afalg_aio aio, int sfd, unsigned char buf,
217	size_t len)
218	{
219	int r;
220	int retry = 0;
221	unsigned int done = 0;
222	struct iocb *cb;
223	struct timespec timeout;
224	struct io_event events[MAX_INFLIGHTS];
225	u_int64_t eval = 0;
226
227	timeout.tv_sec = 0;
228	timeout.tv_nsec = 0;
229
230	/* if efd has not been initialised yet do it here */
231	if (aio->mode == MODE_UNINIT) {
232	r = afalg_setup_async_event_notification(aio);
233	if (r == 0)
234	return 0;
235	}
236
237	cb = &(aio->cbt[0 % MAX_INFLIGHTS]);
238	memset(cb, '\0', sizeof(*cb));
239	cb->aio_fildes = sfd;
240	cb->aio_lio_opcode = IOCB_CMD_PREAD;
241	/*
242	* The pointer has to be converted to unsigned value first to avoid
243	* sign extension on cast to 64 bit value in 32-bit builds
244	*/
245	cb->aio_buf = (size_t)buf;
246	cb->aio_offset = 0;
247	cb->aio_data = 0;
248	cb->aio_nbytes = len;
249	cb->aio_flags = IOCB_FLAG_RESFD;
250	cb->aio_resfd = aio->efd;
251
252	/*
253	* Perform AIO read on AFALG socket, this in turn performs an async
254	* crypto operation in kernel space
255	*/
256	r = io_read(aio->aio_ctx, 1, &cb);
257	if (r < 0) {
258	ALG_PWARN("%s(%d): io_read failed : ", __FILE__, __LINE__);
259	return 0;
260	}
261
262	do {
263	/* While AIO read is being performed pause job */
264	ASYNC_pause_job();
265
266	/* Check for completion of AIO read */
267	r = read(aio->efd, &eval, sizeof(eval));
268	if (r < 0) {
269	if (errno == EAGAIN \|\| errno == EWOULDBLOCK)
270	continue;
271	ALG_PERR("%s(%d): read failed for event fd : ", __FILE__, __LINE__);
272	return 0;
273	} else if (r == 0 \|\| eval <= 0) {
274	ALG_WARN("%s(%d): eventfd read %d bytes, eval = %lu\n", __FILE__,
275	__LINE__, r, eval);
276	}
277	if (eval > 0) {
278
279	/* Get results of AIO read */
280	r = io_getevents(aio->aio_ctx, 1, MAX_INFLIGHTS,
281	events, &timeout);
282	if (r > 0) {
283	/*
284	* events.res indicates the actual status of the operation.
285	* Handle the error condition first.
286	*/
287	if (events[0].res < 0) {
288	/*
289	* Underlying operation cannot be completed at the time
290	* of previous submission. Resubmit for the operation.
291	*/
292	if (events[0].res == -EBUSY && retry++ < 3) {
293	r = io_read(aio->aio_ctx, 1, &cb);
294	if (r < 0) {
295	ALG_PERR("%s(%d): retry %d for io_read failed : ",
296	__FILE__, __LINE__, retry);
297	return 0;
298	}
299	continue;
300	} else {
301	/*
302	* Retries exceed for -EBUSY or unrecoverable error
303	* condition for this instance of operation.
304	*/
305	ALG_WARN
306	("%s(%d): Crypto Operation failed with code %lld\n",
307	__FILE__, __LINE__, events[0].res);
308	return 0;
309	}
310	}
311	/* Operation successful. */
312	done = 1;
313	} else if (r < 0) {
314	ALG_PERR("%s(%d): io_getevents failed : ", __FILE__, __LINE__);
315	return 0;
316	} else {
317	ALG_WARN("%s(%d): io_geteventd read 0 bytes\n", __FILE__,
318	__LINE__);
319	}
320	}
321	} while (!done);
322
323	return 1;
324	}
325
326	static ossl_inline void afalg_set_op_sk(struct cmsghdr *cmsg,
327	const ALG_OP_TYPE op)
328	{
329	cmsg->cmsg_level = SOL_ALG;
330	cmsg->cmsg_type = ALG_SET_OP;
331	cmsg->cmsg_len = CMSG_LEN(ALG_OP_LEN);
332	memcpy(CMSG_DATA(cmsg), &op, ALG_OP_LEN);
333	}
334
335	static void afalg_set_iv_sk(struct cmsghdr cmsg, const unsigned char iv,
336	const unsigned int len)
337	{
338	struct af_alg_iv *aiv;
339
340	cmsg->cmsg_level = SOL_ALG;
341	cmsg->cmsg_type = ALG_SET_IV;
342	cmsg->cmsg_len = CMSG_LEN(ALG_IV_LEN(len));
343	aiv = (struct af_alg_iv *)CMSG_DATA(cmsg);
344	aiv->ivlen = len;
345	memcpy(aiv->iv, iv, len);
346	}
347
348	static ossl_inline int afalg_set_key(afalg_ctx actx, const unsigned char key,
349	const int klen)
350	{
351	int ret;
352	ret = setsockopt(actx->bfd, SOL_ALG, ALG_SET_KEY, key, klen);
353	if (ret < 0) {
354	ALG_PERR("%s(%d): Failed to set socket option : ", __FILE__, __LINE__);
355	AFALGerr(AFALG_F_AFALG_SET_KEY, AFALG_R_SOCKET_SET_KEY_FAILED);
356	return 0;
357	}
358	return 1;
359	}
360
361	static int afalg_create_sk(afalg_ctx actx, const char ciphertype,
362	const char *ciphername)
363	{
364	struct sockaddr_alg sa;
365	int r = -1;
366
367	actx->bfd = actx->sfd = -1;
368
369	memset(&sa, 0, sizeof(sa));
370	sa.salg_family = AF_ALG;
371	OPENSSL_strlcpy((char *) sa.salg_type, ciphertype, sizeof(sa.salg_type));
372	OPENSSL_strlcpy((char *) sa.salg_name, ciphername, sizeof(sa.salg_name));
373
374	actx->bfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
375	if (actx->bfd == -1) {
376	ALG_PERR("%s(%d): Failed to open socket : ", __FILE__, __LINE__);
377	AFALGerr(AFALG_F_AFALG_CREATE_SK, AFALG_R_SOCKET_CREATE_FAILED);
378	goto err;
379	}
380
381	r = bind(actx->bfd, (struct sockaddr *)&sa, sizeof(sa));
382	if (r < 0) {
383	ALG_PERR("%s(%d): Failed to bind socket : ", __FILE__, __LINE__);
384	AFALGerr(AFALG_F_AFALG_CREATE_SK, AFALG_R_SOCKET_BIND_FAILED);
385	goto err;
386	}
387
388	actx->sfd = accept(actx->bfd, NULL, 0);
389	if (actx->sfd < 0) {
390	ALG_PERR("%s(%d): Socket Accept Failed : ", __FILE__, __LINE__);
391	AFALGerr(AFALG_F_AFALG_CREATE_SK, AFALG_R_SOCKET_ACCEPT_FAILED);
392	goto err;
393	}
394
395	return 1;
396
397	err:
398	if (actx->bfd >= 0)
399	close(actx->bfd);
400	if (actx->sfd >= 0)
401	close(actx->sfd);
402	actx->bfd = actx->sfd = -1;
403	return 0;
404	}
405
406	static int afalg_start_cipher_sk(afalg_ctx actx, const unsigned char in,
407	size_t inl, const unsigned char *iv,
408	unsigned int enc)
409	{
410	struct msghdr msg = { 0 };
411	struct cmsghdr *cmsg;
412	struct iovec iov;
413	ssize_t sbytes;
414	# ifdef ALG_ZERO_COPY
415	int ret;
416	# endif
417	char cbuf[CMSG_SPACE(ALG_IV_LEN(ALG_AES_IV_LEN)) + CMSG_SPACE(ALG_OP_LEN)];
418
419	memset(cbuf, 0, sizeof(cbuf));
420	msg.msg_control = cbuf;
421	msg.msg_controllen = sizeof(cbuf);
422
423	/*
424	* cipher direction (i.e. encrypt or decrypt) and iv are sent to the
425	* kernel as part of sendmsg()'s ancillary data
426	*/
427	cmsg = CMSG_FIRSTHDR(&msg);
428	afalg_set_op_sk(cmsg, enc);
429	cmsg = CMSG_NXTHDR(&msg, cmsg);
430	afalg_set_iv_sk(cmsg, iv, ALG_AES_IV_LEN);
431
432	/* iov that describes input data */
433	iov.iov_base = (unsigned char *)in;
434	iov.iov_len = inl;
435
436	msg.msg_flags = MSG_MORE;
437
438	# ifdef ALG_ZERO_COPY
439	/*
440	* ZERO_COPY mode
441	* Works best when buffer is 4k aligned
442	* OPENS: out of place processing (i.e. out != in)
443	*/
444
445	/* Input data is not sent as part of call to sendmsg() */
446	msg.msg_iovlen = 0;
447	msg.msg_iov = NULL;
448
449	/* Sendmsg() sends iv and cipher direction to the kernel */
450	sbytes = sendmsg(actx->sfd, &msg, 0);
451	if (sbytes < 0) {
452	ALG_PERR("%s(%d): sendmsg failed for zero copy cipher operation : ",
453	__FILE__, __LINE__);
454	return 0;
455	}
456
457	/*
458	* vmsplice and splice are used to pin the user space input buffer for
459	* kernel space processing avoiding copies from user to kernel space
460	*/
461	ret = vmsplice(actx->zc_pipe[1], &iov, 1, SPLICE_F_GIFT);
462	if (ret < 0) {
463	ALG_PERR("%s(%d): vmsplice failed : ", __FILE__, __LINE__);
464	return 0;
465	}
466
467	ret = splice(actx->zc_pipe[0], NULL, actx->sfd, NULL, inl, 0);
468	if (ret < 0) {
469	ALG_PERR("%s(%d): splice failed : ", __FILE__, __LINE__);
470	return 0;
471	}
472	# else
473	msg.msg_iovlen = 1;
474	msg.msg_iov = &iov;
475
476	/* Sendmsg() sends iv, cipher direction and input data to the kernel */
477	sbytes = sendmsg(actx->sfd, &msg, 0);
478	if (sbytes < 0) {
479	ALG_PERR("%s(%d): sendmsg failed for cipher operation : ", __FILE__,
480	__LINE__);
481	return 0;
482	}
483
484	if (sbytes != (ssize_t) inl) {
485	ALG_WARN("Cipher operation send bytes %zd != inlen %zd\n", sbytes,
486	inl);
487	return 0;
488	}
489	# endif
490
491	return 1;
492	}
493
494	static int afalg_cipher_init(EVP_CIPHER_CTX ctx, const unsigned char key,
495	const unsigned char *iv, int enc)
496	{
497	int ciphertype;
498	int ret;
499	afalg_ctx *actx;
500	const char *ciphername;
501
502	if (ctx == NULL \|\| key == NULL) {
503	ALG_WARN("%s(%d): Null Parameter\n", __FILE__, __LINE__);
504	return 0;
505	}
506
507	if (EVP_CIPHER_CTX_cipher(ctx) == NULL) {
508	ALG_WARN("%s(%d): Cipher object NULL\n", __FILE__, __LINE__);
509	return 0;
510	}
511
512	actx = EVP_CIPHER_CTX_get_cipher_data(ctx);
513	if (actx == NULL) {
514	ALG_WARN("%s(%d): Cipher data NULL\n", __FILE__, __LINE__);
515	return 0;
516	}
517
518	ciphertype = EVP_CIPHER_CTX_nid(ctx);
519	switch (ciphertype) {
520	case NID_aes_128_cbc:
521	case NID_aes_192_cbc:
522	case NID_aes_256_cbc:
523	ciphername = "cbc(aes)";
524	break;
525	default:
526	ALG_WARN("%s(%d): Unsupported Cipher type %d\n", __FILE__, __LINE__,
527	ciphertype);
528	return 0;
529	}
530
531	if (ALG_AES_IV_LEN != EVP_CIPHER_CTX_iv_length(ctx)) {
532	ALG_WARN("%s(%d): Unsupported IV length :%d\n", __FILE__, __LINE__,
533	EVP_CIPHER_CTX_iv_length(ctx));
534	return 0;
535	}
536
537	/* Setup AFALG socket for crypto processing */
538	ret = afalg_create_sk(actx, "skcipher", ciphername);
539	if (ret < 1)
540	return 0;
541
542
543	ret = afalg_set_key(actx, key, EVP_CIPHER_CTX_key_length(ctx));
544	if (ret < 1)
545	goto err;
546
547	/* Setup AIO ctx to allow async AFALG crypto processing */
548	if (afalg_init_aio(&actx->aio) == 0)
549	goto err;
550
551	# ifdef ALG_ZERO_COPY
552	pipe(actx->zc_pipe);
553	# endif
554
555	actx->init_done = MAGIC_INIT_NUM;
556
557	return 1;
558
559	err:
560	close(actx->sfd);
561	close(actx->bfd);
562	return 0;
563	}
564
565	static int afalg_do_cipher(EVP_CIPHER_CTX ctx, unsigned char out,
566	const unsigned char *in, size_t inl)
567	{
568	afalg_ctx *actx;
569	int ret;
570	char nxtiv[ALG_AES_IV_LEN] = { 0 };
571
572	if (ctx == NULL \|\| out == NULL \|\| in == NULL) {
573	ALG_WARN("NULL parameter passed to function %s(%d)\n", __FILE__,
574	__LINE__);
575	return 0;
576	}
577
578	actx = (afalg_ctx *) EVP_CIPHER_CTX_get_cipher_data(ctx);
579	if (actx == NULL \|\| actx->init_done != MAGIC_INIT_NUM) {
580	ALG_WARN("%s afalg ctx passed\n",
581	ctx == NULL ? "NULL" : "Uninitialised");
582	return 0;
583	}
584
585	/*
586	* set iv now for decrypt operation as the input buffer can be
587	* overwritten for inplace operation where in = out.
588	*/
589	if (EVP_CIPHER_CTX_encrypting(ctx) == 0) {
590	memcpy(nxtiv, in + (inl - ALG_AES_IV_LEN), ALG_AES_IV_LEN);
591	}
592
593	/* Send input data to kernel space */
594	ret = afalg_start_cipher_sk(actx, (unsigned char *)in, inl,
595	EVP_CIPHER_CTX_iv(ctx),
596	EVP_CIPHER_CTX_encrypting(ctx));
597	if (ret < 1) {
598	return 0;
599	}
600
601	/* Perform async crypto operation in kernel space */
602	ret = afalg_fin_cipher_aio(&actx->aio, actx->sfd, out, inl);
603	if (ret < 1)
604	return 0;
605
606	if (EVP_CIPHER_CTX_encrypting(ctx)) {
607	memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), out + (inl - ALG_AES_IV_LEN),
608	ALG_AES_IV_LEN);
609	} else {
610	memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), nxtiv, ALG_AES_IV_LEN);
611	}
612
613	return 1;
614	}
615
616	static int afalg_cipher_cleanup(EVP_CIPHER_CTX *ctx)
617	{
618	afalg_ctx *actx;
619
620	if (ctx == NULL) {
621	ALG_WARN("NULL parameter passed to function %s(%d)\n", __FILE__,
622	__LINE__);
623	return 0;
624	}
625
626	actx = (afalg_ctx *) EVP_CIPHER_CTX_get_cipher_data(ctx);
627	if (actx == NULL \|\| actx->init_done != MAGIC_INIT_NUM) {
628	ALG_WARN("%s afalg ctx passed\n",
629	ctx == NULL ? "NULL" : "Uninitialised");
630	return 0;
631	}
632
633	close(actx->sfd);
634	close(actx->bfd);
635	# ifdef ALG_ZERO_COPY
636	close(actx->zc_pipe[0]);
637	close(actx->zc_pipe[1]);
638	# endif
639	/* close efd in sync mode, async mode is closed in afalg_waitfd_cleanup() */
640	if (actx->aio.mode == MODE_SYNC)
641	close(actx->aio.efd);
642	io_destroy(actx->aio.aio_ctx);
643
644	return 1;
645	}
646
647	static cbc_handles *get_cipher_handle(int nid)
648	{
649	switch (nid) {
650	case NID_aes_128_cbc:
651	return &cbc_handle[AES_CBC_128];
652	case NID_aes_192_cbc:
653	return &cbc_handle[AES_CBC_192];
654	case NID_aes_256_cbc:
655	return &cbc_handle[AES_CBC_256];
656	default:
657	return NULL;
658	}
659	}
660
661	static const EVP_CIPHER *afalg_aes_cbc(int nid)
662	{
663	cbc_handles *cipher_handle = get_cipher_handle(nid);
664	if (cipher_handle->_hidden == NULL
665	&& ((cipher_handle->_hidden =
666	EVP_CIPHER_meth_new(nid,
667	AES_BLOCK_SIZE,
668	cipher_handle->key_size)) == NULL
669	\|\| !EVP_CIPHER_meth_set_iv_length(cipher_handle->_hidden,
670	AES_IV_LEN)
671	\|\| !EVP_CIPHER_meth_set_flags(cipher_handle->_hidden,
672	EVP_CIPH_CBC_MODE \|
673	EVP_CIPH_FLAG_DEFAULT_ASN1)
674	\|\| !EVP_CIPHER_meth_set_init(cipher_handle->_hidden,
675	afalg_cipher_init)
676	\|\| !EVP_CIPHER_meth_set_do_cipher(cipher_handle->_hidden,
677	afalg_do_cipher)
678	\|\| !EVP_CIPHER_meth_set_cleanup(cipher_handle->_hidden,
679	afalg_cipher_cleanup)
680	\|\| !EVP_CIPHER_meth_set_impl_ctx_size(cipher_handle->_hidden,
681	sizeof(afalg_ctx)))) {
682	EVP_CIPHER_meth_free(cipher_handle->_hidden);
683	cipher_handle->_hidden= NULL;
684	}
685	return cipher_handle->_hidden;
686	}
687
688	static int afalg_ciphers(ENGINE e, const EVP_CIPHER *cipher,
689	const int **nids, int nid)
690	{
691	int r = 1;
692
693	if (cipher == NULL) {
694	*nids = afalg_cipher_nids;
695	return (sizeof(afalg_cipher_nids) / sizeof(afalg_cipher_nids[0]));
696	}
697
698	switch (nid) {
699	case NID_aes_128_cbc:
700	case NID_aes_192_cbc:
701	case NID_aes_256_cbc:
702	*cipher = afalg_aes_cbc(nid);
703	break;
704	default:
705	*cipher = NULL;
706	r = 0;
707	}
708	return r;
709	}
710
711	static int bind_afalg(ENGINE *e)
712	{
713	/* Ensure the afalg error handling is set up */
714	unsigned short i;
715	ERR_load_AFALG_strings();
716
717	if (!ENGINE_set_id(e, engine_afalg_id)
718	\|\| !ENGINE_set_name(e, engine_afalg_name)
719	\|\| !ENGINE_set_destroy_function(e, afalg_destroy)
720	\|\| !ENGINE_set_init_function(e, afalg_init)
721	\|\| !ENGINE_set_finish_function(e, afalg_finish)) {
722	AFALGerr(AFALG_F_BIND_AFALG, AFALG_R_INIT_FAILED);
723	return 0;
724	}
725
726	/*
727	* Create _hidden_aes_xxx_cbc by calling afalg_aes_xxx_cbc
728	* now, as bind_aflag can only be called by one thread at a
729	* time.
730	*/
731	for(i = 0; i < OSSL_NELEM(afalg_cipher_nids); i++) {
732	if (afalg_aes_cbc(afalg_cipher_nids[i]) == NULL) {
733	AFALGerr(AFALG_F_BIND_AFALG, AFALG_R_INIT_FAILED);
734	return 0;
735	}
736	}
737
738	if (!ENGINE_set_ciphers(e, afalg_ciphers)) {
739	AFALGerr(AFALG_F_BIND_AFALG, AFALG_R_INIT_FAILED);
740	return 0;
741	}
742
743	return 1;
744	}
745
746	# ifndef OPENSSL_NO_DYNAMIC_ENGINE
747	static int bind_helper(ENGINE e, const char id)
748	{
749	if (id && (strcmp(id, engine_afalg_id) != 0))
750	return 0;
751
752	if (!afalg_chk_platform())
753	return 0;
754
755	if (!bind_afalg(e))
756	return 0;
757	return 1;
758	}
759
760	IMPLEMENT_DYNAMIC_CHECK_FN()
761	IMPLEMENT_DYNAMIC_BIND_FN(bind_helper)
762	# endif
763
764	static int afalg_chk_platform(void)
765	{
766	int ret;
767	int i;
768	int kver[3] = { -1, -1, -1 };
769	int sock;
770	char *str;
771	struct utsname ut;
772
773	ret = uname(&ut);
774	if (ret != 0) {
775	AFALGerr(AFALG_F_AFALG_CHK_PLATFORM,
776	AFALG_R_FAILED_TO_GET_PLATFORM_INFO);
777	return 0;
778	}
779
780	str = strtok(ut.release, ".");
781	for (i = 0; i < 3 && str != NULL; i++) {
782	kver[i] = atoi(str);
783	str = strtok(NULL, ".");
784	}
785
786	if (KERNEL_VERSION(kver[0], kver[1], kver[2])
787	< KERNEL_VERSION(K_MAJ, K_MIN1, K_MIN2)) {
788	ALG_ERR("ASYNC AFALG not supported this kernel(%d.%d.%d)\n",
789	kver[0], kver[1], kver[2]);
790	ALG_ERR("ASYNC AFALG requires kernel version %d.%d.%d or later\n",
791	K_MAJ, K_MIN1, K_MIN2);
792	AFALGerr(AFALG_F_AFALG_CHK_PLATFORM,
793	AFALG_R_KERNEL_DOES_NOT_SUPPORT_ASYNC_AFALG);
794	return 0;
795	}
796
797	/* Test if we can actually create an AF_ALG socket */
798	sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
799	if (sock == -1) {
800	AFALGerr(AFALG_F_AFALG_CHK_PLATFORM, AFALG_R_SOCKET_CREATE_FAILED);
801	return 0;
802	}
803	close(sock);
804
805	return 1;
806	}
807
808	# ifdef OPENSSL_NO_DYNAMIC_ENGINE
809	static ENGINE *engine_afalg(void)
810	{
811	ENGINE *ret = ENGINE_new();
812	if (ret == NULL)
813	return NULL;
814	if (!bind_afalg(ret)) {
815	ENGINE_free(ret);
816	return NULL;
817	}
818	return ret;
819	}
820
821	void engine_load_afalg_int(void)
822	{
823	ENGINE *toadd;
824
825	if (!afalg_chk_platform())
826	return;
827
828	toadd = engine_afalg();
829	if (toadd == NULL)
830	return;
831	ENGINE_add(toadd);
832	ENGINE_free(toadd);
833	ERR_clear_error();
834	}
835	# endif
836
837	static int afalg_init(ENGINE *e)
838	{
839	return 1;
840	}
841
842	static int afalg_finish(ENGINE *e)
843	{
844	return 1;
845	}
846
847	static int free_cbc(void)
848	{
849	short unsigned int i;
850	for(i = 0; i < OSSL_NELEM(afalg_cipher_nids); i++) {
851	EVP_CIPHER_meth_free(cbc_handle[i]._hidden);
852	cbc_handle[i]._hidden = NULL;
853	}
854	return 1;
855	}
856
857	static int afalg_destroy(ENGINE *e)
858	{
859	ERR_unload_AFALG_strings();
860	free_cbc();
861	return 1;
862	}
863
864	#endif /* KERNEL VERSION */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/openssl-1.1.1f/engines/e_afalg.c@ 83531

Download in other formats: