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
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 );
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.
Functions: bn(3)
bn_internal(3)
[ Back ] |
