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;
  9 *
 10 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 11 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 12 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
 13 * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
 14 * CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 18 *
 19 * ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
 20 * COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
 21 * SOFTWARE IS DISCLAIMED.
 22 */
 23#include "ecdh_helper.h"
 24
 25#include <linux/scatterlist.h>
 26#include <crypto/ecdh.h>
 27
 28static inline void swap_digits(u64 *in, u64 *out, unsigned int ndigits)
 29{
 30	int i;
 31
 32	for (i = 0; i < ndigits; i++)
 33		out[i] = __swab64(in[ndigits - 1 - i]);
 34}
 35
 36/* compute_ecdh_secret() - function assumes that the private key was
 37 *                         already set.
 38 * @tfm:          KPP tfm handle allocated with crypto_alloc_kpp().
 39 * @public_key:   pair's ecc public key.
 40 * secret:        memory where the ecdh computed shared secret will be saved.
 41 *
 42 * Return: zero on success; error code in case of error.
 43 */
 44int compute_ecdh_secret(struct crypto_kpp *tfm, const u8 public_key[64],
 45			u8 secret[32])
 46{
 47	DECLARE_CRYPTO_WAIT(result);
 48	struct kpp_request *req;
 49	u8 *tmp;
 50	struct scatterlist src, dst;
 51	int err;
 52
 53	tmp = kmalloc(64, GFP_KERNEL);
 54	if (!tmp)
 55		return -ENOMEM;
 56
 57	req = kpp_request_alloc(tfm, GFP_KERNEL);
 58	if (!req) {
 59		err = -ENOMEM;
 60		goto free_tmp;
 61	}
 62
 63	swap_digits((u64 *)public_key, (u64 *)tmp, 4); /* x */
 64	swap_digits((u64 *)&public_key[32], (u64 *)&tmp[32], 4); /* y */
 65
 66	sg_init_one(&src, tmp, 64);
 67	sg_init_one(&dst, secret, 32);
 68	kpp_request_set_input(req, &src, 64);
 69	kpp_request_set_output(req, &dst, 32);
 70	kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 71				 crypto_req_done, &result);
 72	err = crypto_kpp_compute_shared_secret(req);
 73	err = crypto_wait_req(err, &result);
 74	if (err < 0) {
 75		pr_err("alg: ecdh: compute shared secret failed. err %d\n",
 76		       err);
 77		goto free_all;
 78	}
 79
 80	swap_digits((u64 *)secret, (u64 *)tmp, 4);
 81	memcpy(secret, tmp, 32);
 82
 83free_all:
 84	kpp_request_free(req);
 85free_tmp:
 86	kfree_sensitive(tmp);
 87	return err;
 88}
 89
 90/* set_ecdh_privkey() - set or generate ecc private key.
 91 *
 92 * Function generates an ecc private key in the crypto subsystem when receiving
 93 * a NULL private key or sets the received key when not NULL.
 94 *
 95 * @tfm:           KPP tfm handle allocated with crypto_alloc_kpp().
 96 * @private_key:   user's ecc private key. When not NULL, the key is expected
 97 *                 in little endian format.
 98 *
 99 * Return: zero on success; error code in case of error.
100 */
101int set_ecdh_privkey(struct crypto_kpp *tfm, const u8 private_key[32])
102{
103	u8 *buf, *tmp = NULL;
104	unsigned int buf_len;
105	int err;
106	struct ecdh p = {0};
107
108	if (private_key) {
109		tmp = kmalloc(32, GFP_KERNEL);
110		if (!tmp)
111			return -ENOMEM;
112		swap_digits((u64 *)private_key, (u64 *)tmp, 4);
113		p.key = tmp;
114		p.key_size = 32;
115	}
116
117	buf_len = crypto_ecdh_key_len(&p);
118	buf = kmalloc(buf_len, GFP_KERNEL);
119	if (!buf) {
120		err = -ENOMEM;
121		goto free_tmp;
122	}
123
124	err = crypto_ecdh_encode_key(buf, buf_len, &p);
125	if (err)
126		goto free_all;
127
128	err = crypto_kpp_set_secret(tfm, buf, buf_len);
129	/* fall through */
130free_all:
131	kfree_sensitive(buf);
132free_tmp:
133	kfree_sensitive(tmp);
134	return err;
135}
136
137/* generate_ecdh_public_key() - function assumes that the private key was
138 *                              already set.
139 *
140 * @tfm:          KPP tfm handle allocated with crypto_alloc_kpp().
141 * @public_key:   memory where the computed ecc public key will be saved.
142 *
143 * Return: zero on success; error code in case of error.
144 */
145int generate_ecdh_public_key(struct crypto_kpp *tfm, u8 public_key[64])
146{
147	DECLARE_CRYPTO_WAIT(result);
148	struct kpp_request *req;
149	u8 *tmp;
150	struct scatterlist dst;
151	int err;
152
153	tmp = kmalloc(64, GFP_KERNEL);
154	if (!tmp)
155		return -ENOMEM;
156
157	req = kpp_request_alloc(tfm, GFP_KERNEL);
158	if (!req) {
159		err = -ENOMEM;
160		goto free_tmp;
161	}
162
163	sg_init_one(&dst, tmp, 64);
164	kpp_request_set_input(req, NULL, 0);
165	kpp_request_set_output(req, &dst, 64);
166	kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
167				 crypto_req_done, &result);
168
169	err = crypto_kpp_generate_public_key(req);
170	err = crypto_wait_req(err, &result);
171	if (err < 0)
172		goto free_all;
173
174	/* The public key is handed back in little endian as expected by
175	 * the Security Manager Protocol.
176	 */
177	swap_digits((u64 *)tmp, (u64 *)public_key, 4); /* x */
178	swap_digits((u64 *)&tmp[32], (u64 *)&public_key[32], 4); /* y */
179
180free_all:
181	kpp_request_free(req);
182free_tmp:
183	kfree(tmp);
184	return err;
185}
186
187/* generate_ecdh_keys() - generate ecc key pair.
188 *
189 * @tfm:          KPP tfm handle allocated with crypto_alloc_kpp().
190 * @public_key:   memory where the computed ecc public key will be saved.
191 *
192 * Return: zero on success; error code in case of error.
193 */
194int generate_ecdh_keys(struct crypto_kpp *tfm, u8 public_key[64])
195{
196	int err;
197
198	err = set_ecdh_privkey(tfm, NULL);
199	if (err)
200		return err;
201
202	return generate_ecdh_public_key(tfm, public_key);
203}