2500c093aa
DH_check is used to test the validity of Diffie-Hellman parameter sets (p, q, g). Among the tests performed are primality tests on p and q, for this BN_is_prime_ex is called with the rounds of Miller-Rabin set as default. This will therefore use the average case error estimates derived from the function BN_prime_checks_for_size based on the bit size of the number tested. However, these bounds are only accurate on testing random input. Within this testing scenario, where we are checking the validity of a DH parameter set, we can not assert that these parameters are randomly generated. Thus we must treat them as if they are adversarial in nature and increase the rounds of Miller-Rabin performed. Generally, each round of Miller-Rabin can declare a composite number prime with probability at most (1/4), thus 64 rounds is sufficient in thwarting known generation techniques (even in safe prime settings - see https://eprint.iacr.org/2019/032 for full analysis). The choice of 64 rounds is also consistent with SRP_NUMBER_ITERATIONS_FOR_PRIME 64 as used in srp_Verify_N_and_g in openssl/apps/s_client.c. Reviewed-by: Paul Dale <paul.dale@oracle.com> Reviewed-by: Matt Caswell <matt@openssl.org> (Merged from https://github.com/openssl/openssl/pull/8593)
229 lines
6.2 KiB
C
229 lines
6.2 KiB
C
/*
|
|
* Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
|
|
*
|
|
* Licensed under the Apache License 2.0 (the "License"). You may not use
|
|
* this file except in compliance with the License. You can obtain a copy
|
|
* in the file LICENSE in the source distribution or at
|
|
* https://www.openssl.org/source/license.html
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include "internal/cryptlib.h"
|
|
#include <openssl/bn.h>
|
|
#include "dh_locl.h"
|
|
|
|
# define DH_NUMBER_ITERATIONS_FOR_PRIME 64
|
|
|
|
/*-
|
|
* Check that p and g are suitable enough
|
|
*
|
|
* p is odd
|
|
* 1 < g < p - 1
|
|
*/
|
|
int DH_check_params_ex(const DH *dh)
|
|
{
|
|
int errflags = 0;
|
|
|
|
(void)DH_check_params(dh, &errflags);
|
|
|
|
if ((errflags & DH_CHECK_P_NOT_PRIME) != 0)
|
|
DHerr(DH_F_DH_CHECK_PARAMS_EX, DH_R_CHECK_P_NOT_PRIME);
|
|
if ((errflags & DH_NOT_SUITABLE_GENERATOR) != 0)
|
|
DHerr(DH_F_DH_CHECK_PARAMS_EX, DH_R_NOT_SUITABLE_GENERATOR);
|
|
|
|
return errflags == 0;
|
|
}
|
|
|
|
int DH_check_params(const DH *dh, int *ret)
|
|
{
|
|
int ok = 0;
|
|
BIGNUM *tmp = NULL;
|
|
BN_CTX *ctx = NULL;
|
|
|
|
*ret = 0;
|
|
ctx = BN_CTX_new();
|
|
if (ctx == NULL)
|
|
goto err;
|
|
BN_CTX_start(ctx);
|
|
tmp = BN_CTX_get(ctx);
|
|
if (tmp == NULL)
|
|
goto err;
|
|
|
|
if (!BN_is_odd(dh->p))
|
|
*ret |= DH_CHECK_P_NOT_PRIME;
|
|
if (BN_is_negative(dh->g) || BN_is_zero(dh->g) || BN_is_one(dh->g))
|
|
*ret |= DH_NOT_SUITABLE_GENERATOR;
|
|
if (BN_copy(tmp, dh->p) == NULL || !BN_sub_word(tmp, 1))
|
|
goto err;
|
|
if (BN_cmp(dh->g, tmp) >= 0)
|
|
*ret |= DH_NOT_SUITABLE_GENERATOR;
|
|
|
|
ok = 1;
|
|
err:
|
|
BN_CTX_end(ctx);
|
|
BN_CTX_free(ctx);
|
|
return ok;
|
|
}
|
|
|
|
/*-
|
|
* Check that p is a safe prime and
|
|
* if g is 2, 3 or 5, check that it is a suitable generator
|
|
* where
|
|
* for 2, p mod 24 == 11
|
|
* for 3, p mod 12 == 5
|
|
* for 5, p mod 10 == 3 or 7
|
|
* should hold.
|
|
*/
|
|
int DH_check_ex(const DH *dh)
|
|
{
|
|
int errflags = 0;
|
|
|
|
(void)DH_check(dh, &errflags);
|
|
|
|
if ((errflags & DH_NOT_SUITABLE_GENERATOR) != 0)
|
|
DHerr(DH_F_DH_CHECK_EX, DH_R_NOT_SUITABLE_GENERATOR);
|
|
if ((errflags & DH_CHECK_Q_NOT_PRIME) != 0)
|
|
DHerr(DH_F_DH_CHECK_EX, DH_R_CHECK_Q_NOT_PRIME);
|
|
if ((errflags & DH_CHECK_INVALID_Q_VALUE) != 0)
|
|
DHerr(DH_F_DH_CHECK_EX, DH_R_CHECK_INVALID_Q_VALUE);
|
|
if ((errflags & DH_CHECK_INVALID_J_VALUE) != 0)
|
|
DHerr(DH_F_DH_CHECK_EX, DH_R_CHECK_INVALID_J_VALUE);
|
|
if ((errflags & DH_UNABLE_TO_CHECK_GENERATOR) != 0)
|
|
DHerr(DH_F_DH_CHECK_EX, DH_R_UNABLE_TO_CHECK_GENERATOR);
|
|
if ((errflags & DH_CHECK_P_NOT_PRIME) != 0)
|
|
DHerr(DH_F_DH_CHECK_EX, DH_R_CHECK_P_NOT_PRIME);
|
|
if ((errflags & DH_CHECK_P_NOT_SAFE_PRIME) != 0)
|
|
DHerr(DH_F_DH_CHECK_EX, DH_R_CHECK_P_NOT_SAFE_PRIME);
|
|
|
|
return errflags == 0;
|
|
}
|
|
|
|
int DH_check(const DH *dh, int *ret)
|
|
{
|
|
int ok = 0, r;
|
|
BN_CTX *ctx = NULL;
|
|
BN_ULONG l;
|
|
BIGNUM *t1 = NULL, *t2 = NULL;
|
|
|
|
*ret = 0;
|
|
ctx = BN_CTX_new();
|
|
if (ctx == NULL)
|
|
goto err;
|
|
BN_CTX_start(ctx);
|
|
t1 = BN_CTX_get(ctx);
|
|
t2 = BN_CTX_get(ctx);
|
|
if (t2 == NULL)
|
|
goto err;
|
|
|
|
if (dh->q) {
|
|
if (BN_cmp(dh->g, BN_value_one()) <= 0)
|
|
*ret |= DH_NOT_SUITABLE_GENERATOR;
|
|
else if (BN_cmp(dh->g, dh->p) >= 0)
|
|
*ret |= DH_NOT_SUITABLE_GENERATOR;
|
|
else {
|
|
/* Check g^q == 1 mod p */
|
|
if (!BN_mod_exp(t1, dh->g, dh->q, dh->p, ctx))
|
|
goto err;
|
|
if (!BN_is_one(t1))
|
|
*ret |= DH_NOT_SUITABLE_GENERATOR;
|
|
}
|
|
r = BN_is_prime_ex(dh->q, DH_NUMBER_ITERATIONS_FOR_PRIME, ctx, NULL);
|
|
if (r < 0)
|
|
goto err;
|
|
if (!r)
|
|
*ret |= DH_CHECK_Q_NOT_PRIME;
|
|
/* Check p == 1 mod q i.e. q divides p - 1 */
|
|
if (!BN_div(t1, t2, dh->p, dh->q, ctx))
|
|
goto err;
|
|
if (!BN_is_one(t2))
|
|
*ret |= DH_CHECK_INVALID_Q_VALUE;
|
|
if (dh->j && BN_cmp(dh->j, t1))
|
|
*ret |= DH_CHECK_INVALID_J_VALUE;
|
|
|
|
} else if (BN_is_word(dh->g, DH_GENERATOR_2)) {
|
|
l = BN_mod_word(dh->p, 24);
|
|
if (l == (BN_ULONG)-1)
|
|
goto err;
|
|
if (l != 11)
|
|
*ret |= DH_NOT_SUITABLE_GENERATOR;
|
|
} else if (BN_is_word(dh->g, DH_GENERATOR_5)) {
|
|
l = BN_mod_word(dh->p, 10);
|
|
if (l == (BN_ULONG)-1)
|
|
goto err;
|
|
if ((l != 3) && (l != 7))
|
|
*ret |= DH_NOT_SUITABLE_GENERATOR;
|
|
} else
|
|
*ret |= DH_UNABLE_TO_CHECK_GENERATOR;
|
|
|
|
r = BN_is_prime_ex(dh->p, DH_NUMBER_ITERATIONS_FOR_PRIME, ctx, NULL);
|
|
if (r < 0)
|
|
goto err;
|
|
if (!r)
|
|
*ret |= DH_CHECK_P_NOT_PRIME;
|
|
else if (!dh->q) {
|
|
if (!BN_rshift1(t1, dh->p))
|
|
goto err;
|
|
r = BN_is_prime_ex(t1, DH_NUMBER_ITERATIONS_FOR_PRIME, ctx, NULL);
|
|
if (r < 0)
|
|
goto err;
|
|
if (!r)
|
|
*ret |= DH_CHECK_P_NOT_SAFE_PRIME;
|
|
}
|
|
ok = 1;
|
|
err:
|
|
BN_CTX_end(ctx);
|
|
BN_CTX_free(ctx);
|
|
return ok;
|
|
}
|
|
|
|
int DH_check_pub_key_ex(const DH *dh, const BIGNUM *pub_key)
|
|
{
|
|
int errflags = 0;
|
|
|
|
(void)DH_check(dh, &errflags);
|
|
|
|
if ((errflags & DH_CHECK_PUBKEY_TOO_SMALL) != 0)
|
|
DHerr(DH_F_DH_CHECK_PUB_KEY_EX, DH_R_CHECK_PUBKEY_TOO_SMALL);
|
|
if ((errflags & DH_CHECK_PUBKEY_TOO_LARGE) != 0)
|
|
DHerr(DH_F_DH_CHECK_PUB_KEY_EX, DH_R_CHECK_PUBKEY_TOO_LARGE);
|
|
if ((errflags & DH_CHECK_PUBKEY_INVALID) != 0)
|
|
DHerr(DH_F_DH_CHECK_PUB_KEY_EX, DH_R_CHECK_PUBKEY_INVALID);
|
|
|
|
return errflags == 0;
|
|
}
|
|
|
|
int DH_check_pub_key(const DH *dh, const BIGNUM *pub_key, int *ret)
|
|
{
|
|
int ok = 0;
|
|
BIGNUM *tmp = NULL;
|
|
BN_CTX *ctx = NULL;
|
|
|
|
*ret = 0;
|
|
ctx = BN_CTX_new();
|
|
if (ctx == NULL)
|
|
goto err;
|
|
BN_CTX_start(ctx);
|
|
tmp = BN_CTX_get(ctx);
|
|
if (tmp == NULL || !BN_set_word(tmp, 1))
|
|
goto err;
|
|
if (BN_cmp(pub_key, tmp) <= 0)
|
|
*ret |= DH_CHECK_PUBKEY_TOO_SMALL;
|
|
if (BN_copy(tmp, dh->p) == NULL || !BN_sub_word(tmp, 1))
|
|
goto err;
|
|
if (BN_cmp(pub_key, tmp) >= 0)
|
|
*ret |= DH_CHECK_PUBKEY_TOO_LARGE;
|
|
|
|
if (dh->q != NULL) {
|
|
/* Check pub_key^q == 1 mod p */
|
|
if (!BN_mod_exp(tmp, pub_key, dh->q, dh->p, ctx))
|
|
goto err;
|
|
if (!BN_is_one(tmp))
|
|
*ret |= DH_CHECK_PUBKEY_INVALID;
|
|
}
|
|
|
|
ok = 1;
|
|
err:
|
|
BN_CTX_end(ctx);
|
|
BN_CTX_free(ctx);
|
|
return ok;
|
|
}
|