Revision 1990ae634d0602ff022afc946ef66933e4e4a2dc authored by Santiago Zanella-Beguelin on 09 December 2019, 17:48:55 UTC, committed by Santiago Zanella-Beguelin on 09 December 2019, 17:50:10 UTC
1 parent ae8e182
evercrypt_bcrypt.c
/* BCrypt is only available on Windows platforms */
#if defined(_MSC_VER) || defined(__MINGW32__)
#define IS_WINDOWS 1
#ifdef _KERNEL_MODE
#include <nt.h>
#include <ntrtl.h>
#else
#include <windows.h>
#endif
#include <bcrypt.h>
#ifndef BCRYPT_AES_GCM_ALG_HANDLE
#define BCRYPT_AES_GCM_ALG_HANDLE ((BCRYPT_ALG_HANDLE) 0x000001e1)
#endif
#ifndef NT_SUCCESS
#define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0)
#endif
#else
#define IS_WINDOWS 0
#include <unistd.h>
#endif
#include <fcntl.h>
#include <inttypes.h>
#include "kremlin/internal/target.h"
#include "EverCrypt_BCrypt.h"
/* KB, BB, JP: for now, we just ignore internal errors since the HACL* interface
* has enough preconditions to make sure that no errors ever happen; if the
* OpenSSL F* interface is strong enough, then any error here should be
* catastrophic and not something we can recover from.
* If we want to do something better, we can define:
* type error a = | Ok of a | Error of error_code
* Then at the boundary we could catch the error, print it, then exit abruptly.
* */
#define handleErrors(...) \
do { \
fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); \
} while (0)
#if IS_WINDOWS
static BCRYPT_ALG_HANDLE g_hAlgRandom = NULL;
static uint32_t bcrypt_rng_init(void)
{
NTSTATUS st = BCryptOpenAlgorithmProvider(
&g_hAlgRandom,
BCRYPT_RNG_ALGORITHM,
NULL,
#ifdef _KERNEL_MODE
BCRYPT_PROV_DISPATCH
#else
0
#endif
);
if (!NT_SUCCESS(st)) {
return 0;
}
return 1;
}
static void bcrypt_rng_sample(uint32_t len, uint8_t *out)
{
NTSTATUS st;
/* Try to lazily initialize the RNG if it wasn't done
* by the user. If it fails, the app crashes. */
if(g_hAlgRandom == NULL)
{
if(!bcrypt_rng_init())
handleErrors();
}
st = BCryptGenRandom(g_hAlgRandom, out, len, 0);
if (!NT_SUCCESS(st)) {
handleErrors();
}
}
static void bcrypt_rng_cleanup(void)
{
BCryptCloseAlgorithmProvider(g_hAlgRandom, 0);
}
static BCRYPT_KEY_HANDLE bcrypt_create(BCRYPT_ALG_HANDLE alg, uint8_t *key, ULONG key_size)
{
NTSTATUS s;
BCRYPT_KEY_HANDLE hKey = NULL;
s = BCryptGenerateSymmetricKey(alg, &hKey, NULL, 0, key, key_size, 0);
if(!NT_SUCCESS(s)) handleErrors();
return hKey;
}
static uint32_t bcrypt_aead(BCRYPT_KEY_HANDLE hKey,
int enc, uint8_t *iv,
uint8_t *aad, uint32_t aad_len,
uint8_t *plaintext, uint32_t plaintext_len,
uint8_t *ciphertext, uint8_t *tag)
{
BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO Info;
NTSTATUS s;
ULONG OutSize;
BCRYPT_INIT_AUTH_MODE_INFO(Info);
Info.pbAuthData = (PUCHAR) aad;
Info.cbAuthData = aad_len;
Info.pbTag = tag;
Info.cbTag = 16;
Info.pbNonce = iv;
Info.cbNonce = 12;
if(enc)
s = BCryptEncrypt(hKey, plaintext, plaintext_len, &Info, iv, 12, ciphertext, plaintext_len, &OutSize, 0);
else
s = BCryptDecrypt(hKey, ciphertext, plaintext_len, &Info, iv, 12, plaintext, plaintext_len, &OutSize, 0);
if (!NT_SUCCESS(s))
return 0;
return 1;
}
static void bcrypt_free(BCRYPT_KEY_HANDLE hKey)
{
BCryptDestroyKey(hKey);
}
#else /* IS_WINDOWS */
#define BCRYPT_KEY_HANDLE void*
#define BCRYPT_ALG_HANDLE uint8_t
#define BCRYPT_AES_GCM_ALG_HANDLE 0
static uint32_t bcrypt_rng_init(void)
{
return 0;
}
static void bcrypt_rng_sample(uint32_t len, uint8_t *out)
{
handleErrors();
}
static void bcrypt_rng_cleanup(void)
{
handleErrors();
}
static BCRYPT_KEY_HANDLE bcrypt_create(BCRYPT_ALG_HANDLE alg, uint8_t key, ULONG key_size)
{
return NULL;
}
static uint32_t bcrypt_aead(BCRYPT_KEY_HANDLE hKey,
int enc, uint8_t *iv,
uint8_t *aad, uint32_t aad_len,
uint8_t *plaintext, uint32_t plaintext_len,
uint8_t *ciphertext, uint8_t *tag)
{
return 0;
}
static void bcrypt_free(BCRYPT_KEY_HANDLE hKey)
{
}
#endif /* IS_WINDOWS */
uint32_t EverCrypt_BCrypt_random_init(void)
{
return bcrypt_rng_init();
}
void EverCrypt_BCrypt_random_sample(uint32_t len, uint8_t *out)
{
bcrypt_rng_sample(len, out);
}
void EverCrypt_BCrypt_random_cleanup(void)
{
bcrypt_rng_cleanup();
}
void EverCrypt_BCrypt_aes128_gcm_encrypt(uint8_t *key, uint8_t *iv, uint8_t *aad, uint32_t aad_len,
uint8_t *plaintext, uint32_t plaintext_len, uint8_t *ciphertext, uint8_t *tag)
{
BCRYPT_KEY_HANDLE hKey = bcrypt_create(BCRYPT_AES_GCM_ALG_HANDLE, key, 16);
if(NULL == hKey || 1 != bcrypt_aead(hKey, 1, iv, aad, aad_len, plaintext, plaintext_len, ciphertext, tag))
handleErrors();
bcrypt_free(hKey);
}
uint32_t EverCrypt_BCrypt_aes128_gcm_decrypt(uint8_t *key, uint8_t *iv, uint8_t *aad, uint32_t aad_len,
uint8_t *plaintext, uint32_t plaintext_len, uint8_t *ciphertext, uint8_t *tag)
{
BCRYPT_KEY_HANDLE hKey = bcrypt_create(BCRYPT_AES_GCM_ALG_HANDLE, key, 16);
if(hKey == NULL) return 0;
uint32_t ret = bcrypt_aead(hKey, 0, iv, aad, aad_len, plaintext, plaintext_len, ciphertext, tag);
bcrypt_free(hKey);
return ret;
}
void EverCrypt_BCrypt_aes256_gcm_encrypt(uint8_t *key, uint8_t *iv, uint8_t *aad, uint32_t aad_len,
uint8_t *plaintext, uint32_t plaintext_len, uint8_t *ciphertext, uint8_t *tag)
{
BCRYPT_KEY_HANDLE hKey = bcrypt_create(BCRYPT_AES_GCM_ALG_HANDLE, key, 32);
if(NULL == hKey || 1 != bcrypt_aead(hKey, 1, iv, aad, aad_len, plaintext, plaintext_len, ciphertext, tag))
handleErrors();
bcrypt_free(hKey);
}
uint32_t EverCrypt_BCrypt_aes256_gcm_decrypt(uint8_t *key, uint8_t *iv, uint8_t *aad, uint32_t aad_len,
uint8_t *plaintext, uint32_t plaintext_len, uint8_t *ciphertext, uint8_t *tag)
{
uint32_t ret;
BCRYPT_KEY_HANDLE hKey = bcrypt_create(BCRYPT_AES_GCM_ALG_HANDLE, key, 32);
if(hKey == NULL) return 0;
ret = bcrypt_aead(hKey, 0, iv, aad, aad_len, plaintext, plaintext_len, ciphertext, tag);
bcrypt_free(hKey);
return ret;
}
void* EverCrypt_BCrypt_aead_create(uint8_t alg, uint8_t *key)
{
BCRYPT_KEY_HANDLE hKey = bcrypt_create(BCRYPT_AES_GCM_ALG_HANDLE, key, alg ? 32 : 16);
if(hKey == NULL) handleErrors();
return (void*)hKey;
}
void EverCrypt_BCrypt_aead_encrypt(void* hKey, uint8_t *iv, uint8_t *aad, uint32_t aad_len,
uint8_t *plaintext, uint32_t plaintext_len, uint8_t *ciphertext, uint8_t *tag)
{
bcrypt_aead((BCRYPT_KEY_HANDLE)hKey, 1, iv, aad, aad_len, plaintext, plaintext_len, ciphertext, tag);
}
uint32_t EverCrypt_BCrypt_aead_decrypt(void* hKey, uint8_t *iv, uint8_t *aad, uint32_t aad_len,
uint8_t *plaintext, uint32_t plaintext_len, uint8_t *ciphertext, uint8_t *tag)
{
return bcrypt_aead((BCRYPT_KEY_HANDLE)hKey, 0, iv, aad, aad_len, plaintext, plaintext_len, ciphertext, tag);
}
void EverCrypt_BCrypt_aead_free(void* hKey)
{
bcrypt_free((BCRYPT_KEY_HANDLE)hKey);
}
![swh spinner](/static/img/swh-spinner.gif)
Computing file changes ...