1 /* 2 * Asynchronous Cryptographic Hash operations. 3 * 4 * This is the asynchronous version of hash.c with notification of 5 * completion via a callback. 6 * 7 * Copyright (c) 2008 Loc Ho <lho@amcc.com> 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License as published by the Free 11 * Software Foundation; either version 2 of the License, or (at your option) 12 * any later version. 13 * 14 */ 15 16 #include <crypto/internal/hash.h> 17 #include <crypto/scatterwalk.h> 18 #include <linux/err.h> 19 #include <linux/kernel.h> 20 #include <linux/module.h> 21 #include <linux/sched.h> 22 #include <linux/slab.h> 23 #include <linux/seq_file.h> 24 25 #include "internal.h" 26 27 static int hash_walk_next(struct crypto_hash_walk *walk) 28 { 29 unsigned int alignmask = walk->alignmask; 30 unsigned int offset = walk->offset; 31 unsigned int nbytes = min(walk->entrylen, 32 ((unsigned int)(PAGE_SIZE)) - offset); 33 34 walk->data = crypto_kmap(walk->pg, 0); 35 walk->data += offset; 36 37 if (offset & alignmask) 38 nbytes = alignmask + 1 - (offset & alignmask); 39 40 walk->entrylen -= nbytes; 41 return nbytes; 42 } 43 44 static int hash_walk_new_entry(struct crypto_hash_walk *walk) 45 { 46 struct scatterlist *sg; 47 48 sg = walk->sg; 49 walk->pg = sg_page(sg); 50 walk->offset = sg->offset; 51 walk->entrylen = sg->length; 52 53 if (walk->entrylen > walk->total) 54 walk->entrylen = walk->total; 55 walk->total -= walk->entrylen; 56 57 return hash_walk_next(walk); 58 } 59 60 int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err) 61 { 62 unsigned int alignmask = walk->alignmask; 63 unsigned int nbytes = walk->entrylen; 64 65 walk->data -= walk->offset; 66 67 if (nbytes && walk->offset & alignmask && !err) { 68 walk->offset += alignmask - 1; 69 walk->offset = ALIGN(walk->offset, alignmask + 1); 70 walk->data += walk->offset; 71 72 nbytes = min(nbytes, 73 ((unsigned int)(PAGE_SIZE)) - walk->offset); 74 walk->entrylen -= nbytes; 75 76 return nbytes; 77 } 78 79 crypto_kunmap(walk->data, 0); 80 crypto_yield(walk->flags); 81 82 if (err) 83 return err; 84 85 if (nbytes) { 86 walk->offset = 0; 87 walk->pg++; 88 return hash_walk_next(walk); 89 } 90 91 if (!walk->total) 92 return 0; 93 94 walk->sg = scatterwalk_sg_next(walk->sg); 95 96 return hash_walk_new_entry(walk); 97 } 98 EXPORT_SYMBOL_GPL(crypto_hash_walk_done); 99 100 int crypto_hash_walk_first(struct ahash_request *req, 101 struct crypto_hash_walk *walk) 102 { 103 walk->total = req->nbytes; 104 105 if (!walk->total) 106 return 0; 107 108 walk->alignmask = crypto_ahash_alignmask(crypto_ahash_reqtfm(req)); 109 walk->sg = req->src; 110 walk->flags = req->base.flags; 111 112 return hash_walk_new_entry(walk); 113 } 114 EXPORT_SYMBOL_GPL(crypto_hash_walk_first); 115 116 int crypto_hash_walk_first_compat(struct hash_desc *hdesc, 117 struct crypto_hash_walk *walk, 118 struct scatterlist *sg, unsigned int len) 119 { 120 walk->total = len; 121 122 if (!walk->total) 123 return 0; 124 125 walk->alignmask = crypto_hash_alignmask(hdesc->tfm); 126 walk->sg = sg; 127 walk->flags = hdesc->flags; 128 129 return hash_walk_new_entry(walk); 130 } 131 132 static int ahash_setkey_unaligned(struct crypto_ahash *tfm, const u8 *key, 133 unsigned int keylen) 134 { 135 struct ahash_alg *ahash = crypto_ahash_alg(tfm); 136 unsigned long alignmask = crypto_ahash_alignmask(tfm); 137 int ret; 138 u8 *buffer, *alignbuffer; 139 unsigned long absize; 140 141 absize = keylen + alignmask; 142 buffer = kmalloc(absize, GFP_ATOMIC); 143 if (!buffer) 144 return -ENOMEM; 145 146 alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1); 147 memcpy(alignbuffer, key, keylen); 148 ret = ahash->setkey(tfm, alignbuffer, keylen); 149 memset(alignbuffer, 0, keylen); 150 kfree(buffer); 151 return ret; 152 } 153 154 static int ahash_setkey(struct crypto_ahash *tfm, const u8 *key, 155 unsigned int keylen) 156 { 157 struct ahash_alg *ahash = crypto_ahash_alg(tfm); 158 unsigned long alignmask = crypto_ahash_alignmask(tfm); 159 160 if ((unsigned long)key & alignmask) 161 return ahash_setkey_unaligned(tfm, key, keylen); 162 163 return ahash->setkey(tfm, key, keylen); 164 } 165 166 static int ahash_nosetkey(struct crypto_ahash *tfm, const u8 *key, 167 unsigned int keylen) 168 { 169 return -ENOSYS; 170 } 171 172 int crypto_ahash_import(struct ahash_request *req, const u8 *in) 173 { 174 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 175 struct ahash_alg *alg = crypto_ahash_alg(tfm); 176 177 memcpy(ahash_request_ctx(req), in, crypto_ahash_reqsize(tfm)); 178 179 if (alg->reinit) 180 alg->reinit(req); 181 182 return 0; 183 } 184 EXPORT_SYMBOL_GPL(crypto_ahash_import); 185 186 static unsigned int crypto_ahash_ctxsize(struct crypto_alg *alg, u32 type, 187 u32 mask) 188 { 189 return alg->cra_ctxsize; 190 } 191 192 static int crypto_init_ahash_ops(struct crypto_tfm *tfm, u32 type, u32 mask) 193 { 194 struct ahash_alg *alg = &tfm->__crt_alg->cra_ahash; 195 struct ahash_tfm *crt = &tfm->crt_ahash; 196 197 if (alg->digestsize > PAGE_SIZE / 8) 198 return -EINVAL; 199 200 crt->init = alg->init; 201 crt->update = alg->update; 202 crt->final = alg->final; 203 crt->digest = alg->digest; 204 crt->setkey = alg->setkey ? ahash_setkey : ahash_nosetkey; 205 crt->digestsize = alg->digestsize; 206 207 return 0; 208 } 209 210 static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg) 211 __attribute__ ((unused)); 212 static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg) 213 { 214 seq_printf(m, "type : ahash\n"); 215 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ? 216 "yes" : "no"); 217 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); 218 seq_printf(m, "digestsize : %u\n", alg->cra_ahash.digestsize); 219 } 220 221 const struct crypto_type crypto_ahash_type = { 222 .ctxsize = crypto_ahash_ctxsize, 223 .init = crypto_init_ahash_ops, 224 #ifdef CONFIG_PROC_FS 225 .show = crypto_ahash_show, 226 #endif 227 }; 228 EXPORT_SYMBOL_GPL(crypto_ahash_type); 229 230 MODULE_LICENSE("GPL"); 231 MODULE_DESCRIPTION("Asynchronous cryptographic hash type"); 232