Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
19struct ecdh_ctx {
20 unsigned int curve_id;
21 unsigned int ndigits;
22 u64 private_key[ECC_MAX_DIGITS];
23};
24
25static inline struct ecdh_ctx *ecdh_get_ctx(struct crypto_kpp *tfm)
26{
27 return kpp_tfm_ctx(tfm);
28}
29
30static unsigned int ecdh_supported_curve(unsigned int curve_id)
31{
32 switch (curve_id) {
33 case ECC_CURVE_NIST_P192: return 3;
34 case ECC_CURVE_NIST_P256: return 4;
35 default: return 0;
36 }
37}
38
39static 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
69static 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 copied = sg_copy_to_buffer(req->src, 1, public_key,
93 public_key_sz);
94 if (copied != public_key_sz) {
95 ret = -EINVAL;
96 goto free_all;
97 }
98
99 ret = crypto_ecdh_shared_secret(ctx->curve_id, ctx->ndigits,
100 ctx->private_key, public_key,
101 shared_secret);
102
103 buf = shared_secret;
104 } else {
105 ret = ecc_make_pub_key(ctx->curve_id, ctx->ndigits,
106 ctx->private_key, public_key);
107 buf = public_key;
108 nbytes = public_key_sz;
109 }
110
111 if (ret < 0)
112 goto free_all;
113
114 copied = sg_copy_from_buffer(req->dst, 1, buf, nbytes);
115 if (copied != nbytes)
116 ret = -EINVAL;
117
118 /* fall through */
119free_all:
120 kzfree(shared_secret);
121free_pubkey:
122 kfree(public_key);
123 return ret;
124}
125
126static unsigned int ecdh_max_size(struct crypto_kpp *tfm)
127{
128 struct ecdh_ctx *ctx = ecdh_get_ctx(tfm);
129
130 /* Public key is made of two coordinates, add one to the left shift */
131 return ctx->ndigits << (ECC_DIGITS_TO_BYTES_SHIFT + 1);
132}
133
134static struct kpp_alg ecdh = {
135 .set_secret = ecdh_set_secret,
136 .generate_public_key = ecdh_compute_value,
137 .compute_shared_secret = ecdh_compute_value,
138 .max_size = ecdh_max_size,
139 .base = {
140 .cra_name = "ecdh",
141 .cra_driver_name = "ecdh-generic",
142 .cra_priority = 100,
143 .cra_module = THIS_MODULE,
144 .cra_ctxsize = sizeof(struct ecdh_ctx),
145 },
146};
147
148static int ecdh_init(void)
149{
150 return crypto_register_kpp(&ecdh);
151}
152
153static void ecdh_exit(void)
154{
155 crypto_unregister_kpp(&ecdh);
156}
157
158module_init(ecdh_init);
159module_exit(ecdh_exit);
160MODULE_ALIAS_CRYPTO("ecdh");
161MODULE_LICENSE("GPL");
162MODULE_DESCRIPTION("ECDH generic algorithm");