wolfSSL/wolfssl
1
0
Fork 1
mirror of https://github.com/wolfSSL/wolfssl.git synced 2025-08-03 04:34:41 +02:00
Code Issues Packages Projects Releases Wiki Activity

add int return to OpenSSL compatibility SHA functions

Browse Source
This commit is contained in:
Chris Conlon
2017-09-27 14:28:19 -06:00
parent fadee8fbf2
commit ef141c3ce9
2 changed files with 173 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

199
src/ssl.c
View File

@@ -11988,137 +11988,226 @@ size_t wolfSSL_get_client_random(const WOLFSSL* ssl, unsigned char* out,
#ifndef NO_SHA #ifndef NO_SHA
void wolfSSL_SHA_Init(WOLFSSL_SHA_CTX* sha) int wolfSSL_SHA_Init(WOLFSSL_SHA_CTX* sha)
{ {
int ret;
typedef char sha_test[sizeof(SHA_CTX) >= sizeof(Sha) ? 1 : -1]; typedef char sha_test[sizeof(SHA_CTX) >= sizeof(Sha) ? 1 : -1];
(void)sizeof(sha_test); (void)sizeof(sha_test);
WOLFSSL_ENTER("SHA_Init"); WOLFSSL_ENTER("SHA_Init");
wc_InitSha((Sha*)sha); /* OpenSSL compat, no ret */ ret = wc_InitSha((Sha*)sha);
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
void wolfSSL_SHA_Update(WOLFSSL_SHA_CTX* sha, const void* input, int wolfSSL_SHA_Update(WOLFSSL_SHA_CTX* sha, const void* input,
unsigned long sz) unsigned long sz)
{ {
int ret;
WOLFSSL_ENTER("SHA_Update"); WOLFSSL_ENTER("SHA_Update");
wc_ShaUpdate((Sha*)sha, (const byte*)input, (word32)sz); ret = wc_ShaUpdate((Sha*)sha, (const byte*)input, (word32)sz);
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
void wolfSSL_SHA_Final(byte* input, WOLFSSL_SHA_CTX* sha) int wolfSSL_SHA_Final(byte* input, WOLFSSL_SHA_CTX* sha)
{ {
int ret;
WOLFSSL_ENTER("SHA_Final"); WOLFSSL_ENTER("SHA_Final");
wc_ShaFinal((Sha*)sha, input); ret = wc_ShaFinal((Sha*)sha, input);
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
void wolfSSL_SHA1_Init(WOLFSSL_SHA_CTX* sha) int wolfSSL_SHA1_Init(WOLFSSL_SHA_CTX* sha)
{ {
WOLFSSL_ENTER("SHA1_Init"); WOLFSSL_ENTER("SHA1_Init");
SHA_Init(sha); return SHA_Init(sha);
} }
void wolfSSL_SHA1_Update(WOLFSSL_SHA_CTX* sha, const void* input, int wolfSSL_SHA1_Update(WOLFSSL_SHA_CTX* sha, const void* input,
unsigned long sz) unsigned long sz)
{ {
WOLFSSL_ENTER("SHA1_Update"); WOLFSSL_ENTER("SHA1_Update");
SHA_Update(sha, input, sz); return SHA_Update(sha, input, sz);
} }
void wolfSSL_SHA1_Final(byte* input, WOLFSSL_SHA_CTX* sha) int wolfSSL_SHA1_Final(byte* input, WOLFSSL_SHA_CTX* sha)
{ {
WOLFSSL_ENTER("SHA1_Final"); WOLFSSL_ENTER("SHA1_Final");
SHA_Final(input, sha); return SHA_Final(input, sha);
} }
#endif /* NO_SHA */ #endif /* NO_SHA */
#ifdef WOLFSSL_SHA224 #ifdef WOLFSSL_SHA224
void wolfSSL_SHA224_Init(WOLFSSL_SHA224_CTX* sha) int wolfSSL_SHA224_Init(WOLFSSL_SHA224_CTX* sha)
{ {
int ret;
typedef char sha_test[sizeof(SHA224_CTX) >= sizeof(Sha224) ? 1 : -1]; typedef char sha_test[sizeof(SHA224_CTX) >= sizeof(Sha224) ? 1 : -1];
(void)sizeof(sha_test); (void)sizeof(sha_test);
WOLFSSL_ENTER("SHA224_Init"); WOLFSSL_ENTER("SHA224_Init");
wc_InitSha224((Sha224*)sha); /* OpenSSL compat, no error */ ret = wc_InitSha224((Sha224*)sha);
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
void wolfSSL_SHA224_Update(WOLFSSL_SHA224_CTX* sha, const void* input, int wolfSSL_SHA224_Update(WOLFSSL_SHA224_CTX* sha, const void* input,
unsigned long sz) unsigned long sz)
{ {
int ret;
WOLFSSL_ENTER("SHA224_Update"); WOLFSSL_ENTER("SHA224_Update");
wc_Sha224Update((Sha224*)sha, (const byte*)input, (word32)sz); ret = wc_Sha224Update((Sha224*)sha, (const byte*)input, (word32)sz);
/* OpenSSL compat, no error */
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
void wolfSSL_SHA224_Final(byte* input, WOLFSSL_SHA224_CTX* sha) int wolfSSL_SHA224_Final(byte* input, WOLFSSL_SHA224_CTX* sha)
{ {
int ret;
WOLFSSL_ENTER("SHA224_Final"); WOLFSSL_ENTER("SHA224_Final");
wc_Sha224Final((Sha224*)sha, input); ret = wc_Sha224Final((Sha224*)sha, input);
/* OpenSSL compat, no error */
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
#endif /* WOLFSSL_SHA224 */ #endif /* WOLFSSL_SHA224 */
void wolfSSL_SHA256_Init(WOLFSSL_SHA256_CTX* sha256) int wolfSSL_SHA256_Init(WOLFSSL_SHA256_CTX* sha256)
{ {
int ret;
typedef char sha_test[sizeof(SHA256_CTX) >= sizeof(Sha256) ? 1 : -1]; typedef char sha_test[sizeof(SHA256_CTX) >= sizeof(Sha256) ? 1 : -1];
(void)sizeof(sha_test); (void)sizeof(sha_test);
WOLFSSL_ENTER("SHA256_Init"); WOLFSSL_ENTER("SHA256_Init");
wc_InitSha256((Sha256*)sha256); /* OpenSSL compat, no error */ ret = wc_InitSha256((Sha256*)sha256);
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
void wolfSSL_SHA256_Update(WOLFSSL_SHA256_CTX* sha, const void* input, int wolfSSL_SHA256_Update(WOLFSSL_SHA256_CTX* sha, const void* input,
unsigned long sz) unsigned long sz)
{ {
int ret;
WOLFSSL_ENTER("SHA256_Update"); WOLFSSL_ENTER("SHA256_Update");
wc_Sha256Update((Sha256*)sha, (const byte*)input, (word32)sz); ret = wc_Sha256Update((Sha256*)sha, (const byte*)input, (word32)sz);
/* OpenSSL compat, no error */
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
void wolfSSL_SHA256_Final(byte* input, WOLFSSL_SHA256_CTX* sha) int wolfSSL_SHA256_Final(byte* input, WOLFSSL_SHA256_CTX* sha)
{ {
int ret;
WOLFSSL_ENTER("SHA256_Final"); WOLFSSL_ENTER("SHA256_Final");
wc_Sha256Final((Sha256*)sha, input); ret = wc_Sha256Final((Sha256*)sha, input);
/* OpenSSL compat, no error */
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
#ifdef WOLFSSL_SHA384 #ifdef WOLFSSL_SHA384
void wolfSSL_SHA384_Init(WOLFSSL_SHA384_CTX* sha) int wolfSSL_SHA384_Init(WOLFSSL_SHA384_CTX* sha)
{ {
int ret;
typedef char sha_test[sizeof(SHA384_CTX) >= sizeof(Sha384) ? 1 : -1]; typedef char sha_test[sizeof(SHA384_CTX) >= sizeof(Sha384) ? 1 : -1];
(void)sizeof(sha_test); (void)sizeof(sha_test);
WOLFSSL_ENTER("SHA384_Init"); WOLFSSL_ENTER("SHA384_Init");
wc_InitSha384((Sha384*)sha); /* OpenSSL compat, no error */ ret = wc_InitSha384((Sha384*)sha);
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
void wolfSSL_SHA384_Update(WOLFSSL_SHA384_CTX* sha, const void* input, int wolfSSL_SHA384_Update(WOLFSSL_SHA384_CTX* sha, const void* input,
unsigned long sz) unsigned long sz)
{ {
int ret;
WOLFSSL_ENTER("SHA384_Update"); WOLFSSL_ENTER("SHA384_Update");
wc_Sha384Update((Sha384*)sha, (const byte*)input, (word32)sz); ret = wc_Sha384Update((Sha384*)sha, (const byte*)input, (word32)sz);
/* OpenSSL compat, no error */
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
void wolfSSL_SHA384_Final(byte* input, WOLFSSL_SHA384_CTX* sha) int wolfSSL_SHA384_Final(byte* input, WOLFSSL_SHA384_CTX* sha)
{ {
int ret;
WOLFSSL_ENTER("SHA384_Final"); WOLFSSL_ENTER("SHA384_Final");
wc_Sha384Final((Sha384*)sha, input); ret = wc_Sha384Final((Sha384*)sha, input);
/* OpenSSL compat, no error */
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
#endif /* WOLFSSL_SHA384 */ #endif /* WOLFSSL_SHA384 */
@@ -12126,30 +12215,52 @@ size_t wolfSSL_get_client_random(const WOLFSSL* ssl, unsigned char* out,
#ifdef WOLFSSL_SHA512 #ifdef WOLFSSL_SHA512
void wolfSSL_SHA512_Init(WOLFSSL_SHA512_CTX* sha) int wolfSSL_SHA512_Init(WOLFSSL_SHA512_CTX* sha)
{ {
int ret;
typedef char sha_test[sizeof(SHA512_CTX) >= sizeof(Sha512) ? 1 : -1]; typedef char sha_test[sizeof(SHA512_CTX) >= sizeof(Sha512) ? 1 : -1];
(void)sizeof(sha_test); (void)sizeof(sha_test);
WOLFSSL_ENTER("SHA512_Init"); WOLFSSL_ENTER("SHA512_Init");
wc_InitSha512((Sha512*)sha); /* OpenSSL compat, no error */ ret = wc_InitSha512((Sha512*)sha);
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
void wolfSSL_SHA512_Update(WOLFSSL_SHA512_CTX* sha, const void* input, int wolfSSL_SHA512_Update(WOLFSSL_SHA512_CTX* sha, const void* input,
unsigned long sz) unsigned long sz)
{ {
int ret;
WOLFSSL_ENTER("SHA512_Update"); WOLFSSL_ENTER("SHA512_Update");
wc_Sha512Update((Sha512*)sha, (const byte*)input, (word32)sz); ret = wc_Sha512Update((Sha512*)sha, (const byte*)input, (word32)sz);
/* OpenSSL compat, no error */
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
void wolfSSL_SHA512_Final(byte* input, WOLFSSL_SHA512_CTX* sha) int wolfSSL_SHA512_Final(byte* input, WOLFSSL_SHA512_CTX* sha)
{ {
int ret;
WOLFSSL_ENTER("SHA512_Final"); WOLFSSL_ENTER("SHA512_Final");
wc_Sha512Final((Sha512*)sha, input); ret = wc_Sha512Final((Sha512*)sha, input);
/* OpenSSL compat, no error */
/* return 1 on success, 0 otherwise */
if (ret == 0)
return 1;
return 0;
} }
#endif /* WOLFSSL_SHA512 */ #endif /* WOLFSSL_SHA512 */

36
wolfssl/openssl/sha.h
View File

@@ -21,14 +21,14 @@ typedef struct WOLFSSL_SHA_CTX {
int holder[28 + (WC_ASYNC_DEV_SIZE / sizeof(int))]; int holder[28 + (WC_ASYNC_DEV_SIZE / sizeof(int))];
} WOLFSSL_SHA_CTX; } WOLFSSL_SHA_CTX;
WOLFSSL_API void wolfSSL_SHA_Init(WOLFSSL_SHA_CTX*); WOLFSSL_API int wolfSSL_SHA_Init(WOLFSSL_SHA_CTX*);
WOLFSSL_API void wolfSSL_SHA_Update(WOLFSSL_SHA_CTX*, const void*, unsigned long); WOLFSSL_API int wolfSSL_SHA_Update(WOLFSSL_SHA_CTX*, const void*, unsigned long);
WOLFSSL_API void wolfSSL_SHA_Final(unsigned char*, WOLFSSL_SHA_CTX*); WOLFSSL_API int wolfSSL_SHA_Final(unsigned char*, WOLFSSL_SHA_CTX*);
/* SHA1 points to above, shouldn't use SHA0 ever */ /* SHA1 points to above, shouldn't use SHA0 ever */
WOLFSSL_API void wolfSSL_SHA1_Init(WOLFSSL_SHA_CTX*); WOLFSSL_API int wolfSSL_SHA1_Init(WOLFSSL_SHA_CTX*);
WOLFSSL_API void wolfSSL_SHA1_Update(WOLFSSL_SHA_CTX*, const void*, unsigned long); WOLFSSL_API int wolfSSL_SHA1_Update(WOLFSSL_SHA_CTX*, const void*, unsigned long);
WOLFSSL_API void wolfSSL_SHA1_Final(unsigned char*, WOLFSSL_SHA_CTX*); WOLFSSL_API int wolfSSL_SHA1_Final(unsigned char*, WOLFSSL_SHA_CTX*);
enum { enum {
SHA_DIGEST_LENGTH = 20 SHA_DIGEST_LENGTH = 20
@@ -56,10 +56,10 @@ typedef struct WOLFSSL_SHA224_CTX {
ALIGN16 int holder[34 + (WC_ASYNC_DEV_SIZE / sizeof(int))]; ALIGN16 int holder[34 + (WC_ASYNC_DEV_SIZE / sizeof(int))];
} WOLFSSL_SHA224_CTX; } WOLFSSL_SHA224_CTX;
WOLFSSL_API void wolfSSL_SHA224_Init(WOLFSSL_SHA224_CTX*); WOLFSSL_API int wolfSSL_SHA224_Init(WOLFSSL_SHA224_CTX*);
WOLFSSL_API void wolfSSL_SHA224_Update(WOLFSSL_SHA224_CTX*, const void*, WOLFSSL_API int wolfSSL_SHA224_Update(WOLFSSL_SHA224_CTX*, const void*,
unsigned long); unsigned long);
WOLFSSL_API void wolfSSL_SHA224_Final(unsigned char*, WOLFSSL_SHA224_CTX*); WOLFSSL_API int wolfSSL_SHA224_Final(unsigned char*, WOLFSSL_SHA224_CTX*);
enum { enum {
SHA224_DIGEST_LENGTH = 28 SHA224_DIGEST_LENGTH = 28
@@ -83,10 +83,10 @@ typedef struct WOLFSSL_SHA256_CTX {
ALIGN16 int holder[34 + (WC_ASYNC_DEV_SIZE / sizeof(int))]; ALIGN16 int holder[34 + (WC_ASYNC_DEV_SIZE / sizeof(int))];
} WOLFSSL_SHA256_CTX; } WOLFSSL_SHA256_CTX;
WOLFSSL_API void wolfSSL_SHA256_Init(WOLFSSL_SHA256_CTX*); WOLFSSL_API int wolfSSL_SHA256_Init(WOLFSSL_SHA256_CTX*);
WOLFSSL_API void wolfSSL_SHA256_Update(WOLFSSL_SHA256_CTX*, const void*, WOLFSSL_API int wolfSSL_SHA256_Update(WOLFSSL_SHA256_CTX*, const void*,
unsigned long); unsigned long);
WOLFSSL_API void wolfSSL_SHA256_Final(unsigned char*, WOLFSSL_SHA256_CTX*); WOLFSSL_API int wolfSSL_SHA256_Final(unsigned char*, WOLFSSL_SHA256_CTX*);
enum { enum {
SHA256_DIGEST_LENGTH = 32 SHA256_DIGEST_LENGTH = 32
@@ -107,10 +107,10 @@ typedef struct WOLFSSL_SHA384_CTX {
long long holder[32 + (WC_ASYNC_DEV_SIZE / sizeof(long long))]; long long holder[32 + (WC_ASYNC_DEV_SIZE / sizeof(long long))];
} WOLFSSL_SHA384_CTX; } WOLFSSL_SHA384_CTX;
WOLFSSL_API void wolfSSL_SHA384_Init(WOLFSSL_SHA384_CTX*); WOLFSSL_API int wolfSSL_SHA384_Init(WOLFSSL_SHA384_CTX*);
WOLFSSL_API void wolfSSL_SHA384_Update(WOLFSSL_SHA384_CTX*, const void*, WOLFSSL_API int wolfSSL_SHA384_Update(WOLFSSL_SHA384_CTX*, const void*,
unsigned long); unsigned long);
WOLFSSL_API void wolfSSL_SHA384_Final(unsigned char*, WOLFSSL_SHA384_CTX*); WOLFSSL_API int wolfSSL_SHA384_Final(unsigned char*, WOLFSSL_SHA384_CTX*);
enum { enum {
SHA384_DIGEST_LENGTH = 48 SHA384_DIGEST_LENGTH = 48
@@ -132,10 +132,10 @@ typedef struct WOLFSSL_SHA512_CTX {
long long holder[36 + (WC_ASYNC_DEV_SIZE / sizeof(long long))]; long long holder[36 + (WC_ASYNC_DEV_SIZE / sizeof(long long))];
} WOLFSSL_SHA512_CTX; } WOLFSSL_SHA512_CTX;
WOLFSSL_API void wolfSSL_SHA512_Init(WOLFSSL_SHA512_CTX*); WOLFSSL_API int wolfSSL_SHA512_Init(WOLFSSL_SHA512_CTX*);
WOLFSSL_API void wolfSSL_SHA512_Update(WOLFSSL_SHA512_CTX*, const void*, WOLFSSL_API int wolfSSL_SHA512_Update(WOLFSSL_SHA512_CTX*, const void*,
unsigned long); unsigned long);
WOLFSSL_API void wolfSSL_SHA512_Final(unsigned char*, WOLFSSL_SHA512_CTX*); WOLFSSL_API int wolfSSL_SHA512_Final(unsigned char*, WOLFSSL_SHA512_CTX*);
enum { enum {
SHA512_DIGEST_LENGTH = 64 SHA512_DIGEST_LENGTH = 64