blob: e4435fdde6774da9ad0fe575f6c7331d3203f5c7 [file] [log] [blame]
Jarno Lamsa18987a42019-04-24 15:40:43 +03001/* ecc.h - TinyCrypt interface to common ECC functions */
2
Simon Butcher92c3d1f2019-09-09 17:25:08 +01003/*
4 * Copyright (c) 2019, Arm Limited (or its affiliates), All Rights Reserved.
5 * SPDX-License-Identifier: BSD-3-Clause
6 */
7
Jarno Lamsa18987a42019-04-24 15:40:43 +03008/* Copyright (c) 2014, Kenneth MacKay
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions are met:
13 *
14 * * Redistributions of source code must retain the above copyright notice, this
15 * list of conditions and the following disclaimer.
16 *
17 * * Redistributions in binary form must reproduce the above copyright notice,
18 * this list of conditions and the following disclaimer in the documentation
19 * and/or other materials provided with the distribution.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
25 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/*
35 * Copyright (C) 2017 by Intel Corporation, All Rights Reserved.
36 *
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions are met:
39 *
40 * - Redistributions of source code must retain the above copyright notice,
41 * this list of conditions and the following disclaimer.
42 *
43 * - Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 *
47 * - Neither the name of Intel Corporation nor the names of its contributors
48 * may be used to endorse or promote products derived from this software
49 * without specific prior written permission.
50 *
51 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
52 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
53 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
54 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
55 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
56 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
57 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
58 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
59 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
60 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
61 * POSSIBILITY OF SUCH DAMAGE.
62 */
63
64/**
65 * @file
66 * @brief -- Interface to common ECC functions.
67 *
68 * Overview: This software is an implementation of common functions
69 * necessary to elliptic curve cryptography. This implementation uses
70 * curve NIST p-256.
71 *
72 * Security: The curve NIST p-256 provides approximately 128 bits of security.
73 *
74 */
75
76#ifndef __TC_UECC_H__
77#define __TC_UECC_H__
78
79#include <stdint.h>
80
81#ifdef __cplusplus
82extern "C" {
83#endif
84
85/* Word size (4 bytes considering 32-bits architectures) */
86#define uECC_WORD_SIZE 4
87
88/* setting max number of calls to prng: */
89#ifndef uECC_RNG_MAX_TRIES
90#define uECC_RNG_MAX_TRIES 64
91#endif
92
93/* defining data types to store word and bit counts: */
94typedef int8_t wordcount_t;
95typedef int16_t bitcount_t;
96/* defining data type for comparison result: */
97typedef int8_t cmpresult_t;
98/* defining data type to store ECC coordinate/point in 32bits words: */
99typedef unsigned int uECC_word_t;
100/* defining data type to store an ECC coordinate/point in 64bits words: */
101typedef uint64_t uECC_dword_t;
102
103/* defining masks useful for ecc computations: */
104#define HIGH_BIT_SET 0x80000000
105#define uECC_WORD_BITS 32
106#define uECC_WORD_BITS_SHIFT 5
107#define uECC_WORD_BITS_MASK 0x01F
108
109/* Number of words of 32 bits to represent an element of the the curve p-256: */
110#define NUM_ECC_WORDS 8
111/* Number of bytes to represent an element of the the curve p-256: */
112#define NUM_ECC_BYTES (uECC_WORD_SIZE*NUM_ECC_WORDS)
Manuel Pégourié-Gonnard78a7e352019-11-04 12:31:06 +0100113#define NUM_ECC_BITS 256
Jarno Lamsa18987a42019-04-24 15:40:43 +0300114
115/* structure that represents an elliptic curve (e.g. p256):*/
116struct uECC_Curve_t;
117typedef const struct uECC_Curve_t * uECC_Curve;
118struct uECC_Curve_t {
119 wordcount_t num_words;
120 wordcount_t num_bytes;
121 bitcount_t num_n_bits;
122 uECC_word_t p[NUM_ECC_WORDS];
123 uECC_word_t n[NUM_ECC_WORDS];
124 uECC_word_t G[NUM_ECC_WORDS * 2];
125 uECC_word_t b[NUM_ECC_WORDS];
126 void (*double_jacobian)(uECC_word_t * X1, uECC_word_t * Y1, uECC_word_t * Z1,
127 uECC_Curve curve);
128 void (*x_side)(uECC_word_t *result, const uECC_word_t *x, uECC_Curve curve);
129 void (*mmod_fast)(uECC_word_t *result, uECC_word_t *product);
130};
131
132/*
133 * @brief computes doubling of point ion jacobian coordinates, in place.
134 * @param X1 IN/OUT -- x coordinate
135 * @param Y1 IN/OUT -- y coordinate
136 * @param Z1 IN/OUT -- z coordinate
137 * @param curve IN -- elliptic curve
138 */
139void double_jacobian_default(uECC_word_t * X1, uECC_word_t * Y1,
140 uECC_word_t * Z1, uECC_Curve curve);
141
142/*
143 * @brief Computes x^3 + ax + b. result must not overlap x.
144 * @param result OUT -- x^3 + ax + b
145 * @param x IN -- value of x
146 * @param curve IN -- elliptic curve
147 */
148void x_side_default(uECC_word_t *result, const uECC_word_t *x,
149 uECC_Curve curve);
150
151/*
152 * @brief Computes result = product % curve_p
153 * from http://www.nsa.gov/ia/_files/nist-routines.pdf
154 * @param result OUT -- product % curve_p
155 * @param product IN -- value to be reduced mod curve_p
156 */
157void vli_mmod_fast_secp256r1(unsigned int *result, unsigned int *product);
158
159/* Bytes to words ordering: */
160#define BYTES_TO_WORDS_8(a, b, c, d, e, f, g, h) 0x##d##c##b##a, 0x##h##g##f##e
161#define BYTES_TO_WORDS_4(a, b, c, d) 0x##d##c##b##a
162#define BITS_TO_WORDS(num_bits) \
163 ((num_bits + ((uECC_WORD_SIZE * 8) - 1)) / (uECC_WORD_SIZE * 8))
164#define BITS_TO_BYTES(num_bits) ((num_bits + 7) / 8)
165
166/* definition of curve NIST p-256: */
167static const struct uECC_Curve_t curve_secp256r1 = {
168 NUM_ECC_WORDS,
169 NUM_ECC_BYTES,
170 256, /* num_n_bits */ {
171 BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF),
172 BYTES_TO_WORDS_8(FF, FF, FF, FF, 00, 00, 00, 00),
173 BYTES_TO_WORDS_8(00, 00, 00, 00, 00, 00, 00, 00),
174 BYTES_TO_WORDS_8(01, 00, 00, 00, FF, FF, FF, FF)
175 }, {
176 BYTES_TO_WORDS_8(51, 25, 63, FC, C2, CA, B9, F3),
177 BYTES_TO_WORDS_8(84, 9E, 17, A7, AD, FA, E6, BC),
178 BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF),
179 BYTES_TO_WORDS_8(00, 00, 00, 00, FF, FF, FF, FF)
180 }, {
181 BYTES_TO_WORDS_8(96, C2, 98, D8, 45, 39, A1, F4),
182 BYTES_TO_WORDS_8(A0, 33, EB, 2D, 81, 7D, 03, 77),
183 BYTES_TO_WORDS_8(F2, 40, A4, 63, E5, E6, BC, F8),
184 BYTES_TO_WORDS_8(47, 42, 2C, E1, F2, D1, 17, 6B),
185
186 BYTES_TO_WORDS_8(F5, 51, BF, 37, 68, 40, B6, CB),
187 BYTES_TO_WORDS_8(CE, 5E, 31, 6B, 57, 33, CE, 2B),
188 BYTES_TO_WORDS_8(16, 9E, 0F, 7C, 4A, EB, E7, 8E),
189 BYTES_TO_WORDS_8(9B, 7F, 1A, FE, E2, 42, E3, 4F)
190 }, {
191 BYTES_TO_WORDS_8(4B, 60, D2, 27, 3E, 3C, CE, 3B),
192 BYTES_TO_WORDS_8(F6, B0, 53, CC, B0, 06, 1D, 65),
193 BYTES_TO_WORDS_8(BC, 86, 98, 76, 55, BD, EB, B3),
194 BYTES_TO_WORDS_8(E7, 93, 3A, AA, D8, 35, C6, 5A)
195 },
196 &double_jacobian_default,
197 &x_side_default,
198 &vli_mmod_fast_secp256r1
199};
200
201uECC_Curve uECC_secp256r1(void);
202
203/*
204 * @brief Generates a random integer in the range 0 < random < top.
205 * Both random and top have num_words words.
206 * @param random OUT -- random integer in the range 0 < random < top
207 * @param top IN -- upper limit
208 * @param num_words IN -- number of words
209 * @return a random integer in the range 0 < random < top
210 */
211int uECC_generate_random_int(uECC_word_t *random, const uECC_word_t *top,
212 wordcount_t num_words);
213
214
215/* uECC_RNG_Function type
216 * The RNG function should fill 'size' random bytes into 'dest'. It should
217 * return 1 if 'dest' was filled with random data, or 0 if the random data could
218 * not be generated. The filled-in values should be either truly random, or from
219 * a cryptographically-secure PRNG.
220 *
221 * A correctly functioning RNG function must be set (using uECC_set_rng())
222 * before calling uECC_make_key() or uECC_sign().
223 *
224 * Setting a correctly functioning RNG function improves the resistance to
225 * side-channel attacks for uECC_shared_secret().
226 *
227 * A correct RNG function is set by default. If you are building on another
228 * POSIX-compliant system that supports /dev/random or /dev/urandom, you can
229 * define uECC_POSIX to use the predefined RNG.
230 */
231typedef int(*uECC_RNG_Function)(uint8_t *dest, unsigned int size);
232
233/*
234 * @brief Set the function that will be used to generate random bytes. The RNG
235 * function should return 1 if the random data was generated, or 0 if the random
236 * data could not be generated.
237 *
238 * @note On platforms where there is no predefined RNG function, this must be
239 * called before uECC_make_key() or uECC_sign() are used.
240 *
241 * @param rng_function IN -- function that will be used to generate random bytes
242 */
243void uECC_set_rng(uECC_RNG_Function rng_function);
244
245/*
246 * @brief provides current uECC_RNG_Function.
247 * @return Returns the function that will be used to generate random bytes.
248 */
249uECC_RNG_Function uECC_get_rng(void);
250
251/*
252 * @brief computes the size of a private key for the curve in bytes.
253 * @param curve IN -- elliptic curve
254 * @return size of a private key for the curve in bytes.
255 */
256int uECC_curve_private_key_size(uECC_Curve curve);
257
258/*
259 * @brief computes the size of a public key for the curve in bytes.
260 * @param curve IN -- elliptic curve
261 * @return the size of a public key for the curve in bytes.
262 */
263int uECC_curve_public_key_size(uECC_Curve curve);
264
265/*
266 * @brief Compute the corresponding public key for a private key.
267 * @param private_key IN -- The private key to compute the public key for
268 * @param public_key OUT -- Will be filled in with the corresponding public key
269 * @param curve
270 * @return Returns 1 if key was computed successfully, 0 if an error occurred.
271 */
272int uECC_compute_public_key(const uint8_t *private_key,
273 uint8_t *public_key, uECC_Curve curve);
274
275/*
276 * @brief Compute public-key.
277 * @return corresponding public-key.
278 * @param result OUT -- public-key
279 * @param private_key IN -- private-key
280 * @param curve IN -- elliptic curve
281 */
282uECC_word_t EccPoint_compute_public_key(uECC_word_t *result,
283 uECC_word_t *private_key, uECC_Curve curve);
284
285/*
Manuel Pégourié-Gonnardef238282019-11-04 11:19:30 +0100286 * @brief Point multiplication algorithm using Montgomery's ladder with co-Z
287 * coordinates. See http://eprint.iacr.org/2011/338.pdf.
288 * Uses scalar regularization and coordinate randomization (if a global RNG
289 * function is set) in order to protect against some side channel attacks.
290 * @note Result may overlap point.
291 * @param result OUT -- returns scalar*point
292 * @param point IN -- elliptic curve point
293 * @param scalar IN -- scalar
294 * @param curve IN -- elliptic curve
295 */
296int EccPoint_mult_safer(uECC_word_t * result, const uECC_word_t * point,
297 const uECC_word_t * scalar, uECC_Curve curve);
298
299/*
Jarno Lamsa18987a42019-04-24 15:40:43 +0300300 * @brief Constant-time comparison to zero - secure way to compare long integers
301 * @param vli IN -- very long integer
302 * @param num_words IN -- number of words in the vli
303 * @return 1 if vli == 0, 0 otherwise.
304 */
Manuel Pégourié-Gonnardf3899fc2019-11-04 12:44:43 +0100305uECC_word_t uECC_vli_isZero(const uECC_word_t *vli);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300306
307/*
308 * @brief Check if 'point' is the point at infinity
309 * @param point IN -- elliptic curve point
310 * @param curve IN -- elliptic curve
311 * @return if 'point' is the point at infinity, 0 otherwise.
312 */
313uECC_word_t EccPoint_isZero(const uECC_word_t *point, uECC_Curve curve);
314
315/*
316 * @brief computes the sign of left - right, in constant time.
317 * @param left IN -- left term to be compared
318 * @param right IN -- right term to be compared
319 * @param num_words IN -- number of words
320 * @return the sign of left - right
321 */
Manuel Pégourié-Gonnard2cb3eea2019-11-04 14:43:35 +0100322cmpresult_t uECC_vli_cmp(const uECC_word_t *left, const uECC_word_t *right);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300323
324/*
325 * @brief computes sign of left - right, not in constant time.
326 * @note should not be used if inputs are part of a secret
327 * @param left IN -- left term to be compared
328 * @param right IN -- right term to be compared
329 * @param num_words IN -- number of words
330 * @return the sign of left - right
331 */
Manuel Pégourié-Gonnarda7521912019-11-04 14:31:35 +0100332cmpresult_t uECC_vli_cmp_unsafe(const uECC_word_t *left, const uECC_word_t *right);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300333
334/*
335 * @brief Computes result = (left - right) % mod.
336 * @note Assumes that (left < mod) and (right < mod), and that result does not
337 * overlap mod.
338 * @param result OUT -- (left - right) % mod
339 * @param left IN -- leftright term in modular subtraction
340 * @param right IN -- right term in modular subtraction
341 * @param mod IN -- mod
342 * @param num_words IN -- number of words
343 */
344void uECC_vli_modSub(uECC_word_t *result, const uECC_word_t *left,
Manuel Pégourié-Gonnard1b0875d2019-11-04 14:50:54 +0100345 const uECC_word_t *right, const uECC_word_t *mod);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300346
347/*
348 * @brief Computes P' = (x1', y1', Z3), P + Q = (x3, y3, Z3) or
349 * P => P', Q => P + Q
350 * @note assumes Input P = (x1, y1, Z), Q = (x2, y2, Z)
351 * @param X1 IN -- x coordinate of P
352 * @param Y1 IN -- y coordinate of P
353 * @param X2 IN -- x coordinate of Q
354 * @param Y2 IN -- y coordinate of Q
355 * @param curve IN -- elliptic curve
356 */
357void XYcZ_add(uECC_word_t * X1, uECC_word_t * Y1, uECC_word_t * X2,
358 uECC_word_t * Y2, uECC_Curve curve);
359
360/*
361 * @brief Computes (x1 * z^2, y1 * z^3)
362 * @param X1 IN -- previous x1 coordinate
363 * @param Y1 IN -- previous y1 coordinate
364 * @param Z IN -- z value
365 * @param curve IN -- elliptic curve
366 */
Manuel Pégourié-Gonnardc3ec14c2019-11-04 12:12:00 +0100367void apply_z(uECC_word_t * X1, uECC_word_t * Y1, const uECC_word_t * const Z);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300368
369/*
370 * @brief Check if bit is set.
371 * @return Returns nonzero if bit 'bit' of vli is set.
372 * @warning It is assumed that the value provided in 'bit' is within the
373 * boundaries of the word-array 'vli'.
374 * @note The bit ordering layout assumed for vli is: {31, 30, ..., 0},
375 * {63, 62, ..., 32}, {95, 94, ..., 64}, {127, 126,..., 96} for a vli consisting
376 * of 4 uECC_word_t elements.
377 */
378uECC_word_t uECC_vli_testBit(const uECC_word_t *vli, bitcount_t bit);
379
380/*
381 * @brief Computes result = product % mod, where product is 2N words long.
382 * @param result OUT -- product % mod
383 * @param mod IN -- module
384 * @param num_words IN -- number of words
385 * @warning Currently only designed to work for curve_p or curve_n.
386 */
387void uECC_vli_mmod(uECC_word_t *result, uECC_word_t *product,
Manuel Pégourié-Gonnard10349e42019-11-04 14:57:53 +0100388 const uECC_word_t *mod);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300389
390/*
391 * @brief Computes modular product (using curve->mmod_fast)
392 * @param result OUT -- (left * right) mod % curve_p
393 * @param left IN -- left term in product
394 * @param right IN -- right term in product
395 * @param curve IN -- elliptic curve
396 */
397void uECC_vli_modMult_fast(uECC_word_t *result, const uECC_word_t *left,
Manuel Pégourié-Gonnardc3ec14c2019-11-04 12:12:00 +0100398 const uECC_word_t *right);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300399
400/*
401 * @brief Computes result = left - right.
402 * @note Can modify in place.
403 * @param result OUT -- left - right
404 * @param left IN -- left term in subtraction
405 * @param right IN -- right term in subtraction
406 * @param num_words IN -- number of words
407 * @return borrow
408 */
409uECC_word_t uECC_vli_sub(uECC_word_t *result, const uECC_word_t *left,
Manuel Pégourié-Gonnard129b42e2019-11-04 14:41:45 +0100410 const uECC_word_t *right);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300411
412/*
413 * @brief Constant-time comparison function(secure way to compare long ints)
414 * @param left IN -- left term in comparison
415 * @param right IN -- right term in comparison
416 * @param num_words IN -- number of words
417 * @return Returns 0 if left == right, 1 otherwise.
418 */
Manuel Pégourié-Gonnard2eca3d32019-11-04 14:33:09 +0100419uECC_word_t uECC_vli_equal(const uECC_word_t *left, const uECC_word_t *right);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300420
421/*
422 * @brief Computes (left * right) % mod
423 * @param result OUT -- (left * right) % mod
424 * @param left IN -- left term in product
425 * @param right IN -- right term in product
426 * @param mod IN -- mod
427 * @param num_words IN -- number of words
428 */
429void uECC_vli_modMult(uECC_word_t *result, const uECC_word_t *left,
Manuel Pégourié-Gonnard3e20adf2019-11-04 15:00:43 +0100430 const uECC_word_t *right, const uECC_word_t *mod);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300431
432/*
433 * @brief Computes (1 / input) % mod
434 * @note All VLIs are the same size.
435 * @note See "Euclid's GCD to Montgomery Multiplication to the Great Divide"
436 * @param result OUT -- (1 / input) % mod
437 * @param input IN -- value to be modular inverted
438 * @param mod IN -- mod
439 * @param num_words -- number of words
440 */
441void uECC_vli_modInv(uECC_word_t *result, const uECC_word_t *input,
Manuel Pégourié-Gonnard91353482019-11-04 15:04:20 +0100442 const uECC_word_t *mod);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300443
444/*
445 * @brief Sets dest = src.
446 * @param dest OUT -- destination buffer
447 * @param src IN -- origin buffer
448 * @param num_words IN -- number of words
449 */
Manuel Pégourié-Gonnardcbbb0f02019-11-04 13:02:04 +0100450void uECC_vli_set(uECC_word_t *dest, const uECC_word_t *src);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300451
452/*
453 * @brief Computes (left + right) % mod.
454 * @note Assumes that (left < mod) and right < mod), and that result does not
455 * overlap mod.
456 * @param result OUT -- (left + right) % mod.
457 * @param left IN -- left term in addition
458 * @param right IN -- right term in addition
459 * @param mod IN -- mod
460 * @param num_words IN -- number of words
461 */
462void uECC_vli_modAdd(uECC_word_t *result, const uECC_word_t *left,
Manuel Pégourié-Gonnard0779be72019-11-04 14:48:22 +0100463 const uECC_word_t *right, const uECC_word_t *mod);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300464
465/*
466 * @brief Counts the number of bits required to represent vli.
467 * @param vli IN -- very long integer
468 * @param max_words IN -- number of words
469 * @return number of bits in given vli
470 */
Manuel Pégourié-Gonnard2bf5a122019-11-04 12:56:59 +0100471bitcount_t uECC_vli_numBits(const uECC_word_t *vli);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300472
473/*
474 * @brief Erases (set to 0) vli
475 * @param vli IN -- very long integer
476 * @param num_words IN -- number of words
477 */
Manuel Pégourié-Gonnard94e48492019-11-04 12:47:28 +0100478void uECC_vli_clear(uECC_word_t *vli);
Jarno Lamsa18987a42019-04-24 15:40:43 +0300479
480/*
481 * @brief check if it is a valid point in the curve
482 * @param point IN -- point to be checked
483 * @param curve IN -- elliptic curve
484 * @return 0 if point is valid
485 * @exception returns -1 if it is a point at infinity
486 * @exception returns -2 if x or y is smaller than p,
487 * @exception returns -3 if y^2 != x^3 + ax + b.
488 */
489int uECC_valid_point(const uECC_word_t *point, uECC_Curve curve);
490
491/*
492 * @brief Check if a public key is valid.
493 * @param public_key IN -- The public key to be checked.
494 * @return returns 0 if the public key is valid
495 * @exception returns -1 if it is a point at infinity
496 * @exception returns -2 if x or y is smaller than p,
497 * @exception returns -3 if y^2 != x^3 + ax + b.
498 * @exception returns -4 if public key is the group generator.
499 *
500 * @note Note that you are not required to check for a valid public key before
501 * using any other uECC functions. However, you may wish to avoid spending CPU
502 * time computing a shared secret or verifying a signature using an invalid
503 * public key.
504 */
505int uECC_valid_public_key(const uint8_t *public_key, uECC_Curve curve);
506
507 /*
508 * @brief Converts an integer in uECC native format to big-endian bytes.
509 * @param bytes OUT -- bytes representation
510 * @param num_bytes IN -- number of bytes
511 * @param native IN -- uECC native representation
512 */
513void uECC_vli_nativeToBytes(uint8_t *bytes, int num_bytes,
514 const unsigned int *native);
515
516/*
517 * @brief Converts big-endian bytes to an integer in uECC native format.
518 * @param native OUT -- uECC native representation
519 * @param bytes IN -- bytes representation
520 * @param num_bytes IN -- number of bytes
521 */
522void uECC_vli_bytesToNative(unsigned int *native, const uint8_t *bytes,
523 int num_bytes);
524
525#ifdef __cplusplus
526}
527#endif
528
529#endif /* __TC_UECC_H__ */