1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C)2006 USAGI/WIDE Project 4 * 5 * Author: 6 * Kazunori Miyazawa <miyazawa@linux-ipv6.org> 7 */ 8 9 #include <crypto/internal/cipher.h> 10 #include <crypto/internal/hash.h> 11 #include <linux/err.h> 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 15 static u_int32_t ks[12] = {0x01010101, 0x01010101, 0x01010101, 0x01010101, 16 0x02020202, 0x02020202, 0x02020202, 0x02020202, 17 0x03030303, 0x03030303, 0x03030303, 0x03030303}; 18 19 /* 20 * +------------------------ 21 * | <parent tfm> 22 * +------------------------ 23 * | xcbc_tfm_ctx 24 * +------------------------ 25 * | consts (block size * 2) 26 * +------------------------ 27 */ 28 struct xcbc_tfm_ctx { 29 struct crypto_cipher *child; 30 u8 consts[]; 31 }; 32 33 /* 34 * +------------------------ 35 * | <shash desc> 36 * +------------------------ 37 * | xcbc_desc_ctx 38 * +------------------------ 39 * | odds (block size) 40 * +------------------------ 41 * | prev (block size) 42 * +------------------------ 43 */ 44 struct xcbc_desc_ctx { 45 unsigned int len; 46 u8 odds[]; 47 }; 48 49 #define XCBC_BLOCKSIZE 16 50 51 static int crypto_xcbc_digest_setkey(struct crypto_shash *parent, 52 const u8 *inkey, unsigned int keylen) 53 { 54 struct xcbc_tfm_ctx *ctx = crypto_shash_ctx(parent); 55 u8 *consts = ctx->consts; 56 int err = 0; 57 u8 key1[XCBC_BLOCKSIZE]; 58 int bs = sizeof(key1); 59 60 if ((err = crypto_cipher_setkey(ctx->child, inkey, keylen))) 61 return err; 62 63 crypto_cipher_encrypt_one(ctx->child, consts, (u8 *)ks + bs); 64 crypto_cipher_encrypt_one(ctx->child, consts + bs, (u8 *)ks + bs * 2); 65 crypto_cipher_encrypt_one(ctx->child, key1, (u8 *)ks); 66 67 return crypto_cipher_setkey(ctx->child, key1, bs); 68 69 } 70 71 static int crypto_xcbc_digest_init(struct shash_desc *pdesc) 72 { 73 struct xcbc_desc_ctx *ctx = shash_desc_ctx(pdesc); 74 int bs = crypto_shash_blocksize(pdesc->tfm); 75 u8 *prev = &ctx->odds[bs]; 76 77 ctx->len = 0; 78 memset(prev, 0, bs); 79 80 return 0; 81 } 82 83 static int crypto_xcbc_digest_update(struct shash_desc *pdesc, const u8 *p, 84 unsigned int len) 85 { 86 struct crypto_shash *parent = pdesc->tfm; 87 struct xcbc_tfm_ctx *tctx = crypto_shash_ctx(parent); 88 struct xcbc_desc_ctx *ctx = shash_desc_ctx(pdesc); 89 struct crypto_cipher *tfm = tctx->child; 90 int bs = crypto_shash_blocksize(parent); 91 u8 *odds = ctx->odds; 92 u8 *prev = odds + bs; 93 94 /* checking the data can fill the block */ 95 if ((ctx->len + len) <= bs) { 96 memcpy(odds + ctx->len, p, len); 97 ctx->len += len; 98 return 0; 99 } 100 101 /* filling odds with new data and encrypting it */ 102 memcpy(odds + ctx->len, p, bs - ctx->len); 103 len -= bs - ctx->len; 104 p += bs - ctx->len; 105 106 crypto_xor(prev, odds, bs); 107 crypto_cipher_encrypt_one(tfm, prev, prev); 108 109 /* clearing the length */ 110 ctx->len = 0; 111 112 /* encrypting the rest of data */ 113 while (len > bs) { 114 crypto_xor(prev, p, bs); 115 crypto_cipher_encrypt_one(tfm, prev, prev); 116 p += bs; 117 len -= bs; 118 } 119 120 /* keeping the surplus of blocksize */ 121 if (len) { 122 memcpy(odds, p, len); 123 ctx->len = len; 124 } 125 126 return 0; 127 } 128 129 static int crypto_xcbc_digest_final(struct shash_desc *pdesc, u8 *out) 130 { 131 struct crypto_shash *parent = pdesc->tfm; 132 struct xcbc_tfm_ctx *tctx = crypto_shash_ctx(parent); 133 struct xcbc_desc_ctx *ctx = shash_desc_ctx(pdesc); 134 struct crypto_cipher *tfm = tctx->child; 135 int bs = crypto_shash_blocksize(parent); 136 u8 *odds = ctx->odds; 137 u8 *prev = odds + bs; 138 unsigned int offset = 0; 139 140 if (ctx->len != bs) { 141 unsigned int rlen; 142 u8 *p = odds + ctx->len; 143 144 *p = 0x80; 145 p++; 146 147 rlen = bs - ctx->len -1; 148 if (rlen) 149 memset(p, 0, rlen); 150 151 offset += bs; 152 } 153 154 crypto_xor(prev, odds, bs); 155 crypto_xor(prev, &tctx->consts[offset], bs); 156 157 crypto_cipher_encrypt_one(tfm, out, prev); 158 159 return 0; 160 } 161 162 static int xcbc_init_tfm(struct crypto_tfm *tfm) 163 { 164 struct crypto_cipher *cipher; 165 struct crypto_instance *inst = (void *)tfm->__crt_alg; 166 struct crypto_cipher_spawn *spawn = crypto_instance_ctx(inst); 167 struct xcbc_tfm_ctx *ctx = crypto_tfm_ctx(tfm); 168 169 cipher = crypto_spawn_cipher(spawn); 170 if (IS_ERR(cipher)) 171 return PTR_ERR(cipher); 172 173 ctx->child = cipher; 174 175 return 0; 176 }; 177 178 static void xcbc_exit_tfm(struct crypto_tfm *tfm) 179 { 180 struct xcbc_tfm_ctx *ctx = crypto_tfm_ctx(tfm); 181 crypto_free_cipher(ctx->child); 182 } 183 184 static int xcbc_create(struct crypto_template *tmpl, struct rtattr **tb) 185 { 186 struct shash_instance *inst; 187 struct crypto_cipher_spawn *spawn; 188 struct crypto_alg *alg; 189 u32 mask; 190 int err; 191 192 err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SHASH, &mask); 193 if (err) 194 return err; 195 196 inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL); 197 if (!inst) 198 return -ENOMEM; 199 spawn = shash_instance_ctx(inst); 200 201 err = crypto_grab_cipher(spawn, shash_crypto_instance(inst), 202 crypto_attr_alg_name(tb[1]), 0, mask); 203 if (err) 204 goto err_free_inst; 205 alg = crypto_spawn_cipher_alg(spawn); 206 207 err = -EINVAL; 208 if (alg->cra_blocksize != XCBC_BLOCKSIZE) 209 goto err_free_inst; 210 211 err = crypto_inst_setname(shash_crypto_instance(inst), tmpl->name, alg); 212 if (err) 213 goto err_free_inst; 214 215 inst->alg.base.cra_priority = alg->cra_priority; 216 inst->alg.base.cra_blocksize = alg->cra_blocksize; 217 inst->alg.base.cra_ctxsize = sizeof(struct xcbc_tfm_ctx) + 218 alg->cra_blocksize * 2; 219 220 inst->alg.digestsize = alg->cra_blocksize; 221 inst->alg.descsize = sizeof(struct xcbc_desc_ctx) + 222 alg->cra_blocksize * 2; 223 224 inst->alg.base.cra_init = xcbc_init_tfm; 225 inst->alg.base.cra_exit = xcbc_exit_tfm; 226 227 inst->alg.init = crypto_xcbc_digest_init; 228 inst->alg.update = crypto_xcbc_digest_update; 229 inst->alg.final = crypto_xcbc_digest_final; 230 inst->alg.setkey = crypto_xcbc_digest_setkey; 231 232 inst->free = shash_free_singlespawn_instance; 233 234 err = shash_register_instance(tmpl, inst); 235 if (err) { 236 err_free_inst: 237 shash_free_singlespawn_instance(inst); 238 } 239 return err; 240 } 241 242 static struct crypto_template crypto_xcbc_tmpl = { 243 .name = "xcbc", 244 .create = xcbc_create, 245 .module = THIS_MODULE, 246 }; 247 248 static int __init crypto_xcbc_module_init(void) 249 { 250 return crypto_register_template(&crypto_xcbc_tmpl); 251 } 252 253 static void __exit crypto_xcbc_module_exit(void) 254 { 255 crypto_unregister_template(&crypto_xcbc_tmpl); 256 } 257 258 subsys_initcall(crypto_xcbc_module_init); 259 module_exit(crypto_xcbc_module_exit); 260 261 MODULE_LICENSE("GPL"); 262 MODULE_DESCRIPTION("XCBC keyed hash algorithm"); 263 MODULE_ALIAS_CRYPTO("xcbc"); 264 MODULE_IMPORT_NS(CRYPTO_INTERNAL); 265