openssl/crypto/ec/ec_lcl.h - Issue 2072073002: Delete bundled copy of OpenSSL and replace with README.

Side by Side Diff: openssl/crypto/ec/ec_lcl.h

Issue 2072073002: Delete bundled copy of OpenSSL and replace with README. (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/openssl@master

Patch Set: Delete bundled copy of OpenSSL and replace with README. Created 4 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 /* crypto/ec/ec_lcl.h */

2 /*

3 * Originally written by Bodo Moeller for the OpenSSL project.

4 */

5 /* ====================================================================

6 * Copyright (c) 1998-2010 The OpenSSL Project. All rights reserved.

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

85 /* Use default functions for poin2oct, oct2point and compressed coordinates */

86 #define EC_FLAGS_DEFAULT_OCT 0x1

87

88 /* Structure details are not part of the exported interface,

89 * so all this may change in future versions. */

90

91 struct ec_method_st {

92 /* Various method flags */

93 int flags;

94 /* used by EC_METHOD_get_field_type: */

95 int field_type; /* a NID */

96

97 /* used by EC_GROUP_new, EC_GROUP_free, EC_GROUP_clear_free, EC_GROUP_co py: */

98 int (group_init)(EC_GROUP );

99 void (group_finish)(EC_GROUP );

100 void (group_clear_finish)(EC_GROUP );

101 int (group_copy)(EC_GROUP , const EC_GROUP *);

102

103 /* used by EC_GROUP_set_curve_GFp, EC_GROUP_get_curve_GFp, */

104 /* EC_GROUP_set_curve_GF2m, and EC_GROUP_get_curve_GF2m: */

105 int (group_set_curve)(EC_GROUP , const BIGNUM p, const BIGNUM a, con st BIGNUM b, BN_CTX );

106 int (group_get_curve)(const EC_GROUP , BIGNUM p, BIGNUM a, BIGNUM b , BN_CTX );

107

108 /* used by EC_GROUP_get_degree: */

109 int (group_get_degree)(const EC_GROUP );

110

111 /* used by EC_GROUP_check: */

112 int (group_check_discriminant)(const EC_GROUP , BN_CTX *);

113

114 /* used by EC_POINT_new, EC_POINT_free, EC_POINT_clear_free, EC_POINT_co py: */

115 int (point_init)(EC_POINT );

116 void (point_finish)(EC_POINT );

117 void (point_clear_finish)(EC_POINT );

118 int (point_copy)(EC_POINT , const EC_POINT *);

119

120 /* used by EC_POINT_set_to_infinity,

121 * EC_POINT_set_Jprojective_coordinates_GFp,

122 * EC_POINT_get_Jprojective_coordinates_GFp,

123 * EC_POINT_set_affine_coordinates_GFp, ..._GF2m,

124 * EC_POINT_get_affine_coordinates_GFp, ..._GF2m,

125 * EC_POINT_set_compressed_coordinates_GFp, ..._GF2m:

126 */

127 int (point_set_to_infinity)(const EC_GROUP , EC_POINT *);

128 int (point_set_Jprojective_coordinates_GFp)(const EC_GROUP , EC_POINT *,

129 const BIGNUM x, const BIGNUM y, const BIGNUM z, BN_CTX );

130 int (point_get_Jprojective_coordinates_GFp)(const EC_GROUP , const EC_ POINT *,

131 BIGNUM x, BIGNUM y, BIGNUM z, BN_CTX );

132 int (point_set_affine_coordinates)(const EC_GROUP , EC_POINT *,

133 const BIGNUM x, const BIGNUM y, BN_CTX *);

134 int (point_get_affine_coordinates)(const EC_GROUP , const EC_POINT *,

135 BIGNUM x, BIGNUM y, BN_CTX *);

136 int (point_set_compressed_coordinates)(const EC_GROUP , EC_POINT *,

137 const BIGNUM x, int y_bit, BN_CTX );

138

139 /* used by EC_POINT_point2oct, EC_POINT_oct2point: */

140 size_t (point2oct)(const EC_GROUP , const EC_POINT *, point_conversion _form_t form,

141 unsigned char buf, size_t len, BN_CTX );

142 int (oct2point)(const EC_GROUP , EC_POINT *,

143 const unsigned char buf, size_t len, BN_CTX );

144

145 /* used by EC_POINT_add, EC_POINT_dbl, ECP_POINT_invert: */

146 int (add)(const EC_GROUP , EC_POINT r, const EC_POINT a, const EC_PO INT b, BN_CTX );

147 int (dbl)(const EC_GROUP , EC_POINT r, const EC_POINT a, BN_CTX *);

148 int (invert)(const EC_GROUP , EC_POINT , BN_CTX );

149

150 /* used by EC_POINT_is_at_infinity, EC_POINT_is_on_curve, EC_POINT_cmp: */

151 int (is_at_infinity)(const EC_GROUP , const EC_POINT *);

152 int (is_on_curve)(const EC_GROUP , const EC_POINT , BN_CTX );

153 int (point_cmp)(const EC_GROUP , const EC_POINT a, const EC_POINT b, BN_CTX *);

154

155 /* used by EC_POINT_make_affine, EC_POINTs_make_affine: */

156 int (make_affine)(const EC_GROUP , EC_POINT , BN_CTX );

157 int (points_make_affine)(const EC_GROUP , size_t num, EC_POINT [], BN _CTX );

158

159 /* used by EC_POINTs_mul, EC_POINT_mul, EC_POINT_precompute_mult, EC_POI NT_have_precompute_mult

160 * (default implementations are used if the 'mul' pointer is 0): */

161 int (mul)(const EC_GROUP group, EC_POINT r, const BIGNUM scalar,

162 size_t num, const EC_POINT points[], const BIGNUM scalars[], B N_CTX *);

163 int (precompute_mult)(EC_GROUP group, BN_CTX *);

164 int (have_precompute_mult)(const EC_GROUP group);

165

166

167 /* internal functions */

168

169 /* 'field_mul', 'field_sqr', and 'field_div' can be used by 'add' and 'd bl' so that

170 * the same implementations of point operations can be used with differe nt

171 * optimized implementations of expensive field operations: */

172 int (field_mul)(const EC_GROUP , BIGNUM r, const BIGNUM a, const BIG NUM b, BN_CTX );

173 int (field_sqr)(const EC_GROUP , BIGNUM r, const BIGNUM a, BN_CTX *) ;

174 int (field_div)(const EC_GROUP , BIGNUM r, const BIGNUM a, const BIG NUM b, BN_CTX );

175

176 int (field_encode)(const EC_GROUP , BIGNUM r, const BIGNUM a, BN_CTX ); / e.g. to Montgomery */

177 int (field_decode)(const EC_GROUP , BIGNUM r, const BIGNUM a, BN_CTX ); / e.g. from Montgomery */

178 int (field_set_to_one)(const EC_GROUP , BIGNUM r, BN_CTX );

179 } /* EC_METHOD */;

180

181 typedef struct ec_extra_data_st {

182 struct ec_extra_data_st *next;

183 void *data;

184 void (dup_func)(void *);

185 void (free_func)(void );

186 void (clear_free_func)(void );

187 } EC_EXTRA_DATA; /* used in EC_GROUP */

188

189 struct ec_group_st {

190 const EC_METHOD *meth;

191

192 EC_POINT generator; / optional */

193 BIGNUM order, cofactor;

194

195 int curve_name;/* optional NID for named curve */

196 int asn1_flag; /* flag to control the asn1 encoding */

197 point_conversion_form_t asn1_form;

198

199 unsigned char seed; / optional seed for parameters (appears in ASN1) * /

200 size_t seed_len;

201

202 EC_EXTRA_DATA extra_data; / linked list */

203

204 /* The following members are handled by the method functions,

205 * even if they appear generic */

206

207 BIGNUM field; /* Field specification.

208 * For curves over GF(p), this is the modulus;

209 * for curves over GF(2^m), this is the

210 * irreducible polynomial defining the field.

211 */

212

213 int poly[6]; /* Field specification for curves over GF(2^m).

214 * The irreducible f(t) is then of the form:

215 * t^poly[0] + t^poly[1] + ... + t^poly[k]

216 * where m = poly[0] > poly[1] > ... > poly[k] = 0.

217 * The array is terminated with poly[k+1]=-1.

218 * All elliptic curve irreducibles have at most 5

219 * non-zero terms.

220 */

221

222 BIGNUM a, b; /* Curve coefficients.

223 * (Here the assumption is that BIGNUMs can be used

224 * or abused for all kinds of fields, not just GF(p).)

225 * For characteristic > 3, the curve is defined

226 * by a Weierstrass equation of the form

227 * y^2 = x^3 + a*x + b.

228 * For characteristic 2, the curve is defined by

229 * an equation of the form

230 * y^2 + xy = x^3 + ax^2 + b.

231 */

232

233 int a_is_minus3; /* enable optimized point arithmetics for special case */

234

235 void field_data1; / method-specific (e.g., Montgomery structure) */

236 void field_data2; / method-specific */

237 int (field_mod_func)(BIGNUM , const BIGNUM , const BIGNUM , BN_CTX * ); /* method-specific */

238 } /* EC_GROUP */;

239

240 struct ec_key_st {

241 int version;

242

243 EC_GROUP *group;

244

245 EC_POINT *pub_key;

246 BIGNUM *priv_key;

247

248 unsigned int enc_flag;

249 point_conversion_form_t conv_form;

250

251 int references;

252 int flags;

253

254 EC_EXTRA_DATA *method_data;

255 } /* EC_KEY */;

256

257 /* Basically a 'mixin' for extra data, but available for EC_GROUPs/EC_KEYs only

258 * (with visibility limited to 'package' level for now).

259 * We use the function pointers as index for retrieval; this obviates

260 * global ex_data-style index tables.

261 */

262 int EC_EX_DATA_set_data(EC_EXTRA_DATA *, void data,

263 void (dup_func)(void ), void (free_func)(void ), void (clear_free_ func)(void *));

264 void EC_EX_DATA_get_data(const EC_EXTRA_DATA ,

265 void (dup_func)(void ), void (free_func)(void ), void (clear_free_ func)(void *));

266 void EC_EX_DATA_free_data(EC_EXTRA_DATA **,

267 void (dup_func)(void ), void (free_func)(void ), void (clear_free_ func)(void *));

268 void EC_EX_DATA_clear_free_data(EC_EXTRA_DATA **,

269 void (dup_func)(void ), void (free_func)(void ), void (clear_free_ func)(void *));

270 void EC_EX_DATA_free_all_data(EC_EXTRA_DATA **);

271 void EC_EX_DATA_clear_free_all_data(EC_EXTRA_DATA **);

272

273

274

275 struct ec_point_st {

276 const EC_METHOD *meth;

277

278 /* All members except 'meth' are handled by the method functions,

279 * even if they appear generic */

280

281 BIGNUM X;

282 BIGNUM Y;

283 BIGNUM Z; /* Jacobian projective coordinates:

284 * (X, Y, Z) represents (X/Z^2, Y/Z^3) if Z != 0 */

285 int Z_is_one; /* enable optimized point arithmetics for special case */

286 } /* EC_POINT */;

287

288

289

290 /* method functions in ec_mult.c

291 * (ec_lib.c uses these as defaults if group->method->mul is 0) */

292 int ec_wNAF_mul(const EC_GROUP group, EC_POINT r, const BIGNUM *scalar,

293 size_t num, const EC_POINT points[], const BIGNUM scalars[], BN_CTX *) ;

294 int ec_wNAF_precompute_mult(EC_GROUP group, BN_CTX );

295 int ec_wNAF_have_precompute_mult(const EC_GROUP *group);

296

297

298 /* method functions in ecp_smpl.c */

299 int ec_GFp_simple_group_init(EC_GROUP *);

300 void ec_GFp_simple_group_finish(EC_GROUP *);

301 void ec_GFp_simple_group_clear_finish(EC_GROUP *);

302 int ec_GFp_simple_group_copy(EC_GROUP , const EC_GROUP );

303 int ec_GFp_simple_group_set_curve(EC_GROUP , const BIGNUM p, const BIGNUM a, const BIGNUM b, BN_CTX *);

304 int ec_GFp_simple_group_get_curve(const EC_GROUP , BIGNUM p, BIGNUM a, BIGNUM b, BN_CTX *);

305 int ec_GFp_simple_group_get_degree(const EC_GROUP *);

306 int ec_GFp_simple_group_check_discriminant(const EC_GROUP , BN_CTX );

307 int ec_GFp_simple_point_init(EC_POINT *);

308 void ec_GFp_simple_point_finish(EC_POINT *);

309 void ec_GFp_simple_point_clear_finish(EC_POINT *);

310 int ec_GFp_simple_point_copy(EC_POINT , const EC_POINT );

311 int ec_GFp_simple_point_set_to_infinity(const EC_GROUP , EC_POINT );

312 int ec_GFp_simple_set_Jprojective_coordinates_GFp(const EC_GROUP , EC_POINT ,

313 const BIGNUM x, const BIGNUM y, const BIGNUM z, BN_CTX );

314 int ec_GFp_simple_get_Jprojective_coordinates_GFp(const EC_GROUP , const EC_POI NT ,

315 BIGNUM x, BIGNUM y, BIGNUM z, BN_CTX );

316 int ec_GFp_simple_point_set_affine_coordinates(const EC_GROUP , EC_POINT ,

317 const BIGNUM x, const BIGNUM y, BN_CTX *);

318 int ec_GFp_simple_point_get_affine_coordinates(const EC_GROUP , const EC_POINT ,

319 BIGNUM x, BIGNUM y, BN_CTX *);

320 int ec_GFp_simple_set_compressed_coordinates(const EC_GROUP , EC_POINT ,

321 const BIGNUM x, int y_bit, BN_CTX );

322 size_t ec_GFp_simple_point2oct(const EC_GROUP , const EC_POINT , point_convers ion_form_t form,

323 unsigned char buf, size_t len, BN_CTX );

324 int ec_GFp_simple_oct2point(const EC_GROUP , EC_POINT ,

325 const unsigned char buf, size_t len, BN_CTX );

326 int ec_GFp_simple_add(const EC_GROUP , EC_POINT r, const EC_POINT a, const EC _POINT b, BN_CTX *);

327 int ec_GFp_simple_dbl(const EC_GROUP , EC_POINT r, const EC_POINT a, BN_CTX );

328 int ec_GFp_simple_invert(const EC_GROUP , EC_POINT , BN_CTX *);

329 int ec_GFp_simple_is_at_infinity(const EC_GROUP , const EC_POINT );

330 int ec_GFp_simple_is_on_curve(const EC_GROUP , const EC_POINT , BN_CTX *);

331 int ec_GFp_simple_cmp(const EC_GROUP , const EC_POINT a, const EC_POINT b, BN _CTX );

332 int ec_GFp_simple_make_affine(const EC_GROUP , EC_POINT , BN_CTX *);

333 int ec_GFp_simple_points_make_affine(const EC_GROUP , size_t num, EC_POINT [], BN_CTX *);

334 int ec_GFp_simple_field_mul(const EC_GROUP , BIGNUM r, const BIGNUM a, const BIGNUM b, BN_CTX *);

335 int ec_GFp_simple_field_sqr(const EC_GROUP , BIGNUM r, const BIGNUM a, BN_CTX );

336

337

338 /* method functions in ecp_mont.c */

339 int ec_GFp_mont_group_init(EC_GROUP *);

340 int ec_GFp_mont_group_set_curve(EC_GROUP , const BIGNUM p, const BIGNUM a, co nst BIGNUM b, BN_CTX *);

341 void ec_GFp_mont_group_finish(EC_GROUP *);

342 void ec_GFp_mont_group_clear_finish(EC_GROUP *);

343 int ec_GFp_mont_group_copy(EC_GROUP , const EC_GROUP );

344 int ec_GFp_mont_field_mul(const EC_GROUP , BIGNUM r, const BIGNUM a, const BI GNUM b, BN_CTX *);

345 int ec_GFp_mont_field_sqr(const EC_GROUP , BIGNUM r, const BIGNUM a, BN_CTX );

346 int ec_GFp_mont_field_encode(const EC_GROUP , BIGNUM r, const BIGNUM a, BN_CT X );

347 int ec_GFp_mont_field_decode(const EC_GROUP , BIGNUM r, const BIGNUM a, BN_CT X );

348 int ec_GFp_mont_field_set_to_one(const EC_GROUP , BIGNUM r, BN_CTX *);

349

350

351 /* method functions in ecp_nist.c */

352 int ec_GFp_nist_group_copy(EC_GROUP dest, const EC_GROUP src);

353 int ec_GFp_nist_group_set_curve(EC_GROUP , const BIGNUM p, const BIGNUM a, co nst BIGNUM b, BN_CTX *);

354 int ec_GFp_nist_field_mul(const EC_GROUP , BIGNUM r, const BIGNUM a, const BI GNUM b, BN_CTX *);

355 int ec_GFp_nist_field_sqr(const EC_GROUP , BIGNUM r, const BIGNUM a, BN_CTX );

356

357

358 /* method functions in ec2_smpl.c */

359 int ec_GF2m_simple_group_init(EC_GROUP *);

360 void ec_GF2m_simple_group_finish(EC_GROUP *);

361 void ec_GF2m_simple_group_clear_finish(EC_GROUP *);

362 int ec_GF2m_simple_group_copy(EC_GROUP , const EC_GROUP );

363 int ec_GF2m_simple_group_set_curve(EC_GROUP , const BIGNUM p, const BIGNUM a, const BIGNUM b, BN_CTX *);

364 int ec_GF2m_simple_group_get_curve(const EC_GROUP , BIGNUM p, BIGNUM a, BIGNU M b, BN_CTX *);

365 int ec_GF2m_simple_group_get_degree(const EC_GROUP *);

366 int ec_GF2m_simple_group_check_discriminant(const EC_GROUP , BN_CTX );

367 int ec_GF2m_simple_point_init(EC_POINT *);

368 void ec_GF2m_simple_point_finish(EC_POINT *);

369 void ec_GF2m_simple_point_clear_finish(EC_POINT *);

370 int ec_GF2m_simple_point_copy(EC_POINT , const EC_POINT );

371 int ec_GF2m_simple_point_set_to_infinity(const EC_GROUP , EC_POINT );

372 int ec_GF2m_simple_point_set_affine_coordinates(const EC_GROUP , EC_POINT ,

373 const BIGNUM x, const BIGNUM y, BN_CTX *);

374 int ec_GF2m_simple_point_get_affine_coordinates(const EC_GROUP , const EC_POINT ,

375 BIGNUM x, BIGNUM y, BN_CTX *);

376 int ec_GF2m_simple_set_compressed_coordinates(const EC_GROUP , EC_POINT ,

377 const BIGNUM x, int y_bit, BN_CTX );

378 size_t ec_GF2m_simple_point2oct(const EC_GROUP , const EC_POINT , point_conver sion_form_t form,

379 unsigned char buf, size_t len, BN_CTX );

380 int ec_GF2m_simple_oct2point(const EC_GROUP , EC_POINT ,

381 const unsigned char buf, size_t len, BN_CTX );

382 int ec_GF2m_simple_add(const EC_GROUP , EC_POINT r, const EC_POINT a, const E C_POINT b, BN_CTX *);

383 int ec_GF2m_simple_dbl(const EC_GROUP , EC_POINT r, const EC_POINT a, BN_CTX );

384 int ec_GF2m_simple_invert(const EC_GROUP , EC_POINT , BN_CTX *);

385 int ec_GF2m_simple_is_at_infinity(const EC_GROUP , const EC_POINT );

386 int ec_GF2m_simple_is_on_curve(const EC_GROUP , const EC_POINT , BN_CTX *);

387 int ec_GF2m_simple_cmp(const EC_GROUP , const EC_POINT a, const EC_POINT b, B N_CTX );

388 int ec_GF2m_simple_make_affine(const EC_GROUP , EC_POINT , BN_CTX *);

389 int ec_GF2m_simple_points_make_affine(const EC_GROUP , size_t num, EC_POINT [] , BN_CTX *);

390 int ec_GF2m_simple_field_mul(const EC_GROUP , BIGNUM r, const BIGNUM a, const BIGNUM b, BN_CTX *);

391 int ec_GF2m_simple_field_sqr(const EC_GROUP , BIGNUM r, const BIGNUM a, BN_CT X );

392 int ec_GF2m_simple_field_div(const EC_GROUP , BIGNUM r, const BIGNUM a, const BIGNUM b, BN_CTX *);

393

394

395 /* method functions in ec2_mult.c */

396 int ec_GF2m_simple_mul(const EC_GROUP group, EC_POINT r, const BIGNUM *scalar,

397 size_t num, const EC_POINT points[], const BIGNUM scalars[], BN_CTX *) ;

398 int ec_GF2m_precompute_mult(EC_GROUP group, BN_CTX ctx);

399 int ec_GF2m_have_precompute_mult(const EC_GROUP *group);

400

401 /* method functions in ec2_mult.c */

402 int ec_GF2m_simple_mul(const EC_GROUP group, EC_POINT r, const BIGNUM *scalar,

403 size_t num, const EC_POINT points[], const BIGNUM scalars[], BN_CTX *) ;

404 int ec_GF2m_precompute_mult(EC_GROUP group, BN_CTX ctx);

405 int ec_GF2m_have_precompute_mult(const EC_GROUP *group);

406

407 #ifndef OPENSSL_EC_NISTP_64_GCC_128

408 /* method functions in ecp_nistp224.c */

409 int ec_GFp_nistp224_group_init(EC_GROUP *group);

410 int ec_GFp_nistp224_group_set_curve(EC_GROUP group, const BIGNUM p, const BIGN UM a, const BIGNUM n, BN_CTX *);

411 int ec_GFp_nistp224_point_get_affine_coordinates(const EC_GROUP group, const EC _POINT point, BIGNUM x, BIGNUM y, BN_CTX *ctx);

412 int ec_GFp_nistp224_mul(const EC_GROUP group, EC_POINT r, const BIGNUM scalar , size_t num, const EC_POINT points[], const BIGNUM scalars[], BN_CTX );

413 int ec_GFp_nistp224_points_mul(const EC_GROUP group, EC_POINT r, const BIGNUM scalar, size_t num, const EC_POINT points[], const BIGNUM scalars[], BN_CTX ctx);

414 int ec_GFp_nistp224_precompute_mult(EC_GROUP group, BN_CTX ctx);

415 int ec_GFp_nistp224_have_precompute_mult(const EC_GROUP *group);

416

417 /* method functions in ecp_nistp256.c */

418 int ec_GFp_nistp256_group_init(EC_GROUP *group);

419 int ec_GFp_nistp256_group_set_curve(EC_GROUP group, const BIGNUM p, const BIGN UM a, const BIGNUM n, BN_CTX *);

420 int ec_GFp_nistp256_point_get_affine_coordinates(const EC_GROUP group, const EC _POINT point, BIGNUM x, BIGNUM y, BN_CTX *ctx);

421 int ec_GFp_nistp256_mul(const EC_GROUP group, EC_POINT r, const BIGNUM scalar , size_t num, const EC_POINT points[], const BIGNUM scalars[], BN_CTX );

422 int ec_GFp_nistp256_points_mul(const EC_GROUP group, EC_POINT r, const BIGNUM scalar, size_t num, const EC_POINT points[], const BIGNUM scalars[], BN_CTX ctx);

423 int ec_GFp_nistp256_precompute_mult(EC_GROUP group, BN_CTX ctx);

424 int ec_GFp_nistp256_have_precompute_mult(const EC_GROUP *group);

425

426 /* method functions in ecp_nistp521.c */

427 int ec_GFp_nistp521_group_init(EC_GROUP *group);

428 int ec_GFp_nistp521_group_set_curve(EC_GROUP group, const BIGNUM p, const BIGN UM a, const BIGNUM n, BN_CTX *);

429 int ec_GFp_nistp521_point_get_affine_coordinates(const EC_GROUP group, const EC _POINT point, BIGNUM x, BIGNUM y, BN_CTX *ctx);

430 int ec_GFp_nistp521_mul(const EC_GROUP group, EC_POINT r, const BIGNUM scalar , size_t num, const EC_POINT points[], const BIGNUM scalars[], BN_CTX );

431 int ec_GFp_nistp521_points_mul(const EC_GROUP group, EC_POINT r, const BIGNUM scalar, size_t num, const EC_POINT points[], const BIGNUM scalars[], BN_CTX ctx);

432 int ec_GFp_nistp521_precompute_mult(EC_GROUP group, BN_CTX ctx);

433 int ec_GFp_nistp521_have_precompute_mult(const EC_GROUP *group);

434

435 /* utility functions in ecp_nistputil.c */

436 void ec_GFp_nistp_points_make_affine_internal(size_t num, void *point_array,

437 size_t felem_size, void *tmp_felems,

438 void (felem_one)(void out),

439 int (felem_is_zero)(const void in),

440 void (felem_assign)(void out, const void *in),

441 void (felem_square)(void out, const void *in),

442 void (felem_mul)(void out, const void in1, const void in2),

443 void (felem_inv)(void out, const void *in),

444 void (felem_contract)(void out, const void *in));

445 void ec_GFp_nistp_recode_scalar_bits(unsigned char sign, unsigned char digit, unsigned char in);

446 #endif

OLD	NEW

« no previous file with comments | « openssl/crypto/ec/ec_key.c ('k') | openssl/crypto/ec/ec_lib.c » ('j') | no next file with comments »