~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/s390/crypto/des_s390.c

Version: ~ [ linux-5.1-rc1 ] ~ [ linux-5.0.3 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.30 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.107 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.164 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.176 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.136 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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_list               =       LIST_HEAD_INIT(des_alg.cra_list),
 74         .cra_u                  =       {
 75                 .cipher = {
 76                         .cia_min_keysize        =       DES_KEY_SIZE,
 77                         .cia_max_keysize        =       DES_KEY_SIZE,
 78                         .cia_setkey             =       des_setkey,
 79                         .cia_encrypt            =       des_encrypt,
 80                         .cia_decrypt            =       des_decrypt,
 81                 }
 82         }
 83 };
 84 
 85 static int ecb_desall_crypt(struct blkcipher_desc *desc, long func,
 86                             u8 *key, struct blkcipher_walk *walk)
 87 {
 88         int ret = blkcipher_walk_virt(desc, walk);
 89         unsigned int nbytes;
 90 
 91         while ((nbytes = walk->nbytes)) {
 92                 /* only use complete blocks */
 93                 unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1);
 94                 u8 *out = walk->dst.virt.addr;
 95                 u8 *in = walk->src.virt.addr;
 96 
 97                 ret = crypt_s390_km(func, key, out, in, n);
 98                 BUG_ON((ret < 0) || (ret != n));
 99 
100                 nbytes &= DES_BLOCK_SIZE - 1;
101                 ret = blkcipher_walk_done(desc, walk, nbytes);
102         }
103 
104         return ret;
105 }
106 
107 static int cbc_desall_crypt(struct blkcipher_desc *desc, long func,
108                             u8 *iv, struct blkcipher_walk *walk)
109 {
110         int ret = blkcipher_walk_virt(desc, walk);
111         unsigned int nbytes = walk->nbytes;
112 
113         if (!nbytes)
114                 goto out;
115 
116         memcpy(iv, walk->iv, DES_BLOCK_SIZE);
117         do {
118                 /* only use complete blocks */
119                 unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1);
120                 u8 *out = walk->dst.virt.addr;
121                 u8 *in = walk->src.virt.addr;
122 
123                 ret = crypt_s390_kmc(func, iv, out, in, n);
124                 BUG_ON((ret < 0) || (ret != n));
125 
126                 nbytes &= DES_BLOCK_SIZE - 1;
127                 ret = blkcipher_walk_done(desc, walk, nbytes);
128         } while ((nbytes = walk->nbytes));
129         memcpy(walk->iv, iv, DES_BLOCK_SIZE);
130 
131 out:
132         return ret;
133 }
134 
135 static int ecb_des_encrypt(struct blkcipher_desc *desc,
136                            struct scatterlist *dst, struct scatterlist *src,
137                            unsigned int nbytes)
138 {
139         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
140         struct blkcipher_walk walk;
141 
142         blkcipher_walk_init(&walk, dst, src, nbytes);
143         return ecb_desall_crypt(desc, KM_DEA_ENCRYPT, ctx->key, &walk);
144 }
145 
146 static int ecb_des_decrypt(struct blkcipher_desc *desc,
147                            struct scatterlist *dst, struct scatterlist *src,
148                            unsigned int nbytes)
149 {
150         struct s390_des_ctx *ctx = 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_DECRYPT, ctx->key, &walk);
155 }
156 
157 static struct crypto_alg ecb_des_alg = {
158         .cra_name               =       "ecb(des)",
159         .cra_driver_name        =       "ecb-des-s390",
160         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
161         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
162         .cra_blocksize          =       DES_BLOCK_SIZE,
163         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
164         .cra_type               =       &crypto_blkcipher_type,
165         .cra_module             =       THIS_MODULE,
166         .cra_list               =       LIST_HEAD_INIT(ecb_des_alg.cra_list),
167         .cra_u                  =       {
168                 .blkcipher = {
169                         .min_keysize            =       DES_KEY_SIZE,
170                         .max_keysize            =       DES_KEY_SIZE,
171                         .setkey                 =       des_setkey,
172                         .encrypt                =       ecb_des_encrypt,
173                         .decrypt                =       ecb_des_decrypt,
174                 }
175         }
176 };
177 
178 static int cbc_des_encrypt(struct blkcipher_desc *desc,
179                            struct scatterlist *dst, struct scatterlist *src,
180                            unsigned int nbytes)
181 {
182         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
183         struct blkcipher_walk walk;
184 
185         blkcipher_walk_init(&walk, dst, src, nbytes);
186         return cbc_desall_crypt(desc, KMC_DEA_ENCRYPT, ctx->iv, &walk);
187 }
188 
189 static int cbc_des_decrypt(struct blkcipher_desc *desc,
190                            struct scatterlist *dst, struct scatterlist *src,
191                            unsigned int nbytes)
192 {
193         struct s390_des_ctx *ctx = 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_DECRYPT, ctx->iv, &walk);
198 }
199 
200 static struct crypto_alg cbc_des_alg = {
201         .cra_name               =       "cbc(des)",
202         .cra_driver_name        =       "cbc-des-s390",
203         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
204         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
205         .cra_blocksize          =       DES_BLOCK_SIZE,
206         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
207         .cra_type               =       &crypto_blkcipher_type,
208         .cra_module             =       THIS_MODULE,
209         .cra_list               =       LIST_HEAD_INIT(cbc_des_alg.cra_list),
210         .cra_u                  =       {
211                 .blkcipher = {
212                         .min_keysize            =       DES_KEY_SIZE,
213                         .max_keysize            =       DES_KEY_SIZE,
214                         .ivsize                 =       DES_BLOCK_SIZE,
215                         .setkey                 =       des_setkey,
216                         .encrypt                =       cbc_des_encrypt,
217                         .decrypt                =       cbc_des_decrypt,
218                 }
219         }
220 };
221 
222 /*
223  * RFC2451:
224  *
225  *   For DES-EDE3, there is no known need to reject weak or
226  *   complementation keys.  Any weakness is obviated by the use of
227  *   multiple keys.
228  *
229  *   However, if the first two or last two independent 64-bit keys are
230  *   equal (k1 == k2 or k2 == k3), then the DES3 operation is simply the
231  *   same as DES.  Implementers MUST reject keys that exhibit this
232  *   property.
233  *
234  */
235 static int des3_setkey(struct crypto_tfm *tfm, const u8 *key,
236                        unsigned int key_len)
237 {
238         struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
239         u32 *flags = &tfm->crt_flags;
240 
241         if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) &&
242             memcmp(&key[DES_KEY_SIZE], &key[DES_KEY_SIZE * 2],
243                    DES_KEY_SIZE)) &&
244             (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) {
245                 *flags |= CRYPTO_TFM_RES_WEAK_KEY;
246                 return -EINVAL;
247         }
248         memcpy(ctx->key, key, key_len);
249         return 0;
250 }
251 
252 static void des3_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
253 {
254         struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
255 
256         crypt_s390_km(KM_TDEA_192_ENCRYPT, ctx->key, dst, src, DES_BLOCK_SIZE);
257 }
258 
259 static void des3_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
260 {
261         struct s390_des_ctx *ctx = crypto_tfm_ctx(tfm);
262 
263         crypt_s390_km(KM_TDEA_192_DECRYPT, ctx->key, dst, src, DES_BLOCK_SIZE);
264 }
265 
266 static struct crypto_alg des3_alg = {
267         .cra_name               =       "des3_ede",
268         .cra_driver_name        =       "des3_ede-s390",
269         .cra_priority           =       CRYPT_S390_PRIORITY,
270         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
271         .cra_blocksize          =       DES_BLOCK_SIZE,
272         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
273         .cra_module             =       THIS_MODULE,
274         .cra_list               =       LIST_HEAD_INIT(des3_alg.cra_list),
275         .cra_u                  =       {
276                 .cipher = {
277                         .cia_min_keysize        =       DES3_KEY_SIZE,
278                         .cia_max_keysize        =       DES3_KEY_SIZE,
279                         .cia_setkey             =       des3_setkey,
280                         .cia_encrypt            =       des3_encrypt,
281                         .cia_decrypt            =       des3_decrypt,
282                 }
283         }
284 };
285 
286 static int ecb_des3_encrypt(struct blkcipher_desc *desc,
287                             struct scatterlist *dst, struct scatterlist *src,
288                             unsigned int nbytes)
289 {
290         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
291         struct blkcipher_walk walk;
292 
293         blkcipher_walk_init(&walk, dst, src, nbytes);
294         return ecb_desall_crypt(desc, KM_TDEA_192_ENCRYPT, ctx->key, &walk);
295 }
296 
297 static int ecb_des3_decrypt(struct blkcipher_desc *desc,
298                             struct scatterlist *dst, struct scatterlist *src,
299                             unsigned int nbytes)
300 {
301         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
302         struct blkcipher_walk walk;
303 
304         blkcipher_walk_init(&walk, dst, src, nbytes);
305         return ecb_desall_crypt(desc, KM_TDEA_192_DECRYPT, ctx->key, &walk);
306 }
307 
308 static struct crypto_alg ecb_des3_alg = {
309         .cra_name               =       "ecb(des3_ede)",
310         .cra_driver_name        =       "ecb-des3_ede-s390",
311         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
312         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
313         .cra_blocksize          =       DES_BLOCK_SIZE,
314         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
315         .cra_type               =       &crypto_blkcipher_type,
316         .cra_module             =       THIS_MODULE,
317         .cra_list               =       LIST_HEAD_INIT(
318                                                 ecb_des3_alg.cra_list),
319         .cra_u                  =       {
320                 .blkcipher = {
321                         .min_keysize            =       DES3_KEY_SIZE,
322                         .max_keysize            =       DES3_KEY_SIZE,
323                         .setkey                 =       des3_setkey,
324                         .encrypt                =       ecb_des3_encrypt,
325                         .decrypt                =       ecb_des3_decrypt,
326                 }
327         }
328 };
329 
330 static int cbc_des3_encrypt(struct blkcipher_desc *desc,
331                             struct scatterlist *dst, struct scatterlist *src,
332                             unsigned int nbytes)
333 {
334         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
335         struct blkcipher_walk walk;
336 
337         blkcipher_walk_init(&walk, dst, src, nbytes);
338         return cbc_desall_crypt(desc, KMC_TDEA_192_ENCRYPT, ctx->iv, &walk);
339 }
340 
341 static int cbc_des3_decrypt(struct blkcipher_desc *desc,
342                             struct scatterlist *dst, struct scatterlist *src,
343                             unsigned int nbytes)
344 {
345         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
346         struct blkcipher_walk walk;
347 
348         blkcipher_walk_init(&walk, dst, src, nbytes);
349         return cbc_desall_crypt(desc, KMC_TDEA_192_DECRYPT, ctx->iv, &walk);
350 }
351 
352 static struct crypto_alg cbc_des3_alg = {
353         .cra_name               =       "cbc(des3_ede)",
354         .cra_driver_name        =       "cbc-des3_ede-s390",
355         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
356         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
357         .cra_blocksize          =       DES_BLOCK_SIZE,
358         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
359         .cra_type               =       &crypto_blkcipher_type,
360         .cra_module             =       THIS_MODULE,
361         .cra_list               =       LIST_HEAD_INIT(
362                                                 cbc_des3_alg.cra_list),
363         .cra_u                  =       {
364                 .blkcipher = {
365                         .min_keysize            =       DES3_KEY_SIZE,
366                         .max_keysize            =       DES3_KEY_SIZE,
367                         .ivsize                 =       DES_BLOCK_SIZE,
368                         .setkey                 =       des3_setkey,
369                         .encrypt                =       cbc_des3_encrypt,
370                         .decrypt                =       cbc_des3_decrypt,
371                 }
372         }
373 };
374 
375 static int ctr_desall_crypt(struct blkcipher_desc *desc, long func,
376                             struct s390_des_ctx *ctx, struct blkcipher_walk *walk)
377 {
378         int ret = blkcipher_walk_virt_block(desc, walk, DES_BLOCK_SIZE);
379         unsigned int i, n, nbytes;
380         u8 buf[DES_BLOCK_SIZE];
381         u8 *out, *in;
382 
383         memcpy(ctrblk, walk->iv, DES_BLOCK_SIZE);
384         while ((nbytes = walk->nbytes) >= DES_BLOCK_SIZE) {
385                 out = walk->dst.virt.addr;
386                 in = walk->src.virt.addr;
387                 while (nbytes >= DES_BLOCK_SIZE) {
388                         /* align to block size, max. PAGE_SIZE */
389                         n = (nbytes > PAGE_SIZE) ? PAGE_SIZE :
390                                 nbytes & ~(DES_BLOCK_SIZE - 1);
391                         for (i = DES_BLOCK_SIZE; i < n; i += DES_BLOCK_SIZE) {
392                                 memcpy(ctrblk + i, ctrblk + i - DES_BLOCK_SIZE,
393                                        DES_BLOCK_SIZE);
394                                 crypto_inc(ctrblk + i, DES_BLOCK_SIZE);
395                         }
396                         ret = crypt_s390_kmctr(func, ctx->key, out, in, n, ctrblk);
397                         BUG_ON((ret < 0) || (ret != n));
398                         if (n > DES_BLOCK_SIZE)
399                                 memcpy(ctrblk, ctrblk + n - DES_BLOCK_SIZE,
400                                        DES_BLOCK_SIZE);
401                         crypto_inc(ctrblk, DES_BLOCK_SIZE);
402                         out += n;
403                         in += n;
404                         nbytes -= n;
405                 }
406                 ret = blkcipher_walk_done(desc, walk, nbytes);
407         }
408 
409         /* final block may be < DES_BLOCK_SIZE, copy only nbytes */
410         if (nbytes) {
411                 out = walk->dst.virt.addr;
412                 in = walk->src.virt.addr;
413                 ret = crypt_s390_kmctr(func, ctx->key, buf, in,
414                                        DES_BLOCK_SIZE, ctrblk);
415                 BUG_ON(ret < 0 || ret != DES_BLOCK_SIZE);
416                 memcpy(out, buf, nbytes);
417                 crypto_inc(ctrblk, DES_BLOCK_SIZE);
418                 ret = blkcipher_walk_done(desc, walk, 0);
419         }
420         memcpy(walk->iv, ctrblk, DES_BLOCK_SIZE);
421         return ret;
422 }
423 
424 static int ctr_des_encrypt(struct blkcipher_desc *desc,
425                            struct scatterlist *dst, struct scatterlist *src,
426                            unsigned int nbytes)
427 {
428         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
429         struct blkcipher_walk walk;
430 
431         blkcipher_walk_init(&walk, dst, src, nbytes);
432         return ctr_desall_crypt(desc, KMCTR_DEA_ENCRYPT, ctx, &walk);
433 }
434 
435 static int ctr_des_decrypt(struct blkcipher_desc *desc,
436                            struct scatterlist *dst, struct scatterlist *src,
437                            unsigned int nbytes)
438 {
439         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
440         struct blkcipher_walk walk;
441 
442         blkcipher_walk_init(&walk, dst, src, nbytes);
443         return ctr_desall_crypt(desc, KMCTR_DEA_DECRYPT, ctx, &walk);
444 }
445 
446 static struct crypto_alg ctr_des_alg = {
447         .cra_name               =       "ctr(des)",
448         .cra_driver_name        =       "ctr-des-s390",
449         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
450         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
451         .cra_blocksize          =       1,
452         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
453         .cra_type               =       &crypto_blkcipher_type,
454         .cra_module             =       THIS_MODULE,
455         .cra_list               =       LIST_HEAD_INIT(ctr_des_alg.cra_list),
456         .cra_u                  =       {
457                 .blkcipher = {
458                         .min_keysize            =       DES_KEY_SIZE,
459                         .max_keysize            =       DES_KEY_SIZE,
460                         .ivsize                 =       DES_BLOCK_SIZE,
461                         .setkey                 =       des_setkey,
462                         .encrypt                =       ctr_des_encrypt,
463                         .decrypt                =       ctr_des_decrypt,
464                 }
465         }
466 };
467 
468 static int ctr_des3_encrypt(struct blkcipher_desc *desc,
469                             struct scatterlist *dst, struct scatterlist *src,
470                             unsigned int nbytes)
471 {
472         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
473         struct blkcipher_walk walk;
474 
475         blkcipher_walk_init(&walk, dst, src, nbytes);
476         return ctr_desall_crypt(desc, KMCTR_TDEA_192_ENCRYPT, ctx, &walk);
477 }
478 
479 static int ctr_des3_decrypt(struct blkcipher_desc *desc,
480                             struct scatterlist *dst, struct scatterlist *src,
481                             unsigned int nbytes)
482 {
483         struct s390_des_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
484         struct blkcipher_walk walk;
485 
486         blkcipher_walk_init(&walk, dst, src, nbytes);
487         return ctr_desall_crypt(desc, KMCTR_TDEA_192_DECRYPT, ctx, &walk);
488 }
489 
490 static struct crypto_alg ctr_des3_alg = {
491         .cra_name               =       "ctr(des3_ede)",
492         .cra_driver_name        =       "ctr-des3_ede-s390",
493         .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
494         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
495         .cra_blocksize          =       1,
496         .cra_ctxsize            =       sizeof(struct s390_des_ctx),
497         .cra_type               =       &crypto_blkcipher_type,
498         .cra_module             =       THIS_MODULE,
499         .cra_list               =       LIST_HEAD_INIT(ctr_des3_alg.cra_list),
500         .cra_u                  =       {
501                 .blkcipher = {
502                         .min_keysize            =       DES3_KEY_SIZE,
503                         .max_keysize            =       DES3_KEY_SIZE,
504                         .ivsize                 =       DES_BLOCK_SIZE,
505                         .setkey                 =       des3_setkey,
506                         .encrypt                =       ctr_des3_encrypt,
507                         .decrypt                =       ctr_des3_decrypt,
508                 }
509         }
510 };
511 
512 static int __init des_s390_init(void)
513 {
514         int ret;
515 
516         if (!crypt_s390_func_available(KM_DEA_ENCRYPT, CRYPT_S390_MSA) ||
517             !crypt_s390_func_available(KM_TDEA_192_ENCRYPT, CRYPT_S390_MSA))
518                 return -EOPNOTSUPP;
519 
520         ret = crypto_register_alg(&des_alg);
521         if (ret)
522                 goto des_err;
523         ret = crypto_register_alg(&ecb_des_alg);
524         if (ret)
525                 goto ecb_des_err;
526         ret = crypto_register_alg(&cbc_des_alg);
527         if (ret)
528                 goto cbc_des_err;
529         ret = crypto_register_alg(&des3_alg);
530         if (ret)
531                 goto des3_err;
532         ret = crypto_register_alg(&ecb_des3_alg);
533         if (ret)
534                 goto ecb_des3_err;
535         ret = crypto_register_alg(&cbc_des3_alg);
536         if (ret)
537                 goto cbc_des3_err;
538 
539         if (crypt_s390_func_available(KMCTR_DEA_ENCRYPT,
540                         CRYPT_S390_MSA | CRYPT_S390_MSA4) &&
541             crypt_s390_func_available(KMCTR_TDEA_192_ENCRYPT,
542                         CRYPT_S390_MSA | CRYPT_S390_MSA4)) {
543                 ret = crypto_register_alg(&ctr_des_alg);
544                 if (ret)
545                         goto ctr_des_err;
546                 ret = crypto_register_alg(&ctr_des3_alg);
547                 if (ret)
548                         goto ctr_des3_err;
549                 ctrblk = (u8 *) __get_free_page(GFP_KERNEL);
550                 if (!ctrblk) {
551                         ret = -ENOMEM;
552                         goto ctr_mem_err;
553                 }
554         }
555 out:
556         return ret;
557 
558 ctr_mem_err:
559         crypto_unregister_alg(&ctr_des3_alg);
560 ctr_des3_err:
561         crypto_unregister_alg(&ctr_des_alg);
562 ctr_des_err:
563         crypto_unregister_alg(&cbc_des3_alg);
564 cbc_des3_err:
565         crypto_unregister_alg(&ecb_des3_alg);
566 ecb_des3_err:
567         crypto_unregister_alg(&des3_alg);
568 des3_err:
569         crypto_unregister_alg(&cbc_des_alg);
570 cbc_des_err:
571         crypto_unregister_alg(&ecb_des_alg);
572 ecb_des_err:
573         crypto_unregister_alg(&des_alg);
574 des_err:
575         goto out;
576 }
577 
578 static void __exit des_s390_exit(void)
579 {
580         if (ctrblk) {
581                 crypto_unregister_alg(&ctr_des_alg);
582                 crypto_unregister_alg(&ctr_des3_alg);
583                 free_page((unsigned long) ctrblk);
584         }
585         crypto_unregister_alg(&cbc_des3_alg);
586         crypto_unregister_alg(&ecb_des3_alg);
587         crypto_unregister_alg(&des3_alg);
588         crypto_unregister_alg(&cbc_des_alg);
589         crypto_unregister_alg(&ecb_des_alg);
590         crypto_unregister_alg(&des_alg);
591 }
592 
593 module_init(des_s390_init);
594 module_exit(des_s390_exit);
595 
596 MODULE_ALIAS("des");
597 MODULE_ALIAS("des3_ede");
598 
599 MODULE_LICENSE("GPL");
600 MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms");
601 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp