libcfs/include/libcfs/libcfs_crypto.h

   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 #ifndef _LIBCFS_CRYPTO_H
  29 #define _LIBCFS_CRYPTO_H
  30
  31 struct cfs_crypto_hash_type {
  32         char            *cht_name;      /**< hash algorithm name, equal to
  33                                          * format name for crypto api */
  34         unsigned int    cht_key;        /**< init key by default (vaild for
  35                                          * 4 bytes context like crc32, adler */
  36         unsigned int    cht_size;       /**< hash digest size */
  37 };
  38
  39 enum cfs_crypto_hash_alg {
  40         CFS_HASH_ALG_NULL       = 0,
  41         CFS_HASH_ALG_ADLER32,
  42         CFS_HASH_ALG_CRC32,
  43         CFS_HASH_ALG_MD5,
  44         CFS_HASH_ALG_SHA1,
  45         CFS_HASH_ALG_SHA256,
  46         CFS_HASH_ALG_SHA384,
  47         CFS_HASH_ALG_SHA512,
  48         CFS_HASH_ALG_CRC32C,
  49         CFS_HASH_ALG_MAX,
  50         CFS_HASH_ALG_UNKNOWN    = 0xff
  51 };
  52
  53 static struct cfs_crypto_hash_type hash_types[] = {
  54         [CFS_HASH_ALG_NULL]     = { "null",      0,      0 },
  55         [CFS_HASH_ALG_ADLER32]  = { "adler32",   1,      4 },
  56         [CFS_HASH_ALG_CRC32]    = { "crc32",    ~0,      4 },
  57         [CFS_HASH_ALG_CRC32C]   = { "crc32c",   ~0,      4 },
  58         [CFS_HASH_ALG_MD5]      = { "md5",       0,     16 },
  59         [CFS_HASH_ALG_SHA1]     = { "sha1",      0,     20 },
  60         [CFS_HASH_ALG_SHA256]   = { "sha256",    0,     32 },
  61         [CFS_HASH_ALG_SHA384]   = { "sha384",    0,     48 },
  62         [CFS_HASH_ALG_SHA512]   = { "sha512",    0,     64 },
  63         [CFS_HASH_ALG_MAX]      = { NULL,        0,     64 },
  64 };
  65
  66 /* Maximum size of hash_types[].cht_size */
  67 #define CFS_CRYPTO_HASH_DIGESTSIZE_MAX 64
  68
  69 /**
  70  * Return hash algorithm information for the specified algorithm identifier
  71  *
  72  * Hash information includes algorithm name, initial seed, hash size.
  73  *
  74  * \retval              cfs_crypto_hash_type for valid ID (CFS_HASH_ALG_*)
  75  * \retval              NULL for unknown algorithm identifier
  76  */
  77 static inline const struct
  78 cfs_crypto_hash_type *cfs_crypto_hash_type(enum cfs_crypto_hash_alg hash_alg)
  79 {
  80         struct cfs_crypto_hash_type *ht;
  81
  82         if (hash_alg < CFS_HASH_ALG_MAX) {
  83                 ht = &hash_types[hash_alg];
  84                 if (ht->cht_name != NULL)
  85                         return ht;
  86         }
  87         return NULL;
  88 }
  89
  90 /**
  91  * Return hash name for hash algorithm identifier
  92  *
  93  * \param[in] hash_alg  hash alrgorithm id (CFS_HASH_ALG_*)
  94  *
  95  * \retval              string name of known hash algorithm
  96  * \retval              "unknown" if hash algorithm is unknown
  97  */
  98 static inline const
  99 char *cfs_crypto_hash_name(enum cfs_crypto_hash_alg hash_alg)
 100 {
 101         const struct cfs_crypto_hash_type *ht;
 102
 103         ht = cfs_crypto_hash_type(hash_alg);
 104         if (ht)
 105                 return ht->cht_name;
 106
 107         return "unknown";
 108 }
 109
 110 /**
 111  * Return digest size for hash algorithm type
 112  *
 113  * \param[in] hash_alg  hash alrgorithm id (CFS_HASH_ALG_*)
 114  *
 115  * \retval              hash algorithm digest size in bytes
 116  * \retval              0 if hash algorithm type is unknown
 117  */
 118 static inline int cfs_crypto_hash_digestsize(enum cfs_crypto_hash_alg hash_alg)
 119 {
 120         const struct cfs_crypto_hash_type *ht;
 121
 122         ht = cfs_crypto_hash_type(hash_alg);
 123         if (ht != NULL)
 124                 return ht->cht_size;
 125
 126         return 0;
 127 }
 128
 129 /**
 130  * Find hash algorithm ID for the specified algorithm name
 131  *
 132  * \retval              hash algorithm ID for valid ID (CFS_HASH_ALG_*)
 133  * \retval              CFS_HASH_ALG_UNKNOWN for unknown algorithm name
 134  */
 135 static inline unsigned char cfs_crypto_hash_alg(const char *algname)
 136 {
 137         enum cfs_crypto_hash_alg hash_alg;
 138
 139         for (hash_alg = 0; hash_alg < CFS_HASH_ALG_MAX; hash_alg++)
 140                 if (strcmp(hash_types[hash_alg].cht_name, algname) == 0)
 141                         return hash_alg;
 142
 143         return CFS_HASH_ALG_UNKNOWN;
 144 }
 145
 146 int cfs_crypto_hash_digest(enum cfs_crypto_hash_alg hash_alg,
 147                            const void *buf, unsigned int buf_len,
 148                            unsigned char *key, unsigned int key_len,
 149                            unsigned char *hash, unsigned int *hash_len);
 150
 151 /* cfs crypto hash descriptor */
 152 struct cfs_crypto_hash_desc;
 153
 154 struct cfs_crypto_hash_desc *
 155         cfs_crypto_hash_init(enum cfs_crypto_hash_alg hash_alg,
 156                              unsigned char *key, unsigned int key_len);
 157 int cfs_crypto_hash_update_page(struct cfs_crypto_hash_desc *desc,
 158                                 struct page *page, unsigned int offset,
 159                                 unsigned int len);
 160 int cfs_crypto_hash_update(struct cfs_crypto_hash_desc *desc, const void *buf,
 161                            unsigned int buf_len);
 162 int cfs_crypto_hash_final(struct cfs_crypto_hash_desc *desc,
 163                           unsigned char *hash, unsigned int *hash_len);
 164 int cfs_crypto_register(void);
 165 void cfs_crypto_unregister(void);
 166 int cfs_crypto_hash_speed(enum cfs_crypto_hash_alg hash_alg);
 167 #endif