Spiegel von
https://github.com/wolfSSL/wolfssl.git
synchronisiert 2025-01-19 05:34:54 +00:00
1250 Zeilen
30 KiB
C
1250 Zeilen
30 KiB
C
/*!
|
|
\ingroup SHA
|
|
|
|
\brief This function initializes SHA3-224. This is automatically
|
|
called by wc_Sha3_224Hash.
|
|
|
|
\return 0 Returned upon successfully initializing
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
if ((ret = wc_InitSha3_224(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_224 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_224_Update(sha3, data, len);
|
|
wc_Sha3_224_Final(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_224Hash
|
|
\sa wc_Sha3_224_Update
|
|
\sa wc_Sha3_224_Final
|
|
*/
|
|
int wc_InitSha3_224(wc_Sha3* sha3, void* heap, int devId);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Can be called to continually hash the provided byte
|
|
array of length len.
|
|
|
|
\return 0 Returned upon successfully adding the data to the digest.
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
\param data the data to be hashed
|
|
\param len length of data to be hashed
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitSha3_224(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_224 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_224_Update(sha3, data, len);
|
|
wc_Sha3_224_Final(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_224Hash
|
|
\sa wc_Sha3_224_Final
|
|
\sa wc_InitSha3_224
|
|
*/
|
|
int wc_Sha3_224_Update(wc_Sha3* sha, const byte* data, word32 len);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Finalizes hashing of data. Result is placed into hash.
|
|
Resets state of sha3 struct.
|
|
|
|
\return 0 Returned upon successfully finalizing.
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
\param hash Byte array to hold hash value.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitSha3_224(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_224 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_224_Update(sha3, data, len);
|
|
wc_Sha3_224_Final(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_224Hash
|
|
\sa wc_Sha3_224_GetHash
|
|
\sa wc_InitSha3_224
|
|
*/
|
|
int wc_Sha3_224_Final(wc_Sha3* sha3, byte* hash);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Resets the wc_Sha3 structure. Note: this is only supported
|
|
if you have WOLFSSL_TI_HASH defined.
|
|
|
|
\return none No returns.
|
|
|
|
\param sha3 Pointer to the sha3 structure to be freed.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3;
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitSha3_224(&sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_224 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_224_Update(&sha3, data, len);
|
|
wc_Sha3_224_Final(&sha3, hash);
|
|
wc_Sha3_224_Free(&sha3);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_InitSha3_224
|
|
\sa wc_Sha3_224_Update
|
|
\sa wc_Sha3_224_Final
|
|
*/
|
|
void wc_Sha3_224_Free(wc_Sha3*);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Gets hash data. Result is placed into hash. Does not
|
|
reset state of sha3 struct.
|
|
|
|
\return 0 Returned upon successful copying of the hash.
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
\param hash Byte array to hold hash value.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
if ((ret = wc_InitSha3_224(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_224 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_224_Update(sha3, data, len);
|
|
wc_Sha3_224_GetHash(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_224Hash
|
|
\sa wc_Sha3_224_Final
|
|
\sa wc_InitSha3_224
|
|
\sa wc_Sha3_224_Copy
|
|
*/
|
|
int wc_Sha3_224_GetHash(wc_Sha3* sha3, byte* hash);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Copy the state of the hash.
|
|
|
|
\return 0 Returned upon successful copying.
|
|
|
|
\param sha3 pointer to the sha3 structure to copy
|
|
\param dst pointer to the sha3 structure to copy into
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
wc_Sha3 sha3_dup[1];
|
|
if ((ret = wc_InitSha3_224(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_224 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_224_Update(sha3, data, len);
|
|
wc_Sha3_224_Copy(sha3, sha3_dup);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_224Hash
|
|
\sa wc_Sha3_224_Final
|
|
\sa wc_InitSha3_224
|
|
\sa wc_Sha3_224_GetHash
|
|
*/
|
|
int wc_Sha3_224_Copy(wc_Sha3* sha3, wc_Sha3* dst);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief This function initializes SHA3-256. This is automatically
|
|
called by wc_Sha3_256Hash.
|
|
|
|
\return 0 Returned upon successfully initializing
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
if ((ret = wc_InitSha3_256(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_256 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_256_Update(sha3, data, len);
|
|
wc_Sha3_256_Final(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_256Hash
|
|
\sa wc_Sha3_256_Update
|
|
\sa wc_Sha3_256_Final
|
|
*/
|
|
int wc_InitSha3_256(wc_Sha3* sha3, void* heap, int devId);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Can be called to continually hash the provided byte
|
|
array of length len.
|
|
|
|
\return 0 Returned upon successfully adding the data to the digest.
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
\param data the data to be hashed
|
|
\param len length of data to be hashed
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitSha3_256(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_256 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_256_Update(sha3, data, len);
|
|
wc_Sha3_256_Final(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_256Hash
|
|
\sa wc_Sha3_256_Final
|
|
\sa wc_InitSha3_256
|
|
*/
|
|
int wc_Sha3_256_Update(wc_Sha3* sha, const byte* data, word32 len);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Finalizes hashing of data. Result is placed into hash.
|
|
Resets state of sha3 struct.
|
|
|
|
\return 0 Returned upon successfully finalizing.
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
\param hash Byte array to hold hash value.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitSha3_256(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_256 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_256_Update(sha3, data, len);
|
|
wc_Sha3_256_Final(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_256Hash
|
|
\sa wc_Sha3_256_GetHash
|
|
\sa wc_InitSha3_256
|
|
*/
|
|
int wc_Sha3_256_Final(wc_Sha3* sha3, byte* hash);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Resets the wc_Sha3 structure. Note: this is only supported
|
|
if you have WOLFSSL_TI_HASH defined.
|
|
|
|
\return none No returns.
|
|
|
|
\param sha3 Pointer to the sha3 structure to be freed.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3;
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitSha3_256(&sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_256 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_256_Update(&sha3, data, len);
|
|
wc_Sha3_256_Final(&sha3, hash);
|
|
wc_Sha3_256_Free(&sha3);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_InitSha3_256
|
|
\sa wc_Sha3_256_Update
|
|
\sa wc_Sha3_256_Final
|
|
*/
|
|
void wc_Sha3_256_Free(wc_Sha3*);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Gets hash data. Result is placed into hash. Does not
|
|
reset state of sha3 struct.
|
|
|
|
\return 0 Returned upon successful copying of the hash.
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
\param hash Byte array to hold hash value.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
if ((ret = wc_InitSha3_256(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_256 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_256_Update(sha3, data, len);
|
|
wc_Sha3_256_GetHash(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_256Hash
|
|
\sa wc_Sha3_256_Final
|
|
\sa wc_InitSha3_256
|
|
\sa wc_Sha3_256_Copy
|
|
*/
|
|
int wc_Sha3_256_GetHash(wc_Sha3* sha3, byte* hash);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Copy the state of the hash.
|
|
|
|
\return 0 Returned upon successful copying.
|
|
|
|
\param sha3 pointer to the sha3 structure to copy
|
|
\param dst pointer to the sha3 structure to copy into
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
wc_Sha3 sha3_dup[1];
|
|
if ((ret = wc_InitSha3_256(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_256 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_256_Update(sha3, data, len);
|
|
wc_Sha3_256_Copy(sha3, sha3_dup);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_256Hash
|
|
\sa wc_Sha3_256_Final
|
|
\sa wc_InitSha3_256
|
|
\sa wc_Sha3_256_GetHash
|
|
*/
|
|
int wc_Sha3_256_Copy(wc_Sha3* sha3, wc_Sha3* dst);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief This function initializes SHA3-384. This is automatically
|
|
called by wc_Sha3_384Hash.
|
|
|
|
\return 0 Returned upon successfully initializing
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
if ((ret = wc_InitSha3_384(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_384 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_384_Update(sha3, data, len);
|
|
wc_Sha3_384_Final(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_384Hash
|
|
\sa wc_Sha3_384_Update
|
|
\sa wc_Sha3_384_Final
|
|
*/
|
|
int wc_InitSha3_384(wc_Sha3* sha3, void* heap, int devId);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Can be called to continually hash the provided byte
|
|
array of length len.
|
|
|
|
\return 0 Returned upon successfully adding the data to the digest.
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
\param data the data to be hashed
|
|
\param len length of data to be hashed
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitSha3_384(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_384 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_384_Update(sha3, data, len);
|
|
wc_Sha3_384_Final(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_384Hash
|
|
\sa wc_Sha3_384_Final
|
|
\sa wc_InitSha3_384
|
|
*/
|
|
int wc_Sha3_384_Update(wc_Sha3* sha, const byte* data, word32 len);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Finalizes hashing of data. Result is placed into hash.
|
|
Resets state of sha3 struct.
|
|
|
|
\return 0 Returned upon successfully finalizing.
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
\param hash Byte array to hold hash value.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitSha3_384(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_384 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_384_Update(sha3, data, len);
|
|
wc_Sha3_384_Final(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_384Hash
|
|
\sa wc_Sha3_384_GetHash
|
|
\sa wc_InitSha3_384
|
|
*/
|
|
int wc_Sha3_384_Final(wc_Sha3* sha3, byte* hash);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Resets the wc_Sha3 structure. Note: this is only supported
|
|
if you have WOLFSSL_TI_HASH defined.
|
|
|
|
\return none No returns.
|
|
|
|
\param sha3 Pointer to the sha3 structure to be freed.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3;
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitSha3_384(&sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_384 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_384_Update(&sha3, data, len);
|
|
wc_Sha3_384_Final(&sha3, hash);
|
|
wc_Sha3_384_Free(&sha3);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_InitSha3_384
|
|
\sa wc_Sha3_384_Update
|
|
\sa wc_Sha3_384_Final
|
|
*/
|
|
void wc_Sha3_384_Free(wc_Sha3*);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Gets hash data. Result is placed into hash. Does not
|
|
reset state of sha3 struct.
|
|
|
|
\return 0 Returned upon successful copying of the hash.
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
\param hash Byte array to hold hash value.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
if ((ret = wc_InitSha3_384(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_38384ailed");
|
|
}
|
|
else {
|
|
wc_Sha3_384_Update(sha3, data, len);
|
|
wc_Sha3_384_GetHash(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_384Hash
|
|
\sa wc_Sha3_384_Final
|
|
\sa wc_InitSha3_384
|
|
\sa wc_Sha3_384_Copy
|
|
*/
|
|
int wc_Sha3_384_GetHash(wc_Sha3* sha3, byte* hash);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Copy the state of the hash.
|
|
|
|
\return 0 Returned upon successful copying.
|
|
|
|
\param sha3 pointer to the sha3 structure to copy
|
|
\param dst pointer to the sha3 structure to copy into
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
wc_Sha3 sha3_dup[1];
|
|
if ((ret = wc_InitSha3_384(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_384 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_384_Update(sha3, data, len);
|
|
wc_Sha3_384_Copy(sha3, sha3_dup);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_384Hash
|
|
\sa wc_Sha3_384_Final
|
|
\sa wc_InitSha3_384
|
|
\sa wc_Sha3_384_GetHash
|
|
*/
|
|
int wc_Sha3_384_Copy(wc_Sha3* sha3, wc_Sha3* dst);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief This function initializes SHA3-512. This is automatically
|
|
called by wc_Sha3_512Hash.
|
|
|
|
\return 0 Returned upon successfully initializing
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
if ((ret = wc_InitSha3_512(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_512 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_512_Update(sha3, data, len);
|
|
wc_Sha3_512_Final(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_512Hash
|
|
\sa wc_Sha3_512_Update
|
|
\sa wc_Sha3_512_Final
|
|
*/
|
|
int wc_InitSha3_512(wc_Sha3* sha3, void* heap, int devId);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Can be called to continually hash the provided byte
|
|
array of length len.
|
|
|
|
\return 0 Returned upon successfully adding the data to the digest.
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
\param data the data to be hashed
|
|
\param len length of data to be hashed
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitSha3_512(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_512 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_512_Update(sha3, data, len);
|
|
wc_Sha3_512_Final(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_512Hash
|
|
\sa wc_Sha3_512_Final
|
|
\sa wc_InitSha3_512
|
|
*/
|
|
int wc_Sha3_512_Update(wc_Sha3* sha, const byte* data, word32 len);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Finalizes hashing of data. Result is placed into hash.
|
|
Resets state of sha3 struct.
|
|
|
|
\return 0 Returned upon successfully finalizing.
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
\param hash Byte array to hold hash value.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitSha3_512(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_512 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_512_Update(sha3, data, len);
|
|
wc_Sha3_512_Final(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_512Hash
|
|
\sa wc_Sha3_512_GetHash
|
|
\sa wc_InitSha3_512
|
|
*/
|
|
int wc_Sha3_512_Final(wc_Sha3* sha3, byte* hash);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Resets the wc_Sha3 structure. Note: this is only supported
|
|
if you have WOLFSSL_TI_HASH defined.
|
|
|
|
\return none No returns.
|
|
|
|
\param sha3 Pointer to the sha3 structure to be freed.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3;
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitSha3_512(&sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_512 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_512_Update(&sha3, data, len);
|
|
wc_Sha3_512_Final(&sha3, hash);
|
|
wc_Sha3_512_Free(&sha3);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_InitSha3_512
|
|
\sa wc_Sha3_512_Update
|
|
\sa wc_Sha3_512_Final
|
|
*/
|
|
void wc_Sha3_512_Free(wc_Sha3*);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Gets hash data. Result is placed into hash. Does not
|
|
reset state of sha3 struct.
|
|
|
|
\return 0 Returned upon successful copying of the hash.
|
|
|
|
\param sha3 pointer to the sha3 structure to use for encryption
|
|
\param hash Byte array to hold hash value.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
if ((ret = wc_InitSha3_512(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_512 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_512_Update(sha3, data, len);
|
|
wc_Sha3_512_GetHash(sha3, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_512Hash
|
|
\sa wc_Sha3_512_Final
|
|
\sa wc_InitSha3_512
|
|
\sa wc_Sha3_512_Copy
|
|
*/
|
|
int wc_Sha3_512_GetHash(wc_Sha3* sha3, byte* hash);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Copy the state of the hash.
|
|
|
|
\return 0 Returned upon successful copying.
|
|
|
|
\param sha3 pointer to the sha3 structure to copy
|
|
\param dst pointer to the sha3 structure to copy into
|
|
|
|
_Example_
|
|
\code
|
|
wc_Sha3 sha3[1];
|
|
wc_Sha3 sha3_dup[1];
|
|
if ((ret = wc_InitSha3_512(sha3, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitSha3_512 failed");
|
|
}
|
|
else {
|
|
wc_Sha3_512_Update(sha3, data, len);
|
|
wc_Sha3_512_Copy(sha3, sha3_dup);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Sha3_512Hash
|
|
\sa wc_Sha3_512_Final
|
|
\sa wc_InitSha3_512
|
|
\sa wc_Sha3_512_GetHash
|
|
*/
|
|
int wc_Sha3_512_Copy(wc_Sha3* sha3, wc_Sha3* dst);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief This function initializes SHAKE-128. This is automatically
|
|
called by wc_Shake128Hash.
|
|
|
|
\return 0 Returned upon successfully initializing
|
|
|
|
\param shake pointer to the shake structure to use for encryption
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake128 failed");
|
|
}
|
|
else {
|
|
wc_Shake128_Update(shake, data, len);
|
|
wc_Shake128_Final(shake, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake128Hash
|
|
\sa wc_Shake128_Update
|
|
\sa wc_Shake128_Final
|
|
*/
|
|
int wc_InitShake128(wc_Shake* shake, void* heap, int devId);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Can be called to continually hash the provided byte
|
|
array of length len.
|
|
|
|
\return 0 Returned upon successfully adding the data to the digest.
|
|
|
|
\param shake pointer to the shake structure to use for encryption
|
|
\param data the data to be hashed
|
|
\param len length of data to be hashed
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake128 failed");
|
|
}
|
|
else {
|
|
wc_Shake128_Update(shake, data, len);
|
|
wc_Shake128_Final(shake, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake128Hash
|
|
\sa wc_Shake128_Final
|
|
\sa wc_InitShake128
|
|
*/
|
|
int wc_Shake128_Update(wc_Shake* sha, const byte* data, word32 len);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Finalizes hashing of data. Result is placed into hash.
|
|
Resets state of shake struct.
|
|
|
|
\return 0 Returned upon successfully finalizing.
|
|
|
|
\param shake pointer to the shake structure to use for encryption
|
|
\param hash Byte array to hold hash value.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake128 failed");
|
|
}
|
|
else {
|
|
wc_Shake128_Update(shake, data, len);
|
|
wc_Shake128_Final(shake, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake128Hash
|
|
\sa wc_Shake128_GetHash
|
|
\sa wc_InitShake128
|
|
*/
|
|
int wc_Shake128_Final(wc_Shake* shake, byte* hash);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Called to absorb the provided byte array of length len. Cannot
|
|
be called incrementally.
|
|
|
|
\return 0 Returned upon successfully absorbed the data.
|
|
|
|
\param shake pointer to the shake structure to use for encryption
|
|
\param data the data to be absorbed
|
|
\param len length of data to be absorbed
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
byte out[2 * WC_SHA3_128_BLOCK_SIZE];
|
|
int blocks = 2;
|
|
|
|
if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake128 failed");
|
|
}
|
|
else {
|
|
wc_Shake128_Absorb(shake, data, len);
|
|
wc_Shake128_SqueezeBlocks(shake, out, blocks);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake128_SqueezeBlocks
|
|
\sa wc_InitShake128
|
|
*/
|
|
int wc_Shake128_Absorb(wc_Shake* sha, const byte* data, word32 len);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Squeeze out more blocks of data. Result is placed into out. Can be
|
|
called inrementally.
|
|
|
|
\return 0 Returned upon successfully squeezing.
|
|
|
|
\param shake pointer to the shake structure to use for encryption
|
|
\param hash Byte array to hold output.
|
|
\param blocks Number of blocks to squeeze out. Each block is
|
|
WC_SHA3_128_BLOCK_SIZE bytes in length.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
byte out[2 * WC_SHA3_128_BLOCK_SIZE];
|
|
int blocks = 2;
|
|
|
|
if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake128 failed");
|
|
}
|
|
else {
|
|
wc_Shake128_Absorb(shake, data, len);
|
|
wc_Shake128_SqueezeBlocks(shake, out, blocks);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake128_Absorb
|
|
\sa wc_InitShake128
|
|
*/
|
|
int wc_Shake128_SqueezeBlocks(wc_Shake* shake, byte* out, word32 blockCnt);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Resets the wc_Shake structure. Note: this is only supported
|
|
if you have WOLFSSL_TI_HASH defined.
|
|
|
|
\return none No returns.
|
|
|
|
\param shake Pointer to the shake structure to be freed.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake;
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitShake128(&shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake128 failed");
|
|
}
|
|
else {
|
|
wc_Shake128_Update(&shake, data, len);
|
|
wc_Shake128_Final(&shake, hash);
|
|
wc_Shake128_Free(&shake);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_InitShake128
|
|
\sa wc_Shake128_Update
|
|
\sa wc_Shake128_Final
|
|
*/
|
|
void wc_Shake128_Free(wc_Shake*);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Gets hash data. Result is placed into hash. Does not
|
|
reset state of shake struct.
|
|
|
|
\return 0 Returned upon successful copying of the hash.
|
|
|
|
\param shake pointer to the shake structure to use for encryption
|
|
\param hash Byte array to hold hash value.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake128 failed");
|
|
}
|
|
else {
|
|
wc_Shake128_Update(shake, data, len);
|
|
wc_Shake128_GetHash(shake, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake128Hash
|
|
\sa wc_Shake128_Final
|
|
\sa wc_InitShake128
|
|
\sa wc_Shake128_Copy
|
|
*/
|
|
int wc_Shake128_GetHash(wc_Shake* shake, byte* hash);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Copy the state of the hash.
|
|
|
|
\return 0 Returned upon successful copying.
|
|
|
|
\param shake pointer to the shake structure to copy
|
|
\param dst pointer to the shake structure to copy into
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
wc_Shake shake_dup[1];
|
|
if ((ret = wc_InitShake128(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake128 failed");
|
|
}
|
|
else {
|
|
wc_Shake128_Update(shake, data, len);
|
|
wc_Shake128_Copy(shake, shake_dup);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake128Hash
|
|
\sa wc_Shake128_Final
|
|
\sa wc_InitShake128
|
|
\sa wc_Shake128_GetHash
|
|
*/
|
|
int wc_Shake128_Copy(wc_Shake* shake, wc_Shake* dst);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief This function initializes SHAKE-256. This is automatically
|
|
called by wc_Shake256Hash.
|
|
|
|
\return 0 Returned upon successfully initializing
|
|
|
|
\param shake pointer to the shake structure to use for encryption
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake256 failed");
|
|
}
|
|
else {
|
|
wc_Shake256_Update(shake, data, len);
|
|
wc_Shake256_Final(shake, hash, sizeof(hash));
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake256Hash
|
|
\sa wc_Shake256_Update
|
|
\sa wc_Shake256_Final
|
|
*/
|
|
int wc_InitShake256(wc_Shake* shake, void* heap, int devId);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Can be called to continually hash the provided byte
|
|
array of length len.
|
|
|
|
\return 0 Returned upon successfully adding the data to the digest.
|
|
|
|
\param shake pointer to the shake structure to use for encryption
|
|
\param data the data to be hashed
|
|
\param len length of data to be hashed
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake256 failed");
|
|
}
|
|
else {
|
|
wc_Shake256_Update(shake, data, len);
|
|
wc_Shake256_Final(shake, hash, sizeof(hash));
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake256Hash
|
|
\sa wc_Shake256_Final
|
|
\sa wc_InitShake256
|
|
*/
|
|
int wc_Shake256_Update(wc_Shake* sha, const byte* data, word32 len);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Finalizes hashing of data. Result is placed into hash.
|
|
Resets state of shake struct.
|
|
|
|
\return 0 Returned upon successfully finalizing.
|
|
|
|
\param shake pointer to the shake structure to use for encryption
|
|
\param hash Byte array to hold hash value.
|
|
\param hashLen Size of hash in bytes.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake256 failed");
|
|
}
|
|
else {
|
|
wc_Shake256_Update(shake, data, len);
|
|
wc_Shake256_Final(shake, hash, sizeof(hash));
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake256Hash
|
|
\sa wc_Shake256_GetHash
|
|
\sa wc_InitShake256
|
|
*/
|
|
int wc_Shake256_Final(wc_Shake* shake, byte* hash, word32 hashLen);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Called to absorb the provided byte array of length len. Cannot
|
|
be called incrementally.
|
|
|
|
\return 0 Returned upon successfully absorbed the data.
|
|
|
|
\param shake pointer to the shake structure to use for encryption
|
|
\param data the data to be absorbed
|
|
\param len length of data to be absorbed
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
byte out[2 * WC_SHA3_256_BLOCK_SIZE];
|
|
int blocks = 2;
|
|
|
|
if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake256 failed");
|
|
}
|
|
else {
|
|
wc_Shake256_Absorb(shake, data, len);
|
|
wc_Shake256_SqueezeBlocks(shake, out, blocks);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake256_SqueezeBlocks
|
|
\sa wc_InitShake256
|
|
*/
|
|
int wc_Shake256_Absorb(wc_Shake* sha, const byte* data, word32 len);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Squeeze out more blocks of data. Result is placed into out. Can be
|
|
called incrementally.
|
|
|
|
\return 0 Returned upon successfully squeezing.
|
|
|
|
\param shake pointer to the shake structure to use for encryption
|
|
\param hash Byte array to hold output.
|
|
\param blocks Number of blocks to squeeze out. Each block is
|
|
WC_SHA3_256_BLOCK_SIZE bytes in length.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
byte out[2 * WC_SHA3_256_BLOCK_SIZE];
|
|
int blocks = 2;
|
|
|
|
if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake256 failed");
|
|
}
|
|
else {
|
|
wc_Shake256_Absorb(shake, data, len);
|
|
wc_Shake256_SqueezeBlocks(shake, out, blocks);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake256_Absorb
|
|
\sa wc_InitShake256
|
|
*/
|
|
int wc_Shake256_SqueezeBlocks(wc_Shake* shake, byte* out, word32 blockCnt);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Resets the wc_Shake structure. Note: this is only supported
|
|
if you have WOLFSSL_TI_HASH defined.
|
|
|
|
\return none No returns.
|
|
|
|
\param shake Pointer to the shake structure to be freed.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake;
|
|
byte data[] = { Data to be hashed };
|
|
word32 len = sizeof(data);
|
|
|
|
if ((ret = wc_InitShake256(&shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake256 failed");
|
|
}
|
|
else {
|
|
wc_Shake256_Update(&shake, data, len);
|
|
wc_Shake256_Final(&shake, hash, sizeof(hash));
|
|
wc_Shake256_Free(&shake);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_InitShake256
|
|
\sa wc_Shake256_Update
|
|
\sa wc_Shake256_Final
|
|
*/
|
|
void wc_Shake256_Free(wc_Shake*);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Gets hash data. Result is placed into hash. Does not
|
|
reset state of shake struct.
|
|
|
|
\return 0 Returned upon successful copying of the hash.
|
|
|
|
\param shake pointer to the shake structure to use for encryption
|
|
\param hash Byte array to hold hash value.
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake256 failed");
|
|
}
|
|
else {
|
|
wc_Shake256_Update(shake, data, len);
|
|
wc_Shake256_GetHash(shake, hash);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake256Hash
|
|
\sa wc_Shake256_Final
|
|
\sa wc_InitShake256
|
|
\sa wc_Shake256_Copy
|
|
*/
|
|
int wc_Shake256_GetHash(wc_Shake* shake, byte* hash);
|
|
|
|
/*!
|
|
\ingroup SHA
|
|
|
|
\brief Copy the state of the hash.
|
|
|
|
\return 0 Returned upon successful copying.
|
|
|
|
\param shake pointer to the shake structure to copy
|
|
\param dst pointer to the shake structure to copy into
|
|
|
|
_Example_
|
|
\code
|
|
wc_Shake shake[1];
|
|
wc_Shake shake_dup[1];
|
|
if ((ret = wc_InitShake256(shake, NULL, INVALID_DEVID)) != 0) {
|
|
WOLFSSL_MSG("wc_InitShake256 failed");
|
|
}
|
|
else {
|
|
wc_Shake256_Update(shake, data, len);
|
|
wc_Shake256_Copy(shake, shake_dup);
|
|
}
|
|
\endcode
|
|
|
|
\sa wc_Shake256Hash
|
|
\sa wc_Shake256_Final
|
|
\sa wc_InitShake256
|
|
\sa wc_Shake256_GetHash
|
|
*/
|
|
int wc_Shake256_Copy(wc_Shake* shake, wc_Shake* dst);
|
|
|
|
|