1 /* 2 * ECB: Electronic CodeBook mode 3 * 4 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au> 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License as published by the Free 8 * Software Foundation; either version 2 of the License, or (at your option) 9 * any later version. 10 * 11 */ 12 13 #include <crypto/algapi.h> 14 #include <linux/err.h> 15 #include <linux/init.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/scatterlist.h> 19 #include <linux/slab.h> 20 21 struct crypto_ecb_ctx { 22 struct crypto_cipher *child; 23 }; 24 25 static int crypto_ecb_setkey(struct crypto_tfm *parent, const u8 *key, 26 unsigned int keylen) 27 { 28 struct crypto_ecb_ctx *ctx = crypto_tfm_ctx(parent); 29 struct crypto_cipher *child = ctx->child; 30 int err; 31 32 crypto_cipher_clear_flags(child, CRYPTO_TFM_REQ_MASK); 33 crypto_cipher_set_flags(child, crypto_tfm_get_flags(parent) & 34 CRYPTO_TFM_REQ_MASK); 35 err = crypto_cipher_setkey(child, key, keylen); 36 crypto_tfm_set_flags(parent, crypto_cipher_get_flags(child) & 37 CRYPTO_TFM_RES_MASK); 38 return err; 39 } 40 41 static int crypto_ecb_crypt(struct blkcipher_desc *desc, 42 struct blkcipher_walk *walk, 43 struct crypto_cipher *tfm, 44 void (*fn)(struct crypto_tfm *, u8 *, const u8 *)) 45 { 46 int bsize = crypto_cipher_blocksize(tfm); 47 unsigned int nbytes; 48 int err; 49 50 err = blkcipher_walk_virt(desc, walk); 51 52 while ((nbytes = walk->nbytes)) { 53 u8 *wsrc = walk->src.virt.addr; 54 u8 *wdst = walk->dst.virt.addr; 55 56 do { 57 fn(crypto_cipher_tfm(tfm), wdst, wsrc); 58 59 wsrc += bsize; 60 wdst += bsize; 61 } while ((nbytes -= bsize) >= bsize); 62 63 err = blkcipher_walk_done(desc, walk, nbytes); 64 } 65 66 return err; 67 } 68 69 static int crypto_ecb_encrypt(struct blkcipher_desc *desc, 70 struct scatterlist *dst, struct scatterlist *src, 71 unsigned int nbytes) 72 { 73 struct blkcipher_walk walk; 74 struct crypto_blkcipher *tfm = desc->tfm; 75 struct crypto_ecb_ctx *ctx = crypto_blkcipher_ctx(tfm); 76 struct crypto_cipher *child = ctx->child; 77 78 blkcipher_walk_init(&walk, dst, src, nbytes); 79 return crypto_ecb_crypt(desc, &walk, child, 80 crypto_cipher_alg(child)->cia_encrypt); 81 } 82 83 static int crypto_ecb_decrypt(struct blkcipher_desc *desc, 84 struct scatterlist *dst, struct scatterlist *src, 85 unsigned int nbytes) 86 { 87 struct blkcipher_walk walk; 88 struct crypto_blkcipher *tfm = desc->tfm; 89 struct crypto_ecb_ctx *ctx = crypto_blkcipher_ctx(tfm); 90 struct crypto_cipher *child = ctx->child; 91 92 blkcipher_walk_init(&walk, dst, src, nbytes); 93 return crypto_ecb_crypt(desc, &walk, child, 94 crypto_cipher_alg(child)->cia_decrypt); 95 } 96 97 static int crypto_ecb_init_tfm(struct crypto_tfm *tfm) 98 { 99 struct crypto_instance *inst = (void *)tfm->__crt_alg; 100 struct crypto_spawn *spawn = crypto_instance_ctx(inst); 101 struct crypto_ecb_ctx *ctx = crypto_tfm_ctx(tfm); 102 103 tfm = crypto_spawn_tfm(spawn); 104 if (IS_ERR(tfm)) 105 return PTR_ERR(tfm); 106 107 ctx->child = crypto_cipher_cast(tfm); 108 return 0; 109 } 110 111 static void crypto_ecb_exit_tfm(struct crypto_tfm *tfm) 112 { 113 struct crypto_ecb_ctx *ctx = crypto_tfm_ctx(tfm); 114 crypto_free_cipher(ctx->child); 115 } 116 117 static struct crypto_instance *crypto_ecb_alloc(void *param, unsigned int len) 118 { 119 struct crypto_instance *inst; 120 struct crypto_alg *alg; 121 122 alg = crypto_get_attr_alg(param, len, CRYPTO_ALG_TYPE_CIPHER, 123 CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC); 124 if (IS_ERR(alg)) 125 return ERR_PTR(PTR_ERR(alg)); 126 127 inst = crypto_alloc_instance("ecb", alg); 128 if (IS_ERR(inst)) 129 goto out_put_alg; 130 131 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; 132 inst->alg.cra_priority = alg->cra_priority; 133 inst->alg.cra_blocksize = alg->cra_blocksize; 134 inst->alg.cra_alignmask = alg->cra_alignmask; 135 inst->alg.cra_type = &crypto_blkcipher_type; 136 137 inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize; 138 inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize; 139 140 inst->alg.cra_ctxsize = sizeof(struct crypto_ecb_ctx); 141 142 inst->alg.cra_init = crypto_ecb_init_tfm; 143 inst->alg.cra_exit = crypto_ecb_exit_tfm; 144 145 inst->alg.cra_blkcipher.setkey = crypto_ecb_setkey; 146 inst->alg.cra_blkcipher.encrypt = crypto_ecb_encrypt; 147 inst->alg.cra_blkcipher.decrypt = crypto_ecb_decrypt; 148 149 out_put_alg: 150 crypto_mod_put(alg); 151 return inst; 152 } 153 154 static void crypto_ecb_free(struct crypto_instance *inst) 155 { 156 crypto_drop_spawn(crypto_instance_ctx(inst)); 157 kfree(inst); 158 } 159 160 static struct crypto_template crypto_ecb_tmpl = { 161 .name = "ecb", 162 .alloc = crypto_ecb_alloc, 163 .free = crypto_ecb_free, 164 .module = THIS_MODULE, 165 }; 166 167 static int __init crypto_ecb_module_init(void) 168 { 169 return crypto_register_template(&crypto_ecb_tmpl); 170 } 171 172 static void __exit crypto_ecb_module_exit(void) 173 { 174 crypto_unregister_template(&crypto_ecb_tmpl); 175 } 176 177 module_init(crypto_ecb_module_init); 178 module_exit(crypto_ecb_module_exit); 179 180 MODULE_LICENSE("GPL"); 181 MODULE_DESCRIPTION("ECB block cipher algorithm"); 182