1 /* 2 * Symmetric key ciphers. 3 * 4 * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au> 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License as published by the Free 8 * Software Foundation; either version 2 of the License, or (at your option) 9 * any later version. 10 * 11 */ 12 13 #ifndef _CRYPTO_INTERNAL_SKCIPHER_H 14 #define _CRYPTO_INTERNAL_SKCIPHER_H 15 16 #include <crypto/algapi.h> 17 #include <crypto/skcipher.h> 18 #include <linux/types.h> 19 20 struct rtattr; 21 22 struct skcipher_instance { 23 void (*free)(struct skcipher_instance *inst); 24 union { 25 struct { 26 char head[offsetof(struct skcipher_alg, base)]; 27 struct crypto_instance base; 28 } s; 29 struct skcipher_alg alg; 30 }; 31 }; 32 33 struct crypto_skcipher_spawn { 34 struct crypto_spawn base; 35 }; 36 37 extern const struct crypto_type crypto_givcipher_type; 38 39 static inline struct crypto_instance *skcipher_crypto_instance( 40 struct skcipher_instance *inst) 41 { 42 return &inst->s.base; 43 } 44 45 static inline struct skcipher_instance *skcipher_alg_instance( 46 struct crypto_skcipher *skcipher) 47 { 48 return container_of(crypto_skcipher_alg(skcipher), 49 struct skcipher_instance, alg); 50 } 51 52 static inline void *skcipher_instance_ctx(struct skcipher_instance *inst) 53 { 54 return crypto_instance_ctx(skcipher_crypto_instance(inst)); 55 } 56 57 static inline void skcipher_request_complete(struct skcipher_request *req, int err) 58 { 59 req->base.complete(&req->base, err); 60 } 61 62 static inline void crypto_set_skcipher_spawn( 63 struct crypto_skcipher_spawn *spawn, struct crypto_instance *inst) 64 { 65 crypto_set_spawn(&spawn->base, inst); 66 } 67 68 int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn, const char *name, 69 u32 type, u32 mask); 70 71 static inline int crypto_grab_skcipher2(struct crypto_skcipher_spawn *spawn, 72 const char *name, u32 type, u32 mask) 73 { 74 return crypto_grab_skcipher(spawn, name, type, mask); 75 } 76 77 struct crypto_alg *crypto_lookup_skcipher(const char *name, u32 type, u32 mask); 78 79 static inline void crypto_drop_skcipher(struct crypto_skcipher_spawn *spawn) 80 { 81 crypto_drop_spawn(&spawn->base); 82 } 83 84 static inline struct skcipher_alg *crypto_skcipher_spawn_alg( 85 struct crypto_skcipher_spawn *spawn) 86 { 87 return container_of(spawn->base.alg, struct skcipher_alg, base); 88 } 89 90 static inline struct skcipher_alg *crypto_spawn_skcipher_alg( 91 struct crypto_skcipher_spawn *spawn) 92 { 93 return crypto_skcipher_spawn_alg(spawn); 94 } 95 96 static inline struct crypto_skcipher *crypto_spawn_skcipher( 97 struct crypto_skcipher_spawn *spawn) 98 { 99 return crypto_spawn_tfm2(&spawn->base); 100 } 101 102 static inline struct crypto_skcipher *crypto_spawn_skcipher2( 103 struct crypto_skcipher_spawn *spawn) 104 { 105 return crypto_spawn_skcipher(spawn); 106 } 107 108 static inline void crypto_skcipher_set_reqsize( 109 struct crypto_skcipher *skcipher, unsigned int reqsize) 110 { 111 skcipher->reqsize = reqsize; 112 } 113 114 int crypto_register_skcipher(struct skcipher_alg *alg); 115 void crypto_unregister_skcipher(struct skcipher_alg *alg); 116 int crypto_register_skciphers(struct skcipher_alg *algs, int count); 117 void crypto_unregister_skciphers(struct skcipher_alg *algs, int count); 118 int skcipher_register_instance(struct crypto_template *tmpl, 119 struct skcipher_instance *inst); 120 121 static inline void ablkcipher_request_complete(struct ablkcipher_request *req, 122 int err) 123 { 124 req->base.complete(&req->base, err); 125 } 126 127 static inline u32 ablkcipher_request_flags(struct ablkcipher_request *req) 128 { 129 return req->base.flags; 130 } 131 132 static inline void *crypto_skcipher_ctx(struct crypto_skcipher *tfm) 133 { 134 return crypto_tfm_ctx(&tfm->base); 135 } 136 137 static inline void *skcipher_request_ctx(struct skcipher_request *req) 138 { 139 return req->__ctx; 140 } 141 142 static inline u32 skcipher_request_flags(struct skcipher_request *req) 143 { 144 return req->base.flags; 145 } 146 147 static inline unsigned int crypto_skcipher_alg_min_keysize( 148 struct skcipher_alg *alg) 149 { 150 if ((alg->base.cra_flags & CRYPTO_ALG_TYPE_MASK) == 151 CRYPTO_ALG_TYPE_BLKCIPHER) 152 return alg->base.cra_blkcipher.min_keysize; 153 154 if (alg->base.cra_ablkcipher.encrypt) 155 return alg->base.cra_ablkcipher.min_keysize; 156 157 return alg->min_keysize; 158 } 159 160 static inline unsigned int crypto_skcipher_alg_max_keysize( 161 struct skcipher_alg *alg) 162 { 163 if ((alg->base.cra_flags & CRYPTO_ALG_TYPE_MASK) == 164 CRYPTO_ALG_TYPE_BLKCIPHER) 165 return alg->base.cra_blkcipher.max_keysize; 166 167 if (alg->base.cra_ablkcipher.encrypt) 168 return alg->base.cra_ablkcipher.max_keysize; 169 170 return alg->max_keysize; 171 } 172 173 #endif /* _CRYPTO_INTERNAL_SKCIPHER_H */ 174 175