?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ARM: mm: avoid taking ASID spinlock on fastpath
[linux/fpc-iii.git] / arch / s390 / crypto / des_s390.c
blobb49fb96f42070623a1645db10ebee3457eb0a98a
1 /*
2 * Cryptographic API.
3 *
4 * s390 implementation of the DES Cipher Algorithm.
5 *
6 * Copyright IBM Corp. 2003, 2011
7 * Author(s): Thomas Spatzier
8 * Jan Glauber (jan.glauber@de.ibm.com)
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 */
16
17 #include <linux/init.h>
18 #include <linux/module.h>
19 #include <linux/crypto.h>
20 #include <crypto/algapi.h>
21 #include <crypto/des.h>
22
23 #include "crypt_s390.h"
24
25 #define DES3_KEY_SIZE (3 * DES_KEY_SIZE)
26
27 static u8 *ctrblk;
28
29 struct s390_des_ctx {
30 u8 iv[DES_BLOCK_SIZE];
31 u8 key[DES3_KEY_SIZE];
32 };
33
34 static int des_setkey(struct crypto_tfm *tfm, const u8 *key,
35 unsigned int key_len)
36 {
37 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
38 u32 *flags = &tfm->crt_flags;
39 u32 tmp[DES_EXPKEY_WORDS];
40
41 /* check for weak keys */
42 if (!des_ekey(tmp, key) && (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) {
43 *flags |= CRYPTO_TFM_RES_WEAK_KEY;
44 return -EINVAL;
45 }
46
47 memcpy(ctx->key, key, key_len);
48 return 0;
49 }
50
51 static void des_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
52 {
53 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
54
55 crypt_s390_km(KM_DEA_ENCRYPT, ctx->key, out, in, DES_BLOCK_SIZE);
56 }
57
58 static void des_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
59 {
60 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
61
62 crypt_s390_km(KM_DEA_DECRYPT, ctx->key, out, in, DES_BLOCK_SIZE);
63 }
64
65 static struct crypto_alg des_alg = {
66 .cra_name = "des",
67 .cra_driver_name = "des-s390",
68 .cra_priority = CRYPT_S390_PRIORITY,
69 .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
70 .cra_blocksize = DES_BLOCK_SIZE,
71 .cra_ctxsize = sizeof(struct s390_des_ctx),
72 .cra_module = THIS_MODULE,
73 .cra_u = {
74 .cipher = {
75 .cia_min_keysize = DES_KEY_SIZE,
76 .cia_max_keysize = DES_KEY_SIZE,
77 .cia_setkey = des_setkey,
78 .cia_encrypt = des_encrypt,
79 .cia_decrypt = des_decrypt,
80 }
81 }
82 };
83
84 static int ecb_desall_crypt(struct blkcipher_desc *desc, long func,
85 u8 *key, struct blkcipher_walk *walk)
86 {
87 int ret = blkcipher_walk_virt(desc, walk);
88 unsigned int nbytes;
89
90 while ((nbytes = walk->nbytes)) {
91 /* only use complete blocks */
92 unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1);
93 u8 *out = walk->dst.virt.addr;
94 u8 *in = walk->src.virt.addr;
95
96 ret = crypt_s390_km(func, key, out, in, n);
97 BUG_ON((ret < 0) || (ret != n));
98
99 nbytes &= DES_BLOCK_SIZE - 1;
100 ret = blkcipher_walk_done(desc, walk, nbytes);
101 }
102
103 return ret;
104 }
105
106 static int cbc_desall_crypt(struct blkcipher_desc *desc, long func,
107 u8 *iv, struct blkcipher_walk *walk)
108 {
109 int ret = blkcipher_walk_virt(desc, walk);
110 unsigned int nbytes = walk->nbytes;
111
112 if (!nbytes)
113 goto out;
114
115 memcpy(iv, walk->iv, DES_BLOCK_SIZE);
116 do {
117 /* only use complete blocks */
118 unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1);
119 u8 *out = walk->dst.virt.addr;
120 u8 *in = walk->src.virt.addr;
121
122 ret = crypt_s390_kmc(func, iv, out, in, n);
123 BUG_ON((ret < 0) || (ret != n));
124
125 nbytes &= DES_BLOCK_SIZE - 1;
126 ret = blkcipher_walk_done(desc, walk, nbytes);
127 } while ((nbytes = walk->nbytes));
128 memcpy(walk->iv, iv, DES_BLOCK_SIZE);
129
130 out:
131 return ret;
132 }
133
134 static int ecb_des_encrypt(struct blkcipher_desc *desc,
135 struct scatterlist *dst, struct scatterlist *src,
136 unsigned int nbytes)
137 {
138 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
139 struct blkcipher_walk walk;
140
141 blkcipher_walk_init(&walk, dst, src, nbytes);
142 return ecb_desall_crypt(desc, KM_DEA_ENCRYPT, ctx->key, &walk);
143 }
144
145 static int ecb_des_decrypt(struct blkcipher_desc *desc,
146 struct scatterlist *dst, struct scatterlist *src,
147 unsigned int nbytes)
148 {
149 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
150 struct blkcipher_walk walk;
151
152 blkcipher_walk_init(&walk, dst, src, nbytes);
153 return ecb_desall_crypt(desc, KM_DEA_DECRYPT, ctx->key, &walk);
154 }
155
156 static struct crypto_alg ecb_des_alg = {
157 .cra_name = "ecb(des)",
158 .cra_driver_name = "ecb-des-s390",
159 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
160 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
161 .cra_blocksize = DES_BLOCK_SIZE,
162 .cra_ctxsize = sizeof(struct s390_des_ctx),
163 .cra_type = &crypto_blkcipher_type,
164 .cra_module = THIS_MODULE,
165 .cra_u = {
166 .blkcipher = {
167 .min_keysize = DES_KEY_SIZE,
168 .max_keysize = DES_KEY_SIZE,
169 .setkey = des_setkey,
170 .encrypt = ecb_des_encrypt,
171 .decrypt = ecb_des_decrypt,
172 }
173 }
174 };
175
176 static int cbc_des_encrypt(struct blkcipher_desc *desc,
177 struct scatterlist *dst, struct scatterlist *src,
178 unsigned int nbytes)
179 {
180 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
181 struct blkcipher_walk walk;
182
183 blkcipher_walk_init(&walk, dst, src, nbytes);
184 return cbc_desall_crypt(desc, KMC_DEA_ENCRYPT, ctx->iv, &walk);
185 }
186
187 static int cbc_des_decrypt(struct blkcipher_desc *desc,
188 struct scatterlist *dst, struct scatterlist *src,
189 unsigned int nbytes)
190 {
191 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
192 struct blkcipher_walk walk;
193
194 blkcipher_walk_init(&walk, dst, src, nbytes);
195 return cbc_desall_crypt(desc, KMC_DEA_DECRYPT, ctx->iv, &walk);
196 }
197
198 static struct crypto_alg cbc_des_alg = {
199 .cra_name = "cbc(des)",
200 .cra_driver_name = "cbc-des-s390",
201 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
202 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
203 .cra_blocksize = DES_BLOCK_SIZE,
204 .cra_ctxsize = sizeof(struct s390_des_ctx),
205 .cra_type = &crypto_blkcipher_type,
206 .cra_module = THIS_MODULE,
207 .cra_u = {
208 .blkcipher = {
209 .min_keysize = DES_KEY_SIZE,
210 .max_keysize = DES_KEY_SIZE,
211 .ivsize = DES_BLOCK_SIZE,
212 .setkey = des_setkey,
213 .encrypt = cbc_des_encrypt,
214 .decrypt = cbc_des_decrypt,
215 }
216 }
217 };
218
219 /*
220 * RFC2451:
221 *
222 * For DES-EDE3, there is no known need to reject weak or
223 * complementation keys. Any weakness is obviated by the use of
224 * multiple keys.
225 *
226 * However, if the first two or last two independent 64-bit keys are
227 * equal (k1 == k2 or k2 == k3), then the DES3 operation is simply the
228 * same as DES. Implementers MUST reject keys that exhibit this
229 * property.
230 *
231 */
232 static int des3_setkey(struct crypto_tfm *tfm, const u8 *key,
233 unsigned int key_len)
234 {
235 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
236 u32 *flags = &tfm->crt_flags;
237
238 if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) &&
239 memcmp(&key[DES_KEY_SIZE], &key[DES_KEY_SIZE * 2],
240 DES_KEY_SIZE)) &&
241 (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) {
242 *flags |= CRYPTO_TFM_RES_WEAK_KEY;
243 return -EINVAL;
244 }
245 memcpy(ctx->key, key, key_len);
246 return 0;
247 }
248
249 static void des3_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
250 {
251 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
252
253 crypt_s390_km(KM_TDEA_192_ENCRYPT, ctx->key, dst, src, DES_BLOCK_SIZE);
254 }
255
256 static void des3_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
257 {
258 struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
259
260 crypt_s390_km(KM_TDEA_192_DECRYPT, ctx->key, dst, src, DES_BLOCK_SIZE);
261 }
262
263 static struct crypto_alg des3_alg = {
264 .cra_name = "des3_ede",
265 .cra_driver_name = "des3_ede-s390",
266 .cra_priority = CRYPT_S390_PRIORITY,
267 .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
268 .cra_blocksize = DES_BLOCK_SIZE,
269 .cra_ctxsize = sizeof(struct s390_des_ctx),
270 .cra_module = THIS_MODULE,
271 .cra_u = {
272 .cipher = {
273 .cia_min_keysize = DES3_KEY_SIZE,
274 .cia_max_keysize = DES3_KEY_SIZE,
275 .cia_setkey = des3_setkey,
276 .cia_encrypt = des3_encrypt,
277 .cia_decrypt = des3_decrypt,
278 }
279 }
280 };
281
282 static int ecb_des3_encrypt(struct blkcipher_desc *desc,
283 struct scatterlist *dst, struct scatterlist *src,
284 unsigned int nbytes)
285 {
286 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
287 struct blkcipher_walk walk;
288
289 blkcipher_walk_init(&walk, dst, src, nbytes);
290 return ecb_desall_crypt(desc, KM_TDEA_192_ENCRYPT, ctx->key, &walk);
291 }
292
293 static int ecb_des3_decrypt(struct blkcipher_desc *desc,
294 struct scatterlist *dst, struct scatterlist *src,
295 unsigned int nbytes)
296 {
297 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
298 struct blkcipher_walk walk;
299
300 blkcipher_walk_init(&walk, dst, src, nbytes);
301 return ecb_desall_crypt(desc, KM_TDEA_192_DECRYPT, ctx->key, &walk);
302 }
303
304 static struct crypto_alg ecb_des3_alg = {
305 .cra_name = "ecb(des3_ede)",
306 .cra_driver_name = "ecb-des3_ede-s390",
307 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
308 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
309 .cra_blocksize = DES_BLOCK_SIZE,
310 .cra_ctxsize = sizeof(struct s390_des_ctx),
311 .cra_type = &crypto_blkcipher_type,
312 .cra_module = THIS_MODULE,
313 .cra_u = {
314 .blkcipher = {
315 .min_keysize = DES3_KEY_SIZE,
316 .max_keysize = DES3_KEY_SIZE,
317 .setkey = des3_setkey,
318 .encrypt = ecb_des3_encrypt,
319 .decrypt = ecb_des3_decrypt,
320 }
321 }
322 };
323
324 static int cbc_des3_encrypt(struct blkcipher_desc *desc,
325 struct scatterlist *dst, struct scatterlist *src,
326 unsigned int nbytes)
327 {
328 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
329 struct blkcipher_walk walk;
330
331 blkcipher_walk_init(&walk, dst, src, nbytes);
332 return cbc_desall_crypt(desc, KMC_TDEA_192_ENCRYPT, ctx->iv, &walk);
333 }
334
335 static int cbc_des3_decrypt(struct blkcipher_desc *desc,
336 struct scatterlist *dst, struct scatterlist *src,
337 unsigned int nbytes)
338 {
339 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
340 struct blkcipher_walk walk;
341
342 blkcipher_walk_init(&walk, dst, src, nbytes);
343 return cbc_desall_crypt(desc, KMC_TDEA_192_DECRYPT, ctx->iv, &walk);
344 }
345
346 static struct crypto_alg cbc_des3_alg = {
347 .cra_name = "cbc(des3_ede)",
348 .cra_driver_name = "cbc-des3_ede-s390",
349 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
350 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
351 .cra_blocksize = DES_BLOCK_SIZE,
352 .cra_ctxsize = sizeof(struct s390_des_ctx),
353 .cra_type = &crypto_blkcipher_type,
354 .cra_module = THIS_MODULE,
355 .cra_u = {
356 .blkcipher = {
357 .min_keysize = DES3_KEY_SIZE,
358 .max_keysize = DES3_KEY_SIZE,
359 .ivsize = DES_BLOCK_SIZE,
360 .setkey = des3_setkey,
361 .encrypt = cbc_des3_encrypt,
362 .decrypt = cbc_des3_decrypt,
363 }
364 }
365 };
366
367 static int ctr_desall_crypt(struct blkcipher_desc *desc, long func,
368 struct s390_des_ctx *ctx, struct blkcipher_walk *walk)
369 {
370 int ret = blkcipher_walk_virt_block(desc, walk, DES_BLOCK_SIZE);
371 unsigned int i, n, nbytes;
372 u8 buf[DES_BLOCK_SIZE];
373 u8 *out, *in;
374
375 memcpy(ctrblk, walk->iv, DES_BLOCK_SIZE);
376 while ((nbytes = walk->nbytes) >= DES_BLOCK_SIZE) {
377 out = walk->dst.virt.addr;
378 in = walk->src.virt.addr;
379 while (nbytes >= DES_BLOCK_SIZE) {
380 /* align to block size, max. PAGE_SIZE */
381 n = (nbytes > PAGE_SIZE) ? PAGE_SIZE :
382 nbytes & ~(DES_BLOCK_SIZE - 1);
383 for (i = DES_BLOCK_SIZE; i < n; i += DES_BLOCK_SIZE) {
384 memcpy(ctrblk + i, ctrblk + i - DES_BLOCK_SIZE,
385 DES_BLOCK_SIZE);
386 crypto_inc(ctrblk + i, DES_BLOCK_SIZE);
387 }
388 ret = crypt_s390_kmctr(func, ctx->key, out, in, n, ctrblk);
389 BUG_ON((ret < 0) || (ret != n));
390 if (n > DES_BLOCK_SIZE)
391 memcpy(ctrblk, ctrblk + n - DES_BLOCK_SIZE,
392 DES_BLOCK_SIZE);
393 crypto_inc(ctrblk, DES_BLOCK_SIZE);
394 out += n;
395 in += n;
396 nbytes -= n;
397 }
398 ret = blkcipher_walk_done(desc, walk, nbytes);
399 }
400
401 /* final block may be < DES_BLOCK_SIZE, copy only nbytes */
402 if (nbytes) {
403 out = walk->dst.virt.addr;
404 in = walk->src.virt.addr;
405 ret = crypt_s390_kmctr(func, ctx->key, buf, in,
406 DES_BLOCK_SIZE, ctrblk);
407 BUG_ON(ret < 0 || ret != DES_BLOCK_SIZE);
408 memcpy(out, buf, nbytes);
409 crypto_inc(ctrblk, DES_BLOCK_SIZE);
410 ret = blkcipher_walk_done(desc, walk, 0);
411 }
412 memcpy(walk->iv, ctrblk, DES_BLOCK_SIZE);
413 return ret;
414 }
415
416 static int ctr_des_encrypt(struct blkcipher_desc *desc,
417 struct scatterlist *dst, struct scatterlist *src,
418 unsigned int nbytes)
419 {
420 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
421 struct blkcipher_walk walk;
422
423 blkcipher_walk_init(&walk, dst, src, nbytes);
424 return ctr_desall_crypt(desc, KMCTR_DEA_ENCRYPT, ctx, &walk);
425 }
426
427 static int ctr_des_decrypt(struct blkcipher_desc *desc,
428 struct scatterlist *dst, struct scatterlist *src,
429 unsigned int nbytes)
430 {
431 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
432 struct blkcipher_walk walk;
433
434 blkcipher_walk_init(&walk, dst, src, nbytes);
435 return ctr_desall_crypt(desc, KMCTR_DEA_DECRYPT, ctx, &walk);
436 }
437
438 static struct crypto_alg ctr_des_alg = {
439 .cra_name = "ctr(des)",
440 .cra_driver_name = "ctr-des-s390",
441 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
442 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
443 .cra_blocksize = 1,
444 .cra_ctxsize = sizeof(struct s390_des_ctx),
445 .cra_type = &crypto_blkcipher_type,
446 .cra_module = THIS_MODULE,
447 .cra_u = {
448 .blkcipher = {
449 .min_keysize = DES_KEY_SIZE,
450 .max_keysize = DES_KEY_SIZE,
451 .ivsize = DES_BLOCK_SIZE,
452 .setkey = des_setkey,
453 .encrypt = ctr_des_encrypt,
454 .decrypt = ctr_des_decrypt,
455 }
456 }
457 };
458
459 static int ctr_des3_encrypt(struct blkcipher_desc *desc,
460 struct scatterlist *dst, struct scatterlist *src,
461 unsigned int nbytes)
462 {
463 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
464 struct blkcipher_walk walk;
465
466 blkcipher_walk_init(&walk, dst, src, nbytes);
467 return ctr_desall_crypt(desc, KMCTR_TDEA_192_ENCRYPT, ctx, &walk);
468 }
469
470 static int ctr_des3_decrypt(struct blkcipher_desc *desc,
471 struct scatterlist *dst, struct scatterlist *src,
472 unsigned int nbytes)
473 {
474 struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
475 struct blkcipher_walk walk;
476
477 blkcipher_walk_init(&walk, dst, src, nbytes);
478 return ctr_desall_crypt(desc, KMCTR_TDEA_192_DECRYPT, ctx, &walk);
479 }
480
481 static struct crypto_alg ctr_des3_alg = {
482 .cra_name = "ctr(des3_ede)",
483 .cra_driver_name = "ctr-des3_ede-s390",
484 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
485 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
486 .cra_blocksize = 1,
487 .cra_ctxsize = sizeof(struct s390_des_ctx),
488 .cra_type = &crypto_blkcipher_type,
489 .cra_module = THIS_MODULE,
490 .cra_u = {
491 .blkcipher = {
492 .min_keysize = DES3_KEY_SIZE,
493 .max_keysize = DES3_KEY_SIZE,
494 .ivsize = DES_BLOCK_SIZE,
495 .setkey = des3_setkey,
496 .encrypt = ctr_des3_encrypt,
497 .decrypt = ctr_des3_decrypt,
498 }
499 }
500 };
501
502 static int __init des_s390_init(void)
503 {
504 int ret;
505
506 if (!crypt_s390_func_available(KM_DEA_ENCRYPT, CRYPT_S390_MSA) ||
507 !crypt_s390_func_available(KM_TDEA_192_ENCRYPT, CRYPT_S390_MSA))
508 return -EOPNOTSUPP;
509
510 ret = crypto_register_alg(&des_alg);
511 if (ret)
512 goto des_err;
513 ret = crypto_register_alg(&ecb_des_alg);
514 if (ret)
515 goto ecb_des_err;
516 ret = crypto_register_alg(&cbc_des_alg);
517 if (ret)
518 goto cbc_des_err;
519 ret = crypto_register_alg(&des3_alg);
520 if (ret)
521 goto des3_err;
522 ret = crypto_register_alg(&ecb_des3_alg);
523 if (ret)
524 goto ecb_des3_err;
525 ret = crypto_register_alg(&cbc_des3_alg);
526 if (ret)
527 goto cbc_des3_err;
528
529 if (crypt_s390_func_available(KMCTR_DEA_ENCRYPT,
530 CRYPT_S390_MSA | CRYPT_S390_MSA4) &&
531 crypt_s390_func_available(KMCTR_TDEA_192_ENCRYPT,
532 CRYPT_S390_MSA | CRYPT_S390_MSA4)) {
533 ret = crypto_register_alg(&ctr_des_alg);
534 if (ret)
535 goto ctr_des_err;
536 ret = crypto_register_alg(&ctr_des3_alg);
537 if (ret)
538 goto ctr_des3_err;
539 ctrblk = (u8 *) __get_free_page(GFP_KERNEL);
540 if (!ctrblk) {
541 ret = -ENOMEM;
542 goto ctr_mem_err;
543 }
544 }
545 out:
546 return ret;
547
548 ctr_mem_err:
549 crypto_unregister_alg(&ctr_des3_alg);
550 ctr_des3_err:
551 crypto_unregister_alg(&ctr_des_alg);
552 ctr_des_err:
553 crypto_unregister_alg(&cbc_des3_alg);
554 cbc_des3_err:
555 crypto_unregister_alg(&ecb_des3_alg);
556 ecb_des3_err:
557 crypto_unregister_alg(&des3_alg);
558 des3_err:
559 crypto_unregister_alg(&cbc_des_alg);
560 cbc_des_err:
561 crypto_unregister_alg(&ecb_des_alg);
562 ecb_des_err:
563 crypto_unregister_alg(&des_alg);
564 des_err:
565 goto out;
566 }
567
568 static void __exit des_s390_exit(void)
569 {
570 if (ctrblk) {
571 crypto_unregister_alg(&ctr_des_alg);
572 crypto_unregister_alg(&ctr_des3_alg);
573 free_page((unsigned long) ctrblk);
574 }
575 crypto_unregister_alg(&cbc_des3_alg);
576 crypto_unregister_alg(&ecb_des3_alg);
577 crypto_unregister_alg(&des3_alg);
578 crypto_unregister_alg(&cbc_des_alg);
579 crypto_unregister_alg(&ecb_des_alg);
580 crypto_unregister_alg(&des_alg);
581 }
582
583 module_init(des_s390_init);
584 module_exit(des_s390_exit);
585
586 MODULE_ALIAS("des");
587 MODULE_ALIAS("des3_ede");
588
589 MODULE_LICENSE("GPL");
590 MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms");
Linux with added FPC-III support