1From f20f3e1c7f498bbc2a83a749ed38a795d54a5c25 Mon Sep 17 00:00:00 2001
2From: Michael Forney <mforney@mforney.org>
3Date: Fri, 15 Nov 2019 20:19:37 -0800
4Subject: [PATCH] Add support for some BearSSL crypto primitives
5
6---
7 src/crypto/crypto_bearssl.c | 171 ++++++++++++++++++++++++++++++++++++
8 1 file changed, 171 insertions(+)
9 create mode 100644 src/crypto/crypto_bearssl.c
10
11diff --git a/src/crypto/crypto_bearssl.c b/src/crypto/crypto_bearssl.c
12new file mode 100644
13index 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--
1892.45.2
190
