**BN_mod_mul_reciprocal**,

**BN_RECP_CTX_new**,

**BN_RECP_CTX_init**,

**BN_RECP_CTX_free**,

**BN_RECP_CTX_set**,

**BN_div_recp** —

modular multiplication using reciprocal
**#include
<openssl/bn.h>**
`int`
**BN_mod_mul_reciprocal**(

`BIGNUM
*r`,

`BIGNUM *a`,

`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`,

`BIGNUM *a`,

`BN_RECP_CTX *recp`,

`BN_CTX *ctx`);

**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`.

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.

**BN_RECP_CTX_new**() returns the newly allocated

`BN_RECP_CTX` or

`NULL`

on error.

For the other functions, 1 is returned for success or 0 on error. The error
codes can be obtained by

ERR_get_error(3).

BN_add(3),

BN_CTX_new(3),

BN_new(3)
`BN_RECP_CTX` was added in SSLeay 0.9.0. Before
that, a function

**BN_reciprocal**() was used
instead, and the

**BN_mod_mul_reciprocal**()
arguments were different.

**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.