1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <crypto/algapi.h>
18#include <linux/init.h>
19#include <linux/module.h>
20
21#include "crypt_s390.h"
22#include "crypto_des.h"
23
24#define DES_BLOCK_SIZE 8
25#define DES_KEY_SIZE 8
26
27#define DES3_128_KEY_SIZE (2 * DES_KEY_SIZE)
28#define DES3_128_BLOCK_SIZE DES_BLOCK_SIZE
29
30#define DES3_192_KEY_SIZE (3 * DES_KEY_SIZE)
31#define DES3_192_BLOCK_SIZE DES_BLOCK_SIZE
32
33struct crypt_s390_des_ctx {
34 u8 iv[DES_BLOCK_SIZE];
35 u8 key[DES_KEY_SIZE];
36};
37
38struct crypt_s390_des3_128_ctx {
39 u8 iv[DES_BLOCK_SIZE];
40 u8 key[DES3_128_KEY_SIZE];
41};
42
43struct crypt_s390_des3_192_ctx {
44 u8 iv[DES_BLOCK_SIZE];
45 u8 key[DES3_192_KEY_SIZE];
46};
47
48static int des_setkey(struct crypto_tfm *tfm, const u8 *key,
49 unsigned int keylen)
50{
51 struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm);
52 u32 *flags = &tfm->crt_flags;
53 int ret;
54
55
56 ret = crypto_des_check_key(key, keylen, flags);
57 if (ret == 0)
58 memcpy(dctx->key, key, keylen);
59 return ret;
60}
61
62static void des_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
63{
64 struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm);
65
66 crypt_s390_km(KM_DEA_ENCRYPT, dctx->key, out, in, DES_BLOCK_SIZE);
67}
68
69static void des_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
70{
71 struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm);
72
73 crypt_s390_km(KM_DEA_DECRYPT, dctx->key, out, in, DES_BLOCK_SIZE);
74}
75
76static struct crypto_alg des_alg = {
77 .cra_name = "des",
78 .cra_driver_name = "des-s390",
79 .cra_priority = CRYPT_S390_PRIORITY,
80 .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
81 .cra_blocksize = DES_BLOCK_SIZE,
82 .cra_ctxsize = sizeof(struct crypt_s390_des_ctx),
83 .cra_module = THIS_MODULE,
84 .cra_list = LIST_HEAD_INIT(des_alg.cra_list),
85 .cra_u = {
86 .cipher = {
87 .cia_min_keysize = DES_KEY_SIZE,
88 .cia_max_keysize = DES_KEY_SIZE,
89 .cia_setkey = des_setkey,
90 .cia_encrypt = des_encrypt,
91 .cia_decrypt = des_decrypt,
92 }
93 }
94};
95
96static int ecb_desall_crypt(struct blkcipher_desc *desc, long func,
97 void *param, struct blkcipher_walk *walk)
98{
99 int ret = blkcipher_walk_virt(desc, walk);
100 unsigned int nbytes;
101
102 while ((nbytes = walk->nbytes)) {
103
104 unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1);
105 u8 *out = walk->dst.virt.addr;
106 u8 *in = walk->src.virt.addr;
107
108 ret = crypt_s390_km(func, param, out, in, n);
109 BUG_ON((ret < 0) || (ret != n));
110
111 nbytes &= DES_BLOCK_SIZE - 1;
112 ret = blkcipher_walk_done(desc, walk, nbytes);
113 }
114
115 return ret;
116}
117
118static int cbc_desall_crypt(struct blkcipher_desc *desc, long func,
119 void *param, struct blkcipher_walk *walk)
120{
121 int ret = blkcipher_walk_virt(desc, walk);
122 unsigned int nbytes = walk->nbytes;
123
124 if (!nbytes)
125 goto out;
126
127 memcpy(param, walk->iv, DES_BLOCK_SIZE);
128 do {
129
130 unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1);
131 u8 *out = walk->dst.virt.addr;
132 u8 *in = walk->src.virt.addr;
133
134 ret = crypt_s390_kmc(func, param, out, in, n);
135 BUG_ON((ret < 0) || (ret != n));
136
137 nbytes &= DES_BLOCK_SIZE - 1;
138 ret = blkcipher_walk_done(desc, walk, nbytes);
139 } while ((nbytes = walk->nbytes));
140 memcpy(walk->iv, param, DES_BLOCK_SIZE);
141
142out:
143 return ret;
144}
145
146static int ecb_des_encrypt(struct blkcipher_desc *desc,
147 struct scatterlist *dst, struct scatterlist *src,
148 unsigned int nbytes)
149{
150 struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
151 struct blkcipher_walk walk;
152
153 blkcipher_walk_init(&walk, dst, src, nbytes);
154 return ecb_desall_crypt(desc, KM_DEA_ENCRYPT, sctx->key, &walk);
155}
156
157static int ecb_des_decrypt(struct blkcipher_desc *desc,
158 struct scatterlist *dst, struct scatterlist *src,
159 unsigned int nbytes)
160{
161 struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
162 struct blkcipher_walk walk;
163
164 blkcipher_walk_init(&walk, dst, src, nbytes);
165 return ecb_desall_crypt(desc, KM_DEA_DECRYPT, sctx->key, &walk);
166}
167
168static struct crypto_alg ecb_des_alg = {
169 .cra_name = "ecb(des)",
170 .cra_driver_name = "ecb-des-s390",
171 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
172 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
173 .cra_blocksize = DES_BLOCK_SIZE,
174 .cra_ctxsize = sizeof(struct crypt_s390_des_ctx),
175 .cra_type = &crypto_blkcipher_type,
176 .cra_module = THIS_MODULE,
177 .cra_list = LIST_HEAD_INIT(ecb_des_alg.cra_list),
178 .cra_u = {
179 .blkcipher = {
180 .min_keysize = DES_KEY_SIZE,
181 .max_keysize = DES_KEY_SIZE,
182 .setkey = des_setkey,
183 .encrypt = ecb_des_encrypt,
184 .decrypt = ecb_des_decrypt,
185 }
186 }
187};
188
189static int cbc_des_encrypt(struct blkcipher_desc *desc,
190 struct scatterlist *dst, struct scatterlist *src,
191 unsigned int nbytes)
192{
193 struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
194 struct blkcipher_walk walk;
195
196 blkcipher_walk_init(&walk, dst, src, nbytes);
197 return cbc_desall_crypt(desc, KMC_DEA_ENCRYPT, sctx->iv, &walk);
198}
199
200static int cbc_des_decrypt(struct blkcipher_desc *desc,
201 struct scatterlist *dst, struct scatterlist *src,
202 unsigned int nbytes)
203{
204 struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
205 struct blkcipher_walk walk;
206
207 blkcipher_walk_init(&walk, dst, src, nbytes);
208 return cbc_desall_crypt(desc, KMC_DEA_DECRYPT, sctx->iv, &walk);
209}
210
211static struct crypto_alg cbc_des_alg = {
212 .cra_name = "cbc(des)",
213 .cra_driver_name = "cbc-des-s390",
214 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
215 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
216 .cra_blocksize = DES_BLOCK_SIZE,
217 .cra_ctxsize = sizeof(struct crypt_s390_des_ctx),
218 .cra_type = &crypto_blkcipher_type,
219 .cra_module = THIS_MODULE,
220 .cra_list = LIST_HEAD_INIT(cbc_des_alg.cra_list),
221 .cra_u = {
222 .blkcipher = {
223 .min_keysize = DES_KEY_SIZE,
224 .max_keysize = DES_KEY_SIZE,
225 .ivsize = DES_BLOCK_SIZE,
226 .setkey = des_setkey,
227 .encrypt = cbc_des_encrypt,
228 .decrypt = cbc_des_decrypt,
229 }
230 }
231};
232
233
234
235
236
237
238
239
240
241
242
243
244
245static int des3_128_setkey(struct crypto_tfm *tfm, const u8 *key,
246 unsigned int keylen)
247{
248 int i, ret;
249 struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm);
250 const u8 *temp_key = key;
251 u32 *flags = &tfm->crt_flags;
252
253 if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE))) {
254 *flags |= CRYPTO_TFM_RES_BAD_KEY_SCHED;
255 return -EINVAL;
256 }
257 for (i = 0; i < 2; i++, temp_key += DES_KEY_SIZE) {
258 ret = crypto_des_check_key(temp_key, DES_KEY_SIZE, flags);
259 if (ret < 0)
260 return ret;
261 }
262 memcpy(dctx->key, key, keylen);
263 return 0;
264}
265
266static void des3_128_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
267{
268 struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm);
269
270 crypt_s390_km(KM_TDEA_128_ENCRYPT, dctx->key, dst, (void*)src,
271 DES3_128_BLOCK_SIZE);
272}
273
274static void des3_128_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
275{
276 struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm);
277
278 crypt_s390_km(KM_TDEA_128_DECRYPT, dctx->key, dst, (void*)src,
279 DES3_128_BLOCK_SIZE);
280}
281
282static struct crypto_alg des3_128_alg = {
283 .cra_name = "des3_ede128",
284 .cra_driver_name = "des3_ede128-s390",
285 .cra_priority = CRYPT_S390_PRIORITY,
286 .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
287 .cra_blocksize = DES3_128_BLOCK_SIZE,
288 .cra_ctxsize = sizeof(struct crypt_s390_des3_128_ctx),
289 .cra_module = THIS_MODULE,
290 .cra_list = LIST_HEAD_INIT(des3_128_alg.cra_list),
291 .cra_u = {
292 .cipher = {
293 .cia_min_keysize = DES3_128_KEY_SIZE,
294 .cia_max_keysize = DES3_128_KEY_SIZE,
295 .cia_setkey = des3_128_setkey,
296 .cia_encrypt = des3_128_encrypt,
297 .cia_decrypt = des3_128_decrypt,
298 }
299 }
300};
301
302static int ecb_des3_128_encrypt(struct blkcipher_desc *desc,
303 struct scatterlist *dst,
304 struct scatterlist *src, unsigned int nbytes)
305{
306 struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
307 struct blkcipher_walk walk;
308
309 blkcipher_walk_init(&walk, dst, src, nbytes);
310 return ecb_desall_crypt(desc, KM_TDEA_128_ENCRYPT, sctx->key, &walk);
311}
312
313static int ecb_des3_128_decrypt(struct blkcipher_desc *desc,
314 struct scatterlist *dst,
315 struct scatterlist *src, unsigned int nbytes)
316{
317 struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
318 struct blkcipher_walk walk;
319
320 blkcipher_walk_init(&walk, dst, src, nbytes);
321 return ecb_desall_crypt(desc, KM_TDEA_128_DECRYPT, sctx->key, &walk);
322}
323
324static struct crypto_alg ecb_des3_128_alg = {
325 .cra_name = "ecb(des3_ede128)",
326 .cra_driver_name = "ecb-des3_ede128-s390",
327 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
328 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
329 .cra_blocksize = DES3_128_BLOCK_SIZE,
330 .cra_ctxsize = sizeof(struct crypt_s390_des3_128_ctx),
331 .cra_type = &crypto_blkcipher_type,
332 .cra_module = THIS_MODULE,
333 .cra_list = LIST_HEAD_INIT(
334 ecb_des3_128_alg.cra_list),
335 .cra_u = {
336 .blkcipher = {
337 .min_keysize = DES3_128_KEY_SIZE,
338 .max_keysize = DES3_128_KEY_SIZE,
339 .setkey = des3_128_setkey,
340 .encrypt = ecb_des3_128_encrypt,
341 .decrypt = ecb_des3_128_decrypt,
342 }
343 }
344};
345
346static int cbc_des3_128_encrypt(struct blkcipher_desc *desc,
347 struct scatterlist *dst,
348 struct scatterlist *src, unsigned int nbytes)
349{
350 struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
351 struct blkcipher_walk walk;
352
353 blkcipher_walk_init(&walk, dst, src, nbytes);
354 return cbc_desall_crypt(desc, KMC_TDEA_128_ENCRYPT, sctx->iv, &walk);
355}
356
357static int cbc_des3_128_decrypt(struct blkcipher_desc *desc,
358 struct scatterlist *dst,
359 struct scatterlist *src, unsigned int nbytes)
360{
361 struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
362 struct blkcipher_walk walk;
363
364 blkcipher_walk_init(&walk, dst, src, nbytes);
365 return cbc_desall_crypt(desc, KMC_TDEA_128_DECRYPT, sctx->iv, &walk);
366}
367
368static struct crypto_alg cbc_des3_128_alg = {
369 .cra_name = "cbc(des3_ede128)",
370 .cra_driver_name = "cbc-des3_ede128-s390",
371 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
372 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
373 .cra_blocksize = DES3_128_BLOCK_SIZE,
374 .cra_ctxsize = sizeof(struct crypt_s390_des3_128_ctx),
375 .cra_type = &crypto_blkcipher_type,
376 .cra_module = THIS_MODULE,
377 .cra_list = LIST_HEAD_INIT(
378 cbc_des3_128_alg.cra_list),
379 .cra_u = {
380 .blkcipher = {
381 .min_keysize = DES3_128_KEY_SIZE,
382 .max_keysize = DES3_128_KEY_SIZE,
383 .ivsize = DES3_128_BLOCK_SIZE,
384 .setkey = des3_128_setkey,
385 .encrypt = cbc_des3_128_encrypt,
386 .decrypt = cbc_des3_128_decrypt,
387 }
388 }
389};
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404static int des3_192_setkey(struct crypto_tfm *tfm, const u8 *key,
405 unsigned int keylen)
406{
407 int i, ret;
408 struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm);
409 const u8 *temp_key = key;
410 u32 *flags = &tfm->crt_flags;
411
412 if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) &&
413 memcmp(&key[DES_KEY_SIZE], &key[DES_KEY_SIZE * 2],
414 DES_KEY_SIZE))) {
415
416 *flags |= CRYPTO_TFM_RES_BAD_KEY_SCHED;
417 return -EINVAL;
418 }
419 for (i = 0; i < 3; i++, temp_key += DES_KEY_SIZE) {
420 ret = crypto_des_check_key(temp_key, DES_KEY_SIZE, flags);
421 if (ret < 0)
422 return ret;
423 }
424 memcpy(dctx->key, key, keylen);
425 return 0;
426}
427
428static void des3_192_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
429{
430 struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm);
431
432 crypt_s390_km(KM_TDEA_192_ENCRYPT, dctx->key, dst, (void*)src,
433 DES3_192_BLOCK_SIZE);
434}
435
436static void des3_192_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
437{
438 struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm);
439
440 crypt_s390_km(KM_TDEA_192_DECRYPT, dctx->key, dst, (void*)src,
441 DES3_192_BLOCK_SIZE);
442}
443
444static struct crypto_alg des3_192_alg = {
445 .cra_name = "des3_ede",
446 .cra_driver_name = "des3_ede-s390",
447 .cra_priority = CRYPT_S390_PRIORITY,
448 .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
449 .cra_blocksize = DES3_192_BLOCK_SIZE,
450 .cra_ctxsize = sizeof(struct crypt_s390_des3_192_ctx),
451 .cra_module = THIS_MODULE,
452 .cra_list = LIST_HEAD_INIT(des3_192_alg.cra_list),
453 .cra_u = {
454 .cipher = {
455 .cia_min_keysize = DES3_192_KEY_SIZE,
456 .cia_max_keysize = DES3_192_KEY_SIZE,
457 .cia_setkey = des3_192_setkey,
458 .cia_encrypt = des3_192_encrypt,
459 .cia_decrypt = des3_192_decrypt,
460 }
461 }
462};
463
464static int ecb_des3_192_encrypt(struct blkcipher_desc *desc,
465 struct scatterlist *dst,
466 struct scatterlist *src, unsigned int nbytes)
467{
468 struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
469 struct blkcipher_walk walk;
470
471 blkcipher_walk_init(&walk, dst, src, nbytes);
472 return ecb_desall_crypt(desc, KM_TDEA_192_ENCRYPT, sctx->key, &walk);
473}
474
475static int ecb_des3_192_decrypt(struct blkcipher_desc *desc,
476 struct scatterlist *dst,
477 struct scatterlist *src, unsigned int nbytes)
478{
479 struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
480 struct blkcipher_walk walk;
481
482 blkcipher_walk_init(&walk, dst, src, nbytes);
483 return ecb_desall_crypt(desc, KM_TDEA_192_DECRYPT, sctx->key, &walk);
484}
485
486static struct crypto_alg ecb_des3_192_alg = {
487 .cra_name = "ecb(des3_ede)",
488 .cra_driver_name = "ecb-des3_ede-s390",
489 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
490 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
491 .cra_blocksize = DES3_192_BLOCK_SIZE,
492 .cra_ctxsize = sizeof(struct crypt_s390_des3_192_ctx),
493 .cra_type = &crypto_blkcipher_type,
494 .cra_module = THIS_MODULE,
495 .cra_list = LIST_HEAD_INIT(
496 ecb_des3_192_alg.cra_list),
497 .cra_u = {
498 .blkcipher = {
499 .min_keysize = DES3_192_KEY_SIZE,
500 .max_keysize = DES3_192_KEY_SIZE,
501 .setkey = des3_192_setkey,
502 .encrypt = ecb_des3_192_encrypt,
503 .decrypt = ecb_des3_192_decrypt,
504 }
505 }
506};
507
508static int cbc_des3_192_encrypt(struct blkcipher_desc *desc,
509 struct scatterlist *dst,
510 struct scatterlist *src, unsigned int nbytes)
511{
512 struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
513 struct blkcipher_walk walk;
514
515 blkcipher_walk_init(&walk, dst, src, nbytes);
516 return cbc_desall_crypt(desc, KMC_TDEA_192_ENCRYPT, sctx->iv, &walk);
517}
518
519static int cbc_des3_192_decrypt(struct blkcipher_desc *desc,
520 struct scatterlist *dst,
521 struct scatterlist *src, unsigned int nbytes)
522{
523 struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
524 struct blkcipher_walk walk;
525
526 blkcipher_walk_init(&walk, dst, src, nbytes);
527 return cbc_desall_crypt(desc, KMC_TDEA_192_DECRYPT, sctx->iv, &walk);
528}
529
530static struct crypto_alg cbc_des3_192_alg = {
531 .cra_name = "cbc(des3_ede)",
532 .cra_driver_name = "cbc-des3_ede-s390",
533 .cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
534 .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
535 .cra_blocksize = DES3_192_BLOCK_SIZE,
536 .cra_ctxsize = sizeof(struct crypt_s390_des3_192_ctx),
537 .cra_type = &crypto_blkcipher_type,
538 .cra_module = THIS_MODULE,
539 .cra_list = LIST_HEAD_INIT(
540 cbc_des3_192_alg.cra_list),
541 .cra_u = {
542 .blkcipher = {
543 .min_keysize = DES3_192_KEY_SIZE,
544 .max_keysize = DES3_192_KEY_SIZE,
545 .ivsize = DES3_192_BLOCK_SIZE,
546 .setkey = des3_192_setkey,
547 .encrypt = cbc_des3_192_encrypt,
548 .decrypt = cbc_des3_192_decrypt,
549 }
550 }
551};
552
553static int des_s390_init(void)
554{
555 int ret = 0;
556
557 if (!crypt_s390_func_available(KM_DEA_ENCRYPT) ||
558 !crypt_s390_func_available(KM_TDEA_128_ENCRYPT) ||
559 !crypt_s390_func_available(KM_TDEA_192_ENCRYPT))
560 return -EOPNOTSUPP;
561
562 ret = crypto_register_alg(&des_alg);
563 if (ret)
564 goto des_err;
565 ret = crypto_register_alg(&ecb_des_alg);
566 if (ret)
567 goto ecb_des_err;
568 ret = crypto_register_alg(&cbc_des_alg);
569 if (ret)
570 goto cbc_des_err;
571
572 ret = crypto_register_alg(&des3_128_alg);
573 if (ret)
574 goto des3_128_err;
575 ret = crypto_register_alg(&ecb_des3_128_alg);
576 if (ret)
577 goto ecb_des3_128_err;
578 ret = crypto_register_alg(&cbc_des3_128_alg);
579 if (ret)
580 goto cbc_des3_128_err;
581
582 ret = crypto_register_alg(&des3_192_alg);
583 if (ret)
584 goto des3_192_err;
585 ret = crypto_register_alg(&ecb_des3_192_alg);
586 if (ret)
587 goto ecb_des3_192_err;
588 ret = crypto_register_alg(&cbc_des3_192_alg);
589 if (ret)
590 goto cbc_des3_192_err;
591
592out:
593 return ret;
594
595cbc_des3_192_err:
596 crypto_unregister_alg(&ecb_des3_192_alg);
597ecb_des3_192_err:
598 crypto_unregister_alg(&des3_192_alg);
599des3_192_err:
600 crypto_unregister_alg(&cbc_des3_128_alg);
601cbc_des3_128_err:
602 crypto_unregister_alg(&ecb_des3_128_alg);
603ecb_des3_128_err:
604 crypto_unregister_alg(&des3_128_alg);
605des3_128_err:
606 crypto_unregister_alg(&cbc_des_alg);
607cbc_des_err:
608 crypto_unregister_alg(&ecb_des_alg);
609ecb_des_err:
610 crypto_unregister_alg(&des_alg);
611des_err:
612 goto out;
613}
614
615static void __exit des_s390_fini(void)
616{
617 crypto_unregister_alg(&cbc_des3_192_alg);
618 crypto_unregister_alg(&ecb_des3_192_alg);
619 crypto_unregister_alg(&des3_192_alg);
620 crypto_unregister_alg(&cbc_des3_128_alg);
621 crypto_unregister_alg(&ecb_des3_128_alg);
622 crypto_unregister_alg(&des3_128_alg);
623 crypto_unregister_alg(&cbc_des_alg);
624 crypto_unregister_alg(&ecb_des_alg);
625 crypto_unregister_alg(&des_alg);
626}
627
628module_init(des_s390_init);
629module_exit(des_s390_fini);
630
631MODULE_ALIAS("des");
632MODULE_ALIAS("des3_ede");
633
634MODULE_LICENSE("GPL");
635MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms");
636
