mirror of
https://gitlab.com/cryptsetup/cryptsetup.git
synced 2025-12-11 19:00:02 +01:00
Add Nettle crypto backend support.
git-svn-id: https://cryptsetup.googlecode.com/svn/trunk@516 36d66b0a-2a48-0410-832c-cd162a569da5
This commit is contained in:
Milan Broz
@@ -18,5 +18,8 @@ endif
|
||||
if CRYPTO_BACKEND_KERNEL
|
||||
libcrypto_backend_la_SOURCES += crypto_kernel.c
|
||||
endif
|
||||
if CRYPTO_BACKEND_NETTLE
|
||||
libcrypto_backend_la_SOURCES += crypto_nettle.c
|
||||
endif
|
||||
|
||||
INCLUDES = -D_GNU_SOURCE -I$(top_srcdir)/lib
|
||||
|
||||
256
lib/crypto_backend/crypto_nettle.c
Normal file
256
lib/crypto_backend/crypto_nettle.c
Normal file
@@ -0,0 +1,256 @@
|
||||
/*
|
||||
* Nettle crypto backend implementation
|
||||
*
|
||||
* Copyright (C) 2011 Red Hat, Inc. All rights reserved.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* version 2 as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <nettle/sha.h>
|
||||
#include <nettle/hmac.h>
|
||||
#include "crypto_backend.h"
|
||||
|
||||
typedef void (*init_func) (void *);
|
||||
typedef void (*update_func) (void *, unsigned, const uint8_t *);
|
||||
typedef void (*digest_func) (void *, unsigned, uint8_t *);
|
||||
typedef void (*set_key_func) (void *, unsigned, const uint8_t *);
|
||||
|
||||
struct hash_alg {
|
||||
const char *name;
|
||||
int length;
|
||||
init_func init;
|
||||
update_func update;
|
||||
digest_func digest;
|
||||
update_func hmac_update;
|
||||
digest_func hmac_digest;
|
||||
set_key_func hmac_set_key;
|
||||
};
|
||||
|
||||
static struct hash_alg hash_algs[] = {
|
||||
{ "sha1", SHA1_DIGEST_SIZE,
|
||||
(init_func) sha1_init,
|
||||
(update_func) sha1_update,
|
||||
(digest_func) sha1_digest,
|
||||
(update_func) hmac_sha1_update,
|
||||
(digest_func) hmac_sha1_digest,
|
||||
(set_key_func) hmac_sha1_set_key,
|
||||
},
|
||||
{ "sha224", SHA224_DIGEST_SIZE,
|
||||
(init_func) sha224_init,
|
||||
(update_func) sha224_update,
|
||||
(digest_func) sha224_digest,
|
||||
(update_func) hmac_sha224_update,
|
||||
(digest_func) hmac_sha224_digest,
|
||||
(set_key_func) hmac_sha224_set_key,
|
||||
},
|
||||
{ "sha256", SHA256_DIGEST_SIZE,
|
||||
(init_func) sha256_init,
|
||||
(update_func) sha256_update,
|
||||
(digest_func) sha256_digest,
|
||||
(update_func) hmac_sha256_update,
|
||||
(digest_func) hmac_sha256_digest,
|
||||
(set_key_func) hmac_sha256_set_key,
|
||||
},
|
||||
{ "sha384", SHA384_DIGEST_SIZE,
|
||||
(init_func) sha384_init,
|
||||
(update_func) sha384_update,
|
||||
(digest_func) sha384_digest,
|
||||
(update_func) hmac_sha384_update,
|
||||
(digest_func) hmac_sha384_digest,
|
||||
(set_key_func) hmac_sha384_set_key,
|
||||
},
|
||||
{ "sha512", SHA512_DIGEST_SIZE,
|
||||
(init_func) sha512_init,
|
||||
(update_func) sha512_update,
|
||||
(digest_func) sha512_digest,
|
||||
(update_func) hmac_sha512_update,
|
||||
(digest_func) hmac_sha512_digest,
|
||||
(set_key_func) hmac_sha512_set_key,
|
||||
},
|
||||
{ NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL, }
|
||||
};
|
||||
|
||||
struct crypt_hash {
|
||||
const struct hash_alg *hash;
|
||||
union {
|
||||
struct sha1_ctx sha1;
|
||||
struct sha224_ctx sha224;
|
||||
struct sha256_ctx sha256;
|
||||
struct sha384_ctx sha384;
|
||||
struct sha512_ctx sha512;
|
||||
} nettle_ctx;
|
||||
};
|
||||
|
||||
struct crypt_hmac {
|
||||
const struct hash_alg *hash;
|
||||
union {
|
||||
struct hmac_sha1_ctx sha1;
|
||||
struct hmac_sha224_ctx sha224;
|
||||
struct hmac_sha256_ctx sha256;
|
||||
struct hmac_sha384_ctx sha384;
|
||||
struct hmac_sha512_ctx sha512;
|
||||
} nettle_ctx;
|
||||
size_t key_length;
|
||||
uint8_t *key;
|
||||
};
|
||||
|
||||
uint32_t crypt_backend_flags(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct hash_alg *_get_alg(const char *name)
|
||||
{
|
||||
int i = 0;
|
||||
|
||||
while (name && hash_algs[i].name) {
|
||||
if (!strcmp(name, hash_algs[i].name))
|
||||
return &hash_algs[i];
|
||||
i++;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int crypt_backend_init(struct crypt_device *ctx)
|
||||
{
|
||||
log_dbg("Initialising Nettle crypto backend.");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* HASH */
|
||||
int crypt_hash_size(const char *name)
|
||||
{
|
||||
struct hash_alg *ha = _get_alg(name);
|
||||
|
||||
return ha ? ha->length : -EINVAL;
|
||||
}
|
||||
|
||||
int crypt_hash_init(struct crypt_hash **ctx, const char *name)
|
||||
{
|
||||
struct crypt_hash *h;
|
||||
|
||||
h = malloc(sizeof(*h));
|
||||
if (!h)
|
||||
return -ENOMEM;
|
||||
|
||||
h->hash = _get_alg(name);
|
||||
if (!h->hash) {
|
||||
free(h);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
h->hash->init(&h->nettle_ctx);
|
||||
|
||||
*ctx = h;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int crypt_hash_restart(struct crypt_hash *ctx)
|
||||
{
|
||||
ctx->hash->init(&ctx->nettle_ctx);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int crypt_hash_write(struct crypt_hash *ctx, const char *buffer, size_t length)
|
||||
{
|
||||
ctx->hash->update(&ctx->nettle_ctx, length, (const uint8_t*)buffer);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int crypt_hash_final(struct crypt_hash *ctx, char *buffer, size_t length)
|
||||
{
|
||||
if (length > (size_t)ctx->hash->length)
|
||||
return -EINVAL;
|
||||
|
||||
ctx->hash->digest(&ctx->nettle_ctx, length, (uint8_t *)buffer);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int crypt_hash_destroy(struct crypt_hash *ctx)
|
||||
{
|
||||
memset(ctx, 0, sizeof(*ctx));
|
||||
free(ctx);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* HMAC */
|
||||
int crypt_hmac_size(const char *name)
|
||||
{
|
||||
return crypt_hash_size(name);
|
||||
}
|
||||
|
||||
int crypt_hmac_init(struct crypt_hmac **ctx, const char *name,
|
||||
const void *buffer, size_t length)
|
||||
{
|
||||
struct crypt_hmac *h;
|
||||
|
||||
h = malloc(sizeof(*h));
|
||||
if (!h)
|
||||
return -ENOMEM;
|
||||
memset(ctx, 0, sizeof(*ctx));
|
||||
|
||||
|
||||
h->hash = _get_alg(name);
|
||||
if (!h->hash)
|
||||
goto bad;
|
||||
|
||||
h->key = malloc(length);
|
||||
if (!h->key)
|
||||
goto bad;
|
||||
|
||||
memcpy(h->key, buffer, length);
|
||||
h->key_length = length;
|
||||
|
||||
h->hash->init(&h->nettle_ctx);
|
||||
h->hash->hmac_set_key(&h->nettle_ctx, h->key_length, h->key);
|
||||
|
||||
*ctx = h;
|
||||
return 0;
|
||||
bad:
|
||||
free(h);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
int crypt_hmac_restart(struct crypt_hmac *ctx)
|
||||
{
|
||||
ctx->hash->hmac_set_key(&ctx->nettle_ctx, ctx->key_length, ctx->key);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int crypt_hmac_write(struct crypt_hmac *ctx, const char *buffer, size_t length)
|
||||
{
|
||||
ctx->hash->hmac_update(&ctx->nettle_ctx, length, (const uint8_t *)buffer);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int crypt_hmac_final(struct crypt_hmac *ctx, char *buffer, size_t length)
|
||||
{
|
||||
if (length > (size_t)ctx->hash->length)
|
||||
return -EINVAL;
|
||||
|
||||
ctx->hash->hmac_digest(&ctx->nettle_ctx, length, (uint8_t *)buffer);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int crypt_hmac_destroy(struct crypt_hmac *ctx)
|
||||
{
|
||||
memset(ctx->key, 0, ctx->key_length);
|
||||
memset(ctx, 0, sizeof(*ctx));
|
||||
free(ctx->key);
|
||||
free(ctx);
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user