Unit mseopensslbignum

Description

Uses

Classes, Interfaces, Objects and Records

Functions and Procedures

Types

Constants

Variables

Description

Overview

Classes, Interfaces, Objects and Records

Name	Description
Record `BIGNUM`
Record `BN_CTX`
Record `BN_BLINDING`
Record `BN_MONT_CTX`
Record `BN_RECP_CTX`

Functions and Procedures

function BN_to_montgomery(r, a: pBIGNUM; m_ctx: pBN_MONT_CTX; ctx: pBN_CTX): cint;

function BN_zero(n: pBIGNUM): cint;

function BN_one(n: pBIGNUM): cint;

function BN_num_bytes(const a: pBIGNUM): cint;

function BN_mod(rem: pBIGNUM; const a, m: pBIGNUM; ctx: pBN_CTX): cint;

Types

pBN_ULONG = ˆBN_ULONG;

BN_ULONG = culong;

pBIGNUM = ˆBIGNUM;

pBN_CTX = ˆBN_CTX;

pBN_BLINDING = ˆBN_BLINDING;

pBN_MONT_CTX = ˆBN_MONT_CTX;

pBN_RECP_CTX = ˆBN_RECP_CTX;

Variables

BN_new:function: pBIGNUM; cdecl;

BN_init: procedure(bn: pBIGNUM); cdecl;

BN_clear: procedure(bn: pBIGNUM); cdecl;

BN_free: procedure(bn: pBIGNUM); cdecl;

BN_clear_free: procedure(bn: pBIGNUM); cdecl;

BN_set_params: procedure(mul, high, low, mont: cint); cdecl;

BN_get_params: function(which: cint): cint; cdecl;

BN_options:function: PCharacter; cdecl;

BN_CTX_new: function: pBN_CTX; cdecl;

BN_CTX_init: procedure(ctx: pBN_CTX); cdecl;

BN_CTX_start: procedure(ctx: pBN_CTX); cdecl;

BN_CTX_get: function(ctx: pBN_CTX): pBIGNUM; cdecl;

BN_CTX_end: procedure(ctx: pBN_CTX); cdecl;

BN_CTX_free: procedure(ctx: pBN_CTX); cdecl;

BN_MONT_CTX_new: function: pBN_MONT_CTX; cdecl;

BN_MONT_CTX_init: procedure(m_ctx: pBN_MONT_CTX); cdecl;

BN_MONT_CTX_set: function(m_ctx: pBN_MONT_CTX;const modulus: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_MONT_CTX_copy: function(_to: pBN_MONT_CTX; from: pBN_MONT_CTX): pBN_MONT_CTX; cdecl;

BN_MONT_CTX_free: procedure(m_ctx: pBN_MONT_CTX); cdecl;

BN_mod_mul_montgomery: function(r, a, b: pBIGNUM; m_ctx: pBN_MONT_CTX; ctx: pBN_CTX): cint; cdecl;

BN_from_montgomery: function(r, a: pBIGNUM; m_ctx: pBN_MONT_CTX; ctx: pBN_CTX): cint; cdecl;

BN_RECP_CTX_init: procedure(recp: pBN_RECP_CTX); cdecl;

BN_RECP_CTX_set: function(recp: pBN_RECP_CTX; const rdiv: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_RECP_CTX_new: function: pBN_RECP_CTX; cdecl;

BN_RECP_CTX_free: procedure(recp: pBN_RECP_CTX); cdecl;

BN_div_recp: function(dv, rem, a: pBIGNUM; recp: pBN_RECP_CTX; ctx: pBN_CTX): cint; cdecl;

BN_mod_mul_reciprocal: function(r, a, b: pBIGNUM; recp: pBN_RECP_CTX; ctx: pBN_CTX): cint; cdecl;

BN_BLINDING_new: function(a: pBIGNUM; Ai: pBIGNUM; _mod: pBIGNUM): pBN_BLINDING; cdecl;

BN_BLINDING_update: function(b: pBN_BLINDING; ctx: pBN_CTX): pBN_BLINDING; cdecl;

BN_BLINDING_free: procedure(b: pBN_BLINDING); cdecl;

BN_BLINDING_convert: function(n: pBIGNUM; r: pBN_BLINDING; ctx: pBN_CTX): cint; cdecl;

BN_BLINDING_invert: function(n: pBIGNUM; b: pBN_BLINDING; ctx: pBN_CTX): cint; cdecl;

BN_copy: function(_to: pBIGNUM; const from: pBIGNUM): pBIGNUM; cdecl;

BN_dup: function(const from: pBIGNUM): pBIGNUM; cdecl;

BN_bn2bin: function(const n: pBIGNUM; _to: pointer): cint; cdecl;

BN_bin2bn: function(const _from: pointer; len: cint; ret: pBIGNUM): pBIGNUM; cdecl;

BN_bn2hex: function(const n: pBIGNUM): PCharacter; cdecl;

BN_bn2dec: function(const n: pBIGNUM): PCharacter; cdecl;

BN_hex2bn: function(var n: pBIGNUM; const str: PCharacter): cint; cdecl;

BN_dec2bn: function(var n: pBIGNUM; const str: PCharacter): cint; cdecl;

BN_bn2mpi: function(const a: pBIGNUM; _to: pointer): cint; cdecl;

BN_mpi2bn: function(s: pointer; len: cint; ret: pBIGNUM): pBIGNUM; cdecl;

BN_print: function(fp: pBIO; const a: pointer): cint; cdecl;

BN_value_one: function: pBIGNUM; cdecl;

BN_set_word: function(n: pBIGNUM; w: cardinal): cint; cdecl;

BN_get_word: function(n: pBIGNUM): cardinal; cdecl;

BN_cmp: function(a: pBIGNUM; b: pBIGNUM): cint; cdecl;

BN_ucmp: function(a: pBIGNUM; b: pBIGNUM): cint; cdecl;

BN_num_bits: function(const a: pBIGNUM): cint; cdecl;

BN_num_bits_word: function(w: BN_ULONG): cint; cdecl;

BN_add: function(r: pBIGNUM; const a, b: pBIGNUM): cint; cdecl;

BN_sub: function(r: pBIGNUM; const a, b: pBIGNUM): cint; cdecl;

BN_uadd: function(r: pBIGNUM; const a, b: pBIGNUM): cint; cdecl;

BN_usub: function(r: pBIGNUM; const a, b: pBIGNUM): cint; cdecl;

BN_mul: function(r: pBIGNUM; a: pBIGNUM; b: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_sqr: function(r: pBIGNUM; a: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_div: function(dv: pBIGNUM; rem: pBIGNUM; const a, d: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_exp: function(r: pBIGNUM; a: pBIGNUM; p: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_mod_exp: function(r, a: pBIGNUM; const p, m: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_gcd: function(r: pBIGNUM; a: pBIGNUM; b: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_nnmod: function(rem: pBIGNUM; const a: pBIGNUM; const m: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_mod_add: function(r: pBIGNUM; a: pBIGNUM; b: pBIGNUM; const m: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_mod_sub: function(r: pBIGNUM; a: pBIGNUM; b: pBIGNUM; const m: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_mod_mul: function(ret, a, b: pBIGNUM; const m: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_mod_sqr: function(r: pBIGNUM; a: pBIGNUM; const m: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_reciprocal: function(r, m: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_mod_exp2_mont: function(r, a1, p1, a2, p2, m: pBIGNUM; ctx: pBN_CTX; m_ctx: pBN_MONT_CTX): cint; cdecl;

BN_mod_exp_mont: function(r, a: pBIGNUM; const p, m: pBIGNUM; ctx: pBN_CTX; m_ctx: pBN_MONT_CTX): cint; cdecl;

BN_mod_exp_mont_word: function(r: pBIGNUM; a: BN_ULONG; const p, m: pBIGNUM; ctx: pBN_CTX; m_ctx: pBN_MONT_CTX): cint; cdecl;

BN_mod_exp_simple: function(r, a, p, m: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_mod_exp_recp: function(r: pBIGNUM; const a, p, m: pBIGNUM; ctx: pBN_CTX): cint; cdecl;

BN_mod_inverse: function(ret, a: pBIGNUM; const n: pBIGNUM; ctx: pBN_CTX): pBIGNUM; cdecl;

BN_add_word: function(a: pBIGNUM; w: BN_ULONG): cint; cdecl;

BN_sub_word: function(a: pBIGNUM; w: BN_ULONG): cint; cdecl;

BN_mul_word: function(a: pBIGNUM; w: BN_ULONG): cint; cdecl;

BN_div_word: function(a: pBIGNUM; w: BN_ULONG): BN_ULONG; cdecl;

BN_mod_word: function(const a: pBIGNUM; w: BN_ULONG): BN_ULONG; cdecl;

bn_mul_words: function(rp, ap: pBN_ULONG; num: cint; w: BN_ULONG): BN_ULONG; cdecl;

bn_mul_add_words: function(rp, ap: pBN_ULONG; num: cint; w: BN_ULONG): BN_ULONG; cdecl;

bn_sqr_words: procedure(rp, ap: pBN_ULONG; num: cint); cdecl;

bn_div_words: function(h, l, d: BN_ULONG): BN_ULONG; cdecl;

bn_add_words: function(rp, ap, bp: pBN_ULONG; num: cint): BN_ULONG; cdecl;

bn_sub_words: function(rp, ap, bp: pBN_ULONG; num: cint): BN_ULONG; cdecl;

bn_expand2: function(a: pBIGNUM; n: cint): pBIGNUM; cdecl;

BN_set_bit: function(a: pBIGNUM; n: cint): cint; cdecl;

BN_clear_bit: function(a: pBIGNUM; n: cint): cint; cdecl;

BN_is_bit_set: function(const a: pBIGNUM; n: cint): cint; cdecl;

BN_mask_bits: function(a: pBIGNUM; n: cint): cint; cdecl;

BN_lshift: function(r: pBIGNUM; const a: pBIGNUM; n: cint): cint; cdecl;

BN_lshift1: function(r: pBIGNUM; a: pBIGNUM): cint; cdecl;

BN_rshift: function(r: pBIGNUM; const a: pBIGNUM; n: cint): cint; cdecl;

BN_rshift1: function(r: pBIGNUM; a: pBIGNUM): cint; cdecl;

BN_generate_prime: function(ret: pBIGNUM; num, safe: cint; add, rem: pBIGNUM; progress: TProgressCallbackFunction; cb_arg: pointer): pBIGNUM; cdecl;

BN_is_prime: function(const a: pBIGNUM; checks: cint; progress: TProgressCallbackFunction; ctx: pBN_CTX; cb_arg: pointer): cint; cdecl;

BN_is_prime_fasttest: function(const a: pBIGNUM; checks: cint; progress: TProgressCallbackFunction; ctx: pBN_CTX; cb_arg: pointer; do_trial_division: cint): cint; cdecl;

BN_rand: function(rnd: pBIGNUM; bits, top, bottom: cint): cint; cdecl;

BN_pseudo_rand: function(rnd: pBIGNUM; bits, top, bottom: cint): cint; cdecl;

BN_rand_range: function(rnd, range: pBIGNUM): cint; cdecl;

BN_pseudo_rand_range: function(rnd, range: pBIGNUM): cint; cdecl;

BN_bntest_rand: function(rnd: pBIGNUM; bits, top, bottom: cint): cint; cdecl;

BN_to_ASN1_INTEGER: function(bn: pBIGNUM; ai: pASN1_INTEGER): pASN1_INTEGER; cdecl;

BN_to_ASN1_ENUMERATED: function(bn: pBIGNUM; ai: pASN1_ENUMERATED): pASN1_ENUMERATED; cdecl;