Struct tomcrypt_sys::ltc_math_descriptor [−] [src]

#[repr(C)]

pub struct ltc_math_descriptor {
    pub name: *const c_char,
    pub bits_per_digit: c_int,
    pub init: Option<unsafe extern "C" fn(_: *mut *mut c_void) -> c_int>,
    pub init_copy: Option<unsafe extern "C" fn(_: *mut *mut c_void, _: *mut c_void) -> c_int>,
    pub deinit: Option<unsafe extern "C" fn(_: *mut c_void)>,
    pub neg: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void) -> c_int>,
    pub copy: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void) -> c_int>,
    pub set_int: Option<unsafe extern "C" fn(_: *mut c_void, _: ltc_mp_digit) -> c_int>,
    pub get_int: Option<unsafe extern "C" fn(_: *mut c_void) -> c_ulong>,
    pub get_digit: Option<unsafe extern "C" fn(_: *mut c_void, _: c_int) -> ltc_mp_digit>,
    pub get_digit_count: Option<unsafe extern "C" fn(_: *mut c_void) -> c_int>,
    pub compare: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void) -> c_int>,
    pub compare_d: Option<unsafe extern "C" fn(_: *mut c_void, _: ltc_mp_digit) -> c_int>,
    pub count_bits: Option<unsafe extern "C" fn(_: *mut c_void) -> c_int>,
    pub count_lsb_bits: Option<unsafe extern "C" fn(_: *mut c_void) -> c_int>,
    pub twoexpt: Option<unsafe extern "C" fn(_: *mut c_void, _: c_int) -> c_int>,
    pub read_radix: Option<unsafe extern "C" fn(_: *mut c_void, _: *const c_char, _: c_int) -> c_int>,
    pub write_radix: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_char, _: c_int) -> c_int>,
    pub unsigned_size: Option<unsafe extern "C" fn(_: *mut c_void) -> c_ulong>,
    pub unsigned_write: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_uchar) -> c_int>,
    pub unsigned_read: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_uchar, _: c_ulong) -> c_int>,
    pub add: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub addi: Option<unsafe extern "C" fn(_: *mut c_void, _: ltc_mp_digit, _: *mut c_void) -> c_int>,
    pub sub: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub subi: Option<unsafe extern "C" fn(_: *mut c_void, _: ltc_mp_digit, _: *mut c_void) -> c_int>,
    pub mul: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub muli: Option<unsafe extern "C" fn(_: *mut c_void, _: ltc_mp_digit, _: *mut c_void) -> c_int>,
    pub sqr: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void) -> c_int>,
    pub mpdiv: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub div_2: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void) -> c_int>,
    pub modi: Option<unsafe extern "C" fn(_: *mut c_void, _: ltc_mp_digit, _: *mut ltc_mp_digit) -> c_int>,
    pub gcd: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub lcm: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub mulmod: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub sqrmod: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub invmod: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub montgomery_setup: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut *mut c_void) -> c_int>,
    pub montgomery_normalization: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void) -> c_int>,
    pub montgomery_reduce: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub montgomery_deinit: Option<unsafe extern "C" fn(_: *mut c_void)>,
    pub exptmod: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub isprime: Option<unsafe extern "C" fn(_: *mut c_void, _: c_int, _: *mut c_int) -> c_int>,
    pub ecc_ptmul: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut ecc_point, _: *mut ecc_point, _: *mut c_void, _: c_int) -> c_int>,
    pub ecc_ptadd: Option<unsafe extern "C" fn(_: *mut ecc_point, _: *mut ecc_point, _: *mut ecc_point, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub ecc_ptdbl: Option<unsafe extern "C" fn(_: *mut ecc_point, _: *mut ecc_point, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub ecc_map: Option<unsafe extern "C" fn(_: *mut ecc_point, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub ecc_mul2add: Option<unsafe extern "C" fn(_: *mut ecc_point, _: *mut c_void, _: *mut ecc_point, _: *mut c_void, _: *mut ecc_point, _: *mut c_void) -> c_int>,
    pub rsa_keygen: Option<unsafe extern "C" fn(_: *mut prng_state, _: c_int, _: c_int, _: c_long, _: *mut rsa_key) -> c_int>,
    pub rsa_me: Option<unsafe extern "C" fn(_: *const c_uchar, _: c_ulong, _: *mut c_uchar, _: *mut c_ulong, _: c_int, _: *mut rsa_key) -> c_int>,
    pub addmod: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub submod: Option<unsafe extern "C" fn(_: *mut c_void, _: *mut c_void, _: *mut c_void, _: *mut c_void) -> c_int>,
    pub rand: Option<unsafe extern "C" fn(_: *mut c_void, _: c_int) -> c_int>,
}

math descriptor

Fields

Name of the math provider

Bits per digit, amount of bits must fit in an unsigned long

initialize a bignum @param a The number to initialize @return CRYPT_OK on success

init copy @param dst The number to initialize and write to @param src The number to copy from @return CRYPT_OK on success

deinit @param a The number to free @return CRYPT_OK on success

negate @param src The number to negate @param dst The destination @return CRYPT_OK on success

copy @param src The number to copy from @param dst The number to write to @return CRYPT_OK on success

set small constant @param a Number to write to @param n Source upto bits_per_digit (actually meant for very small constants) @return CRYPT_OK on success

get small constant @param a Small number to read, only fetches up to bits_per_digit from the number @return The lower bits_per_digit of the integer (unsigned)

get digit n @param a The number to read from @param n The number of the digit to fetch @return The bits_per_digit sized n'th digit of a

Get the number of digits that represent the number @param a The number to count @return The number of digits used to represent the number

compare two integers @param a The left side integer @param b The right side integer @return LTC_MP_LT if a < b, LTC_MP_GT if a > b and LTC_MP_EQ otherwise. (signed comparison)

compare against int @param a The left side integer @param b The right side integer (upto bits_per_digit) @return LTC_MP_LT if a < b, LTC_MP_GT if a > b and LTC_MP_EQ otherwise. (signed comparison)

Count the number of bits used to represent the integer @param a The integer to count @return The number of bits required to represent the integer

Count the number of LSB bits which are zero @param a The integer to count @return The number of contiguous zero LSB bits

Compute a power of two @param a The integer to store the power in @param n The power of two you want to store (a = 2n) @return CRYPT_OK on success

read ascii string @param a The integer to store into @param str The string to read @param radix The radix the integer has been represented in (2-64) @return CRYPT_OK on success

write number to string @param a The integer to store @param str The destination for the string @param radix The radix the integer is to be represented in (2-64) @return CRYPT_OK on success

get size as unsigned char string @param a The integer to get the size (when stored in array of octets) @return The length of the integer in octets

store an integer as an array of octets @param src The integer to store @param dst The buffer to store the integer in @return CRYPT_OK on success

read an array of octets and store as integer @param dst The integer to load @param src The array of octets @param len The number of octets @return CRYPT_OK on success

add two integers @param a The first source integer @param b The second source integer @param c The destination of "a + b" @return CRYPT_OK on success

add two integers @param a The first source integer @param b The second source integer (single digit of upto bits_per_digit in length) @param c The destination of "a + b" @return CRYPT_OK on success

subtract two integers @param a The first source integer @param b The second source integer @param c The destination of "a - b" @return CRYPT_OK on success

subtract two integers @param a The first source integer @param b The second source integer (single digit of upto bits_per_digit in length) @param c The destination of "a - b" @return CRYPT_OK on success

multiply two integers @param a The first source integer @param b The second source integer (single digit of upto bits_per_digit in length) @param c The destination of "a * b" @return CRYPT_OK on success

multiply two integers @param a The first source integer @param b The second source integer (single digit of upto bits_per_digit in length) @param c The destination of "a * b" @return CRYPT_OK on success

Square an integer @param a The integer to square @param b The destination @return CRYPT_OK on success

Divide an integer @param a The dividend @param b The divisor @param c The quotient (can be NULL to signify don't care) @param d The remainder (can be NULL to signify don't care) @return CRYPT_OK on success

divide by two @param a The integer to divide (shift right) @param b The destination @return CRYPT_OK on success

Get remainder (small value) @param a The integer to reduce @param b The modulus (upto bits_per_digit in length) @param c The destination for the residue @return CRYPT_OK on success

gcd @param a The first integer @param b The second integer @param c The destination for (a, b) @return CRYPT_OK on success

lcm @param a The first integer @param b The second integer @param c The destination for [a, b] @return CRYPT_OK on success

Modular multiplication @param a The first source @param b The second source @param c The modulus @param d The destination (a*b mod c) @return CRYPT_OK on success

Modular squaring @param a The first source @param b The modulus @param c The destination (a*a mod b) @return CRYPT_OK on success

Modular inversion @param a The value to invert @param b The modulus @param c The destination (1/a mod b) @return CRYPT_OK on success

setup Montgomery @param a The modulus @param b The destination for the reduction digit @return CRYPT_OK on success

get normalization value @param a The destination for the normalization value @param b The modulus @return CRYPT_OK on success

reduce a number @param a The number [and dest] to reduce @param b The modulus @param c The value "b" from montgomery_setup() @return CRYPT_OK on success

clean up (frees memory) @param a The value "b" from montgomery_setup() @return CRYPT_OK on success

Modular exponentiation @param a The base integer @param b The power (can be negative) integer @param c The modulus integer @param d The destination @return CRYPT_OK on success

Primality testing @param a The integer to test @param b The number of Miller-Rabin tests that shall be executed @param c The destination of the result (FP_YES if prime) @return CRYPT_OK on success

ECC GF(p) point multiplication (from the NIST curves) @param k The integer to multiply the point by @param G The point to multiply @param R The destination for kG @param modulus The modulus for the field @param map Boolean indicated whether to map back to affine or not (can be ignored if you work in affine only) @return CRYPT_OK on success

ECC GF(p) point addition @param P The first point @param Q The second point @param R The destination of P + Q @param modulus The modulus @param mp The "b" value from montgomery_setup() @return CRYPT_OK on success

ECC GF(p) point double @param P The first point @param R The destination of 2P @param modulus The modulus @param mp The "b" value from montgomery_setup() @return CRYPT_OK on success

ECC mapping from projective to affine, currently uses (x,y,z) => (x/z2, y/z3, 1) @param P The point to map @param modulus The modulus @param mp The "b" value from montgomery_setup() @return CRYPT_OK on success @remark The mapping can be different but keep in mind a ecc_point only has three integers (x,y,z) so if you use a different mapping you have to make it fit.

Computes kA*A + kB*B = C using Shamir's Trick @param A First point to multiply @param kA What to multiple A by @param B Second point to multiply @param kB What to multiple B by @param C [out] Destination point (can overlap with A or B) @param modulus Modulus for curve @return CRYPT_OK on success

RSA Key Generation @param prng An active PRNG state @param wprng The index of the PRNG desired @param size The size of the key in octets @param e The "e" value (public key). e==65537 is a good choice @param key [out] Destination of a newly created private key pair @return CRYPT_OK if successful, upon error all allocated ram is freed

RSA exponentiation @param in The octet array representing the base @param inlen The length of the input @param out The destination (to be stored in an octet array format) @param outlen The length of the output buffer and the resulting size (zero padded to the size of the modulus) @param which PK_PUBLIC for public RSA and PK_PRIVATE for private RSA @param key The RSA key to use @return CRYPT_OK on success

Modular addition @param a The first source @param b The second source @param c The modulus @param d The destination (a + b mod c) @return CRYPT_OK on success

Modular substraction @param a The first source @param b The second source @param c The modulus @param d The destination (a - b mod c) @return CRYPT_OK on success

Make a pseudo-random mpi @param a The mpi to make random @param size The desired length @return CRYPT_OK on success

Trait Implementations

impl Debug for ltc_math_descriptor
[src]

[src]

Formats the value using the given formatter.

impl Copy for ltc_math_descriptor
[src]

impl Clone for ltc_math_descriptor
[src]

[src]

Returns a copy of the value. Read more

1.0.0
[src]

Performs copy-assignment from source. Read more