1 /* 2 * Scatterlist Cryptographic API. 3 * 4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> 5 * Copyright (c) 2002 David S. Miller (davem@redhat.com) 6 * 7 * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no> 8 * and Nettle, by Niels M�ller. 9 * 10 * This program is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License as published by the Free 12 * Software Foundation; either version 2 of the License, or (at your option) 13 * any later version. 14 * 15 */ 16 17 #include <linux/compiler.h> 18 #include <linux/init.h> 19 #include <linux/crypto.h> 20 #include <linux/errno.h> 21 #include <linux/kmod.h> 22 #include <linux/rwsem.h> 23 #include <linux/slab.h> 24 #include "internal.h" 25 26 LIST_HEAD(crypto_alg_list); 27 DECLARE_RWSEM(crypto_alg_sem); 28 29 static inline int crypto_alg_get(struct crypto_alg *alg) 30 { 31 return try_module_get(alg->cra_module); 32 } 33 34 static inline void crypto_alg_put(struct crypto_alg *alg) 35 { 36 module_put(alg->cra_module); 37 } 38 39 static struct crypto_alg *crypto_alg_lookup(const char *name) 40 { 41 struct crypto_alg *q, *alg = NULL; 42 43 if (!name) 44 return NULL; 45 46 down_read(&crypto_alg_sem); 47 48 list_for_each_entry(q, &crypto_alg_list, cra_list) { 49 if (!(strcmp(q->cra_name, name))) { 50 if (crypto_alg_get(q)) 51 alg = q; 52 break; 53 } 54 } 55 56 up_read(&crypto_alg_sem); 57 return alg; 58 } 59 60 /* A far more intelligent version of this is planned. For now, just 61 * try an exact match on the name of the algorithm. */ 62 static inline struct crypto_alg *crypto_alg_mod_lookup(const char *name) 63 { 64 return try_then_request_module(crypto_alg_lookup(name), name); 65 } 66 67 static int crypto_init_flags(struct crypto_tfm *tfm, u32 flags) 68 { 69 tfm->crt_flags = flags & CRYPTO_TFM_REQ_MASK; 70 flags &= ~CRYPTO_TFM_REQ_MASK; 71 72 switch (crypto_tfm_alg_type(tfm)) { 73 case CRYPTO_ALG_TYPE_CIPHER: 74 return crypto_init_cipher_flags(tfm, flags); 75 76 case CRYPTO_ALG_TYPE_DIGEST: 77 return crypto_init_digest_flags(tfm, flags); 78 79 case CRYPTO_ALG_TYPE_COMPRESS: 80 return crypto_init_compress_flags(tfm, flags); 81 82 default: 83 break; 84 } 85 86 BUG(); 87 return -EINVAL; 88 } 89 90 static int crypto_init_ops(struct crypto_tfm *tfm) 91 { 92 switch (crypto_tfm_alg_type(tfm)) { 93 case CRYPTO_ALG_TYPE_CIPHER: 94 return crypto_init_cipher_ops(tfm); 95 96 case CRYPTO_ALG_TYPE_DIGEST: 97 return crypto_init_digest_ops(tfm); 98 99 case CRYPTO_ALG_TYPE_COMPRESS: 100 return crypto_init_compress_ops(tfm); 101 102 default: 103 break; 104 } 105 106 BUG(); 107 return -EINVAL; 108 } 109 110 static void crypto_exit_ops(struct crypto_tfm *tfm) 111 { 112 switch (crypto_tfm_alg_type(tfm)) { 113 case CRYPTO_ALG_TYPE_CIPHER: 114 crypto_exit_cipher_ops(tfm); 115 break; 116 117 case CRYPTO_ALG_TYPE_DIGEST: 118 crypto_exit_digest_ops(tfm); 119 break; 120 121 case CRYPTO_ALG_TYPE_COMPRESS: 122 crypto_exit_compress_ops(tfm); 123 break; 124 125 default: 126 BUG(); 127 128 } 129 } 130 131 static unsigned int crypto_ctxsize(struct crypto_alg *alg, int flags) 132 { 133 unsigned int len; 134 135 switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) { 136 default: 137 BUG(); 138 139 case CRYPTO_ALG_TYPE_CIPHER: 140 len = crypto_cipher_ctxsize(alg, flags); 141 break; 142 143 case CRYPTO_ALG_TYPE_DIGEST: 144 len = crypto_digest_ctxsize(alg, flags); 145 break; 146 147 case CRYPTO_ALG_TYPE_COMPRESS: 148 len = crypto_compress_ctxsize(alg, flags); 149 break; 150 } 151 152 return len + alg->cra_alignmask; 153 } 154 155 struct crypto_tfm *crypto_alloc_tfm(const char *name, u32 flags) 156 { 157 struct crypto_tfm *tfm = NULL; 158 struct crypto_alg *alg; 159 unsigned int tfm_size; 160 161 alg = crypto_alg_mod_lookup(name); 162 if (alg == NULL) 163 goto out; 164 165 tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, flags); 166 tfm = kmalloc(tfm_size, GFP_KERNEL); 167 if (tfm == NULL) 168 goto out_put; 169 170 memset(tfm, 0, tfm_size); 171 172 tfm->__crt_alg = alg; 173 174 if (crypto_init_flags(tfm, flags)) 175 goto out_free_tfm; 176 177 if (crypto_init_ops(tfm)) { 178 crypto_exit_ops(tfm); 179 goto out_free_tfm; 180 } 181 182 goto out; 183 184 out_free_tfm: 185 kfree(tfm); 186 tfm = NULL; 187 out_put: 188 crypto_alg_put(alg); 189 out: 190 return tfm; 191 } 192 193 void crypto_free_tfm(struct crypto_tfm *tfm) 194 { 195 struct crypto_alg *alg; 196 int size; 197 198 if (unlikely(!tfm)) 199 return; 200 201 alg = tfm->__crt_alg; 202 size = sizeof(*tfm) + alg->cra_ctxsize; 203 204 crypto_exit_ops(tfm); 205 crypto_alg_put(alg); 206 memset(tfm, 0, size); 207 kfree(tfm); 208 } 209 210 int crypto_register_alg(struct crypto_alg *alg) 211 { 212 int ret = 0; 213 struct crypto_alg *q; 214 215 if (alg->cra_alignmask & (alg->cra_alignmask + 1)) 216 return -EINVAL; 217 218 if (alg->cra_alignmask > PAGE_SIZE) 219 return -EINVAL; 220 221 down_write(&crypto_alg_sem); 222 223 list_for_each_entry(q, &crypto_alg_list, cra_list) { 224 if (!(strcmp(q->cra_name, alg->cra_name))) { 225 ret = -EEXIST; 226 goto out; 227 } 228 } 229 230 list_add_tail(&alg->cra_list, &crypto_alg_list); 231 out: 232 up_write(&crypto_alg_sem); 233 return ret; 234 } 235 236 int crypto_unregister_alg(struct crypto_alg *alg) 237 { 238 int ret = -ENOENT; 239 struct crypto_alg *q; 240 241 BUG_ON(!alg->cra_module); 242 243 down_write(&crypto_alg_sem); 244 list_for_each_entry(q, &crypto_alg_list, cra_list) { 245 if (alg == q) { 246 list_del(&alg->cra_list); 247 ret = 0; 248 goto out; 249 } 250 } 251 out: 252 up_write(&crypto_alg_sem); 253 return ret; 254 } 255 256 int crypto_alg_available(const char *name, u32 flags) 257 { 258 int ret = 0; 259 struct crypto_alg *alg = crypto_alg_mod_lookup(name); 260 261 if (alg) { 262 crypto_alg_put(alg); 263 ret = 1; 264 } 265 266 return ret; 267 } 268 269 static int __init init_crypto(void) 270 { 271 printk(KERN_INFO "Initializing Cryptographic API\n"); 272 crypto_init_proc(); 273 return 0; 274 } 275 276 __initcall(init_crypto); 277 278 EXPORT_SYMBOL_GPL(crypto_register_alg); 279 EXPORT_SYMBOL_GPL(crypto_unregister_alg); 280 EXPORT_SYMBOL_GPL(crypto_alloc_tfm); 281 EXPORT_SYMBOL_GPL(crypto_free_tfm); 282 EXPORT_SYMBOL_GPL(crypto_alg_available); 283