*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->Tru64 Unix man pages -> bn_set_low (3)              
Title
Content
Arch
Section
 

bn_internal(3)

Contents


NAME    [Toc]    [Back]

       bn_internal, bn_mul_words, bn_mul_add_words, bn_sqr_words,
       bn_div_words, bn_add_words,  bn_sub_words,  bn_mul_comba4,
       bn_mul_comba8, bn_sqr_comba4, bn_sqr_comba8, bn_cmp_words,
       bn_mul_normal,    bn_mul_low_normal,     bn_mul_recursive,
       bn_mul_part_recursive,  bn_mul_low_recursive, bn_mul_high,
       bn_sqr_normal,  bn_sqr_recursive,  bn_expand,  bn_wexpand,
       bn_expand2,  bn_fix_top,  bn_check_top, bn_print, bn_dump,
       bn_set_max,  bn_set_high,  bn_set_low  -  BIGNUM   library
       internal functions

SYNOPSIS    [Toc]    [Back]

       BN_ULONG bn_mul_words(
               BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w );
       BN_ULONG bn_mul_add_words(
               BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w );
       void bn_sqr_words(
               BN_ULONG  *rp,  BN_ULONG  *ap, int num ); BN_ULONG
       bn_div_words(
               BN_ULONG h, BN_ULONG l,  BN_ULONG  d  );  BN_ULONG
       bn_add_words(
               BN_ULONG  *rp, BN_ULONG *ap, BN_ULONG *bp, int num
       ); BN_ULONG bn_sub_words(
               BN_ULONG *rp, BN_ULONG *ap, BN_ULONG *bp, int  num
       ); void bn_mul_comba4(
               BN_ULONG  *r,  BN_ULONG  *a,  BN_ULONG  *b ); void
       bn_mul_comba8(
               BN_ULONG *r, BN_ULONG  *a,  BN_ULONG  *b  );  void
       bn_sqr_comba4(
               BN_ULONG *r, BN_ULONG *a ); void bn_sqr_comba8(
               BN_ULONG *r, BN_ULONG *a ); int bn_cmp_words(
               BN_ULONG   *a,   BN_ULONG   *b,   int  n  );  void
       bn_mul_normal(
               BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int
       nb ); void bn_mul_low_normal(
               BN_ULONG  *r,  BN_ULONG  *a, BN_ULONG *b, int n );
       void bn_mul_recursive(
               BN_ULONG *r, BN_ULONG *a,  BN_ULONG  *b,  int  n2,
       BN_ULONG *tmp ); void bn_mul_part_recursive(
               BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int tn, int
       n, BN_ULONG *tmp ); void bn_mul_low_recursive(
               BN_ULONG *r, BN_ULONG *a,  BN_ULONG  *b,  int  n2,
       BN_ULONG *tmp ); void bn_mul_high(
               BN_ULONG  *r,  BN_ULONG  *a, BN_ULONG *b, BN_ULONG
       *l, int n2, BN_ULONG *tmp ); void bn_sqr_normal(
               BN_ULONG *r, BN_ULONG *a, int n, BN_ULONG *tmp  );
       void bn_sqr_recursive(
               BN_ULONG *r, BN_ULONG *a, int n2, BN_ULONG *tmp );
       void mul(
               BN_ULONG r, BN_ULONG a, BN_ULONG w, BN_ULONG c  );
       void mul_add(
               BN_ULONG  r, BN_ULONG a, BN_ULONG w, BN_ULONG c );
       void sqr(
               BN_ULONG r0, BN_ULONG r1,  BN_ULONG  a  );  BIGNUM
       *bn_expand(
               BIGNUM *a, int bits ); BIGNUM *bn_wexpand(
               BIGNUM *a, int n ); BIGNUM *bn_expand2(
               BIGNUM *a, int n ); void bn_fix_top(
               BIGNUM *a ); void bn_check_top(
               BIGNUM *a ); void bn_print(
               BIGNUM *a ); void bn_dump(
               BN_ULONG *d, int n ); void bn_set_max(
               BIGNUM *a ); void bn_set_high(
               BIGNUM *r, BIGNUM *a, int n ); void bn_set_low(
               BIGNUM *r, BIGNUM *a, int n );

DESCRIPTION    [Toc]    [Back]

       This  page  describes  the  internal functions used by the
       OpenSSL BIGNUM implementation. They are described here  to
       facilitate  debugging  and extending the library. They are
       not to be used by applications.

   The BIGNUM structure    [Toc]    [Back]
        typedef struct bignum_st
               {
               int top;      /* index of last used d  (most  significant
 word) */
               BN_ULONG  *d;   /*  pointer to an array of 'BITS2'
       bit chunks */
               int max;      /* size of the d array */
               int neg;      /* sign */
               } BIGNUM;

       The  big  number  is  stored  in  d,  a  malloc  array  of
       BN_ULONGs,  least  significant  first.  A  BN_ULONG can be
       either 16, 32 or 64 bits in size (BITS2), depending on the
       number of bits specified in openssl/bn.h.

       The  max  is  the  size of the d array that has been allocated.
  The top is the last entry being used. For a  value
       of  4,  for example, bn.d[0]=4 and bn.top=1.  The neg is 1
       if the number is negative.  When a  BIGNUM  is  0,  the  d
       field can be NULL and top == 0.

       Various routines in this library require the use of temporary
  BIGNUM  variables  during  their  execution.   Since
       dynamic  memory  allocation  to  create  BIGNUMs is rather
       expensive when used in conjunction with  repeated  subroutine
  calls, the BN_CTX structure is used.  This structure
       contains BN_CTX_NUM BIGNUMs. See

       BN_CTX_start(3).

   Low-level arithmetic operations    [Toc]    [Back]
       These functions are implemented in C and for several platforms
  in  assembly  language:  Operates  on  the num word
       arrays rp and ap.  It computes ap * w, places  the  result
       in rp, and returns the high word (carry).  Operates on the
       num word arrays rp and ap.  It  computes  ap  *  w  +  rp,
       places  the  result  in  rp,  and  returns  the  high word
       (carry).  Operates on the num word array ap and the  2*num
       word  array ap.  It computes ap * ap word-wise, and places
       the low and high bytes of the result in rp.   Divides  the
       two  word number (h,l) by d and returns the result.  Operates
 on the num word arrays ap, bp and rp.  It computes ap
       +  bp,  places the result in rp, and returns the high word
       (carry).  Operates on the num word arrays ap, bp  and  rp.
       It  computes ap - bp, places the result in rp, and returns
       the carry (1 if bp > ap, 0 otherwise).  Operates on the  4
       word  arrays  a and b and the 8 word array r.  It computes
       a*b and places the result in r.  Operates  on  the  8-word
       arrays  a  and b and the 16-word array r.  It computes a*b
       and places the result in r.  Operates on the 4-word arrays
       a  and  b  and the 8-word array r.  Operates on the 8-word
       arrays a and b and the 16-word array r.

       The following functions are implemented in C: Operates  on
       the n word arrays a and b.  It returns 1, 0 and -1 if a is
       greater than, equal and less than b.  Operates on  the  na
       word array a, the nb word array b and the na+nb word array
       r.  It computes a*b and places the result in r.   Operates
       on  the  n  word arrays r, a and b.  It computes the n low
       words of a*b and places the result in r.  Operates on  the
       n2  word  arrays a and b and the 2*n2 word arrays r and t.
       The n2 must be a power of 2.  It computes a*b  and  places
       the result in r.  Operates on the n+tn word arrays a and b
       and the 4*n word arrays r and tmp.   Operates  on  the  n2
       word  arrays  r  and tmp and the n2/2 word arrays a and b.
       Operates on the n2 word arrays r, a, b and l (?)  and  the
       3*n2 word array tmp.

              BN_mul()  calls  bn_mul_normal(),  or  an optimized
              implementation if the factors have the  same  size:
              bn_mul_comba8()  is  used if they are 8 words long,
              bn_mul_recursive()  if   they   are   larger   than
              BN_MULL_SIZE_NORMAL and the size is an exact multiple
 of the word size,  and  bn_mul_part_recursive()
              for  others  that are larger than BN_MULL_SIZE_NORMAL.
  Operates on the n word array a  and  the  2*n
              word arrays tmp and r.

       The   implementations  use  the  following  macros  which,
       depending on the architecture, may use "long long" C operations
  or inline assembler. They are defined in bn_lcl.h.
       Computes w*a+c and places the low word of the result in  r
       and  the  high word in c.  Computes w*a+r+c and places the
       low word of the result in r and the high word in c.   Computes
  a*a and places the low word of the result in r0 and
       the high word in r1.

   Size changes    [Toc]    [Back]
       The bn_expand() macro ensures that b has enough space  for
       a  bits bit number.  The bn_wexpand() macro ensures that b
       has enough space for an n word number.  If the number  has
       to be expanded, both macros call bn_expand2(), which allocates
 a new d array and copies the data.  They return NULL
       on error, b otherwise.

       The bn_fix_top() macro reduces a->top to point to the most
       significant non-zero word when a has shrunk.

   Debugging    [Toc]    [Back]
       The  bn_check_top()  verifies  that  ((a)->top  >=  0   &&
       (a)->top <= (a)->max).  A violation will cause the program
       to abort.

       The bn_print() prints a to  stderr.   bn_dump()  prints  n
       words  at  d (in reverse order, i.e. most significant word
       first) to stderr.

       The bn_set_max() makes a a static number with a max of its
       current   size.   This   is   used   by  bn_set_low()  and
       bn_set_high() to make r a read-only BIGNUM  that  contains
       the n low or high words of a.

       If  BN_DEBUG  is  not defined, bn_check_top(), bn_print(),
       bn_dump(), and bn_set_max() are defined as empty macros.







SEE ALSO    [Toc]    [Back]

      
      
       Functions: bn(3)



                                                   bn_internal(3)
[ Back ]
 Similar pages
Name OS Title
perlclib OpenBSD Internal replacements for standard C library functions
BN_cmp OpenBSD BIGNUM comparison and test functions
BN_ucmp Tru64 BIGNUM comparison and test functions
BN_ucmp OpenBSD BIGNUM comparison and test functions
BN_is_zero OpenBSD BIGNUM comparison and test functions
BN_is_odd OpenBSD BIGNUM comparison and test functions
BN_is_one OpenBSD BIGNUM comparison and test functions
BN_cmp NetBSD BIGNUM comparison and test functions
BN_is_word Tru64 BIGNUM comparison and test functions
BN_is_one Tru64 BIGNUM comparison and test functions
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service