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