bn_mul_normal man page on OSF1

Man page or keyword search:  
man Server   12896 pages
apropos Keyword Search (all sections)
Output format
OSF1 logo
[printable version]

bn_internal(3)							bn_internal(3)

NAME
       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
       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
       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
	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  sig‐
       nificant	 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	struc‐
       ture contains BN_CTX_NUM BIGNUMs. See

       BN_CTX_start(3).

   Low-level arithmetic operations
       These  functions	 are  implemented  in  C  and for several platforms in
       assembly language: Operates on the num word arrays rp and ap.  It  com‐
       putes  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 com‐
       putes  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	other‐
       wise).	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
       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
       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
       Functions: bn(3)

								bn_internal(3)
[top]
                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server OSF1

List of man pages available for OSF1

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net