URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [arch/] [s390/] [crypto/] [des_s390.c] - Blame information for rev 63

Details | Compare with Previous | View Log


/*
 * Cryptographic API.
 *
 * s390 implementation of the DES Cipher Algorithm.
 *
 * Copyright IBM Corp. 2003,2007
 * Author(s): Thomas Spatzier
 *            Jan Glauber (jan.glauber@de.ibm.com)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 */
 
#include <crypto/algapi.h>
#include <linux/init.h>
#include <linux/module.h>
 
#include "crypt_s390.h"
#include "crypto_des.h"
 
#define DES_BLOCK_SIZE 8
#define DES_KEY_SIZE 8
 
#define DES3_128_KEY_SIZE       (2 * DES_KEY_SIZE)
#define DES3_128_BLOCK_SIZE     DES_BLOCK_SIZE
 
#define DES3_192_KEY_SIZE       (3 * DES_KEY_SIZE)
#define DES3_192_BLOCK_SIZE     DES_BLOCK_SIZE
 
struct crypt_s390_des_ctx {
        u8 iv[DES_BLOCK_SIZE];
        u8 key[DES_KEY_SIZE];
};
 
struct crypt_s390_des3_128_ctx {
        u8 iv[DES_BLOCK_SIZE];
        u8 key[DES3_128_KEY_SIZE];
};
 
struct crypt_s390_des3_192_ctx {
        u8 iv[DES_BLOCK_SIZE];
        u8 key[DES3_192_KEY_SIZE];
};
 
static int des_setkey(struct crypto_tfm *tfm, const u8 *key,
                      unsigned int keylen)
{
        struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm);
        u32 *flags = &tfm->crt_flags;
        int ret;
 
        /* test if key is valid (not a weak key) */
        ret = crypto_des_check_key(key, keylen, flags);
        if (ret == 0)
                memcpy(dctx->key, key, keylen);
        return ret;
}
 
static void des_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
{
        struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm);
 
        crypt_s390_km(KM_DEA_ENCRYPT, dctx->key, out, in, DES_BLOCK_SIZE);
}
 
static void des_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
{
        struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm);
 
        crypt_s390_km(KM_DEA_DECRYPT, dctx->key, out, in, DES_BLOCK_SIZE);
}
 
static struct crypto_alg des_alg = {
        .cra_name               =       "des",
        .cra_driver_name        =       "des-s390",
        .cra_priority           =       CRYPT_S390_PRIORITY,
        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
        .cra_blocksize          =       DES_BLOCK_SIZE,
        .cra_ctxsize            =       sizeof(struct crypt_s390_des_ctx),
        .cra_module             =       THIS_MODULE,
        .cra_list               =       LIST_HEAD_INIT(des_alg.cra_list),
        .cra_u                  =       {
                .cipher = {
                        .cia_min_keysize        =       DES_KEY_SIZE,
                        .cia_max_keysize        =       DES_KEY_SIZE,
                        .cia_setkey             =       des_setkey,
                        .cia_encrypt            =       des_encrypt,
                        .cia_decrypt            =       des_decrypt,
                }
        }
};
 
static int ecb_desall_crypt(struct blkcipher_desc *desc, long func,
                            void *param, struct blkcipher_walk *walk)
{
        int ret = blkcipher_walk_virt(desc, walk);
        unsigned int nbytes;
 
        while ((nbytes = walk->nbytes)) {
                /* only use complete blocks */
                unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1);
                u8 *out = walk->dst.virt.addr;
                u8 *in = walk->src.virt.addr;
 
                ret = crypt_s390_km(func, param, out, in, n);
                BUG_ON((ret < 0) || (ret != n));
 
                nbytes &= DES_BLOCK_SIZE - 1;
                ret = blkcipher_walk_done(desc, walk, nbytes);
        }
 
        return ret;
}
 
static int cbc_desall_crypt(struct blkcipher_desc *desc, long func,
                            void *param, struct blkcipher_walk *walk)
{
        int ret = blkcipher_walk_virt(desc, walk);
        unsigned int nbytes = walk->nbytes;
 
        if (!nbytes)
                goto out;
 
        memcpy(param, walk->iv, DES_BLOCK_SIZE);
        do {
                /* only use complete blocks */
                unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1);
                u8 *out = walk->dst.virt.addr;
                u8 *in = walk->src.virt.addr;
 
                ret = crypt_s390_kmc(func, param, out, in, n);
                BUG_ON((ret < 0) || (ret != n));
 
                nbytes &= DES_BLOCK_SIZE - 1;
                ret = blkcipher_walk_done(desc, walk, nbytes);
        } while ((nbytes = walk->nbytes));
        memcpy(walk->iv, param, DES_BLOCK_SIZE);
 
out:
        return ret;
}
 
static int ecb_des_encrypt(struct blkcipher_desc *desc,
                           struct scatterlist *dst, struct scatterlist *src,
                           unsigned int nbytes)
{
        struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
        struct blkcipher_walk walk;
 
        blkcipher_walk_init(&walk, dst, src, nbytes);
        return ecb_desall_crypt(desc, KM_DEA_ENCRYPT, sctx->key, &walk);
}
 
static int ecb_des_decrypt(struct blkcipher_desc *desc,
                           struct scatterlist *dst, struct scatterlist *src,
                           unsigned int nbytes)
{
        struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
        struct blkcipher_walk walk;
 
        blkcipher_walk_init(&walk, dst, src, nbytes);
        return ecb_desall_crypt(desc, KM_DEA_DECRYPT, sctx->key, &walk);
}
 
static struct crypto_alg ecb_des_alg = {
        .cra_name               =       "ecb(des)",
        .cra_driver_name        =       "ecb-des-s390",
        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
        .cra_blocksize          =       DES_BLOCK_SIZE,
        .cra_ctxsize            =       sizeof(struct crypt_s390_des_ctx),
        .cra_type               =       &crypto_blkcipher_type,
        .cra_module             =       THIS_MODULE,
        .cra_list               =       LIST_HEAD_INIT(ecb_des_alg.cra_list),
        .cra_u                  =       {
                .blkcipher = {
                        .min_keysize            =       DES_KEY_SIZE,
                        .max_keysize            =       DES_KEY_SIZE,
                        .setkey                 =       des_setkey,
                        .encrypt                =       ecb_des_encrypt,
                        .decrypt                =       ecb_des_decrypt,
                }
        }
};
 
static int cbc_des_encrypt(struct blkcipher_desc *desc,
                           struct scatterlist *dst, struct scatterlist *src,
                           unsigned int nbytes)
{
        struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
        struct blkcipher_walk walk;
 
        blkcipher_walk_init(&walk, dst, src, nbytes);
        return cbc_desall_crypt(desc, KMC_DEA_ENCRYPT, sctx->iv, &walk);
}
 
static int cbc_des_decrypt(struct blkcipher_desc *desc,
                           struct scatterlist *dst, struct scatterlist *src,
                           unsigned int nbytes)
{
        struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
        struct blkcipher_walk walk;
 
        blkcipher_walk_init(&walk, dst, src, nbytes);
        return cbc_desall_crypt(desc, KMC_DEA_DECRYPT, sctx->iv, &walk);
}
 
static struct crypto_alg cbc_des_alg = {
        .cra_name               =       "cbc(des)",
        .cra_driver_name        =       "cbc-des-s390",
        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
        .cra_blocksize          =       DES_BLOCK_SIZE,
        .cra_ctxsize            =       sizeof(struct crypt_s390_des_ctx),
        .cra_type               =       &crypto_blkcipher_type,
        .cra_module             =       THIS_MODULE,
        .cra_list               =       LIST_HEAD_INIT(cbc_des_alg.cra_list),
        .cra_u                  =       {
                .blkcipher = {
                        .min_keysize            =       DES_KEY_SIZE,
                        .max_keysize            =       DES_KEY_SIZE,
                        .ivsize                 =       DES_BLOCK_SIZE,
                        .setkey                 =       des_setkey,
                        .encrypt                =       cbc_des_encrypt,
                        .decrypt                =       cbc_des_decrypt,
                }
        }
};
 
/*
 * RFC2451:
 *
 *   For DES-EDE3, there is no known need to reject weak or
 *   complementation keys.  Any weakness is obviated by the use of
 *   multiple keys.
 *
 *   However, if the two  independent 64-bit keys are equal,
 *   then the DES3 operation is simply the same as DES.
 *   Implementers MUST reject keys that exhibit this property.
 *
 */
static int des3_128_setkey(struct crypto_tfm *tfm, const u8 *key,
                           unsigned int keylen)
{
        int i, ret;
        struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm);
        const u8 *temp_key = key;
        u32 *flags = &tfm->crt_flags;
 
        if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE))) {
                *flags |= CRYPTO_TFM_RES_BAD_KEY_SCHED;
                return -EINVAL;
        }
        for (i = 0; i < 2; i++, temp_key += DES_KEY_SIZE) {
                ret = crypto_des_check_key(temp_key, DES_KEY_SIZE, flags);
                if (ret < 0)
                        return ret;
        }
        memcpy(dctx->key, key, keylen);
        return 0;
}
 
static void des3_128_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
{
        struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm);
 
        crypt_s390_km(KM_TDEA_128_ENCRYPT, dctx->key, dst, (void*)src,
                      DES3_128_BLOCK_SIZE);
}
 
static void des3_128_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
{
        struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm);
 
        crypt_s390_km(KM_TDEA_128_DECRYPT, dctx->key, dst, (void*)src,
                      DES3_128_BLOCK_SIZE);
}
 
static struct crypto_alg des3_128_alg = {
        .cra_name               =       "des3_ede128",
        .cra_driver_name        =       "des3_ede128-s390",
        .cra_priority           =       CRYPT_S390_PRIORITY,
        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
        .cra_blocksize          =       DES3_128_BLOCK_SIZE,
        .cra_ctxsize            =       sizeof(struct crypt_s390_des3_128_ctx),
        .cra_module             =       THIS_MODULE,
        .cra_list               =       LIST_HEAD_INIT(des3_128_alg.cra_list),
        .cra_u                  =       {
                .cipher = {
                        .cia_min_keysize        =       DES3_128_KEY_SIZE,
                        .cia_max_keysize        =       DES3_128_KEY_SIZE,
                        .cia_setkey             =       des3_128_setkey,
                        .cia_encrypt            =       des3_128_encrypt,
                        .cia_decrypt            =       des3_128_decrypt,
                }
        }
};
 
static int ecb_des3_128_encrypt(struct blkcipher_desc *desc,
                                struct scatterlist *dst,
                                struct scatterlist *src, unsigned int nbytes)
{
        struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
        struct blkcipher_walk walk;
 
        blkcipher_walk_init(&walk, dst, src, nbytes);
        return ecb_desall_crypt(desc, KM_TDEA_128_ENCRYPT, sctx->key, &walk);
}
 
static int ecb_des3_128_decrypt(struct blkcipher_desc *desc,
                                struct scatterlist *dst,
                                struct scatterlist *src, unsigned int nbytes)
{
        struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
        struct blkcipher_walk walk;
 
        blkcipher_walk_init(&walk, dst, src, nbytes);
        return ecb_desall_crypt(desc, KM_TDEA_128_DECRYPT, sctx->key, &walk);
}
 
static struct crypto_alg ecb_des3_128_alg = {
        .cra_name               =       "ecb(des3_ede128)",
        .cra_driver_name        =       "ecb-des3_ede128-s390",
        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
        .cra_blocksize          =       DES3_128_BLOCK_SIZE,
        .cra_ctxsize            =       sizeof(struct crypt_s390_des3_128_ctx),
        .cra_type               =       &crypto_blkcipher_type,
        .cra_module             =       THIS_MODULE,
        .cra_list               =       LIST_HEAD_INIT(
                                                ecb_des3_128_alg.cra_list),
        .cra_u                  =       {
                .blkcipher = {
                        .min_keysize            =       DES3_128_KEY_SIZE,
                        .max_keysize            =       DES3_128_KEY_SIZE,
                        .setkey                 =       des3_128_setkey,
                        .encrypt                =       ecb_des3_128_encrypt,
                        .decrypt                =       ecb_des3_128_decrypt,
                }
        }
};
 
static int cbc_des3_128_encrypt(struct blkcipher_desc *desc,
                                struct scatterlist *dst,
                                struct scatterlist *src, unsigned int nbytes)
{
        struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
        struct blkcipher_walk walk;
 
        blkcipher_walk_init(&walk, dst, src, nbytes);
        return cbc_desall_crypt(desc, KMC_TDEA_128_ENCRYPT, sctx->iv, &walk);
}
 
static int cbc_des3_128_decrypt(struct blkcipher_desc *desc,
                                struct scatterlist *dst,
                                struct scatterlist *src, unsigned int nbytes)
{
        struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
        struct blkcipher_walk walk;
 
        blkcipher_walk_init(&walk, dst, src, nbytes);
        return cbc_desall_crypt(desc, KMC_TDEA_128_DECRYPT, sctx->iv, &walk);
}
 
static struct crypto_alg cbc_des3_128_alg = {
        .cra_name               =       "cbc(des3_ede128)",
        .cra_driver_name        =       "cbc-des3_ede128-s390",
        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
        .cra_blocksize          =       DES3_128_BLOCK_SIZE,
        .cra_ctxsize            =       sizeof(struct crypt_s390_des3_128_ctx),
        .cra_type               =       &crypto_blkcipher_type,
        .cra_module             =       THIS_MODULE,
        .cra_list               =       LIST_HEAD_INIT(
                                                cbc_des3_128_alg.cra_list),
        .cra_u                  =       {
                .blkcipher = {
                        .min_keysize            =       DES3_128_KEY_SIZE,
                        .max_keysize            =       DES3_128_KEY_SIZE,
                        .ivsize                 =       DES3_128_BLOCK_SIZE,
                        .setkey                 =       des3_128_setkey,
                        .encrypt                =       cbc_des3_128_encrypt,
                        .decrypt                =       cbc_des3_128_decrypt,
                }
        }
};
 
/*
 * RFC2451:
 *
 *   For DES-EDE3, there is no known need to reject weak or
 *   complementation keys.  Any weakness is obviated by the use of
 *   multiple keys.
 *
 *   However, if the first two or last two independent 64-bit keys are
 *   equal (k1 == k2 or k2 == k3), then the DES3 operation is simply the
 *   same as DES.  Implementers MUST reject keys that exhibit this
 *   property.
 *
 */
static int des3_192_setkey(struct crypto_tfm *tfm, const u8 *key,
                           unsigned int keylen)
{
        int i, ret;
        struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm);
        const u8 *temp_key = key;
        u32 *flags = &tfm->crt_flags;
 
        if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) &&
            memcmp(&key[DES_KEY_SIZE], &key[DES_KEY_SIZE * 2],
                   DES_KEY_SIZE))) {
 
                *flags |= CRYPTO_TFM_RES_BAD_KEY_SCHED;
                return -EINVAL;
        }
        for (i = 0; i < 3; i++, temp_key += DES_KEY_SIZE) {
                ret = crypto_des_check_key(temp_key, DES_KEY_SIZE, flags);
                if (ret < 0)
                        return ret;
        }
        memcpy(dctx->key, key, keylen);
        return 0;
}
 
static void des3_192_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
{
        struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm);
 
        crypt_s390_km(KM_TDEA_192_ENCRYPT, dctx->key, dst, (void*)src,
                      DES3_192_BLOCK_SIZE);
}
 
static void des3_192_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
{
        struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm);
 
        crypt_s390_km(KM_TDEA_192_DECRYPT, dctx->key, dst, (void*)src,
                      DES3_192_BLOCK_SIZE);
}
 
static struct crypto_alg des3_192_alg = {
        .cra_name               =       "des3_ede",
        .cra_driver_name        =       "des3_ede-s390",
        .cra_priority           =       CRYPT_S390_PRIORITY,
        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
        .cra_blocksize          =       DES3_192_BLOCK_SIZE,
        .cra_ctxsize            =       sizeof(struct crypt_s390_des3_192_ctx),
        .cra_module             =       THIS_MODULE,
        .cra_list               =       LIST_HEAD_INIT(des3_192_alg.cra_list),
        .cra_u                  =       {
                .cipher = {
                        .cia_min_keysize        =       DES3_192_KEY_SIZE,
                        .cia_max_keysize        =       DES3_192_KEY_SIZE,
                        .cia_setkey             =       des3_192_setkey,
                        .cia_encrypt            =       des3_192_encrypt,
                        .cia_decrypt            =       des3_192_decrypt,
                }
        }
};
 
static int ecb_des3_192_encrypt(struct blkcipher_desc *desc,
                                struct scatterlist *dst,
                                struct scatterlist *src, unsigned int nbytes)
{
        struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
        struct blkcipher_walk walk;
 
        blkcipher_walk_init(&walk, dst, src, nbytes);
        return ecb_desall_crypt(desc, KM_TDEA_192_ENCRYPT, sctx->key, &walk);
}
 
static int ecb_des3_192_decrypt(struct blkcipher_desc *desc,
                                struct scatterlist *dst,
                                struct scatterlist *src, unsigned int nbytes)
{
        struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
        struct blkcipher_walk walk;
 
        blkcipher_walk_init(&walk, dst, src, nbytes);
        return ecb_desall_crypt(desc, KM_TDEA_192_DECRYPT, sctx->key, &walk);
}
 
static struct crypto_alg ecb_des3_192_alg = {
        .cra_name               =       "ecb(des3_ede)",
        .cra_driver_name        =       "ecb-des3_ede-s390",
        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
        .cra_blocksize          =       DES3_192_BLOCK_SIZE,
        .cra_ctxsize            =       sizeof(struct crypt_s390_des3_192_ctx),
        .cra_type               =       &crypto_blkcipher_type,
        .cra_module             =       THIS_MODULE,
        .cra_list               =       LIST_HEAD_INIT(
                                                ecb_des3_192_alg.cra_list),
        .cra_u                  =       {
                .blkcipher = {
                        .min_keysize            =       DES3_192_KEY_SIZE,
                        .max_keysize            =       DES3_192_KEY_SIZE,
                        .setkey                 =       des3_192_setkey,
                        .encrypt                =       ecb_des3_192_encrypt,
                        .decrypt                =       ecb_des3_192_decrypt,
                }
        }
};
 
static int cbc_des3_192_encrypt(struct blkcipher_desc *desc,
                                struct scatterlist *dst,
                                struct scatterlist *src, unsigned int nbytes)
{
        struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
        struct blkcipher_walk walk;
 
        blkcipher_walk_init(&walk, dst, src, nbytes);
        return cbc_desall_crypt(desc, KMC_TDEA_192_ENCRYPT, sctx->iv, &walk);
}
 
static int cbc_des3_192_decrypt(struct blkcipher_desc *desc,
                                struct scatterlist *dst,
                                struct scatterlist *src, unsigned int nbytes)
{
        struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
        struct blkcipher_walk walk;
 
        blkcipher_walk_init(&walk, dst, src, nbytes);
        return cbc_desall_crypt(desc, KMC_TDEA_192_DECRYPT, sctx->iv, &walk);
}
 
static struct crypto_alg cbc_des3_192_alg = {
        .cra_name               =       "cbc(des3_ede)",
        .cra_driver_name        =       "cbc-des3_ede-s390",
        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
        .cra_blocksize          =       DES3_192_BLOCK_SIZE,
        .cra_ctxsize            =       sizeof(struct crypt_s390_des3_192_ctx),
        .cra_type               =       &crypto_blkcipher_type,
        .cra_module             =       THIS_MODULE,
        .cra_list               =       LIST_HEAD_INIT(
                                                cbc_des3_192_alg.cra_list),
        .cra_u                  =       {
                .blkcipher = {
                        .min_keysize            =       DES3_192_KEY_SIZE,
                        .max_keysize            =       DES3_192_KEY_SIZE,
                        .ivsize                 =       DES3_192_BLOCK_SIZE,
                        .setkey                 =       des3_192_setkey,
                        .encrypt                =       cbc_des3_192_encrypt,
                        .decrypt                =       cbc_des3_192_decrypt,
                }
        }
};
 
static int init(void)
{
        int ret = 0;
 
        if (!crypt_s390_func_available(KM_DEA_ENCRYPT) ||
            !crypt_s390_func_available(KM_TDEA_128_ENCRYPT) ||
            !crypt_s390_func_available(KM_TDEA_192_ENCRYPT))
                return -EOPNOTSUPP;
 
        ret = crypto_register_alg(&des_alg);
        if (ret)
                goto des_err;
        ret = crypto_register_alg(&ecb_des_alg);
        if (ret)
                goto ecb_des_err;
        ret = crypto_register_alg(&cbc_des_alg);
        if (ret)
                goto cbc_des_err;
 
        ret = crypto_register_alg(&des3_128_alg);
        if (ret)
                goto des3_128_err;
        ret = crypto_register_alg(&ecb_des3_128_alg);
        if (ret)
                goto ecb_des3_128_err;
        ret = crypto_register_alg(&cbc_des3_128_alg);
        if (ret)
                goto cbc_des3_128_err;
 
        ret = crypto_register_alg(&des3_192_alg);
        if (ret)
                goto des3_192_err;
        ret = crypto_register_alg(&ecb_des3_192_alg);
        if (ret)
                goto ecb_des3_192_err;
        ret = crypto_register_alg(&cbc_des3_192_alg);
        if (ret)
                goto cbc_des3_192_err;
 
out:
        return ret;
 
cbc_des3_192_err:
        crypto_unregister_alg(&ecb_des3_192_alg);
ecb_des3_192_err:
        crypto_unregister_alg(&des3_192_alg);
des3_192_err:
        crypto_unregister_alg(&cbc_des3_128_alg);
cbc_des3_128_err:
        crypto_unregister_alg(&ecb_des3_128_alg);
ecb_des3_128_err:
        crypto_unregister_alg(&des3_128_alg);
des3_128_err:
        crypto_unregister_alg(&cbc_des_alg);
cbc_des_err:
        crypto_unregister_alg(&ecb_des_alg);
ecb_des_err:
        crypto_unregister_alg(&des_alg);
des_err:
        goto out;
}
 
static void __exit fini(void)
{
        crypto_unregister_alg(&cbc_des3_192_alg);
        crypto_unregister_alg(&ecb_des3_192_alg);
        crypto_unregister_alg(&des3_192_alg);
        crypto_unregister_alg(&cbc_des3_128_alg);
        crypto_unregister_alg(&ecb_des3_128_alg);
        crypto_unregister_alg(&des3_128_alg);
        crypto_unregister_alg(&cbc_des_alg);
        crypto_unregister_alg(&ecb_des_alg);
        crypto_unregister_alg(&des_alg);
}
 
module_init(init);
module_exit(fini);
 
MODULE_ALIAS("des");
MODULE_ALIAS("des3_ede");
 
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms");

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [arch/] [s390/] [crypto/] [des_s390.c] - Blame information for rev 63

Line No.	Rev	Author	Line
1	63	marcus.erl	`/*`
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");`