| /* | |
| * Cryptographic API. | |
| * | |
| * Cipher operations. | |
| * | |
| * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> | |
| * | |
| * 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 <linux/compiler.h> | |
| #include <linux/kernel.h> | |
| #include <linux/crypto.h> | |
| #include <linux/errno.h> | |
| #include <linux/mm.h> | |
| #include <linux/slab.h> | |
| #include <linux/string.h> | |
| #include <asm/scatterlist.h> | |
| #include "internal.h" | |
| #include "scatterwalk.h" | |
| typedef void (cryptfn_t)(void *, u8 *, const u8 *); | |
| typedef void (procfn_t)(struct crypto_tfm *, u8 *, | |
| u8*, cryptfn_t, void *); | |
| static inline void xor_64(u8 *a, const u8 *b) | |
| { | |
| ((u32 *)a)[0] ^= ((u32 *)b)[0]; | |
| ((u32 *)a)[1] ^= ((u32 *)b)[1]; | |
| } | |
| static inline void xor_128(u8 *a, const u8 *b) | |
| { | |
| ((u32 *)a)[0] ^= ((u32 *)b)[0]; | |
| ((u32 *)a)[1] ^= ((u32 *)b)[1]; | |
| ((u32 *)a)[2] ^= ((u32 *)b)[2]; | |
| ((u32 *)a)[3] ^= ((u32 *)b)[3]; | |
| } | |
| static inline void *prepare_src(struct scatter_walk *walk, int bsize, | |
| void *tmp, int in_place) | |
| { | |
| void *src = walk->data; | |
| int n = bsize; | |
| if (unlikely(scatterwalk_across_pages(walk, bsize))) { | |
| src = tmp; | |
| n = scatterwalk_copychunks(src, walk, bsize, 0); | |
| } | |
| scatterwalk_advance(walk, n); | |
| return src; | |
| } | |
| static inline void *prepare_dst(struct scatter_walk *walk, int bsize, | |
| void *tmp, int in_place) | |
| { | |
| void *dst = walk->data; | |
| if (unlikely(scatterwalk_across_pages(walk, bsize)) || in_place) | |
| dst = tmp; | |
| return dst; | |
| } | |
| static inline void complete_src(struct scatter_walk *walk, int bsize, | |
| void *src, int in_place) | |
| { | |
| } | |
| static inline void complete_dst(struct scatter_walk *walk, int bsize, | |
| void *dst, int in_place) | |
| { | |
| int n = bsize; | |
| if (unlikely(scatterwalk_across_pages(walk, bsize))) | |
| n = scatterwalk_copychunks(dst, walk, bsize, 1); | |
| else if (in_place) | |
| memcpy(walk->data, dst, bsize); | |
| scatterwalk_advance(walk, n); | |
| } | |
| /* | |
| * Generic encrypt/decrypt wrapper for ciphers, handles operations across | |
| * multiple page boundaries by using temporary blocks. In user context, | |
| * the kernel is given a chance to schedule us once per block. | |
| */ | |
| static int crypt(struct crypto_tfm *tfm, | |
| struct scatterlist *dst, | |
| struct scatterlist *src, | |
| unsigned int nbytes, cryptfn_t crfn, | |
| procfn_t prfn, void *info) | |
| { | |
| struct scatter_walk walk_in, walk_out; | |
| const unsigned int bsize = crypto_tfm_alg_blocksize(tfm); | |
| u8 tmp_src[bsize]; | |
| u8 tmp_dst[bsize]; | |
| if (!nbytes) | |
| return 0; | |
| if (nbytes % bsize) { | |
| tfm->crt_flags |= CRYPTO_TFM_RES_BAD_BLOCK_LEN; | |
| return -EINVAL; | |
| } | |
| scatterwalk_start(&walk_in, src); | |
| scatterwalk_start(&walk_out, dst); | |
| for(;;) { | |
| u8 *src_p, *dst_p; | |
| int in_place; | |
| scatterwalk_map(&walk_in, 0); | |
| scatterwalk_map(&walk_out, 1); | |
| in_place = scatterwalk_samebuf(&walk_in, &walk_out); | |
| do { | |
| src_p = prepare_src(&walk_in, bsize, tmp_src, | |
| in_place); | |
| dst_p = prepare_dst(&walk_out, bsize, tmp_dst, | |
| in_place); | |
| prfn(tfm, dst_p, src_p, crfn, info); | |
| complete_src(&walk_in, bsize, src_p, in_place); | |
| complete_dst(&walk_out, bsize, dst_p, in_place); | |
| nbytes -= bsize; | |
| } while (nbytes && | |
| !scatterwalk_across_pages(&walk_in, bsize) && | |
| !scatterwalk_across_pages(&walk_out, bsize)); | |
| scatterwalk_done(&walk_in, 0, nbytes); | |
| scatterwalk_done(&walk_out, 1, nbytes); | |
| if (!nbytes) | |
| return 0; | |
| crypto_yield(tfm); | |
| } | |
| } | |
| static void cbc_process_encrypt(struct crypto_tfm *tfm, u8 *dst, u8 *src, | |
| cryptfn_t fn, void *info) | |
| { | |
| u8 *iv = info; | |
| tfm->crt_u.cipher.cit_xor_block(iv, src); | |
| fn(crypto_tfm_ctx(tfm), dst, iv); | |
| memcpy(iv, dst, crypto_tfm_alg_blocksize(tfm)); | |
| } | |
| static void cbc_process_decrypt(struct crypto_tfm *tfm, u8 *dst, u8 *src, | |
| cryptfn_t fn, void *info) | |
| { | |
| u8 *iv = info; | |
| fn(crypto_tfm_ctx(tfm), dst, src); | |
| tfm->crt_u.cipher.cit_xor_block(dst, iv); | |
| memcpy(iv, src, crypto_tfm_alg_blocksize(tfm)); | |
| } | |
| static void ecb_process(struct crypto_tfm *tfm, u8 *dst, u8 *src, | |
| cryptfn_t fn, void *info) | |
| { | |
| fn(crypto_tfm_ctx(tfm), dst, src); | |
| } | |
| static int setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen) | |
| { | |
| struct cipher_alg *cia = &tfm->__crt_alg->cra_cipher; | |
| if (keylen < cia->cia_min_keysize || keylen > cia->cia_max_keysize) { | |
| tfm->crt_flags |= CRYPTO_TFM_RES_BAD_KEY_LEN; | |
| return -EINVAL; | |
| } else | |
| return cia->cia_setkey(crypto_tfm_ctx(tfm), key, keylen, | |
| &tfm->crt_flags); | |
| } | |
| static int ecb_encrypt(struct crypto_tfm *tfm, | |
| struct scatterlist *dst, | |
| struct scatterlist *src, unsigned int nbytes) | |
| { | |
| return crypt(tfm, dst, src, nbytes, | |
| tfm->__crt_alg->cra_cipher.cia_encrypt, | |
| ecb_process, NULL); | |
| } | |
| static int ecb_decrypt(struct crypto_tfm *tfm, | |
| struct scatterlist *dst, | |
| struct scatterlist *src, | |
| unsigned int nbytes) | |
| { | |
| return crypt(tfm, dst, src, nbytes, | |
| tfm->__crt_alg->cra_cipher.cia_decrypt, | |
| ecb_process, NULL); | |
| } | |
| static int cbc_encrypt(struct crypto_tfm *tfm, | |
| struct scatterlist *dst, | |
| struct scatterlist *src, | |
| unsigned int nbytes) | |
| { | |
| return crypt(tfm, dst, src, nbytes, | |
| tfm->__crt_alg->cra_cipher.cia_encrypt, | |
| cbc_process_encrypt, tfm->crt_cipher.cit_iv); | |
| } | |
| static int cbc_encrypt_iv(struct crypto_tfm *tfm, | |
| struct scatterlist *dst, | |
| struct scatterlist *src, | |
| unsigned int nbytes, u8 *iv) | |
| { | |
| return crypt(tfm, dst, src, nbytes, | |
| tfm->__crt_alg->cra_cipher.cia_encrypt, | |
| cbc_process_encrypt, iv); | |
| } | |
| static int cbc_decrypt(struct crypto_tfm *tfm, | |
| struct scatterlist *dst, | |
| struct scatterlist *src, | |
| unsigned int nbytes) | |
| { | |
| return crypt(tfm, dst, src, nbytes, | |
| tfm->__crt_alg->cra_cipher.cia_decrypt, | |
| cbc_process_decrypt, tfm->crt_cipher.cit_iv); | |
| } | |
| static int cbc_decrypt_iv(struct crypto_tfm *tfm, | |
| struct scatterlist *dst, | |
| struct scatterlist *src, | |
| unsigned int nbytes, u8 *iv) | |
| { | |
| return crypt(tfm, dst, src, nbytes, | |
| tfm->__crt_alg->cra_cipher.cia_decrypt, | |
| cbc_process_decrypt, iv); | |
| } | |
| static int nocrypt(struct crypto_tfm *tfm, | |
| struct scatterlist *dst, | |
| struct scatterlist *src, | |
| unsigned int nbytes) | |
| { | |
| return -ENOSYS; | |
| } | |
| static int nocrypt_iv(struct crypto_tfm *tfm, | |
| struct scatterlist *dst, | |
| struct scatterlist *src, | |
| unsigned int nbytes, u8 *iv) | |
| { | |
| return -ENOSYS; | |
| } | |
| int crypto_init_cipher_flags(struct crypto_tfm *tfm, u32 flags) | |
| { | |
| u32 mode = flags & CRYPTO_TFM_MODE_MASK; | |
| tfm->crt_cipher.cit_mode = mode ? mode : CRYPTO_TFM_MODE_ECB; | |
| if (flags & CRYPTO_TFM_REQ_WEAK_KEY) | |
| tfm->crt_flags = CRYPTO_TFM_REQ_WEAK_KEY; | |
| return 0; | |
| } | |
| int crypto_init_cipher_ops(struct crypto_tfm *tfm) | |
| { | |
| int ret = 0; | |
| struct cipher_tfm *ops = &tfm->crt_cipher; | |
| ops->cit_setkey = setkey; | |
| switch (tfm->crt_cipher.cit_mode) { | |
| case CRYPTO_TFM_MODE_ECB: | |
| ops->cit_encrypt = ecb_encrypt; | |
| ops->cit_decrypt = ecb_decrypt; | |
| break; | |
| case CRYPTO_TFM_MODE_CBC: | |
| ops->cit_encrypt = cbc_encrypt; | |
| ops->cit_decrypt = cbc_decrypt; | |
| ops->cit_encrypt_iv = cbc_encrypt_iv; | |
| ops->cit_decrypt_iv = cbc_decrypt_iv; | |
| break; | |
| case CRYPTO_TFM_MODE_CFB: | |
| ops->cit_encrypt = nocrypt; | |
| ops->cit_decrypt = nocrypt; | |
| ops->cit_encrypt_iv = nocrypt_iv; | |
| ops->cit_decrypt_iv = nocrypt_iv; | |
| break; | |
| case CRYPTO_TFM_MODE_CTR: | |
| ops->cit_encrypt = nocrypt; | |
| ops->cit_decrypt = nocrypt; | |
| ops->cit_encrypt_iv = nocrypt_iv; | |
| ops->cit_decrypt_iv = nocrypt_iv; | |
| break; | |
| default: | |
| BUG(); | |
| } | |
| if (ops->cit_mode == CRYPTO_TFM_MODE_CBC) { | |
| switch (crypto_tfm_alg_blocksize(tfm)) { | |
| case 8: | |
| ops->cit_xor_block = xor_64; | |
| break; | |
| case 16: | |
| ops->cit_xor_block = xor_128; | |
| break; | |
| default: | |
| printk(KERN_WARNING "%s: block size %u not supported\n", | |
| crypto_tfm_alg_name(tfm), | |
| crypto_tfm_alg_blocksize(tfm)); | |
| ret = -EINVAL; | |
| goto out; | |
| } | |
| ops->cit_ivsize = crypto_tfm_alg_blocksize(tfm); | |
| ops->cit_iv = kmalloc(ops->cit_ivsize, GFP_KERNEL); | |
| if (ops->cit_iv == NULL) | |
| ret = -ENOMEM; | |
| } | |
| out: | |
| return ret; | |
| } | |
| void crypto_exit_cipher_ops(struct crypto_tfm *tfm) | |
| { | |
| if (tfm->crt_cipher.cit_iv) | |
| kfree(tfm->crt_cipher.cit_iv); | |
| } |