logo

oasis

Own branch of Oasis Linux (upstream: <https://git.sr.ht/~mcf/oasis/>) git clone https://anongit.hacktivis.me/git/oasis.git

0004-Add-support-for-some-BearSSL-crypto-primitives.patch (4890B)

    

  1. From f20f3e1c7f498bbc2a83a749ed38a795d54a5c25 Mon Sep 17 00:00:00 2001
  2. From: Michael Forney <mforney@mforney.org>
  3. Date: Fri, 15 Nov 2019 20:19:37 -0800
  4. Subject: [PATCH] Add support for some BearSSL crypto primitives
  6. ---
  7.  src/crypto/crypto_bearssl.c | 171 ++++++++++++++++++++++++++++++++++++
  8.  1 file changed, 171 insertions(+)
  9.  create mode 100644 src/crypto/crypto_bearssl.c
  11. diff --git a/src/crypto/crypto_bearssl.c b/src/crypto/crypto_bearssl.c
  12. new file mode 100644
  13. index 000000000..4f1b64e24
  14. --- /dev/null
  15. +++ b/src/crypto/crypto_bearssl.c
  16. @@ -0,0 +1,171 @@
  17. +/*
  18. + * Wrapper functions for BearSSL crypto
  19. + * Copyright (c) 2019, Michael Forney <mforney@mforney.org>
  20. + *
  21. + * This software may be distributed under the terms of the BSD license.
  22. + * See README for more details.
  23. + */
  24. +
  25. +#include "includes.h"
  26. +#include <bearssl.h>
  27. +
  28. +#include "common.h"
  29. +#include "md5.h"
  30. +#include "crypto.h"
  31. +
  32. +static int digest_vector(size_t num_elem, const u8 *addr[], const size_t *len,
  33. +			 u8 *out, const br_hash_class *hash)
  34. +{
  35. +	br_hash_compat_context ctx;
  36. +	size_t i;
  37. +
  38. +	hash->init(&ctx.vtable);
  39. +	for (i = 0; i < num_elem; ++i)
  40. +		hash->update(&ctx.vtable, addr[i], len[i]);
  41. +	hash->out(&ctx.vtable, out);
  42. +
  43. +	return 0;
  44. +}
  45. +
  46. +int sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *out)
  47. +{
  48. +	return digest_vector(num_elem, addr, len, out, &br_sha1_vtable);
  49. +}
  50. +
  51. +int sha256_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *out)
  52. +{
  53. +	return digest_vector(num_elem, addr, len, out, &br_sha256_vtable);
  54. +}
  55. +
  56. +static int hmac_vector(const u8 *key, size_t key_len, size_t num_elem,
  57. +                       const u8 *addr[], const size_t *len, u8 *mac,
  58. +                       const br_hash_class *type)
  59. +{
  60. +	br_hmac_key_context kc;
  61. +	br_hmac_context ctx;
  62. +	size_t i;
  63. +
  64. +	br_hmac_key_init(&kc, type, key, key_len);
  65. +	br_hmac_init(&ctx, &kc, 0);
  66. +	for (i = 0; i < num_elem; ++i)
  67. +		br_hmac_update(&ctx, addr[i], len[i]);
  68. +	br_hmac_out(&ctx, mac);
  69. +
  70. +	return 0;
  71. +}
  72. +
  73. +int hmac_sha256_vector(const u8 *key, size_t key_len, size_t num_elem,
  74. +                       const u8 *addr[], const size_t *len, u8 *mac)
  75. +{
  76. +	return hmac_vector(key, key_len, num_elem, addr, len, mac, &br_sha256_vtable);
  77. +}
  78. +
  79. +int hmac_sha256(const u8 *key, size_t key_len, const u8 *data,
  80. +		size_t data_len, u8 *mac)
  81. +{
  82. +	return hmac_sha256_vector(key, key_len, 1, &data, &data_len, mac);
  83. +}
  84. +
  85. +int hmac_sha1_vector(const u8 *key, size_t key_len, size_t num_elem,
  86. +                     const u8 *addr[], const size_t *len, u8 *mac)
  87. +{
  88. +	return hmac_vector(key, key_len, num_elem, addr, len, mac, &br_sha1_vtable);
  89. +}
  90. +
  91. +int hmac_sha1(const u8 *key, size_t key_len, const u8 *data, size_t data_len,
  92. +	       u8 *mac)
  93. +{
  94. +	return hmac_sha1_vector(key, key_len, 1, &data, &data_len, mac);
  95. +}
  96. +
  97. +int hmac_md5(const u8 *key, size_t key_len, const u8 *data, size_t data_len,
  98. +             u8 *mac)
  99. +{
  100. +	return hmac_vector(key, key_len, 1, &data, &data_len, mac, &br_md5_vtable);
  101. +}
  102. +
  103. +void *aes_encrypt_init(const u8 *key, size_t len)
  104. +{
  105. +	br_aes_ct64_cbcenc_keys *ctx;
  106. +
  107. +	if (len != 16 && len != 24 && len != 32)
  108. +		return NULL;
  109. +	ctx = os_malloc(sizeof *ctx);
  110. +	if (ctx == NULL)
  111. +		return NULL;
  112. +	br_aes_ct64_cbcenc_init(ctx, key, len);
  113. +	return ctx;
  114. +}
  115. +
  116. +int aes_encrypt(void *ctx, const u8 *plain, u8 *crypt)
  117. +{
  118. +	unsigned char iv[br_aes_ct64_BLOCK_SIZE];
  119. +
  120. +	memset(iv, 0, sizeof iv);
  121. +	memcpy(crypt, plain, br_aes_ct64_BLOCK_SIZE);
  122. +	br_aes_ct64_cbcenc_run(ctx, iv, crypt, br_aes_ct64_BLOCK_SIZE);
  123. +	return 0;
  124. +}
  125. +
  126. +void aes_encrypt_deinit(void *ctx)
  127. +{
  128. +	os_free(ctx);
  129. +}
  130. +
  131. +void *aes_decrypt_init(const u8 *key, size_t len)
  132. +{
  133. +	br_aes_ct64_cbcdec_keys *ctx;
  134. +
  135. +	if (len != 16 && len != 24 && len != 32)
  136. +		return NULL;
  137. +	ctx = os_malloc(sizeof *ctx);
  138. +	if (ctx == NULL)
  139. +		return NULL;
  140. +	br_aes_ct64_cbcdec_init(ctx, key, len);
  141. +	return ctx;
  142. +}
  143. +
  144. +int aes_decrypt(void *ctx, const u8 *plain, u8 *crypt)
  145. +{
  146. +	unsigned char iv[br_aes_ct64_BLOCK_SIZE];
  147. +
  148. +	memset(iv, 0, sizeof iv);
  149. +	memcpy(crypt, plain, br_aes_ct64_BLOCK_SIZE);
  150. +	br_aes_ct64_cbcdec_run(ctx, iv, crypt, br_aes_ct64_BLOCK_SIZE);
  151. +	return 0;
  152. +}
  153. +
  154. +void aes_decrypt_deinit(void *ctx)
  155. +{
  156. +	os_free(ctx);
  157. +}
  158. +
  159. +int aes_128_cbc_encrypt(const u8 *key, const u8 *iv, u8 *data, size_t data_len)
  160. +{
  161. +	br_aes_ct64_cbcenc_keys ctx;
  162. +	u8 ivbuf[br_aes_ct64_BLOCK_SIZE];
  163. +
  164. +	if (data_len & 0xF)
  165. +		return -1;
  166. +	memcpy(ivbuf, iv, sizeof ivbuf);
  167. +	br_aes_ct64_cbcenc_init(&ctx, key, 16);
  168. +	br_aes_ct64_cbcenc_run(&ctx, ivbuf, data, data_len);
  169. +	return 0;
  170. +}
  171. +
  172. +int aes_128_cbc_decrypt(const u8 *key, const u8 *iv, u8 *data, size_t data_len)
  173. +{
  174. +	br_aes_ct64_cbcdec_keys ctx;
  175. +	u8 ivbuf[br_aes_ct64_BLOCK_SIZE];
  176. +
  177. +	if (data_len & 0xF)
  178. +		return -1;
  179. +	memcpy(ivbuf, iv, sizeof ivbuf);
  180. +	br_aes_ct64_cbcdec_init(&ctx, key, 16);
  181. +	br_aes_ct64_cbcdec_run(&ctx, ivbuf, data, data_len);
  182. +	return 0;
  183. +}
  184. +
  185. +void crypto_unload(void)
  186. +{
  187. +}
  188. -- 
  189. 2.45.2