crypto/ec/ec2_smpl.c

   1 /*
   2  * Copyright 2002-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
   4  *
   5  * Licensed under the OpenSSL license (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or at
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 #include <openssl/err.h>
  12
  13 #include "internal/bn_int.h"
  14 #include "ec_lcl.h"
  15
  16 #ifndef OPENSSL_NO_EC2M
  17
  18 const EC_METHOD *EC_GF2m_simple_method(void)
  19 {
  20     static const EC_METHOD ret = {
  21         EC_FLAGS_DEFAULT_OCT,
  22         NID_X9_62_characteristic_two_field,
  23         ec_GF2m_simple_group_init,
  24         ec_GF2m_simple_group_finish,
  25         ec_GF2m_simple_group_clear_finish,
  26         ec_GF2m_simple_group_copy,
  27         ec_GF2m_simple_group_set_curve,
  28         ec_GF2m_simple_group_get_curve,
  29         ec_GF2m_simple_group_get_degree,
  30         ec_group_simple_order_bits,
  31         ec_GF2m_simple_group_check_discriminant,
  32         ec_GF2m_simple_point_init,
  33         ec_GF2m_simple_point_finish,
  34         ec_GF2m_simple_point_clear_finish,
  35         ec_GF2m_simple_point_copy,
  36         ec_GF2m_simple_point_set_to_infinity,
  37         0 /* set_Jprojective_coordinates_GFp */ ,
  38         0 /* get_Jprojective_coordinates_GFp */ ,
  39         ec_GF2m_simple_point_set_affine_coordinates,
  40         ec_GF2m_simple_point_get_affine_coordinates,
  41         0, 0, 0,
  42         ec_GF2m_simple_add,
  43         ec_GF2m_simple_dbl,
  44         ec_GF2m_simple_invert,
  45         ec_GF2m_simple_is_at_infinity,
  46         ec_GF2m_simple_is_on_curve,
  47         ec_GF2m_simple_cmp,
  48         ec_GF2m_simple_make_affine,
  49         ec_GF2m_simple_points_make_affine,
  50
  51         /*
  52          * the following three method functions are defined in ec2_mult.c
  53          */
  54         ec_GF2m_simple_mul,
  55         ec_GF2m_precompute_mult,
  56         ec_GF2m_have_precompute_mult,
  57
  58         ec_GF2m_simple_field_mul,
  59         ec_GF2m_simple_field_sqr,
  60         ec_GF2m_simple_field_div,
  61         0 /* field_encode */ ,
  62         0 /* field_decode */ ,
  63         0,                      /* field_set_to_one */
  64         ec_key_simple_priv2oct,
  65         ec_key_simple_oct2priv,
  66         0, /* set private */
  67         ec_key_simple_generate_key,
  68         ec_key_simple_check_key,
  69         ec_key_simple_generate_public_key,
  70         0, /* keycopy */
  71         0, /* keyfinish */
  72         ecdh_simple_compute_key
  73     };
  74
  75     return &ret;
  76 }
  77
  78 /*
  79  * Initialize a GF(2^m)-based EC_GROUP structure. Note that all other members
  80  * are handled by EC_GROUP_new.
  81  */
  82 int ec_GF2m_simple_group_init(EC_GROUP *group)
  83 {
  84     group->field = BN_new();
  85     group->a = BN_new();
  86     group->b = BN_new();
  87
  88     if (group->field == NULL || group->a == NULL || group->b == NULL) {
  89         BN_free(group->field);
  90         BN_free(group->a);
  91         BN_free(group->b);
  92         return 0;
  93     }
  94     return 1;
  95 }
  96
  97 /*
  98  * Free a GF(2^m)-based EC_GROUP structure. Note that all other members are
  99  * handled by EC_GROUP_free.
 100  */
 101 void ec_GF2m_simple_group_finish(EC_GROUP *group)
 102 {
 103     BN_free(group->field);
 104     BN_free(group->a);
 105     BN_free(group->b);
 106 }
 107
 108 /*
 109  * Clear and free a GF(2^m)-based EC_GROUP structure. Note that all other
 110  * members are handled by EC_GROUP_clear_free.
 111  */
 112 void ec_GF2m_simple_group_clear_finish(EC_GROUP *group)
 113 {
 114     BN_clear_free(group->field);
 115     BN_clear_free(group->a);
 116     BN_clear_free(group->b);
 117     group->poly[0] = 0;
 118     group->poly[1] = 0;
 119     group->poly[2] = 0;
 120     group->poly[3] = 0;
 121     group->poly[4] = 0;
 122     group->poly[5] = -1;
 123 }
 124
 125 /*
 126  * Copy a GF(2^m)-based EC_GROUP structure. Note that all other members are
 127  * handled by EC_GROUP_copy.
 128  */
 129 int ec_GF2m_simple_group_copy(EC_GROUP *dest, const EC_GROUP *src)
 130 {
 131     if (!BN_copy(dest->field, src->field))
 132         return 0;
 133     if (!BN_copy(dest->a, src->a))
 134         return 0;
 135     if (!BN_copy(dest->b, src->b))
 136         return 0;
 137     dest->poly[0] = src->poly[0];
 138     dest->poly[1] = src->poly[1];
 139     dest->poly[2] = src->poly[2];
 140     dest->poly[3] = src->poly[3];
 141     dest->poly[4] = src->poly[4];
 142     dest->poly[5] = src->poly[5];
 143     if (bn_wexpand(dest->a, (int)(dest->poly[0] + BN_BITS2 - 1) / BN_BITS2) ==
 144         NULL)
 145         return 0;
 146     if (bn_wexpand(dest->b, (int)(dest->poly[0] + BN_BITS2 - 1) / BN_BITS2) ==
 147         NULL)
 148         return 0;
 149     bn_set_all_zero(dest->a);
 150     bn_set_all_zero(dest->b);
 151     return 1;
 152 }
 153
 154 /* Set the curve parameters of an EC_GROUP structure. */
 155 int ec_GF2m_simple_group_set_curve(EC_GROUP *group,
 156                                    const BIGNUM *p, const BIGNUM *a,
 157                                    const BIGNUM *b, BN_CTX *ctx)
 158 {
 159     int ret = 0, i;
 160
 161     /* group->field */
 162     if (!BN_copy(group->field, p))
 163         goto err;
 164     i = BN_GF2m_poly2arr(group->field, group->poly, 6) - 1;
 165     if ((i != 5) && (i != 3)) {
 166         ECerr(EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE, EC_R_UNSUPPORTED_FIELD);
 167         goto err;
 168     }
 169
 170     /* group->a */
 171     if (!BN_GF2m_mod_arr(group->a, a, group->poly))
 172         goto err;
 173     if (bn_wexpand(group->a, (int)(group->poly[0] + BN_BITS2 - 1) / BN_BITS2)
 174         == NULL)
 175         goto err;
 176     bn_set_all_zero(group->a);
 177
 178     /* group->b */
 179     if (!BN_GF2m_mod_arr(group->b, b, group->poly))
 180         goto err;
 181     if (bn_wexpand(group->b, (int)(group->poly[0] + BN_BITS2 - 1) / BN_BITS2)
 182         == NULL)
 183         goto err;
 184     bn_set_all_zero(group->b);
 185
 186     ret = 1;
 187  err:
 188     return ret;
 189 }
 190
 191 /*
 192  * Get the curve parameters of an EC_GROUP structure. If p, a, or b are NULL
 193  * then there values will not be set but the method will return with success.
 194  */
 195 int ec_GF2m_simple_group_get_curve(const EC_GROUP *group, BIGNUM *p,
 196                                    BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
 197 {
 198     int ret = 0;
 199
 200     if (p != NULL) {
 201         if (!BN_copy(p, group->field))
 202             return 0;
 203     }
 204
 205     if (a != NULL) {
 206         if (!BN_copy(a, group->a))
 207             goto err;
 208     }
 209
 210     if (b != NULL) {
 211         if (!BN_copy(b, group->b))
 212             goto err;
 213     }
 214
 215     ret = 1;
 216
 217  err:
 218     return ret;
 219 }
 220
 221 /*
 222  * Gets the degree of the field.  For a curve over GF(2^m) this is the value
 223  * m.
 224  */
 225 int ec_GF2m_simple_group_get_degree(const EC_GROUP *group)
 226 {
 227     return BN_num_bits(group->field) - 1;
 228 }
 229
 230 /*
 231  * Checks the discriminant of the curve. y^2 + x*y = x^3 + a*x^2 + b is an
 232  * elliptic curve <=> b != 0 (mod p)
 233  */
 234 int ec_GF2m_simple_group_check_discriminant(const EC_GROUP *group,
 235                                             BN_CTX *ctx)
 236 {
 237     int ret = 0;
 238     BIGNUM *b;
 239     BN_CTX *new_ctx = NULL;
 240
 241     if (ctx == NULL) {
 242         ctx = new_ctx = BN_CTX_new();
 243         if (ctx == NULL) {
 244             ECerr(EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT,
 245                   ERR_R_MALLOC_FAILURE);
 246             goto err;
 247         }
 248     }
 249     BN_CTX_start(ctx);
 250     b = BN_CTX_get(ctx);
 251     if (b == NULL)
 252         goto err;
 253
 254     if (!BN_GF2m_mod_arr(b, group->b, group->poly))
 255         goto err;
 256
 257     /*
 258      * check the discriminant: y^2 + x*y = x^3 + a*x^2 + b is an elliptic
 259      * curve <=> b != 0 (mod p)
 260      */
 261     if (BN_is_zero(b))
 262         goto err;
 263
 264     ret = 1;
 265
 266  err:
 267     if (ctx != NULL)
 268         BN_CTX_end(ctx);
 269     BN_CTX_free(new_ctx);
 270     return ret;
 271 }
 272
 273 /* Initializes an EC_POINT. */
 274 int ec_GF2m_simple_point_init(EC_POINT *point)
 275 {
 276     point->X = BN_new();
 277     point->Y = BN_new();
 278     point->Z = BN_new();
 279
 280     if (point->X == NULL || point->Y == NULL || point->Z == NULL) {
 281         BN_free(point->X);
 282         BN_free(point->Y);
 283         BN_free(point->Z);
 284         return 0;
 285     }
 286     return 1;
 287 }
 288
 289 /* Frees an EC_POINT. */
 290 void ec_GF2m_simple_point_finish(EC_POINT *point)
 291 {
 292     BN_free(point->X);
 293     BN_free(point->Y);
 294     BN_free(point->Z);
 295 }
 296
 297 /* Clears and frees an EC_POINT. */
 298 void ec_GF2m_simple_point_clear_finish(EC_POINT *point)
 299 {
 300     BN_clear_free(point->X);
 301     BN_clear_free(point->Y);
 302     BN_clear_free(point->Z);
 303     point->Z_is_one = 0;
 304 }
 305
 306 /*
 307  * Copy the contents of one EC_POINT into another.  Assumes dest is
 308  * initialized.
 309  */
 310 int ec_GF2m_simple_point_copy(EC_POINT *dest, const EC_POINT *src)
 311 {
 312     if (!BN_copy(dest->X, src->X))
 313         return 0;
 314     if (!BN_copy(dest->Y, src->Y))
 315         return 0;
 316     if (!BN_copy(dest->Z, src->Z))
 317         return 0;
 318     dest->Z_is_one = src->Z_is_one;
 319
 320     return 1;
 321 }
 322
 323 /*
 324  * Set an EC_POINT to the point at infinity. A point at infinity is
 325  * represented by having Z=0.
 326  */
 327 int ec_GF2m_simple_point_set_to_infinity(const EC_GROUP *group,
 328                                          EC_POINT *point)
 329 {
 330     point->Z_is_one = 0;
 331     BN_zero(point->Z);
 332     return 1;
 333 }
 334
 335 /*
 336  * Set the coordinates of an EC_POINT using affine coordinates. Note that
 337  * the simple implementation only uses affine coordinates.
 338  */
 339 int ec_GF2m_simple_point_set_affine_coordinates(const EC_GROUP *group,
 340                                                 EC_POINT *point,
 341                                                 const BIGNUM *x,
 342                                                 const BIGNUM *y, BN_CTX *ctx)
 343 {
 344     int ret = 0;
 345     if (x == NULL || y == NULL) {
 346         ECerr(EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES,
 347               ERR_R_PASSED_NULL_PARAMETER);
 348         return 0;
 349     }
 350
 351     if (!BN_copy(point->X, x))
 352         goto err;
 353     BN_set_negative(point->X, 0);
 354     if (!BN_copy(point->Y, y))
 355         goto err;
 356     BN_set_negative(point->Y, 0);
 357     if (!BN_copy(point->Z, BN_value_one()))
 358         goto err;
 359     BN_set_negative(point->Z, 0);
 360     point->Z_is_one = 1;
 361     ret = 1;
 362
 363  err:
 364     return ret;
 365 }
 366
 367 /*
 368  * Gets the affine coordinates of an EC_POINT. Note that the simple
 369  * implementation only uses affine coordinates.
 370  */
 371 int ec_GF2m_simple_point_get_affine_coordinates(const EC_GROUP *group,
 372                                                 const EC_POINT *point,
 373                                                 BIGNUM *x, BIGNUM *y,
 374                                                 BN_CTX *ctx)
 375 {
 376     int ret = 0;
 377
 378     if (EC_POINT_is_at_infinity(group, point)) {
 379         ECerr(EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES,
 380               EC_R_POINT_AT_INFINITY);
 381         return 0;
 382     }
 383
 384     if (BN_cmp(point->Z, BN_value_one())) {
 385         ECerr(EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES,
 386               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 387         return 0;
 388     }
 389     if (x != NULL) {
 390         if (!BN_copy(x, point->X))
 391             goto err;
 392         BN_set_negative(x, 0);
 393     }
 394     if (y != NULL) {
 395         if (!BN_copy(y, point->Y))
 396             goto err;
 397         BN_set_negative(y, 0);
 398     }
 399     ret = 1;
 400
 401  err:
 402     return ret;
 403 }
 404
 405 /*
 406  * Computes a + b and stores the result in r.  r could be a or b, a could be
 407  * b. Uses algorithm A.10.2 of IEEE P1363.
 408  */
 409 int ec_GF2m_simple_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
 410                        const EC_POINT *b, BN_CTX *ctx)
 411 {
 412     BN_CTX *new_ctx = NULL;
 413     BIGNUM *x0, *y0, *x1, *y1, *x2, *y2, *s, *t;
 414     int ret = 0;
 415
 416     if (EC_POINT_is_at_infinity(group, a)) {
 417         if (!EC_POINT_copy(r, b))
 418             return 0;
 419         return 1;
 420     }
 421
 422     if (EC_POINT_is_at_infinity(group, b)) {
 423         if (!EC_POINT_copy(r, a))
 424             return 0;
 425         return 1;
 426     }
 427
 428     if (ctx == NULL) {
 429         ctx = new_ctx = BN_CTX_new();
 430         if (ctx == NULL)
 431             return 0;
 432     }
 433
 434     BN_CTX_start(ctx);
 435     x0 = BN_CTX_get(ctx);
 436     y0 = BN_CTX_get(ctx);
 437     x1 = BN_CTX_get(ctx);
 438     y1 = BN_CTX_get(ctx);
 439     x2 = BN_CTX_get(ctx);
 440     y2 = BN_CTX_get(ctx);
 441     s = BN_CTX_get(ctx);
 442     t = BN_CTX_get(ctx);
 443     if (t == NULL)
 444         goto err;
 445
 446     if (a->Z_is_one) {
 447         if (!BN_copy(x0, a->X))
 448             goto err;
 449         if (!BN_copy(y0, a->Y))
 450             goto err;
 451     } else {
 452         if (!EC_POINT_get_affine_coordinates_GF2m(group, a, x0, y0, ctx))
 453             goto err;
 454     }
 455     if (b->Z_is_one) {
 456         if (!BN_copy(x1, b->X))
 457             goto err;
 458         if (!BN_copy(y1, b->Y))
 459             goto err;
 460     } else {
 461         if (!EC_POINT_get_affine_coordinates_GF2m(group, b, x1, y1, ctx))
 462             goto err;
 463     }
 464
 465     if (BN_GF2m_cmp(x0, x1)) {
 466         if (!BN_GF2m_add(t, x0, x1))
 467             goto err;
 468         if (!BN_GF2m_add(s, y0, y1))
 469             goto err;
 470         if (!group->meth->field_div(group, s, s, t, ctx))
 471             goto err;
 472         if (!group->meth->field_sqr(group, x2, s, ctx))
 473             goto err;
 474         if (!BN_GF2m_add(x2, x2, group->a))
 475             goto err;
 476         if (!BN_GF2m_add(x2, x2, s))
 477             goto err;
 478         if (!BN_GF2m_add(x2, x2, t))
 479             goto err;
 480     } else {
 481         if (BN_GF2m_cmp(y0, y1) || BN_is_zero(x1)) {
 482             if (!EC_POINT_set_to_infinity(group, r))
 483                 goto err;
 484             ret = 1;
 485             goto err;
 486         }
 487         if (!group->meth->field_div(group, s, y1, x1, ctx))
 488             goto err;
 489         if (!BN_GF2m_add(s, s, x1))
 490             goto err;
 491
 492         if (!group->meth->field_sqr(group, x2, s, ctx))
 493             goto err;
 494         if (!BN_GF2m_add(x2, x2, s))
 495             goto err;
 496         if (!BN_GF2m_add(x2, x2, group->a))
 497             goto err;
 498     }
 499
 500     if (!BN_GF2m_add(y2, x1, x2))
 501         goto err;
 502     if (!group->meth->field_mul(group, y2, y2, s, ctx))
 503         goto err;
 504     if (!BN_GF2m_add(y2, y2, x2))
 505         goto err;
 506     if (!BN_GF2m_add(y2, y2, y1))
 507         goto err;
 508
 509     if (!EC_POINT_set_affine_coordinates_GF2m(group, r, x2, y2, ctx))
 510         goto err;
 511
 512     ret = 1;
 513
 514  err:
 515     BN_CTX_end(ctx);
 516     BN_CTX_free(new_ctx);
 517     return ret;
 518 }
 519
 520 /*
 521  * Computes 2 * a and stores the result in r.  r could be a. Uses algorithm
 522  * A.10.2 of IEEE P1363.
 523  */
 524 int ec_GF2m_simple_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
 525                        BN_CTX *ctx)
 526 {
 527     return ec_GF2m_simple_add(group, r, a, a, ctx);
 528 }
 529
 530 int ec_GF2m_simple_invert(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
 531 {
 532     if (EC_POINT_is_at_infinity(group, point) || BN_is_zero(point->Y))
 533         /* point is its own inverse */
 534         return 1;
 535
 536     if (!EC_POINT_make_affine(group, point, ctx))
 537         return 0;
 538     return BN_GF2m_add(point->Y, point->X, point->Y);
 539 }
 540
 541 /* Indicates whether the given point is the point at infinity. */
 542 int ec_GF2m_simple_is_at_infinity(const EC_GROUP *group,
 543                                   const EC_POINT *point)
 544 {
 545     return BN_is_zero(point->Z);
 546 }
 547
 548 /*-
 549  * Determines whether the given EC_POINT is an actual point on the curve defined
 550  * in the EC_GROUP.  A point is valid if it satisfies the Weierstrass equation:
 551  *      y^2 + x*y = x^3 + a*x^2 + b.
 552  */
 553 int ec_GF2m_simple_is_on_curve(const EC_GROUP *group, const EC_POINT *point,
 554                                BN_CTX *ctx)
 555 {
 556     int ret = -1;
 557     BN_CTX *new_ctx = NULL;
 558     BIGNUM *lh, *y2;
 559     int (*field_mul) (const EC_GROUP *, BIGNUM *, const BIGNUM *,
 560                       const BIGNUM *, BN_CTX *);
 561     int (*field_sqr) (const EC_GROUP *, BIGNUM *, const BIGNUM *, BN_CTX *);
 562
 563     if (EC_POINT_is_at_infinity(group, point))
 564         return 1;
 565
 566     field_mul = group->meth->field_mul;
 567     field_sqr = group->meth->field_sqr;
 568
 569     /* only support affine coordinates */
 570     if (!point->Z_is_one)
 571         return -1;
 572
 573     if (ctx == NULL) {
 574         ctx = new_ctx = BN_CTX_new();
 575         if (ctx == NULL)
 576             return -1;
 577     }
 578
 579     BN_CTX_start(ctx);
 580     y2 = BN_CTX_get(ctx);
 581     lh = BN_CTX_get(ctx);
 582     if (lh == NULL)
 583         goto err;
 584
 585     /*-
 586      * We have a curve defined by a Weierstrass equation
 587      *      y^2 + x*y = x^3 + a*x^2 + b.
 588      *  <=> x^3 + a*x^2 + x*y + b + y^2 = 0
 589      *  <=> ((x + a) * x + y ) * x + b + y^2 = 0
 590      */
 591     if (!BN_GF2m_add(lh, point->X, group->a))
 592         goto err;
 593     if (!field_mul(group, lh, lh, point->X, ctx))
 594         goto err;
 595     if (!BN_GF2m_add(lh, lh, point->Y))
 596         goto err;
 597     if (!field_mul(group, lh, lh, point->X, ctx))
 598         goto err;
 599     if (!BN_GF2m_add(lh, lh, group->b))
 600         goto err;
 601     if (!field_sqr(group, y2, point->Y, ctx))
 602         goto err;
 603     if (!BN_GF2m_add(lh, lh, y2))
 604         goto err;
 605     ret = BN_is_zero(lh);
 606
 607  err:
 608     BN_CTX_end(ctx);
 609     BN_CTX_free(new_ctx);
 610     return ret;
 611 }
 612
 613 /*-
 614  * Indicates whether two points are equal.
 615  * Return values:
 616  *  -1   error
 617  *   0   equal (in affine coordinates)
 618  *   1   not equal
 619  */
 620 int ec_GF2m_simple_cmp(const EC_GROUP *group, const EC_POINT *a,
 621                        const EC_POINT *b, BN_CTX *ctx)
 622 {
 623     BIGNUM *aX, *aY, *bX, *bY;
 624     BN_CTX *new_ctx = NULL;
 625     int ret = -1;
 626
 627     if (EC_POINT_is_at_infinity(group, a)) {
 628         return EC_POINT_is_at_infinity(group, b) ? 0 : 1;
 629     }
 630
 631     if (EC_POINT_is_at_infinity(group, b))
 632         return 1;
 633
 634     if (a->Z_is_one && b->Z_is_one) {
 635         return ((BN_cmp(a->X, b->X) == 0) && BN_cmp(a->Y, b->Y) == 0) ? 0 : 1;
 636     }
 637
 638     if (ctx == NULL) {
 639         ctx = new_ctx = BN_CTX_new();
 640         if (ctx == NULL)
 641             return -1;
 642     }
 643
 644     BN_CTX_start(ctx);
 645     aX = BN_CTX_get(ctx);
 646     aY = BN_CTX_get(ctx);
 647     bX = BN_CTX_get(ctx);
 648     bY = BN_CTX_get(ctx);
 649     if (bY == NULL)
 650         goto err;
 651
 652     if (!EC_POINT_get_affine_coordinates_GF2m(group, a, aX, aY, ctx))
 653         goto err;
 654     if (!EC_POINT_get_affine_coordinates_GF2m(group, b, bX, bY, ctx))
 655         goto err;
 656     ret = ((BN_cmp(aX, bX) == 0) && BN_cmp(aY, bY) == 0) ? 0 : 1;
 657
 658  err:
 659     BN_CTX_end(ctx);
 660     BN_CTX_free(new_ctx);
 661     return ret;
 662 }
 663
 664 /* Forces the given EC_POINT to internally use affine coordinates. */
 665 int ec_GF2m_simple_make_affine(const EC_GROUP *group, EC_POINT *point,
 666                                BN_CTX *ctx)
 667 {
 668     BN_CTX *new_ctx = NULL;
 669     BIGNUM *x, *y;
 670     int ret = 0;
 671
 672     if (point->Z_is_one || EC_POINT_is_at_infinity(group, point))
 673         return 1;
 674
 675     if (ctx == NULL) {
 676         ctx = new_ctx = BN_CTX_new();
 677         if (ctx == NULL)
 678             return 0;
 679     }
 680
 681     BN_CTX_start(ctx);
 682     x = BN_CTX_get(ctx);
 683     y = BN_CTX_get(ctx);
 684     if (y == NULL)
 685         goto err;
 686
 687     if (!EC_POINT_get_affine_coordinates_GF2m(group, point, x, y, ctx))
 688         goto err;
 689     if (!BN_copy(point->X, x))
 690         goto err;
 691     if (!BN_copy(point->Y, y))
 692         goto err;
 693     if (!BN_one(point->Z))
 694         goto err;
 695     point->Z_is_one = 1;
 696
 697     ret = 1;
 698
 699  err:
 700     BN_CTX_end(ctx);
 701     BN_CTX_free(new_ctx);
 702     return ret;
 703 }
 704
 705 /*
 706  * Forces each of the EC_POINTs in the given array to use affine coordinates.
 707  */
 708 int ec_GF2m_simple_points_make_affine(const EC_GROUP *group, size_t num,
 709                                       EC_POINT *points[], BN_CTX *ctx)
 710 {
 711     size_t i;
 712
 713     for (i = 0; i < num; i++) {
 714         if (!group->meth->make_affine(group, points[i], ctx))
 715             return 0;
 716     }
 717
 718     return 1;
 719 }
 720
 721 /* Wrapper to simple binary polynomial field multiplication implementation. */
 722 int ec_GF2m_simple_field_mul(const EC_GROUP *group, BIGNUM *r,
 723                              const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
 724 {
 725     return BN_GF2m_mod_mul_arr(r, a, b, group->poly, ctx);
 726 }
 727
 728 /* Wrapper to simple binary polynomial field squaring implementation. */
 729 int ec_GF2m_simple_field_sqr(const EC_GROUP *group, BIGNUM *r,
 730                              const BIGNUM *a, BN_CTX *ctx)
 731 {
 732     return BN_GF2m_mod_sqr_arr(r, a, group->poly, ctx);
 733 }
 734
 735 /* Wrapper to simple binary polynomial field division implementation. */
 736 int ec_GF2m_simple_field_div(const EC_GROUP *group, BIGNUM *r,
 737                              const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
 738 {
 739     return BN_GF2m_mod_div(r, a, b, group->field, ctx);
 740 }
 741
 742 #endif