kris
/
boringssl
1
0
Fork 0
Código Issues 0 Pull requests 0 Versões 0 Wiki Atividade
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
92 Commits
12 Branches
38 MiB
 
 
 
 
 
 
Tag: f77452c572
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de f77452c572
${ noResults }
boringssl/crypto/bn/bn_test.c

1420 linhas
32 KiB
Original Anotar Histórico 

  1. /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

  2.  * All rights reserved.

  3.  *

  4.  * This package is an SSL implementation written

  5.  * by Eric Young (eay@cryptsoft.com).

  6.  * The implementation was written so as to conform with Netscapes SSL.

  7.  *

  8.  * This library is free for commercial and non-commercial use as long as

  9.  * the following conditions are aheared to.  The following conditions

  10.  * apply to all code found in this distribution, be it the RC4, RSA,

  11.  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation

  12.  * included with this distribution is covered by the same copyright terms

  13.  * except that the holder is Tim Hudson (tjh@cryptsoft.com).

  14.  *

  15.  * Copyright remains Eric Young's, and as such any Copyright notices in

  16.  * the code are not to be removed.

  17.  * If this package is used in a product, Eric Young should be given attribution

  18.  * as the author of the parts of the library used.

  19.  * This can be in the form of a textual message at program startup or

  20.  * in documentation (online or textual) provided with the package.

  21.  *

  22.  * Redistribution and use in source and binary forms, with or without

  23.  * modification, are permitted provided that the following conditions

  24.  * are met:

  25.  * 1. Redistributions of source code must retain the copyright

  26.  *    notice, this list of conditions and the following disclaimer.

  27.  * 2. Redistributions in binary form must reproduce the above copyright

  28.  *    notice, this list of conditions and the following disclaimer in the

  29.  *    documentation and/or other materials provided with the distribution.

  30.  * 3. All advertising materials mentioning features or use of this software

  31.  *    must display the following acknowledgement:

  32.  *    "This product includes cryptographic software written by

  33.  *     Eric Young (eay@cryptsoft.com)"

  34.  *    The word 'cryptographic' can be left out if the rouines from the library

  35.  *    being used are not cryptographic related :-).

  36.  * 4. If you include any Windows specific code (or a derivative thereof) from

  37.  *    the apps directory (application code) you must include an acknowledgement:

  38.  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

  39.  *

  40.  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND

  41.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  42.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

  43.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

  44.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

  45.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

  46.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

  47.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

  48.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

  49.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

  50.  * SUCH DAMAGE.

  51.  *

  52.  * The licence and distribution terms for any publically available version or

  53.  * derivative of this code cannot be changed.  i.e. this code cannot simply be

  54.  * copied and put under another distribution licence

  55.  * [including the GNU Public Licence.]

  56.  */

  57. /* ====================================================================

  58.  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.

  59.  *

  60.  * Portions of the attached software ("Contribution") are developed by

  61.  * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.

  62.  *

  63.  * The Contribution is licensed pursuant to the Eric Young open source

  64.  * license provided above.

  65.  *

  66.  * The binary polynomial arithmetic software is originally written by

  67.  * Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems

  68.  * Laboratories. */

  69. 

  70. #include <stdio.h>

  71. 

  72. #include <openssl/bio.h>

  73. #include <openssl/bn.h>

  74. #include <openssl/err.h>

  75. #include <openssl/mem.h>

  76. 

  77. #include "internal.h"

  78. 

  79. static const int num0 = 100; /* number of tests */

  80. static const int num1 = 50;  /* additional tests for some functions */

  81. static const int num2 = 5;   /* number of tests for slow functions */

  82. 

  83. int test_add(BIO *bp);

  84. int test_sub(BIO *bp);

  85. int test_lshift1(BIO *bp);

  86. int test_lshift(BIO *bp, BN_CTX *ctx, BIGNUM *a_);

  87. int test_rshift1(BIO *bp);

  88. int test_rshift(BIO *bp, BN_CTX *ctx);

  89. int test_sqr(BIO *bp, BN_CTX *ctx);

  90. int test_mul(BIO *bp);

  91. int test_div(BIO *bp, BN_CTX *ctx);

  92. int rand_neg(void);

  93. 

  94. int test_div_word(BIO *bp);

  95. int test_mont(BIO *bp, BN_CTX *ctx);

  96. int test_mod(BIO *bp, BN_CTX *ctx);

  97. int test_mod_mul(BIO *bp, BN_CTX *ctx);

  98. int test_mod_exp(BIO *bp, BN_CTX *ctx);

  99. int test_mod_exp_mont_consttime(BIO *bp, BN_CTX *ctx);

  100. int test_exp(BIO *bp, BN_CTX *ctx);

  101. int test_mod_sqrt(BIO *bp, BN_CTX *ctx);

  102. static int test_exp_mod_zero();

  103. int test_small_prime(BIO *bp,BN_CTX *ctx);

  104. int test_mod_exp_mont5(BIO *bp, BN_CTX *ctx);

  105. int test_sqrt(BIO *bp, BN_CTX *ctx);

  106. int test_bn2bin_padded(BIO *bp, BN_CTX *ctx);

  107. #if 0

  108. int test_gf2m_add(BIO *bp);

  109. int test_gf2m_mod(BIO *bp);

  110. int test_gf2m_mod_mul(BIO *bp, BN_CTX *ctx);

  111. int test_gf2m_mod_sqr(BIO *bp, BN_CTX *ctx);

  112. int test_gf2m_mod_inv(BIO *bp, BN_CTX *ctx);

  113. int test_gf2m_mod_div(BIO *bp, BN_CTX *ctx);

  114. int test_gf2m_mod_exp(BIO *bp, BN_CTX *ctx);

  115. int test_gf2m_mod_sqrt(BIO *bp, BN_CTX *ctx);

  116. int test_gf2m_mod_solve_quad(BIO *bp, BN_CTX *ctx);

  117. #endif

  118. static int results = 0;

  119. 

  120. static unsigned char lst[] =

  121.     "\xC6\x4F\x43\x04\x2A\xEA\xCA\x6E\x58\x36\x80\x5B\xE8\xC9"

  122.     "\x9B\x04\x5D\x48\x36\xC2\xFD\x16\xC9\x64\xF0";

  123. 

  124. static void ERR_print_errors_fp(FILE *out) {

  125. }

  126. 

  127. static void message(BIO *out, char *m) {

  128.   BIO_puts(out, "print \"test ");

  129.   BIO_puts(out, m);

  130.   BIO_puts(out, "\\n\"\n");

  131. }

  132. 

  133. int main(int argc, char *argv[]) {

  134.   BN_CTX *ctx;

  135.   BIO *out = NULL;

  136.   char *outfile = NULL;

  137. 

  138.   results = 0;

  139. 

  140.   argc--;

  141.   argv++;

  142.   while (argc >= 1) {

  143.     if (strcmp(*argv, "-results") == 0)

  144.       results = 1;

  145.     else if (strcmp(*argv, "-out") == 0) {

  146.       if (--argc < 1)

  147.         break;

  148.       outfile = *(++argv);

  149.     }

  150.     argc--;

  151.     argv++;

  152.   }

  153. 

  154. 

  155.   ctx = BN_CTX_new();

  156.   if (ctx == NULL)

  157.     return 1;

  158. 

  159.   out = BIO_new(BIO_s_file());

  160.   if (out == NULL) {

  161.     return 1;

  162.   }

  163. 

  164.   if (outfile == NULL) {

  165.     BIO_set_fp(out, stdout, BIO_NOCLOSE);

  166.   } else {

  167.     if (!BIO_write_filename(out, outfile)) {

  168.       perror(outfile);

  169.       return 1;

  170.     }

  171.   }

  172. 

  173.   if (!results)

  174.     BIO_puts(out, "obase=16\nibase=16\n");

  175. 

  176.   message(out, "BN_add");

  177.   if (!test_add(out))

  178.     goto err;

  179.   (void)BIO_flush(out);

  180. 

  181.   message(out, "BN_sub");

  182.   if (!test_sub(out))

  183.     goto err;

  184.   (void)BIO_flush(out);

  185. 

  186.   message(out, "BN_lshift1");

  187.   if (!test_lshift1(out))

  188.     goto err;

  189.   (void)BIO_flush(out);

  190. 

  191.   message(out, "BN_lshift (fixed)");

  192.   if (!test_lshift(out, ctx, BN_bin2bn(lst, sizeof(lst) - 1, NULL)))

  193.     goto err;

  194.   (void)BIO_flush(out);

  195. 

  196.   message(out, "BN_lshift");

  197.   if (!test_lshift(out, ctx, NULL))

  198.     goto err;

  199.   (void)BIO_flush(out);

  200. 

  201.   message(out, "BN_rshift1");

  202.   if (!test_rshift1(out))

  203.     goto err;

  204.   (void)BIO_flush(out);

  205. 

  206.   message(out, "BN_rshift");

  207.   if (!test_rshift(out, ctx))

  208.     goto err;

  209.   (void)BIO_flush(out);

  210. 

  211.   message(out, "BN_sqr");

  212.   if (!test_sqr(out, ctx))

  213.     goto err;

  214.   (void)BIO_flush(out);

  215. 

  216.   message(out, "BN_mul");

  217.   if (!test_mul(out))

  218.     goto err;

  219.   (void)BIO_flush(out);

  220. 

  221.   message(out, "BN_div");

  222.   if (!test_div(out, ctx))

  223.     goto err;

  224.   (void)BIO_flush(out);

  225. 

  226.   message(out, "BN_div_word");

  227.   if (!test_div_word(out))

  228.     goto err;

  229.   (void)BIO_flush(out);

  230. 

  231.   message(out, "BN_mod");

  232.   if (!test_mod(out, ctx))

  233.     goto err;

  234.   (void)BIO_flush(out);

  235. 

  236.   message(out, "BN_mod_mul");

  237.   if (!test_mod_mul(out, ctx))

  238.     goto err;

  239.   (void)BIO_flush(out);

  240. 

  241.   message(out, "BN_mont");

  242.   if (!test_mont(out, ctx))

  243.     goto err;

  244.   (void)BIO_flush(out);

  245. 

  246.   message(out, "BN_mod_exp");

  247.   if (!test_mod_exp(out, ctx))

  248.     goto err;

  249.   (void)BIO_flush(out);

  250. 

  251.   message(out, "BN_mod_exp_mont_consttime");

  252.   if (!test_mod_exp_mont_consttime(out, ctx) ||

  253.       !test_mod_exp_mont5(out, ctx)) {

  254.     goto err;

  255.   }

  256.   (void)BIO_flush(out);

  257. 

  258.   message(out, "BN_exp");

  259.   if (!test_exp(out, ctx) ||

  260.       !test_exp_mod_zero()) {

  261.     goto err;

  262.   }

  263.   (void)BIO_flush(out);

  264. 

  265.   message(out, "BN_mod_sqrt");

  266.   if (!test_mod_sqrt(out, ctx))

  267.     goto err;

  268.   (void)BIO_flush(out);

  269. 

  270.   message(out, "Small prime generation");

  271.   if (!test_small_prime(out, ctx))

  272.     goto err;

  273.   (void)BIO_flush(out);

  274. 

  275.   message(out, "BN_sqrt");

  276.   if (!test_sqrt(out, ctx))

  277.     goto err;

  278.   (void)BIO_flush(out);

  279. 

  280.   message(out, "BN_bn2bin_padded");

  281.   if (!test_bn2bin_padded(out, ctx))

  282.     goto err;

  283.   (void)BIO_flush(out);

  284. 

  285.   BN_CTX_free(ctx);

  286.   BIO_free(out);

  287. 

  288.   printf("PASS\n");

  289.   return 0;

  290. 

  291. err:

  292.   BIO_puts(out, "1\n"); /* make sure the Perl script fed by bc notices

  293.                          * the failure, see test_bn in test/Makefile.ssl*/

  294.   (void)BIO_flush(out);

  295. 

  296.   return 1;

  297. }

  298. 

  299. int test_add(BIO *bp) {

  300.   BIGNUM a, b, c;

  301.   int i;

  302. 

  303.   BN_init(&a);

  304.   BN_init(&b);

  305.   BN_init(&c);

  306. 

  307.   BN_rand(&a, 512, 0, 0);

  308.   for (i = 0; i < num0; i++) {

  309.     BN_rand(&b, 450 + i, 0, 0);

  310.     a.neg = rand_neg();

  311.     b.neg = rand_neg();

  312.     BN_add(&c, &a, &b);

  313.     if (bp != NULL) {

  314.       if (!results) {

  315.         BN_print(bp, &a);

  316.         BIO_puts(bp, " + ");

  317.         BN_print(bp, &b);

  318.         BIO_puts(bp, " - ");

  319.       }

  320.       BN_print(bp, &c);

  321.       BIO_puts(bp, "\n");

  322.     }

  323.     a.neg = !a.neg;

  324.     b.neg = !b.neg;

  325.     BN_add(&c, &c, &b);

  326.     BN_add(&c, &c, &a);

  327.     if (!BN_is_zero(&c)) {

  328.       fprintf(stderr, "Add test failed!\n");

  329.       return 0;

  330.     }

  331.   }

  332.   BN_free(&a);

  333.   BN_free(&b);

  334.   BN_free(&c);

  335.   return (1);

  336. }

  337. 

  338. int test_sub(BIO *bp) {

  339.   BIGNUM a, b, c;

  340.   int i;

  341. 

  342.   BN_init(&a);

  343.   BN_init(&b);

  344.   BN_init(&c);

  345. 

  346.   for (i = 0; i < num0 + num1; i++) {

  347.     if (i < num1) {

  348.       BN_rand(&a, 512, 0, 0);

  349.       BN_copy(&b, &a);

  350.       if (BN_set_bit(&a, i) == 0)

  351.         return (0);

  352.       BN_add_word(&b, i);

  353.     } else {

  354.       BN_rand(&b, 400 + i - num1, 0, 0);

  355.       a.neg = rand_neg();

  356.       b.neg = rand_neg();

  357.     }

  358.     BN_sub(&c, &a, &b);

  359.     if (bp != NULL) {

  360.       if (!results) {

  361.         BN_print(bp, &a);

  362.         BIO_puts(bp, " - ");

  363.         BN_print(bp, &b);

  364.         BIO_puts(bp, " - ");

  365.       }

  366.       BN_print(bp, &c);

  367.       BIO_puts(bp, "\n");

  368.     }

  369.     BN_add(&c, &c, &b);

  370.     BN_sub(&c, &c, &a);

  371.     if (!BN_is_zero(&c)) {

  372.       fprintf(stderr, "Subtract test failed!\n");

  373.       return 0;

  374.     }

  375.   }

  376.   BN_free(&a);

  377.   BN_free(&b);

  378.   BN_free(&c);

  379.   return (1);

  380. }

  381. 

  382. int test_div(BIO *bp, BN_CTX *ctx) {

  383.   BIGNUM a, b, c, d, e;

  384.   int i;

  385. 

  386.   BN_init(&a);

  387.   BN_init(&b);

  388.   BN_init(&c);

  389.   BN_init(&d);

  390.   BN_init(&e);

  391. 

  392.   for (i = 0; i < num0 + num1; i++) {

  393.     if (i < num1) {

  394.       BN_rand(&a, 400, 0, 0);

  395.       BN_copy(&b, &a);

  396.       BN_lshift(&a, &a, i);

  397.       BN_add_word(&a, i);

  398.     } else

  399.       BN_rand(&b, 50 + 3 * (i - num1), 0, 0);

  400.     a.neg = rand_neg();

  401.     b.neg = rand_neg();

  402.     BN_div(&d, &c, &a, &b, ctx);

  403.     if (bp != NULL) {

  404.       if (!results) {

  405.         BN_print(bp, &a);

  406.         BIO_puts(bp, " / ");

  407.         BN_print(bp, &b);

  408.         BIO_puts(bp, " - ");

  409.       }

  410.       BN_print(bp, &d);

  411.       BIO_puts(bp, "\n");

  412. 

  413.       if (!results) {

  414.         BN_print(bp, &a);

  415.         BIO_puts(bp, " % ");

  416.         BN_print(bp, &b);

  417.         BIO_puts(bp, " - ");

  418.       }

  419.       BN_print(bp, &c);

  420.       BIO_puts(bp, "\n");

  421.     }

  422.     BN_mul(&e, &d, &b, ctx);

  423.     BN_add(&d, &e, &c);

  424.     BN_sub(&d, &d, &a);

  425.     if (!BN_is_zero(&d)) {

  426.       fprintf(stderr, "Division test failed!\n");

  427.       return 0;

  428.     }

  429.   }

  430.   BN_free(&a);

  431.   BN_free(&b);

  432.   BN_free(&c);

  433.   BN_free(&d);

  434.   BN_free(&e);

  435.   return (1);

  436. }

  437. 

  438. int test_lshift1(BIO *bp) {

  439.   BIGNUM *a, *b, *c;

  440.   int i;

  441. 

  442.   a = BN_new();

  443.   b = BN_new();

  444.   c = BN_new();

  445. 

  446.   BN_rand(a, 200, 0, 0); /**/

  447.   a->neg = rand_neg();

  448.   for (i = 0; i < num0; i++) {

  449.     BN_lshift1(b, a);

  450.     if (bp != NULL) {

  451.       if (!results) {

  452.         BN_print(bp, a);

  453.         BIO_puts(bp, " * 2");

  454.         BIO_puts(bp, " - ");

  455.       }

  456.       BN_print(bp, b);

  457.       BIO_puts(bp, "\n");

  458.     }

  459.     BN_add(c, a, a);

  460.     BN_sub(a, b, c);

  461.     if (!BN_is_zero(a)) {

  462.       fprintf(stderr, "Left shift one test failed!\n");

  463.       return 0;

  464.     }

  465. 

  466.     BN_copy(a, b);

  467.   }

  468.   BN_free(a);

  469.   BN_free(b);

  470.   BN_free(c);

  471.   return (1);

  472. }

  473. 

  474. int test_rshift(BIO *bp, BN_CTX *ctx) {

  475.   BIGNUM *a, *b, *c, *d, *e;

  476.   int i;

  477. 

  478.   a = BN_new();

  479.   b = BN_new();

  480.   c = BN_new();

  481.   d = BN_new();

  482.   e = BN_new();

  483.   BN_one(c);

  484. 

  485.   BN_rand(a, 200, 0, 0); /**/

  486.   a->neg = rand_neg();

  487.   for (i = 0; i < num0; i++) {

  488.     BN_rshift(b, a, i + 1);

  489.     BN_add(c, c, c);

  490.     if (bp != NULL) {

  491.       if (!results) {

  492.         BN_print(bp, a);

  493.         BIO_puts(bp, " / ");

  494.         BN_print(bp, c);

  495.         BIO_puts(bp, " - ");

  496.       }

  497.       BN_print(bp, b);

  498.       BIO_puts(bp, "\n");

  499.     }

  500.     BN_div(d, e, a, c, ctx);

  501.     BN_sub(d, d, b);

  502.     if (!BN_is_zero(d)) {

  503.       fprintf(stderr, "Right shift test failed!\n");

  504.       return 0;

  505.     }

  506.   }

  507.   BN_free(a);

  508.   BN_free(b);

  509.   BN_free(c);

  510.   BN_free(d);

  511.   BN_free(e);

  512.   return (1);

  513. }

  514. 

  515. int test_rshift1(BIO *bp) {

  516.   BIGNUM *a, *b, *c;

  517.   int i;

  518. 

  519.   a = BN_new();

  520.   b = BN_new();

  521.   c = BN_new();

  522. 

  523.   BN_rand(a, 200, 0, 0); /**/

  524.   a->neg = rand_neg();

  525.   for (i = 0; i < num0; i++) {

  526.     BN_rshift1(b, a);

  527.     if (bp != NULL) {

  528.       if (!results) {

  529.         BN_print(bp, a);

  530.         BIO_puts(bp, " / 2");

  531.         BIO_puts(bp, " - ");

  532.       }

  533.       BN_print(bp, b);

  534.       BIO_puts(bp, "\n");

  535.     }

  536.     BN_sub(c, a, b);

  537.     BN_sub(c, c, b);

  538.     if (!BN_is_zero(c) && !BN_abs_is_word(c, 1)) {

  539.       fprintf(stderr, "Right shift one test failed!\n");

  540.       return 0;

  541.     }

  542.     BN_copy(a, b);

  543.   }

  544.   BN_free(a);

  545.   BN_free(b);

  546.   BN_free(c);

  547.   return (1);

  548. }

  549. 

  550. int test_lshift(BIO *bp, BN_CTX *ctx, BIGNUM *a_) {

  551.   BIGNUM *a, *b, *c, *d;

  552.   int i;

  553. 

  554.   b = BN_new();

  555.   c = BN_new();

  556.   d = BN_new();

  557.   BN_one(c);

  558. 

  559.   if (a_)

  560.     a = a_;

  561.   else {

  562.     a = BN_new();

  563.     BN_rand(a, 200, 0, 0); /**/

  564.     a->neg = rand_neg();

  565.   }

  566.   for (i = 0; i < num0; i++) {

  567.     BN_lshift(b, a, i + 1);

  568.     BN_add(c, c, c);

  569.     if (bp != NULL) {

  570.       if (!results) {

  571.         BN_print(bp, a);

  572.         BIO_puts(bp, " * ");

  573.         BN_print(bp, c);

  574.         BIO_puts(bp, " - ");

  575.       }

  576.       BN_print(bp, b);

  577.       BIO_puts(bp, "\n");

  578.     }

  579.     BN_mul(d, a, c, ctx);

  580.     BN_sub(d, d, b);

  581.     if (!BN_is_zero(d)) {

  582.       fprintf(stderr, "Left shift test failed!\n");

  583.       fprintf(stderr, "a=");

  584.       BN_print_fp(stderr, a);

  585.       fprintf(stderr, "\nb=");

  586.       BN_print_fp(stderr, b);

  587.       fprintf(stderr, "\nc=");

  588.       BN_print_fp(stderr, c);

  589.       fprintf(stderr, "\nd=");

  590.       BN_print_fp(stderr, d);

  591.       fprintf(stderr, "\n");

  592.       return 0;

  593.     }

  594.   }

  595.   BN_free(a);

  596.   BN_free(b);

  597.   BN_free(c);

  598.   BN_free(d);

  599.   return (1);

  600. }

  601. 

  602. int test_mul(BIO *bp) {

  603.   BIGNUM a, b, c, d, e;

  604.   int i;

  605.   BN_CTX *ctx;

  606. 

  607.   ctx = BN_CTX_new();

  608.   if (ctx == NULL)

  609.     abort();

  610. 

  611.   BN_init(&a);

  612.   BN_init(&b);

  613.   BN_init(&c);

  614.   BN_init(&d);

  615.   BN_init(&e);

  616. 

  617.   for (i = 0; i < num0 + num1; i++) {

  618.     if (i <= num1) {

  619.       BN_rand(&a, 100, 0, 0);

  620.       BN_rand(&b, 100, 0, 0);

  621.     } else

  622.       BN_rand(&b, i - num1, 0, 0);

  623.     a.neg = rand_neg();

  624.     b.neg = rand_neg();

  625.     BN_mul(&c, &a, &b, ctx);

  626.     if (bp != NULL) {

  627.       if (!results) {

  628.         BN_print(bp, &a);

  629.         BIO_puts(bp, " * ");

  630.         BN_print(bp, &b);

  631.         BIO_puts(bp, " - ");

  632.       }

  633.       BN_print(bp, &c);

  634.       BIO_puts(bp, "\n");

  635.     }

  636.     BN_div(&d, &e, &c, &a, ctx);

  637.     BN_sub(&d, &d, &b);

  638.     if (!BN_is_zero(&d) || !BN_is_zero(&e)) {

  639.       fprintf(stderr, "Multiplication test failed!\n");

  640.       return 0;

  641.     }

  642.   }

  643.   BN_free(&a);

  644.   BN_free(&b);

  645.   BN_free(&c);

  646.   BN_free(&d);

  647.   BN_free(&e);

  648.   BN_CTX_free(ctx);

  649.   return (1);

  650. }

  651. 

  652. int test_sqr(BIO *bp, BN_CTX *ctx) {

  653.   BIGNUM a, c, d, e;

  654.   int i;

  655. 

  656.   BN_init(&a);

  657.   BN_init(&c);

  658.   BN_init(&d);

  659.   BN_init(&e);

  660. 

  661.   for (i = 0; i < num0; i++) {

  662.     BN_rand(&a, 40 + i * 10, 0, 0);

  663.     a.neg = rand_neg();

  664.     BN_sqr(&c, &a, ctx);

  665.     if (bp != NULL) {

  666.       if (!results) {

  667.         BN_print(bp, &a);

  668.         BIO_puts(bp, " * ");

  669.         BN_print(bp, &a);

  670.         BIO_puts(bp, " - ");

  671.       }

  672.       BN_print(bp, &c);

  673.       BIO_puts(bp, "\n");

  674.     }

  675.     BN_div(&d, &e, &c, &a, ctx);

  676.     BN_sub(&d, &d, &a);

  677.     if (!BN_is_zero(&d) || !BN_is_zero(&e)) {

  678.       fprintf(stderr, "Square test failed!\n");

  679.       return 0;

  680.     }

  681.   }

  682.   BN_free(&a);

  683.   BN_free(&c);

  684.   BN_free(&d);

  685.   BN_free(&e);

  686.   return (1);

  687. }

  688. 

  689. 

  690. int rand_neg(void) {

  691.   static unsigned int neg = 0;

  692.   static int sign[8] = {0, 0, 0, 1, 1, 0, 1, 1};

  693. 

  694.   return (sign[(neg++) % 8]);

  695. }

  696. 

  697. static void print_word(BIO *bp, BN_ULONG w) {

  698. #ifdef OPENSSL_64_BIT

  699.   if (sizeof(w) > sizeof(unsigned long)) {

  700.     unsigned long h = (unsigned long)(w >> 32), l = (unsigned long)(w);

  701. 

  702.     if (h)

  703.       BIO_printf(bp, "%lX%08lX", h, l);

  704.     else

  705.       BIO_printf(bp, "%lX", l);

  706.     return;

  707.   }

  708. #endif

  709.   BIO_printf(bp, BN_HEX_FMT1, w);

  710. }

  711. 

  712. int test_div_word(BIO *bp) {

  713.   BIGNUM a, b;

  714.   BN_ULONG r, s;

  715.   int i;

  716. 

  717.   BN_init(&a);

  718.   BN_init(&b);

  719. 

  720.   for (i = 0; i < num0; i++) {

  721.     do {

  722.       BN_rand(&a, 512, -1, 0);

  723.       BN_rand(&b, BN_BITS2, -1, 0);

  724.       s = b.d[0];

  725.     } while (!s);

  726. 

  727.     BN_copy(&b, &a);

  728.     r = BN_div_word(&b, s);

  729. 

  730.     if (bp != NULL) {

  731.       if (!results) {

  732.         BN_print(bp, &a);

  733.         BIO_puts(bp, " / ");

  734.         print_word(bp, s);

  735.         BIO_puts(bp, " - ");

  736.       }

  737.       BN_print(bp, &b);

  738.       BIO_puts(bp, "\n");

  739. 

  740.       if (!results) {

  741.         BN_print(bp, &a);

  742.         BIO_puts(bp, " % ");

  743.         print_word(bp, s);

  744.         BIO_puts(bp, " - ");

  745.       }

  746.       print_word(bp, r);

  747.       BIO_puts(bp, "\n");

  748.     }

  749.     BN_mul_word(&b, s);

  750.     BN_add_word(&b, r);

  751.     BN_sub(&b, &a, &b);

  752.     if (!BN_is_zero(&b)) {

  753.       fprintf(stderr, "Division (word) test failed!\n");

  754.       return 0;

  755.     }

  756.   }

  757.   BN_free(&a);

  758.   BN_free(&b);

  759.   return (1);

  760. }

  761. 

  762. int test_mont(BIO *bp, BN_CTX *ctx) {

  763.   BIGNUM a, b, c, d, A, B;

  764.   BIGNUM n;

  765.   int i;

  766.   BN_MONT_CTX *mont;

  767. 

  768.   BN_init(&a);

  769.   BN_init(&b);

  770.   BN_init(&c);

  771.   BN_init(&d);

  772.   BN_init(&A);

  773.   BN_init(&B);

  774.   BN_init(&n);

  775. 

  776.   mont = BN_MONT_CTX_new();

  777.   if (mont == NULL)

  778.     return 0;

  779. 

  780.   BN_rand(&a, 100, 0, 0); /**/

  781.   BN_rand(&b, 100, 0, 0); /**/

  782.   for (i = 0; i < num2; i++) {

  783.     int bits = (200 * (i + 1)) / num2;

  784. 

  785.     if (bits == 0)

  786.       continue;

  787.     BN_rand(&n, bits, 0, 1);

  788.     BN_MONT_CTX_set(mont, &n, ctx);

  789. 

  790.     BN_nnmod(&a, &a, &n, ctx);

  791.     BN_nnmod(&b, &b, &n, ctx);

  792. 

  793.     BN_to_montgomery(&A, &a, mont, ctx);

  794.     BN_to_montgomery(&B, &b, mont, ctx);

  795. 

  796.     BN_mod_mul_montgomery(&c, &A, &B, mont, ctx); /**/

  797.     BN_from_montgomery(&A, &c, mont, ctx);        /**/

  798.     if (bp != NULL) {

  799.       if (!results) {

  800. #ifdef undef

  801.         fprintf(stderr, "%d * %d %% %d\n", BN_num_bits(&a), BN_num_bits(&b),

  802.                 BN_num_bits(mont->N));

  803. #endif

  804.         BN_print(bp, &a);

  805.         BIO_puts(bp, " * ");

  806.         BN_print(bp, &b);

  807.         BIO_puts(bp, " % ");

  808.         BN_print(bp, &(mont->N));

  809.         BIO_puts(bp, " - ");

  810.       }

  811.       BN_print(bp, &A);

  812.       BIO_puts(bp, "\n");

  813.     }

  814.     BN_mod_mul(&d, &a, &b, &n, ctx);

  815.     BN_sub(&d, &d, &A);

  816.     if (!BN_is_zero(&d)) {

  817.       fprintf(stderr, "Montgomery multiplication test failed!\n");

  818.       return 0;

  819.     }

  820.   }

  821.   BN_MONT_CTX_free(mont);

  822.   BN_free(&a);

  823.   BN_free(&b);

  824.   BN_free(&c);

  825.   BN_free(&d);

  826.   BN_free(&A);

  827.   BN_free(&B);

  828.   BN_free(&n);

  829.   return (1);

  830. }

  831. 

  832. int test_mod(BIO *bp, BN_CTX *ctx) {

  833.   BIGNUM *a, *b, *c, *d, *e;

  834.   int i;

  835. 

  836.   a = BN_new();

  837.   b = BN_new();

  838.   c = BN_new();

  839.   d = BN_new();

  840.   e = BN_new();

  841. 

  842.   BN_rand(a, 1024, 0, 0); /**/

  843.   for (i = 0; i < num0; i++) {

  844.     BN_rand(b, 450 + i * 10, 0, 0); /**/

  845.     a->neg = rand_neg();

  846.     b->neg = rand_neg();

  847.     BN_mod(c, a, b, ctx); /**/

  848.     if (bp != NULL) {

  849.       if (!results) {

  850.         BN_print(bp, a);

  851.         BIO_puts(bp, " % ");

  852.         BN_print(bp, b);

  853.         BIO_puts(bp, " - ");

  854.       }

  855.       BN_print(bp, c);

  856.       BIO_puts(bp, "\n");

  857.     }

  858.     BN_div(d, e, a, b, ctx);

  859.     BN_sub(e, e, c);

  860.     if (!BN_is_zero(e)) {

  861.       fprintf(stderr, "Modulo test failed!\n");

  862.       return 0;

  863.     }

  864.   }

  865.   BN_free(a);

  866.   BN_free(b);

  867.   BN_free(c);

  868.   BN_free(d);

  869.   BN_free(e);

  870.   return (1);

  871. }

  872. 

  873. int test_mod_mul(BIO *bp, BN_CTX *ctx) {

  874.   BIGNUM *a, *b, *c, *d, *e;

  875.   int i, j;

  876. 

  877.   a = BN_new();

  878.   b = BN_new();

  879.   c = BN_new();

  880.   d = BN_new();

  881.   e = BN_new();

  882. 

  883.   for (j = 0; j < 3; j++) {

  884.     BN_rand(c, 1024, 0, 0); /**/

  885.     for (i = 0; i < num0; i++) {

  886.       BN_rand(a, 475 + i * 10, 0, 0); /**/

  887.       BN_rand(b, 425 + i * 11, 0, 0); /**/

  888.       a->neg = rand_neg();

  889.       b->neg = rand_neg();

  890.       if (!BN_mod_mul(e, a, b, c, ctx)) {

  891.         unsigned long l;

  892. 

  893.         while ((l = ERR_get_error()))

  894.           fprintf(stderr, "ERROR:%s\n", ERR_error_string(l, NULL));

  895.         abort();

  896.       }

  897.       if (bp != NULL) {

  898.         if (!results) {

  899.           BN_print(bp, a);

  900.           BIO_puts(bp, " * ");

  901.           BN_print(bp, b);

  902.           BIO_puts(bp, " % ");

  903.           BN_print(bp, c);

  904.           if ((a->neg ^ b->neg) && !BN_is_zero(e)) {

  905.             /* If  (a*b) % c  is negative,  c  must be added

  906.              * in order to obtain the normalized remainder

  907.              * (new with OpenSSL 0.9.7, previous versions of

  908.              * BN_mod_mul could generate negative results)

  909.              */

  910.             BIO_puts(bp, " + ");

  911.             BN_print(bp, c);

  912.           }

  913.           BIO_puts(bp, " - ");

  914.         }

  915.         BN_print(bp, e);

  916.         BIO_puts(bp, "\n");

  917.       }

  918.       BN_mul(d, a, b, ctx);

  919.       BN_sub(d, d, e);

  920.       BN_div(a, b, d, c, ctx);

  921.       if (!BN_is_zero(b)) {

  922.         fprintf(stderr, "Modulo multiply test failed!\n");

  923.         ERR_print_errors_fp(stderr);

  924.         return 0;

  925.       }

  926.     }

  927.   }

  928.   BN_free(a);

  929.   BN_free(b);

  930.   BN_free(c);

  931.   BN_free(d);

  932.   BN_free(e);

  933.   return (1);

  934. }

  935. 

  936. int test_mod_exp(BIO *bp, BN_CTX *ctx) {

  937.   BIGNUM *a, *b, *c, *d, *e;

  938.   int i;

  939. 

  940.   a = BN_new();

  941.   b = BN_new();

  942.   c = BN_new();

  943.   d = BN_new();

  944.   e = BN_new();

  945. 

  946.   BN_rand(c, 30, 0, 1); /* must be odd for montgomery */

  947.   for (i = 0; i < num2; i++) {

  948.     BN_rand(a, 20 + i * 5, 0, 0); /**/

  949.     BN_rand(b, 2 + i, 0, 0);      /**/

  950. 

  951.     if (!BN_mod_exp(d, a, b, c, ctx))

  952.       return (0);

  953. 

  954.     if (bp != NULL) {

  955.       if (!results) {

  956.         BN_print(bp, a);

  957.         BIO_puts(bp, " ^ ");

  958.         BN_print(bp, b);

  959.         BIO_puts(bp, " % ");

  960.         BN_print(bp, c);

  961.         BIO_puts(bp, " - ");

  962.       }

  963.       BN_print(bp, d);

  964.       BIO_puts(bp, "\n");

  965.     }

  966.     BN_exp(e, a, b, ctx);

  967.     BN_sub(e, e, d);

  968.     BN_div(a, b, e, c, ctx);

  969.     if (!BN_is_zero(b)) {

  970.       fprintf(stderr, "Modulo exponentiation test failed!\n");

  971.       return 0;

  972.     }

  973.   }

  974.   BN_free(a);

  975.   BN_free(b);

  976.   BN_free(c);

  977.   BN_free(d);

  978.   BN_free(e);

  979.   return (1);

  980. }

  981. 

  982. int test_mod_exp_mont_consttime(BIO *bp, BN_CTX *ctx) {

  983.   BIGNUM *a, *b, *c, *d, *e;

  984.   int i;

  985. 

  986.   a = BN_new();

  987.   b = BN_new();

  988.   c = BN_new();

  989.   d = BN_new();

  990.   e = BN_new();

  991. 

  992.   BN_rand(c, 30, 0, 1); /* must be odd for montgomery */

  993.   for (i = 0; i < num2; i++) {

  994.     BN_rand(a, 20 + i * 5, 0, 0); /**/

  995.     BN_rand(b, 2 + i, 0, 0);      /**/

  996. 

  997.     if (!BN_mod_exp_mont_consttime(d, a, b, c, ctx, NULL))

  998.       return (00);

  999. 

  1000.     if (bp != NULL) {

  1001.       if (!results) {

  1002.         BN_print(bp, a);

  1003.         BIO_puts(bp, " ^ ");

  1004.         BN_print(bp, b);

  1005.         BIO_puts(bp, " % ");

  1006.         BN_print(bp, c);

  1007.         BIO_puts(bp, " - ");

  1008.       }

  1009.       BN_print(bp, d);

  1010.       BIO_puts(bp, "\n");

  1011.     }

  1012.     BN_exp(e, a, b, ctx);

  1013.     BN_sub(e, e, d);

  1014.     BN_div(a, b, e, c, ctx);

  1015.     if (!BN_is_zero(b)) {

  1016.       fprintf(stderr, "Modulo exponentiation test failed!\n");

  1017.       return 0;

  1018.     }

  1019.   }

  1020.   BN_free(a);

  1021.   BN_free(b);

  1022.   BN_free(c);

  1023.   BN_free(d);

  1024.   BN_free(e);

  1025.   return (1);

  1026. }

  1027. 

  1028. /* Test constant-time modular exponentiation with 1024-bit inputs,

  1029.  * which on x86_64 cause a different code branch to be taken. */

  1030. int test_mod_exp_mont5(BIO *bp, BN_CTX *ctx) {

  1031.   BIGNUM *a, *p, *m, *d, *e;

  1032. 

  1033.   BN_MONT_CTX *mont;

  1034. 

  1035.   a = BN_new();

  1036.   p = BN_new();

  1037.   m = BN_new();

  1038.   d = BN_new();

  1039.   e = BN_new();

  1040. 

  1041.   mont = BN_MONT_CTX_new();

  1042. 

  1043.   BN_rand(m, 1024, 0, 1); /* must be odd for montgomery */

  1044.   /* Zero exponent */

  1045.   BN_rand(a, 1024, 0, 0);

  1046.   BN_zero(p);

  1047.   if (!BN_mod_exp_mont_consttime(d, a, p, m, ctx, NULL))

  1048.     return 0;

  1049.   if (!BN_is_one(d)) {

  1050.     fprintf(stderr, "Modular exponentiation test failed!\n");

  1051.     return 0;

  1052.   }

  1053.   /* Zero input */

  1054.   BN_rand(p, 1024, 0, 0);

  1055.   BN_zero(a);

  1056.   if (!BN_mod_exp_mont_consttime(d, a, p, m, ctx, NULL))

  1057.     return 0;

  1058.   if (!BN_is_zero(d)) {

  1059.     fprintf(stderr, "Modular exponentiation test failed!\n");

  1060.     return 0;

  1061.   }

  1062.   /* Craft an input whose Montgomery representation is 1,

  1063.    * i.e., shorter than the modulus m, in order to test

  1064.    * the const time precomputation scattering/gathering.

  1065.    */

  1066.   BN_one(a);

  1067.   BN_MONT_CTX_set(mont, m, ctx);

  1068.   if (!BN_from_montgomery(e, a, mont, ctx) ||

  1069.       !BN_mod_exp_mont_consttime(d, e, p, m, ctx, NULL) ||

  1070.       !BN_mod_exp(a, e, p, m, ctx)) {

  1071.     return 0;

  1072.   }

  1073.   if (BN_cmp(a, d) != 0) {

  1074.     fprintf(stderr, "Modular exponentiation test failed!\n");

  1075.     return 0;

  1076.   }

  1077.   /* Finally, some regular test vectors. */

  1078.   BN_rand(e, 1024, 0, 0);

  1079.   if (!BN_mod_exp_mont_consttime(d, e, p, m, ctx, NULL))

  1080.     return 0;

  1081.   if (!BN_mod_exp(a, e, p, m, ctx))

  1082.     return 0;

  1083.   if (BN_cmp(a, d) != 0) {

  1084.     fprintf(stderr, "Modular exponentiation test failed!\n");

  1085.     return 0;

  1086.   }

  1087. 

  1088.   BN_MONT_CTX_free(mont);

  1089.   BN_free(a);

  1090.   BN_free(p);

  1091.   BN_free(m);

  1092.   BN_free(d);

  1093.   BN_free(e);

  1094.   return (1);

  1095. }

  1096. 

  1097. int test_exp(BIO *bp, BN_CTX *ctx) {

  1098.   BIGNUM *a, *b, *d, *e, *one;

  1099.   int i;

  1100. 

  1101.   a = BN_new();

  1102.   b = BN_new();

  1103.   d = BN_new();

  1104.   e = BN_new();

  1105.   one = BN_new();

  1106.   BN_one(one);

  1107. 

  1108.   for (i = 0; i < num2; i++) {

  1109.     BN_rand(a, 20 + i * 5, 0, 0); /**/

  1110.     BN_rand(b, 2 + i, 0, 0);      /**/

  1111. 

  1112.     if (BN_exp(d, a, b, ctx) <= 0)

  1113.       return (0);

  1114. 

  1115.     if (bp != NULL) {

  1116.       if (!results) {

  1117.         BN_print(bp, a);

  1118.         BIO_puts(bp, " ^ ");

  1119.         BN_print(bp, b);

  1120.         BIO_puts(bp, " - ");

  1121.       }

  1122.       BN_print(bp, d);

  1123.       BIO_puts(bp, "\n");

  1124.     }

  1125.     BN_one(e);

  1126.     for (; !BN_is_zero(b); BN_sub(b, b, one))

  1127.       BN_mul(e, e, a, ctx);

  1128.     BN_sub(e, e, d);

  1129.     if (!BN_is_zero(e)) {

  1130.       fprintf(stderr, "Exponentiation test failed!\n");

  1131.       return 0;

  1132.     }

  1133.   }

  1134.   BN_free(a);

  1135.   BN_free(b);

  1136.   BN_free(d);

  1137.   BN_free(e);

  1138.   BN_free(one);

  1139.   return (1);

  1140. }

  1141. 

  1142. /* test_exp_mod_zero tests that x**0 mod 1 == 0. */

  1143. static int test_exp_mod_zero() {

  1144.   BIGNUM a, p, m;

  1145.   BIGNUM r;

  1146.   BN_CTX *ctx = BN_CTX_new();

  1147.   int ret = 0;

  1148. 

  1149.   BN_init(&m);

  1150.   BN_one(&m);

  1151. 

  1152.   BN_init(&a);

  1153.   BN_one(&a);

  1154. 

  1155.   BN_init(&p);

  1156.   BN_zero(&p);

  1157. 

  1158.   BN_init(&r);

  1159.   BN_mod_exp(&r, &a, &p, &m, ctx);

  1160.   BN_CTX_free(ctx);

  1161. 

  1162.   if (BN_is_zero(&r)) {

  1163.     ret = 1;

  1164.   } else {

  1165.     printf("1**0 mod 1 = ");

  1166.     BN_print_fp(stdout, &r);

  1167.     printf(", should be 0\n");

  1168.   }

  1169. 

  1170.   BN_free(&r);

  1171.   BN_free(&a);

  1172.   BN_free(&p);

  1173.   BN_free(&m);

  1174. 

  1175.   return ret;

  1176. }

  1177. 

  1178. static int genprime_cb(int p, int n, BN_GENCB *arg) {

  1179.   char c = '*';

  1180. 

  1181.   if (p == 0)

  1182.     c = '.';

  1183.   if (p == 1)

  1184.     c = '+';

  1185.   if (p == 2)

  1186.     c = '*';

  1187.   if (p == 3)

  1188.     c = '\n';

  1189.   putc(c, stdout);

  1190.   fflush(stdout);

  1191.   return 1;

  1192. }

  1193. 

  1194. int test_mod_sqrt(BIO *bp, BN_CTX *ctx) {

  1195.   BN_GENCB cb;

  1196.   BIGNUM *a, *p, *r;

  1197.   int i, j;

  1198.   int ret = 0;

  1199. 

  1200.   a = BN_new();

  1201.   p = BN_new();

  1202.   r = BN_new();

  1203.   if (a == NULL || p == NULL || r == NULL)

  1204.     goto err;

  1205. 

  1206.   BN_GENCB_set(&cb, genprime_cb, NULL);

  1207. 

  1208.   for (i = 0; i < 16; i++) {

  1209.     if (i < 8) {

  1210.       unsigned primes[8] = {2, 3, 5, 7, 11, 13, 17, 19};

  1211. 

  1212.       if (!BN_set_word(p, primes[i]))

  1213.         goto err;

  1214.     } else {

  1215.       if (!BN_set_word(a, 32))

  1216.         goto err;

  1217.       if (!BN_set_word(r, 2 * i + 1))

  1218.         goto err;

  1219. 

  1220.       if (!BN_generate_prime_ex(p, 256, 0, a, r, &cb))

  1221.         goto err;

  1222.       putc('\n', stdout);

  1223.     }

  1224.     p->neg = rand_neg();

  1225. 

  1226.     for (j = 0; j < num2; j++) {

  1227.       /* construct 'a' such that it is a square modulo p,

  1228.        * but in general not a proper square and not reduced modulo p */

  1229.       if (!BN_rand(r, 256, 0, 3))

  1230.         goto err;

  1231.       if (!BN_nnmod(r, r, p, ctx))

  1232.         goto err;

  1233.       if (!BN_mod_sqr(r, r, p, ctx))

  1234.         goto err;

  1235.       if (!BN_rand(a, 256, 0, 3))

  1236.         goto err;

  1237.       if (!BN_nnmod(a, a, p, ctx))

  1238.         goto err;

  1239.       if (!BN_mod_sqr(a, a, p, ctx))

  1240.         goto err;

  1241.       if (!BN_mul(a, a, r, ctx))

  1242.         goto err;

  1243.       if (rand_neg())

  1244.         if (!BN_sub(a, a, p))

  1245.           goto err;

  1246. 

  1247.       if (!BN_mod_sqrt(r, a, p, ctx))

  1248.         goto err;

  1249.       if (!BN_mod_sqr(r, r, p, ctx))

  1250.         goto err;

  1251. 

  1252.       if (!BN_nnmod(a, a, p, ctx))

  1253.         goto err;

  1254. 

  1255.       if (BN_cmp(a, r) != 0) {

  1256.         fprintf(stderr, "BN_mod_sqrt failed: a = ");

  1257.         BN_print_fp(stderr, a);

  1258.         fprintf(stderr, ", r = ");

  1259.         BN_print_fp(stderr, r);

  1260.         fprintf(stderr, ", p = ");

  1261.         BN_print_fp(stderr, p);

  1262.         fprintf(stderr, "\n");

  1263.         goto err;

  1264.       }

  1265. 

  1266.       putc('.', stdout);

  1267.       fflush(stdout);

  1268.     }

  1269. 

  1270.     putc('\n', stdout);

  1271.     fflush(stderr);

  1272.   }

  1273.   ret = 1;

  1274. err:

  1275.   if (a != NULL)

  1276.     BN_free(a);

  1277.   if (p != NULL)

  1278.     BN_free(p);

  1279.   if (r != NULL)

  1280.     BN_free(r);

  1281.   return ret;

  1282. }

  1283. 

  1284. int test_small_prime(BIO *bp, BN_CTX *ctx) {

  1285.   static const int bits = 10;

  1286.   int ret = 0;

  1287.   BIGNUM r;

  1288. 

  1289.   BN_init(&r);

  1290.   if (!BN_generate_prime_ex(&r, bits, 0, NULL, NULL, NULL)) {

  1291.     goto err;

  1292.   }

  1293.   if (BN_num_bits(&r) != bits) {

  1294.     BIO_printf(bp, "Expected %d bit prime, got %d bit number\n", bits,

  1295.                BN_num_bits(&r));

  1296.     goto err;

  1297.   }

  1298. 

  1299.   ret = 1;

  1300. 

  1301. err:

  1302.   BN_free(&r);

  1303.   return ret;

  1304. }

  1305. 

  1306. int test_sqrt(BIO *bp, BN_CTX *ctx) {

  1307.   BIGNUM *n = BN_new(), *nn = BN_new(), *sqrt = BN_new();

  1308.   unsigned i;

  1309. 

  1310.   /* Test some random squares. */

  1311.   for (i = 0; i < 100; i++) {

  1312.     if (!BN_rand(n, 1024 /* bit length */, -1 /* no modification of top bits */,

  1313.                  0 /* don't modify bottom bit */) ||

  1314.         !BN_mul(nn, n, n, ctx) ||

  1315.         !BN_sqrt(sqrt, nn, ctx)) {

  1316.       BIO_print_errors_fp(stderr);

  1317.       return 0;

  1318.     }

  1319.     if (BN_cmp(n, sqrt) != 0) {

  1320.       fprintf(stderr, "Bad result from BN_sqrt.\n");

  1321.       return 0;

  1322.     }

  1323.   }

  1324. 

  1325.   /* Test some non-squares */

  1326.   for (i = 0; i < 100; i++) {

  1327.     if (!BN_rand(n, 1024 /* bit length */, -1 /* no modification of top bits */,

  1328.                  0 /* don't modify bottom bit */) ||

  1329.         !BN_mul(nn, n, n, ctx) ||

  1330.         !BN_add(nn, nn, BN_value_one())) {

  1331.       BIO_print_errors_fp(stderr);

  1332.       return 0;

  1333.     }

  1334. 

  1335.     if (BN_sqrt(sqrt, nn, ctx)) {

  1336.       char *nn_str = BN_bn2dec(nn);

  1337.       fprintf(stderr, "BIO_sqrt didn't fail on a non-square: %s\n", nn_str);

  1338.       OPENSSL_free(nn_str);

  1339.     }

  1340.   }

  1341. 

  1342.   BN_free(n);

  1343.   BN_free(sqrt);

  1344.   BN_free(nn);

  1345. 

  1346.   return 1;

  1347. }

  1348. 

  1349. int test_bn2bin_padded(BIO *bp, BN_CTX *ctx) {

  1350.   BIGNUM *n = BN_new();

  1351.   uint8_t zeros[256], out[256], reference[128];

  1352.   size_t bytes;

  1353. 

  1354.   memset(zeros, 0, sizeof(zeros));

  1355. 

  1356.   /* Test edge case at 0. */

  1357.   if (!BN_bn2bin_padded(NULL, 0, n)) {

  1358.     fprintf(stderr,

  1359.             "BN_bn2bin_padded failed to encode 0 in an empty buffer.\n");

  1360.     return 0;

  1361.   }

  1362.   memset(out, -1, sizeof(out));

  1363.   if (!BN_bn2bin_padded(out, sizeof(out), n)) {

  1364.     fprintf(stderr,

  1365.             "BN_bn2bin_padded failed to encode 0 in a non-empty buffer.\n");

  1366.     return 0;

  1367.   }

  1368.   if (memcmp(zeros, out, sizeof(out))) {

  1369.     fprintf(stderr, "BN_bn2bin_padded did not zero buffer.\n");

  1370.     return 0;

  1371.   }

  1372. 

  1373.   /* Test a random numbers at various byte lengths. */

  1374.   for (bytes = 128 - 7; bytes <= 128; bytes++) {

  1375.     if (!BN_rand(n, bytes * 8, 0 /* make sure top bit is 1 */,

  1376.                  0 /* don't modify bottom bit */)) {

  1377.       BIO_print_errors_fp(stderr);

  1378.       return 0;

  1379.     }

  1380.     if (BN_num_bytes(n) != bytes || BN_bn2bin(n, reference) != bytes) {

  1381.       fprintf(stderr, "Bad result from BN_rand; bytes.\n");

  1382.       return 0;

  1383.     }

  1384.     /* Empty buffer should fail. */

  1385.     if (BN_bn2bin_padded(NULL, 0, n)) {

  1386.       fprintf(stderr,

  1387.               "BN_bn2bin_padded incorrectly succeeded on empty buffer.\n");

  1388.       return 0;

  1389.     }

  1390.     /* One byte short should fail. */

  1391.     if (BN_bn2bin_padded(out, bytes - 1, n)) {

  1392.       fprintf(stderr, "BN_bn2bin_padded incorrectly succeeded on short.\n");

  1393.       return 0;

  1394.     }

  1395.     /* Exactly right size should encode. */

  1396.     if (!BN_bn2bin_padded(out, bytes, n) ||

  1397.         memcmp(out, reference, bytes) != 0) {

  1398.       fprintf(stderr, "BN_bn2bin_padded gave a bad result.\n");

  1399.       return 0;

  1400.     }

  1401.     /* Pad up one byte extra. */

  1402.     if (!BN_bn2bin_padded(out, bytes + 1, n) ||

  1403.         memcmp(out + 1, reference, bytes) || memcmp(out, zeros, 1)) {

  1404.       fprintf(stderr, "BN_bn2bin_padded gave a bad result.\n");

  1405.       return 0;

  1406.     }

  1407.     /* Pad up to 256. */

  1408.     if (!BN_bn2bin_padded(out, sizeof(out), n) ||

  1409.         memcmp(out + sizeof(out) - bytes, reference, bytes) ||

  1410.         memcmp(out, zeros, sizeof(out) - bytes)) {

  1411.       fprintf(stderr, "BN_bn2bin_padded gave a bad result.\n");

  1412.       return 0;

  1413.     }

  1414.   }

  1415. 

  1416.   BN_free(n);

  1417. 

  1418.   return 1;

  1419. }