crypto/api.c

   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 #include <linux/init.h>
  17 #include <linux/crypto.h>
  18 #include <linux/errno.h>
  19 #include <linux/rwsem.h>
  20 #include <linux/slab.h>
  21 #include "internal.h"
  22
  23 LIST_HEAD(crypto_alg_list);
  24 DECLARE_RWSEM(crypto_alg_sem);
  25
  26 static inline int crypto_alg_get(struct crypto_alg *alg)
  27 {
  28         return try_module_get(alg->cra_module);
  29 }
  30
  31 static inline void crypto_alg_put(struct crypto_alg *alg)
  32 {
  33         module_put(alg->cra_module);
  34 }
  35
  36 struct crypto_alg *crypto_alg_lookup(const char *name)
  37 {
  38         struct crypto_alg *q, *alg = NULL;
  39
  40         down_read(&crypto_alg_sem);
  41
  42         list_for_each_entry(q, &crypto_alg_list, cra_list) {
  43                 if (!(strcmp(q->cra_name, name))) {
  44                         if (crypto_alg_get(q))
  45                                 alg = q;
  46                         break;
  47                 }
  48         }
  49
  50         up_read(&crypto_alg_sem);
  51         return alg;
  52 }
  53
  54 static int crypto_init_flags(struct crypto_tfm *tfm, u32 flags)
  55 {
  56         tfm->crt_flags = 0;
  57
  58         switch (crypto_tfm_alg_type(tfm)) {
  59         case CRYPTO_ALG_TYPE_CIPHER:
  60                 return crypto_init_cipher_flags(tfm, flags);
  61
  62         case CRYPTO_ALG_TYPE_DIGEST:
  63                 return crypto_init_digest_flags(tfm, flags);
  64
  65         case CRYPTO_ALG_TYPE_COMPRESS:
  66                 return crypto_init_compress_flags(tfm, flags);
  67
  68         default:
  69                 break;
  70         }
  71
  72         BUG();
  73         return -EINVAL;
  74 }
  75
  76 static int crypto_init_ops(struct crypto_tfm *tfm)
  77 {
  78         switch (crypto_tfm_alg_type(tfm)) {
  79         case CRYPTO_ALG_TYPE_CIPHER:
  80                 return crypto_init_cipher_ops(tfm);
  81
  82         case CRYPTO_ALG_TYPE_DIGEST:
  83                 return crypto_init_digest_ops(tfm);
  84
  85         case CRYPTO_ALG_TYPE_COMPRESS:
  86                 return crypto_init_compress_ops(tfm);
  87
  88         default:
  89                 break;
  90         }
  91
  92         BUG();
  93         return -EINVAL;
  94 }
  95
  96 static void crypto_exit_ops(struct crypto_tfm *tfm)
  97 {
  98         switch (crypto_tfm_alg_type(tfm)) {
  99         case CRYPTO_ALG_TYPE_CIPHER:
 100                 crypto_exit_cipher_ops(tfm);
 101                 break;
 102
 103         case CRYPTO_ALG_TYPE_DIGEST:
 104                 crypto_exit_digest_ops(tfm);
 105                 break;
 106
 107         case CRYPTO_ALG_TYPE_COMPRESS:
 108                 crypto_exit_compress_ops(tfm);
 109                 break;
 110
 111         default:
 112                 BUG();
 113
 114         }
 115 }
 116
 117 struct crypto_tfm *crypto_alloc_tfm(const char *name, u32 flags)
 118 {
 119         struct crypto_tfm *tfm = NULL;
 120         struct crypto_alg *alg;
 121
 122         alg = crypto_alg_mod_lookup(name);
 123         if (alg == NULL)
 124                 goto out;
 125
 126         tfm = kmalloc(sizeof(*tfm) + alg->cra_ctxsize, GFP_KERNEL);
 127         if (tfm == NULL)
 128                 goto out_put;
 129
 130         memset(tfm, 0, sizeof(*tfm) + alg->cra_ctxsize);
 131
 132         tfm->__crt_alg = alg;
 133
 134         if (crypto_init_flags(tfm, flags))
 135                 goto out_free_tfm;
 136
 137         if (crypto_init_ops(tfm)) {
 138                 crypto_exit_ops(tfm);
 139                 goto out_free_tfm;
 140         }
 141
 142         goto out;
 143
 144 out_free_tfm:
 145         kfree(tfm);
 146         tfm = NULL;
 147 out_put:
 148         crypto_alg_put(alg);
 149 out:
 150         return tfm;
 151 }
 152
 153 void crypto_free_tfm(struct crypto_tfm *tfm)
 154 {
 155         crypto_exit_ops(tfm);
 156         crypto_alg_put(tfm->__crt_alg);
 157         kfree(tfm);
 158 }
 159
 160 int crypto_register_alg(struct crypto_alg *alg)
 161 {
 162         int ret = 0;
 163         struct crypto_alg *q;
 164
 165         down_write(&crypto_alg_sem);
 166
 167         list_for_each_entry(q, &crypto_alg_list, cra_list) {
 168                 if (!(strcmp(q->cra_name, alg->cra_name))) {
 169                         ret = -EEXIST;
 170                         goto out;
 171                 }
 172         }
 173
 174         list_add_tail(&alg->cra_list, &crypto_alg_list);
 175 out:
 176         up_write(&crypto_alg_sem);
 177         return ret;
 178 }
 179
 180 int crypto_unregister_alg(struct crypto_alg *alg)
 181 {
 182         int ret = -ENOENT;
 183         struct crypto_alg *q;
 184
 185         BUG_ON(!alg->cra_module);
 186
 187         down_write(&crypto_alg_sem);
 188         list_for_each_entry(q, &crypto_alg_list, cra_list) {
 189                 if (alg == q) {
 190                         list_del(&alg->cra_list);
 191                         ret = 0;
 192                         goto out;
 193                 }
 194         }
 195 out:
 196         up_write(&crypto_alg_sem);
 197         return ret;
 198 }
 199
 200 int crypto_alg_available(const char *name, u32 flags)
 201 {
 202         int ret = 0;
 203         struct crypto_alg *alg = crypto_alg_mod_lookup(name);
 204
 205         if (alg) {
 206                 crypto_alg_put(alg);
 207                 ret = 1;
 208         }
 209
 210         return ret;
 211 }
 212
 213 static int __init init_crypto(void)
 214 {
 215         printk(KERN_INFO "Initializing Cryptographic API\n");
 216         crypto_init_proc();
 217         return 0;
 218 }
 219
 220 __initcall(init_crypto);
 221
 222 EXPORT_SYMBOL_GPL(crypto_register_alg);
 223 EXPORT_SYMBOL_GPL(crypto_unregister_alg);
 224 EXPORT_SYMBOL_GPL(crypto_alloc_tfm);
 225 EXPORT_SYMBOL_GPL(crypto_free_tfm);
 226 EXPORT_SYMBOL_GPL(crypto_alg_available);