Restore -no_comp switch for backwards compatible behaviour
[openssl.git] / test / ecdhtest.c
1 /* ====================================================================
2  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
3  *
4  * The Elliptic Curve Public-Key Crypto Library (ECC Code) included
5  * herein is developed by SUN MICROSYSTEMS, INC., and is contributed
6  * to the OpenSSL project.
7  *
8  * The ECC Code is licensed pursuant to the OpenSSL open source
9  * license provided below.
10  *
11  * The ECDH software is originally written by Douglas Stebila of
12  * Sun Microsystems Laboratories.
13  *
14  */
15 /* ====================================================================
16  * Copyright (c) 1998-2003 The OpenSSL Project.  All rights reserved.
17  *
18  * Redistribution and use in source and binary forms, with or without
19  * modification, are permitted provided that the following conditions
20  * are met:
21  *
22  * 1. Redistributions of source code must retain the above copyright
23  *    notice, this list of conditions and the following disclaimer.
24  *
25  * 2. Redistributions in binary form must reproduce the above copyright
26  *    notice, this list of conditions and the following disclaimer in
27  *    the documentation and/or other materials provided with the
28  *    distribution.
29  *
30  * 3. All advertising materials mentioning features or use of this
31  *    software must display the following acknowledgment:
32  *    "This product includes software developed by the OpenSSL Project
33  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
34  *
35  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
36  *    endorse or promote products derived from this software without
37  *    prior written permission. For written permission, please contact
38  *    openssl-core@openssl.org.
39  *
40  * 5. Products derived from this software may not be called "OpenSSL"
41  *    nor may "OpenSSL" appear in their names without prior written
42  *    permission of the OpenSSL Project.
43  *
44  * 6. Redistributions of any form whatsoever must retain the following
45  *    acknowledgment:
46  *    "This product includes software developed by the OpenSSL Project
47  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
48  *
49  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
50  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
52  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
53  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
54  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
55  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
56  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
58  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
59  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
60  * OF THE POSSIBILITY OF SUCH DAMAGE.
61  * ====================================================================
62  *
63  * This product includes cryptographic software written by Eric Young
64  * (eay@cryptsoft.com).  This product includes software written by Tim
65  * Hudson (tjh@cryptsoft.com).
66  *
67  */
68
69 #include <stdio.h>
70 #include <stdlib.h>
71 #include <string.h>
72
73 #include "../e_os.h"
74
75 #include <openssl/opensslconf.h> /* for OPENSSL_NO_EC */
76 #include <openssl/crypto.h>
77 #include <openssl/bio.h>
78 #include <openssl/bn.h>
79 #include <openssl/objects.h>
80 #include <openssl/rand.h>
81 #include <openssl/sha.h>
82 #include <openssl/err.h>
83
84 #ifdef OPENSSL_NO_EC
85 int main(int argc, char *argv[])
86 {
87     printf("No ECDH support\n");
88     return (0);
89 }
90 #else
91 # include <openssl/ec.h>
92
93 static const char rnd_seed[] =
94     "string to make the random number generator think it has entropy";
95
96 static const int KDF1_SHA1_len = 20;
97 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
98                        size_t *outlen)
99 {
100     if (*outlen < SHA_DIGEST_LENGTH)
101         return NULL;
102     *outlen = SHA_DIGEST_LENGTH;
103     return SHA1(in, inlen, out);
104 }
105
106 static int test_ecdh_curve(int nid, const char *text, BN_CTX *ctx, BIO *out)
107 {
108     EC_KEY *a = NULL;
109     EC_KEY *b = NULL;
110     BIGNUM *x_a = NULL, *y_a = NULL, *x_b = NULL, *y_b = NULL;
111     char buf[12];
112     unsigned char *abuf = NULL, *bbuf = NULL;
113     int i, alen, blen, aout, bout, ret = 0;
114     const EC_GROUP *group;
115
116     a = EC_KEY_new_by_curve_name(nid);
117     b = EC_KEY_new_by_curve_name(nid);
118     if (a == NULL || b == NULL)
119         goto err;
120
121     group = EC_KEY_get0_group(a);
122
123     if ((x_a = BN_new()) == NULL)
124         goto err;
125     if ((y_a = BN_new()) == NULL)
126         goto err;
127     if ((x_b = BN_new()) == NULL)
128         goto err;
129     if ((y_b = BN_new()) == NULL)
130         goto err;
131
132     BIO_puts(out, "Testing key generation with ");
133     BIO_puts(out, text);
134 # ifdef NOISY
135     BIO_puts(out, "\n");
136 # else
137     (void)BIO_flush(out);
138 # endif
139
140     if (!EC_KEY_generate_key(a))
141         goto err;
142
143     if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) ==
144         NID_X9_62_prime_field) {
145         if (!EC_POINT_get_affine_coordinates_GFp
146             (group, EC_KEY_get0_public_key(a), x_a, y_a, ctx))
147             goto err;
148     }
149 # ifndef OPENSSL_NO_EC2M
150     else {
151         if (!EC_POINT_get_affine_coordinates_GF2m(group,
152                                                   EC_KEY_get0_public_key(a),
153                                                   x_a, y_a, ctx))
154             goto err;
155     }
156 # endif
157 # ifdef NOISY
158     BIO_puts(out, "  pri 1=");
159     BN_print(out, a->priv_key);
160     BIO_puts(out, "\n  pub 1=");
161     BN_print(out, x_a);
162     BIO_puts(out, ",");
163     BN_print(out, y_a);
164     BIO_puts(out, "\n");
165 # else
166     BIO_printf(out, " .");
167     (void)BIO_flush(out);
168 # endif
169
170     if (!EC_KEY_generate_key(b))
171         goto err;
172
173     if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) ==
174         NID_X9_62_prime_field) {
175         if (!EC_POINT_get_affine_coordinates_GFp
176             (group, EC_KEY_get0_public_key(b), x_b, y_b, ctx))
177             goto err;
178     }
179 # ifndef OPENSSL_NO_EC2M
180     else {
181         if (!EC_POINT_get_affine_coordinates_GF2m(group,
182                                                   EC_KEY_get0_public_key(b),
183                                                   x_b, y_b, ctx))
184             goto err;
185     }
186 # endif
187
188 # ifdef NOISY
189     BIO_puts(out, "  pri 2=");
190     BN_print(out, b->priv_key);
191     BIO_puts(out, "\n  pub 2=");
192     BN_print(out, x_b);
193     BIO_puts(out, ",");
194     BN_print(out, y_b);
195     BIO_puts(out, "\n");
196 # else
197     BIO_printf(out, ".");
198     (void)BIO_flush(out);
199 # endif
200
201     alen = KDF1_SHA1_len;
202     abuf = OPENSSL_malloc(alen);
203     aout =
204         ECDH_compute_key(abuf, alen, EC_KEY_get0_public_key(b), a, KDF1_SHA1);
205
206 # ifdef NOISY
207     BIO_puts(out, "  key1 =");
208     for (i = 0; i < aout; i++) {
209         sprintf(buf, "%02X", abuf[i]);
210         BIO_puts(out, buf);
211     }
212     BIO_puts(out, "\n");
213 # else
214     BIO_printf(out, ".");
215     (void)BIO_flush(out);
216 # endif
217
218     blen = KDF1_SHA1_len;
219     bbuf = OPENSSL_malloc(blen);
220     bout =
221         ECDH_compute_key(bbuf, blen, EC_KEY_get0_public_key(a), b, KDF1_SHA1);
222
223 # ifdef NOISY
224     BIO_puts(out, "  key2 =");
225     for (i = 0; i < bout; i++) {
226         sprintf(buf, "%02X", bbuf[i]);
227         BIO_puts(out, buf);
228     }
229     BIO_puts(out, "\n");
230 # else
231     BIO_printf(out, ".");
232     (void)BIO_flush(out);
233 # endif
234
235     if ((aout < 4) || (bout != aout) || (memcmp(abuf, bbuf, aout) != 0)) {
236 # ifndef NOISY
237         BIO_printf(out, " failed\n\n");
238         BIO_printf(out, "key a:\n");
239         BIO_printf(out, "private key: ");
240         BN_print(out, EC_KEY_get0_private_key(a));
241         BIO_printf(out, "\n");
242         BIO_printf(out, "public key (x,y): ");
243         BN_print(out, x_a);
244         BIO_printf(out, ",");
245         BN_print(out, y_a);
246         BIO_printf(out, "\nkey b:\n");
247         BIO_printf(out, "private key: ");
248         BN_print(out, EC_KEY_get0_private_key(b));
249         BIO_printf(out, "\n");
250         BIO_printf(out, "public key (x,y): ");
251         BN_print(out, x_b);
252         BIO_printf(out, ",");
253         BN_print(out, y_b);
254         BIO_printf(out, "\n");
255         BIO_printf(out, "generated key a: ");
256         for (i = 0; i < bout; i++) {
257             sprintf(buf, "%02X", bbuf[i]);
258             BIO_puts(out, buf);
259         }
260         BIO_printf(out, "\n");
261         BIO_printf(out, "generated key b: ");
262         for (i = 0; i < aout; i++) {
263             sprintf(buf, "%02X", abuf[i]);
264             BIO_puts(out, buf);
265         }
266         BIO_printf(out, "\n");
267 # endif
268         fprintf(stderr, "Error in ECDH routines\n");
269         ret = 0;
270     } else {
271 # ifndef NOISY
272         BIO_printf(out, " ok\n");
273 # endif
274         ret = 1;
275     }
276  err:
277     ERR_print_errors_fp(stderr);
278
279     OPENSSL_free(abuf);
280     OPENSSL_free(bbuf);
281     BN_free(x_a);
282     BN_free(y_a);
283     BN_free(x_b);
284     BN_free(y_b);
285     EC_KEY_free(b);
286     EC_KEY_free(a);
287     return (ret);
288 }
289
290 /* Keys and shared secrets from RFC 7027 */
291
292 static const unsigned char bp256_da[] = {
293     0x81, 0xDB, 0x1E, 0xE1, 0x00, 0x15, 0x0F, 0xF2, 0xEA, 0x33, 0x8D, 0x70,
294     0x82, 0x71, 0xBE, 0x38, 0x30, 0x0C, 0xB5, 0x42, 0x41, 0xD7, 0x99, 0x50,
295     0xF7, 0x7B, 0x06, 0x30, 0x39, 0x80, 0x4F, 0x1D
296 };
297
298 static const unsigned char bp256_db[] = {
299     0x55, 0xE4, 0x0B, 0xC4, 0x1E, 0x37, 0xE3, 0xE2, 0xAD, 0x25, 0xC3, 0xC6,
300     0x65, 0x45, 0x11, 0xFF, 0xA8, 0x47, 0x4A, 0x91, 0xA0, 0x03, 0x20, 0x87,
301     0x59, 0x38, 0x52, 0xD3, 0xE7, 0xD7, 0x6B, 0xD3
302 };
303
304 static const unsigned char bp256_Z[] = {
305     0x89, 0xAF, 0xC3, 0x9D, 0x41, 0xD3, 0xB3, 0x27, 0x81, 0x4B, 0x80, 0x94,
306     0x0B, 0x04, 0x25, 0x90, 0xF9, 0x65, 0x56, 0xEC, 0x91, 0xE6, 0xAE, 0x79,
307     0x39, 0xBC, 0xE3, 0x1F, 0x3A, 0x18, 0xBF, 0x2B
308 };
309
310 static const unsigned char bp384_da[] = {
311     0x1E, 0x20, 0xF5, 0xE0, 0x48, 0xA5, 0x88, 0x6F, 0x1F, 0x15, 0x7C, 0x74,
312     0xE9, 0x1B, 0xDE, 0x2B, 0x98, 0xC8, 0xB5, 0x2D, 0x58, 0xE5, 0x00, 0x3D,
313     0x57, 0x05, 0x3F, 0xC4, 0xB0, 0xBD, 0x65, 0xD6, 0xF1, 0x5E, 0xB5, 0xD1,
314     0xEE, 0x16, 0x10, 0xDF, 0x87, 0x07, 0x95, 0x14, 0x36, 0x27, 0xD0, 0x42
315 };
316
317 static const unsigned char bp384_db[] = {
318     0x03, 0x26, 0x40, 0xBC, 0x60, 0x03, 0xC5, 0x92, 0x60, 0xF7, 0x25, 0x0C,
319     0x3D, 0xB5, 0x8C, 0xE6, 0x47, 0xF9, 0x8E, 0x12, 0x60, 0xAC, 0xCE, 0x4A,
320     0xCD, 0xA3, 0xDD, 0x86, 0x9F, 0x74, 0xE0, 0x1F, 0x8B, 0xA5, 0xE0, 0x32,
321     0x43, 0x09, 0xDB, 0x6A, 0x98, 0x31, 0x49, 0x7A, 0xBA, 0xC9, 0x66, 0x70
322 };
323
324 static const unsigned char bp384_Z[] = {
325     0x0B, 0xD9, 0xD3, 0xA7, 0xEA, 0x0B, 0x3D, 0x51, 0x9D, 0x09, 0xD8, 0xE4,
326     0x8D, 0x07, 0x85, 0xFB, 0x74, 0x4A, 0x6B, 0x35, 0x5E, 0x63, 0x04, 0xBC,
327     0x51, 0xC2, 0x29, 0xFB, 0xBC, 0xE2, 0x39, 0xBB, 0xAD, 0xF6, 0x40, 0x37,
328     0x15, 0xC3, 0x5D, 0x4F, 0xB2, 0xA5, 0x44, 0x4F, 0x57, 0x5D, 0x4F, 0x42
329 };
330
331 static const unsigned char bp512_da[] = {
332     0x16, 0x30, 0x2F, 0xF0, 0xDB, 0xBB, 0x5A, 0x8D, 0x73, 0x3D, 0xAB, 0x71,
333     0x41, 0xC1, 0xB4, 0x5A, 0xCB, 0xC8, 0x71, 0x59, 0x39, 0x67, 0x7F, 0x6A,
334     0x56, 0x85, 0x0A, 0x38, 0xBD, 0x87, 0xBD, 0x59, 0xB0, 0x9E, 0x80, 0x27,
335     0x96, 0x09, 0xFF, 0x33, 0x3E, 0xB9, 0xD4, 0xC0, 0x61, 0x23, 0x1F, 0xB2,
336     0x6F, 0x92, 0xEE, 0xB0, 0x49, 0x82, 0xA5, 0xF1, 0xD1, 0x76, 0x4C, 0xAD,
337     0x57, 0x66, 0x54, 0x22
338 };
339
340 static const unsigned char bp512_db[] = {
341     0x23, 0x0E, 0x18, 0xE1, 0xBC, 0xC8, 0x8A, 0x36, 0x2F, 0xA5, 0x4E, 0x4E,
342     0xA3, 0x90, 0x20, 0x09, 0x29, 0x2F, 0x7F, 0x80, 0x33, 0x62, 0x4F, 0xD4,
343     0x71, 0xB5, 0xD8, 0xAC, 0xE4, 0x9D, 0x12, 0xCF, 0xAB, 0xBC, 0x19, 0x96,
344     0x3D, 0xAB, 0x8E, 0x2F, 0x1E, 0xBA, 0x00, 0xBF, 0xFB, 0x29, 0xE4, 0xD7,
345     0x2D, 0x13, 0xF2, 0x22, 0x45, 0x62, 0xF4, 0x05, 0xCB, 0x80, 0x50, 0x36,
346     0x66, 0xB2, 0x54, 0x29
347 };
348
349 static const unsigned char bp512_Z[] = {
350     0xA7, 0x92, 0x70, 0x98, 0x65, 0x5F, 0x1F, 0x99, 0x76, 0xFA, 0x50, 0xA9,
351     0xD5, 0x66, 0x86, 0x5D, 0xC5, 0x30, 0x33, 0x18, 0x46, 0x38, 0x1C, 0x87,
352     0x25, 0x6B, 0xAF, 0x32, 0x26, 0x24, 0x4B, 0x76, 0xD3, 0x64, 0x03, 0xC0,
353     0x24, 0xD7, 0xBB, 0xF0, 0xAA, 0x08, 0x03, 0xEA, 0xFF, 0x40, 0x5D, 0x3D,
354     0x24, 0xF1, 0x1A, 0x9B, 0x5C, 0x0B, 0xEF, 0x67, 0x9F, 0xE1, 0x45, 0x4B,
355     0x21, 0xC4, 0xCD, 0x1F
356 };
357
358 /* Given private value and NID, create EC_KEY structure */
359
360 static EC_KEY *mk_eckey(int nid, const unsigned char *p, size_t plen)
361 {
362     int ok = 0;
363     EC_KEY *k = NULL;
364     BIGNUM *priv = NULL;
365     EC_POINT *pub = NULL;
366     const EC_GROUP *grp;
367     k = EC_KEY_new_by_curve_name(nid);
368     if (!k)
369         goto err;
370     priv = BN_bin2bn(p, plen, NULL);
371     if (!priv)
372         goto err;
373     if (!EC_KEY_set_private_key(k, priv))
374         goto err;
375     grp = EC_KEY_get0_group(k);
376     pub = EC_POINT_new(grp);
377     if (!pub)
378         goto err;
379     if (!EC_POINT_mul(grp, pub, priv, NULL, NULL, NULL))
380         goto err;
381     if (!EC_KEY_set_public_key(k, pub))
382         goto err;
383     ok = 1;
384  err:
385     BN_clear_free(priv);
386     EC_POINT_free(pub);
387     if (ok)
388         return k;
389     EC_KEY_free(k);
390     return NULL;
391 }
392
393 /*
394  * Known answer test: compute shared secret and check it matches expected
395  * value.
396  */
397
398 static int ecdh_kat(BIO *out, const char *cname, int nid,
399                     const unsigned char *k1, size_t k1_len,
400                     const unsigned char *k2, size_t k2_len,
401                     const unsigned char *Z, size_t Zlen)
402 {
403     int rv = 0;
404     EC_KEY *key1 = NULL, *key2 = NULL;
405     unsigned char *Ztmp = NULL;
406     size_t Ztmplen;
407     BIO_puts(out, "Testing ECDH shared secret with ");
408     BIO_puts(out, cname);
409     key1 = mk_eckey(nid, k1, k1_len);
410     key2 = mk_eckey(nid, k2, k2_len);
411     if (!key1 || !key2)
412         goto err;
413     Ztmplen = (EC_GROUP_get_degree(EC_KEY_get0_group(key1)) + 7) / 8;
414     if (Ztmplen != Zlen)
415         goto err;
416     Ztmp = OPENSSL_malloc(Ztmplen);
417     if (!ECDH_compute_key(Ztmp, Ztmplen,
418                           EC_KEY_get0_public_key(key2), key1, 0))
419         goto err;
420     if (memcmp(Ztmp, Z, Zlen))
421         goto err;
422     memset(Ztmp, 0, Zlen);
423     if (!ECDH_compute_key(Ztmp, Ztmplen,
424                           EC_KEY_get0_public_key(key1), key2, 0))
425         goto err;
426     if (memcmp(Ztmp, Z, Zlen))
427         goto err;
428     rv = 1;
429  err:
430     EC_KEY_free(key1);
431     EC_KEY_free(key2);
432     OPENSSL_free(Ztmp);
433     if (rv)
434         BIO_puts(out, " ok\n");
435     else {
436         fprintf(stderr, "Error in ECDH routines\n");
437         ERR_print_errors_fp(stderr);
438     }
439     return rv;
440 }
441
442 # define test_ecdh_kat(bio, curve, bits) \
443         ecdh_kat(bio, curve, NID_brainpoolP##bits##r1, \
444                 bp##bits##_da, sizeof(bp##bits##_da), \
445                 bp##bits##_db, sizeof(bp##bits##_db), \
446                 bp##bits##_Z, sizeof(bp##bits##_Z))
447
448 int main(int argc, char *argv[])
449 {
450     BN_CTX *ctx = NULL;
451     int ret = 1;
452     BIO *out;
453
454     CRYPTO_set_mem_debug(1);
455     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
456
457     RAND_seed(rnd_seed, sizeof rnd_seed);
458
459     out = BIO_new(BIO_s_file());
460     if (out == NULL)
461         EXIT(1);
462     BIO_set_fp(out, stdout, BIO_NOCLOSE | BIO_FP_TEXT);
463
464     if ((ctx = BN_CTX_new()) == NULL)
465         goto err;
466
467     /* NIST PRIME CURVES TESTS */
468     if (!test_ecdh_curve
469         (NID_X9_62_prime192v1, "NIST Prime-Curve P-192", ctx, out))
470         goto err;
471     if (!test_ecdh_curve(NID_secp224r1, "NIST Prime-Curve P-224", ctx, out))
472         goto err;
473     if (!test_ecdh_curve
474         (NID_X9_62_prime256v1, "NIST Prime-Curve P-256", ctx, out))
475         goto err;
476     if (!test_ecdh_curve(NID_secp384r1, "NIST Prime-Curve P-384", ctx, out))
477         goto err;
478     if (!test_ecdh_curve(NID_secp521r1, "NIST Prime-Curve P-521", ctx, out))
479         goto err;
480 # ifndef OPENSSL_NO_EC2M
481     /* NIST BINARY CURVES TESTS */
482     if (!test_ecdh_curve(NID_sect163k1, "NIST Binary-Curve K-163", ctx, out))
483         goto err;
484     if (!test_ecdh_curve(NID_sect163r2, "NIST Binary-Curve B-163", ctx, out))
485         goto err;
486     if (!test_ecdh_curve(NID_sect233k1, "NIST Binary-Curve K-233", ctx, out))
487         goto err;
488     if (!test_ecdh_curve(NID_sect233r1, "NIST Binary-Curve B-233", ctx, out))
489         goto err;
490     if (!test_ecdh_curve(NID_sect283k1, "NIST Binary-Curve K-283", ctx, out))
491         goto err;
492     if (!test_ecdh_curve(NID_sect283r1, "NIST Binary-Curve B-283", ctx, out))
493         goto err;
494     if (!test_ecdh_curve(NID_sect409k1, "NIST Binary-Curve K-409", ctx, out))
495         goto err;
496     if (!test_ecdh_curve(NID_sect409r1, "NIST Binary-Curve B-409", ctx, out))
497         goto err;
498     if (!test_ecdh_curve(NID_sect571k1, "NIST Binary-Curve K-571", ctx, out))
499         goto err;
500     if (!test_ecdh_curve(NID_sect571r1, "NIST Binary-Curve B-571", ctx, out))
501         goto err;
502 # endif
503     if (!test_ecdh_kat(out, "Brainpool Prime-Curve brainpoolP256r1", 256))
504         goto err;
505     if (!test_ecdh_kat(out, "Brainpool Prime-Curve brainpoolP384r1", 384))
506         goto err;
507     if (!test_ecdh_kat(out, "Brainpool Prime-Curve brainpoolP512r1", 512))
508         goto err;
509
510     ret = 0;
511
512  err:
513     ERR_print_errors_fp(stderr);
514     BN_CTX_free(ctx);
515     BIO_free(out);
516     CRYPTO_cleanup_all_ex_data();
517     ERR_remove_thread_state(NULL);
518 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
519     CRYPTO_mem_leaks_fp(stderr);
520 #endif
521     EXIT(ret);
522 }
523 #endif