1
2 /*
3 * CDDL HEADER START
4 *
5 * The contents of this file are subject to the terms of the
6 * Common Development and Distribution License (the "License").
7 * You may not use this file except in compliance with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22
23 /*
24 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28 /*
29 * Deimos - cryptographic acceleration based upon Broadcom 582x.
30 */
31
32 #include <sys/types.h>
33 #include <sys/ddi.h>
34 #include <sys/sunddi.h>
35 #include <sys/kmem.h>
36 #include <sys/note.h>
37 #include <sys/crypto/common.h>
38 #include <sys/crypto/spi.h>
39 #include <sys/crypto/dca.h>
40
41 #if defined(__i386) || defined(__amd64)
42 #include <sys/byteorder.h>
43 #define UNALIGNED_POINTERS_PERMITTED
44 #endif
45
46 /*
47 * 3DES implementation.
48 */
49
50 static int dca_3desstart(dca_t *, uint32_t, dca_request_t *);
51 static void dca_3desdone(dca_request_t *, int);
52
53
54 int
55 dca_3des(crypto_ctx_t *ctx, crypto_data_t *in,
56 crypto_data_t *out, crypto_req_handle_t req, int flags)
57 {
58 int len;
59 int rv;
60 dca_request_t *reqp = ctx->cc_provider_private;
61 dca_request_t *des_ctx = ctx->cc_provider_private;
62 dca_t *dca = ctx->cc_provider;
63 crypto_data_t *nin = &reqp->dr_ctx.in_dup;
64
65 len = dca_length(in);
66 if (len % DESBLOCK) {
67 DBG(dca, DWARN, "input not an integral number of DES blocks");
68 (void) dca_free_context(ctx);
69 if (flags & DR_DECRYPT) {
70 return (CRYPTO_ENCRYPTED_DATA_LEN_RANGE);
71 } else {
72 return (CRYPTO_DATA_LEN_RANGE);
73 }
74 }
75
76 /*
77 * If cd_miscdata non-null then this contains the IV.
78 */
79 if (in->cd_miscdata != NULL) {
80 #ifdef UNALIGNED_POINTERS_PERMITTED
81 uint32_t *p = (uint32_t *)in->cd_miscdata;
82 des_ctx->dr_ctx.iv[0] = htonl(p[0]);
83 des_ctx->dr_ctx.iv[1] = htonl(p[1]);
84 #else
85 uchar_t *p = (uchar_t *)in->cd_miscdata;
86 des_ctx->dr_ctx.iv[0] = p[0]<<24 | p[1]<<16 | p[2]<<8 | p[3];
87 des_ctx->dr_ctx.iv[1] = p[4]<<24 | p[5]<<16 | p[6]<<8 | p[7];
88 #endif /* UNALIGNED_POINTERS_PERMITTED */
89 }
90
91 if (len > dca_length(out)) {
92 DBG(dca, DWARN, "inadequate output space (need %d, got %d)",
93 len, dca_length(out));
94 out->cd_length = len;
95 /* Do not free the context since the app will call again */
96 return (CRYPTO_BUFFER_TOO_SMALL);
97 }
98
99 if ((rv = dca_verifyio(in, out)) != CRYPTO_SUCCESS) {
100 (void) dca_free_context(ctx);
101 return (rv);
102 }
103
104 /* special handling for null-sized input buffers */
105 if (len == 0) {
106 out->cd_length = 0;
107 (void) dca_free_context(ctx);
108 return (CRYPTO_SUCCESS);
109 }
110
111 /*
112 * Make a local copy of the input crypto_data_t structure. This
113 * allows it to be manipulated locally and for dealing with in-place
114 * data (ie in == out). Note that "nin" has been pre-allocated,
115 * and only fields are copied, not actual data.
116 */
117 if ((rv = dca_dupcrypto(in, nin)) != CRYPTO_SUCCESS) {
118 (void) dca_free_context(ctx);
119 return (rv);
120 }
121
122 /* Set output to zero ready to take the processed data */
123 out->cd_length = 0;
124
125 reqp->dr_kcf_req = req;
126 reqp->dr_in = nin;
127 reqp->dr_out = out;
128 reqp->dr_job_stat = DS_3DESJOBS;
129 reqp->dr_byte_stat = DS_3DESBYTES;
130
131 rv = dca_3desstart(dca, flags, reqp);
132
133 /* Context will be freed in the kCF callback function otherwise */
134 if (rv != CRYPTO_QUEUED && rv != CRYPTO_BUFFER_TOO_SMALL) {
135 (void) dca_free_context(ctx);
136 }
137 return (rv);
138 }
139
140
141 void
142 dca_3desctxfree(void *arg)
143 {
144 crypto_ctx_t *ctx = (crypto_ctx_t *)arg;
145 dca_request_t *des_ctx = ctx->cc_provider_private;
146
147 if (des_ctx == NULL)
148 return;
149
150 des_ctx->dr_ctx.atomic = 0;
151 des_ctx->dr_ctx.ctx_cm_type = 0;
152 ctx->cc_provider_private = NULL;
153
154 if (des_ctx->destroy)
155 dca_destroyreq(des_ctx);
156 else
157 /* Return it to the pool */
158 dca_freereq(des_ctx);
159 }
160
161 int
162 dca_3desupdate(crypto_ctx_t *ctx, crypto_data_t *in,
163 crypto_data_t *out, crypto_req_handle_t req, int flags)
164 {
165 int len;
166 int rawlen;
167 int rv;
168 dca_request_t *reqp = ctx->cc_provider_private;
169 dca_request_t *des_ctx = ctx->cc_provider_private;
170 dca_t *dca = ctx->cc_provider;
171 crypto_data_t *nin = &reqp->dr_ctx.in_dup;
172
173 rawlen = dca_length(in) + des_ctx->dr_ctx.residlen;
174
175 len = ROUNDDOWN(rawlen, DESBLOCK);
176 /*
177 * If cd_miscdata non-null then this contains the IV.
178 */
179 if (in->cd_miscdata != NULL) {
180 #ifdef UNALIGNED_POINTERS_PERMITTED
181 uint32_t *p = (uint32_t *)in->cd_miscdata;
182 des_ctx->dr_ctx.iv[0] = htonl(p[0]);
183 des_ctx->dr_ctx.iv[1] = htonl(p[1]);
184 #else
185 uchar_t *p = (uchar_t *)in->cd_miscdata;
186 des_ctx->dr_ctx.iv[0] = p[0]<<24 | p[1]<<16 | p[2]<<8 | p[3];
187 des_ctx->dr_ctx.iv[1] = p[4]<<24 | p[5]<<16 | p[6]<<8 | p[7];
188 #endif /* UNALIGNED_POINTERS_PERMITTED */
189 }
190
191 if (len > dca_length(out)) {
192 DBG(dca, DWARN, "not enough output space (need %d, got %d)",
193 len, dca_length(out));
194 out->cd_length = len;
195 /* Do not free the context since the app will call again */
196 return (CRYPTO_BUFFER_TOO_SMALL);
197 }
198
199 if ((rv = dca_verifyio(in, out)) != CRYPTO_SUCCESS) {
200 (void) dca_free_context(ctx);
201 return (rv);
202 }
203
204 reqp->dr_kcf_req = req;
205
206 /*
207 * From here on out, we are committed.
208 */
209
210 if (len == 0) {
211 /*
212 * No blocks being encrypted, so we just accumulate the
213 * input for the next pass and return.
214 */
215 if ((rv = dca_getbufbytes(in, 0,
216 (rawlen % DESBLOCK) - des_ctx->dr_ctx.residlen,
217 des_ctx->dr_ctx.resid + des_ctx->dr_ctx.residlen)) !=
218 CRYPTO_SUCCESS) {
219 DBG(dca, DWARN,
220 "dca_3desupdate: dca_getbufbytes() failed for residual only pass");
221 dca_freereq(reqp);
222 return (rv);
223 }
224 des_ctx->dr_ctx.residlen = rawlen % DESBLOCK;
225
226 out->cd_length = 0;
227 /*
228 * Do not free the context here since it will be done
229 * in the final function
230 */
231 return (CRYPTO_SUCCESS);
232 }
233
234 /*
235 * Set up rbuf for previous residual data.
236 */
237 if (des_ctx->dr_ctx.residlen) {
238 bcopy(des_ctx->dr_ctx.resid, des_ctx->dr_ctx.activeresid,
239 des_ctx->dr_ctx.residlen);
240 des_ctx->dr_ctx.activeresidlen = des_ctx->dr_ctx.residlen;
241 }
242
243 /*
244 * Locate and save residual data for next encrypt_update.
245 */
246 if ((rv = dca_getbufbytes(in, len - des_ctx->dr_ctx.residlen,
247 rawlen % DESBLOCK, des_ctx->dr_ctx.resid)) != CRYPTO_SUCCESS) {
248 DBG(dca, DWARN, "dca_3desupdate: dca_getbufbytes() failed");
249 (void) dca_free_context(ctx);
250 return (rv);
251 }
252
253 /* Calculate new residual length. */
254 des_ctx->dr_ctx.residlen = rawlen % DESBLOCK;
255
256 /*
257 * Make a local copy of the input crypto_data_t structure. This
258 * allows it to be manipulated locally and for dealing with in-place
259 * data (ie in == out).
260 */
261 if ((rv = dca_dupcrypto(in, nin)) != CRYPTO_SUCCESS) {
262 (void) dca_free_context(ctx);
263 return (rv);
264 }
265
266 /* Set output to zero ready to take the processed data */
267 out->cd_length = 0;
268
269 reqp->dr_in = nin;
270 reqp->dr_out = out;
271 reqp->dr_job_stat = DS_3DESJOBS;
272 reqp->dr_byte_stat = DS_3DESBYTES;
273
274 rv = dca_3desstart(dca, flags, reqp);
275
276 /*
277 * As this is multi-part the context is cleared on success
278 * (CRYPTO_QUEUED) in dca_3desfinal().
279 */
280
281 if (rv != CRYPTO_QUEUED && rv != CRYPTO_BUFFER_TOO_SMALL) {
282 (void) dca_free_context(ctx);
283 }
284 return (rv);
285 }
286
287 int
288 dca_3desfinal(crypto_ctx_t *ctx, crypto_data_t *out, int mode)
289 {
290 dca_request_t *des_ctx = ctx->cc_provider_private;
291 dca_t *dca = ctx->cc_provider;
292 int rv = CRYPTO_SUCCESS;
293
294 ASSERT(ctx->cc_provider_private != NULL);
295 /*
296 * There must be no unprocessed ciphertext/plaintext.
297 * This happens if the length of the last data is
298 * not a multiple of the DES block length.
299 */
300 if (des_ctx->dr_ctx.residlen != 0) {
301 DBG(dca, DWARN, "dca_3desfinal: invalid nonzero residual");
302 if (mode & DR_DECRYPT) {
303 rv = CRYPTO_ENCRYPTED_DATA_LEN_RANGE;
304 } else {
305 rv = CRYPTO_DATA_LEN_RANGE;
306 }
307 }
308 (void) dca_free_context(ctx);
309 out->cd_length = 0;
310 return (rv);
311 }
312
313 int
314 dca_3desatomic(crypto_provider_handle_t provider,
315 crypto_session_id_t session_id, crypto_mechanism_t *mechanism,
316 crypto_key_t *key, crypto_data_t *input, crypto_data_t *output,
317 int kmflag, crypto_req_handle_t req, int mode)
318 {
319 crypto_ctx_t ctx; /* on the stack */
320 int rv;
321
322 ctx.cc_provider = provider;
323 ctx.cc_session = session_id;
324
325 /*
326 * Input must be a multiple of the block size. This test only
327 * works for non-padded mechanisms when the blocksize is 2^N.
328 */
329 if ((dca_length(input) & (DESBLOCK - 1)) != 0) {
330 DBG(NULL, DWARN, "dca_3desatomic: input not multiple of BS");
331 if (mode & DR_DECRYPT) {
332 return (CRYPTO_ENCRYPTED_DATA_LEN_RANGE);
333 } else {
334 return (CRYPTO_DATA_LEN_RANGE);
335 }
336 }
337
338 rv = dca_3desctxinit(&ctx, mechanism, key, kmflag, mode);
339 if (rv != CRYPTO_SUCCESS) {
340 DBG(NULL, DWARN, "dca_3desatomic: dca_3desctxinit() failed");
341 return (rv);
342 }
343
344 /*
345 * Set the atomic flag so that the hardware callback function
346 * will free the context.
347 */
348 ((dca_request_t *)ctx.cc_provider_private)->dr_ctx.atomic = 1;
349
350 /* check for inplace ops */
351 if (input == output) {
352 ((dca_request_t *)ctx.cc_provider_private)->dr_flags
353 |= DR_INPLACE;
354 }
355
356 rv = dca_3des(&ctx, input, output, req, mode);
357 if ((rv != CRYPTO_QUEUED) && (rv != CRYPTO_SUCCESS)) {
358 DBG(NULL, DWARN, "dca_3desatomic: dca_3des() failed");
359 output->cd_length = 0;
360 }
361
362 /*
363 * The features of dca_3desfinal() are implemented within
364 * dca_3desdone() due to the asynchronous nature of dca_3des().
365 */
366
367 /*
368 * The context will be freed in the hardware callback function if it
369 * is queued
370 */
371 if (rv != CRYPTO_QUEUED)
372 dca_3desctxfree(&ctx);
373
374 return (rv);
375 }
376
377 int
378 dca_3desstart(dca_t *dca, uint32_t flags, dca_request_t *reqp)
379 {
380 size_t len;
381 crypto_data_t *in = reqp->dr_in;
382 int rv;
383 dca_request_t *ctx = reqp;
384 uint32_t iv[2];
385
386 /*
387 * Preconditions:
388 * 1) in and out point to the "right" buffers.
389 * 2) in->b_bcount - in->b_resid == initial offset
390 * 3) likewise for out
391 * 4) there is enough space in the output
392 * 5) we perform a block for block encrypt
393 */
394 len = ctx->dr_ctx.activeresidlen + dca_length(in);
395 len = ROUNDDOWN(min(len, MAXPACKET), DESBLOCK);
396 reqp->dr_pkt_length = (uint16_t)len;
397
398 /* collect IVs for this pass */
399 iv[0] = ctx->dr_ctx.iv[0];
400 iv[1] = ctx->dr_ctx.iv[1];
401
402 /*
403 * And also, for decrypt, collect the IV for the next pass. For
404 * decrypt, the IV must be collected BEFORE decryption, or else
405 * we will lose it. (For encrypt, we grab the IV AFTER encryption,
406 * in dca_3desdone.
407 */
408 if (flags & DR_DECRYPT) {
409 uchar_t ivstore[DESBLOCK];
410 #ifdef UNALIGNED_POINTERS_PERMITTED
411 uint32_t *ivp = (uint32_t *)ivstore;
412 #else
413 uchar_t *ivp = ivstore;
414 #endif /* UNALIGNED_POINTERS_PERMITTED */
415
416 /* get last 8 bytes of ciphertext for IV of next op */
417 /*
418 * If we're processing only a DESBLOCKS worth of data
419 * and there is active residual present then it will be
420 * needed for the IV also.
421 */
422 if ((len == DESBLOCK) && ctx->dr_ctx.activeresidlen) {
423 /* Bring the active residual into play */
424 bcopy(ctx->dr_ctx.activeresid, ivstore,
425 ctx->dr_ctx.activeresidlen);
426 rv = dca_getbufbytes(in, 0,
427 DESBLOCK - ctx->dr_ctx.activeresidlen,
428 ivstore + ctx->dr_ctx.activeresidlen);
429 } else {
430 rv = dca_getbufbytes(in,
431 len - DESBLOCK - ctx->dr_ctx.activeresidlen,
432 DESBLOCK, ivstore);
433 }
434
435 if (rv != CRYPTO_SUCCESS) {
436 DBG(dca, DWARN,
437 "dca_3desstart: dca_getbufbytes() failed");
438 return (rv);
439 }
440
441 /* store as a pair of native 32-bit values */
442 #ifdef UNALIGNED_POINTERS_PERMITTED
443 ctx->dr_ctx.iv[0] = htonl(ivp[0]);
444 ctx->dr_ctx.iv[1] = htonl(ivp[1]);
445 #else
446 ctx->dr_ctx.iv[0] =
447 ivp[0]<<24 | ivp[1]<<16 | ivp[2]<<8 | ivp[3];
448 ctx->dr_ctx.iv[1] =
449 ivp[4]<<24 | ivp[5]<<16 | ivp[6]<<8 | ivp[7];
450 #endif /* UNALIGNED_POINTERS_PERMITTED */
451 }
452
453 /* For now we force a pullup. Add direct DMA later. */
454 reqp->dr_flags &= ~(DR_SCATTER | DR_GATHER);
455 if ((len < dca_mindma) || (ctx->dr_ctx.activeresidlen > 0) ||
456 dca_sgcheck(dca, reqp->dr_in, DCA_SG_CONTIG) ||
457 dca_sgcheck(dca, reqp->dr_out, DCA_SG_WALIGN)) {
458 reqp->dr_flags |= DR_SCATTER | DR_GATHER;
459 }
460
461 /* Try to do direct DMA. */
462 if (!(reqp->dr_flags & (DR_SCATTER | DR_GATHER))) {
463 if (dca_bindchains(reqp, len, len) == DDI_SUCCESS) {
464 reqp->dr_in->cd_offset += len;
465 reqp->dr_in->cd_length -= len;
466 } else {
467 DBG(dca, DWARN,
468 "dca_3desstart: dca_bindchains() failed");
469 return (CRYPTO_DEVICE_ERROR);
470 }
471 }
472
473 /* gather the data into the device */
474 if (reqp->dr_flags & DR_GATHER) {
475 rv = dca_resid_gather(in, (char *)ctx->dr_ctx.activeresid,
476 &ctx->dr_ctx.activeresidlen, reqp->dr_ibuf_kaddr, len);
477 if (rv != CRYPTO_SUCCESS) {
478 DBG(dca, DWARN,
479 "dca_3desstart: dca_resid_gather() failed");
480 return (rv);
481 }
482 /*
483 * Setup for scattering the result back out
484 * The output buffer is a multi-entry chain for x86 and
485 * a single entry chain for Sparc.
486 * Use the actual length if the first entry is sufficient.
487 */
488 (void) ddi_dma_sync(reqp->dr_ibuf_dmah, 0, len,
489 DDI_DMA_SYNC_FORDEV);
490 if (dca_check_dma_handle(dca, reqp->dr_ibuf_dmah,
491 DCA_FM_ECLASS_NONE) != DDI_SUCCESS) {
492 reqp->destroy = TRUE;
493 return (CRYPTO_DEVICE_ERROR);
494 }
495
496 reqp->dr_in_paddr = reqp->dr_ibuf_head.dc_buffer_paddr;
497 reqp->dr_in_next = reqp->dr_ibuf_head.dc_next_paddr;
498 if (len > reqp->dr_ibuf_head.dc_buffer_length)
499 reqp->dr_in_len = reqp->dr_ibuf_head.dc_buffer_length;
500 else
501 reqp->dr_in_len = len;
502 }
503 /*
504 * Setup for scattering the result back out
505 * The output buffer is a multi-entry chain for x86 and
506 * a single entry chain for Sparc.
507 * Use the actual length if the first entry is sufficient.
508 */
509 if (reqp->dr_flags & DR_SCATTER) {
510 reqp->dr_out_paddr = reqp->dr_obuf_head.dc_buffer_paddr;
511 reqp->dr_out_next = reqp->dr_obuf_head.dc_next_paddr;
512 if (len > reqp->dr_obuf_head.dc_buffer_length)
513 reqp->dr_out_len = reqp->dr_obuf_head.dc_buffer_length;
514 else
515 reqp->dr_out_len = len;
516 }
517
518 reqp->dr_flags |= flags;
519 reqp->dr_callback = dca_3desdone;
520
521 /* write out the context structure */
522 PUTCTX32(reqp, CTX_3DESIVHI, iv[0]);
523 PUTCTX32(reqp, CTX_3DESIVLO, iv[1]);
524
525 /* schedule the work by doing a submit */
526 return (dca_start(dca, reqp, MCR1, 1));
527 }
528
529 void
530 dca_3desdone(dca_request_t *reqp, int errno)
531 {
532 crypto_data_t *out = reqp->dr_out;
533 dca_request_t *ctx = reqp;
534 ASSERT(ctx != NULL);
535
536 if (errno == CRYPTO_SUCCESS) {
537 size_t off;
538 /*
539 * Save the offset: this has to be done *before* dca_scatter
540 * modifies the buffer. We take the initial offset into the
541 * first buf, and add that to the total packet size to find
542 * the end of the packet.
543 */
544 off = dca_length(out) + reqp->dr_pkt_length - DESBLOCK;
545
546 if (reqp->dr_flags & DR_SCATTER) {
547 (void) ddi_dma_sync(reqp->dr_obuf_dmah, 0,
548 reqp->dr_out_len, DDI_DMA_SYNC_FORKERNEL);
549 if (dca_check_dma_handle(reqp->dr_dca,
550 reqp->dr_obuf_dmah, DCA_FM_ECLASS_NONE) !=
551 DDI_SUCCESS) {
552 reqp->destroy = TRUE;
553 errno = CRYPTO_DEVICE_ERROR;
554 goto errout;
555 }
556
557 errno = dca_scatter(reqp->dr_obuf_kaddr,
558 reqp->dr_out, reqp->dr_out_len, 0);
559 if (errno != CRYPTO_SUCCESS) {
560 DBG(NULL, DWARN,
561 "dca_3desdone: dca_scatter() failed");
562 goto errout;
563 }
564
565 } else {
566 /* we've processed some more data */
567 out->cd_length += reqp->dr_pkt_length;
568 }
569
570
571 /*
572 * For encryption only, we have to grab the IV for the
573 * next pass AFTER encryption.
574 */
575 if (reqp->dr_flags & DR_ENCRYPT) {
576 uchar_t ivstore[DESBLOCK];
577 #ifdef UNALIGNED_POINTERS_PERMITTED
578 uint32_t *iv = (uint32_t *)ivstore;
579 #else
580 uchar_t *iv = ivstore;
581 #endif /* UNALIGNED_POINTERS_PERMITTED */
582
583 /* get last 8 bytes for IV of next op */
584 errno = dca_getbufbytes(out, off, DESBLOCK,
585 (uchar_t *)iv);
586 if (errno != CRYPTO_SUCCESS) {
587 DBG(NULL, DWARN,
588 "dca_3desdone: dca_getbufbytes() failed");
589 goto errout;
590 }
591
592 /* store as a pair of native 32-bit values */
593 #ifdef UNALIGNED_POINTERS_PERMITTED
594 ctx->dr_ctx.iv[0] = htonl(iv[0]);
595 ctx->dr_ctx.iv[1] = htonl(iv[1]);
596 #else
597 ctx->dr_ctx.iv[0] =
598 iv[0]<<24 | iv[1]<<16 | iv[2]<<8 | iv[3];
599 ctx->dr_ctx.iv[1] =
600 iv[4]<<24 | iv[5]<<16 | iv[6]<<8 | iv[7];
601 #endif /* UNALIGNED_POINTERS_PERMITTED */
602 }
603
604 /*
605 * If there is more to do, then reschedule another
606 * pass.
607 */
608 if (dca_length(reqp->dr_in) >= 8) {
609 errno = dca_3desstart(reqp->dr_dca, reqp->dr_flags,
610 reqp);
611 if (errno == CRYPTO_QUEUED) {
612 return;
613 }
614 }
615 }
616
617 errout:
618
619 /*
620 * If this is an atomic operation perform the final function
621 * tasks (equivalent to to dca_3desfinal()).
622 */
623 if (reqp->dr_ctx.atomic) {
624 if ((errno == CRYPTO_SUCCESS) && (ctx->dr_ctx.residlen != 0)) {
625 DBG(NULL, DWARN,
626 "dca_3desdone: invalid nonzero residual");
627 if (reqp->dr_flags & DR_DECRYPT) {
628 errno = CRYPTO_ENCRYPTED_DATA_LEN_RANGE;
629 } else {
630 errno = CRYPTO_DATA_LEN_RANGE;
631 }
632 }
633 }
634
635 ASSERT(reqp->dr_kcf_req != NULL);
636 /* notify framework that request is completed */
637 crypto_op_notification(reqp->dr_kcf_req, errno);
638 DBG(NULL, DINTR,
639 "dca_3desdone: returning %d to the kef via crypto_op_notification",
640 errno);
641
642 /* This has to be done after notifing the framework */
643 if (reqp->dr_ctx.atomic) {
644 reqp->dr_context = NULL;
645 reqp->dr_ctx.atomic = 0;
646 reqp->dr_ctx.ctx_cm_type = 0;
647 if (reqp->destroy)
648 dca_destroyreq(reqp);
649 else
650 dca_freereq(reqp);
651 }
652 }
653
654 /* ARGSUSED */
655 int
656 dca_3desctxinit(crypto_ctx_t *ctx, crypto_mechanism_t *mechanism,
657 crypto_key_t *key, int kmflag, int flags)
658 {
659 dca_request_t *des_ctx;
660 dca_t *dca = ctx->cc_provider;
661 #ifdef UNALIGNED_POINTERS_PERMITTED
662 uint32_t *param;
663 uint32_t *value32;
664 #else
665 uchar_t *param;
666 #endif /* UNALIGNED_POINTERS_PERMITTED */
667 uchar_t *value;
668 size_t paramsz;
669 unsigned len;
670 int i, j;
671
672 paramsz = mechanism->cm_param_len;
673 #ifdef UNALIGNED_POINTERS_PERMITTED
674 param = (uint32_t *)mechanism->cm_param;
675 #else
676 param = (uchar_t *)mechanism->cm_param;
677 #endif /* UNALIGNED_POINTERS_PERMITTED */
678
679 if ((paramsz != 0) && (paramsz != DES_IV_LEN)) {
680 DBG(NULL, DWARN,
681 "dca_3desctxinit: parameter(IV) length not %d (%d)",
682 DES_IV_LEN, paramsz);
683 return (CRYPTO_MECHANISM_PARAM_INVALID);
684 }
685
686 if ((des_ctx = dca_getreq(dca, MCR1, 1)) == NULL) {
687 dca_error(dca, "unable to allocate request for 3DES");
688 return (CRYPTO_HOST_MEMORY);
689 }
690 /*
691 * Identify and store the IV as a pair of native 32-bit words.
692 *
693 * If cm_param == NULL then the IV comes from the cd_miscdata field
694 * in the crypto_data structure.
695 */
696 if (param != NULL) {
697 ASSERT(paramsz == DES_IV_LEN);
698 #ifdef UNALIGNED_POINTERS_PERMITTED
699 des_ctx->dr_ctx.iv[0] = htonl(param[0]);
700 des_ctx->dr_ctx.iv[1] = htonl(param[1]);
701 #else
702 des_ctx->dr_ctx.iv[0] = param[0]<<24 | param[1]<<16 |
703 param[2]<<8 | param[3];
704 des_ctx->dr_ctx.iv[1] = param[4]<<24 | param[5]<<16 |
705 param[6]<<8 | param[7];
706 #endif /* UNALIGNED_POINTERS_PERMITTED */
707 }
708 des_ctx->dr_ctx.residlen = 0;
709 des_ctx->dr_ctx.activeresidlen = 0;
710 des_ctx->dr_ctx.ctx_cm_type = mechanism->cm_type;
711 ctx->cc_provider_private = des_ctx;
712
713 if (key->ck_format != CRYPTO_KEY_RAW) {
714 DBG(NULL, DWARN,
715 "dca_3desctxinit: only raw crypto key type support with DES/3DES");
716 dca_3desctxfree(ctx);
717 return (CRYPTO_KEY_TYPE_INCONSISTENT);
718 }
719
720 len = key->ck_length;
721 value = (uchar_t *)key->ck_data;
722
723 if (flags & DR_TRIPLE) {
724 /* 3DES */
725 switch (len) {
726 case 192:
727 for (i = 0; i < 6; i++) {
728 des_ctx->dr_ctx.key[i] = 0;
729 for (j = 0; j < 4; j++) {
730 des_ctx->dr_ctx.key[i] <<= 8;
731 des_ctx->dr_ctx.key[i] |= *value;
732 value++;
733 }
734 }
735 break;
736
737 case 128:
738 for (i = 0; i < 4; i++) {
739 des_ctx->dr_ctx.key[i] = 0;
740 for (j = 0; j < 4; j++) {
741 des_ctx->dr_ctx.key[i] <<= 8;
742 des_ctx->dr_ctx.key[i] |= *value;
743 value++;
744 }
745 }
746 des_ctx->dr_ctx.key[4] = des_ctx->dr_ctx.key[0];
747 des_ctx->dr_ctx.key[5] = des_ctx->dr_ctx.key[1];
748 break;
749
750 default:
751 DBG(NULL, DWARN, "Incorrect 3DES keysize (%d)", len);
752 dca_3desctxfree(ctx);
753 return (CRYPTO_KEY_SIZE_RANGE);
754 }
755 } else {
756 /* single DES */
757 if (len != 64) {
758 DBG(NULL, DWARN, "Incorrect DES keysize (%d)", len);
759 dca_3desctxfree(ctx);
760 return (CRYPTO_KEY_SIZE_RANGE);
761 }
762
763 #ifdef UNALIGNED_POINTERS_PERMITTED
764 value32 = (uint32_t *)value;
765 des_ctx->dr_ctx.key[0] = htonl(value32[0]);
766 des_ctx->dr_ctx.key[1] = htonl(value32[1]);
767 #else
768 des_ctx->dr_ctx.key[0] =
769 value[0]<<24 | value[1]<<16 | value[2]<<8 | value[3];
770 des_ctx->dr_ctx.key[1] =
771 value[4]<<24 | value[5]<<16 | value[6]<<8 | value[7];
772 #endif /* UNALIGNED_POINTERS_PERMITTED */
773
774 /* for single des just repeat des key */
775 des_ctx->dr_ctx.key[4] =
776 des_ctx->dr_ctx.key[2] = des_ctx->dr_ctx.key[0];
777 des_ctx->dr_ctx.key[5] =
778 des_ctx->dr_ctx.key[3] = des_ctx->dr_ctx.key[1];
779 }
780
781 /*
782 * Setup the context here so that we do not need to setup it up
783 * for every update
784 */
785 PUTCTX16(des_ctx, CTX_LENGTH, CTX_3DES_LENGTH);
786 PUTCTX16(des_ctx, CTX_CMD, CMD_3DES);
787 PUTCTX32(des_ctx, CTX_3DESDIRECTION,
788 flags & DR_ENCRYPT ? CTX_3DES_ENCRYPT : CTX_3DES_DECRYPT);
789 PUTCTX32(des_ctx, CTX_3DESKEY1HI, des_ctx->dr_ctx.key[0]);
790 PUTCTX32(des_ctx, CTX_3DESKEY1LO, des_ctx->dr_ctx.key[1]);
791 PUTCTX32(des_ctx, CTX_3DESKEY2HI, des_ctx->dr_ctx.key[2]);
792 PUTCTX32(des_ctx, CTX_3DESKEY2LO, des_ctx->dr_ctx.key[3]);
793 PUTCTX32(des_ctx, CTX_3DESKEY3HI, des_ctx->dr_ctx.key[4]);
794 PUTCTX32(des_ctx, CTX_3DESKEY3LO, des_ctx->dr_ctx.key[5]);
795
796 return (CRYPTO_SUCCESS);
797 }