test/dhtest.c

   1 /*
   2  * Copyright 1995-2016 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 <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 #include "../e_os.h"
  15
  16 #include <openssl/crypto.h>
  17 #include <openssl/bio.h>
  18 #include <openssl/bn.h>
  19 #include <openssl/rand.h>
  20 #include <openssl/err.h>
  21
  22 #ifdef OPENSSL_NO_DH
  23 int main(int argc, char *argv[])
  24 {
  25     printf("No DH support\n");
  26     return (0);
  27 }
  28 #else
  29 # include <openssl/dh.h>
  30
  31 static int cb(int p, int n, BN_GENCB *arg);
  32
  33 static const char rnd_seed[] =
  34     "string to make the random number generator think it has entropy";
  35
  36 static int run_rfc5114_tests(void);
  37
  38 int main(int argc, char *argv[])
  39 {
  40     BN_GENCB *_cb = NULL;
  41     DH *a = NULL;
  42     DH *b = NULL;
  43     DH *c = NULL;
  44     const BIGNUM *ap = NULL, *ag = NULL, *apub_key = NULL, *priv_key = NULL;
  45     const BIGNUM *bpub_key = NULL;
  46     BIGNUM *bp = NULL, *bg = NULL, *cpriv_key = NULL;
  47     char buf[12] = {0};
  48     unsigned char *abuf = NULL;
  49     unsigned char *bbuf = NULL;
  50     unsigned char *cbuf = NULL;
  51     int i, alen, blen, clen, aout, bout, cout;
  52     int ret = 1;
  53     BIO *out = NULL;
  54
  55     CRYPTO_set_mem_debug(1);
  56     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
  57
  58     RAND_seed(rnd_seed, sizeof(rnd_seed));
  59
  60     out = BIO_new(BIO_s_file());
  61     if (out == NULL)
  62         EXIT(1);
  63     BIO_set_fp(out, stdout, BIO_NOCLOSE | BIO_FP_TEXT);
  64
  65     _cb = BN_GENCB_new();
  66     if (_cb == NULL)
  67         goto err;
  68     BN_GENCB_set(_cb, &cb, out);
  69     if (((a = DH_new()) == NULL)
  70         || (!DH_generate_parameters_ex(a, 64, DH_GENERATOR_5, _cb)))
  71         goto err;
  72
  73     if (!DH_check(a, &i))
  74         goto err;
  75     if (i & DH_CHECK_P_NOT_PRIME)
  76         BIO_puts(out, "p value is not prime\n");
  77     if (i & DH_CHECK_P_NOT_SAFE_PRIME)
  78         BIO_puts(out, "p value is not a safe prime\n");
  79     if (i & DH_UNABLE_TO_CHECK_GENERATOR)
  80         BIO_puts(out, "unable to check the generator value\n");
  81     if (i & DH_NOT_SUITABLE_GENERATOR)
  82         BIO_puts(out, "the g value is not a generator\n");
  83
  84     DH_get0_pqg(a, &ap, NULL, &ag);
  85     BIO_puts(out, "\np    =");
  86     BN_print(out, ap);
  87     BIO_puts(out, "\ng    =");
  88     BN_print(out, ag);
  89     BIO_puts(out, "\n");
  90
  91     b = DH_new();
  92     if (b == NULL)
  93         goto err;
  94
  95     bp = BN_dup(ap);
  96     bg = BN_dup(ag);
  97     if ((bp == NULL) || (bg == NULL) || !DH_set0_pqg(b, bp, NULL, bg))
  98         goto err;
  99     bp = bg = NULL;
 100
 101     if (!DH_generate_key(a))
 102         goto err;
 103     DH_get0_key(a, &apub_key, &priv_key);
 104     BIO_puts(out, "pri 1=");
 105     BN_print(out, priv_key);
 106     BIO_puts(out, "\npub 1=");
 107     BN_print(out, apub_key);
 108     BIO_puts(out, "\n");
 109
 110     if (!DH_generate_key(b))
 111         goto err;
 112     DH_get0_key(b, &bpub_key, &priv_key);
 113     BIO_puts(out, "pri 2=");
 114     BN_print(out, priv_key);
 115     BIO_puts(out, "\npub 2=");
 116     BN_print(out, bpub_key);
 117     BIO_puts(out, "\n");
 118
 119     /* Also test with a private-key-only copy of |b|. */
 120     if ((c = DHparams_dup(b)) == NULL
 121             || (cpriv_key = BN_dup(priv_key)) == NULL
 122             || !DH_set0_key(c, NULL, cpriv_key))
 123         goto err;
 124     cpriv_key = NULL;
 125
 126     alen = DH_size(a);
 127     abuf = OPENSSL_malloc(alen);
 128     if (abuf == NULL)
 129         goto err;
 130
 131     aout = DH_compute_key(abuf, bpub_key, a);
 132
 133     BIO_puts(out, "key1 =");
 134     for (i = 0; i < aout; i++) {
 135         sprintf(buf, "%02X", abuf[i]);
 136         BIO_puts(out, buf);
 137     }
 138     BIO_puts(out, "\n");
 139
 140     blen = DH_size(b);
 141     bbuf = OPENSSL_malloc(blen);
 142     if (bbuf == NULL)
 143         goto err;
 144
 145     bout = DH_compute_key(bbuf, apub_key, b);
 146
 147     BIO_puts(out, "key2 =");
 148     for (i = 0; i < bout; i++) {
 149         sprintf(buf, "%02X", bbuf[i]);
 150         BIO_puts(out, buf);
 151     }
 152     BIO_puts(out, "\n");
 153
 154     clen = DH_size(c);
 155     cbuf = OPENSSL_malloc(clen);
 156     if (cbuf == NULL)
 157         goto err;
 158
 159     cout = DH_compute_key(cbuf, apub_key, c);
 160
 161     BIO_puts(out, "key3 =");
 162     for (i = 0; i < cout; i++) {
 163         sprintf(buf, "%02X", cbuf[i]);
 164         BIO_puts(out, buf);
 165     }
 166     BIO_puts(out, "\n");
 167
 168     if ((aout < 4) || (bout != aout) || (memcmp(abuf, bbuf, aout) != 0)
 169         || (cout != aout) || (memcmp(abuf, cbuf, aout) != 0)) {
 170         fprintf(stderr, "Error in DH routines\n");
 171         ret = 1;
 172     } else
 173         ret = 0;
 174     if (!run_rfc5114_tests())
 175         ret = 1;
 176  err:
 177     (void)BIO_flush(out);
 178     ERR_print_errors_fp(stderr);
 179
 180     OPENSSL_free(abuf);
 181     OPENSSL_free(bbuf);
 182     OPENSSL_free(cbuf);
 183     DH_free(b);
 184     DH_free(a);
 185     DH_free(c);
 186     BN_free(bp);
 187     BN_free(bg);
 188     BN_free(cpriv_key);
 189     BN_GENCB_free(_cb);
 190     BIO_free(out);
 191
 192 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
 193     if (CRYPTO_mem_leaks_fp(stderr) <= 0)
 194         ret = 1;
 195 #endif
 196
 197     EXIT(ret);
 198 }
 199
 200 static int cb(int p, int n, BN_GENCB *arg)
 201 {
 202     char c = '*';
 203
 204     if (p == 0)
 205         c = '.';
 206     if (p == 1)
 207         c = '+';
 208     if (p == 2)
 209         c = '*';
 210     if (p == 3)
 211         c = '\n';
 212     BIO_write(BN_GENCB_get_arg(arg), &c, 1);
 213     (void)BIO_flush(BN_GENCB_get_arg(arg));
 214     return 1;
 215 }
 216
 217 /* Test data from RFC 5114 */
 218
 219 static const unsigned char dhtest_1024_160_xA[] = {
 220     0xB9, 0xA3, 0xB3, 0xAE, 0x8F, 0xEF, 0xC1, 0xA2, 0x93, 0x04, 0x96, 0x50,
 221     0x70, 0x86, 0xF8, 0x45, 0x5D, 0x48, 0x94, 0x3E
 222 };
 223
 224 static const unsigned char dhtest_1024_160_yA[] = {
 225     0x2A, 0x85, 0x3B, 0x3D, 0x92, 0x19, 0x75, 0x01, 0xB9, 0x01, 0x5B, 0x2D,
 226     0xEB, 0x3E, 0xD8, 0x4F, 0x5E, 0x02, 0x1D, 0xCC, 0x3E, 0x52, 0xF1, 0x09,
 227     0xD3, 0x27, 0x3D, 0x2B, 0x75, 0x21, 0x28, 0x1C, 0xBA, 0xBE, 0x0E, 0x76,
 228     0xFF, 0x57, 0x27, 0xFA, 0x8A, 0xCC, 0xE2, 0x69, 0x56, 0xBA, 0x9A, 0x1F,
 229     0xCA, 0x26, 0xF2, 0x02, 0x28, 0xD8, 0x69, 0x3F, 0xEB, 0x10, 0x84, 0x1D,
 230     0x84, 0xA7, 0x36, 0x00, 0x54, 0xEC, 0xE5, 0xA7, 0xF5, 0xB7, 0xA6, 0x1A,
 231     0xD3, 0xDF, 0xB3, 0xC6, 0x0D, 0x2E, 0x43, 0x10, 0x6D, 0x87, 0x27, 0xDA,
 232     0x37, 0xDF, 0x9C, 0xCE, 0x95, 0xB4, 0x78, 0x75, 0x5D, 0x06, 0xBC, 0xEA,
 233     0x8F, 0x9D, 0x45, 0x96, 0x5F, 0x75, 0xA5, 0xF3, 0xD1, 0xDF, 0x37, 0x01,
 234     0x16, 0x5F, 0xC9, 0xE5, 0x0C, 0x42, 0x79, 0xCE, 0xB0, 0x7F, 0x98, 0x95,
 235     0x40, 0xAE, 0x96, 0xD5, 0xD8, 0x8E, 0xD7, 0x76
 236 };
 237
 238 static const unsigned char dhtest_1024_160_xB[] = {
 239     0x93, 0x92, 0xC9, 0xF9, 0xEB, 0x6A, 0x7A, 0x6A, 0x90, 0x22, 0xF7, 0xD8,
 240     0x3E, 0x72, 0x23, 0xC6, 0x83, 0x5B, 0xBD, 0xDA
 241 };
 242
 243 static const unsigned char dhtest_1024_160_yB[] = {
 244     0x71, 0x7A, 0x6C, 0xB0, 0x53, 0x37, 0x1F, 0xF4, 0xA3, 0xB9, 0x32, 0x94,
 245     0x1C, 0x1E, 0x56, 0x63, 0xF8, 0x61, 0xA1, 0xD6, 0xAD, 0x34, 0xAE, 0x66,
 246     0x57, 0x6D, 0xFB, 0x98, 0xF6, 0xC6, 0xCB, 0xF9, 0xDD, 0xD5, 0xA5, 0x6C,
 247     0x78, 0x33, 0xF6, 0xBC, 0xFD, 0xFF, 0x09, 0x55, 0x82, 0xAD, 0x86, 0x8E,
 248     0x44, 0x0E, 0x8D, 0x09, 0xFD, 0x76, 0x9E, 0x3C, 0xEC, 0xCD, 0xC3, 0xD3,
 249     0xB1, 0xE4, 0xCF, 0xA0, 0x57, 0x77, 0x6C, 0xAA, 0xF9, 0x73, 0x9B, 0x6A,
 250     0x9F, 0xEE, 0x8E, 0x74, 0x11, 0xF8, 0xD6, 0xDA, 0xC0, 0x9D, 0x6A, 0x4E,
 251     0xDB, 0x46, 0xCC, 0x2B, 0x5D, 0x52, 0x03, 0x09, 0x0E, 0xAE, 0x61, 0x26,
 252     0x31, 0x1E, 0x53, 0xFD, 0x2C, 0x14, 0xB5, 0x74, 0xE6, 0xA3, 0x10, 0x9A,
 253     0x3D, 0xA1, 0xBE, 0x41, 0xBD, 0xCE, 0xAA, 0x18, 0x6F, 0x5C, 0xE0, 0x67,
 254     0x16, 0xA2, 0xB6, 0xA0, 0x7B, 0x3C, 0x33, 0xFE
 255 };
 256
 257 static const unsigned char dhtest_1024_160_Z[] = {
 258     0x5C, 0x80, 0x4F, 0x45, 0x4D, 0x30, 0xD9, 0xC4, 0xDF, 0x85, 0x27, 0x1F,
 259     0x93, 0x52, 0x8C, 0x91, 0xDF, 0x6B, 0x48, 0xAB, 0x5F, 0x80, 0xB3, 0xB5,
 260     0x9C, 0xAA, 0xC1, 0xB2, 0x8F, 0x8A, 0xCB, 0xA9, 0xCD, 0x3E, 0x39, 0xF3,
 261     0xCB, 0x61, 0x45, 0x25, 0xD9, 0x52, 0x1D, 0x2E, 0x64, 0x4C, 0x53, 0xB8,
 262     0x07, 0xB8, 0x10, 0xF3, 0x40, 0x06, 0x2F, 0x25, 0x7D, 0x7D, 0x6F, 0xBF,
 263     0xE8, 0xD5, 0xE8, 0xF0, 0x72, 0xE9, 0xB6, 0xE9, 0xAF, 0xDA, 0x94, 0x13,
 264     0xEA, 0xFB, 0x2E, 0x8B, 0x06, 0x99, 0xB1, 0xFB, 0x5A, 0x0C, 0xAC, 0xED,
 265     0xDE, 0xAE, 0xAD, 0x7E, 0x9C, 0xFB, 0xB3, 0x6A, 0xE2, 0xB4, 0x20, 0x83,
 266     0x5B, 0xD8, 0x3A, 0x19, 0xFB, 0x0B, 0x5E, 0x96, 0xBF, 0x8F, 0xA4, 0xD0,
 267     0x9E, 0x34, 0x55, 0x25, 0x16, 0x7E, 0xCD, 0x91, 0x55, 0x41, 0x6F, 0x46,
 268     0xF4, 0x08, 0xED, 0x31, 0xB6, 0x3C, 0x6E, 0x6D
 269 };
 270
 271 static const unsigned char dhtest_2048_224_xA[] = {
 272     0x22, 0xE6, 0x26, 0x01, 0xDB, 0xFF, 0xD0, 0x67, 0x08, 0xA6, 0x80, 0xF7,
 273     0x47, 0xF3, 0x61, 0xF7, 0x6D, 0x8F, 0x4F, 0x72, 0x1A, 0x05, 0x48, 0xE4,
 274     0x83, 0x29, 0x4B, 0x0C
 275 };
 276
 277 static const unsigned char dhtest_2048_224_yA[] = {
 278     0x1B, 0x3A, 0x63, 0x45, 0x1B, 0xD8, 0x86, 0xE6, 0x99, 0xE6, 0x7B, 0x49,
 279     0x4E, 0x28, 0x8B, 0xD7, 0xF8, 0xE0, 0xD3, 0x70, 0xBA, 0xDD, 0xA7, 0xA0,
 280     0xEF, 0xD2, 0xFD, 0xE7, 0xD8, 0xF6, 0x61, 0x45, 0xCC, 0x9F, 0x28, 0x04,
 281     0x19, 0x97, 0x5E, 0xB8, 0x08, 0x87, 0x7C, 0x8A, 0x4C, 0x0C, 0x8E, 0x0B,
 282     0xD4, 0x8D, 0x4A, 0x54, 0x01, 0xEB, 0x1E, 0x87, 0x76, 0xBF, 0xEE, 0xE1,
 283     0x34, 0xC0, 0x38, 0x31, 0xAC, 0x27, 0x3C, 0xD9, 0xD6, 0x35, 0xAB, 0x0C,
 284     0xE0, 0x06, 0xA4, 0x2A, 0x88, 0x7E, 0x3F, 0x52, 0xFB, 0x87, 0x66, 0xB6,
 285     0x50, 0xF3, 0x80, 0x78, 0xBC, 0x8E, 0xE8, 0x58, 0x0C, 0xEF, 0xE2, 0x43,
 286     0x96, 0x8C, 0xFC, 0x4F, 0x8D, 0xC3, 0xDB, 0x08, 0x45, 0x54, 0x17, 0x1D,
 287     0x41, 0xBF, 0x2E, 0x86, 0x1B, 0x7B, 0xB4, 0xD6, 0x9D, 0xD0, 0xE0, 0x1E,
 288     0xA3, 0x87, 0xCB, 0xAA, 0x5C, 0xA6, 0x72, 0xAF, 0xCB, 0xE8, 0xBD, 0xB9,
 289     0xD6, 0x2D, 0x4C, 0xE1, 0x5F, 0x17, 0xDD, 0x36, 0xF9, 0x1E, 0xD1, 0xEE,
 290     0xDD, 0x65, 0xCA, 0x4A, 0x06, 0x45, 0x5C, 0xB9, 0x4C, 0xD4, 0x0A, 0x52,
 291     0xEC, 0x36, 0x0E, 0x84, 0xB3, 0xC9, 0x26, 0xE2, 0x2C, 0x43, 0x80, 0xA3,
 292     0xBF, 0x30, 0x9D, 0x56, 0x84, 0x97, 0x68, 0xB7, 0xF5, 0x2C, 0xFD, 0xF6,
 293     0x55, 0xFD, 0x05, 0x3A, 0x7E, 0xF7, 0x06, 0x97, 0x9E, 0x7E, 0x58, 0x06,
 294     0xB1, 0x7D, 0xFA, 0xE5, 0x3A, 0xD2, 0xA5, 0xBC, 0x56, 0x8E, 0xBB, 0x52,
 295     0x9A, 0x7A, 0x61, 0xD6, 0x8D, 0x25, 0x6F, 0x8F, 0xC9, 0x7C, 0x07, 0x4A,
 296     0x86, 0x1D, 0x82, 0x7E, 0x2E, 0xBC, 0x8C, 0x61, 0x34, 0x55, 0x31, 0x15,
 297     0xB7, 0x0E, 0x71, 0x03, 0x92, 0x0A, 0xA1, 0x6D, 0x85, 0xE5, 0x2B, 0xCB,
 298     0xAB, 0x8D, 0x78, 0x6A, 0x68, 0x17, 0x8F, 0xA8, 0xFF, 0x7C, 0x2F, 0x5C,
 299     0x71, 0x64, 0x8D, 0x6F
 300 };
 301
 302 static const unsigned char dhtest_2048_224_xB[] = {
 303     0x4F, 0xF3, 0xBC, 0x96, 0xC7, 0xFC, 0x6A, 0x6D, 0x71, 0xD3, 0xB3, 0x63,
 304     0x80, 0x0A, 0x7C, 0xDF, 0xEF, 0x6F, 0xC4, 0x1B, 0x44, 0x17, 0xEA, 0x15,
 305     0x35, 0x3B, 0x75, 0x90
 306 };
 307
 308 static const unsigned char dhtest_2048_224_yB[] = {
 309     0x4D, 0xCE, 0xE9, 0x92, 0xA9, 0x76, 0x2A, 0x13, 0xF2, 0xF8, 0x38, 0x44,
 310     0xAD, 0x3D, 0x77, 0xEE, 0x0E, 0x31, 0xC9, 0x71, 0x8B, 0x3D, 0xB6, 0xC2,
 311     0x03, 0x5D, 0x39, 0x61, 0x18, 0x2C, 0x3E, 0x0B, 0xA2, 0x47, 0xEC, 0x41,
 312     0x82, 0xD7, 0x60, 0xCD, 0x48, 0xD9, 0x95, 0x99, 0x97, 0x06, 0x22, 0xA1,
 313     0x88, 0x1B, 0xBA, 0x2D, 0xC8, 0x22, 0x93, 0x9C, 0x78, 0xC3, 0x91, 0x2C,
 314     0x66, 0x61, 0xFA, 0x54, 0x38, 0xB2, 0x07, 0x66, 0x22, 0x2B, 0x75, 0xE2,
 315     0x4C, 0x2E, 0x3A, 0xD0, 0xC7, 0x28, 0x72, 0x36, 0x12, 0x95, 0x25, 0xEE,
 316     0x15, 0xB5, 0xDD, 0x79, 0x98, 0xAA, 0x04, 0xC4, 0xA9, 0x69, 0x6C, 0xAC,
 317     0xD7, 0x17, 0x20, 0x83, 0xA9, 0x7A, 0x81, 0x66, 0x4E, 0xAD, 0x2C, 0x47,
 318     0x9E, 0x44, 0x4E, 0x4C, 0x06, 0x54, 0xCC, 0x19, 0xE2, 0x8D, 0x77, 0x03,
 319     0xCE, 0xE8, 0xDA, 0xCD, 0x61, 0x26, 0xF5, 0xD6, 0x65, 0xEC, 0x52, 0xC6,
 320     0x72, 0x55, 0xDB, 0x92, 0x01, 0x4B, 0x03, 0x7E, 0xB6, 0x21, 0xA2, 0xAC,
 321     0x8E, 0x36, 0x5D, 0xE0, 0x71, 0xFF, 0xC1, 0x40, 0x0A, 0xCF, 0x07, 0x7A,
 322     0x12, 0x91, 0x3D, 0xD8, 0xDE, 0x89, 0x47, 0x34, 0x37, 0xAB, 0x7B, 0xA3,
 323     0x46, 0x74, 0x3C, 0x1B, 0x21, 0x5D, 0xD9, 0xC1, 0x21, 0x64, 0xA7, 0xE4,
 324     0x05, 0x31, 0x18, 0xD1, 0x99, 0xBE, 0xC8, 0xEF, 0x6F, 0xC5, 0x61, 0x17,
 325     0x0C, 0x84, 0xC8, 0x7D, 0x10, 0xEE, 0x9A, 0x67, 0x4A, 0x1F, 0xA8, 0xFF,
 326     0xE1, 0x3B, 0xDF, 0xBA, 0x1D, 0x44, 0xDE, 0x48, 0x94, 0x6D, 0x68, 0xDC,
 327     0x0C, 0xDD, 0x77, 0x76, 0x35, 0xA7, 0xAB, 0x5B, 0xFB, 0x1E, 0x4B, 0xB7,
 328     0xB8, 0x56, 0xF9, 0x68, 0x27, 0x73, 0x4C, 0x18, 0x41, 0x38, 0xE9, 0x15,
 329     0xD9, 0xC3, 0x00, 0x2E, 0xBC, 0xE5, 0x31, 0x20, 0x54, 0x6A, 0x7E, 0x20,
 330     0x02, 0x14, 0x2B, 0x6C
 331 };
 332
 333 static const unsigned char dhtest_2048_224_Z[] = {
 334     0x34, 0xD9, 0xBD, 0xDC, 0x1B, 0x42, 0x17, 0x6C, 0x31, 0x3F, 0xEA, 0x03,
 335     0x4C, 0x21, 0x03, 0x4D, 0x07, 0x4A, 0x63, 0x13, 0xBB, 0x4E, 0xCD, 0xB3,
 336     0x70, 0x3F, 0xFF, 0x42, 0x45, 0x67, 0xA4, 0x6B, 0xDF, 0x75, 0x53, 0x0E,
 337     0xDE, 0x0A, 0x9D, 0xA5, 0x22, 0x9D, 0xE7, 0xD7, 0x67, 0x32, 0x28, 0x6C,
 338     0xBC, 0x0F, 0x91, 0xDA, 0x4C, 0x3C, 0x85, 0x2F, 0xC0, 0x99, 0xC6, 0x79,
 339     0x53, 0x1D, 0x94, 0xC7, 0x8A, 0xB0, 0x3D, 0x9D, 0xEC, 0xB0, 0xA4, 0xE4,
 340     0xCA, 0x8B, 0x2B, 0xB4, 0x59, 0x1C, 0x40, 0x21, 0xCF, 0x8C, 0xE3, 0xA2,
 341     0x0A, 0x54, 0x1D, 0x33, 0x99, 0x40, 0x17, 0xD0, 0x20, 0x0A, 0xE2, 0xC9,
 342     0x51, 0x6E, 0x2F, 0xF5, 0x14, 0x57, 0x79, 0x26, 0x9E, 0x86, 0x2B, 0x0F,
 343     0xB4, 0x74, 0xA2, 0xD5, 0x6D, 0xC3, 0x1E, 0xD5, 0x69, 0xA7, 0x70, 0x0B,
 344     0x4C, 0x4A, 0xB1, 0x6B, 0x22, 0xA4, 0x55, 0x13, 0x53, 0x1E, 0xF5, 0x23,
 345     0xD7, 0x12, 0x12, 0x07, 0x7B, 0x5A, 0x16, 0x9B, 0xDE, 0xFF, 0xAD, 0x7A,
 346     0xD9, 0x60, 0x82, 0x84, 0xC7, 0x79, 0x5B, 0x6D, 0x5A, 0x51, 0x83, 0xB8,
 347     0x70, 0x66, 0xDE, 0x17, 0xD8, 0xD6, 0x71, 0xC9, 0xEB, 0xD8, 0xEC, 0x89,
 348     0x54, 0x4D, 0x45, 0xEC, 0x06, 0x15, 0x93, 0xD4, 0x42, 0xC6, 0x2A, 0xB9,
 349     0xCE, 0x3B, 0x1C, 0xB9, 0x94, 0x3A, 0x1D, 0x23, 0xA5, 0xEA, 0x3B, 0xCF,
 350     0x21, 0xA0, 0x14, 0x71, 0xE6, 0x7E, 0x00, 0x3E, 0x7F, 0x8A, 0x69, 0xC7,
 351     0x28, 0xBE, 0x49, 0x0B, 0x2F, 0xC8, 0x8C, 0xFE, 0xB9, 0x2D, 0xB6, 0xA2,
 352     0x15, 0xE5, 0xD0, 0x3C, 0x17, 0xC4, 0x64, 0xC9, 0xAC, 0x1A, 0x46, 0xE2,
 353     0x03, 0xE1, 0x3F, 0x95, 0x29, 0x95, 0xFB, 0x03, 0xC6, 0x9D, 0x3C, 0xC4,
 354     0x7F, 0xCB, 0x51, 0x0B, 0x69, 0x98, 0xFF, 0xD3, 0xAA, 0x6D, 0xE7, 0x3C,
 355     0xF9, 0xF6, 0x38, 0x69
 356 };
 357
 358 static const unsigned char dhtest_2048_256_xA[] = {
 359     0x08, 0x81, 0x38, 0x2C, 0xDB, 0x87, 0x66, 0x0C, 0x6D, 0xC1, 0x3E, 0x61,
 360     0x49, 0x38, 0xD5, 0xB9, 0xC8, 0xB2, 0xF2, 0x48, 0x58, 0x1C, 0xC5, 0xE3,
 361     0x1B, 0x35, 0x45, 0x43, 0x97, 0xFC, 0xE5, 0x0E
 362 };
 363
 364 static const unsigned char dhtest_2048_256_yA[] = {
 365     0x2E, 0x93, 0x80, 0xC8, 0x32, 0x3A, 0xF9, 0x75, 0x45, 0xBC, 0x49, 0x41,
 366     0xDE, 0xB0, 0xEC, 0x37, 0x42, 0xC6, 0x2F, 0xE0, 0xEC, 0xE8, 0x24, 0xA6,
 367     0xAB, 0xDB, 0xE6, 0x6C, 0x59, 0xBE, 0xE0, 0x24, 0x29, 0x11, 0xBF, 0xB9,
 368     0x67, 0x23, 0x5C, 0xEB, 0xA3, 0x5A, 0xE1, 0x3E, 0x4E, 0xC7, 0x52, 0xBE,
 369     0x63, 0x0B, 0x92, 0xDC, 0x4B, 0xDE, 0x28, 0x47, 0xA9, 0xC6, 0x2C, 0xB8,
 370     0x15, 0x27, 0x45, 0x42, 0x1F, 0xB7, 0xEB, 0x60, 0xA6, 0x3C, 0x0F, 0xE9,
 371     0x15, 0x9F, 0xCC, 0xE7, 0x26, 0xCE, 0x7C, 0xD8, 0x52, 0x3D, 0x74, 0x50,
 372     0x66, 0x7E, 0xF8, 0x40, 0xE4, 0x91, 0x91, 0x21, 0xEB, 0x5F, 0x01, 0xC8,
 373     0xC9, 0xB0, 0xD3, 0xD6, 0x48, 0xA9, 0x3B, 0xFB, 0x75, 0x68, 0x9E, 0x82,
 374     0x44, 0xAC, 0x13, 0x4A, 0xF5, 0x44, 0x71, 0x1C, 0xE7, 0x9A, 0x02, 0xDC,
 375     0xC3, 0x42, 0x26, 0x68, 0x47, 0x80, 0xDD, 0xDC, 0xB4, 0x98, 0x59, 0x41,
 376     0x06, 0xC3, 0x7F, 0x5B, 0xC7, 0x98, 0x56, 0x48, 0x7A, 0xF5, 0xAB, 0x02,
 377     0x2A, 0x2E, 0x5E, 0x42, 0xF0, 0x98, 0x97, 0xC1, 0xA8, 0x5A, 0x11, 0xEA,
 378     0x02, 0x12, 0xAF, 0x04, 0xD9, 0xB4, 0xCE, 0xBC, 0x93, 0x7C, 0x3C, 0x1A,
 379     0x3E, 0x15, 0xA8, 0xA0, 0x34, 0x2E, 0x33, 0x76, 0x15, 0xC8, 0x4E, 0x7F,
 380     0xE3, 0xB8, 0xB9, 0xB8, 0x7F, 0xB1, 0xE7, 0x3A, 0x15, 0xAF, 0x12, 0xA3,
 381     0x0D, 0x74, 0x6E, 0x06, 0xDF, 0xC3, 0x4F, 0x29, 0x0D, 0x79, 0x7C, 0xE5,
 382     0x1A, 0xA1, 0x3A, 0xA7, 0x85, 0xBF, 0x66, 0x58, 0xAF, 0xF5, 0xE4, 0xB0,
 383     0x93, 0x00, 0x3C, 0xBE, 0xAF, 0x66, 0x5B, 0x3C, 0x2E, 0x11, 0x3A, 0x3A,
 384     0x4E, 0x90, 0x52, 0x69, 0x34, 0x1D, 0xC0, 0x71, 0x14, 0x26, 0x68, 0x5F,
 385     0x4E, 0xF3, 0x7E, 0x86, 0x8A, 0x81, 0x26, 0xFF, 0x3F, 0x22, 0x79, 0xB5,
 386     0x7C, 0xA6, 0x7E, 0x29
 387 };
 388
 389 static const unsigned char dhtest_2048_256_xB[] = {
 390     0x7D, 0x62, 0xA7, 0xE3, 0xEF, 0x36, 0xDE, 0x61, 0x7B, 0x13, 0xD1, 0xAF,
 391     0xB8, 0x2C, 0x78, 0x0D, 0x83, 0xA2, 0x3B, 0xD4, 0xEE, 0x67, 0x05, 0x64,
 392     0x51, 0x21, 0xF3, 0x71, 0xF5, 0x46, 0xA5, 0x3D
 393 };
 394
 395 static const unsigned char dhtest_2048_256_yB[] = {
 396     0x57, 0x5F, 0x03, 0x51, 0xBD, 0x2B, 0x1B, 0x81, 0x74, 0x48, 0xBD, 0xF8,
 397     0x7A, 0x6C, 0x36, 0x2C, 0x1E, 0x28, 0x9D, 0x39, 0x03, 0xA3, 0x0B, 0x98,
 398     0x32, 0xC5, 0x74, 0x1F, 0xA2, 0x50, 0x36, 0x3E, 0x7A, 0xCB, 0xC7, 0xF7,
 399     0x7F, 0x3D, 0xAC, 0xBC, 0x1F, 0x13, 0x1A, 0xDD, 0x8E, 0x03, 0x36, 0x7E,
 400     0xFF, 0x8F, 0xBB, 0xB3, 0xE1, 0xC5, 0x78, 0x44, 0x24, 0x80, 0x9B, 0x25,
 401     0xAF, 0xE4, 0xD2, 0x26, 0x2A, 0x1A, 0x6F, 0xD2, 0xFA, 0xB6, 0x41, 0x05,
 402     0xCA, 0x30, 0xA6, 0x74, 0xE0, 0x7F, 0x78, 0x09, 0x85, 0x20, 0x88, 0x63,
 403     0x2F, 0xC0, 0x49, 0x23, 0x37, 0x91, 0xAD, 0x4E, 0xDD, 0x08, 0x3A, 0x97,
 404     0x8B, 0x88, 0x3E, 0xE6, 0x18, 0xBC, 0x5E, 0x0D, 0xD0, 0x47, 0x41, 0x5F,
 405     0x2D, 0x95, 0xE6, 0x83, 0xCF, 0x14, 0x82, 0x6B, 0x5F, 0xBE, 0x10, 0xD3,
 406     0xCE, 0x41, 0xC6, 0xC1, 0x20, 0xC7, 0x8A, 0xB2, 0x00, 0x08, 0xC6, 0x98,
 407     0xBF, 0x7F, 0x0B, 0xCA, 0xB9, 0xD7, 0xF4, 0x07, 0xBE, 0xD0, 0xF4, 0x3A,
 408     0xFB, 0x29, 0x70, 0xF5, 0x7F, 0x8D, 0x12, 0x04, 0x39, 0x63, 0xE6, 0x6D,
 409     0xDD, 0x32, 0x0D, 0x59, 0x9A, 0xD9, 0x93, 0x6C, 0x8F, 0x44, 0x13, 0x7C,
 410     0x08, 0xB1, 0x80, 0xEC, 0x5E, 0x98, 0x5C, 0xEB, 0xE1, 0x86, 0xF3, 0xD5,
 411     0x49, 0x67, 0x7E, 0x80, 0x60, 0x73, 0x31, 0xEE, 0x17, 0xAF, 0x33, 0x80,
 412     0xA7, 0x25, 0xB0, 0x78, 0x23, 0x17, 0xD7, 0xDD, 0x43, 0xF5, 0x9D, 0x7A,
 413     0xF9, 0x56, 0x8A, 0x9B, 0xB6, 0x3A, 0x84, 0xD3, 0x65, 0xF9, 0x22, 0x44,
 414     0xED, 0x12, 0x09, 0x88, 0x21, 0x93, 0x02, 0xF4, 0x29, 0x24, 0xC7, 0xCA,
 415     0x90, 0xB8, 0x9D, 0x24, 0xF7, 0x1B, 0x0A, 0xB6, 0x97, 0x82, 0x3D, 0x7D,
 416     0xEB, 0x1A, 0xFF, 0x5B, 0x0E, 0x8E, 0x4A, 0x45, 0xD4, 0x9F, 0x7F, 0x53,
 417     0x75, 0x7E, 0x19, 0x13
 418 };
 419
 420 static const unsigned char dhtest_2048_256_Z[] = {
 421     0x86, 0xC7, 0x0B, 0xF8, 0xD0, 0xBB, 0x81, 0xBB, 0x01, 0x07, 0x8A, 0x17,
 422     0x21, 0x9C, 0xB7, 0xD2, 0x72, 0x03, 0xDB, 0x2A, 0x19, 0xC8, 0x77, 0xF1,
 423     0xD1, 0xF1, 0x9F, 0xD7, 0xD7, 0x7E, 0xF2, 0x25, 0x46, 0xA6, 0x8F, 0x00,
 424     0x5A, 0xD5, 0x2D, 0xC8, 0x45, 0x53, 0xB7, 0x8F, 0xC6, 0x03, 0x30, 0xBE,
 425     0x51, 0xEA, 0x7C, 0x06, 0x72, 0xCA, 0xC1, 0x51, 0x5E, 0x4B, 0x35, 0xC0,
 426     0x47, 0xB9, 0xA5, 0x51, 0xB8, 0x8F, 0x39, 0xDC, 0x26, 0xDA, 0x14, 0xA0,
 427     0x9E, 0xF7, 0x47, 0x74, 0xD4, 0x7C, 0x76, 0x2D, 0xD1, 0x77, 0xF9, 0xED,
 428     0x5B, 0xC2, 0xF1, 0x1E, 0x52, 0xC8, 0x79, 0xBD, 0x95, 0x09, 0x85, 0x04,
 429     0xCD, 0x9E, 0xEC, 0xD8, 0xA8, 0xF9, 0xB3, 0xEF, 0xBD, 0x1F, 0x00, 0x8A,
 430     0xC5, 0x85, 0x30, 0x97, 0xD9, 0xD1, 0x83, 0x7F, 0x2B, 0x18, 0xF7, 0x7C,
 431     0xD7, 0xBE, 0x01, 0xAF, 0x80, 0xA7, 0xC7, 0xB5, 0xEA, 0x3C, 0xA5, 0x4C,
 432     0xC0, 0x2D, 0x0C, 0x11, 0x6F, 0xEE, 0x3F, 0x95, 0xBB, 0x87, 0x39, 0x93,
 433     0x85, 0x87, 0x5D, 0x7E, 0x86, 0x74, 0x7E, 0x67, 0x6E, 0x72, 0x89, 0x38,
 434     0xAC, 0xBF, 0xF7, 0x09, 0x8E, 0x05, 0xBE, 0x4D, 0xCF, 0xB2, 0x40, 0x52,
 435     0xB8, 0x3A, 0xEF, 0xFB, 0x14, 0x78, 0x3F, 0x02, 0x9A, 0xDB, 0xDE, 0x7F,
 436     0x53, 0xFA, 0xE9, 0x20, 0x84, 0x22, 0x40, 0x90, 0xE0, 0x07, 0xCE, 0xE9,
 437     0x4D, 0x4B, 0xF2, 0xBA, 0xCE, 0x9F, 0xFD, 0x4B, 0x57, 0xD2, 0xAF, 0x7C,
 438     0x72, 0x4D, 0x0C, 0xAA, 0x19, 0xBF, 0x05, 0x01, 0xF6, 0xF1, 0x7B, 0x4A,
 439     0xA1, 0x0F, 0x42, 0x5E, 0x3E, 0xA7, 0x60, 0x80, 0xB4, 0xB9, 0xD6, 0xB3,
 440     0xCE, 0xFE, 0xA1, 0x15, 0xB2, 0xCE, 0xB8, 0x78, 0x9B, 0xB8, 0xA3, 0xB0,
 441     0xEA, 0x87, 0xFE, 0xBE, 0x63, 0xB6, 0xC8, 0xF8, 0x46, 0xEC, 0x6D, 0xB0,
 442     0xC2, 0x6C, 0x5D, 0x7C
 443 };
 444
 445 static const unsigned char dhtest_rfc5114_2048_224_bad_y[] = {
 446     0x45, 0x32, 0x5F, 0x51, 0x07, 0xE5, 0xDF, 0x1C, 0xD6, 0x02, 0x82, 0xB3,
 447     0x32, 0x8F, 0xA4, 0x0F, 0x87, 0xB8, 0x41, 0xFE, 0xB9, 0x35, 0xDE, 0xAD,
 448     0xC6, 0x26, 0x85, 0xB4, 0xFF, 0x94, 0x8C, 0x12, 0x4C, 0xBF, 0x5B, 0x20,
 449     0xC4, 0x46, 0xA3, 0x26, 0xEB, 0xA4, 0x25, 0xB7, 0x68, 0x8E, 0xCC, 0x67,
 450     0xBA, 0xEA, 0x58, 0xD0, 0xF2, 0xE9, 0xD2, 0x24, 0x72, 0x60, 0xDA, 0x88,
 451     0x18, 0x9C, 0xE0, 0x31, 0x6A, 0xAD, 0x50, 0x6D, 0x94, 0x35, 0x8B, 0x83,
 452     0x4A, 0x6E, 0xFA, 0x48, 0x73, 0x0F, 0x83, 0x87, 0xFF, 0x6B, 0x66, 0x1F,
 453     0xA8, 0x82, 0xC6, 0x01, 0xE5, 0x80, 0xB5, 0xB0, 0x52, 0xD0, 0xE9, 0xD8,
 454     0x72, 0xF9, 0x7D, 0x5B, 0x8B, 0xA5, 0x4C, 0xA5, 0x25, 0x95, 0x74, 0xE2,
 455     0x7A, 0x61, 0x4E, 0xA7, 0x8F, 0x12, 0xE2, 0xD2, 0x9D, 0x8C, 0x02, 0x70,
 456     0x34, 0x44, 0x32, 0xC7, 0xB2, 0xF3, 0xB9, 0xFE, 0x17, 0x2B, 0xD6, 0x1F,
 457     0x8B, 0x7E, 0x4A, 0xFA, 0xA3, 0xB5, 0x3E, 0x7A, 0x81, 0x9A, 0x33, 0x66,
 458     0x62, 0xA4, 0x50, 0x18, 0x3E, 0xA2, 0x5F, 0x00, 0x07, 0xD8, 0x9B, 0x22,
 459     0xE4, 0xEC, 0x84, 0xD5, 0xEB, 0x5A, 0xF3, 0x2A, 0x31, 0x23, 0xD8, 0x44,
 460     0x22, 0x2A, 0x8B, 0x37, 0x44, 0xCC, 0xC6, 0x87, 0x4B, 0xBE, 0x50, 0x9D,
 461     0x4A, 0xC4, 0x8E, 0x45, 0xCF, 0x72, 0x4D, 0xC0, 0x89, 0xB3, 0x72, 0xED,
 462     0x33, 0x2C, 0xBC, 0x7F, 0x16, 0x39, 0x3B, 0xEB, 0xD2, 0xDD, 0xA8, 0x01,
 463     0x73, 0x84, 0x62, 0xB9, 0x29, 0xD2, 0xC9, 0x51, 0x32, 0x9E, 0x7A, 0x6A,
 464     0xCF, 0xC1, 0x0A, 0xDB, 0x0E, 0xE0, 0x62, 0x77, 0x6F, 0x59, 0x62, 0x72,
 465     0x5A, 0x69, 0xA6, 0x5B, 0x70, 0xCA, 0x65, 0xC4, 0x95, 0x6F, 0x9A, 0xC2,
 466     0xDF, 0x72, 0x6D, 0xB1, 0x1E, 0x54, 0x7B, 0x51, 0xB4, 0xEF, 0x7F, 0x89,
 467     0x93, 0x74, 0x89, 0x59
 468 };
 469
 470 typedef struct {
 471     DH *(*get_param) (void);
 472     const unsigned char *xA;
 473     size_t xA_len;
 474     const unsigned char *yA;
 475     size_t yA_len;
 476     const unsigned char *xB;
 477     size_t xB_len;
 478     const unsigned char *yB;
 479     size_t yB_len;
 480     const unsigned char *Z;
 481     size_t Z_len;
 482 } rfc5114_td;
 483
 484 # define make_rfc5114_td(pre) { \
 485         DH_get_##pre, \
 486         dhtest_##pre##_xA, sizeof(dhtest_##pre##_xA), \
 487         dhtest_##pre##_yA, sizeof(dhtest_##pre##_yA), \
 488         dhtest_##pre##_xB, sizeof(dhtest_##pre##_xB), \
 489         dhtest_##pre##_yB, sizeof(dhtest_##pre##_yB), \
 490         dhtest_##pre##_Z, sizeof(dhtest_##pre##_Z) \
 491         }
 492
 493 static const rfc5114_td rfctd[] = {
 494         make_rfc5114_td(1024_160),
 495         make_rfc5114_td(2048_224),
 496         make_rfc5114_td(2048_256)
 497 };
 498
 499 static int run_rfc5114_tests(void)
 500 {
 501     int i;
 502     DH *dhA = NULL;
 503     DH *dhB = NULL;
 504     unsigned char *Z1 = NULL;
 505     unsigned char *Z2 = NULL;
 506     const rfc5114_td *td = NULL;
 507     BIGNUM *bady = NULL, *priv_key = NULL, *pub_key = NULL;
 508     const BIGNUM *pub_key_tmp;
 509
 510     for (i = 0; i < (int)OSSL_NELEM(rfctd); i++) {
 511         td = rfctd + i;
 512         /* Set up DH structures setting key components */
 513         dhA = td->get_param();
 514         dhB = td->get_param();
 515         if ((dhA == NULL) || (dhB == NULL))
 516             goto bad_err;
 517
 518         priv_key = BN_bin2bn(td->xA, td->xA_len, NULL);
 519         pub_key = BN_bin2bn(td->yA, td->yA_len, NULL);
 520         if (priv_key == NULL || pub_key == NULL
 521                 || !DH_set0_key(dhA, pub_key, priv_key))
 522             goto bad_err;
 523
 524         priv_key = BN_bin2bn(td->xB, td->xB_len, NULL);
 525         pub_key = BN_bin2bn(td->yB, td->yB_len, NULL);
 526
 527         if (priv_key == NULL || pub_key == NULL
 528                 || !DH_set0_key(dhB, pub_key, priv_key))
 529             goto bad_err;
 530         priv_key = pub_key = NULL;
 531
 532         if ((td->Z_len != (size_t)DH_size(dhA))
 533             || (td->Z_len != (size_t)DH_size(dhB)))
 534             goto err;
 535
 536         Z1 = OPENSSL_malloc(DH_size(dhA));
 537         Z2 = OPENSSL_malloc(DH_size(dhB));
 538         if ((Z1 == NULL) || (Z2 == NULL))
 539             goto bad_err;
 540         /*
 541          * Work out shared secrets using both sides and compare with expected
 542          * values.
 543          */
 544         DH_get0_key(dhB, &pub_key_tmp, NULL);
 545         if (DH_compute_key(Z1, pub_key_tmp, dhA) == -1)
 546             goto bad_err;
 547
 548         DH_get0_key(dhA, &pub_key_tmp, NULL);
 549         if (DH_compute_key(Z2, pub_key_tmp, dhB) == -1)
 550             goto bad_err;
 551
 552         if (memcmp(Z1, td->Z, td->Z_len))
 553             goto err;
 554         if (memcmp(Z2, td->Z, td->Z_len))
 555             goto err;
 556
 557         printf("RFC5114 parameter test %d OK\n", i + 1);
 558
 559         DH_free(dhA);
 560         DH_free(dhB);
 561         OPENSSL_free(Z1);
 562         OPENSSL_free(Z2);
 563         dhA = NULL;
 564         dhB = NULL;
 565         Z1 = NULL;
 566         Z2 = NULL;
 567     }
 568
 569     /* Now i == OSSL_NELEM(rfctd) */
 570     /* RFC5114 uses unsafe primes, so now test an invalid y value */
 571     dhA = DH_get_2048_224();
 572     if (dhA == NULL)
 573         goto bad_err;
 574     Z1 = OPENSSL_malloc(DH_size(dhA));
 575     if (Z1 == NULL)
 576         goto bad_err;
 577
 578     bady = BN_bin2bn(dhtest_rfc5114_2048_224_bad_y,
 579                      sizeof(dhtest_rfc5114_2048_224_bad_y), NULL);
 580     if (bady == NULL)
 581         goto bad_err;
 582
 583     if (!DH_generate_key(dhA))
 584         goto bad_err;
 585
 586     if (DH_compute_key(Z1, bady, dhA) != -1) {
 587         /*
 588          * DH_compute_key should fail with -1. If we get here we unexpectedly
 589          * allowed an invalid y value
 590          */
 591         goto err;
 592     }
 593     /* We'll have a stale error on the queue from the above test so clear it */
 594     ERR_clear_error();
 595
 596     printf("RFC5114 parameter test %d OK\n", i + 1);
 597
 598     BN_free(bady);
 599     DH_free(dhA);
 600     OPENSSL_free(Z1);
 601
 602     return 1;
 603  bad_err:
 604     BN_free(bady);
 605     DH_free(dhA);
 606     DH_free(dhB);
 607     BN_free(pub_key);
 608     BN_free(priv_key);
 609     OPENSSL_free(Z1);
 610     OPENSSL_free(Z2);
 611
 612     fprintf(stderr, "Initialisation error RFC5114 set %d\n", i + 1);
 613     ERR_print_errors_fp(stderr);
 614     return 0;
 615  err:
 616     BN_free(bady);
 617     DH_free(dhA);
 618     DH_free(dhB);
 619     OPENSSL_free(Z1);
 620     OPENSSL_free(Z2);
 621
 622     fprintf(stderr, "Test failed RFC5114 set %d\n", i + 1);
 623     return 0;
 624 }
 625
 626 #endif