espressif/ESP8266_RTOS_SDK
1
0
Fork 0
mirror of https://github.com/espressif/ESP8266_RTOS_SDK.git synced 2025-10-23 01:47:33 +08:00
Code Issues Projects Releases Wiki Activity
Files
d244c20dece3770f8511cdb85ebb6471f8fa8250
ESP8266_RTOS_SDK/components/util/src/sha.c

600 lines
18 KiB
C
Raw Blame History

// Copyright 2018 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <stdio.h>
#include <string.h>
#include "util_assert.h"
#include <sys/errno.h>
#include "esp_sha.h"
#include "esp_log.h"
#define UL64(x) x##ULL
#define F0(x, y, z) ((x & y) | (z & (x | y)))
#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define SHR(x, n) ((x & 0xFFFFFFFF) >> n)
#define ROTR(x, n) (SHR(x,n) | (x << (32 - n)))
#define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^ SHR(x, 3))
#define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^ SHR(x,10))
#define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
#define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
#define TAG "SHA"
static const uint32_t sha_padding[] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
const uint32_t __g_esp_sha1_state_ctx[] = {
0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0
};
const uint32_t __g_esp_sha224_state_ctx[] = {
0xC1059ED8, 0x367CD507, 0x3070DD17, 0xF70E5939,
0xFFC00B31, 0x68581511, 0x64F98FA7, 0xBEFA4FA4
};
const uint32_t __g_esp_sha256_state_ctx[] = {
0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
};
const uint64_t __g_esp_sha384_state_ctx[] = {
0xCBBB9D5DC1059ED8, 0x629A292A367CD507, 0x9159015A3070DD17,
0x152FECD8F70E5939, 0x67332667FFC00B31, 0x8EB44A8768581511,
0xDB0C2E0D64F98FA7, 0x47B5481DBEFA4FA4
};
const uint64_t __g_esp_sha512_state_ctx[] = {
0x6A09E667F3BCC908, 0xBB67AE8584CAA73B, 0x3C6EF372FE94F82B,
0xA54FF53A5F1D36F1, 0x510E527FADE682D1, 0x9B05688C2B3E6C1F,
0x1F83D9ABFB41BD6B, 0x5BE0CD19137E2179
};
static void esp_sha_put_be(void *dest, const void *src, size_t size, size_t steps)
{
uint8_t *d_buf = (uint8_t *)dest;
const uint8_t *s_buf = (const uint8_t *)src;
for (int i = 0; i < size; i += steps) {
for (int j = 0; j < steps; j++) {
d_buf[i + j] = s_buf[i + (steps - j - 1)];
}
}
}
int __esp_sha1_process(void *in_ctx, const void *src)
{
const uint8_t *data = (const uint8_t *)src;
esp_sha_t *ctx = (esp_sha_t *)in_ctx;
uint32_t temp, W[16], A[5];
esp_sha_put_be(W, data, 64, sizeof(uint32_t));
#undef S
#undef R
#undef P
#undef F
#undef K
#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
#define R(t) \
( \
temp = W[( t - 3 ) & 0x0F] ^ W[( t - 8 ) & 0x0F] ^ \
W[( t - 14 ) & 0x0F] ^ W[ t & 0x0F], \
( W[t & 0x0F] = S(temp,1) ) \
)
#define P(a,b,c,d,e,x) \
{ \
e += S(a,5) + F(b,c,d) + K + x; b = S(b,30); \
}
for (int i = 0; i < 5; i++)
A[i] = ctx->state[i];
#define F(x,y,z) (z ^ (x & (y ^ z)))
#define K 0x5A827999
P( A[0], A[1], A[2], A[3], A[4], W[0] );
P( A[4], A[0], A[1], A[2], A[3], W[1] );
P( A[3], A[4], A[0], A[1], A[2], W[2] );
P( A[2], A[3], A[4], A[0], A[1], W[3] );
P( A[1], A[2], A[3], A[4], A[0], W[4] );
P( A[0], A[1], A[2], A[3], A[4], W[5] );
P( A[4], A[0], A[1], A[2], A[3], W[6] );
P( A[3], A[4], A[0], A[1], A[2], W[7] );
P( A[2], A[3], A[4], A[0], A[1], W[8] );
P( A[1], A[2], A[3], A[4], A[0], W[9] );
P( A[0], A[1], A[2], A[3], A[4], W[10] );
P( A[4], A[0], A[1], A[2], A[3], W[11] );
P( A[3], A[4], A[0], A[1], A[2], W[12] );
P( A[2], A[3], A[4], A[0], A[1], W[13] );
P( A[1], A[2], A[3], A[4], A[0], W[14] );
P( A[0], A[1], A[2], A[3], A[4], W[15] );
P( A[4], A[0], A[1], A[2], A[3], R(16) );
P( A[3], A[4], A[0], A[1], A[2], R(17) );
P( A[2], A[3], A[4], A[0], A[1], R(18) );
P( A[1], A[2], A[3], A[4], A[0], R(19) );
#undef K
#undef F
#define F(x,y,z) (x ^ y ^ z)
#define K 0x6ED9EBA1
P( A[0], A[1], A[2], A[3], A[4], R(20) );
P( A[4], A[0], A[1], A[2], A[3], R(21) );
P( A[3], A[4], A[0], A[1], A[2], R(22) );
P( A[2], A[3], A[4], A[0], A[1], R(23) );
P( A[1], A[2], A[3], A[4], A[0], R(24) );
P( A[0], A[1], A[2], A[3], A[4], R(25) );
P( A[4], A[0], A[1], A[2], A[3], R(26) );
P( A[3], A[4], A[0], A[1], A[2], R(27) );
P( A[2], A[3], A[4], A[0], A[1], R(28) );
P( A[1], A[2], A[3], A[4], A[0], R(29) );
P( A[0], A[1], A[2], A[3], A[4], R(30) );
P( A[4], A[0], A[1], A[2], A[3], R(31) );
P( A[3], A[4], A[0], A[1], A[2], R(32) );
P( A[2], A[3], A[4], A[0], A[1], R(33) );
P( A[1], A[2], A[3], A[4], A[0], R(34) );
P( A[0], A[1], A[2], A[3], A[4], R(35) );
P( A[4], A[0], A[1], A[2], A[3], R(36) );
P( A[3], A[4], A[0], A[1], A[2], R(37) );
P( A[2], A[3], A[4], A[0], A[1], R(38) );
P( A[1], A[2], A[3], A[4], A[0], R(39) );
#undef K
#undef F
#define F(x,y,z) ((x & y) | (z & (x | y)))
#define K 0x8F1BBCDC
P( A[0], A[1], A[2], A[3], A[4], R(40) );
P( A[4], A[0], A[1], A[2], A[3], R(41) );
P( A[3], A[4], A[0], A[1], A[2], R(42) );
P( A[2], A[3], A[4], A[0], A[1], R(43) );
P( A[1], A[2], A[3], A[4], A[0], R(44) );
P( A[0], A[1], A[2], A[3], A[4], R(45) );
P( A[4], A[0], A[1], A[2], A[3], R(46) );
P( A[3], A[4], A[0], A[1], A[2], R(47) );
P( A[2], A[3], A[4], A[0], A[1], R(48) );
P( A[1], A[2], A[3], A[4], A[0], R(49) );
P( A[0], A[1], A[2], A[3], A[4], R(50) );
P( A[4], A[0], A[1], A[2], A[3], R(51) );
P( A[3], A[4], A[0], A[1], A[2], R(52) );
P( A[2], A[3], A[4], A[0], A[1], R(53) );
P( A[1], A[2], A[3], A[4], A[0], R(54) );
P( A[0], A[1], A[2], A[3], A[4], R(55) );
P( A[4], A[0], A[1], A[2], A[3], R(56) );
P( A[3], A[4], A[0], A[1], A[2], R(57) );
P( A[2], A[3], A[4], A[0], A[1], R(58) );
P( A[1], A[2], A[3], A[4], A[0], R(59) );
#undef K
#undef F
#define F(x,y,z) (x ^ y ^ z)
#define K 0xCA62C1D6
P( A[0], A[1], A[2], A[3], A[4], R(60) );
P( A[4], A[0], A[1], A[2], A[3], R(61) );
P( A[3], A[4], A[0], A[1], A[2], R(62) );
P( A[2], A[3], A[4], A[0], A[1], R(63) );
P( A[1], A[2], A[3], A[4], A[0], R(64) );
P( A[0], A[1], A[2], A[3], A[4], R(65) );
P( A[4], A[0], A[1], A[2], A[3], R(66) );
P( A[3], A[4], A[0], A[1], A[2], R(67) );
P( A[2], A[3], A[4], A[0], A[1], R(68) );
P( A[1], A[2], A[3], A[4], A[0], R(69) );
P( A[0], A[1], A[2], A[3], A[4], R(70) );
P( A[4], A[0], A[1], A[2], A[3], R(71) );
P( A[3], A[4], A[0], A[1], A[2], R(72) );
P( A[2], A[3], A[4], A[0], A[1], R(73) );
P( A[1], A[2], A[3], A[4], A[0], R(74) );
P( A[0], A[1], A[2], A[3], A[4], R(75) );
P( A[4], A[0], A[1], A[2], A[3], R(76) );
P( A[3], A[4], A[0], A[1], A[2], R(77) );
P( A[2], A[3], A[4], A[0], A[1], R(78) );
P( A[1], A[2], A[3], A[4], A[0], R(79) );
#undef K
#undef F
#undef R
#undef P
for (int i = 0; i < 5; i++)
ctx->state[i] += A[i];
return 0;
}
int __esp_sha256_process(void *in_ctx, const void *src)
{
const uint8_t *data = (const uint8_t *)src;
esp_sha_t *ctx = (esp_sha_t *)in_ctx;
uint32_t temp1, temp2, W[64];
uint32_t A[8];
#undef R
#undef P
#define R(t) \
( \
W[t] = S1(W[t - 2]) + W[t - 7] + \
S0(W[t - 15]) + W[t - 16] \
)
#define P(a, b, c, d, e, f, g, h, x, K) \
{ \
temp1 = h + S3(e) + F1(e,f,g) + K + x; \
temp2 = S2(a) + F0(a,b,c); \
d += temp1; h = temp1 + temp2; \
}
static const uint32_t K[] = {
0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2,
};
for (int i = 0; i < 8; i++)
A[i] = ctx->state[i];
for (int i = 0; i < 64; i++) {
if (i < 16)
esp_sha_put_be(&W[i], data + 4 * i, 4, sizeof(uint32_t));
else
R(i);
P(A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i], K[i]);
temp1 = A[7];
A[7] = A[6];
A[6] = A[5];
A[5] = A[4];
A[4] = A[3];
A[3] = A[2];
A[2] = A[1];
A[1] = A[0];
A[0] = temp1;
}
for (int i = 0; i < 8; i++)
ctx->state[i] += A[i];
return 0;
#undef R
#undef P
}
int __esp_sha512_process(void *in_ctx, const void *src)
{
int i;
uint64_t temp1, temp2, W[80];
uint64_t A[8];
const uint8_t *data = (const uint8_t *)src;
esp_sha512_t *ctx = (esp_sha512_t *)in_ctx;
static const uint64_t K[80] =
{
UL64(0x428A2F98D728AE22), UL64(0x7137449123EF65CD),
UL64(0xB5C0FBCFEC4D3B2F), UL64(0xE9B5DBA58189DBBC),
UL64(0x3956C25BF348B538), UL64(0x59F111F1B605D019),
UL64(0x923F82A4AF194F9B), UL64(0xAB1C5ED5DA6D8118),
UL64(0xD807AA98A3030242), UL64(0x12835B0145706FBE),
UL64(0x243185BE4EE4B28C), UL64(0x550C7DC3D5FFB4E2),
UL64(0x72BE5D74F27B896F), UL64(0x80DEB1FE3B1696B1),
UL64(0x9BDC06A725C71235), UL64(0xC19BF174CF692694),
UL64(0xE49B69C19EF14AD2), UL64(0xEFBE4786384F25E3),
UL64(0x0FC19DC68B8CD5B5), UL64(0x240CA1CC77AC9C65),
UL64(0x2DE92C6F592B0275), UL64(0x4A7484AA6EA6E483),
UL64(0x5CB0A9DCBD41FBD4), UL64(0x76F988DA831153B5),
UL64(0x983E5152EE66DFAB), UL64(0xA831C66D2DB43210),
UL64(0xB00327C898FB213F), UL64(0xBF597FC7BEEF0EE4),
UL64(0xC6E00BF33DA88FC2), UL64(0xD5A79147930AA725),
UL64(0x06CA6351E003826F), UL64(0x142929670A0E6E70),
UL64(0x27B70A8546D22FFC), UL64(0x2E1B21385C26C926),
UL64(0x4D2C6DFC5AC42AED), UL64(0x53380D139D95B3DF),
UL64(0x650A73548BAF63DE), UL64(0x766A0ABB3C77B2A8),
UL64(0x81C2C92E47EDAEE6), UL64(0x92722C851482353B),
UL64(0xA2BFE8A14CF10364), UL64(0xA81A664BBC423001),
UL64(0xC24B8B70D0F89791), UL64(0xC76C51A30654BE30),
UL64(0xD192E819D6EF5218), UL64(0xD69906245565A910),
UL64(0xF40E35855771202A), UL64(0x106AA07032BBD1B8),
UL64(0x19A4C116B8D2D0C8), UL64(0x1E376C085141AB53),
UL64(0x2748774CDF8EEB99), UL64(0x34B0BCB5E19B48A8),
UL64(0x391C0CB3C5C95A63), UL64(0x4ED8AA4AE3418ACB),
UL64(0x5B9CCA4F7763E373), UL64(0x682E6FF3D6B2B8A3),
UL64(0x748F82EE5DEFB2FC), UL64(0x78A5636F43172F60),
UL64(0x84C87814A1F0AB72), UL64(0x8CC702081A6439EC),
UL64(0x90BEFFFA23631E28), UL64(0xA4506CEBDE82BDE9),
UL64(0xBEF9A3F7B2C67915), UL64(0xC67178F2E372532B),
UL64(0xCA273ECEEA26619C), UL64(0xD186B8C721C0C207),
UL64(0xEADA7DD6CDE0EB1E), UL64(0xF57D4F7FEE6ED178),
UL64(0x06F067AA72176FBA), UL64(0x0A637DC5A2C898A6),
UL64(0x113F9804BEF90DAE), UL64(0x1B710B35131C471B),
UL64(0x28DB77F523047D84), UL64(0x32CAAB7B40C72493),
UL64(0x3C9EBE0A15C9BEBC), UL64(0x431D67C49C100D4C),
UL64(0x4CC5D4BECB3E42B6), UL64(0x597F299CFC657E2A),
UL64(0x5FCB6FAB3AD6FAEC), UL64(0x6C44198C4A475817)
};
#undef SHR
#undef ROTR
#undef S0
#undef S1
#undef S2
#undef S3
#undef F0
#undef F1
#undef P
#define SHR(x,n) (x >> n)
#define ROTR(x,n) (SHR(x,n) | (x << (64 - n)))
#define S0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x, 7))
#define S1(x) (ROTR(x,19) ^ ROTR(x,61) ^ SHR(x, 6))
#define S2(x) (ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
#define S3(x) (ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
#define F0(x,y,z) ((x & y) | (z & (x | y)))
#define F1(x,y,z) (z ^ (x & (y ^ z)))
#define P(a,b,c,d,e,f,g,h,x,K) \
{ \
temp1 = h + S3(e) + F1(e,f,g) + K + x; \
temp2 = S2(a) + F0(a,b,c); \
d += temp1; h = temp1 + temp2; \
}
for (i = 0; i < 16; i++) {
esp_sha_put_be(&W[i], data + (i << 3), sizeof(uint64_t), sizeof(uint64_t));
}
for (; i < 80; i++) {
W[i] = S1(W[i - 2]) + W[i - 7] +
S0(W[i - 15]) + W[i - 16];
}
for (int j = 0; j < 8; j++)
A[j] = ctx->state[j];
i = 0;
do {
P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i], K[i] ); i++;
P( A[7], A[0], A[1], A[2], A[3], A[4], A[5], A[6], W[i], K[i] ); i++;
P( A[6], A[7], A[0], A[1], A[2], A[3], A[4], A[5], W[i], K[i] ); i++;
P( A[5], A[6], A[7], A[0], A[1], A[2], A[3], A[4], W[i], K[i] ); i++;
P( A[4], A[5], A[6], A[7], A[0], A[1], A[2], A[3], W[i], K[i] ); i++;
P( A[3], A[4], A[5], A[6], A[7], A[0], A[1], A[2], W[i], K[i] ); i++;
P( A[2], A[3], A[4], A[5], A[6], A[7], A[0], A[1], W[i], K[i] ); i++;
P( A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[0], W[i], K[i] ); i++;
} while (i < 80);
for (int j = 0; j < 8; j++)
ctx->state[j] += A[j];
return 0;
#undef SHR
#undef ROTR
#undef S0
#undef S1
#undef S2
#undef S3
#undef F0
#undef F1
#undef P
}
/**
* @brief initialize the SHA1/SHA224/SHA256 contex
*/
int __esp_sha_init(esp_sha_t *ctx, esp_sha_type_t type, const uint32_t *state_ctx, size_t size, sha_cal_t sha_cal)
{
util_assert(ctx);
ctx->total[0] = 0;
ctx->total[1] = 0;
for (int i = 0; i < size; i ++)
ctx->state[i] = state_ctx[i];
ctx->type = type;
ctx->sha_cal = sha_cal;
return 0;
}
/**
* @brief initialize the SHA512 contex
*/
int __esp_sha512_init(esp_sha512_t *ctx, esp_sha_type_t type, const uint64_t *state_ctx, size_t size)
{
util_assert(ctx);
ctx->total[0] = 0;
ctx->total[1] = 0;
for (int i = 0; i < size; i ++)
ctx->state[i] = state_ctx[i];
ctx->type = type;
ctx->sha_cal = __esp_sha512_process;
return 0;
}
/**
* @brief input data which is calculated for SHA
*/
int __esp_sha_update(esp_sha_t *ctx, const void *src, size_t size)
{
int ret;
size_t fill;
uint32_t left;
uint32_t step;
sha_cal_t sha_cal;
size_t ilen = size;
const uint8_t *input = (const uint8_t *)src;
util_assert(ctx);
util_assert(src);
if (ilen == 0)
return 0;
if (SHA1 == ctx->type || SHA224 == ctx->type || SHA256 == ctx->type) {
left = ctx->total[0] & 0x3F;
ctx->total[0] += (uint32_t)ilen;
if (ctx->total[0] < (uint32_t)ilen)
ctx->total[1]++;
sha_cal = ctx->sha_cal;
step = 64;
} else {
esp_sha512_t *ctx512 = (esp_sha512_t *)ctx;
left = (uint32_t)(ctx512->total[0] & 0x7F);
ctx512->total[0] += ilen;
if (ctx512->total[0] < ilen)
ctx512->total[1]++;
sha_cal = ctx512->sha_cal;
step = 128;
}
fill = step - left;
if (left && ilen >= fill) {
memcpy(ctx->buffer + left, input, fill);
if ((ret = sha_cal(ctx, ctx->buffer)) != 0)
return ret;
input += fill;
ilen -= fill;
left = 0;
}
while (ilen >= step) {
ret = sha_cal(ctx, input);
if (ret)
return ret;
input += step;
ilen -= step;
}
if (ilen > 0)
memcpy(ctx->buffer + left, input, ilen);
return 0;
}
/**
* @brief input data which is calculated for SHA
*/
int __esp_sha_finish(esp_sha_t *ctx, void *dest)
{
int ret;
size_t bytes = 0;
uint32_t last, padn;
uint64_t high, low;
uint8_t *output = dest;
size_t step;
void *state;
uint8_t msglen[16];
util_assert(ctx);
util_assert(dest);
if (SHA1 == ctx->type)
bytes = 20;
else if (SHA224 == ctx->type)
bytes = 28;
else if (SHA256 == ctx->type)
bytes = 32;
else if (SHA384 == ctx->type)
bytes = 48;
else if (SHA512 == ctx->type)
bytes = 64;
if (SHA1 == ctx->type || SHA224 == ctx->type || SHA256 == ctx->type) {
high = (ctx->total[0] >> 29)
| (ctx->total[1] << 3);
low = (ctx->total[0] << 3);
last = ctx->total[0] & 0x3F;
padn = (last < 56) ? (56 - last) : (120 - last);
step = 4;
state = ctx->state;
} else {
esp_sha512_t *ctx512 = (esp_sha512_t *)ctx;
high = (ctx512->total[0] >> 61)
| (ctx512->total[1] << 3);
low = (ctx512->total[0] << 3);
last = (size_t)(ctx512->total[0] & 0x7F);
padn = (last < 112) ? (112 - last) : (240 - last);
step = 8;
state = ctx512->state;
}
esp_sha_put_be(msglen, &high, step, step);
esp_sha_put_be(msglen + step, &low, step, step);
ret = __esp_sha_update(ctx, sha_padding, padn);
if (ret)
return ret;
ret = __esp_sha_update(ctx, msglen, step * 2);
if (ret)
return ret;
esp_sha_put_be(output, state, bytes, step);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink