Add actual testing to bntest...

diff --git a/CHANGES b/CHANGES
index b72f682386a11d54f0b0bfb6fa3d9dfbd962ed00..9946a9578525714452c6ce4fe1ca1b46768332d6 100644 (file)
--- a/CHANGES
+++ b/CHANGES
@@ -10,6 +10,9 @@
                                    [23-Dec-1998] down below; but in later
                                    versions, these hyphens are gone.]
 
+  *) Belatedly make the BN tests actually check the results.
+     [Ben Laurie]
+
   *) Fix the encoding and decoding of negative ASN1 INTEGERS and conversion
      to and from BNs: it was completely broken. New compilation option
      NEG_PUBKEY_BUG to allow for some broken certificates that encode public

diff --git a/crypto/bn/bntest.c b/crypto/bn/bntest.c
index c60cee7388e2bc7c6b959ec4b06152f93221fb0f..ff4d6fea113637c3154a8ba5cef827a216befc7e 100644 (file)
--- a/crypto/bn/bntest.c
+++ b/crypto/bn/bntest.c
@@ -73,9 +73,9 @@
 int test_add(BIO *bp);
 int test_sub(BIO *bp);
 int test_lshift1(BIO *bp);
-int test_lshift(BIO *bp);
+int test_lshift(BIO *bp,BN_CTX *ctx);
 int test_rshift1(BIO *bp);
-int test_rshift(BIO *bp);
+int test_rshift(BIO *bp,BN_CTX *ctx);
 int test_div(BIO *bp,BN_CTX *ctx);
 int test_div_recp(BIO *bp,BN_CTX *ctx);
 int test_mul(BIO *bp);
@@ -151,7 +151,7 @@ int main(int argc, char *argv[])
        fflush(stdout);
 
        fprintf(stderr,"test BN_lshift\n");
-       if (!test_lshift(out)) goto err;
+       if (!test_lshift(out,ctx)) goto err;
        fflush(stdout);
 
        fprintf(stderr,"test BN_rshift1\n");
@@ -159,7 +159,7 @@ int main(int argc, char *argv[])
        fflush(stdout);
 
        fprintf(stderr,"test BN_rshift\n");
-       if (!test_rshift(out)) goto err;
+       if (!test_rshift(out,ctx)) goto err;
        fflush(stdout);
 
        fprintf(stderr,"test BN_sqr\n");
@@ -240,6 +240,15 @@ int test_add(BIO *bp)
                        BN_print(bp,&c);
                        BIO_puts(bp,"\n");
                        }
+               a.neg=!a.neg;
+               b.neg=!b.neg;
+               BN_add(&c,&c,&b);
+               BN_add(&c,&c,&a);
+               if(!BN_is_zero(&c))
+                   {
+                   BIO_puts(bp,"Add test failed!\n");
+                   return 0;
+                   }
                }
        BN_free(&a);
        BN_free(&b);
@@ -279,6 +288,13 @@ int test_sub(BIO *bp)
                        BN_print(bp,&c);
                        BIO_puts(bp,"\n");
                        }
+               BN_add(&c,&c,&b);
+               BN_sub(&c,&c,&a);
+               if(!BN_is_zero(&c))
+                   {
+                   BIO_puts(bp,"Subtract test failed!\n");
+                   return 0;
+                   }
                }
        BN_free(&a);
        BN_free(&b);
@@ -288,7 +304,7 @@ int test_sub(BIO *bp)
 
 int test_div(BIO *bp, BN_CTX *ctx)
        {
-       BIGNUM a,b,c,d;
+       BIGNUM a,b,c,d,e;
        int i;
        int j;
 
@@ -296,6 +312,7 @@ int test_div(BIO *bp, BN_CTX *ctx)
        BN_init(&b);
        BN_init(&c);
        BN_init(&d);
+       BN_init(&e);
 
        BN_rand(&a,400,0,0);
        for (i=0; i<100; i++)
@@ -329,17 +346,26 @@ int test_div(BIO *bp, BN_CTX *ctx)
                        BN_print(bp,&c);
                        BIO_puts(bp,"\n");
                        }
+               BN_mul(&e,&d,&b,ctx);
+               BN_add(&d,&e,&c);
+               BN_sub(&d,&d,&a);
+               if(!BN_is_zero(&d))
+                   {
+                   BIO_puts(bp,"Division test failed!\n");
+                   return 0;
+                   }
                }
        BN_free(&a);
        BN_free(&b);
        BN_free(&c);
        BN_free(&d);
+       BN_free(&e);
        return(1);
        }
 
 int test_div_recp(BIO *bp, BN_CTX *ctx)
        {
-       BIGNUM a,b,c,d;
+       BIGNUM a,b,c,d,e;
        BN_RECP_CTX recp;
        int i;
        int j;
@@ -349,6 +375,7 @@ int test_div_recp(BIO *bp, BN_CTX *ctx)
        BN_init(&b);
        BN_init(&c);
        BN_init(&d);
+       BN_init(&e);
 
        BN_rand(&a,400,0,0);
        for (i=0; i<100; i++)
@@ -383,18 +410,27 @@ int test_div_recp(BIO *bp, BN_CTX *ctx)
                        BN_print(bp,&c);
                        BIO_puts(bp,"\n");
                        }
+               BN_mul(&e,&d,&b,ctx);
+               BN_add(&d,&e,&c);
+               BN_sub(&d,&d,&a);
+               if(!BN_is_zero(&d))
+                   {
+                   BIO_puts(bp,"Reciprocal division test failed!\n");
+                   return 0;
+                   }
                }
        BN_free(&a);
        BN_free(&b);
        BN_free(&c);
        BN_free(&d);
+       BN_free(&e);
        BN_RECP_CTX_free(&recp);
        return(1);
        }
 
 int test_mul(BIO *bp)
        {
-       BIGNUM a,b,c;
+       BIGNUM a,b,c,d,e;
        int i;
        int j;
        BN_CTX ctx;
@@ -403,6 +439,8 @@ int test_mul(BIO *bp)
        BN_init(&a);
        BN_init(&b);
        BN_init(&c);
+       BN_init(&d);
+       BN_init(&e);
 
        BN_rand(&a,200,0,0);
        for (i=0; i<100; i++)
@@ -415,7 +453,6 @@ int test_mul(BIO *bp)
                        for (j=0; j<100; j++)
                                BN_mul(&c,&a,&b,&ctx);
                BN_mul(&c,&a,&b,&ctx);
-/*bn_do(&c,&a,&b,ctx); */
                if (bp != NULL)
                        {
                        if (!results)
@@ -428,22 +465,33 @@ int test_mul(BIO *bp)
                        BN_print(bp,&c);
                        BIO_puts(bp,"\n");
                        }
+               BN_div(&d,&e,&c,&a,&ctx);
+               BN_sub(&d,&d,&b);
+               if(!BN_is_zero(&d) || !BN_is_zero(&e))
+                   {
+                   BIO_puts(bp,"Multiplication test failed!\n");
+                   return 0;
+                   }
                }
        BN_free(&a);
        BN_free(&b);
        BN_free(&c);
+       BN_free(&d);
+       BN_free(&e);
        BN_CTX_free(&ctx);
        return(1);
        }
 
 int test_sqr(BIO *bp, BN_CTX *ctx)
        {
-       BIGNUM a,c;
+       BIGNUM a,c,d,e;
        int i;
        int j;
 
        BN_init(&a);
        BN_init(&c);
+       BN_init(&d);
+       BN_init(&e);
 
        for (i=0; i<40; i++)
                {
@@ -465,15 +513,24 @@ int test_sqr(BIO *bp, BN_CTX *ctx)
                        BN_print(bp,&c);
                        BIO_puts(bp,"\n");
                        }
+               BN_div(&d,&e,&c,&a,ctx);
+               BN_sub(&d,&d,&a);
+               if(!BN_is_zero(&d) || !BN_is_zero(&e))
+                   {
+                   BIO_puts(bp,"Square test failed!\n");
+                   return 0;
+                   }
                }
        BN_free(&a);
        BN_free(&c);
+       BN_free(&d);
+       BN_free(&e);
        return(1);
        }
 
 int test_mont(BIO *bp, BN_CTX *ctx)
        {
-       BIGNUM a,b,c,A,B;
+       BIGNUM a,b,c,d,A,B;
        BIGNUM n;
        int i;
        int j;
@@ -482,6 +539,7 @@ int test_mont(BIO *bp, BN_CTX *ctx)
        BN_init(&a);
        BN_init(&b);
        BN_init(&c);
+       BN_init(&d);
        BN_init(&A);
        BN_init(&B);
        BN_init(&n);
@@ -523,23 +581,36 @@ BN_num_bits(mont->N));
                        BN_print(bp,&A);
                        BIO_puts(bp,"\n");
                        }
+               BN_mod_mul(&d,&a,&b,&n,ctx);
+               BN_sub(&d,&d,&A);
+               if(!BN_is_zero(&d))
+                   {
+                   BIO_puts(bp,"Montgomery multiplication test failed!\n");
+                   return 0;
+                   }
                }
        BN_MONT_CTX_free(mont);
        BN_free(&a);
        BN_free(&b);
        BN_free(&c);
+       BN_free(&d);
+       BN_free(&A);
+       BN_free(&B);
+       BN_free(&n);
        return(1);
        }
 
 int test_mod(BIO *bp, BN_CTX *ctx)
        {
-       BIGNUM *a,*b,*c;
+       BIGNUM *a,*b,*c,*d,*e;
        int i;
        int j;
 
        a=BN_new();
        b=BN_new();
        c=BN_new();
+       d=BN_new();
+       e=BN_new();
 
        BN_rand(a,1024,0,0); /**/
        for (i=0; i<20; i++)
@@ -563,10 +634,19 @@ int test_mod(BIO *bp, BN_CTX *ctx)
                        BN_print(bp,c);
                        BIO_puts(bp,"\n");
                        }
+               BN_div(d,e,a,b,ctx);
+               BN_sub(e,e,c);
+               if(!BN_is_zero(e))
+                   {
+                   BIO_puts(bp,"Modulo test failed!\n");
+                   return 0;
+                   }
                }
        BN_free(a);
        BN_free(b);
        BN_free(c);
+       BN_free(d);
+       BN_free(e);
        return(1);
        }
 
@@ -615,6 +695,14 @@ int test_mod_mul(BIO *bp, BN_CTX *ctx)
                        BN_print(bp,e);
                        BIO_puts(bp,"\n");
                        }
+               BN_mul(d,a,b,ctx);
+               BN_sub(d,d,e);
+               BN_div(a,b,d,c,ctx);
+               if(!BN_is_zero(b))
+                   {
+                   BIO_puts(bp,"Modulo multiply test failed!\n");
+                   return 0;
+                   }
                }
        BN_free(a);
        BN_free(b);
@@ -658,6 +746,14 @@ int test_mod_exp(BIO *bp, BN_CTX *ctx)
                        BN_print(bp,d);
                        BIO_puts(bp,"\n");
                        }
+               BN_exp(e,a,b,ctx);
+               BN_sub(e,e,d);
+               BN_div(a,b,e,c,ctx);
+               if(!BN_is_zero(b))
+                   {
+                   BIO_puts(bp,"Modulo exponentiation test failed!\n");
+                   return 0;
+                   }
                }
        BN_free(a);
        BN_free(b);
@@ -669,13 +765,15 @@ int test_mod_exp(BIO *bp, BN_CTX *ctx)
 
 int test_exp(BIO *bp, BN_CTX *ctx)
        {
-       BIGNUM *a,*b,*d,*e;
+       BIGNUM *a,*b,*d,*e,*one;
        int i;
 
        a=BN_new();
        b=BN_new();
        d=BN_new();
        e=BN_new();
+       one=BN_new();
+       BN_one(one);
 
        for (i=0; i<6; i++)
                {
@@ -697,22 +795,33 @@ int test_exp(BIO *bp, BN_CTX *ctx)
                        BN_print(bp,d);
                        BIO_puts(bp,"\n");
                        }
+               BN_one(e);
+               for( ; !BN_is_zero(b) ; BN_sub(b,b,one))
+                   BN_mul(e,e,a,ctx);
+               BN_sub(e,e,d);
+               if(!BN_is_zero(e))
+                   {
+                   BIO_puts(bp,"Exponentiation test failed!\n");
+                   return 0;
+                   }
                }
        BN_free(a);
        BN_free(b);
        BN_free(d);
        BN_free(e);
+       BN_free(one);
        return(1);
        }
 
-int test_lshift(BIO *bp)
+int test_lshift(BIO *bp,BN_CTX *ctx)
        {
-       BIGNUM *a,*b,*c;
+       BIGNUM *a,*b,*c,*d;
        int i;
 
        a=BN_new();
        b=BN_new();
        c=BN_new();
+       d=BN_new();
        BN_one(c);
 
        BN_rand(a,200,0,0); /**/
@@ -733,20 +842,29 @@ int test_lshift(BIO *bp)
                        BN_print(bp,b);
                        BIO_puts(bp,"\n");
                        }
+               BN_mul(d,a,c,ctx);
+               BN_sub(d,d,b);
+               if(!BN_is_zero(d))
+                   {
+                   BIO_puts(bp,"Left shift test failed!\n");
+                   return 0;
+                   }
                }
        BN_free(a);
        BN_free(b);
        BN_free(c);
+       BN_free(d);
        return(1);
        }
 
 int test_lshift1(BIO *bp)
        {
-       BIGNUM *a,*b;
+       BIGNUM *a,*b,*c;
        int i;
 
        a=BN_new();
        b=BN_new();
+       c=BN_new();
 
        BN_rand(a,200,0,0); /**/
        a->neg=rand_neg();
@@ -764,21 +882,32 @@ int test_lshift1(BIO *bp)
                        BN_print(bp,b);
                        BIO_puts(bp,"\n");
                        }
+               BN_add(c,a,a);
+               BN_sub(a,b,c);
+               if(!BN_is_zero(a))
+                   {
+                   BIO_puts(bp,"Left shift one test failed!\n");
+                   return 0;
+                   }
+               
                BN_copy(a,b);
                }
        BN_free(a);
        BN_free(b);
+       BN_free(c);
        return(1);
        }
 
-int test_rshift(BIO *bp)
+int test_rshift(BIO *bp,BN_CTX *ctx)
        {
-       BIGNUM *a,*b,*c;
+       BIGNUM *a,*b,*c,*d,*e;
        int i;
 
        a=BN_new();
        b=BN_new();
        c=BN_new();
+       d=BN_new();
+       e=BN_new();
        BN_one(c);
 
        BN_rand(a,200,0,0); /**/
@@ -799,20 +928,30 @@ int test_rshift(BIO *bp)
                        BN_print(bp,b);
                        BIO_puts(bp,"\n");
                        }
+               BN_div(d,e,a,c,ctx);
+               BN_sub(d,d,b);
+               if(!BN_is_zero(d))
+                   {
+                   BIO_puts(bp,"Right shift test failed!\n");
+                   return 0;
+                   }
                }
        BN_free(a);
        BN_free(b);
        BN_free(c);
+       BN_free(d);
+       BN_free(e);
        return(1);
        }
 
 int test_rshift1(BIO *bp)
        {
-       BIGNUM *a,*b;
+       BIGNUM *a,*b,*c;
        int i;
 
        a=BN_new();
        b=BN_new();
+       c=BN_new();
 
        BN_rand(a,200,0,0); /**/
        a->neg=rand_neg();
@@ -830,10 +969,18 @@ int test_rshift1(BIO *bp)
                        BN_print(bp,b);
                        BIO_puts(bp,"\n");
                        }
+               BN_sub(c,a,b);
+               BN_sub(c,c,b);
+               if(!BN_is_zero(c) && !BN_is_one(c))
+                   {
+                   BIO_puts(bp,"Right shift one test failed!\n");
+                   return 0;
+                   }
                BN_copy(a,b);
                }
        BN_free(a);
        BN_free(b);
+       BN_free(c);
        return(1);
        }