Alexandre Savard | 1b09e31 | 2012-08-07 20:33:29 -0400 | [diff] [blame] | 1 | /* crypto/ec/ec_lcl.h */ |
| 2 | /* |
| 3 | * Originally written by Bodo Moeller for the OpenSSL project. |
| 4 | */ |
| 5 | /* ==================================================================== |
Alexandre Savard | 7541067 | 2012-08-08 09:50:01 -0400 | [diff] [blame] | 6 | * Copyright (c) 1998-2003 The OpenSSL Project. All rights reserved. |
Alexandre Savard | 1b09e31 | 2012-08-07 20:33:29 -0400 | [diff] [blame] | 7 | * |
| 8 | * Redistribution and use in source and binary forms, with or without |
| 9 | * modification, are permitted provided that the following conditions |
| 10 | * are met: |
| 11 | * |
| 12 | * 1. Redistributions of source code must retain the above copyright |
| 13 | * notice, this list of conditions and the following disclaimer. |
| 14 | * |
| 15 | * 2. Redistributions in binary form must reproduce the above copyright |
| 16 | * notice, this list of conditions and the following disclaimer in |
| 17 | * the documentation and/or other materials provided with the |
| 18 | * distribution. |
| 19 | * |
| 20 | * 3. All advertising materials mentioning features or use of this |
| 21 | * software must display the following acknowledgment: |
| 22 | * "This product includes software developed by the OpenSSL Project |
| 23 | * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" |
| 24 | * |
| 25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
| 26 | * endorse or promote products derived from this software without |
| 27 | * prior written permission. For written permission, please contact |
| 28 | * openssl-core@openssl.org. |
| 29 | * |
| 30 | * 5. Products derived from this software may not be called "OpenSSL" |
| 31 | * nor may "OpenSSL" appear in their names without prior written |
| 32 | * permission of the OpenSSL Project. |
| 33 | * |
| 34 | * 6. Redistributions of any form whatsoever must retain the following |
| 35 | * acknowledgment: |
| 36 | * "This product includes software developed by the OpenSSL Project |
| 37 | * for use in the OpenSSL Toolkit (http://www.openssl.org/)" |
| 38 | * |
| 39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
| 40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| 42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
| 43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| 45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| 46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
| 48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| 49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
| 50 | * OF THE POSSIBILITY OF SUCH DAMAGE. |
| 51 | * ==================================================================== |
| 52 | * |
| 53 | * This product includes cryptographic software written by Eric Young |
| 54 | * (eay@cryptsoft.com). This product includes software written by Tim |
| 55 | * Hudson (tjh@cryptsoft.com). |
| 56 | * |
| 57 | */ |
| 58 | /* ==================================================================== |
| 59 | * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. |
| 60 | * |
| 61 | * Portions of the attached software ("Contribution") are developed by |
| 62 | * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project. |
| 63 | * |
| 64 | * The Contribution is licensed pursuant to the OpenSSL open source |
| 65 | * license provided above. |
| 66 | * |
| 67 | * The elliptic curve binary polynomial software is originally written by |
| 68 | * Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories. |
| 69 | * |
| 70 | */ |
| 71 | |
| 72 | |
| 73 | #include <stdlib.h> |
| 74 | |
| 75 | #include <openssl/obj_mac.h> |
| 76 | #include <openssl/ec.h> |
| 77 | #include <openssl/bn.h> |
| 78 | |
| 79 | #if defined(__SUNPRO_C) |
| 80 | # if __SUNPRO_C >= 0x520 |
| 81 | # pragma error_messages (off,E_ARRAY_OF_INCOMPLETE_NONAME,E_ARRAY_OF_INCOMPLETE) |
| 82 | # endif |
| 83 | #endif |
| 84 | |
Alexandre Savard | 1b09e31 | 2012-08-07 20:33:29 -0400 | [diff] [blame] | 85 | /* Structure details are not part of the exported interface, |
| 86 | * so all this may change in future versions. */ |
| 87 | |
| 88 | struct ec_method_st { |
Alexandre Savard | 1b09e31 | 2012-08-07 20:33:29 -0400 | [diff] [blame] | 89 | /* used by EC_METHOD_get_field_type: */ |
| 90 | int field_type; /* a NID */ |
| 91 | |
| 92 | /* used by EC_GROUP_new, EC_GROUP_free, EC_GROUP_clear_free, EC_GROUP_copy: */ |
| 93 | int (*group_init)(EC_GROUP *); |
| 94 | void (*group_finish)(EC_GROUP *); |
| 95 | void (*group_clear_finish)(EC_GROUP *); |
| 96 | int (*group_copy)(EC_GROUP *, const EC_GROUP *); |
| 97 | |
| 98 | /* used by EC_GROUP_set_curve_GFp, EC_GROUP_get_curve_GFp, */ |
| 99 | /* EC_GROUP_set_curve_GF2m, and EC_GROUP_get_curve_GF2m: */ |
| 100 | int (*group_set_curve)(EC_GROUP *, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *); |
| 101 | int (*group_get_curve)(const EC_GROUP *, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *); |
| 102 | |
| 103 | /* used by EC_GROUP_get_degree: */ |
| 104 | int (*group_get_degree)(const EC_GROUP *); |
| 105 | |
| 106 | /* used by EC_GROUP_check: */ |
| 107 | int (*group_check_discriminant)(const EC_GROUP *, BN_CTX *); |
| 108 | |
| 109 | /* used by EC_POINT_new, EC_POINT_free, EC_POINT_clear_free, EC_POINT_copy: */ |
| 110 | int (*point_init)(EC_POINT *); |
| 111 | void (*point_finish)(EC_POINT *); |
| 112 | void (*point_clear_finish)(EC_POINT *); |
| 113 | int (*point_copy)(EC_POINT *, const EC_POINT *); |
| 114 | |
| 115 | /* used by EC_POINT_set_to_infinity, |
| 116 | * EC_POINT_set_Jprojective_coordinates_GFp, |
| 117 | * EC_POINT_get_Jprojective_coordinates_GFp, |
| 118 | * EC_POINT_set_affine_coordinates_GFp, ..._GF2m, |
| 119 | * EC_POINT_get_affine_coordinates_GFp, ..._GF2m, |
| 120 | * EC_POINT_set_compressed_coordinates_GFp, ..._GF2m: |
| 121 | */ |
| 122 | int (*point_set_to_infinity)(const EC_GROUP *, EC_POINT *); |
| 123 | int (*point_set_Jprojective_coordinates_GFp)(const EC_GROUP *, EC_POINT *, |
| 124 | const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *); |
| 125 | int (*point_get_Jprojective_coordinates_GFp)(const EC_GROUP *, const EC_POINT *, |
| 126 | BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *); |
| 127 | int (*point_set_affine_coordinates)(const EC_GROUP *, EC_POINT *, |
| 128 | const BIGNUM *x, const BIGNUM *y, BN_CTX *); |
| 129 | int (*point_get_affine_coordinates)(const EC_GROUP *, const EC_POINT *, |
| 130 | BIGNUM *x, BIGNUM *y, BN_CTX *); |
| 131 | int (*point_set_compressed_coordinates)(const EC_GROUP *, EC_POINT *, |
| 132 | const BIGNUM *x, int y_bit, BN_CTX *); |
| 133 | |
| 134 | /* used by EC_POINT_point2oct, EC_POINT_oct2point: */ |
| 135 | size_t (*point2oct)(const EC_GROUP *, const EC_POINT *, point_conversion_form_t form, |
| 136 | unsigned char *buf, size_t len, BN_CTX *); |
| 137 | int (*oct2point)(const EC_GROUP *, EC_POINT *, |
| 138 | const unsigned char *buf, size_t len, BN_CTX *); |
| 139 | |
| 140 | /* used by EC_POINT_add, EC_POINT_dbl, ECP_POINT_invert: */ |
| 141 | int (*add)(const EC_GROUP *, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *); |
| 142 | int (*dbl)(const EC_GROUP *, EC_POINT *r, const EC_POINT *a, BN_CTX *); |
| 143 | int (*invert)(const EC_GROUP *, EC_POINT *, BN_CTX *); |
| 144 | |
| 145 | /* used by EC_POINT_is_at_infinity, EC_POINT_is_on_curve, EC_POINT_cmp: */ |
| 146 | int (*is_at_infinity)(const EC_GROUP *, const EC_POINT *); |
| 147 | int (*is_on_curve)(const EC_GROUP *, const EC_POINT *, BN_CTX *); |
| 148 | int (*point_cmp)(const EC_GROUP *, const EC_POINT *a, const EC_POINT *b, BN_CTX *); |
| 149 | |
| 150 | /* used by EC_POINT_make_affine, EC_POINTs_make_affine: */ |
| 151 | int (*make_affine)(const EC_GROUP *, EC_POINT *, BN_CTX *); |
| 152 | int (*points_make_affine)(const EC_GROUP *, size_t num, EC_POINT *[], BN_CTX *); |
| 153 | |
| 154 | /* used by EC_POINTs_mul, EC_POINT_mul, EC_POINT_precompute_mult, EC_POINT_have_precompute_mult |
| 155 | * (default implementations are used if the 'mul' pointer is 0): */ |
| 156 | int (*mul)(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar, |
| 157 | size_t num, const EC_POINT *points[], const BIGNUM *scalars[], BN_CTX *); |
| 158 | int (*precompute_mult)(EC_GROUP *group, BN_CTX *); |
| 159 | int (*have_precompute_mult)(const EC_GROUP *group); |
| 160 | |
| 161 | |
| 162 | /* internal functions */ |
| 163 | |
| 164 | /* 'field_mul', 'field_sqr', and 'field_div' can be used by 'add' and 'dbl' so that |
| 165 | * the same implementations of point operations can be used with different |
| 166 | * optimized implementations of expensive field operations: */ |
| 167 | int (*field_mul)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *); |
| 168 | int (*field_sqr)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *); |
| 169 | int (*field_div)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *); |
| 170 | |
| 171 | int (*field_encode)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *); /* e.g. to Montgomery */ |
| 172 | int (*field_decode)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *); /* e.g. from Montgomery */ |
| 173 | int (*field_set_to_one)(const EC_GROUP *, BIGNUM *r, BN_CTX *); |
| 174 | } /* EC_METHOD */; |
| 175 | |
| 176 | typedef struct ec_extra_data_st { |
| 177 | struct ec_extra_data_st *next; |
| 178 | void *data; |
| 179 | void *(*dup_func)(void *); |
| 180 | void (*free_func)(void *); |
| 181 | void (*clear_free_func)(void *); |
| 182 | } EC_EXTRA_DATA; /* used in EC_GROUP */ |
| 183 | |
| 184 | struct ec_group_st { |
| 185 | const EC_METHOD *meth; |
| 186 | |
| 187 | EC_POINT *generator; /* optional */ |
| 188 | BIGNUM order, cofactor; |
| 189 | |
| 190 | int curve_name;/* optional NID for named curve */ |
| 191 | int asn1_flag; /* flag to control the asn1 encoding */ |
| 192 | point_conversion_form_t asn1_form; |
| 193 | |
| 194 | unsigned char *seed; /* optional seed for parameters (appears in ASN1) */ |
| 195 | size_t seed_len; |
| 196 | |
| 197 | EC_EXTRA_DATA *extra_data; /* linked list */ |
| 198 | |
| 199 | /* The following members are handled by the method functions, |
| 200 | * even if they appear generic */ |
| 201 | |
| 202 | BIGNUM field; /* Field specification. |
| 203 | * For curves over GF(p), this is the modulus; |
| 204 | * for curves over GF(2^m), this is the |
| 205 | * irreducible polynomial defining the field. |
| 206 | */ |
| 207 | |
| 208 | int poly[6]; /* Field specification for curves over GF(2^m). |
| 209 | * The irreducible f(t) is then of the form: |
| 210 | * t^poly[0] + t^poly[1] + ... + t^poly[k] |
| 211 | * where m = poly[0] > poly[1] > ... > poly[k] = 0. |
| 212 | * The array is terminated with poly[k+1]=-1. |
| 213 | * All elliptic curve irreducibles have at most 5 |
| 214 | * non-zero terms. |
| 215 | */ |
| 216 | |
| 217 | BIGNUM a, b; /* Curve coefficients. |
| 218 | * (Here the assumption is that BIGNUMs can be used |
| 219 | * or abused for all kinds of fields, not just GF(p).) |
| 220 | * For characteristic > 3, the curve is defined |
| 221 | * by a Weierstrass equation of the form |
| 222 | * y^2 = x^3 + a*x + b. |
| 223 | * For characteristic 2, the curve is defined by |
| 224 | * an equation of the form |
| 225 | * y^2 + x*y = x^3 + a*x^2 + b. |
| 226 | */ |
| 227 | |
| 228 | int a_is_minus3; /* enable optimized point arithmetics for special case */ |
| 229 | |
| 230 | void *field_data1; /* method-specific (e.g., Montgomery structure) */ |
| 231 | void *field_data2; /* method-specific */ |
| 232 | int (*field_mod_func)(BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *); /* method-specific */ |
| 233 | } /* EC_GROUP */; |
| 234 | |
| 235 | struct ec_key_st { |
| 236 | int version; |
| 237 | |
| 238 | EC_GROUP *group; |
| 239 | |
| 240 | EC_POINT *pub_key; |
| 241 | BIGNUM *priv_key; |
| 242 | |
| 243 | unsigned int enc_flag; |
| 244 | point_conversion_form_t conv_form; |
| 245 | |
| 246 | int references; |
Alexandre Savard | 1b09e31 | 2012-08-07 20:33:29 -0400 | [diff] [blame] | 247 | |
| 248 | EC_EXTRA_DATA *method_data; |
| 249 | } /* EC_KEY */; |
| 250 | |
| 251 | /* Basically a 'mixin' for extra data, but available for EC_GROUPs/EC_KEYs only |
| 252 | * (with visibility limited to 'package' level for now). |
| 253 | * We use the function pointers as index for retrieval; this obviates |
| 254 | * global ex_data-style index tables. |
| 255 | */ |
| 256 | int EC_EX_DATA_set_data(EC_EXTRA_DATA **, void *data, |
| 257 | void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *)); |
| 258 | void *EC_EX_DATA_get_data(const EC_EXTRA_DATA *, |
| 259 | void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *)); |
| 260 | void EC_EX_DATA_free_data(EC_EXTRA_DATA **, |
| 261 | void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *)); |
| 262 | void EC_EX_DATA_clear_free_data(EC_EXTRA_DATA **, |
| 263 | void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *)); |
| 264 | void EC_EX_DATA_free_all_data(EC_EXTRA_DATA **); |
| 265 | void EC_EX_DATA_clear_free_all_data(EC_EXTRA_DATA **); |
| 266 | |
| 267 | |
| 268 | |
| 269 | struct ec_point_st { |
| 270 | const EC_METHOD *meth; |
| 271 | |
| 272 | /* All members except 'meth' are handled by the method functions, |
| 273 | * even if they appear generic */ |
| 274 | |
| 275 | BIGNUM X; |
| 276 | BIGNUM Y; |
| 277 | BIGNUM Z; /* Jacobian projective coordinates: |
| 278 | * (X, Y, Z) represents (X/Z^2, Y/Z^3) if Z != 0 */ |
| 279 | int Z_is_one; /* enable optimized point arithmetics for special case */ |
| 280 | } /* EC_POINT */; |
| 281 | |
| 282 | |
| 283 | |
| 284 | /* method functions in ec_mult.c |
| 285 | * (ec_lib.c uses these as defaults if group->method->mul is 0) */ |
| 286 | int ec_wNAF_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar, |
| 287 | size_t num, const EC_POINT *points[], const BIGNUM *scalars[], BN_CTX *); |
| 288 | int ec_wNAF_precompute_mult(EC_GROUP *group, BN_CTX *); |
| 289 | int ec_wNAF_have_precompute_mult(const EC_GROUP *group); |
| 290 | |
| 291 | |
| 292 | /* method functions in ecp_smpl.c */ |
| 293 | int ec_GFp_simple_group_init(EC_GROUP *); |
| 294 | void ec_GFp_simple_group_finish(EC_GROUP *); |
| 295 | void ec_GFp_simple_group_clear_finish(EC_GROUP *); |
| 296 | int ec_GFp_simple_group_copy(EC_GROUP *, const EC_GROUP *); |
| 297 | int ec_GFp_simple_group_set_curve(EC_GROUP *, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *); |
| 298 | int ec_GFp_simple_group_get_curve(const EC_GROUP *, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *); |
| 299 | int ec_GFp_simple_group_get_degree(const EC_GROUP *); |
| 300 | int ec_GFp_simple_group_check_discriminant(const EC_GROUP *, BN_CTX *); |
| 301 | int ec_GFp_simple_point_init(EC_POINT *); |
| 302 | void ec_GFp_simple_point_finish(EC_POINT *); |
| 303 | void ec_GFp_simple_point_clear_finish(EC_POINT *); |
| 304 | int ec_GFp_simple_point_copy(EC_POINT *, const EC_POINT *); |
| 305 | int ec_GFp_simple_point_set_to_infinity(const EC_GROUP *, EC_POINT *); |
| 306 | int ec_GFp_simple_set_Jprojective_coordinates_GFp(const EC_GROUP *, EC_POINT *, |
| 307 | const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *); |
| 308 | int ec_GFp_simple_get_Jprojective_coordinates_GFp(const EC_GROUP *, const EC_POINT *, |
| 309 | BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *); |
| 310 | int ec_GFp_simple_point_set_affine_coordinates(const EC_GROUP *, EC_POINT *, |
| 311 | const BIGNUM *x, const BIGNUM *y, BN_CTX *); |
| 312 | int ec_GFp_simple_point_get_affine_coordinates(const EC_GROUP *, const EC_POINT *, |
| 313 | BIGNUM *x, BIGNUM *y, BN_CTX *); |
| 314 | int ec_GFp_simple_set_compressed_coordinates(const EC_GROUP *, EC_POINT *, |
| 315 | const BIGNUM *x, int y_bit, BN_CTX *); |
| 316 | size_t ec_GFp_simple_point2oct(const EC_GROUP *, const EC_POINT *, point_conversion_form_t form, |
| 317 | unsigned char *buf, size_t len, BN_CTX *); |
| 318 | int ec_GFp_simple_oct2point(const EC_GROUP *, EC_POINT *, |
| 319 | const unsigned char *buf, size_t len, BN_CTX *); |
| 320 | int ec_GFp_simple_add(const EC_GROUP *, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *); |
| 321 | int ec_GFp_simple_dbl(const EC_GROUP *, EC_POINT *r, const EC_POINT *a, BN_CTX *); |
| 322 | int ec_GFp_simple_invert(const EC_GROUP *, EC_POINT *, BN_CTX *); |
| 323 | int ec_GFp_simple_is_at_infinity(const EC_GROUP *, const EC_POINT *); |
| 324 | int ec_GFp_simple_is_on_curve(const EC_GROUP *, const EC_POINT *, BN_CTX *); |
| 325 | int ec_GFp_simple_cmp(const EC_GROUP *, const EC_POINT *a, const EC_POINT *b, BN_CTX *); |
| 326 | int ec_GFp_simple_make_affine(const EC_GROUP *, EC_POINT *, BN_CTX *); |
| 327 | int ec_GFp_simple_points_make_affine(const EC_GROUP *, size_t num, EC_POINT *[], BN_CTX *); |
| 328 | int ec_GFp_simple_field_mul(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *); |
| 329 | int ec_GFp_simple_field_sqr(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *); |
| 330 | |
| 331 | |
| 332 | /* method functions in ecp_mont.c */ |
| 333 | int ec_GFp_mont_group_init(EC_GROUP *); |
| 334 | int ec_GFp_mont_group_set_curve(EC_GROUP *, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *); |
| 335 | void ec_GFp_mont_group_finish(EC_GROUP *); |
| 336 | void ec_GFp_mont_group_clear_finish(EC_GROUP *); |
| 337 | int ec_GFp_mont_group_copy(EC_GROUP *, const EC_GROUP *); |
| 338 | int ec_GFp_mont_field_mul(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *); |
| 339 | int ec_GFp_mont_field_sqr(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *); |
| 340 | int ec_GFp_mont_field_encode(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *); |
| 341 | int ec_GFp_mont_field_decode(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *); |
| 342 | int ec_GFp_mont_field_set_to_one(const EC_GROUP *, BIGNUM *r, BN_CTX *); |
| 343 | |
| 344 | |
| 345 | /* method functions in ecp_nist.c */ |
| 346 | int ec_GFp_nist_group_copy(EC_GROUP *dest, const EC_GROUP *src); |
| 347 | int ec_GFp_nist_group_set_curve(EC_GROUP *, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *); |
| 348 | int ec_GFp_nist_field_mul(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *); |
| 349 | int ec_GFp_nist_field_sqr(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *); |
| 350 | |
| 351 | |
| 352 | /* method functions in ec2_smpl.c */ |
| 353 | int ec_GF2m_simple_group_init(EC_GROUP *); |
| 354 | void ec_GF2m_simple_group_finish(EC_GROUP *); |
| 355 | void ec_GF2m_simple_group_clear_finish(EC_GROUP *); |
| 356 | int ec_GF2m_simple_group_copy(EC_GROUP *, const EC_GROUP *); |
| 357 | int ec_GF2m_simple_group_set_curve(EC_GROUP *, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *); |
| 358 | int ec_GF2m_simple_group_get_curve(const EC_GROUP *, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *); |
| 359 | int ec_GF2m_simple_group_get_degree(const EC_GROUP *); |
| 360 | int ec_GF2m_simple_group_check_discriminant(const EC_GROUP *, BN_CTX *); |
| 361 | int ec_GF2m_simple_point_init(EC_POINT *); |
| 362 | void ec_GF2m_simple_point_finish(EC_POINT *); |
| 363 | void ec_GF2m_simple_point_clear_finish(EC_POINT *); |
| 364 | int ec_GF2m_simple_point_copy(EC_POINT *, const EC_POINT *); |
| 365 | int ec_GF2m_simple_point_set_to_infinity(const EC_GROUP *, EC_POINT *); |
| 366 | int ec_GF2m_simple_point_set_affine_coordinates(const EC_GROUP *, EC_POINT *, |
| 367 | const BIGNUM *x, const BIGNUM *y, BN_CTX *); |
| 368 | int ec_GF2m_simple_point_get_affine_coordinates(const EC_GROUP *, const EC_POINT *, |
| 369 | BIGNUM *x, BIGNUM *y, BN_CTX *); |
| 370 | int ec_GF2m_simple_set_compressed_coordinates(const EC_GROUP *, EC_POINT *, |
| 371 | const BIGNUM *x, int y_bit, BN_CTX *); |
| 372 | size_t ec_GF2m_simple_point2oct(const EC_GROUP *, const EC_POINT *, point_conversion_form_t form, |
| 373 | unsigned char *buf, size_t len, BN_CTX *); |
| 374 | int ec_GF2m_simple_oct2point(const EC_GROUP *, EC_POINT *, |
| 375 | const unsigned char *buf, size_t len, BN_CTX *); |
| 376 | int ec_GF2m_simple_add(const EC_GROUP *, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *); |
| 377 | int ec_GF2m_simple_dbl(const EC_GROUP *, EC_POINT *r, const EC_POINT *a, BN_CTX *); |
| 378 | int ec_GF2m_simple_invert(const EC_GROUP *, EC_POINT *, BN_CTX *); |
| 379 | int ec_GF2m_simple_is_at_infinity(const EC_GROUP *, const EC_POINT *); |
| 380 | int ec_GF2m_simple_is_on_curve(const EC_GROUP *, const EC_POINT *, BN_CTX *); |
| 381 | int ec_GF2m_simple_cmp(const EC_GROUP *, const EC_POINT *a, const EC_POINT *b, BN_CTX *); |
| 382 | int ec_GF2m_simple_make_affine(const EC_GROUP *, EC_POINT *, BN_CTX *); |
| 383 | int ec_GF2m_simple_points_make_affine(const EC_GROUP *, size_t num, EC_POINT *[], BN_CTX *); |
| 384 | int ec_GF2m_simple_field_mul(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *); |
| 385 | int ec_GF2m_simple_field_sqr(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *); |
| 386 | int ec_GF2m_simple_field_div(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *); |
| 387 | |
| 388 | |
| 389 | /* method functions in ec2_mult.c */ |
| 390 | int ec_GF2m_simple_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar, |
| 391 | size_t num, const EC_POINT *points[], const BIGNUM *scalars[], BN_CTX *); |
| 392 | int ec_GF2m_precompute_mult(EC_GROUP *group, BN_CTX *ctx); |
| 393 | int ec_GF2m_have_precompute_mult(const EC_GROUP *group); |