Make bn opaque

[openssl.git] / crypto / bn / bn_lcl.h

diff --git a/crypto/bn/bn_lcl.h b/crypto/bn/bn_lcl.h
index 74cea91c1cf9a1c316321be2cf92f24b219dc280..5ca1b9c911400a2028558a4aa68935a85f8f749a 100644 (file)
--- a/crypto/bn/bn_lcl.h
+++ b/crypto/bn/bn_lcl.h
@@ -112,13 +112,63 @@
 #ifndef HEADER_BN_LCL_H
 #define HEADER_BN_LCL_H
 
-#include <openssl/bn.h>
+#include "internal/bn_int.h"
 
 #ifdef  __cplusplus
 extern "C" {
 #endif
 
 
+struct bignum_st
+       {
+       BN_ULONG *d;    /* Pointer to an array of 'BN_BITS2' bit chunks. */
+       int top;        /* Index of last used d +1. */
+       /* The next are internal book keeping for bn_expand. */
+       int dmax;       /* Size of the d array. */
+       int neg;        /* one if the number is negative */
+       int flags;
+       };
+
+/* Used for montgomery multiplication */
+struct bn_mont_ctx_st
+       {
+       int ri;        /* number of bits in R */
+       BIGNUM RR;     /* used to convert to montgomery form */
+       BIGNUM N;      /* The modulus */
+       BIGNUM Ni;     /* R*(1/R mod N) - N*Ni = 1
+                       * (Ni is only stored for bignum algorithm) */
+       BN_ULONG n0[2];/* least significant word(s) of Ni;
+                         (type changed with 0.9.9, was "BN_ULONG n0;" before) */
+       int flags;
+       };
+
+/* Used for reciprocal division/mod functions
+ * It cannot be shared between threads
+ */
+struct bn_recp_ctx_st
+       {
+       BIGNUM N;       /* the divisor */
+       BIGNUM Nr;      /* the reciprocal */
+       int num_bits;
+       int shift;
+       int flags;
+       };
+
+/* Used for slow "generation" functions. */
+struct bn_gencb_st
+       {
+       unsigned int ver;       /* To handle binary (in)compatibility */
+       void *arg;              /* callback-specific data */
+       union
+               {
+               /* if(ver==1) - handles old style callbacks */
+               void (*cb_1)(int, int, void *);
+               /* if(ver==2) - new callback style */
+               int (*cb_2)(int, int, BN_GENCB *);
+               } cb;
+       };
+
+
 /*
  * BN_window_bits_for_exponent_size -- macro for sliding window mod_exp functions
  *
@@ -300,16 +350,32 @@ extern "C" {
 #  endif
 # elif defined(__mips) && (defined(SIXTY_FOUR_BIT) || defined(SIXTY_FOUR_BIT_LONG))
 #  if defined(__GNUC__) && __GNUC__>=2
-#   define BN_UMULT_HIGH(a,b)  ({      \
+#   if __GNUC__>=4 && __GNUC_MINOR__>=4 /* "h" constraint is no more since 4.4 */
+#     define BN_UMULT_HIGH(a,b)                 (((__uint128_t)(a)*(b))>>64)
+#     define BN_UMULT_LOHI(low,high,a,b) ({    \
+       __uint128_t ret=(__uint128_t)(a)*(b);   \
+       (high)=ret>>64; (low)=ret;       })
+#   else
+#     define BN_UMULT_HIGH(a,b)        ({      \
        register BN_ULONG ret;          \
        asm ("dmultu    %1,%2"          \
             : "=h"(ret)                \
             : "r"(a), "r"(b) : "l");   \
        ret;                    })
-#   define BN_UMULT_LOHI(low,high,a,b) \
+#     define BN_UMULT_LOHI(low,high,a,b)\
        asm ("dmultu    %2,%3"          \
             : "=l"(low),"=h"(high)     \
             : "r"(a), "r"(b));
+#    endif
+#  endif
+# elif defined(__aarch64__) && defined(SIXTY_FOUR_BIT_LONG)
+#  if defined(__GNUC__) && __GNUC__>=2
+#   define BN_UMULT_HIGH(a,b)  ({      \
+       register BN_ULONG ret;          \
+       asm ("umulh     %0,%1,%2"       \
+            : "=r"(ret)                \
+            : "r"(a), "r"(b));         \
+       ret;                    })
 #  endif
 # endif                /* cpu */
 #endif         /* OPENSSL_NO_ASM */
@@ -490,6 +556,10 @@ extern "C" {
        }
 #endif /* !BN_LLONG */
 
+void BN_init(BIGNUM *a);
+void BN_RECP_CTX_init(BN_RECP_CTX *recp);
+void BN_MONT_CTX_init(BN_MONT_CTX *ctx);
+
 void bn_mul_normal(BN_ULONG *r,BN_ULONG *a,int na,BN_ULONG *b,int nb);
 void bn_mul_comba8(BN_ULONG *r,BN_ULONG *a,BN_ULONG *b);
 void bn_mul_comba4(BN_ULONG *r,BN_ULONG *a,BN_ULONG *b);
@@ -518,6 +588,11 @@ int bn_mul_mont(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp, const BN_U
 BIGNUM *int_bn_mod_inverse(BIGNUM *in,
        const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx, int *noinv);
 
+int bn_probable_prime_dh(BIGNUM *rnd, int bits,
+       const BIGNUM *add, const BIGNUM *rem, BN_CTX *ctx);
+int bn_probable_prime_dh_retry(BIGNUM *rnd, int bits, BN_CTX *ctx);
+int bn_probable_prime_dh_coprime(BIGNUM *rnd, int bits, BN_CTX *ctx);
+
 #ifdef  __cplusplus
 }
 #endif