drivers/staging/skein/skein_generic.c

   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 <crypto/internal/hash.h>
  20 #include "skein_base.h"
  21
  22
  23 static 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
  29 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
  36 static 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
  42 static 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
  50 static 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
  58 static 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
  64 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
  71 static 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
  77 static 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
  85 static 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
  93 static 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
  99 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
 106 static 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
 112 static 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
 120 static 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
 128 static 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         }
 143 };
 144
 145 static struct shash_alg alg512 = {
 146         .digestsize     =       (SKEIN512_DIGEST_BIT_SIZE / 8),
 147         .init           =       skein512_init,
 148         .update         =       skein512_update,
 149         .final          =       skein512_final,
 150         .export         =       skein512_export,
 151         .import         =       skein512_import,
 152         .descsize       =       sizeof(struct skein_512_ctx),
 153         .statesize      =       sizeof(struct skein_512_ctx),
 154         .base           =       {
 155                 .cra_name               =       "skein512",
 156                 .cra_driver_name        =       "skein",
 157                 .cra_flags              =       CRYPTO_ALG_TYPE_SHASH,
 158                 .cra_blocksize          =       SKEIN_512_BLOCK_BYTES,
 159         }
 160 };
 161
 162 static struct shash_alg alg1024 = {
 163         .digestsize     =       (SKEIN1024_DIGEST_BIT_SIZE / 8),
 164         .init           =       skein1024_init,
 165         .update         =       skein1024_update,
 166         .final          =       skein1024_final,
 167         .export         =       skein1024_export,
 168         .import         =       skein1024_import,
 169         .descsize       =       sizeof(struct skein_1024_ctx),
 170         .statesize      =       sizeof(struct skein_1024_ctx),
 171         .base           =       {
 172                 .cra_name               =       "skein1024",
 173                 .cra_driver_name        =       "skein",
 174                 .cra_flags              =       CRYPTO_ALG_TYPE_SHASH,
 175                 .cra_blocksize          =       SKEIN_1024_BLOCK_BYTES,
 176         }
 177 };
 178
 179 static int __init skein_generic_init(void)
 180 {
 181         if (crypto_register_shash(&alg256))
 182                 goto out;
 183         if (crypto_register_shash(&alg512))
 184                 goto unreg256;
 185         if (crypto_register_shash(&alg1024))
 186                 goto unreg512;
 187
 188         return 0;
 189
 190
 191 unreg512:
 192         crypto_unregister_shash(&alg512);
 193 unreg256:
 194         crypto_unregister_shash(&alg256);
 195 out:
 196         return -1;
 197 }
 198
 199 device_initcall(skein_generic_init);