Line data Source code
1 : /*
2 : * pgp-mpi-openssl.c
3 : * OpenPGP MPI functions using OpenSSL BIGNUM code.
4 : *
5 : * Copyright (c) 2005 Marko Kreen
6 : * All rights reserved.
7 : *
8 : * Redistribution and use in source and binary forms, with or without
9 : * modification, are permitted provided that the following conditions
10 : * are met:
11 : * 1. Redistributions of source code must retain the above copyright
12 : * notice, this list of conditions and the following disclaimer.
13 : * 2. Redistributions in binary form must reproduce the above copyright
14 : * notice, this list of conditions and the following disclaimer in the
15 : * documentation and/or other materials provided with the distribution.
16 : *
17 : * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 : * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 : * SUCH DAMAGE.
28 : *
29 : * contrib/pgcrypto/pgp-mpi-openssl.c
30 : */
31 : #include "postgres.h"
32 :
33 : #include <openssl/bn.h>
34 :
35 : #include "pgp.h"
36 : #include "px.h"
37 :
38 : static BIGNUM *
39 74 : mpi_to_bn(PGP_MPI *n)
40 : {
41 74 : BIGNUM *bn = BN_bin2bn(n->data, n->bytes, NULL);
42 :
43 74 : if (!bn)
44 0 : return NULL;
45 74 : if (BN_num_bits(bn) != n->bits)
46 : {
47 0 : px_debug("mpi_to_bn: bignum conversion failed: mpi=%d, bn=%d",
48 : n->bits, BN_num_bits(bn));
49 0 : BN_clear_free(bn);
50 0 : return NULL;
51 : }
52 74 : return bn;
53 : }
54 :
55 : static PGP_MPI *
56 25 : bn_to_mpi(BIGNUM *bn)
57 : {
58 : int res;
59 : PGP_MPI *n;
60 :
61 25 : res = pgp_mpi_alloc(BN_num_bits(bn), &n);
62 25 : if (res < 0)
63 0 : return NULL;
64 :
65 25 : if (BN_num_bytes(bn) != n->bytes)
66 : {
67 0 : px_debug("bn_to_mpi: bignum conversion failed: bn=%d, mpi=%d",
68 0 : BN_num_bytes(bn), n->bytes);
69 0 : pgp_mpi_free(n);
70 0 : return NULL;
71 : }
72 25 : BN_bn2bin(bn, n->data);
73 25 : return n;
74 : }
75 :
76 : /*
77 : * Decide the number of bits in the random component k
78 : *
79 : * It should be in the same range as p for signing (which
80 : * is deprecated), but can be much smaller for encrypting.
81 : *
82 : * Until I research it further, I just mimic gpg behaviour.
83 : * It has a special mapping table, for values <= 5120,
84 : * above that it uses 'arbitrary high number'. Following
85 : * algorithm hovers 10-70 bits above gpg values. And for
86 : * larger p, it uses gpg's algorithm.
87 : *
88 : * The point is - if k gets large, encryption will be
89 : * really slow. It does not matter for decryption.
90 : */
91 : static int
92 5 : decide_k_bits(int p_bits)
93 : {
94 5 : if (p_bits <= 5120)
95 5 : return p_bits / 10 + 160;
96 : else
97 0 : return (p_bits / 8 + 200) * 3 / 2;
98 : }
99 :
100 : int
101 5 : pgp_elgamal_encrypt(PGP_PubKey *pk, PGP_MPI *_m,
102 : PGP_MPI **c1_p, PGP_MPI **c2_p)
103 : {
104 5 : int res = PXE_PGP_MATH_FAILED;
105 : int k_bits;
106 5 : BIGNUM *m = mpi_to_bn(_m);
107 5 : BIGNUM *p = mpi_to_bn(pk->pub.elg.p);
108 5 : BIGNUM *g = mpi_to_bn(pk->pub.elg.g);
109 5 : BIGNUM *y = mpi_to_bn(pk->pub.elg.y);
110 5 : BIGNUM *k = BN_new();
111 5 : BIGNUM *yk = BN_new();
112 5 : BIGNUM *c1 = BN_new();
113 5 : BIGNUM *c2 = BN_new();
114 5 : BN_CTX *tmp = BN_CTX_new();
115 :
116 5 : if (!m || !p || !g || !y || !k || !yk || !c1 || !c2 || !tmp)
117 0 : goto err;
118 :
119 : /*
120 : * generate k
121 : */
122 5 : k_bits = decide_k_bits(BN_num_bits(p));
123 5 : if (!BN_rand(k, k_bits, 0, 0))
124 0 : goto err;
125 :
126 : /*
127 : * c1 = g^k c2 = m * y^k
128 : */
129 5 : if (!BN_mod_exp(c1, g, k, p, tmp))
130 0 : goto err;
131 5 : if (!BN_mod_exp(yk, y, k, p, tmp))
132 0 : goto err;
133 5 : if (!BN_mod_mul(c2, m, yk, p, tmp))
134 0 : goto err;
135 :
136 : /* result */
137 5 : *c1_p = bn_to_mpi(c1);
138 5 : *c2_p = bn_to_mpi(c2);
139 5 : if (*c1_p && *c2_p)
140 5 : res = 0;
141 0 : err:
142 5 : if (tmp)
143 5 : BN_CTX_free(tmp);
144 5 : if (c2)
145 5 : BN_clear_free(c2);
146 5 : if (c1)
147 5 : BN_clear_free(c1);
148 5 : if (yk)
149 5 : BN_clear_free(yk);
150 5 : if (k)
151 5 : BN_clear_free(k);
152 5 : if (y)
153 5 : BN_clear_free(y);
154 5 : if (g)
155 5 : BN_clear_free(g);
156 5 : if (p)
157 5 : BN_clear_free(p);
158 5 : if (m)
159 5 : BN_clear_free(m);
160 5 : return res;
161 : }
162 :
163 : int
164 9 : pgp_elgamal_decrypt(PGP_PubKey *pk, PGP_MPI *_c1, PGP_MPI *_c2,
165 : PGP_MPI **msg_p)
166 : {
167 9 : int res = PXE_PGP_MATH_FAILED;
168 9 : BIGNUM *c1 = mpi_to_bn(_c1);
169 9 : BIGNUM *c2 = mpi_to_bn(_c2);
170 9 : BIGNUM *p = mpi_to_bn(pk->pub.elg.p);
171 9 : BIGNUM *x = mpi_to_bn(pk->sec.elg.x);
172 9 : BIGNUM *c1x = BN_new();
173 9 : BIGNUM *div = BN_new();
174 9 : BIGNUM *m = BN_new();
175 9 : BN_CTX *tmp = BN_CTX_new();
176 :
177 9 : if (!c1 || !c2 || !p || !x || !c1x || !div || !m || !tmp)
178 0 : goto err;
179 :
180 : /*
181 : * m = c2 / (c1^x)
182 : */
183 9 : if (!BN_mod_exp(c1x, c1, x, p, tmp))
184 0 : goto err;
185 9 : if (!BN_mod_inverse(div, c1x, p, tmp))
186 0 : goto err;
187 9 : if (!BN_mod_mul(m, c2, div, p, tmp))
188 0 : goto err;
189 :
190 : /* result */
191 9 : *msg_p = bn_to_mpi(m);
192 9 : if (*msg_p)
193 9 : res = 0;
194 0 : err:
195 9 : if (tmp)
196 9 : BN_CTX_free(tmp);
197 9 : if (m)
198 9 : BN_clear_free(m);
199 9 : if (div)
200 9 : BN_clear_free(div);
201 9 : if (c1x)
202 9 : BN_clear_free(c1x);
203 9 : if (x)
204 9 : BN_clear_free(x);
205 9 : if (p)
206 9 : BN_clear_free(p);
207 9 : if (c2)
208 9 : BN_clear_free(c2);
209 9 : if (c1)
210 9 : BN_clear_free(c1);
211 9 : return res;
212 : }
213 :
214 : int
215 1 : pgp_rsa_encrypt(PGP_PubKey *pk, PGP_MPI *_m, PGP_MPI **c_p)
216 : {
217 1 : int res = PXE_PGP_MATH_FAILED;
218 1 : BIGNUM *m = mpi_to_bn(_m);
219 1 : BIGNUM *e = mpi_to_bn(pk->pub.rsa.e);
220 1 : BIGNUM *n = mpi_to_bn(pk->pub.rsa.n);
221 1 : BIGNUM *c = BN_new();
222 1 : BN_CTX *tmp = BN_CTX_new();
223 :
224 1 : if (!m || !e || !n || !c || !tmp)
225 0 : goto err;
226 :
227 : /*
228 : * c = m ^ e
229 : */
230 1 : if (!BN_mod_exp(c, m, e, n, tmp))
231 0 : goto err;
232 :
233 1 : *c_p = bn_to_mpi(c);
234 1 : if (*c_p)
235 1 : res = 0;
236 0 : err:
237 1 : if (tmp)
238 1 : BN_CTX_free(tmp);
239 1 : if (c)
240 1 : BN_clear_free(c);
241 1 : if (n)
242 1 : BN_clear_free(n);
243 1 : if (e)
244 1 : BN_clear_free(e);
245 1 : if (m)
246 1 : BN_clear_free(m);
247 1 : return res;
248 : }
249 :
250 : int
251 5 : pgp_rsa_decrypt(PGP_PubKey *pk, PGP_MPI *_c, PGP_MPI **m_p)
252 : {
253 5 : int res = PXE_PGP_MATH_FAILED;
254 5 : BIGNUM *c = mpi_to_bn(_c);
255 5 : BIGNUM *d = mpi_to_bn(pk->sec.rsa.d);
256 5 : BIGNUM *n = mpi_to_bn(pk->pub.rsa.n);
257 5 : BIGNUM *m = BN_new();
258 5 : BN_CTX *tmp = BN_CTX_new();
259 :
260 5 : if (!m || !d || !n || !c || !tmp)
261 0 : goto err;
262 :
263 : /*
264 : * m = c ^ d
265 : */
266 5 : if (!BN_mod_exp(m, c, d, n, tmp))
267 0 : goto err;
268 :
269 5 : *m_p = bn_to_mpi(m);
270 5 : if (*m_p)
271 5 : res = 0;
272 0 : err:
273 5 : if (tmp)
274 5 : BN_CTX_free(tmp);
275 5 : if (m)
276 5 : BN_clear_free(m);
277 5 : if (n)
278 5 : BN_clear_free(n);
279 5 : if (d)
280 5 : BN_clear_free(d);
281 5 : if (c)
282 5 : BN_clear_free(c);
283 5 : return res;
284 : }
|
