mirror/openssl
2
0
Fork 0
mirror of https://github.com/openssl/openssl.git synced 2024-11-21 01:15:20 +08:00
Code Issues Packages Projects Releases Wiki Activity

Factorise duplicated code.

Browse Source 
Extract and factorise duplicated string glue code.
Cache strlen result to avoid duplicate calls.
[extended tests]

Reviewed-by: Andy Polyakov <appro@openssl.org>
Reviewed-by: Rich Salz <rsalz@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/4719)
This commit is contained in:
FdaSilvaYY 2017-11-07 11:50:30 +01:00 committed by Rich Salz
parent 1a78a33aed
commit 4483fbae10
4 changed files with 53 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
test/bntest.c
View File

@ -79,6 +79,18 @@ static const char *findattr(STANZA *s, const char *key)
return NULL;
}
/*
* Parse BIGNUM from sparse hex-strings, return |BN_hex2bn| result.
*/
static int parse_bigBN(BIGNUM **out, const char *bn_strings[])
{
char *bigstring = glue_strings(bn_strings, NULL);
int ret = BN_hex2bn(out, bigstring);
OPENSSL_free(bigstring);
return ret;
}
/*
* Parse BIGNUM, return number of bytes parsed.
*/
@ -305,21 +317,6 @@ static const char *bn2strings[] = {
NULL
};
static char *glue(const char *list[])
{
size_t len = 0;
char *p, *save;
int i;
for (i = 0; list[i] != NULL; i++)
len += strlen(list[i]);
if (!TEST_ptr(p = save = OPENSSL_malloc(len + 1)))
return NULL;
for (i = 0; list[i] != NULL; i++)
p += strlen(strcpy(p, list[i]));
return save;
}
/*
* Test constant-time modular exponentiation with 1024-bit inputs, which on
* x86_64 cause a different code branch to be taken.
@ -329,7 +326,6 @@ static int test_modexp_mont5(void)
BIGNUM *a = NULL, *p = NULL, *m = NULL, *d = NULL, *e = NULL;
BIGNUM *b = NULL, *n = NULL, *c = NULL;
BN_MONT_CTX *mont = NULL;
char *bigstring;
int st = 0;
if (!TEST_ptr(a = BN_new())
@ -375,12 +371,8 @@ static int test_modexp_mont5(void)
goto err;
/* Regression test for carry bug in sqr[x]8x_mont */
bigstring = glue(bn1strings);
BN_hex2bn(&n, bigstring);
OPENSSL_free(bigstring);
bigstring = glue(bn2strings);
BN_hex2bn(&a, bigstring);
OPENSSL_free(bigstring);
parse_bigBN(&n, bn1strings);
parse_bigBN(&a, bn2strings);
BN_free(b);
b = BN_dup(a);
BN_MONT_CTX_set(mont, n, ctx);
@ -405,7 +397,7 @@ static int test_modexp_mont5(void)
"FCFFFFFFFFFF000000000000000000FF0302030000000000FFFFFFFFFFFFFFFF",
"FF00FCFDFDFF030202FF00000000FFFFFFFFFFFFFFFFFF00FCFDFCFFFFFFFFFF",
NULL
};
};
static const char *nhex[] = {
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
@ -420,14 +412,10 @@ static int test_modexp_mont5(void)
"FFFFFFFFFFFF000000000000000000000000000000000000FFFFFFFFFFFFFFFF",
"FFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
NULL
};
};
bigstring = glue(ahex);
BN_hex2bn(&a, bigstring);
OPENSSL_free(bigstring);
bigstring = glue(nhex);
BN_hex2bn(&n, bigstring);
OPENSSL_free(bigstring);
parse_bigBN(&a, ahex);
parse_bigBN(&n, nhex);
}
BN_free(b);
b = BN_dup(a);

17
test/crltest.c
View File

@ -187,20 +187,11 @@ static X509 *test_leaf = NULL;
* Glue an array of strings together. Return a BIO and put the string
* into |*out| so we can free it.
*/
static BIO *glue(const char **pem, char **out)
static BIO *glue2bio(const char **pem, char **out)
{
char *dest;
int i;
size_t s = 0;
/* Glue the strings together. */
for (i = 0; pem[i] != NULL; ++i)
s += strlen(pem[i]);
dest = *out = OPENSSL_malloc(s + 1);
if (dest == NULL)
return NULL;
for (i = 0; pem[i] != NULL; ++i)
dest += strlen(strcpy(dest, pem[i]));
*out = glue_strings(pem, &s);
return BIO_new_mem_buf(*out, s);
}
@ -210,7 +201,7 @@ static BIO *glue(const char **pem, char **out)
static X509_CRL *CRL_from_strings(const char **pem)
{
char *p;
BIO *b = glue(pem, &p);
BIO *b = glue2bio(pem, &p);
X509_CRL *crl = PEM_read_bio_X509_CRL(b, NULL, NULL, NULL);
OPENSSL_free(p);
@ -224,7 +215,7 @@ static X509_CRL *CRL_from_strings(const char **pem)
static X509 *X509_from_strings(const char **pem)
{
char *p;
BIO *b = glue(pem, &p);
BIO *b = glue2bio(pem, &p);
X509 *x = PEM_read_bio_X509(b, NULL, NULL, NULL);
OPENSSL_free(p);

6
test/testutil.h
View File

@ -440,4 +440,10 @@ int test_readstanza(STANZA *s);
*/
void test_clearstanza(STANZA *s);
/*
* Glue an array of strings together and return it as an allocated string.
* Optionally return the whole length of this string in |out_len|
*/
char *glue_strings(const char *list[], size_t *out_len);
#endif /* HEADER_TESTUTIL_H */

25
test/testutil/driver.c
View File

@ -272,3 +272,28 @@ int run_tests(const char *test_prog_name)
return EXIT_SUCCESS;
}
/*
* Glue an array of strings together and return it as an allocated string.
* Optionally return the whole length of this string in |out_len|
*/
char *glue_strings(const char *list[], size_t *out_len)
{
size_t len = 0;
char *p, *ret;
int i;
for (i = 0; list[i] != NULL; i++)
len += strlen(list[i]);
if (out_len != NULL)
*out_len = len;
if (!TEST_ptr(ret = p = OPENSSL_malloc(len + 1)))
return NULL;
for (i = 0; list[i] != NULL; i++)
p += strlen(strcpy(p, list[i]));
return ret;
}