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

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

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

~ [ 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