| Message ID | 1453311539-1193-4-git-send-email-berrange@redhat.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
On Wed, 01/20 17:38, Daniel P. Berrange wrote: > The LUKS data format includes use of PBKDF2 (Password-Based > Key Derivation Function). The Nettle library can provide > an implementation of this, but we don't want code directly > depending on a specific crypto library backend. Introduce > a include/crypto/pbkdf.h header which defines a QEMU > API for invoking PBKDK2. The initial implementations are > backed by nettle & gcrypt, which are commonly available > with distros shipping GNUTLS. > > The test suite data is taken from the cryptsetup codebase > under the LGPLv2.1+ license. This merely aims to verify > that whatever backend we provide for this function in QEMU > will comply with the spec. > > Signed-off-by: Daniel P. Berrange <berrange@redhat.com> > --- > crypto/Makefile.objs | 6 +- > crypto/pbkdf-gcrypt.c | 65 ++++++++ > crypto/pbkdf-nettle.c | 64 ++++++++ > crypto/pbkdf-stub.c | 41 +++++ > crypto/pbkdf.c | 68 +++++++++ > include/crypto/pbkdf.h | 152 +++++++++++++++++++ > tests/.gitignore | 1 + > tests/Makefile | 2 + > tests/test-crypto-pbkdf.c | 378 ++++++++++++++++++++++++++++++++++++++++++++++ > 9 files changed, 776 insertions(+), 1 deletion(-) > create mode 100644 crypto/pbkdf-gcrypt.c > create mode 100644 crypto/pbkdf-nettle.c > create mode 100644 crypto/pbkdf-stub.c > create mode 100644 crypto/pbkdf.c > create mode 100644 include/crypto/pbkdf.h > create mode 100644 tests/test-crypto-pbkdf.c > > diff --git a/crypto/Makefile.objs b/crypto/Makefile.objs > index 1802ff5..4d2cd3e 100644 > --- a/crypto/Makefile.objs > +++ b/crypto/Makefile.objs > @@ -10,8 +10,12 @@ crypto-obj-y += tlssession.o > crypto-obj-y += secret.o > crypto-obj-$(if $(CONFIG_GNUTLS),n,$(CONFIG_GCRYPT)) += random-gcrypt.o > crypto-obj-$(CONFIG_GNUTLS) += random-gnutls.o > +crypto-obj-y += pbkdf.o > +crypto-obj-$(CONFIG_NETTLE) += pbkdf-nettle.o > +crypto-obj-$(if $(CONFIG_NETTLE),n,$(CONFIG_GCRYPT)) += pbkdf-gcrypt.o > > # Let the userspace emulators avoid linking gnutls/etc > crypto-aes-obj-y = aes.o > > -stub-obj-y += random-stub.o > \ No newline at end of file > +stub-obj-y += random-stub.o > +stub-obj-y += pbkdf-stub.o > diff --git a/crypto/pbkdf-gcrypt.c b/crypto/pbkdf-gcrypt.c > new file mode 100644 > index 0000000..94abcf8 > --- /dev/null > +++ b/crypto/pbkdf-gcrypt.c > @@ -0,0 +1,65 @@ > +/* > + * QEMU Crypto PBKDF support (Password-Based Key Derivation Function) > + * > + * Copyright (c) 2015-2016 Red Hat, Inc. > + * > + * This library is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Lesser General Public > + * License as published by the Free Software Foundation; either > + * version 2 of the License, or (at your option) any later version. > + * > + * This library 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 > + * Lesser General Public License for more details. > + * > + * You should have received a copy of the GNU Lesser General Public > + * License along with this library; if not, see <http://www.gnu.org/licenses/>. > + * > + */ > + > +#include "crypto/pbkdf.h" > +#include "gcrypt.h" > + > +bool qcrypto_pbkdf2_supports(QCryptoHashAlgorithm hash) > +{ > + switch (hash) { > + case QCRYPTO_HASH_ALG_SHA1: > + case QCRYPTO_HASH_ALG_SHA256: > + return true; > + default: > + return false; > + } > +} > + > +int qcrypto_pbkdf2(QCryptoHashAlgorithm hash, > + const uint8_t *key, size_t nkey, > + const uint8_t *salt, size_t nsalt, > + unsigned int iterations, > + uint8_t *out, size_t nout, > + Error **errp) > +{ > + static const int hash_map[QCRYPTO_HASH_ALG__MAX] = { > + [QCRYPTO_HASH_ALG_MD5] = GCRY_MD_MD5, > + [QCRYPTO_HASH_ALG_SHA1] = GCRY_MD_SHA1, > + [QCRYPTO_HASH_ALG_SHA256] = GCRY_MD_SHA256, > + }; > + int ret; > + > + if (hash > G_N_ELEMENTS(hash_map)) { Do you want ">="? > + error_setg(errp, "Unexpected hash algorithm %d", hash); > + return -1; > + } > + > + ret = gcry_kdf_derive(key, nkey, GCRY_KDF_PBKDF2, > + hash_map[hash], > + salt, nsalt, iterations, > + nout, out); We go ahead with QCRYPTO_HASH_ALG_MD5 here, but we didn't accept it in qcrypto_pbkdf2_supports, is that a mistake? > + if (ret != 0) { > + error_setg(errp, "Cannot derive password: %s", > + gcry_strerror(ret)); > + return -1; > + } > + > + return 0; > +} > diff --git a/crypto/pbkdf-nettle.c b/crypto/pbkdf-nettle.c > new file mode 100644 > index 0000000..b0f2d8e > --- /dev/null > +++ b/crypto/pbkdf-nettle.c > @@ -0,0 +1,64 @@ > +/* > + * QEMU Crypto PBKDF support (Password-Based Key Derivation Function) > + * > + * Copyright (c) 2015-2016 Red Hat, Inc. > + * > + * This library is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Lesser General Public > + * License as published by the Free Software Foundation; either > + * version 2 of the License, or (at your option) any later version. > + * > + * This library 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 > + * Lesser General Public License for more details. > + * > + * You should have received a copy of the GNU Lesser General Public > + * License along with this library; if not, see <http://www.gnu.org/licenses/>. > + * > + */ > + > +#include "crypto/pbkdf.h" > +#include "nettle/pbkdf2.h" > + > + > +bool qcrypto_pbkdf2_supports(QCryptoHashAlgorithm hash) > +{ > + switch (hash) { > + case QCRYPTO_HASH_ALG_SHA1: > + case QCRYPTO_HASH_ALG_SHA256: > + return true; > + default: > + return false; > + } > +} > + > +int qcrypto_pbkdf2(QCryptoHashAlgorithm hash, > + const uint8_t *key, size_t nkey, > + const uint8_t *salt, size_t nsalt, > + unsigned int iterations, > + uint8_t *out, size_t nout, > + Error **errp) > +{ > + switch (hash) { > + case QCRYPTO_HASH_ALG_SHA1: > + pbkdf2_hmac_sha1(nkey, key, > + iterations, > + nsalt, salt, > + nout, out); > + break; > + > + case QCRYPTO_HASH_ALG_SHA256: > + pbkdf2_hmac_sha256(nkey, key, > + iterations, > + nsalt, salt, > + nout, out); > + break; > + > + default: > + error_setg_errno(errp, ENOSYS, > + "PBKDF does not support hash algorithm %d", hash); > + return -1; > + } > + return 0; > +} > diff --git a/crypto/pbkdf-stub.c b/crypto/pbkdf-stub.c > new file mode 100644 > index 0000000..73a08c3 > --- /dev/null > +++ b/crypto/pbkdf-stub.c > @@ -0,0 +1,41 @@ > +/* > + * QEMU Crypto PBKDF support (Password-Based Key Derivation Function) > + * > + * Copyright (c) 2015-2016 Red Hat, Inc. > + * > + * This library is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Lesser General Public > + * License as published by the Free Software Foundation; either > + * version 2 of the License, or (at your option) any later version. > + * > + * This library 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 > + * Lesser General Public License for more details. > + * > + * You should have received a copy of the GNU Lesser General Public > + * License along with this library; if not, see <http://www.gnu.org/licenses/>. > + * > + */ > + > +#include "crypto/pbkdf.h" > + > +bool qcrypto_pbkdf2_supports(QCryptoHashAlgorithm hash) Missing G_GNUC_UNUSED to be consistent with the rest of the file, doesn't hurt though. > +{ > + return false; > +} > + > +int qcrypto_pbkdf2(QCryptoHashAlgorithm hash G_GNUC_UNUSED, > + const uint8_t *key G_GNUC_UNUSED, > + size_t nkey G_GNUC_UNUSED, > + const uint8_t *salt G_GNUC_UNUSED, > + size_t nsalt G_GNUC_UNUSED, > + unsigned int iterations G_GNUC_UNUSED, > + uint8_t *out G_GNUC_UNUSED, > + size_t nout G_GNUC_UNUSED, > + Error **errp) > +{ > + error_setg_errno(errp, ENOSYS, > + "No crypto library supporting PBKDF in this build"); > + return -1; > +} > diff --git a/crypto/pbkdf.c b/crypto/pbkdf.c > new file mode 100644 > index 0000000..71f96cd > --- /dev/null > +++ b/crypto/pbkdf.c > @@ -0,0 +1,68 @@ > +/* > + * QEMU Crypto PBKDF support (Password-Based Key Derivation Function) > + * > + * Copyright (c) 2015-2016 Red Hat, Inc. > + * > + * This library is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Lesser General Public > + * License as published by the Free Software Foundation; either > + * version 2 of the License, or (at your option) any later version. > + * > + * This library 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 > + * Lesser General Public License for more details. > + * > + * You should have received a copy of the GNU Lesser General Public > + * License along with this library; if not, see <http://www.gnu.org/licenses/>. > + * > + */ > + > +#include "crypto/pbkdf.h" > +#include <sys/resource.h> > + > + > +int qcrypto_pbkdf2_count_iters(QCryptoHashAlgorithm hash, > + const uint8_t *key, size_t nkey, > + const uint8_t *salt, size_t nsalt, > + Error **errp) > +{ > + uint8_t out[32]; > + int iterations = (1 << 15); To be safe from overflow, I'd use at least 64 bits to do the math, just in case that some machine is too good at computing this stuff. :) > + struct rusage start, end; > + unsigned long long delta; > + > + while (1) { > + if (getrusage(RUSAGE_THREAD, &start) < 0) { > + error_setg_errno(errp, errno, "Unable to get thread CPU usage"); > + return -1; > + } > + if (qcrypto_pbkdf2(hash, > + key, nkey, > + salt, nsalt, > + iterations, > + out, sizeof(out), > + errp) < 0) { > + return -1; > + } > + if (getrusage(RUSAGE_THREAD, &end) < 0) { > + error_setg_errno(errp, errno, "Unable to get thread CPU usage"); > + return -1; > + } > + > + delta = (((end.ru_utime.tv_sec * 1000ll) + > + (end.ru_utime.tv_usec / 1000)) - > + ((start.ru_utime.tv_sec * 1000ll) + > + (start.ru_utime.tv_usec / 1000))); > + > + if (delta > 500) { > + break; > + } else if (delta < 100) { > + iterations = iterations * 10; > + } else { > + iterations = (iterations * 1000 / delta); > + } > + } > + > + return iterations * 1000 / delta; > +} > diff --git a/include/crypto/pbkdf.h b/include/crypto/pbkdf.h > new file mode 100644 > index 0000000..a5e8267 > --- /dev/null > +++ b/include/crypto/pbkdf.h > @@ -0,0 +1,152 @@ > +/* > + * QEMU Crypto PBKDF support (Password-Based Key Derivation Function) > + * > + * Copyright (c) 2015-2016 Red Hat, Inc. > + * > + * This library is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Lesser General Public > + * License as published by the Free Software Foundation; either > + * version 2 of the License, or (at your option) any later version. > + * > + * This library 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 > + * Lesser General Public License for more details. > + * > + * You should have received a copy of the GNU Lesser General Public > + * License along with this library; if not, see <http://www.gnu.org/licenses/>. > + * > + */ > + > +#ifndef QCRYPTO_PBKDF_H__ > +#define QCRYPTO_PBKDF_H__ > + > +#include "crypto/hash.h" > + > +/** > + * This module provides an interface to the PBKDF2 algorithm > + * > + * https://en.wikipedia.org/wiki/PBKDF2 > + * > + * <example> > + * <title>Generating a AES encryption key from a user password</title> s/a AES/an AES/ ? > + * <programlisting>
On Thu, Jan 21, 2016 at 02:59:24PM +0800, Fam Zheng wrote: > On Wed, 01/20 17:38, Daniel P. Berrange wrote: > > The LUKS data format includes use of PBKDF2 (Password-Based > > Key Derivation Function). The Nettle library can provide > > an implementation of this, but we don't want code directly > > depending on a specific crypto library backend. Introduce > > a include/crypto/pbkdf.h header which defines a QEMU > > API for invoking PBKDK2. The initial implementations are > > backed by nettle & gcrypt, which are commonly available > > with distros shipping GNUTLS. > > > > The test suite data is taken from the cryptsetup codebase > > under the LGPLv2.1+ license. This merely aims to verify > > that whatever backend we provide for this function in QEMU > > will comply with the spec. > > > > Signed-off-by: Daniel P. Berrange <berrange@redhat.com> > > --- > > crypto/Makefile.objs | 6 +- > > crypto/pbkdf-gcrypt.c | 65 ++++++++ > > crypto/pbkdf-nettle.c | 64 ++++++++ > > crypto/pbkdf-stub.c | 41 +++++ > > crypto/pbkdf.c | 68 +++++++++ > > include/crypto/pbkdf.h | 152 +++++++++++++++++++ > > tests/.gitignore | 1 + > > tests/Makefile | 2 + > > tests/test-crypto-pbkdf.c | 378 ++++++++++++++++++++++++++++++++++++++++++++++ > > 9 files changed, 776 insertions(+), 1 deletion(-) > > create mode 100644 crypto/pbkdf-gcrypt.c > > create mode 100644 crypto/pbkdf-nettle.c > > create mode 100644 crypto/pbkdf-stub.c > > create mode 100644 crypto/pbkdf.c > > create mode 100644 include/crypto/pbkdf.h > > create mode 100644 tests/test-crypto-pbkdf.c > > > > +int qcrypto_pbkdf2(QCryptoHashAlgorithm hash, > > + const uint8_t *key, size_t nkey, > > + const uint8_t *salt, size_t nsalt, > > + unsigned int iterations, > > + uint8_t *out, size_t nout, > > + Error **errp) > > +{ > > + static const int hash_map[QCRYPTO_HASH_ALG__MAX] = { > > + [QCRYPTO_HASH_ALG_MD5] = GCRY_MD_MD5, > > + [QCRYPTO_HASH_ALG_SHA1] = GCRY_MD_SHA1, > > + [QCRYPTO_HASH_ALG_SHA256] = GCRY_MD_SHA256, > > + }; > > + int ret; > > + > > + if (hash > G_N_ELEMENTS(hash_map)) { > > Do you want ">="? Yes. > > > + error_setg(errp, "Unexpected hash algorithm %d", hash); > > + return -1; > > + } > > + > > + ret = gcry_kdf_derive(key, nkey, GCRY_KDF_PBKDF2, > > + hash_map[hash], > > + salt, nsalt, iterations, > > + nout, out); > > We go ahead with QCRYPTO_HASH_ALG_MD5 here, but we didn't accept it in > qcrypto_pbkdf2_supports, is that a mistake? Yes, I should have reported MD5 in the earlier function, since gcrypt allows that. > > diff --git a/crypto/pbkdf.c b/crypto/pbkdf.c > > new file mode 100644 > > index 0000000..71f96cd > > --- /dev/null > > +++ b/crypto/pbkdf.c > > @@ -0,0 +1,68 @@ > > +/* > > + * QEMU Crypto PBKDF support (Password-Based Key Derivation Function) > > + * > > + * Copyright (c) 2015-2016 Red Hat, Inc. > > + * > > + * This library is free software; you can redistribute it and/or > > + * modify it under the terms of the GNU Lesser General Public > > + * License as published by the Free Software Foundation; either > > + * version 2 of the License, or (at your option) any later version. > > + * > > + * This library 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 > > + * Lesser General Public License for more details. > > + * > > + * You should have received a copy of the GNU Lesser General Public > > + * License along with this library; if not, see <http://www.gnu.org/licenses/>. > > + * > > + */ > > + > > +#include "crypto/pbkdf.h" > > +#include <sys/resource.h> > > + > > + > > +int qcrypto_pbkdf2_count_iters(QCryptoHashAlgorithm hash, > > + const uint8_t *key, size_t nkey, > > + const uint8_t *salt, size_t nsalt, > > + Error **errp) > > +{ > > + uint8_t out[32]; > > + int iterations = (1 << 15); > > To be safe from overflow, I'd use at least 64 bits to do the math, just in case > that some machine is too good at computing this stuff. :) Hmm, probably need to change the return type to be 64 bit too then > > > + struct rusage start, end; > > + unsigned long long delta; > > + > > + while (1) { > > + if (getrusage(RUSAGE_THREAD, &start) < 0) { > > + error_setg_errno(errp, errno, "Unable to get thread CPU usage"); > > + return -1; > > + } > > + if (qcrypto_pbkdf2(hash, > > + key, nkey, > > + salt, nsalt, > > + iterations, > > + out, sizeof(out), > > + errp) < 0) { > > + return -1; > > + } > > + if (getrusage(RUSAGE_THREAD, &end) < 0) { > > + error_setg_errno(errp, errno, "Unable to get thread CPU usage"); > > + return -1; > > + } > > + > > + delta = (((end.ru_utime.tv_sec * 1000ll) + > > + (end.ru_utime.tv_usec / 1000)) - > > + ((start.ru_utime.tv_sec * 1000ll) + > > + (start.ru_utime.tv_usec / 1000))); > > + > > + if (delta > 500) { > > + break; > > + } else if (delta < 100) { > > + iterations = iterations * 10; > > + } else { > > + iterations = (iterations * 1000 / delta); > > + } > > + } > > + > > + return iterations * 1000 / delta; > > +} > > +/** > > + * This module provides an interface to the PBKDF2 algorithm > > + * > > + * https://en.wikipedia.org/wiki/PBKDF2 > > + * > > + * <example> > > + * <title>Generating a AES encryption key from a user password</title> > > s/a AES/an AES/ ? Yes Regards, Daniel
On 01/20/2016 10:38 AM, Daniel P. Berrange wrote: > The LUKS data format includes use of PBKDF2 (Password-Based > Key Derivation Function). The Nettle library can provide > an implementation of this, but we don't want code directly > depending on a specific crypto library backend. Introduce > a include/crypto/pbkdf.h header which defines a QEMU 'an include/...', or maybe 'a new include/...'? > API for invoking PBKDK2. The initial implementations are > backed by nettle & gcrypt, which are commonly available > with distros shipping GNUTLS. > > The test suite data is taken from the cryptsetup codebase > under the LGPLv2.1+ license. This merely aims to verify > that whatever backend we provide for this function in QEMU > will comply with the spec. > > Signed-off-by: Daniel P. Berrange <berrange@redhat.com> > --- In addition to Fam's review, > +++ b/crypto/pbkdf-gcrypt.c > +int qcrypto_pbkdf2(QCryptoHashAlgorithm hash, > + const uint8_t *key, size_t nkey, > + const uint8_t *salt, size_t nsalt, > + unsigned int iterations, > + uint8_t *out, size_t nout, > + Error **errp) > +{ > + static const int hash_map[QCRYPTO_HASH_ALG__MAX] = { > + [QCRYPTO_HASH_ALG_MD5] = GCRY_MD_MD5, > + [QCRYPTO_HASH_ALG_SHA1] = GCRY_MD_SHA1, > + [QCRYPTO_HASH_ALG_SHA256] = GCRY_MD_SHA256, > + }; If QCRYPTO_HASH_ gains future enum values, those elements of the array will be 0-initialized. > + int ret; > + > + if (hash > G_N_ELEMENTS(hash_map)) { > + error_setg(errp, "Unexpected hash algorithm %d", hash); > + return -1; > + } This checks for beyond the bounds of the array, but not for an element that was 0-initialized. Is that a problem we need to worry about? > +int qcrypto_pbkdf2(QCryptoHashAlgorithm hash, > + const uint8_t *key, size_t nkey, > + const uint8_t *salt, size_t nsalt, > + unsigned int iterations, > + uint8_t *out, size_t nout, > + Error **errp); > + > +/** > + * qcrypto_pbkdf2_count_iters: > + * @hash: the hash algorithm to use > + * @key: the user password / key > + * @nkey: the length of @key in bytes > + * @salt: a random salt > + * @nsalt: length of @salt in bytes > + * @errp: pointer to a NULL-initialized error object > + * > + * Time the PBKDF2 algorithm to determine how many > + * iterations are required to derive an encryption > + * key from a user password provided in @key in 1 > + * second of compute time. The result of this can > + * be used as a the @iterations parameter of a later > + * call to qcrypto_pbkdf2(). As machines get faster, will 2^31 still be enough, or do we want a 64-bit iterations counter?
On Thu, Feb 04, 2016 at 03:14:10PM -0700, Eric Blake wrote: > On 01/20/2016 10:38 AM, Daniel P. Berrange wrote: > > +int qcrypto_pbkdf2(QCryptoHashAlgorithm hash, > > + const uint8_t *key, size_t nkey, > > + const uint8_t *salt, size_t nsalt, > > + unsigned int iterations, > > + uint8_t *out, size_t nout, > > + Error **errp); > > + > > +/** > > + * qcrypto_pbkdf2_count_iters: > > + * @hash: the hash algorithm to use > > + * @key: the user password / key > > + * @nkey: the length of @key in bytes > > + * @salt: a random salt > > + * @nsalt: length of @salt in bytes > > + * @errp: pointer to a NULL-initialized error object > > + * > > + * Time the PBKDF2 algorithm to determine how many > > + * iterations are required to derive an encryption > > + * key from a user password provided in @key in 1 > > + * second of compute time. The result of this can > > + * be used as a the @iterations parameter of a later > > + * call to qcrypto_pbkdf2(). > > As machines get faster, will 2^31 still be enough, or do we want a > 64-bit iterations counter? The luks format only has space to store a 32-bit int for interations, so 64-bit would require an on disk format change. On my current modern laptop we're getting iteration counts in the 400,000 range, so it will be a decent while before we hit 2^31, by which time LUKS maintainers will have to do a format change. Regards, Daniel
On Thu, Feb 04, 2016 at 03:14:10PM -0700, Eric Blake wrote: > On 01/20/2016 10:38 AM, Daniel P. Berrange wrote: > > The LUKS data format includes use of PBKDF2 (Password-Based > > Key Derivation Function). The Nettle library can provide > > an implementation of this, but we don't want code directly > > depending on a specific crypto library backend. Introduce > > a include/crypto/pbkdf.h header which defines a QEMU > > 'an include/...', or maybe 'a new include/...'? > > > API for invoking PBKDK2. The initial implementations are > > backed by nettle & gcrypt, which are commonly available > > with distros shipping GNUTLS. > > > > The test suite data is taken from the cryptsetup codebase > > under the LGPLv2.1+ license. This merely aims to verify > > that whatever backend we provide for this function in QEMU > > will comply with the spec. > > > > Signed-off-by: Daniel P. Berrange <berrange@redhat.com> > > --- > > In addition to Fam's review, > > > +++ b/crypto/pbkdf-gcrypt.c > > > +int qcrypto_pbkdf2(QCryptoHashAlgorithm hash, > > + const uint8_t *key, size_t nkey, > > + const uint8_t *salt, size_t nsalt, > > + unsigned int iterations, > > + uint8_t *out, size_t nout, > > + Error **errp) > > +{ > > + static const int hash_map[QCRYPTO_HASH_ALG__MAX] = { > > + [QCRYPTO_HASH_ALG_MD5] = GCRY_MD_MD5, > > + [QCRYPTO_HASH_ALG_SHA1] = GCRY_MD_SHA1, > > + [QCRYPTO_HASH_ALG_SHA256] = GCRY_MD_SHA256, > > + }; > > If QCRYPTO_HASH_ gains future enum values, those elements of the array > will be 0-initialized. > > > + int ret; > > + > > + if (hash > G_N_ELEMENTS(hash_map)) { > > + error_setg(errp, "Unexpected hash algorithm %d", hash); > > + return -1; > > + } > > This checks for beyond the bounds of the array, but not for an element > that was 0-initialized. Is that a problem we need to worry about? I'll add '|| hash_map[hash] == GCRY_MD_NONE' to this condition Regards, Daniel
diff --git a/crypto/Makefile.objs b/crypto/Makefile.objs index 1802ff5..4d2cd3e 100644 --- a/crypto/Makefile.objs +++ b/crypto/Makefile.objs @@ -10,8 +10,12 @@ crypto-obj-y += tlssession.o crypto-obj-y += secret.o crypto-obj-$(if $(CONFIG_GNUTLS),n,$(CONFIG_GCRYPT)) += random-gcrypt.o crypto-obj-$(CONFIG_GNUTLS) += random-gnutls.o +crypto-obj-y += pbkdf.o +crypto-obj-$(CONFIG_NETTLE) += pbkdf-nettle.o +crypto-obj-$(if $(CONFIG_NETTLE),n,$(CONFIG_GCRYPT)) += pbkdf-gcrypt.o # Let the userspace emulators avoid linking gnutls/etc crypto-aes-obj-y = aes.o -stub-obj-y += random-stub.o \ No newline at end of file +stub-obj-y += random-stub.o +stub-obj-y += pbkdf-stub.o diff --git a/crypto/pbkdf-gcrypt.c b/crypto/pbkdf-gcrypt.c new file mode 100644 index 0000000..94abcf8 --- /dev/null +++ b/crypto/pbkdf-gcrypt.c @@ -0,0 +1,65 @@ +/* + * QEMU Crypto PBKDF support (Password-Based Key Derivation Function) + * + * Copyright (c) 2015-2016 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#include "crypto/pbkdf.h" +#include "gcrypt.h" + +bool qcrypto_pbkdf2_supports(QCryptoHashAlgorithm hash) +{ + switch (hash) { + case QCRYPTO_HASH_ALG_SHA1: + case QCRYPTO_HASH_ALG_SHA256: + return true; + default: + return false; + } +} + +int qcrypto_pbkdf2(QCryptoHashAlgorithm hash, + const uint8_t *key, size_t nkey, + const uint8_t *salt, size_t nsalt, + unsigned int iterations, + uint8_t *out, size_t nout, + Error **errp) +{ + static const int hash_map[QCRYPTO_HASH_ALG__MAX] = { + [QCRYPTO_HASH_ALG_MD5] = GCRY_MD_MD5, + [QCRYPTO_HASH_ALG_SHA1] = GCRY_MD_SHA1, + [QCRYPTO_HASH_ALG_SHA256] = GCRY_MD_SHA256, + }; + int ret; + + if (hash > G_N_ELEMENTS(hash_map)) { + error_setg(errp, "Unexpected hash algorithm %d", hash); + return -1; + } + + ret = gcry_kdf_derive(key, nkey, GCRY_KDF_PBKDF2, + hash_map[hash], + salt, nsalt, iterations, + nout, out); + if (ret != 0) { + error_setg(errp, "Cannot derive password: %s", + gcry_strerror(ret)); + return -1; + } + + return 0; +} diff --git a/crypto/pbkdf-nettle.c b/crypto/pbkdf-nettle.c new file mode 100644 index 0000000..b0f2d8e --- /dev/null +++ b/crypto/pbkdf-nettle.c @@ -0,0 +1,64 @@ +/* + * QEMU Crypto PBKDF support (Password-Based Key Derivation Function) + * + * Copyright (c) 2015-2016 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#include "crypto/pbkdf.h" +#include "nettle/pbkdf2.h" + + +bool qcrypto_pbkdf2_supports(QCryptoHashAlgorithm hash) +{ + switch (hash) { + case QCRYPTO_HASH_ALG_SHA1: + case QCRYPTO_HASH_ALG_SHA256: + return true; + default: + return false; + } +} + +int qcrypto_pbkdf2(QCryptoHashAlgorithm hash, + const uint8_t *key, size_t nkey, + const uint8_t *salt, size_t nsalt, + unsigned int iterations, + uint8_t *out, size_t nout, + Error **errp) +{ + switch (hash) { + case QCRYPTO_HASH_ALG_SHA1: + pbkdf2_hmac_sha1(nkey, key, + iterations, + nsalt, salt, + nout, out); + break; + + case QCRYPTO_HASH_ALG_SHA256: + pbkdf2_hmac_sha256(nkey, key, + iterations, + nsalt, salt, + nout, out); + break; + + default: + error_setg_errno(errp, ENOSYS, + "PBKDF does not support hash algorithm %d", hash); + return -1; + } + return 0; +} diff --git a/crypto/pbkdf-stub.c b/crypto/pbkdf-stub.c new file mode 100644 index 0000000..73a08c3 --- /dev/null +++ b/crypto/pbkdf-stub.c @@ -0,0 +1,41 @@ +/* + * QEMU Crypto PBKDF support (Password-Based Key Derivation Function) + * + * Copyright (c) 2015-2016 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#include "crypto/pbkdf.h" + +bool qcrypto_pbkdf2_supports(QCryptoHashAlgorithm hash) +{ + return false; +} + +int qcrypto_pbkdf2(QCryptoHashAlgorithm hash G_GNUC_UNUSED, + const uint8_t *key G_GNUC_UNUSED, + size_t nkey G_GNUC_UNUSED, + const uint8_t *salt G_GNUC_UNUSED, + size_t nsalt G_GNUC_UNUSED, + unsigned int iterations G_GNUC_UNUSED, + uint8_t *out G_GNUC_UNUSED, + size_t nout G_GNUC_UNUSED, + Error **errp) +{ + error_setg_errno(errp, ENOSYS, + "No crypto library supporting PBKDF in this build"); + return -1; +} diff --git a/crypto/pbkdf.c b/crypto/pbkdf.c new file mode 100644 index 0000000..71f96cd --- /dev/null +++ b/crypto/pbkdf.c @@ -0,0 +1,68 @@ +/* + * QEMU Crypto PBKDF support (Password-Based Key Derivation Function) + * + * Copyright (c) 2015-2016 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#include "crypto/pbkdf.h" +#include <sys/resource.h> + + +int qcrypto_pbkdf2_count_iters(QCryptoHashAlgorithm hash, + const uint8_t *key, size_t nkey, + const uint8_t *salt, size_t nsalt, + Error **errp) +{ + uint8_t out[32]; + int iterations = (1 << 15); + struct rusage start, end; + unsigned long long delta; + + while (1) { + if (getrusage(RUSAGE_THREAD, &start) < 0) { + error_setg_errno(errp, errno, "Unable to get thread CPU usage"); + return -1; + } + if (qcrypto_pbkdf2(hash, + key, nkey, + salt, nsalt, + iterations, + out, sizeof(out), + errp) < 0) { + return -1; + } + if (getrusage(RUSAGE_THREAD, &end) < 0) { + error_setg_errno(errp, errno, "Unable to get thread CPU usage"); + return -1; + } + + delta = (((end.ru_utime.tv_sec * 1000ll) + + (end.ru_utime.tv_usec / 1000)) - + ((start.ru_utime.tv_sec * 1000ll) + + (start.ru_utime.tv_usec / 1000))); + + if (delta > 500) { + break; + } else if (delta < 100) { + iterations = iterations * 10; + } else { + iterations = (iterations * 1000 / delta); + } + } + + return iterations * 1000 / delta; +} diff --git a/include/crypto/pbkdf.h b/include/crypto/pbkdf.h new file mode 100644 index 0000000..a5e8267 --- /dev/null +++ b/include/crypto/pbkdf.h @@ -0,0 +1,152 @@ +/* + * QEMU Crypto PBKDF support (Password-Based Key Derivation Function) + * + * Copyright (c) 2015-2016 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#ifndef QCRYPTO_PBKDF_H__ +#define QCRYPTO_PBKDF_H__ + +#include "crypto/hash.h" + +/** + * This module provides an interface to the PBKDF2 algorithm + * + * https://en.wikipedia.org/wiki/PBKDF2 + * + * <example> + * <title>Generating a AES encryption key from a user password</title> + * <programlisting> + * #include "crypto/cipher.h" + * #include "crypto/random.h" + * #include "crypto/pbkdf.h" + * + * .... + * + * char *password = "a-typical-awful-user-password"; + * size_t nkey = qcrypto_cipher_get_key_len(QCRYPTO_CIPHER_ALG_AES_128); + * uint8_t *salt = g_new0(uint8_t, nkey); + * uint8_t *key = g_new0(uint8_t, nkey); + * int iterations; + * QCryptoCipher *cipher; + * + * if (qcrypto_random_bytes(salt, nkey, errp) < 0) { + * g_free(key); + * g_free(salt); + * return -1; + * } + * + * iterations = qcrypto_pbkdf2_count_iters(QCRYPTO_HASH_ALG_SHA256, + * (const uint8_t *)password, + * strlen(password), + * salt, nkey, errp); + * if (iterations < 0) { + * g_free(key); + * g_free(salt); + * return -1; + * } + * + * if (qcrypto_pbkdf2(QCRYPTO_HASH_ALG_SHA256, + * (const uint8_t *)password, strlen(password), + * salt, nkey, iterations, key, nkey, errp) < 0) { + * g_free(key); + * g_free(salt); + * return -1; + * } + * + * g_free(salt); + * + * cipher = qcrypto_cipher_new(QCRYPTO_CIPHER_ALG_AES_128, + * QCRYPTO_CIPHER_MODE_ECB, + * key, nkey, errp); + * g_free(key); + * + * ....encrypt some data... + * + * qcrypto_cipher_free(cipher); + * </programlisting> + * </example> + * + */ + +/** + * qcrypto_pbkdf2_supports: + * @hash: the hash algorithm + * + * Determine if the current build supports the PBKDF2 algorithm + * in combination with the hash @hash. + * + * Returns true if supported, false otherwise + */ +bool qcrypto_pbkdf2_supports(QCryptoHashAlgorithm hash); + + +/** + * qcrypto_pbkdf2: + * @hash: the hash algorithm to use + * @key: the user password / key + * @nkey: the length of @key in bytes + * @salt: a random salt + * @nsalt: length of @salt in bytes + * @iterations: the number of iterations to compute + * @out: pointer to pre-allocated buffer to hold output + * @nout: length of @out in bytes + * @errp: pointer to a NULL-initialized error object + * + * Apply the PBKDF2 algorithm to derive an encryption + * key from a user password provided in @key. The + * @salt parameter is used to perturb the algorithm. + * The @iterations count determines how many times + * the hashing process is run, which influences how + * hard it is to crack the key. The number of @iterations + * should be large enough such that the algorithm takes + * 1 second or longer to derive a key. The derived key + * will be stored in the preallocated buffer @out. + * + * Returns: 0 on success, -1 on error + */ +int qcrypto_pbkdf2(QCryptoHashAlgorithm hash, + const uint8_t *key, size_t nkey, + const uint8_t *salt, size_t nsalt, + unsigned int iterations, + uint8_t *out, size_t nout, + Error **errp); + +/** + * qcrypto_pbkdf2_count_iters: + * @hash: the hash algorithm to use + * @key: the user password / key + * @nkey: the length of @key in bytes + * @salt: a random salt + * @nsalt: length of @salt in bytes + * @errp: pointer to a NULL-initialized error object + * + * Time the PBKDF2 algorithm to determine how many + * iterations are required to derive an encryption + * key from a user password provided in @key in 1 + * second of compute time. The result of this can + * be used as a the @iterations parameter of a later + * call to qcrypto_pbkdf2(). + * + * Returns: number of iterations in 1 second, -1 on error + */ +int qcrypto_pbkdf2_count_iters(QCryptoHashAlgorithm hash, + const uint8_t *key, size_t nkey, + const uint8_t *salt, size_t nsalt, + Error **errp); + +#endif /* QCRYPTO_PBKDF_H__ */ diff --git a/tests/.gitignore b/tests/.gitignore index 787c95c..db6b9be 100644 --- a/tests/.gitignore +++ b/tests/.gitignore @@ -14,6 +14,7 @@ test-blockjob-txn test-coroutine test-crypto-cipher test-crypto-hash +test-crypto-pbkdf test-crypto-secret test-crypto-tlscredsx509 test-crypto-tlscredsx509-work/ diff --git a/tests/Makefile b/tests/Makefile index b7352f1..833a290 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -92,6 +92,7 @@ check-unit-$(CONFIG_GNUTLS) += tests/test-io-channel-tls$(EXESUF) check-unit-y += tests/test-io-channel-command$(EXESUF) check-unit-y += tests/test-io-channel-buffer$(EXESUF) check-unit-y += tests/test-base64$(EXESUF) +check-unit-y += tests/test-crypto-pbkdf$(EXESUF) check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh @@ -495,6 +496,7 @@ tests/test-io-channel-command$(EXESUF): tests/test-io-channel-command.o \ tests/io-channel-helpers.o $(test-io-obj-y) tests/test-io-channel-buffer$(EXESUF): tests/test-io-channel-buffer.o \ tests/io-channel-helpers.o $(test-io-obj-y) +tests/test-crypto-pbkdf$(EXESUF): tests/test-crypto-pbkdf.o $(test-crypto-obj-y) libqos-obj-y = tests/libqos/pci.o tests/libqos/fw_cfg.o tests/libqos/malloc.o libqos-obj-y += tests/libqos/i2c.o tests/libqos/libqos.o diff --git a/tests/test-crypto-pbkdf.c b/tests/test-crypto-pbkdf.c new file mode 100644 index 0000000..3e0e938 --- /dev/null +++ b/tests/test-crypto-pbkdf.c @@ -0,0 +1,378 @@ +/* + * QEMU Crypto cipher algorithms + * + * Copyright (c) 2015-2016 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#include <glib.h> + +#include "crypto/init.h" + +#if defined(CONFIG_NETTLE) || defined(CONFIG_GCRYPT) +#include "crypto/pbkdf.h" + +typedef struct QCryptoPbkdfTestData QCryptoPbkdfTestData; +struct QCryptoPbkdfTestData { + const char *path; + QCryptoHashAlgorithm hash; + unsigned int iterations; + const char *key; + size_t nkey; + const char *salt; + size_t nsalt; + const char *out; + size_t nout; +}; + +/* This test data comes from cryptsetup package + * + * $SRC/lib/crypto_backend/pbkdf2_generic.c + * + * under LGPLv2.1+ license + */ +static QCryptoPbkdfTestData test_data[] = { + /* RFC 3962 test data */ + { + .path = "/crypto/pbkdf/rfc3962/sha1/iter1", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 1, + .key = "password", + .nkey = 8, + .salt = "ATHENA.MIT.EDUraeburn", + .nsalt = 21, + .out = "\xcd\xed\xb5\x28\x1b\xb2\xf8\x01" + "\x56\x5a\x11\x22\xb2\x56\x35\x15" + "\x0a\xd1\xf7\xa0\x4b\xb9\xf3\xa3" + "\x33\xec\xc0\xe2\xe1\xf7\x08\x37", + .nout = 32 + }, + { + .path = "/crypto/pbkdf/rfc3962/sha1/iter2", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 2, + .key = "password", + .nkey = 8, + .salt = "ATHENA.MIT.EDUraeburn", + .nsalt = 21, + .out = "\x01\xdb\xee\x7f\x4a\x9e\x24\x3e" + "\x98\x8b\x62\xc7\x3c\xda\x93\x5d" + "\xa0\x53\x78\xb9\x32\x44\xec\x8f" + "\x48\xa9\x9e\x61\xad\x79\x9d\x86", + .nout = 32 + }, + { + .path = "/crypto/pbkdf/rfc3962/sha1/iter1200a", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 1200, + .key = "password", + .nkey = 8, + .salt = "ATHENA.MIT.EDUraeburn", + .nsalt = 21, + .out = "\x5c\x08\xeb\x61\xfd\xf7\x1e\x4e" + "\x4e\xc3\xcf\x6b\xa1\xf5\x51\x2b" + "\xa7\xe5\x2d\xdb\xc5\xe5\x14\x2f" + "\x70\x8a\x31\xe2\xe6\x2b\x1e\x13", + .nout = 32 + }, + { + .path = "/crypto/pbkdf/rfc3962/sha1/iter5", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 5, + .key = "password", + .nkey = 8, + .salt = "\0224VxxV4\022", /* "\x1234567878563412 */ + .nsalt = 8, + .out = "\xd1\xda\xa7\x86\x15\xf2\x87\xe6" + "\xa1\xc8\xb1\x20\xd7\x06\x2a\x49" + "\x3f\x98\xd2\x03\xe6\xbe\x49\xa6" + "\xad\xf4\xfa\x57\x4b\x6e\x64\xee", + .nout = 32 + }, + { + .path = "/crypto/pbkdf/rfc3962/sha1/iter1200b", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 1200, + .key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" + "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", + .nkey = 64, + .salt = "pass phrase equals block size", + .nsalt = 29, + .out = "\x13\x9c\x30\xc0\x96\x6b\xc3\x2b" + "\xa5\x5f\xdb\xf2\x12\x53\x0a\xc9" + "\xc5\xec\x59\xf1\xa4\x52\xf5\xcc" + "\x9a\xd9\x40\xfe\xa0\x59\x8e\xd1", + .nout = 32 + }, + { + .path = "/crypto/pbkdf/rfc3962/sha1/iter1200c", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 1200, + .key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" + "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", + .nkey = 65, + .salt = "pass phrase exceeds block size", + .nsalt = 30, + .out = "\x9c\xca\xd6\xd4\x68\x77\x0c\xd5" + "\x1b\x10\xe6\xa6\x87\x21\xbe\x61" + "\x1a\x8b\x4d\x28\x26\x01\xdb\x3b" + "\x36\xbe\x92\x46\x91\x5e\xc8\x2a", + .nout = 32 + }, + { + .path = "/crypto/pbkdf/rfc3962/sha1/iter50", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 50, + .key = "\360\235\204\236", /* g-clef ("\xf09d849e) */ + .nkey = 4, + .salt = "EXAMPLE.COMpianist", + .nsalt = 18, + .out = "\x6b\x9c\xf2\x6d\x45\x45\x5a\x43" + "\xa5\xb8\xbb\x27\x6a\x40\x3b\x39" + "\xe7\xfe\x37\xa0\xc4\x1e\x02\xc2" + "\x81\xff\x30\x69\xe1\xe9\x4f\x52", + .nout = 32 + }, + + /* RFC-6070 test data */ + { + .path = "/crypto/pbkdf/rfc6070/sha1/iter1", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 1, + .key = "password", + .nkey = 8, + .salt = "salt", + .nsalt = 4, + .out = "\x0c\x60\xc8\x0f\x96\x1f\x0e\x71\xf3\xa9" + "\xb5\x24\xaf\x60\x12\x06\x2f\xe0\x37\xa6", + .nout = 20 + }, + { + .path = "/crypto/pbkdf/rfc6070/sha1/iter2", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 2, + .key = "password", + .nkey = 8, + .salt = "salt", + .nsalt = 4, + .out = "\xea\x6c\x01\x4d\xc7\x2d\x6f\x8c\xcd\x1e" + "\xd9\x2a\xce\x1d\x41\xf0\xd8\xde\x89\x57", + .nout = 20 + }, + { + .path = "/crypto/pbkdf/rfc6070/sha1/iter4096", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 4096, + .key = "password", + .nkey = 8, + .salt = "salt", + .nsalt = 4, + .out = "\x4b\x00\x79\x01\xb7\x65\x48\x9a\xbe\xad" + "\x49\xd9\x26\xf7\x21\xd0\x65\xa4\x29\xc1", + .nout = 20 + }, + { + .path = "/crypto/pbkdf/rfc6070/sha1/iter16777216", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 16777216, + .key = "password", + .nkey = 8, + .salt = "salt", + .nsalt = 4, + .out = "\xee\xfe\x3d\x61\xcd\x4d\xa4\xe4\xe9\x94" + "\x5b\x3d\x6b\xa2\x15\x8c\x26\x34\xe9\x84", + .nout = 20 + }, + { + .path = "/crypto/pbkdf/rfc6070/sha1/iter4096a", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 4096, + .key = "passwordPASSWORDpassword", + .nkey = 24, + .salt = "saltSALTsaltSALTsaltSALTsaltSALTsalt", + .nsalt = 36, + .out = "\x3d\x2e\xec\x4f\xe4\x1c\x84\x9b\x80\xc8" + "\xd8\x36\x62\xc0\xe4\x4a\x8b\x29\x1a\x96" + "\x4c\xf2\xf0\x70\x38", + .nout = 25 + }, + { + .path = "/crypto/pbkdf/rfc6070/sha1/iter4096b", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 4096, + .key = "pass\0word", + .nkey = 9, + .salt = "sa\0lt", + .nsalt = 5, + .out = "\x56\xfa\x6a\xa7\x55\x48\x09\x9d\xcc\x37" + "\xd7\xf0\x34\x25\xe0\xc3", + .nout = 16 + }, + + /* non-RFC misc test data */ + { + /* empty password test */ + .path = "/crypto/pbkdf/nonrfc/sha1/iter2", + .hash = QCRYPTO_HASH_ALG_SHA1, + .iterations = 2, + .key = "", + .nkey = 0, + .salt = "salt", + .nsalt = 4, + .out = "\x13\x3a\x4c\xe8\x37\xb4\xd2\x52\x1e\xe2" + "\xbf\x03\xe1\x1c\x71\xca\x79\x4e\x07\x97", + .nout = 20 + }, { + /* Password exceeds block size test */ + .path = "/crypto/pbkdf/nonrfc/sha256/iter1200", + .hash = QCRYPTO_HASH_ALG_SHA256, + .iterations = 1200, + .key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" + "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", + .nkey = 65, + .salt = "pass phrase exceeds block size", + .nsalt = 30, + .out = "\x22\x34\x4b\xc4\xb6\xe3\x26\x75" + "\xa8\x09\x0f\x3e\xa8\x0b\xe0\x1d" + "\x5f\x95\x12\x6a\x2c\xdd\xc3\xfa" + "\xcc\x4a\x5e\x6d\xca\x04\xec\x58", + .nout = 32 + }, +#if 0 + { + .path = "/crypto/pbkdf/nonrfc/sha512/iter1200", + .hash = QCRYPTO_HASH_ALG_SHA512, + .iterations = 1200, + .key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" + "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" + "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" + "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", + .nkey = 129, + .salt = "pass phrase exceeds block size", + .nsalt = 30, + .out = "\x0f\xb2\xed\x2c\x0e\x6e\xfb\x7d" + "\x7d\x8e\xdd\x58\x01\xb4\x59\x72" + "\x99\x92\x16\x30\x5e\xa4\x36\x8d" + "\x76\x14\x80\xf3\xe3\x7a\x22\xb9", + .nout = 32 + }, + { + .path = "/crypto/pbkdf/nonrfc/whirlpool/iter1200", + .hash = QCRYPTO_HASH_ALG_WHIRLPOOL, + .iterations = 1200, + .key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" + "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", + .nkey = 65, + .salt = "pass phrase exceeds block size", + .nsalt = 30, + .out = "\x9c\x1c\x74\xf5\x88\x26\xe7\x6a" + "\x53\x58\xf4\x0c\x39\xe7\x80\x89" + "\x07\xc0\x31\x19\x9a\x50\xa2\x48" + "\xf1\xd9\xfe\x78\x64\xe5\x84\x50", + .nout = 32 + } +#endif +}; + + +static inline char hex(int i) +{ + if (i < 10) { + return '0' + i; + } + return 'a' + (i - 10); +} + +static char *hex_string(const uint8_t *bytes, + size_t len) +{ + char *hexstr = g_new0(char, len * 2 + 1); + size_t i; + + for (i = 0; i < len; i++) { + hexstr[i * 2] = hex((bytes[i] >> 4) & 0xf); + hexstr[i * 2 + 1] = hex(bytes[i] & 0xf); + } + hexstr[len * 2] = '\0'; + + return hexstr; +} + +static void test_pbkdf(const void *opaque) +{ + const QCryptoPbkdfTestData *data = opaque; + size_t nout = data->nout; + uint8_t *out = g_new0(uint8_t, nout); + gchar *expect, *actual; + + qcrypto_pbkdf2(data->hash, + (uint8_t *)data->key, data->nkey, + (uint8_t *)data->salt, data->nsalt, + data->iterations, + (uint8_t *)out, nout, + &error_abort); + + expect = hex_string((const uint8_t *)data->out, data->nout); + actual = hex_string(out, nout); + + g_assert_cmpstr(actual, ==, expect); + + g_free(actual); + g_free(expect); + g_free(out); +} + + +static void test_pbkdf_timing(void) +{ + uint8_t key[32]; + uint8_t salt[32]; + int iters; + + memset(key, 0x5d, sizeof(key)); + memset(salt, 0x7c, sizeof(salt)); + + iters = qcrypto_pbkdf2_count_iters(QCRYPTO_HASH_ALG_SHA256, + key, sizeof(key), + salt, sizeof(salt), + &error_abort); + + g_assert(iters >= (1 << 15)); +} + + +int main(int argc, char **argv) +{ + size_t i; + + g_test_init(&argc, &argv, NULL); + + g_assert(qcrypto_init(NULL) == 0); + + for (i = 0; i < G_N_ELEMENTS(test_data); i++) { + g_test_add_data_func(test_data[i].path, &test_data[i], test_pbkdf); + } + + g_test_add_func("/crypt/pbkdf/timing", test_pbkdf_timing); + + return g_test_run(); +} +#else +int main(int argc, char **argv) +{ + return 0; +} +#endif
The LUKS data format includes use of PBKDF2 (Password-Based Key Derivation Function). The Nettle library can provide an implementation of this, but we don't want code directly depending on a specific crypto library backend. Introduce a include/crypto/pbkdf.h header which defines a QEMU API for invoking PBKDK2. The initial implementations are backed by nettle & gcrypt, which are commonly available with distros shipping GNUTLS. The test suite data is taken from the cryptsetup codebase under the LGPLv2.1+ license. This merely aims to verify that whatever backend we provide for this function in QEMU will comply with the spec. Signed-off-by: Daniel P. Berrange <berrange@redhat.com> --- crypto/Makefile.objs | 6 +- crypto/pbkdf-gcrypt.c | 65 ++++++++ crypto/pbkdf-nettle.c | 64 ++++++++ crypto/pbkdf-stub.c | 41 +++++ crypto/pbkdf.c | 68 +++++++++ include/crypto/pbkdf.h | 152 +++++++++++++++++++ tests/.gitignore | 1 + tests/Makefile | 2 + tests/test-crypto-pbkdf.c | 378 ++++++++++++++++++++++++++++++++++++++++++++++ 9 files changed, 776 insertions(+), 1 deletion(-) create mode 100644 crypto/pbkdf-gcrypt.c create mode 100644 crypto/pbkdf-nettle.c create mode 100644 crypto/pbkdf-stub.c create mode 100644 crypto/pbkdf.c create mode 100644 include/crypto/pbkdf.h create mode 100644 tests/test-crypto-pbkdf.c