1/* 2 * Cryptographic API. 3 * 4 * Skein256 Hash Algorithm. 5 * 6 * Derived from cryptoapi implementation, adapted for in-place 7 * scatterlist interface. 8 * 9 * Copyright (c) Eric Rost <eric.rost@mybabylon.net> 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#include <linux/types.h> 18#include <linux/init.h> 19#include <linux/module.h> 20#include <crypto/internal/hash.h> 21#include "skein_base.h" 22 23static int skein256_init(struct shash_desc *desc) 24{ 25 return skein_256_init((struct skein_256_ctx *)shash_desc_ctx(desc), 26 SKEIN256_DIGEST_BIT_SIZE); 27} 28 29static int skein256_update(struct shash_desc *desc, const u8 *data, 30 unsigned int len) 31{ 32 return skein_256_update((struct skein_256_ctx *)shash_desc_ctx(desc), 33 data, len); 34} 35 36static int skein256_final(struct shash_desc *desc, u8 *out) 37{ 38 return skein_256_final((struct skein_256_ctx *)shash_desc_ctx(desc), 39 out); 40} 41 42static int skein256_export(struct shash_desc *desc, void *out) 43{ 44 struct skein_256_ctx *sctx = shash_desc_ctx(desc); 45 46 memcpy(out, sctx, sizeof(*sctx)); 47 return 0; 48} 49 50static int skein256_import(struct shash_desc *desc, const void *in) 51{ 52 struct skein_256_ctx *sctx = shash_desc_ctx(desc); 53 54 memcpy(sctx, in, sizeof(*sctx)); 55 return 0; 56} 57 58static int skein512_init(struct shash_desc *desc) 59{ 60 return skein_512_init((struct skein_512_ctx *)shash_desc_ctx(desc), 61 SKEIN512_DIGEST_BIT_SIZE); 62} 63 64static int skein512_update(struct shash_desc *desc, const u8 *data, 65 unsigned int len) 66{ 67 return skein_512_update((struct skein_512_ctx *)shash_desc_ctx(desc), 68 data, len); 69} 70 71static int skein512_final(struct shash_desc *desc, u8 *out) 72{ 73 return skein_512_final((struct skein_512_ctx *)shash_desc_ctx(desc), 74 out); 75} 76 77static int skein512_export(struct shash_desc *desc, void *out) 78{ 79 struct skein_512_ctx *sctx = shash_desc_ctx(desc); 80 81 memcpy(out, sctx, sizeof(*sctx)); 82 return 0; 83} 84 85static int skein512_import(struct shash_desc *desc, const void *in) 86{ 87 struct skein_512_ctx *sctx = shash_desc_ctx(desc); 88 89 memcpy(sctx, in, sizeof(*sctx)); 90 return 0; 91} 92 93static int skein1024_init(struct shash_desc *desc) 94{ 95 return skein_1024_init((struct skein_1024_ctx *)shash_desc_ctx(desc), 96 SKEIN1024_DIGEST_BIT_SIZE); 97} 98 99static int skein1024_update(struct shash_desc *desc, const u8 *data, 100 unsigned int len) 101{ 102 return skein_1024_update((struct skein_1024_ctx *)shash_desc_ctx(desc), 103 data, len); 104} 105 106static int skein1024_final(struct shash_desc *desc, u8 *out) 107{ 108 return skein_1024_final((struct skein_1024_ctx *)shash_desc_ctx(desc), 109 out); 110} 111 112static int skein1024_export(struct shash_desc *desc, void *out) 113{ 114 struct skein_1024_ctx *sctx = shash_desc_ctx(desc); 115 116 memcpy(out, sctx, sizeof(*sctx)); 117 return 0; 118} 119 120static int skein1024_import(struct shash_desc *desc, const void *in) 121{ 122 struct skein_1024_ctx *sctx = shash_desc_ctx(desc); 123 124 memcpy(sctx, in, sizeof(*sctx)); 125 return 0; 126} 127 128static struct shash_alg alg256 = { 129 .digestsize = (SKEIN256_DIGEST_BIT_SIZE / 8), 130 .init = skein256_init, 131 .update = skein256_update, 132 .final = skein256_final, 133 .export = skein256_export, 134 .import = skein256_import, 135 .descsize = sizeof(struct skein_256_ctx), 136 .statesize = sizeof(struct skein_256_ctx), 137 .base = { 138 .cra_name = "skein256", 139 .cra_driver_name = "skein", 140 .cra_flags = CRYPTO_ALG_TYPE_SHASH, 141 .cra_blocksize = SKEIN_256_BLOCK_BYTES, 142 .cra_module = THIS_MODULE, 143 } 144}; 145 146static struct shash_alg alg512 = { 147 .digestsize = (SKEIN512_DIGEST_BIT_SIZE / 8), 148 .init = skein512_init, 149 .update = skein512_update, 150 .final = skein512_final, 151 .export = skein512_export, 152 .import = skein512_import, 153 .descsize = sizeof(struct skein_512_ctx), 154 .statesize = sizeof(struct skein_512_ctx), 155 .base = { 156 .cra_name = "skein512", 157 .cra_driver_name = "skein", 158 .cra_flags = CRYPTO_ALG_TYPE_SHASH, 159 .cra_blocksize = SKEIN_512_BLOCK_BYTES, 160 .cra_module = THIS_MODULE, 161 } 162}; 163 164static struct shash_alg alg1024 = { 165 .digestsize = (SKEIN1024_DIGEST_BIT_SIZE / 8), 166 .init = skein1024_init, 167 .update = skein1024_update, 168 .final = skein1024_final, 169 .export = skein1024_export, 170 .import = skein1024_import, 171 .descsize = sizeof(struct skein_1024_ctx), 172 .statesize = sizeof(struct skein_1024_ctx), 173 .base = { 174 .cra_name = "skein1024", 175 .cra_driver_name = "skein", 176 .cra_flags = CRYPTO_ALG_TYPE_SHASH, 177 .cra_blocksize = SKEIN_1024_BLOCK_BYTES, 178 .cra_module = THIS_MODULE, 179 } 180}; 181 182static int __init skein_generic_init(void) 183{ 184 if (crypto_register_shash(&alg256)) 185 goto out; 186 if (crypto_register_shash(&alg512)) 187 goto unreg256; 188 if (crypto_register_shash(&alg1024)) 189 goto unreg512; 190 191 return 0; 192 193unreg512: 194 crypto_unregister_shash(&alg512); 195unreg256: 196 crypto_unregister_shash(&alg256); 197out: 198 return -1; 199} 200 201static void __exit skein_generic_fini(void) 202{ 203 crypto_unregister_shash(&alg256); 204 crypto_unregister_shash(&alg512); 205 crypto_unregister_shash(&alg1024); 206} 207 208module_init(skein_generic_init); 209module_exit(skein_generic_fini); 210 211MODULE_LICENSE("GPL"); 212MODULE_DESCRIPTION("Skein Hash Algorithm"); 213 214MODULE_ALIAS("skein"); 215