ecdh_helper.c (168ed65483a1777c2570f4c0a4a64e20a823cf25) ecdh_helper.c (c0153b0b901a16663ff91504fea25fb51d57cc29)
1/*
2 * ECDH helper functions - KPP wrappings
3 *
4 * Copyright (C) 2017 Intel Corporation
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation;

--- 35 unchanged lines hidden (view full) ---

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
1/*
2 * ECDH helper functions - KPP wrappings
3 *
4 * Copyright (C) 2017 Intel Corporation
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation;

--- 35 unchanged lines hidden (view full) ---

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/* compute_ecdh_secret() - function assumes that the private key was
53 * already set.
54 * @tfm: KPP tfm handle allocated with crypto_alloc_kpp().
55 * @public_key: pair's ecc public key.
56 * secret: memory where the ecdh computed shared secret will be saved.
57 *
58 * Return: zero on success; error code in case of error.
59 */
52int compute_ecdh_secret(struct crypto_kpp *tfm, const u8 public_key[64],
60int compute_ecdh_secret(struct crypto_kpp *tfm, const u8 public_key[64],
53 const u8 private_key[32], u8 secret[32])
61 u8 secret[32])
54{
55 struct kpp_request *req;
62{
63 struct kpp_request *req;
56 struct ecdh p;
64 u8 *tmp;
57 struct ecdh_completion result;
58 struct scatterlist src, dst;
65 struct ecdh_completion result;
66 struct scatterlist src, dst;
59 u8 *tmp, *buf;
60 unsigned int buf_len;
61 int err;
62
63 tmp = kmalloc(64, GFP_KERNEL);
64 if (!tmp)
65 return -ENOMEM;
66
67 req = kpp_request_alloc(tfm, GFP_KERNEL);
68 if (!req) {
69 err = -ENOMEM;
70 goto free_tmp;
71 }
72
73 init_completion(&result.completion);
74
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
75 /* Security Manager Protocol holds digits in litte-endian order
76 * while ECC API expect big-endian data
77 */
78 swap_digits((u64 *)private_key, (u64 *)tmp, 4);
79 p.key = (char *)tmp;
80 p.key_size = 32;
81 /* Set curve_id */
82 p.curve_id = ECC_CURVE_NIST_P256;
83 buf_len = crypto_ecdh_key_len(&p);
84 buf = kmalloc(buf_len, GFP_KERNEL);
85 if (!buf) {
86 err = -ENOMEM;
87 goto free_req;
88 }
89
90 crypto_ecdh_encode_key(buf, buf_len, &p);
91
92 /* Set A private Key */
93 err = crypto_kpp_set_secret(tfm, (void *)buf, buf_len);
94 if (err)
95 goto free_all;
96
97 swap_digits((u64 *)public_key, (u64 *)tmp, 4); /* x */
98 swap_digits((u64 *)&public_key[32], (u64 *)&tmp[32], 4); /* y */
99
100 sg_init_one(&src, tmp, 64);
101 sg_init_one(&dst, secret, 32);
102 kpp_request_set_input(req, &src, 64);
103 kpp_request_set_output(req, &dst, 32);
104 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,

--- 8 unchanged lines hidden (view full) ---

113 err);
114 goto free_all;
115 }
116
117 swap_digits((u64 *)secret, (u64 *)tmp, 4);
118 memcpy(secret, tmp, 32);
119
120free_all:
81 swap_digits((u64 *)public_key, (u64 *)tmp, 4); /* x */
82 swap_digits((u64 *)&public_key[32], (u64 *)&tmp[32], 4); /* y */
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,

--- 8 unchanged lines hidden (view full) ---

97 err);
98 goto free_all;
99 }
100
101 swap_digits((u64 *)secret, (u64 *)tmp, 4);
102 memcpy(secret, tmp, 32);
103
104free_all:
121 kzfree(buf);
122free_req:
123 kpp_request_free(req);
124free_tmp:
125 kzfree(tmp);
126 return err;
127}
128
105 kpp_request_free(req);
106free_tmp:
107 kzfree(tmp);
108 return err;
109}
110
129int generate_ecdh_keys(struct crypto_kpp *tfm, u8 public_key[64],
130 u8 private_key[32])
111/* set_ecdh_privkey() - set or generate ecc private key.
112 *
113 * Function generates an ecc private key in the crypto subsystem when receiving
114 * a NULL private key or sets the received key when not NULL.
115 *
116 * @tfm: KPP tfm handle allocated with crypto_alloc_kpp().
117 * @private_key: user's ecc private key. When not NULL, the key is expected
118 * in little endian format.
119 *
120 * Return: zero on success; error code in case of error.
121 */
122int set_ecdh_privkey(struct crypto_kpp *tfm, const u8 private_key[32])
131{
123{
124 u8 *buf, *tmp = NULL;
125 unsigned int buf_len;
126 int err;
127 struct ecdh p = {0};
128
129 p.curve_id = ECC_CURVE_NIST_P256;
130
131 if (private_key) {
132 tmp = kmalloc(32, GFP_KERNEL);
133 if (!tmp)
134 return -ENOMEM;
135 swap_digits((u64 *)private_key, (u64 *)tmp, 4);
136 p.key = tmp;
137 p.key_size = 32;
138 }
139
140 buf_len = crypto_ecdh_key_len(&p);
141 buf = kmalloc(buf_len, GFP_KERNEL);
142 if (!buf) {
143 err = -ENOMEM;
144 goto free_tmp;
145 }
146
147 err = crypto_ecdh_encode_key(buf, buf_len, &p);
148 if (err)
149 goto free_all;
150
151 err = crypto_kpp_set_secret(tfm, buf, buf_len);
152 /* fall through */
153free_all:
154 kzfree(buf);
155free_tmp:
156 kzfree(tmp);
157 return err;
158}
159
160/* generate_ecdh_public_key() - function assumes that the private key was
161 * already set.
162 *
163 * @tfm: KPP tfm handle allocated with crypto_alloc_kpp().
164 * @public_key: memory where the computed ecc public key will be saved.
165 *
166 * Return: zero on success; error code in case of error.
167 */
168int generate_ecdh_public_key(struct crypto_kpp *tfm, u8 public_key[64])
169{
132 struct kpp_request *req;
170 struct kpp_request *req;
133 struct ecdh p;
171 u8 *tmp;
134 struct ecdh_completion result;
135 struct scatterlist dst;
172 struct ecdh_completion result;
173 struct scatterlist dst;
136 u8 *tmp, *buf;
137 unsigned int buf_len;
138 int err;
174 int err;
139 const unsigned short max_tries = 16;
140 unsigned short tries = 0;
141
142 tmp = kmalloc(64, GFP_KERNEL);
143 if (!tmp)
144 return -ENOMEM;
145
146 req = kpp_request_alloc(tfm, GFP_KERNEL);
147 if (!req) {
148 err = -ENOMEM;
149 goto free_tmp;
150 }
151
152 init_completion(&result.completion);
175
176 tmp = kmalloc(64, GFP_KERNEL);
177 if (!tmp)
178 return -ENOMEM;
179
180 req = kpp_request_alloc(tfm, GFP_KERNEL);
181 if (!req) {
182 err = -ENOMEM;
183 goto free_tmp;
184 }
185
186 init_completion(&result.completion);
187 sg_init_one(&dst, tmp, 64);
188 kpp_request_set_input(req, NULL, 0);
189 kpp_request_set_output(req, &dst, 64);
190 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
191 ecdh_complete, &result);
153
192
154 /* Set curve_id */
155 p.curve_id = ECC_CURVE_NIST_P256;
156 p.key_size = 32;
157 buf_len = crypto_ecdh_key_len(&p);
158 buf = kmalloc(buf_len, GFP_KERNEL);
159 if (!buf)
160 goto free_req;
193 err = crypto_kpp_generate_public_key(req);
194 if (err == -EINPROGRESS) {
195 wait_for_completion(&result.completion);
196 err = result.err;
197 }
198 if (err < 0)
199 goto free_all;
161
200
162 do {
163 if (tries++ >= max_tries)
164 goto free_all;
165
166 /* Set private Key */
167 p.key = (char *)private_key;
168 crypto_ecdh_encode_key(buf, buf_len, &p);
169 err = crypto_kpp_set_secret(tfm, buf, buf_len);
170 if (err)
171 goto free_all;
172
173 sg_init_one(&dst, tmp, 64);
174 kpp_request_set_input(req, NULL, 0);
175 kpp_request_set_output(req, &dst, 64);
176 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
177 ecdh_complete, &result);
178
179 err = crypto_kpp_generate_public_key(req);
180
181 if (err == -EINPROGRESS) {
182 wait_for_completion(&result.completion);
183 err = result.err;
184 }
185
186 /* Private key is not valid. Regenerate */
187 if (err == -EINVAL)
188 continue;
189
190 if (err < 0)
191 goto free_all;
192 else
193 break;
194
195 } while (true);
196
197 /* Keys are handed back in little endian as expected by Security
198 * Manager Protocol
201 /* The public key is handed back in little endian as expected by
202 * the Security Manager Protocol.
199 */
200 swap_digits((u64 *)tmp, (u64 *)public_key, 4); /* x */
201 swap_digits((u64 *)&tmp[32], (u64 *)&public_key[32], 4); /* y */
203 */
204 swap_digits((u64 *)tmp, (u64 *)public_key, 4); /* x */
205 swap_digits((u64 *)&tmp[32], (u64 *)&public_key[32], 4); /* y */
202 swap_digits((u64 *)private_key, (u64 *)tmp, 4);
203 memcpy(private_key, tmp, 32);
204
205free_all:
206
207free_all:
206 kzfree(buf);
207free_req:
208 kpp_request_free(req);
209free_tmp:
210 kfree(tmp);
211 return err;
212}
208 kpp_request_free(req);
209free_tmp:
210 kfree(tmp);
211 return err;
212}
213
214/* generate_ecdh_keys() - generate ecc key pair.
215 *
216 * @tfm: KPP tfm handle allocated with crypto_alloc_kpp().
217 * @public_key: memory where the computed ecc public key will be saved.
218 *
219 * Return: zero on success; error code in case of error.
220 */
221int generate_ecdh_keys(struct crypto_kpp *tfm, u8 public_key[64])
222{
223 int err;
224
225 err = set_ecdh_privkey(tfm, NULL);
226 if (err)
227 return err;
228
229 return generate_ecdh_public_key(tfm, public_key);
230}