1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* ECDH key-agreement protocol
4 * Copyright (c) 2016, Intel Corporation
5 * Authors: Salvator Benedetto <salvatore.benedetto@intel.com>
8 #include <linux/module.h>
9 #include <crypto/internal/kpp.h>
10 #include <crypto/kpp.h>
11 #include <crypto/ecdh.h>
12 #include <linux/scatterlist.h>
16 unsigned int curve_id
;
18 u64 private_key
[ECC_MAX_DIGITS
];
21 static inline struct ecdh_ctx
*ecdh_get_ctx(struct crypto_kpp
*tfm
)
23 return kpp_tfm_ctx(tfm
);
26 static unsigned int ecdh_supported_curve(unsigned int curve_id
)
29 case ECC_CURVE_NIST_P192
: return ECC_CURVE_NIST_P192_DIGITS
;
30 case ECC_CURVE_NIST_P256
: return ECC_CURVE_NIST_P256_DIGITS
;
35 static int ecdh_set_secret(struct crypto_kpp
*tfm
, const void *buf
,
38 struct ecdh_ctx
*ctx
= ecdh_get_ctx(tfm
);
42 if (crypto_ecdh_decode_key(buf
, len
, ¶ms
) < 0 ||
43 params
.key_size
> sizeof(ctx
->private_key
))
46 ndigits
= ecdh_supported_curve(params
.curve_id
);
50 ctx
->curve_id
= params
.curve_id
;
51 ctx
->ndigits
= ndigits
;
53 if (!params
.key
|| !params
.key_size
)
54 return ecc_gen_privkey(ctx
->curve_id
, ctx
->ndigits
,
57 memcpy(ctx
->private_key
, params
.key
, params
.key_size
);
59 if (ecc_is_key_valid(ctx
->curve_id
, ctx
->ndigits
,
60 ctx
->private_key
, params
.key_size
) < 0) {
61 memzero_explicit(ctx
->private_key
, params
.key_size
);
67 static int ecdh_compute_value(struct kpp_request
*req
)
69 struct crypto_kpp
*tfm
= crypto_kpp_reqtfm(req
);
70 struct ecdh_ctx
*ctx
= ecdh_get_ctx(tfm
);
72 u64
*shared_secret
= NULL
;
74 size_t copied
, nbytes
, public_key_sz
;
77 nbytes
= ctx
->ndigits
<< ECC_DIGITS_TO_BYTES_SHIFT
;
78 /* Public part is a point thus it has both coordinates */
79 public_key_sz
= 2 * nbytes
;
81 public_key
= kmalloc(public_key_sz
, GFP_KERNEL
);
86 shared_secret
= kmalloc(nbytes
, GFP_KERNEL
);
90 /* from here on it's invalid parameters */
93 /* must have exactly two points to be on the curve */
94 if (public_key_sz
!= req
->src_len
)
97 copied
= sg_copy_to_buffer(req
->src
,
98 sg_nents_for_len(req
->src
,
100 public_key
, public_key_sz
);
101 if (copied
!= public_key_sz
)
104 ret
= crypto_ecdh_shared_secret(ctx
->curve_id
, ctx
->ndigits
,
105 ctx
->private_key
, public_key
,
110 ret
= ecc_make_pub_key(ctx
->curve_id
, ctx
->ndigits
,
111 ctx
->private_key
, public_key
);
113 nbytes
= public_key_sz
;
119 /* might want less than we've got */
120 nbytes
= min_t(size_t, nbytes
, req
->dst_len
);
121 copied
= sg_copy_from_buffer(req
->dst
, sg_nents_for_len(req
->dst
,
124 if (copied
!= nbytes
)
129 kfree_sensitive(shared_secret
);
135 static unsigned int ecdh_max_size(struct crypto_kpp
*tfm
)
137 struct ecdh_ctx
*ctx
= ecdh_get_ctx(tfm
);
139 /* Public key is made of two coordinates, add one to the left shift */
140 return ctx
->ndigits
<< (ECC_DIGITS_TO_BYTES_SHIFT
+ 1);
143 static struct kpp_alg ecdh
= {
144 .set_secret
= ecdh_set_secret
,
145 .generate_public_key
= ecdh_compute_value
,
146 .compute_shared_secret
= ecdh_compute_value
,
147 .max_size
= ecdh_max_size
,
150 .cra_driver_name
= "ecdh-generic",
152 .cra_module
= THIS_MODULE
,
153 .cra_ctxsize
= sizeof(struct ecdh_ctx
),
157 static int ecdh_init(void)
159 return crypto_register_kpp(&ecdh
);
162 static void ecdh_exit(void)
164 crypto_unregister_kpp(&ecdh
);
167 subsys_initcall(ecdh_init
);
168 module_exit(ecdh_exit
);
169 MODULE_ALIAS_CRYPTO("ecdh");
170 MODULE_LICENSE("GPL");
171 MODULE_DESCRIPTION("ECDH generic algorithm");