1 /* ECDH key-agreement protocol
2 *
3 * Copyright (c) 2016, Intel Corporation
4 * Authors: Salvator Benedetto <salvatore.benedetto@intel.com>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12 #include <linux/module.h>
13 #include <crypto/internal/kpp.h>
14 #include <crypto/kpp.h>
15 #include <crypto/ecdh.h>
16 #include <linux/scatterlist.h>
17 #include "ecc.h"
18
19 struct ecdh_ctx {
20 unsigned int curve_id;
21 unsigned int ndigits;
22 u64 private_key[ECC_MAX_DIGITS];
23 };
24
ecdh_get_ctx(struct crypto_kpp * tfm)25 static inline struct ecdh_ctx *ecdh_get_ctx(struct crypto_kpp *tfm)
26 {
27 return kpp_tfm_ctx(tfm);
28 }
29
ecdh_supported_curve(unsigned int curve_id)30 static unsigned int ecdh_supported_curve(unsigned int curve_id)
31 {
32 switch (curve_id) {
33 case ECC_CURVE_NIST_P192: return ECC_CURVE_NIST_P192_DIGITS;
34 case ECC_CURVE_NIST_P256: return ECC_CURVE_NIST_P256_DIGITS;
35 default: return 0;
36 }
37 }
38
ecdh_set_secret(struct crypto_kpp * tfm,const void * buf,unsigned int len)39 static int ecdh_set_secret(struct crypto_kpp *tfm, const void *buf,
40 unsigned int len)
41 {
42 struct ecdh_ctx *ctx = ecdh_get_ctx(tfm);
43 struct ecdh params;
44 unsigned int ndigits;
45
46 if (crypto_ecdh_decode_key(buf, len, ¶ms) < 0)
47 return -EINVAL;
48
49 ndigits = ecdh_supported_curve(params.curve_id);
50 if (!ndigits)
51 return -EINVAL;
52
53 ctx->curve_id = params.curve_id;
54 ctx->ndigits = ndigits;
55
56 if (!params.key || !params.key_size)
57 return ecc_gen_privkey(ctx->curve_id, ctx->ndigits,
58 ctx->private_key);
59
60 if (ecc_is_key_valid(ctx->curve_id, ctx->ndigits,
61 (const u64 *)params.key, params.key_size) < 0)
62 return -EINVAL;
63
64 memcpy(ctx->private_key, params.key, params.key_size);
65
66 return 0;
67 }
68
ecdh_compute_value(struct kpp_request * req)69 static int ecdh_compute_value(struct kpp_request *req)
70 {
71 struct crypto_kpp *tfm = crypto_kpp_reqtfm(req);
72 struct ecdh_ctx *ctx = ecdh_get_ctx(tfm);
73 u64 *public_key;
74 u64 *shared_secret = NULL;
75 void *buf;
76 size_t copied, nbytes, public_key_sz;
77 int ret = -ENOMEM;
78
79 nbytes = ctx->ndigits << ECC_DIGITS_TO_BYTES_SHIFT;
80 /* Public part is a point thus it has both coordinates */
81 public_key_sz = 2 * nbytes;
82
83 public_key = kmalloc(public_key_sz, GFP_KERNEL);
84 if (!public_key)
85 return -ENOMEM;
86
87 if (req->src) {
88 shared_secret = kmalloc(nbytes, GFP_KERNEL);
89 if (!shared_secret)
90 goto free_pubkey;
91
92 /* from here on it's invalid parameters */
93 ret = -EINVAL;
94
95 /* must have exactly two points to be on the curve */
96 if (public_key_sz != req->src_len)
97 goto free_all;
98
99 copied = sg_copy_to_buffer(req->src,
100 sg_nents_for_len(req->src,
101 public_key_sz),
102 public_key, public_key_sz);
103 if (copied != public_key_sz)
104 goto free_all;
105
106 ret = crypto_ecdh_shared_secret(ctx->curve_id, ctx->ndigits,
107 ctx->private_key, public_key,
108 shared_secret);
109
110 buf = shared_secret;
111 } else {
112 ret = ecc_make_pub_key(ctx->curve_id, ctx->ndigits,
113 ctx->private_key, public_key);
114 buf = public_key;
115 nbytes = public_key_sz;
116 }
117
118 if (ret < 0)
119 goto free_all;
120
121 /* might want less than we've got */
122 nbytes = min_t(size_t, nbytes, req->dst_len);
123 copied = sg_copy_from_buffer(req->dst, sg_nents_for_len(req->dst,
124 nbytes),
125 buf, nbytes);
126 if (copied != nbytes)
127 ret = -EINVAL;
128
129 /* fall through */
130 free_all:
131 kzfree(shared_secret);
132 free_pubkey:
133 kfree(public_key);
134 return ret;
135 }
136
ecdh_max_size(struct crypto_kpp * tfm)137 static unsigned int ecdh_max_size(struct crypto_kpp *tfm)
138 {
139 struct ecdh_ctx *ctx = ecdh_get_ctx(tfm);
140
141 /* Public key is made of two coordinates, add one to the left shift */
142 return ctx->ndigits << (ECC_DIGITS_TO_BYTES_SHIFT + 1);
143 }
144
145 static struct kpp_alg ecdh = {
146 .set_secret = ecdh_set_secret,
147 .generate_public_key = ecdh_compute_value,
148 .compute_shared_secret = ecdh_compute_value,
149 .max_size = ecdh_max_size,
150 .base = {
151 .cra_name = "ecdh",
152 .cra_driver_name = "ecdh-generic",
153 .cra_priority = 100,
154 .cra_module = THIS_MODULE,
155 .cra_ctxsize = sizeof(struct ecdh_ctx),
156 },
157 };
158
ecdh_init(void)159 static int ecdh_init(void)
160 {
161 return crypto_register_kpp(&ecdh);
162 }
163
ecdh_exit(void)164 static void ecdh_exit(void)
165 {
166 crypto_unregister_kpp(&ecdh);
167 }
168
169 module_init(ecdh_init);
170 module_exit(ecdh_exit);
171 MODULE_ALIAS_CRYPTO("ecdh");
172 MODULE_LICENSE("GPL");
173 MODULE_DESCRIPTION("ECDH generic algorithm");
174
