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

() first appeared in
SSLeay 0.5.1 and has been available since

OpenBSD 2.4.

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

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