include/crypto/pbkdf.h

   1 /*
   2  * QEMU Crypto PBKDF support (Password-Based Key Derivation Function)
   3  *
   4  * Copyright (c) 2015-2016 Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #ifndef QCRYPTO_PBKDF_H
  22 #define QCRYPTO_PBKDF_H
  23
  24 #include "crypto/hash.h"
  25
  26 /**
  27  * This module provides an interface to the PBKDF2 algorithm
  28  *
  29  *   https://en.wikipedia.org/wiki/PBKDF2
  30  *
  31  * <example>
  32  *   <title>Generating an AES encryption key from a user password</title>
  33  *   <programlisting>
  34  * #include "crypto/cipher.h"
  35  * #include "crypto/random.h"
  36  * #include "crypto/pbkdf.h"
  37  *
  38  * ....
  39  *
  40  * char *password = "a-typical-awful-user-password";
  41  * size_t nkey = qcrypto_cipher_get_key_len(QCRYPTO_CIPHER_ALG_AES_128);
  42  * uint8_t *salt = g_new0(uint8_t, nkey);
  43  * uint8_t *key = g_new0(uint8_t, nkey);
  44  * int iterations;
  45  * QCryptoCipher *cipher;
  46  *
  47  * if (qcrypto_random_bytes(salt, nkey, errp) < 0) {
  48  *     g_free(key);
  49  *     g_free(salt);
  50  *     return -1;
  51  * }
  52  *
  53  * iterations = qcrypto_pbkdf2_count_iters(QCRYPTO_HASH_ALG_SHA256,
  54  *                                         (const uint8_t *)password,
  55  *                                         strlen(password),
  56  *                                         salt, nkey, errp);
  57  * if (iterations < 0) {
  58  *     g_free(key);
  59  *     g_free(salt);
  60  *     return -1;
  61  * }
  62  *
  63  * if (qcrypto_pbkdf2(QCRYPTO_HASH_ALG_SHA256,
  64  *                    (const uint8_t *)password, strlen(password),
  65  *                    salt, nkey, iterations, key, nkey, errp) < 0) {
  66  *     g_free(key);
  67  *     g_free(salt);
  68  *     return -1;
  69  * }
  70  *
  71  * g_free(salt);
  72  *
  73  * cipher = qcrypto_cipher_new(QCRYPTO_CIPHER_ALG_AES_128,
  74  *                             QCRYPTO_CIPHER_MODE_ECB,
  75  *                             key, nkey, errp);
  76  * g_free(key);
  77  *
  78  * ....encrypt some data...
  79  *
  80  * qcrypto_cipher_free(cipher);
  81  *   </programlisting>
  82  * </example>
  83  *
  84  */
  85
  86 /**
  87  * qcrypto_pbkdf2_supports:
  88  * @hash: the hash algorithm
  89  *
  90  * Determine if the current build supports the PBKDF2 algorithm
  91  * in combination with the hash @hash.
  92  *
  93  * Returns true if supported, false otherwise
  94  */
  95 bool qcrypto_pbkdf2_supports(QCryptoHashAlgorithm hash);
  96
  97
  98 /**
  99  * qcrypto_pbkdf2:
 100  * @hash: the hash algorithm to use
 101  * @key: the user password / key
 102  * @nkey: the length of @key in bytes
 103  * @salt: a random salt
 104  * @nsalt: length of @salt in bytes
 105  * @iterations: the number of iterations to compute
 106  * @out: pointer to pre-allocated buffer to hold output
 107  * @nout: length of @out in bytes
 108  * @errp: pointer to a NULL-initialized error object
 109  *
 110  * Apply the PBKDF2 algorithm to derive an encryption
 111  * key from a user password provided in @key. The
 112  * @salt parameter is used to perturb the algorithm.
 113  * The @iterations count determines how many times
 114  * the hashing process is run, which influences how
 115  * hard it is to crack the key. The number of @iterations
 116  * should be large enough such that the algorithm takes
 117  * 1 second or longer to derive a key. The derived key
 118  * will be stored in the preallocated buffer @out.
 119  *
 120  * Returns: 0 on success, -1 on error
 121  */
 122 int qcrypto_pbkdf2(QCryptoHashAlgorithm hash,
 123                    const uint8_t *key, size_t nkey,
 124                    const uint8_t *salt, size_t nsalt,
 125                    uint64_t iterations,
 126                    uint8_t *out, size_t nout,
 127                    Error **errp);
 128
 129 /**
 130  * qcrypto_pbkdf2_count_iters:
 131  * @hash: the hash algorithm to use
 132  * @key: the user password / key
 133  * @nkey: the length of @key in bytes
 134  * @salt: a random salt
 135  * @nsalt: length of @salt in bytes
 136  * @nout: size of desired derived key
 137  * @errp: pointer to a NULL-initialized error object
 138  *
 139  * Time the PBKDF2 algorithm to determine how many
 140  * iterations are required to derive an encryption
 141  * key from a user password provided in @key in 1
 142  * second of compute time. The result of this can
 143  * be used as a the @iterations parameter of a later
 144  * call to qcrypto_pbkdf2(). The value of @nout should
 145  * match that value that will later be provided with
 146  * a call to qcrypto_pbkdf2().
 147  *
 148  * Returns: number of iterations in 1 second, -1 on error
 149  */
 150 uint64_t qcrypto_pbkdf2_count_iters(QCryptoHashAlgorithm hash,
 151                                     const uint8_t *key, size_t nkey,
 152                                     const uint8_t *salt, size_t nsalt,
 153                                     size_t nout,
 154                                     Error **errp);
 155
 156 #endif /* QCRYPTO_PBKDF_H */