923a9b33d8f54be0cdc29194d74a44c0663cdccb
[openssl.git] / crypto / bn / bn_recp.c
1 /*
2  * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include "internal/cryptlib.h"
11 #include "bn_lcl.h"
12
13 void BN_RECP_CTX_init(BN_RECP_CTX *recp)
14 {
15     memset(recp, 0, sizeof(*recp));
16     bn_init(&(recp->N));
17     bn_init(&(recp->Nr));
18 }
19
20 BN_RECP_CTX *BN_RECP_CTX_new(void)
21 {
22     BN_RECP_CTX *ret;
23
24     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
25         return NULL;
26
27     bn_init(&(ret->N));
28     bn_init(&(ret->Nr));
29     ret->flags = BN_FLG_MALLOCED;
30     return ret;
31 }
32
33 void BN_RECP_CTX_free(BN_RECP_CTX *recp)
34 {
35     BN_free(&(recp->N));
36     BN_free(&(recp->Nr));
37     if (recp->flags & BN_FLG_MALLOCED)
38         OPENSSL_free(recp);
39 }
40
41 int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *d, BN_CTX *ctx)
42 {
43     if (!BN_copy(&(recp->N), d))
44         return 0;
45     BN_zero(&(recp->Nr));
46     recp->num_bits = BN_num_bits(d);
47     recp->shift = 0;
48     return 1;
49 }
50
51 int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y,
52                           BN_RECP_CTX *recp, BN_CTX *ctx)
53 {
54     int ret = 0;
55     BIGNUM *a;
56     const BIGNUM *ca;
57
58     BN_CTX_start(ctx);
59     if ((a = BN_CTX_get(ctx)) == NULL)
60         goto err;
61     if (y != NULL) {
62         if (x == y) {
63             if (!BN_sqr(a, x, ctx))
64                 goto err;
65         } else {
66             if (!BN_mul(a, x, y, ctx))
67                 goto err;
68         }
69         ca = a;
70     } else
71         ca = x;                 /* Just do the mod */
72
73     ret = BN_div_recp(NULL, r, ca, recp, ctx);
74  err:
75     BN_CTX_end(ctx);
76     bn_check_top(r);
77     return ret;
78 }
79
80 int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
81                 BN_RECP_CTX *recp, BN_CTX *ctx)
82 {
83     int i, j, ret = 0;
84     BIGNUM *a, *b, *d, *r;
85
86     BN_CTX_start(ctx);
87     d = (dv != NULL) ? dv : BN_CTX_get(ctx);
88     r = (rem != NULL) ? rem : BN_CTX_get(ctx);
89     a = BN_CTX_get(ctx);
90     b = BN_CTX_get(ctx);
91     if (b == NULL)
92         goto err;
93
94     if (BN_ucmp(m, &(recp->N)) < 0) {
95         BN_zero(d);
96         if (!BN_copy(r, m)) {
97             BN_CTX_end(ctx);
98             return 0;
99         }
100         BN_CTX_end(ctx);
101         return 1;
102     }
103
104     /*
105      * We want the remainder Given input of ABCDEF / ab we need multiply
106      * ABCDEF by 3 digests of the reciprocal of ab
107      */
108
109     /* i := max(BN_num_bits(m), 2*BN_num_bits(N)) */
110     i = BN_num_bits(m);
111     j = recp->num_bits << 1;
112     if (j > i)
113         i = j;
114
115     /* Nr := round(2^i / N) */
116     if (i != recp->shift)
117         recp->shift = BN_reciprocal(&(recp->Nr), &(recp->N), i, ctx);
118     /* BN_reciprocal could have returned -1 for an error */
119     if (recp->shift == -1)
120         goto err;
121
122     /*-
123      * d := |round(round(m / 2^BN_num_bits(N)) * recp->Nr / 2^(i - BN_num_bits(N)))|
124      *    = |round(round(m / 2^BN_num_bits(N)) * round(2^i / N) / 2^(i - BN_num_bits(N)))|
125      *   <= |(m / 2^BN_num_bits(N)) * (2^i / N) * (2^BN_num_bits(N) / 2^i)|
126      *    = |m/N|
127      */
128     if (!BN_rshift(a, m, recp->num_bits))
129         goto err;
130     if (!BN_mul(b, a, &(recp->Nr), ctx))
131         goto err;
132     if (!BN_rshift(d, b, i - recp->num_bits))
133         goto err;
134     d->neg = 0;
135
136     if (!BN_mul(b, &(recp->N), d, ctx))
137         goto err;
138     if (!BN_usub(r, m, b))
139         goto err;
140     r->neg = 0;
141
142     j = 0;
143     while (BN_ucmp(r, &(recp->N)) >= 0) {
144         if (j++ > 2) {
145             BNerr(BN_F_BN_DIV_RECP, BN_R_BAD_RECIPROCAL);
146             goto err;
147         }
148         if (!BN_usub(r, r, &(recp->N)))
149             goto err;
150         if (!BN_add_word(d, 1))
151             goto err;
152     }
153
154     r->neg = BN_is_zero(r) ? 0 : m->neg;
155     d->neg = m->neg ^ recp->N.neg;
156     ret = 1;
157  err:
158     BN_CTX_end(ctx);
159     bn_check_top(dv);
160     bn_check_top(rem);
161     return ret;
162 }
163
164 /*
165  * len is the expected size of the result We actually calculate with an extra
166  * word of precision, so we can do faster division if the remainder is not
167  * required.
168  */
169 /* r := 2^len / m */
170 int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx)
171 {
172     int ret = -1;
173     BIGNUM *t;
174
175     BN_CTX_start(ctx);
176     if ((t = BN_CTX_get(ctx)) == NULL)
177         goto err;
178
179     if (!BN_set_bit(t, len))
180         goto err;
181
182     if (!BN_div(r, NULL, t, m, ctx))
183         goto err;
184
185     ret = len;
186  err:
187     bn_check_top(r);
188     BN_CTX_end(ctx);
189     return ret;
190 }