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 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
 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 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
 628 module_init(des_s390_init);
 629 module_exit(des_s390_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");