[S390] Support for s390 Pseudo Random Number Generator
[linux-2.6.git] / arch / s390 / crypto / des_s390.c
1 /*
2  * Cryptographic API.
3  *
4  * s390 implementation of the DES Cipher Algorithm.
5  *
6  * Copyright IBM Corp. 2003,2007
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 <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
33 struct crypt_s390_des_ctx {
34         u8 iv[DES_BLOCK_SIZE];
35         u8 key[DES_KEY_SIZE];
36 };
37
38 struct crypt_s390_des3_128_ctx {
39         u8 iv[DES_BLOCK_SIZE];
40         u8 key[DES3_128_KEY_SIZE];
41 };
42
43 struct crypt_s390_des3_192_ctx {
44         u8 iv[DES_BLOCK_SIZE];
45         u8 key[DES3_192_KEY_SIZE];
46 };
47
48 static 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         /* test if key is valid (not a weak key) */
56         ret = crypto_des_check_key(key, keylen, flags);
57         if (ret == 0)
58                 memcpy(dctx->key, key, keylen);
59         return ret;
60 }
61
62 static 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
69 static 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
76 static 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
96 static 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                 /* only use complete blocks */
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
118 static 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                 /* only use complete blocks */
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
142 out:
143         return ret;
144 }
145
146 static 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
157 static 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
168 static 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
189 static 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
200 static 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
211 static 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  * RFC2451:
235  *
236  *   For DES-EDE3, there is no known need to reject weak or
237  *   complementation keys.  Any weakness is obviated by the use of
238  *   multiple keys.
239  *
240  *   However, if the two  independent 64-bit keys are equal,
241  *   then the DES3 operation is simply the same as DES.
242  *   Implementers MUST reject keys that exhibit this property.
243  *
244  */
245 static 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
266 static 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
274 static 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
282 static 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
302 static 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
313 static 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
324 static 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
346 static 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
357 static 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
368 static 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  * RFC2451:
393  *
394  *   For DES-EDE3, there is no known need to reject weak or
395  *   complementation keys.  Any weakness is obviated by the use of
396  *   multiple keys.
397  *
398  *   However, if the first two or last two independent 64-bit keys are
399  *   equal (k1 == k2 or k2 == k3), then the DES3 operation is simply the
400  *   same as DES.  Implementers MUST reject keys that exhibit this
401  *   property.
402  *
403  */
404 static 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
428 static 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
436 static 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
444 static 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
464 static 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
475 static 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
486 static 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
508 static 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
519 static 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
530 static 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
553 static int 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
592 out:
593         return ret;
594
595 cbc_des3_192_err:
596         crypto_unregister_alg(&ecb_des3_192_alg);
597 ecb_des3_192_err:
598         crypto_unregister_alg(&des3_192_alg);
599 des3_192_err:
600         crypto_unregister_alg(&cbc_des3_128_alg);
601 cbc_des3_128_err:
602         crypto_unregister_alg(&ecb_des3_128_alg);
603 ecb_des3_128_err:
604         crypto_unregister_alg(&des3_128_alg);
605 des3_128_err:
606         crypto_unregister_alg(&cbc_des_alg);
607 cbc_des_err:
608         crypto_unregister_alg(&ecb_des_alg);
609 ecb_des_err:
610         crypto_unregister_alg(&des_alg);
611 des_err:
612         goto out;
613 }
614
615 static void __exit 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
628 module_init(init);
629 module_exit(fini);
630
631 MODULE_ALIAS("des");
632 MODULE_ALIAS("des3_ede");
633
634 MODULE_LICENSE("GPL");
635 MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms");