git.sesse.net Git - ffmpeg/blob - libavformat/rtmpdh.c

   1 /*
   2  * RTMP Diffie-Hellmann utilities
   3  * Copyright (c) 2009 Andrej Stepanchuk
   4  * Copyright (c) 2009-2010 Howard Chu
   5  * Copyright (c) 2012 Samuel Pitoiset
   6  *
   7  * This file is part of FFmpeg.
   8  *
   9  * FFmpeg is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * FFmpeg is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with FFmpeg; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 /**
  25  * @file
  26  * RTMP Diffie-Hellmann utilities
  27  */
  28
  29 #include "config.h"
  30 #include "rtmpdh.h"
  31 #include "libavutil/random_seed.h"
  32
  33 #define P1024                                          \
  34     "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1" \
  35     "29024E088A67CC74020BBEA63B139B22514A08798E3404DD" \
  36     "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245" \
  37     "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED" \
  38     "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381" \
  39     "FFFFFFFFFFFFFFFF"
  40
  41 #define Q1024                                          \
  42     "7FFFFFFFFFFFFFFFE487ED5110B4611A62633145C06E0E68" \
  43     "948127044533E63A0105DF531D89CD9128A5043CC71A026E" \
  44     "F7CA8CD9E69D218D98158536F92F8A1BA7F09AB6B6A8E122" \
  45     "F242DABB312F3F637A262174D31BF6B585FFAE5B7A035BF6" \
  46     "F71C35FDAD44CFD2D74F9208BE258FF324943328F67329C0" \
  47     "FFFFFFFFFFFFFFFF"
  48
  49 #if CONFIG_GMP || CONFIG_GCRYPT
  50 #if CONFIG_GMP
  51 #define bn_new(bn)                      \
  52     do {                                \
  53         bn = av_malloc(sizeof(*bn));    \
  54         if (bn)                         \
  55             mpz_init2(bn, 1);           \
  56     } while (0)
  57 #define bn_free(bn)     \
  58     do {                \
  59         mpz_clear(bn);  \
  60         av_free(bn);    \
  61     } while (0)
  62 #define bn_set_word(bn, w)          mpz_set_ui(bn, w)
  63 #define bn_cmp(a, b)                mpz_cmp(a, b)
  64 #define bn_copy(to, from)           mpz_set(to, from)
  65 #define bn_sub_word(bn, w)          mpz_sub_ui(bn, bn, w)
  66 #define bn_cmp_1(bn)                mpz_cmp_ui(bn, 1)
  67 #define bn_num_bytes(bn)            (mpz_sizeinbase(bn, 2) + 7) / 8
  68 #define bn_bn2bin(bn, buf, len)                     \
  69     do {                                            \
  70         memset(buf, 0, len);                        \
  71         if (bn_num_bytes(bn) <= len)                \
  72             mpz_export(buf, NULL, 1, 1, 0, 0, bn);  \
  73     } while (0)
  74 #define bn_bin2bn(bn, buf, len)                     \
  75     do {                                            \
  76         bn_new(bn);                                 \
  77         if (bn)                                     \
  78             mpz_import(bn, len, 1, 1, 0, 0, buf);   \
  79     } while (0)
  80 #define bn_hex2bn(bn, buf, ret)                     \
  81     do {                                            \
  82         bn_new(bn);                                 \
  83         if (bn)                                     \
  84             ret = (mpz_set_str(bn, buf, 16) == 0);  \
  85         else                                        \
  86             ret = 1;                                \
  87     } while (0)
  88 #define bn_modexp(bn, y, q, p)      mpz_powm(bn, y, q, p)
  89 #define bn_random(bn, num_bits)                       \
  90     do {                                              \
  91         int bits = num_bits;                          \
  92         mpz_set_ui(bn, 0);                            \
  93         for (bits = num_bits; bits > 0; bits -= 32) { \
  94             mpz_mul_2exp(bn, bn, 32);                 \
  95             mpz_add_ui(bn, bn, av_get_random_seed()); \
  96         }                                             \
  97         mpz_fdiv_r_2exp(bn, bn, num_bits);            \
  98     } while (0)
  99 #elif CONFIG_GCRYPT
 100 #define bn_new(bn)                                              \
 101     do {                                                        \
 102         if (!gcry_control(GCRYCTL_INITIALIZATION_FINISHED_P)) { \
 103             if (!gcry_check_version("1.5.4"))                   \
 104                 return AVERROR(EINVAL);                         \
 105             gcry_control(GCRYCTL_DISABLE_SECMEM, 0);            \
 106             gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);   \
 107         }                                                       \
 108         bn = gcry_mpi_new(1);                                   \
 109     } while (0)
 110 #define bn_free(bn)                 gcry_mpi_release(bn)
 111 #define bn_set_word(bn, w)          gcry_mpi_set_ui(bn, w)
 112 #define bn_cmp(a, b)                gcry_mpi_cmp(a, b)
 113 #define bn_copy(to, from)           gcry_mpi_set(to, from)
 114 #define bn_sub_word(bn, w)          gcry_mpi_sub_ui(bn, bn, w)
 115 #define bn_cmp_1(bn)                gcry_mpi_cmp_ui(bn, 1)
 116 #define bn_num_bytes(bn)            (gcry_mpi_get_nbits(bn) + 7) / 8
 117 #define bn_bn2bin(bn, buf, len)     gcry_mpi_print(GCRYMPI_FMT_USG, buf, len, NULL, bn)
 118 #define bn_bin2bn(bn, buf, len)     gcry_mpi_scan(&bn, GCRYMPI_FMT_USG, buf, len, NULL)
 119 #define bn_hex2bn(bn, buf, ret)     ret = (gcry_mpi_scan(&bn, GCRYMPI_FMT_HEX, buf, 0, 0) == 0)
 120 #define bn_modexp(bn, y, q, p)      gcry_mpi_powm(bn, y, q, p)
 121 #define bn_random(bn, num_bits)     gcry_mpi_randomize(bn, num_bits, GCRY_WEAK_RANDOM)
 122 #endif
 123
 124 #define MAX_BYTES 18000
 125
 126 #define dh_new()                    av_malloc(sizeof(FF_DH))
 127
 128 static FFBigNum dh_generate_key(FF_DH *dh)
 129 {
 130     int num_bytes;
 131
 132     num_bytes = bn_num_bytes(dh->p) - 1;
 133     if (num_bytes <= 0 || num_bytes > MAX_BYTES)
 134         return NULL;
 135
 136     bn_new(dh->priv_key);
 137     if (!dh->priv_key)
 138         return NULL;
 139     bn_random(dh->priv_key, 8 * num_bytes);
 140
 141     bn_new(dh->pub_key);
 142     if (!dh->pub_key) {
 143         bn_free(dh->priv_key);
 144         return NULL;
 145     }
 146
 147     bn_modexp(dh->pub_key, dh->g, dh->priv_key, dh->p);
 148
 149     return dh->pub_key;
 150 }
 151
 152 static int dh_compute_key(FF_DH *dh, FFBigNum pub_key_bn,
 153                           uint32_t secret_key_len, uint8_t *secret_key)
 154 {
 155     FFBigNum k;
 156
 157     bn_new(k);
 158     if (!k)
 159         return -1;
 160
 161     bn_modexp(k, pub_key_bn, dh->priv_key, dh->p);
 162     bn_bn2bin(k, secret_key, secret_key_len);
 163     bn_free(k);
 164
 165     /* return the length of the shared secret key like DH_compute_key */
 166     return secret_key_len;
 167 }
 168
 169 void ff_dh_free(FF_DH *dh)
 170 {
 171     if (!dh)
 172         return;
 173     bn_free(dh->p);
 174     bn_free(dh->g);
 175     bn_free(dh->pub_key);
 176     bn_free(dh->priv_key);
 177     av_free(dh);
 178 }
 179 #elif CONFIG_OPENSSL
 180 #define bn_new(bn)                  bn = BN_new()
 181 #define bn_free(bn)                 BN_free(bn)
 182 #define bn_set_word(bn, w)          BN_set_word(bn, w)
 183 #define bn_cmp(a, b)                BN_cmp(a, b)
 184 #define bn_copy(to, from)           BN_copy(to, from)
 185 #define bn_sub_word(bn, w)          BN_sub_word(bn, w)
 186 #define bn_cmp_1(bn)                BN_cmp(bn, BN_value_one())
 187 #define bn_num_bytes(bn)            BN_num_bytes(bn)
 188 #define bn_bn2bin(bn, buf, len)     BN_bn2bin(bn, buf)
 189 #define bn_bin2bn(bn, buf, len)     bn = BN_bin2bn(buf, len, 0)
 190 #define bn_hex2bn(bn, buf, ret)     ret = BN_hex2bn(&bn, buf)
 191 #define bn_modexp(bn, y, q, p)               \
 192     do {                                     \
 193         BN_CTX *ctx = BN_CTX_new();          \
 194         if (!ctx)                            \
 195             return AVERROR(ENOMEM);          \
 196         if (!BN_mod_exp(bn, y, q, p, ctx)) { \
 197             BN_CTX_free(ctx);                \
 198             return AVERROR(EINVAL);          \
 199         }                                    \
 200         BN_CTX_free(ctx);                    \
 201     } while (0)
 202
 203 #define dh_new()                                DH_new()
 204 #define dh_generate_key(dh)                     DH_generate_key(dh)
 205
 206 static int dh_compute_key(FF_DH *dh, FFBigNum pub_key_bn,
 207                           uint32_t secret_key_len, uint8_t *secret_key)
 208 {
 209     if (secret_key_len < DH_size(dh))
 210         return AVERROR(EINVAL);
 211     return DH_compute_key(secret_key, pub_key_bn, dh);
 212 }
 213
 214 void ff_dh_free(FF_DH *dh)
 215 {
 216     if (!dh)
 217         return;
 218     DH_free(dh);
 219 }
 220 #endif
 221
 222 static int dh_is_valid_public_key(FFBigNum y, FFBigNum p, FFBigNum q)
 223 {
 224     FFBigNum bn = NULL;
 225     int ret = AVERROR(EINVAL);
 226
 227     bn_new(bn);
 228     if (!bn)
 229         return AVERROR(ENOMEM);
 230
 231     /* y must lie in [2, p - 1] */
 232     bn_set_word(bn, 1);
 233     if (!bn_cmp(y, bn))
 234         goto fail;
 235
 236     /* bn = p - 2 */
 237     bn_copy(bn, p);
 238     bn_sub_word(bn, 1);
 239     if (!bn_cmp(y, bn))
 240         goto fail;
 241
 242     /* Verify with Sophie-Germain prime
 243      *
 244      * This is a nice test to make sure the public key position is calculated
 245      * correctly. This test will fail in about 50% of the cases if applied to
 246      * random data.
 247      */
 248     /* y must fulfill y^q mod p = 1 */
 249     bn_modexp(bn, y, q, p);
 250
 251     if (bn_cmp_1(bn))
 252         goto fail;
 253
 254     ret = 0;
 255 fail:
 256     bn_free(bn);
 257
 258     return ret;
 259 }
 260
 261 av_cold FF_DH *ff_dh_init(int key_len)
 262 {
 263     FF_DH *dh;
 264     int ret;
 265
 266     if (!(dh = dh_new()))
 267         return NULL;
 268
 269     bn_new(dh->g);
 270     if (!dh->g)
 271         goto fail;
 272
 273     bn_hex2bn(dh->p, P1024, ret);
 274     if (!ret)
 275         goto fail;
 276
 277     bn_set_word(dh->g, 2);
 278     dh->length = key_len;
 279
 280     return dh;
 281
 282 fail:
 283     ff_dh_free(dh);
 284
 285     return NULL;
 286 }
 287
 288 int ff_dh_generate_public_key(FF_DH *dh)
 289 {
 290     int ret = 0;
 291
 292     while (!ret) {
 293         FFBigNum q1 = NULL;
 294
 295         if (!dh_generate_key(dh))
 296             return AVERROR(EINVAL);
 297
 298         bn_hex2bn(q1, Q1024, ret);
 299         if (!ret)
 300             return AVERROR(ENOMEM);
 301
 302         ret = dh_is_valid_public_key(dh->pub_key, dh->p, q1);
 303         bn_free(q1);
 304
 305         if (!ret) {
 306             /* the public key is valid */
 307             break;
 308         }
 309     }
 310
 311     return ret;
 312 }
 313
 314 int ff_dh_write_public_key(FF_DH *dh, uint8_t *pub_key, int pub_key_len)
 315 {
 316     int len;
 317
 318     /* compute the length of the public key */
 319     len = bn_num_bytes(dh->pub_key);
 320     if (len <= 0 || len > pub_key_len)
 321         return AVERROR(EINVAL);
 322
 323     /* convert the public key value into big-endian form */
 324     memset(pub_key, 0, pub_key_len);
 325     bn_bn2bin(dh->pub_key, pub_key + pub_key_len - len, len);
 326
 327     return 0;
 328 }
 329
 330 int ff_dh_compute_shared_secret_key(FF_DH *dh, const uint8_t *pub_key,
 331                                     int pub_key_len, uint8_t *secret_key,
 332                                     int secret_key_len)
 333 {
 334     FFBigNum q1 = NULL, pub_key_bn = NULL;
 335     int ret;
 336
 337     /* convert the big-endian form of the public key into a bignum */
 338     bn_bin2bn(pub_key_bn, pub_key, pub_key_len);
 339     if (!pub_key_bn)
 340         return AVERROR(ENOMEM);
 341
 342     /* convert the string containing a hexadecimal number into a bignum */
 343     bn_hex2bn(q1, Q1024, ret);
 344     if (!ret) {
 345         ret = AVERROR(ENOMEM);
 346         goto fail;
 347     }
 348
 349     /* when the public key is valid we have to compute the shared secret key */
 350     if ((ret = dh_is_valid_public_key(pub_key_bn, dh->p, q1)) < 0) {
 351         goto fail;
 352     } else if ((ret = dh_compute_key(dh, pub_key_bn, secret_key_len,
 353                                      secret_key)) < 0) {
 354         ret = AVERROR(EINVAL);
 355         goto fail;
 356     }
 357
 358 fail:
 359     bn_free(pub_key_bn);
 360     bn_free(q1);
 361
 362     return ret;
 363 }
 364
 365 #ifdef TEST
 366 static int test_random_shared_secret(void)
 367 {
 368     FF_DH *peer1 = NULL, *peer2 = NULL;
 369     int ret;
 370     uint8_t pubkey1[128], pubkey2[128];
 371     uint8_t sharedkey1[128], sharedkey2[128];
 372
 373     peer1 = ff_dh_init(1024);
 374     peer2 = ff_dh_init(1024);
 375     if (!peer1 || !peer2) {
 376         ret = AVERROR(ENOMEM);
 377         goto fail;
 378     }
 379     if ((ret = ff_dh_generate_public_key(peer1)) < 0)
 380         goto fail;
 381     if ((ret = ff_dh_generate_public_key(peer2)) < 0)
 382         goto fail;
 383     if ((ret = ff_dh_write_public_key(peer1, pubkey1, sizeof(pubkey1))) < 0)
 384         goto fail;
 385     if ((ret = ff_dh_write_public_key(peer2, pubkey2, sizeof(pubkey2))) < 0)
 386         goto fail;
 387     if ((ret = ff_dh_compute_shared_secret_key(peer1, pubkey2, sizeof(pubkey2),
 388                                                sharedkey1, sizeof(sharedkey1))) < 0)
 389         goto fail;
 390     if ((ret = ff_dh_compute_shared_secret_key(peer2, pubkey1, sizeof(pubkey1),
 391                                                sharedkey2, sizeof(sharedkey2))) < 0)
 392         goto fail;
 393     if (memcmp(sharedkey1, sharedkey2, sizeof(sharedkey1))) {
 394         printf("Mismatched generated shared key\n");
 395         ret = AVERROR_INVALIDDATA;
 396     } else {
 397         printf("Generated shared key ok\n");
 398     }
 399 fail:
 400     ff_dh_free(peer1);
 401     ff_dh_free(peer2);
 402     return ret;
 403 }
 404
 405 static const char *private_key =
 406     "976C18FCADC255B456564F74F3EEDA59D28AF6B744D743F2357BFD2404797EF896EF1A"
 407     "7C1CBEAAA3AB60AF3192D189CFF3F991C9CBBFD78119FCA2181384B94011943B6D6F28"
 408     "9E1B708E2D1A0C7771169293F03DA27E561F15F16F0AC9BC858C77A80FA98FD088A232"
 409     "19D08BE6F165DE0B02034B18705829FAD0ACB26A5B75EF";
 410 static const char *public_key =
 411     "F272ECF8362257C5D2C3CC2229CF9C0A03225BC109B1DBC76A68C394F256ACA3EF5F64"
 412     "FC270C26382BF315C19E97A76104A716FC998A651E8610A3AE6CF65D8FAE5D3F32EEA0"
 413     "0B32CB9609B494116A825D7142D17B88E3D20EDD98743DE29CF37A23A9F6A58B960591"
 414     "3157D5965FCB46DDA73A1F08DD897BAE88DFE6FC937CBA";
 415 static const uint8_t public_key_bin[] = {
 416     0xf2, 0x72, 0xec, 0xf8, 0x36, 0x22, 0x57, 0xc5, 0xd2, 0xc3, 0xcc, 0x22,
 417     0x29, 0xcf, 0x9c, 0x0a, 0x03, 0x22, 0x5b, 0xc1, 0x09, 0xb1, 0xdb, 0xc7,
 418     0x6a, 0x68, 0xc3, 0x94, 0xf2, 0x56, 0xac, 0xa3, 0xef, 0x5f, 0x64, 0xfc,
 419     0x27, 0x0c, 0x26, 0x38, 0x2b, 0xf3, 0x15, 0xc1, 0x9e, 0x97, 0xa7, 0x61,
 420     0x04, 0xa7, 0x16, 0xfc, 0x99, 0x8a, 0x65, 0x1e, 0x86, 0x10, 0xa3, 0xae,
 421     0x6c, 0xf6, 0x5d, 0x8f, 0xae, 0x5d, 0x3f, 0x32, 0xee, 0xa0, 0x0b, 0x32,
 422     0xcb, 0x96, 0x09, 0xb4, 0x94, 0x11, 0x6a, 0x82, 0x5d, 0x71, 0x42, 0xd1,
 423     0x7b, 0x88, 0xe3, 0xd2, 0x0e, 0xdd, 0x98, 0x74, 0x3d, 0xe2, 0x9c, 0xf3,
 424     0x7a, 0x23, 0xa9, 0xf6, 0xa5, 0x8b, 0x96, 0x05, 0x91, 0x31, 0x57, 0xd5,
 425     0x96, 0x5f, 0xcb, 0x46, 0xdd, 0xa7, 0x3a, 0x1f, 0x08, 0xdd, 0x89, 0x7b,
 426     0xae, 0x88, 0xdf, 0xe6, 0xfc, 0x93, 0x7c, 0xba
 427 };
 428 static const uint8_t peer_public_key[] = {
 429     0x58, 0x66, 0x05, 0x49, 0x94, 0x23, 0x2b, 0x66, 0x52, 0x13, 0xff, 0x46,
 430     0xf2, 0xb3, 0x79, 0xa9, 0xee, 0xae, 0x1a, 0x13, 0xf0, 0x71, 0x52, 0xfb,
 431     0x93, 0x4e, 0xee, 0x97, 0x05, 0x73, 0x50, 0x7d, 0xaf, 0x02, 0x07, 0x72,
 432     0xac, 0xdc, 0xa3, 0x95, 0x78, 0xee, 0x9a, 0x19, 0x71, 0x7e, 0x99, 0x9f,
 433     0x2a, 0xd4, 0xb3, 0xe2, 0x0c, 0x1d, 0x1a, 0x78, 0x4c, 0xde, 0xf1, 0xad,
 434     0xb4, 0x60, 0xa8, 0x51, 0xac, 0x71, 0xec, 0x86, 0x70, 0xa2, 0x63, 0x36,
 435     0x92, 0x7c, 0xe3, 0x87, 0xee, 0xe4, 0xf1, 0x62, 0x24, 0x74, 0xb4, 0x04,
 436     0xfa, 0x5c, 0xdf, 0xba, 0xfa, 0xa3, 0xc2, 0xbb, 0x62, 0x27, 0xd0, 0xf4,
 437     0xe4, 0x43, 0xda, 0x8a, 0x88, 0x69, 0x60, 0xe2, 0xdb, 0x75, 0x2a, 0x98,
 438     0x9d, 0xb5, 0x50, 0xe3, 0x99, 0xda, 0xe0, 0xa6, 0x14, 0xc9, 0x80, 0x12,
 439     0xf9, 0x3c, 0xac, 0x06, 0x02, 0x7a, 0xde, 0x74
 440 };
 441 static const uint8_t shared_secret[] = {
 442     0xb2, 0xeb, 0xcb, 0x71, 0xf3, 0x61, 0xfb, 0x5b, 0x4e, 0x5c, 0x4c, 0xcf,
 443     0x5c, 0x08, 0x5f, 0x96, 0x26, 0x77, 0x1d, 0x31, 0xf1, 0xe1, 0xf7, 0x4b,
 444     0x92, 0xac, 0x82, 0x2a, 0x88, 0xc7, 0x83, 0xe1, 0xc7, 0xf3, 0xd3, 0x1a,
 445     0x7d, 0xc8, 0x31, 0xe3, 0x97, 0xe4, 0xec, 0x31, 0x0e, 0x8f, 0x73, 0x1a,
 446     0xe4, 0xf6, 0xd8, 0xc8, 0x94, 0xff, 0xa0, 0x03, 0x84, 0x03, 0x0f, 0xa5,
 447     0x30, 0x5d, 0x67, 0xe0, 0x7a, 0x3b, 0x5f, 0xed, 0x4c, 0xf5, 0xbc, 0x18,
 448     0xea, 0xd4, 0x77, 0xa9, 0x07, 0xb3, 0x54, 0x0b, 0x02, 0xd9, 0xc6, 0xb8,
 449     0x66, 0x5e, 0xec, 0xa4, 0xcd, 0x47, 0xed, 0xc9, 0x38, 0xc6, 0x91, 0x08,
 450     0xf3, 0x85, 0x9b, 0x69, 0x16, 0x78, 0x0d, 0xb7, 0x74, 0x51, 0xaa, 0x5b,
 451     0x4d, 0x74, 0xe4, 0x29, 0x2e, 0x9e, 0x8e, 0xf7, 0xe5, 0x42, 0x83, 0xb0,
 452     0x65, 0xb0, 0xce, 0xc6, 0xb2, 0x8f, 0x5b, 0xb0
 453 };
 454
 455 static int test_ref_data(void)
 456 {
 457     FF_DH *dh;
 458     int ret = AVERROR(ENOMEM);
 459     uint8_t pubkey_test[128];
 460     uint8_t sharedkey_test[128];
 461
 462     dh = ff_dh_init(1024);
 463     if (!dh)
 464         goto fail;
 465     bn_hex2bn(dh->priv_key, private_key, ret);
 466     if (!ret)
 467         goto fail;
 468     bn_hex2bn(dh->pub_key, public_key, ret);
 469     if (!ret)
 470         goto fail;
 471     if ((ret = ff_dh_write_public_key(dh, pubkey_test, sizeof(pubkey_test))) < 0)
 472         goto fail;
 473     if (memcmp(pubkey_test, public_key_bin, sizeof(pubkey_test))) {
 474         printf("Mismatched generated public key\n");
 475         ret = AVERROR_INVALIDDATA;
 476         goto fail;
 477     } else {
 478         printf("Generated public key ok\n");
 479     }
 480     if ((ret = ff_dh_compute_shared_secret_key(dh, peer_public_key, sizeof(peer_public_key),
 481                                                sharedkey_test, sizeof(sharedkey_test))) < 0)
 482         goto fail;
 483     if (memcmp(shared_secret, sharedkey_test, sizeof(sharedkey_test))) {
 484         printf("Mismatched generated shared key\n");
 485         ret = AVERROR_INVALIDDATA;
 486     } else {
 487         printf("Generated shared key ok\n");
 488     }
 489 fail:
 490     ff_dh_free(dh);
 491     return ret;
 492 }
 493
 494 int main(void)
 495 {
 496     if (test_random_shared_secret() < 0)
 497         return 1;
 498     if (test_ref_data() < 0)
 499         return 1;
 500     return 0;
 501 }
 502 #endif