zzy/openssl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

that open brace { should be on the previous line

Browse Source 
Found by running the checkpatch.pl Linux script to enforce coding style.

Reviewed-by: Neil Horman <nhorman@openssl.org>
Reviewed-by: David von Oheimb <david.von.oheimb@siemens.com>
Reviewed-by: Tomas Mraz <tomas@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/22097)
This commit is contained in:
Dimitri Papadopoulos 2023-09-13 20:32:54 +02:00 committed by Neil Horman
parent 1cf2f8231e
commit 962431d58b
45 changed files with 189 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
apps/passwd.c
View File

@ -706,12 +706,11 @@ static char *shacrypt(const char *passwd, const char *magic, const char *salt)
cp = out_buf + strlen(out_buf);
*cp++ = ascii_dollar[0];
# define b64_from_24bit(B2, B1, B0, N) \
# define b64_from_24bit(B2, B1, B0, N) \
do { \
unsigned int w = ((B2) << 16) | ((B1) << 8) | (B0); \
int i = (N); \
while (i-- > 0) \
{ \
while (i-- > 0) { \
*cp++ = cov_2char[w & 0x3f]; \
w >>= 6; \
} \

3
apps/pkcs12.c
View File

@ -1257,8 +1257,7 @@ int print_attribs(BIO *out, const STACK_OF(X509_ATTRIBUTE) *attrlst,
}
if (X509_ATTRIBUTE_count(attr)) {
for (j = 0; j < X509_ATTRIBUTE_count(attr); j++)
{
for (j = 0; j < X509_ATTRIBUTE_count(attr); j++) {
av = X509_ATTRIBUTE_get0_type(attr, j);
print_attribute(out, av);
}

5
apps/speed.c
View File

@ -4768,8 +4768,9 @@ static int do_multi(int multi, int size_num)
static void multiblock_speed(const EVP_CIPHER *evp_cipher, int lengths_single,
const openssl_speed_sec_t *seconds)
{
static const int mblengths_list[] =
{ 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
static const int mblengths_list[] = {
8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024
};
const int *mblengths = mblengths_list;
int j, count, keylen, num = OSSL_NELEM(mblengths_list), ciph_success = 1;
const char *alg_name;

3
crypto/asn1/f_int.c
View File

@ -76,8 +76,7 @@ int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size)
again = (buf[i - 1] == '\\');
for (j = 0; j < i; j++) {
if (!ossl_isxdigit(buf[j]))
{
if (!ossl_isxdigit(buf[j])) {
i = j;
break;
}

17
crypto/bio/bio_addr.c
View File

@ -774,16 +774,19 @@ int BIO_lookup_ex(const char *host, const char *service, int lookup_type,
/* Windows doesn't seem to have in_addr_t */
#if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS)
static uint32_t he_fallback_address;
static const char *he_fallback_addresses[] =
{ (char *)&he_fallback_address, NULL };
static const char *he_fallback_addresses[] = {
(char *)&he_fallback_address, NULL
};
#else
static in_addr_t he_fallback_address;
static const char *he_fallback_addresses[] =
{ (char *)&he_fallback_address, NULL };
static const char *he_fallback_addresses[] = {
(char *)&he_fallback_address, NULL
};
#endif
static const struct hostent he_fallback =
{ NULL, NULL, AF_INET, sizeof(he_fallback_address),
(char **)&he_fallback_addresses };
static const struct hostent he_fallback = {
NULL, NULL, AF_INET, sizeof(he_fallback_address),
(char **)&he_fallback_addresses
};
#if defined(OPENSSL_SYS_VMS) && defined(__DECC)
# pragma pointer_size restore
#endif

5
crypto/bn/bn_lib.c
View File

@ -82,8 +82,9 @@ int BN_get_params(int which)
const BIGNUM *BN_value_one(void)
{
static const BN_ULONG data_one = 1L;
static const BIGNUM const_one =
{ (BN_ULONG *)&data_one, 1, 1, 0, BN_FLG_STATIC_DATA };
static const BIGNUM const_one = {
(BN_ULONG *)&data_one, 1, 1, 0, BN_FLG_STATIC_DATA
};
return &const_one;
}

4
crypto/bn/bn_nist.c
View File

@ -84,8 +84,8 @@ static const BN_ULONG _nist_p_384_sqr[] = {
0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL
};
static const BN_ULONG _nist_p_521[] =
{ 0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL,
static const BN_ULONG _nist_p_521[] = {
0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL,
0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL,
0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL,
0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL,

5
crypto/des/set_key.c
View File

@ -324,8 +324,9 @@ int DES_set_key_checked(const_DES_cblock *key, DES_key_schedule *schedule)
void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule)
{
static const int shifts2[16] =
{ 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0 };
static const int shifts2[16] = {
0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0
};
register DES_LONG c, d, t, s, t2;
register const unsigned char *in;
register DES_LONG *k;

5
crypto/ec/curve448/curve448.c
View File

@ -55,8 +55,9 @@ static void gf_invert(gf y, const gf x, int assert_nonzero)
}
/** identity = (0,1) */
const curve448_point_t ossl_curve448_point_identity =
{ {{{{0}}}, {{{1}}}, {{{1}}}, {{{0}}}} };
const curve448_point_t ossl_curve448_point_identity = {
{{{{0}}}, {{{1}}}, {{{1}}}, {{{0}}}}
};
static void point_double_internal(curve448_point_t p, const curve448_point_t q,
int before_double)

3
crypto/ec/ec_backend.c
View File

@ -184,8 +184,7 @@ static int ec_group_explicit_todata(const EC_GROUP *group, OSSL_PARAM_BLD *tmpl,
param_p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_P);
param_a = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_A);
param_b = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_B);
if (tmpl != NULL || param_p != NULL || param_a != NULL || param_b != NULL)
{
if (tmpl != NULL || param_p != NULL || param_a != NULL || param_b != NULL) {
BIGNUM *p = BN_CTX_get(bnctx);
BIGNUM *a = BN_CTX_get(bnctx);
BIGNUM *b = BN_CTX_get(bnctx);

10
crypto/ec/ecp_nistp256.c
View File

@ -118,8 +118,9 @@ typedef limb longfelem[NLIMBS * 2];
typedef u64 smallfelem[NLIMBS];
/* This is the value of the prime as four 64-bit words, little-endian. */
static const u64 kPrime[4] =
{ 0xfffffffffffffffful, 0xffffffff, 0, 0xffffffff00000001ul };
static const u64 kPrime[4] = {
0xfffffffffffffffful, 0xffffffff, 0, 0xffffffff00000001ul
};
static const u64 bottom63bits = 0x7ffffffffffffffful;
/*
@ -292,8 +293,9 @@ static void felem_diff(felem out, const felem in)
#define two107m43p11 (((limb)1) << 107) - (((limb)1) << 43) + (((limb)1) << 11)
/* zero107 is 0 mod p */
static const felem zero107 =
{ two107m43m11, two107, two107m43p11, two107m43p11 };
static const felem zero107 = {
two107m43m11, two107, two107m43p11, two107m43p11
};
/*-
* An alternative felem_diff for larger inputs |in|

5
crypto/evp/dh_support.c
View File

@ -12,7 +12,7 @@
#include "internal/nelem.h"
#include "crypto/dh.h"
typedef struct dh_name2id_st{
typedef struct dh_name2id_st {
const char *name;
int id;
int type;
@ -28,8 +28,7 @@ typedef struct dh_name2id_st{
# define TYPE_DHX 0
#endif
static const DH_GENTYPE_NAME2ID dhtype2id[] =
{
static const DH_GENTYPE_NAME2ID dhtype2id[] = {
{ "group", DH_PARAMGEN_TYPE_GROUP, TYPE_ANY },
{ "generator", DH_PARAMGEN_TYPE_GENERATOR, TYPE_DH },
{ "fips186_4", DH_PARAMGEN_TYPE_FIPS_186_4, TYPE_DHX },

5
crypto/evp/e_des3.c
View File

@ -312,8 +312,9 @@ const EVP_CIPHER *EVP_des_ede3(void)
# include <openssl/sha.h>
static const unsigned char wrap_iv[8] =
{ 0x4a, 0xdd, 0xa2, 0x2c, 0x79, 0xe8, 0x21, 0x05 };
static const unsigned char wrap_iv[8] = {
0x4a, 0xdd, 0xa2, 0x2c, 0x79, 0xe8, 0x21, 0x05
};
static int des_ede3_unwrap(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in, size_t inl)

9
crypto/idea/idea_local.h
View File

@ -9,13 +9,12 @@
#define idea_mul(r,a,b,ul) \
ul=(unsigned long)a*b; \
if (ul != 0) \
{ \
if (ul != 0) { \
r=(ul&0xffff)-(ul>>16); \
r-=((r)>>16); \
} \
else \
r=(-(int)a-b+1); /* assuming a or b is 0 and in range */
} else { \
r=(-(int)a-b+1); /* assuming a or b is 0 and in range */ \
}
/* NOTE - c is not incremented as per n2l */
#define n2ln(c,l1,l2,n) { \

26
crypto/sha/sha256.c
View File

@ -88,27 +88,31 @@ int SHA224_Final(unsigned char *md, SHA256_CTX *c)
#define HASH_MAKE_STRING(c,s) do { \
unsigned long ll; \
unsigned int nn; \
switch ((c)->md_len) \
{ case SHA256_192_DIGEST_LENGTH: \
for (nn=0;nn<SHA256_192_DIGEST_LENGTH/4;nn++) \
{ ll=(c)->h[nn]; (void)HOST_l2c(ll,(s)); } \
switch ((c)->md_len) { \
case SHA256_192_DIGEST_LENGTH: \
for (nn=0;nn<SHA256_192_DIGEST_LENGTH/4;nn++) { \
ll=(c)->h[nn]; (void)HOST_l2c(ll,(s)); \
} \
break; \
case SHA224_DIGEST_LENGTH: \
for (nn=0;nn<SHA224_DIGEST_LENGTH/4;nn++) \
{ ll=(c)->h[nn]; (void)HOST_l2c(ll,(s)); } \
for (nn=0;nn<SHA224_DIGEST_LENGTH/4;nn++) { \
ll=(c)->h[nn]; (void)HOST_l2c(ll,(s)); \
} \
break; \
case SHA256_DIGEST_LENGTH: \
for (nn=0;nn<SHA256_DIGEST_LENGTH/4;nn++) \
{ ll=(c)->h[nn]; (void)HOST_l2c(ll,(s)); } \
for (nn=0;nn<SHA256_DIGEST_LENGTH/4;nn++) { \
ll=(c)->h[nn]; (void)HOST_l2c(ll,(s)); \
} \
break; \
default: \
if ((c)->md_len > SHA256_DIGEST_LENGTH) \
return 0; \
for (nn=0;nn<(c)->md_len/4;nn++) \
{ ll=(c)->h[nn]; (void)HOST_l2c(ll,(s)); } \
for (nn=0;nn<(c)->md_len/4;nn++) { \
ll=(c)->h[nn]; (void)HOST_l2c(ll,(s)); \
} \
break; \
} \
} while (0)
} while (0)
#define HASH_UPDATE SHA256_Update
#define HASH_TRANSFORM SHA256_Transform

5
crypto/sm4/sm4.c
View File

@ -283,8 +283,9 @@ int ossl_sm4_set_key(const uint8_t *key, SM4_KEY *ks)
/*
* Family Key
*/
static const uint32_t FK[4] =
{ 0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc };
static const uint32_t FK[4] = {
0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc
};
/*
* Constant Key

4
crypto/x509/v3_pci.c
View File

@ -54,8 +54,8 @@ static int i2r_pci(X509V3_EXT_METHOD *method, PROXY_CERT_INFO_EXTENSION *ext,
static PROXY_CERT_INFO_EXTENSION *r2i_pci(X509V3_EXT_METHOD *method,
X509V3_CTX *ctx, char *str);
const X509V3_EXT_METHOD ossl_v3_pci =
{ NID_proxyCertInfo, 0, ASN1_ITEM_ref(PROXY_CERT_INFO_EXTENSION),
const X509V3_EXT_METHOD ossl_v3_pci = {
NID_proxyCertInfo, 0, ASN1_ITEM_ref(PROXY_CERT_INFO_EXTENSION),
0, 0, 0, 0,
0, 0,
NULL, NULL,

3
fuzz/server.c
View File

@ -625,8 +625,7 @@ int FuzzerTestOneInput(const uint8_t *buf, size_t len)
OPENSSL_assert((size_t)BIO_write(in, buf, len) == len);
if ((opt & 0x01) != 0)
{
if ((opt & 0x01) != 0) {
do {
char early_buf[16384];
size_t early_len;

8
include/crypto/evp.h
View File

@ -396,13 +396,12 @@ static int cname##_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const uns
#define BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
static int cname##_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
{\
while(inl>=EVP_MAXCHUNK) \
{\
while(inl>=EVP_MAXCHUNK) {\
cprefix##_cbc_encrypt(in, out, (long)EVP_MAXCHUNK, &EVP_C_DATA(kstruct,ctx)->ksched, ctx->iv, EVP_CIPHER_CTX_is_encrypting(ctx));\
inl-=EVP_MAXCHUNK;\
in +=EVP_MAXCHUNK;\
out+=EVP_MAXCHUNK;\
}\
}\
if (inl)\
cprefix##_cbc_encrypt(in, out, (long)inl, &EVP_C_DATA(kstruct,ctx)->ksched, ctx->iv, EVP_CIPHER_CTX_is_encrypting(ctx));\
return 1;\
@ -414,8 +413,7 @@ static int cname##_cfb##cbits##_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
size_t chunk = EVP_MAXCHUNK;\
if (cbits == 1) chunk >>= 3;\
if (inl < chunk) chunk = inl;\
while (inl && inl >= chunk)\
{\
while (inl && inl >= chunk) {\
int num = EVP_CIPHER_CTX_get_num(ctx);\
cprefix##_cfb##cbits##_encrypt(in, out, (long) \
((cbits == 1) \

3
providers/fips/self_test_kats.c
View File

@ -162,8 +162,7 @@ static int add_params(OSSL_PARAM_BLD *bld, const ST_KAT_PARAM *params,
if (params == NULL)
return 1;
for (p = params; p->data != NULL; ++p)
{
for (p = params; p->data != NULL; ++p) {
switch (p->type) {
case OSSL_PARAM_UNSIGNED_INTEGER: {
BIGNUM *bn = BN_CTX_get(ctx);

3
providers/implementations/ciphers/cipher_aes_gcm_siv_hw.c
View File

@ -318,8 +318,7 @@ static int aes_gcm_siv_dup_ctx(void *vdst, void *vsrc)
return 0;
}
static const PROV_CIPHER_HW_AES_GCM_SIV aes_gcm_siv_hw =
{
static const PROV_CIPHER_HW_AES_GCM_SIV aes_gcm_siv_hw = {
aes_gcm_siv_initkey,
aes_gcm_siv_cipher,
aes_gcm_siv_dup_ctx,

3
providers/implementations/ciphers/cipher_aes_siv_hw.c
View File

@ -120,8 +120,7 @@ static int aes_siv_cipher(void *vctx, unsigned char *out,
return ossl_siv128_decrypt(sctx, in, out, len) > 0;
}
static const PROV_CIPHER_HW_AES_SIV aes_siv_hw =
{
static const PROV_CIPHER_HW_AES_SIV aes_siv_hw = {
aes_siv_initkey,
aes_siv_cipher,
aes_siv_setspeed,

3
providers/implementations/ciphers/cipher_chacha20_poly1305_hw.c
View File

@ -398,8 +398,7 @@ err:
return rv;
}
static const PROV_CIPHER_HW_CHACHA20_POLY1305 chacha20poly1305_hw =
{
static const PROV_CIPHER_HW_CHACHA20_POLY1305 chacha20poly1305_hw = {
{ chacha20_poly1305_initkey, NULL },
chacha20_poly1305_aead_cipher,
chacha20_poly1305_initiv,

3
providers/implementations/ciphers/cipher_cts.c
View File

@ -68,8 +68,7 @@ typedef struct cts_mode_name2id_st {
const char *name;
} CTS_MODE_NAME2ID;
static CTS_MODE_NAME2ID cts_modes[] =
{
static CTS_MODE_NAME2ID cts_modes[] = {
{ CTS_CS1, OSSL_CIPHER_CTS_MODE_CS1 },
{ CTS_CS2, OSSL_CIPHER_CTS_MODE_CS2 },
{ CTS_CS3, OSSL_CIPHER_CTS_MODE_CS3 },

3
providers/implementations/ciphers/cipher_desx_hw.c
View File

@ -67,8 +67,7 @@ static int cipher_hw_desx_cbc(PROV_CIPHER_CTX *ctx, unsigned char *out,
return 1;
}
static const PROV_CIPHER_HW desx_cbc =
{
static const PROV_CIPHER_HW desx_cbc = {
cipher_hw_desx_cbc_initkey,
cipher_hw_desx_cbc,
cipher_hw_desx_copyctx

3
providers/implementations/ciphers/cipher_tdes_wrap.c
View File

@ -27,8 +27,7 @@
static OSSL_FUNC_cipher_update_fn tdes_wrap_update;
static OSSL_FUNC_cipher_cipher_fn tdes_wrap_cipher;
static const unsigned char wrap_iv[8] =
{
static const unsigned char wrap_iv[8] = {
0x4a, 0xdd, 0xa2, 0x2c, 0x79, 0xe8, 0x21, 0x05
};

6
providers/implementations/digests/blake2s_prov.c
View File

@ -20,14 +20,12 @@
#include "blake2_impl.h"
#include "prov/blake2.h"
static const uint32_t blake2s_IV[8] =
{
static const uint32_t blake2s_IV[8] = {
0x6A09E667U, 0xBB67AE85U, 0x3C6EF372U, 0xA54FF53AU,
0x510E527FU, 0x9B05688CU, 0x1F83D9ABU, 0x5BE0CD19U
};
static const uint8_t blake2s_sigma[10][16] =
{
static const uint8_t blake2s_sigma[10][16] = {
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ,
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 } ,
{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 } ,

18
providers/implementations/digests/sha3_prov.c
View File

@ -165,8 +165,7 @@ static int generic_sha3_squeeze(void *vctx, unsigned char *out, size_t outlen)
return ossl_sha3_squeeze((KECCAK1600_CTX *)vctx, out, outlen);
}
static PROV_SHA3_METHOD sha3_generic_md =
{
static PROV_SHA3_METHOD sha3_generic_md = {
generic_sha3_absorb,
generic_sha3_final,
NULL
@ -362,29 +361,25 @@ static int s390x_kmac_squeeze(void *vctx, unsigned char *out, size_t outlen)
return s390x_keccakc_squeeze(vctx, out, outlen, 0x04);
}
static PROV_SHA3_METHOD sha3_s390x_md =
{
static PROV_SHA3_METHOD sha3_s390x_md = {
s390x_sha3_absorb,
s390x_sha3_final,
NULL,
};
static PROV_SHA3_METHOD keccak_s390x_md =
{
static PROV_SHA3_METHOD keccak_s390x_md = {
s390x_sha3_absorb,
s390x_keccak_final,
s390x_keccak_squeeze,
};
static PROV_SHA3_METHOD shake_s390x_md =
{
static PROV_SHA3_METHOD shake_s390x_md = {
s390x_sha3_absorb,
s390x_shake_final,
s390x_shake_squeeze,
};
static PROV_SHA3_METHOD kmac_s390x_md =
{
static PROV_SHA3_METHOD kmac_s390x_md = {
s390x_sha3_absorb,
s390x_kmac_final,
s390x_kmac_squeeze,
@ -429,8 +424,7 @@ static size_t armsha3_sha3_absorb(void *vctx, const void *inp, size_t len)
return SHA3_absorb_cext(ctx->A, inp, len, ctx->block_size);
}
static PROV_SHA3_METHOD sha3_ARMSHA3_md =
{
static PROV_SHA3_METHOD sha3_ARMSHA3_md = {
armsha3_sha3_absorb,
generic_sha3_final
};

5
providers/implementations/kdfs/kbkdf.c
View File

@ -463,8 +463,9 @@ static int kbkdf_get_ctx_params(void *vctx, OSSL_PARAM params[])
static const OSSL_PARAM *kbkdf_gettable_ctx_params(ossl_unused void *ctx,
ossl_unused void *provctx)
{
static const OSSL_PARAM known_gettable_ctx_params[] =
{ OSSL_PARAM_size_t(OSSL_KDF_PARAM_SIZE, NULL), OSSL_PARAM_END };
static const OSSL_PARAM known_gettable_ctx_params[] = {
OSSL_PARAM_size_t(OSSL_KDF_PARAM_SIZE, NULL), OSSL_PARAM_END
};
return known_gettable_ctx_params;
}

3
providers/implementations/keymgmt/dsa_kmgmt.c
View File

@ -73,8 +73,7 @@ typedef struct dh_name2id_st{
int id;
} DSA_GENTYPE_NAME2ID;
static const DSA_GENTYPE_NAME2ID dsatype2id[]=
{
static const DSA_GENTYPE_NAME2ID dsatype2id[] = {
#ifdef FIPS_MODULE
{ "default", DSA_PARAMGEN_TYPE_FIPS_186_4 },
#else

3
providers/implementations/rands/seeding/rand_vxworks.c
View File

@ -105,8 +105,7 @@ size_t ossl_pool_acquire_entropy(RAND_POOL *pool)
size_t bytes_needed;
bytes_needed = ossl_rand_pool_bytes_needed(pool, 1 /*entropy_factor*/);
if (bytes_needed > 0)
{
if (bytes_needed > 0) {
int retryCount = 0;
STATUS result = ERROR;
unsigned char *buffer;

9
ssl/ssl_lib.c
View File

@ -1116,8 +1116,7 @@ int SSL_add1_host(SSL *s, const char *hostname)
/* If a hostname is provided and parses as an IP address,
* treat it as such. */
if (hostname)
{
if (hostname) {
ASN1_OCTET_STRING *ip;
char *old_ip;
@ -1127,8 +1126,7 @@ int SSL_add1_host(SSL *s, const char *hostname)
ASN1_OCTET_STRING_free(ip);
old_ip = X509_VERIFY_PARAM_get1_ip_asc(sc->param);
if (old_ip)
{
if (old_ip) {
OPENSSL_free(old_ip);
/* There can be only one IP address */
return 0;
@ -4820,8 +4818,7 @@ int ssl_undefined_const_function(const SSL *s)
const char *ssl_protocol_to_string(int version)
{
switch (version)
{
switch (version) {
case TLS1_3_VERSION:
return "TLSv1.3";

13
ssl/statem/statem_dtls.c
View File

@ -39,10 +39,12 @@
if (is_complete) for (ii = (((msg_len) - 1) >> 3) - 1; ii >= 0 ; ii--) \
if (bitmask[ii] != 0xff) { is_complete = 0; break; } }
static const unsigned char bitmask_start_values[] =
{ 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80 };
static const unsigned char bitmask_end_values[] =
{ 0xff, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f };
static const unsigned char bitmask_start_values[] = {
0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80
};
static const unsigned char bitmask_end_values[] = {
0xff, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f
};
static void dtls1_fix_message_header(SSL_CONNECTION *s, size_t frag_off,
size_t frag_len);
@ -1061,8 +1063,7 @@ int dtls1_read_failed(SSL_CONNECTION *s, int code)
return code;
}
/* done, no need to send a retransmit */
if (!SSL_in_init(ssl))
{
if (!SSL_in_init(ssl)) {
BIO_set_flags(SSL_get_rbio(ssl), BIO_FLAGS_READ);
return code;
}

10
test/bftest.c
View File

@ -163,8 +163,9 @@ static unsigned char cbc_key[16] = {
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87
};
static unsigned char cbc_iv[8] =
{ 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
static unsigned char cbc_iv[8] = {
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
};
static char cbc_data[40] = "7654321 Now is the time for ";
static unsigned char cbc_ok[32] = {
0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6,
@ -195,8 +196,9 @@ static unsigned char key_test[KEY_TEST_NUM] = {
0x88
};
static unsigned char key_data[8] =
{ 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
static unsigned char key_data[8] = {
0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10
};
static unsigned char key_out[KEY_TEST_NUM][8] = {
{0xF9, 0xAD, 0x59, 0x7C, 0x49, 0xDB, 0x00, 0x5E},

3
test/bio_enc_test.c
View File

@ -206,8 +206,7 @@ err:
static int do_test_bio_cipher(const EVP_CIPHER* cipher, int idx)
{
switch (idx)
{
switch (idx) {
case 0:
return do_bio_cipher(cipher, KEY, NULL);
case 1:

5
test/casttest.c
View File

@ -29,8 +29,9 @@ static unsigned char k[16] = {
0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9A
};
static unsigned char in[8] =
{ 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF };
static unsigned char in[8] = {
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF
};
static int k_len[3] = { 16, 10, 5 };

50
test/destest.c
View File

@ -177,14 +177,18 @@ static unsigned char cipher_ecb2[NUM_TESTS - 1][8] = {
{0x08, 0xD7, 0xB4, 0xFB, 0x62, 0x9D, 0x08, 0x85}
};
static unsigned char cbc_key[8] =
{ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
static unsigned char cbc2_key[8] =
{ 0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86 };
static unsigned char cbc3_key[8] =
{ 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
static unsigned char cbc_iv[8] =
{ 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
static unsigned char cbc_key[8] = {
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef
};
static unsigned char cbc2_key[8] = {
0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86
};
static unsigned char cbc3_key[8] = {
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
};
static unsigned char cbc_iv[8] = {
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
};
/*
* Changed the following text constant to binary so it will work on ebcdic
* machines :-)
@ -208,8 +212,9 @@ static unsigned char cbc_ok[32] = {
# ifdef SCREW_THE_PARITY
# error "SCREW_THE_PARITY is not meant to be defined."
# error "Original vectors are preserved for reference only."
static unsigned char cbc2_key[8] =
{ 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 };
static unsigned char cbc2_key[8] = {
0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87
};
static unsigned char xcbc_ok[32] = {
0x86, 0x74, 0x81, 0x0D, 0x61, 0xA4, 0xA5, 0x48,
0xB9, 0x93, 0x03, 0xE1, 0xB8, 0xBB, 0xBD, 0xBD,
@ -239,10 +244,12 @@ static unsigned char pcbc_ok[32] = {
0xf7, 0x17, 0x46, 0x3b, 0x8a, 0xb3, 0xcc, 0x88
};
static unsigned char cfb_key[8] =
{ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
static unsigned char cfb_iv[8] =
{ 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
static unsigned char cfb_key[8] = {
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef
};
static unsigned char cfb_iv[8] = {
0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef
};
static unsigned char cfb_buf1[40], cfb_buf2[40], cfb_tmp[8];
static unsigned char plain[24] = {
0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73,
@ -276,10 +283,12 @@ static unsigned char cfb_cipher64[24] = {
0x1A, 0x92, 0xF7, 0x84, 0x03, 0x46, 0x71, 0x33, 0x89, 0x8E, 0xA6, 0x22
};
static unsigned char ofb_key[8] =
{ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
static unsigned char ofb_iv[8] =
{ 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
static unsigned char ofb_key[8] = {
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef
};
static unsigned char ofb_iv[8] = {
0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef
};
static unsigned char ofb_buf1[24], ofb_buf2[24], ofb_tmp[8];
static unsigned char ofb_cipher[24] = {
0xf3, 0x09, 0x62, 0x49, 0xc7, 0xf4, 0x6e, 0x51,
@ -287,8 +296,9 @@ static unsigned char ofb_cipher[24] = {
0x3d, 0x6d, 0x5b, 0xe3, 0x25, 0x5a, 0xf8, 0xc3
};
static DES_LONG cbc_cksum_ret = 0xF7FE62B4L;
static unsigned char cbc_cksum_data[8] =
{ 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 };
static unsigned char cbc_cksum_data[8] = {
0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4
};
static char *pt(const unsigned char *p, char buf[DATA_BUF_SIZE])
{

57
test/evp_extra_test.c
View File

@ -3504,28 +3504,43 @@ static int test_evp_iv_aes(int idx)
{
int ret = 0;
EVP_CIPHER_CTX *ctx = NULL;
unsigned char key[16] = {0x4c, 0x43, 0xdb, 0xdd, 0x42, 0x73, 0x47, 0xd1,
0xe5, 0x62, 0x7d, 0xcd, 0x4d, 0x76, 0x4d, 0x57};
unsigned char init_iv[EVP_MAX_IV_LENGTH] =
{0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b, 0x98, 0x82,
0x5a, 0x55, 0x91, 0x81, 0x42, 0xa8, 0x89, 0x34};
static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16 };
unsigned char key[16] = {
0x4c, 0x43, 0xdb, 0xdd, 0x42, 0x73, 0x47, 0xd1,
0xe5, 0x62, 0x7d, 0xcd, 0x4d, 0x76, 0x4d, 0x57
};
unsigned char init_iv[EVP_MAX_IV_LENGTH] = {
0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b, 0x98, 0x82,
0x5a, 0x55, 0x91, 0x81, 0x42, 0xa8, 0x89, 0x34
};
static const unsigned char msg[] = {
1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16
};
unsigned char ciphertext[32], oiv[16], iv[16];
unsigned char *ref_iv;
unsigned char cbc_state[16] = {0x10, 0x2f, 0x05, 0xcc, 0xc2, 0x55, 0x72, 0xb9,
0x88, 0xe6, 0x4a, 0x17, 0x10, 0x74, 0x22, 0x5e};
unsigned char cbc_state[16] = {
0x10, 0x2f, 0x05, 0xcc, 0xc2, 0x55, 0x72, 0xb9,
0x88, 0xe6, 0x4a, 0x17, 0x10, 0x74, 0x22, 0x5e
};
unsigned char ofb_state[16] = {0x76, 0xe6, 0x66, 0x61, 0xd0, 0x8a, 0xe4, 0x64,
0xdd, 0x66, 0xbf, 0x00, 0xf0, 0xe3, 0x6f, 0xfd};
unsigned char cfb_state[16] = {0x77, 0xe4, 0x65, 0x65, 0xd5, 0x8c, 0xe3, 0x6c,
0xd4, 0x6c, 0xb4, 0x0c, 0xfd, 0xed, 0x60, 0xed};
unsigned char gcm_state[12] = {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b,
0x98, 0x82, 0x5a, 0x55, 0x91, 0x81};
unsigned char ccm_state[7] = {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b, 0x98};
unsigned char ofb_state[16] = {
0x76, 0xe6, 0x66, 0x61, 0xd0, 0x8a, 0xe4, 0x64,
0xdd, 0x66, 0xbf, 0x00, 0xf0, 0xe3, 0x6f, 0xfd
};
unsigned char cfb_state[16] = {
0x77, 0xe4, 0x65, 0x65, 0xd5, 0x8c, 0xe3, 0x6c,
0xd4, 0x6c, 0xb4, 0x0c, 0xfd, 0xed, 0x60, 0xed
};
unsigned char gcm_state[12] = {
0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b,
0x98, 0x82, 0x5a, 0x55, 0x91, 0x81
};
unsigned char ccm_state[7] = { 0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b, 0x98 };
#ifndef OPENSSL_NO_OCB
unsigned char ocb_state[12] = {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b,
0x98, 0x82, 0x5a, 0x55, 0x91, 0x81};
unsigned char ocb_state[12] = {
0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b,
0x98, 0x82, 0x5a, 0x55, 0x91, 0x81
};
#endif
int len = sizeof(ciphertext);
size_t ivlen, ref_len;
@ -3654,8 +3669,10 @@ static int test_evp_iv_des(int idx)
static const unsigned char init_iv[8] = {
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
};
static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16 };
static const unsigned char msg[] = {
1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16
};
unsigned char ciphertext[32], oiv[8], iv[8];
unsigned const char *ref_iv;
static const unsigned char cbc_state_des[8] = {

3
test/helpers/pkcs12.c
View File

@ -531,8 +531,7 @@ static int check_attrs(const STACK_OF(X509_ATTRIBUTE) *bag_attrs, const PKCS12_A
if (!TEST_int_eq(X509_ATTRIBUTE_count(attr), 1))
goto err;
for (j = 0; j < X509_ATTRIBUTE_count(attr); j++)
{
for (j = 0; j < X509_ATTRIBUTE_count(attr); j++) {
av = X509_ATTRIBUTE_get0_type(attr, j);
if (!TEST_true(check_asn1_string(av, p_attr->value)))
goto err;

5
test/ideatest.c
View File

@ -38,8 +38,9 @@ static const unsigned char cfb_key[16] = {
0xe1, 0xf0, 0xc3, 0xd2, 0xa5, 0xb4, 0x87, 0x96,
0x69, 0x78, 0x4b, 0x5a, 0x2d, 0x3c, 0x0f, 0x1e,
};
static const unsigned char cfb_iv[80] =
{ 0x34, 0x12, 0x78, 0x56, 0xab, 0x90, 0xef, 0xcd };
static const unsigned char cfb_iv[80] = {
0x34, 0x12, 0x78, 0x56, 0xab, 0x90, 0xef, 0xcd
};
static unsigned char cfb_buf1[40], cfb_buf2[40], cfb_tmp[8];
# define CFB_TEST_SIZE 24
static const unsigned char plain[CFB_TEST_SIZE] = {

5
test/modes_internal_test.c
View File

@ -40,8 +40,9 @@ static const unsigned char cts128_test_key[16] = "chicken teriyaki";
static const unsigned char cts128_test_input[64] =
"I would like the" " General Gau's C"
"hicken, please, " "and wonton soup.";
static const unsigned char cts128_test_iv[] =
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
static const unsigned char cts128_test_iv[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
static const unsigned char vector_17[17] = {
0xc6, 0x35, 0x35, 0x68, 0xf2, 0xbf, 0x8c, 0xb4,

12
test/pkcs12_format_test.c
View File

@ -30,8 +30,7 @@ static OSSL_PROVIDER *lgcyprov = NULL;
* PKCS12 component test data
*/
static const unsigned char CERT1[] =
{
static const unsigned char CERT1[] = {
0x30, 0x82, 0x01, 0xed, 0x30, 0x82, 0x01, 0x56, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x09, 0x00,
0x8b, 0x4b, 0x5e, 0x6c, 0x03, 0x28, 0x4e, 0xe6, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86,
0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30, 0x19, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55,
@ -66,8 +65,7 @@ static const unsigned char CERT1[] =
0x30,
};
static const unsigned char CERT2[] =
{
static const unsigned char CERT2[] = {
0x30, 0x82, 0x01, 0xed, 0x30, 0x82, 0x01, 0x56, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x09, 0x00,
0x8b, 0x4b, 0x5e, 0x6c, 0x03, 0x28, 0x4e, 0xe7, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86,
0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30, 0x19, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55,
@ -102,8 +100,7 @@ static const unsigned char CERT2[] =
0x0b,
};
static const unsigned char KEY1[] =
{
static const unsigned char KEY1[] = {
0x30, 0x82, 0x02, 0x5d, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xbc, 0xdc, 0x6f, 0x8c, 0x7a,
0x2a, 0x4b, 0xea, 0x66, 0x66, 0x04, 0xa9, 0x05, 0x92, 0x53, 0xd7, 0x13, 0x3c, 0x49, 0xe1, 0xc8,
0xbb, 0xdf, 0x3d, 0xcb, 0x88, 0x31, 0x07, 0x20, 0x59, 0x93, 0x24, 0x7f, 0x7d, 0xc6, 0x84, 0x81,
@ -146,8 +143,7 @@ static const unsigned char KEY1[] =
};
static const unsigned char KEY2[] =
{
static const unsigned char KEY2[] = {
0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xa8, 0x6e, 0x40, 0x86, 0x9f,
0x98, 0x59, 0xfb, 0x57, 0xbf, 0xc1, 0x55, 0x12, 0x38, 0xeb, 0xb3, 0x46, 0x34, 0xc9, 0x35, 0x4d,
0xfd, 0x03, 0xe9, 0x3a, 0x88, 0x9e, 0x97, 0x8f, 0xf4, 0xec, 0x36, 0x7b, 0x3f, 0xba, 0xb8, 0xa5,

3
test/rsa_sp800_56b_test.c
View File

@ -480,8 +480,7 @@ end:
return ret;
}
static int keygen_size[] =
{
static int keygen_size[] = {
2048, 3072
};

3
test/ssl_old_test.c
View File

@ -903,8 +903,7 @@ int main(int argc, char *argv[])
int ret = EXIT_FAILURE;
int client_auth = 0;
int server_auth = 0, i;
struct app_verify_arg app_verify_arg =
{ APP_CALLBACK_STRING, 0 };
struct app_verify_arg app_verify_arg = { APP_CALLBACK_STRING, 0 };
SSL_CTX *c_ctx = NULL;
const SSL_METHOD *meth = NULL;
SSL *c_ssl = NULL;

3
test/sslbuffertest.c
View File

@ -140,8 +140,7 @@ static int test_func(int test)
* bytes from the record header/padding etc.
*/
for (ret = -1, i = 0, len = 0; len != sizeof(testdata) &&
i < MAX_ATTEMPTS; i++)
{
i < MAX_ATTEMPTS; i++) {
if (test >= 5 && (!TEST_true(SSL_free_buffers(serverssl))
|| !TEST_true(checkbuffers(serverssl, 0))))
goto end;