## NAME

`BN_mod_mul_reciprocal`

,
`BN_RECP_CTX_new`

,
`BN_RECP_CTX_init`

,
`BN_RECP_CTX_free`

,
`BN_RECP_CTX_set`

,
`BN_div_recp`

, `BN_reciprocal`

— modular multiplication using
reciprocal

## SYNOPSIS

```
#include
<openssl/bn.h>
```

`int`

`BN_mod_mul_reciprocal`

(`BIGNUM *r`,
`const BIGNUM *a`, `const BIGNUM
*b`, `BN_RECP_CTX *recp`, `BN_CTX
*ctx`);

`BN_RECP_CTX *`

`BN_RECP_CTX_new`

(`void`);

`void`

`BN_RECP_CTX_init`

(`BN_RECP_CTX
*recp`);

`void`

`BN_RECP_CTX_free`

(`BN_RECP_CTX
*recp`);

`int`

`BN_RECP_CTX_set`

(`BN_RECP_CTX
*recp`, `const BIGNUM *m`, `BN_CTX
*ctx`);

`int`

`BN_div_recp`

(`BIGNUM *dv`,
`BIGNUM *rem`, `const BIGNUM *a`,
`BN_RECP_CTX *recp`, `BN_CTX
*ctx`);

`int`

`BN_reciprocal`

(`BIGNUM *r`,
`const BIGNUM *m`, `int len`,
`BN_CTX *ctx`);

## DESCRIPTION

`BN_mod_mul_reciprocal`

()
can be used to perform an efficient
BN_mod_mul(3) operation when the operation will be performed
repeatedly with the same modulus. It computes
`r`=(`a`*`b`)%`m`
using `recp`=1/`m`, which is set as
described below. `ctx` is a previously allocated
`BN_CTX` used for temporary variables.

`BN_RECP_CTX_new`

()
allocates and initializes a `BN_RECP_CTX` structure.

`BN_RECP_CTX_init`

()
initializes an existing uninitialized `BN_RECP_CTX`. It
is deprecated and dangerous: see
CAVEATS.

`BN_RECP_CTX_free`

()
frees the components of the `BN_RECP_CTX`, and, if it
was created by `BN_RECP_CTX_new`

(), also the structure
itself. If `recp` is a `NULL`

pointer, no action occurs.

`BN_RECP_CTX_set`

()
stores `m` in `recp` and sets it up
for computing 1/`m` and shifting it left by
`BN_num_bits`

(`m`)+1
to make it an integer. The result and the number of bits it was shifted left
will later be stored in `recp`.

`BN_div_recp`

()
divides `a` by `m` using
`recp`. It places the quotient in
`dv` and the remainder in `rem`.

`BN_reciprocal`

()
divides the `len`'th power of two by
`m` and places the quotient in `r`,
rounding it towards zero to the closest integer.

The `BN_RECP_CTX` structure is defined as
follows:

typedef struct bn_recp_ctx_st { BIGNUM N; /* the divisor */ BIGNUM Nr; /* the reciprocal */ int num_bits; int shift; int flags; } BN_RECP_CTX;

It cannot be shared between threads.

## RETURN VALUES

`BN_RECP_CTX_new`

() returns the newly
allocated `BN_RECP_CTX` or `NULL`

on error.

`BN_mod_mul_reciprocal`

(),
`BN_RECP_CTX_set`

(), and
`BN_div_recp`

() return 1 for success or 0 on
error.

`BN_reciprocal`

() returns
`len` for success or -1 on error.

The error codes can be obtained by ERR_get_error(3).

## SEE ALSO

## HISTORY

`BN_mod_mul_reciprocal`

() and
`BN_reciprocal`

() first appeared in SSLeay 0.5.1 and
have been available since OpenBSD 2.4.

`BN_RECP_CTX` was added in SSLeay 0.9.0.
Before that, the `BN_mod_mul_reciprocal`

() arguments
were different.

`BN_RECP_CTX_new`

(),
`BN_RECP_CTX_init`

(),
`BN_RECP_CTX_free`

(),
`BN_RECP_CTX_set`

(), and
`BN_div_recp`

() first appeared in SSLeay 0.9.1 and
have been available since OpenBSD 2.6.

## CAVEATS

`BN_RECP_CTX_init`

() must not be called on a
context that was used previously, or memory used by the embedded
`BIGNUM` structures is leaked immediately. Besides, it
must not be called on a context created with
`BN_RECP_CTX_new`

(), or the context itself will likely
be leaked later. It can only be used on a static
`BN_RECP_CTX` structure, on one located on the stack, or
on one malloc(3)'ed manually, but all these options are discouraged because
they will no longer work once `BN_RECP_CTX` is made
opaque.