1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include "ecdh_helper.h"
24
25#include <linux/scatterlist.h>
26#include <crypto/ecdh.h>
27
28struct ecdh_completion {
29 struct completion completion;
30 int err;
31};
32
33static void ecdh_complete(struct crypto_async_request *req, int err)
34{
35 struct ecdh_completion *res = req->data;
36
37 if (err == -EINPROGRESS)
38 return;
39
40 res->err = err;
41 complete(&res->completion);
42}
43
44static inline void swap_digits(u64 *in, u64 *out, unsigned int ndigits)
45{
46 int i;
47
48 for (i = 0; i < ndigits; i++)
49 out[i] = __swab64(in[ndigits - 1 - i]);
50}
51
52
53
54
55
56
57
58
59
60int compute_ecdh_secret(struct crypto_kpp *tfm, const u8 public_key[64],
61 u8 secret[32])
62{
63 struct kpp_request *req;
64 u8 *tmp;
65 struct ecdh_completion result;
66 struct scatterlist src, dst;
67 int err;
68
69 tmp = kmalloc(64, GFP_KERNEL);
70 if (!tmp)
71 return -ENOMEM;
72
73 req = kpp_request_alloc(tfm, GFP_KERNEL);
74 if (!req) {
75 err = -ENOMEM;
76 goto free_tmp;
77 }
78
79 init_completion(&result.completion);
80
81 swap_digits((u64 *)public_key, (u64 *)tmp, 4);
82 swap_digits((u64 *)&public_key[32], (u64 *)&tmp[32], 4);
83
84 sg_init_one(&src, tmp, 64);
85 sg_init_one(&dst, secret, 32);
86 kpp_request_set_input(req, &src, 64);
87 kpp_request_set_output(req, &dst, 32);
88 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
89 ecdh_complete, &result);
90 err = crypto_kpp_compute_shared_secret(req);
91 if (err == -EINPROGRESS) {
92 wait_for_completion(&result.completion);
93 err = result.err;
94 }
95 if (err < 0) {
96 pr_err("alg: ecdh: compute shared secret failed. err %d\n",
97 err);
98 goto free_all;
99 }
100
101 swap_digits((u64 *)secret, (u64 *)tmp, 4);
102 memcpy(secret, tmp, 32);
103
104free_all:
105 kpp_request_free(req);
106free_tmp:
107 kfree_sensitive(tmp);
108 return err;
109}
110
111
112
113
114
115
116
117
118
119
120
121
122int set_ecdh_privkey(struct crypto_kpp *tfm, const u8 private_key[32])
123{
124 u8 *buf, *tmp = NULL;
125 unsigned int buf_len;
126 int err;
127 struct ecdh p = {0};
128
129 if (private_key) {
130 tmp = kmalloc(32, GFP_KERNEL);
131 if (!tmp)
132 return -ENOMEM;
133 swap_digits((u64 *)private_key, (u64 *)tmp, 4);
134 p.key = tmp;
135 p.key_size = 32;
136 }
137
138 buf_len = crypto_ecdh_key_len(&p);
139 buf = kmalloc(buf_len, GFP_KERNEL);
140 if (!buf) {
141 err = -ENOMEM;
142 goto free_tmp;
143 }
144
145 err = crypto_ecdh_encode_key(buf, buf_len, &p);
146 if (err)
147 goto free_all;
148
149 err = crypto_kpp_set_secret(tfm, buf, buf_len);
150
151free_all:
152 kfree_sensitive(buf);
153free_tmp:
154 kfree_sensitive(tmp);
155 return err;
156}
157
158
159
160
161
162
163
164
165
166int generate_ecdh_public_key(struct crypto_kpp *tfm, u8 public_key[64])
167{
168 struct kpp_request *req;
169 u8 *tmp;
170 struct ecdh_completion result;
171 struct scatterlist dst;
172 int err;
173
174 tmp = kmalloc(64, GFP_KERNEL);
175 if (!tmp)
176 return -ENOMEM;
177
178 req = kpp_request_alloc(tfm, GFP_KERNEL);
179 if (!req) {
180 err = -ENOMEM;
181 goto free_tmp;
182 }
183
184 init_completion(&result.completion);
185 sg_init_one(&dst, tmp, 64);
186 kpp_request_set_input(req, NULL, 0);
187 kpp_request_set_output(req, &dst, 64);
188 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
189 ecdh_complete, &result);
190
191 err = crypto_kpp_generate_public_key(req);
192 if (err == -EINPROGRESS) {
193 wait_for_completion(&result.completion);
194 err = result.err;
195 }
196 if (err < 0)
197 goto free_all;
198
199
200
201
202 swap_digits((u64 *)tmp, (u64 *)public_key, 4);
203 swap_digits((u64 *)&tmp[32], (u64 *)&public_key[32], 4);
204
205free_all:
206 kpp_request_free(req);
207free_tmp:
208 kfree(tmp);
209 return err;
210}
211
212
213
214
215
216
217
218
219int generate_ecdh_keys(struct crypto_kpp *tfm, u8 public_key[64])
220{
221 int err;
222
223 err = set_ecdh_privkey(tfm, NULL);
224 if (err)
225 return err;
226
227 return generate_ecdh_public_key(tfm, public_key);
228}
229