unsigned int cht_size; /**< hash digest size */
};
+struct cfs_crypto_crypt_type {
+ char *cct_name; /**< crypto algorithm name, equal to
+ * format name for crypto api */
+ unsigned int cct_size; /**< crypto key size */
+};
+
enum cfs_crypto_hash_alg {
CFS_HASH_ALG_NULL = 0,
CFS_HASH_ALG_ADLER32,
CFS_HASH_ALG_CRC32,
+ CFS_HASH_ALG_CRC32C,
+ /* hashes before here will be speed-tested at module load */
CFS_HASH_ALG_MD5,
CFS_HASH_ALG_SHA1,
CFS_HASH_ALG_SHA256,
CFS_HASH_ALG_SHA384,
CFS_HASH_ALG_SHA512,
- CFS_HASH_ALG_CRC32C,
CFS_HASH_ALG_MAX,
+ CFS_HASH_ALG_SPEED_MAX = CFS_HASH_ALG_MD5,
CFS_HASH_ALG_UNKNOWN = 0xff
};
+enum cfs_crypto_crypt_alg {
+ CFS_CRYPT_ALG_NULL = 0,
+ CFS_CRYPT_ALG_AES256_CTR,
+ CFS_CRYPT_ALG_MAX,
+ CFS_CRYPT_ALG_UNKNOWN = 0xff
+};
+
static struct cfs_crypto_hash_type hash_types[] = {
- [CFS_HASH_ALG_NULL] = { "null", 0, 0 },
- [CFS_HASH_ALG_ADLER32] = { "adler32", 1, 4 },
- [CFS_HASH_ALG_CRC32] = { "crc32", ~0, 4 },
- [CFS_HASH_ALG_CRC32C] = { "crc32c", ~0, 4 },
- [CFS_HASH_ALG_MD5] = { "md5", 0, 16 },
- [CFS_HASH_ALG_SHA1] = { "sha1", 0, 20 },
- [CFS_HASH_ALG_SHA256] = { "sha256", 0, 32 },
- [CFS_HASH_ALG_SHA384] = { "sha384", 0, 48 },
- [CFS_HASH_ALG_SHA512] = { "sha512", 0, 64 },
- [CFS_HASH_ALG_MAX] = { NULL, 0, 64 },
+ [CFS_HASH_ALG_NULL] = {
+ .cht_name = "null",
+ .cht_key = 0,
+ .cht_size = 0
+ },
+ [CFS_HASH_ALG_ADLER32] = {
+ .cht_name = "adler32",
+ .cht_key = 1,
+ .cht_size = 4
+ },
+ [CFS_HASH_ALG_CRC32] = {
+ .cht_name = "crc32",
+ .cht_key = ~0,
+ .cht_size = 4
+ },
+ [CFS_HASH_ALG_CRC32C] = {
+ .cht_name = "crc32c",
+ .cht_key = ~0,
+ .cht_size = 4
+ },
+ [CFS_HASH_ALG_MD5] = {
+ .cht_name = "md5",
+ .cht_key = 0,
+ .cht_size = 16
+ },
+ [CFS_HASH_ALG_SHA1] = {
+ .cht_name = "sha1",
+ .cht_key = 0,
+ .cht_size = 20
+ },
+ [CFS_HASH_ALG_SHA256] = {
+ .cht_name = "sha256",
+ .cht_key = 0,
+ .cht_size = 32
+ },
+ [CFS_HASH_ALG_SHA384] = {
+ .cht_name = "sha384",
+ .cht_key = 0,
+ .cht_size = 48
+ },
+ [CFS_HASH_ALG_SHA512] = {
+ .cht_name = "sha512",
+ .cht_key = 0,
+ .cht_size = 64
+ },
+ [CFS_HASH_ALG_MAX] = {
+ .cht_name = NULL,
+ .cht_key = 0,
+ .cht_size = 64
+ }
+};
+
+static struct cfs_crypto_crypt_type crypt_types[] = {
+ [CFS_CRYPT_ALG_NULL] = {
+ .cct_name = "null",
+ .cct_size = 0
+ },
+ [CFS_CRYPT_ALG_AES256_CTR] = {
+ .cct_name = "ctr(aes)",
+ .cct_size = 32
+ }
};
/* Maximum size of hash_types[].cht_size */
return CFS_HASH_ALG_UNKNOWN;
}
+/**
+ * Return crypt algorithm information for the specified algorithm identifier
+ *
+ * Crypt information includes algorithm name, key size.
+ *
+ * \retval cfs_crypto_crupt_type for valid ID (CFS_CRYPT_ALG_*)
+ * \retval NULL for unknown algorithm identifier
+ */
+static inline const struct
+cfs_crypto_crypt_type *cfs_crypto_crypt_type(
+ enum cfs_crypto_crypt_alg crypt_alg)
+{
+ struct cfs_crypto_crypt_type *ct;
+
+ if (crypt_alg < CFS_CRYPT_ALG_MAX) {
+ ct = &crypt_types[crypt_alg];
+ if (ct->cct_name != NULL)
+ return ct;
+ }
+ return NULL;
+}
+
+/**
+ * Return crypt name for crypt algorithm identifier
+ *
+ * \param[in] crypt_alg crypt alrgorithm id (CFS_CRYPT_ALG_*)
+ *
+ * \retval string name of known crypt algorithm
+ * \retval "unknown" if hash algorithm is unknown
+ */
+static inline const
+char *cfs_crypto_crypt_name(enum cfs_crypto_crypt_alg crypt_alg)
+{
+ const struct cfs_crypto_crypt_type *ct;
+
+ ct = cfs_crypto_crypt_type(crypt_alg);
+ if (ct)
+ return ct->cct_name;
+
+ return "unknown";
+}
+
+
+/**
+ * Return key size for crypto algorithm type
+ *
+ * \param[in] crypt_alg crypt alrgorithm id (CFS_CRYPT_ALG_*)
+ *
+ * \retval crypt algorithm key size in bytes
+ * \retval 0 if crypt algorithm type is unknown
+ */
+static inline
+unsigned int cfs_crypto_crypt_keysize(enum cfs_crypto_crypt_alg crypt_alg)
+{
+ const struct cfs_crypto_crypt_type *ct;
+
+ ct = cfs_crypto_crypt_type(crypt_alg);
+ if (ct != NULL)
+ return ct->cct_size;
+
+ return 0;
+}
+
+/**
+ * Find crypto algorithm ID for the specified algorithm name
+ *
+ * \retval crypto algorithm ID for valid ID (CFS_CRYPT_ALG_*)
+ * \retval CFS_CRYPT_ALG_UNKNOWN for unknown algorithm name
+ */
+static inline unsigned char cfs_crypto_crypt_alg(const char *algname)
+{
+ enum cfs_crypto_crypt_alg crypt_alg;
+
+ for (crypt_alg = 0; crypt_alg < CFS_CRYPT_ALG_MAX; crypt_alg++)
+ if (strcmp(crypt_types[crypt_alg].cct_name, algname) == 0)
+ return crypt_alg;
+
+ return CFS_CRYPT_ALG_UNKNOWN;
+}
+
int cfs_crypto_hash_digest(enum cfs_crypto_hash_alg hash_alg,
const void *buf, unsigned int buf_len,
unsigned char *key, unsigned int key_len,
unsigned char *hash, unsigned int *hash_len);
/* cfs crypto hash descriptor */
-struct cfs_crypto_hash_desc;
+struct page;
-struct cfs_crypto_hash_desc *
+struct ahash_request *
cfs_crypto_hash_init(enum cfs_crypto_hash_alg hash_alg,
unsigned char *key, unsigned int key_len);
-int cfs_crypto_hash_update_page(struct cfs_crypto_hash_desc *desc,
+int cfs_crypto_hash_update_page(struct ahash_request *req,
struct page *page, unsigned int offset,
unsigned int len);
-int cfs_crypto_hash_update(struct cfs_crypto_hash_desc *desc, const void *buf,
+int cfs_crypto_hash_update(struct ahash_request *req, const void *buf,
unsigned int buf_len);
-int cfs_crypto_hash_final(struct cfs_crypto_hash_desc *desc,
+int cfs_crypto_hash_final(struct ahash_request *req,
unsigned char *hash, unsigned int *hash_len);
int cfs_crypto_register(void);
void cfs_crypto_unregister(void);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff