libcfs/libcfs/linux/linux-crypto-adler.c

   1 /* GPL HEADER START
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 only,
   7  * as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License version 2 for more details (a copy is included
  13  * in the LICENSE file that accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * version 2 along with this program; If not, see http://www.gnu.org/licenses
  17  *
  18  * Please  visit http://www.xyratex.com/contact if you need additional
  19  * information or have any questions.
  20  *
  21  * GPL HEADER END
  22  */
  23
  24 /*
  25  * Copyright 2012 Xyratex Technology Limited
  26  */
  27
  28 /*
  29  * This is crypto api shash wrappers to zlib_adler32.
  30  */
  31
  32 #include <linux/module.h>
  33 #include <linux/zutil.h>
  34 #include <libcfs/linux/linux-crypto.h>
  35 #include <crypto/internal/hash.h>
  36
  37
  38 #define CHKSUM_BLOCK_SIZE       1
  39 #define CHKSUM_DIGEST_SIZE      4
  40
  41
  42 static u32 __adler32(u32 cksum, unsigned char const *p, size_t len)
  43 {
  44         return zlib_adler32(cksum, p, len);
  45 }
  46
  47 static int adler32_cra_init(struct crypto_tfm *tfm)
  48 {
  49         u32 *key = crypto_tfm_ctx(tfm);
  50
  51         *key = 1;
  52
  53         return 0;
  54 }
  55
  56 static int adler32_setkey(struct crypto_shash *hash, const u8 *key,
  57                           unsigned int keylen)
  58 {
  59         u32 *mctx = crypto_shash_ctx(hash);
  60
  61         if (keylen != sizeof(u32)) {
  62                 crypto_shash_set_flags(hash, CRYPTO_TFM_RES_BAD_KEY_LEN);
  63                 return -EINVAL;
  64         }
  65         *mctx = *(u32 *)key;
  66         return 0;
  67 }
  68
  69 static int adler32_init(struct shash_desc *desc)
  70 {
  71         u32 *mctx = crypto_shash_ctx(desc->tfm);
  72         u32 *cksump = shash_desc_ctx(desc);
  73
  74         *cksump = *mctx;
  75
  76         return 0;
  77 }
  78
  79 static int adler32_update(struct shash_desc *desc, const u8 *data,
  80                           unsigned int len)
  81 {
  82         u32 *cksump = shash_desc_ctx(desc);
  83
  84         *cksump = __adler32(*cksump, data, len);
  85         return 0;
  86 }
  87 static int __adler32_finup(u32 *cksump, const u8 *data, unsigned int len,
  88                            u8 *out)
  89 {
  90         *(u32 *)out = __adler32(*cksump, data, len);
  91         return 0;
  92 }
  93
  94 static int adler32_finup(struct shash_desc *desc, const u8 *data,
  95                          unsigned int len, u8 *out)
  96 {
  97         return __adler32_finup(shash_desc_ctx(desc), data, len, out);
  98 }
  99
 100 static int adler32_final(struct shash_desc *desc, u8 *out)
 101 {
 102         u32 *cksump = shash_desc_ctx(desc);
 103
 104         *(u32 *)out = *cksump;
 105         return 0;
 106 }
 107
 108 static int adler32_digest(struct shash_desc *desc, const u8 *data,
 109                           unsigned int len, u8 *out)
 110 {
 111         return __adler32_finup(crypto_shash_ctx(desc->tfm), data, len,
 112                                     out);
 113 }
 114 static struct shash_alg alg = {
 115         .setkey         = adler32_setkey,
 116         .init           = adler32_init,
 117         .update         = adler32_update,
 118         .final          = adler32_final,
 119         .finup          = adler32_finup,
 120         .digest         = adler32_digest,
 121         .descsize       = sizeof(u32),
 122         .digestsize     = CHKSUM_DIGEST_SIZE,
 123         .base           = {
 124                 .cra_name               = "adler32",
 125                 .cra_driver_name        = "adler32-zlib",
 126                 .cra_priority           = 100,
 127                 .cra_blocksize          = CHKSUM_BLOCK_SIZE,
 128                 .cra_ctxsize            = sizeof(u32),
 129                 .cra_module             = THIS_MODULE,
 130                 .cra_init               = adler32_cra_init,
 131         }
 132 };
 133
 134 int cfs_crypto_adler32_register(void)
 135 {
 136         return crypto_register_shash(&alg);
 137 }
 138 EXPORT_SYMBOL(cfs_crypto_adler32_register);
 139
 140 void cfs_crypto_adler32_unregister(void)
 141 {
 142         crypto_unregister_shash(&alg);
 143 }
 144 EXPORT_SYMBOL(cfs_crypto_adler32_unregister);