espressif/ESP8266_RTOS_SDK
1
0
Fork 0
mirror of https://github.com/espressif/ESP8266_RTOS_SDK.git synced 2025-05-22 09:37:00 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat(mbedtls): remove util algorithm and add them to esp8266 rom and mbedtls

Browse Source
This commit is contained in:
yuanjm
2020-03-02 14:46:45 +08:00
parent c4f549dbc1
commit 514bca61f4
60 changed files with 2192 additions and 2230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
components/app_update/CMakeLists.txt
View File

@ -1,7 +1,6 @@
idf_component_register(SRCS "esp_ota_ops.c"
INCLUDE_DIRS "include"
REQUIRES spi_flash partition_table bootloader_support
PRIV_REQUIRES util)
REQUIRES spi_flash partition_table bootloader_support)
# esp_app_desc structure is added as an undefined symbol because otherwise the
# linker will ignore this structure as it has no other files depending on it.

2
components/app_update/esp_ota_ops.c
View File

@ -31,7 +31,7 @@
#include "esp_ota_ops.h"
#include "sys/queue.h"
#include "crc.h"
#include "rom/crc.h"
#include "esp_log.h"
#ifdef CONFIG_IDF_TARGET_ESP8266

4
components/bootloader/subproject/Makefile
View File

@ -8,14 +8,14 @@ endif
PROJECT_NAME := bootloader
COMPONENTS := esptool_py main bootloader_support spi_flash log esp8266 util
COMPONENTS := esptool_py main bootloader_support spi_flash log $(IDF_TARGET)
# Clear C and CXX from top level project
CFLAGS =
CXXFLAGS =
#We cannot include the esp8266 component directly but we need its includes.
CFLAGS += -I $(IDF_PATH)/components/esp8266/include -I $(IDF_PATH)/components/util/include
CFLAGS += -I $(IDF_PATH)/components/$(IDF_TARGET)/include -I $(IDF_PATH)/components/mbedtls/port/include/$(IDF_TARGET)
CFLAGS += -I $(IDF_PATH)/components/esp_common/include
# The bootloader pseudo-component is also included in this build, for its Kconfig.projbuild to be included.

4
components/bootloader_support/CMakeLists.txt
View File

@ -3,12 +3,12 @@ set(COMPONENT_SRCDIRS "src")
if(${BOOTLOADER_BUILD})
set(COMPONENT_ADD_INCLUDEDIRS "include include_priv")
set(COMPONENT_REQUIRES)
set(COMPONENT_PRIV_REQUIRES spi_flash util)
set(COMPONENT_PRIV_REQUIRES spi_flash)
else()
set(COMPONENT_ADD_INCLUDEDIRS "include")
set(COMPONENT_PRIV_INCLUDEDIRS "include_priv")
set(COMPONENT_REQUIRES)
set(COMPONENT_PRIV_REQUIRES spi_flash util mbedtls)
set(COMPONENT_PRIV_REQUIRES spi_flash mbedtls)
endif()
register_component()

2
components/bootloader_support/src/bootloader_common.c
View File

@ -169,7 +169,7 @@ bool bootloader_common_erase_part_type_data(const char *list_erase, bool ota_dat
#include "esp_err.h"
#include "esp_log.h"
#include "crc.h"
#include "rom/crc.h"
#include "rom/gpio.h"

4
components/esp-wolfssl/CMakeLists.txt
View File

@ -1,9 +1,9 @@
idf_build_get_property(target IDF_TARGET)
if(CONFIG_ESP_WOLFSSL_INTERNAL)
set(COMPONENT_ADD_INCLUDEDIRS wolfssl/include wolfssl/wolfssl wolfssl/wolfssl/wolfssl)
set(COMPONENT_SRCDIRS "wolfssl/source")
set(COMPONENT_REQUIRES "lwip" "esp8266" "util")
set(COMPONENT_REQUIRES "lwip" "${target}")
endif()
register_component()

7
components/esp8266/CMakeLists.txt
View File

@ -2,7 +2,7 @@ if(BOOTLOADER_BUILD)
# For bootloader, all we need from esp8266 is headers
set(COMPONENT_ADD_INCLUDEDIRS include)
# set(COMPONENT_REQUIRES ${COMPONENTS})
set(COMPONENT_SRCS source/ets_printf.c)
set(COMPONENT_SRCS source/ets_printf.c source/crc.c)
register_component(esp8266)
# as cmake won't attach linker args to a header-only library, attach
@ -29,6 +29,7 @@ else()
"source/esp_wifi_os_adapter.c"
"source/esp_wifi.c"
"source/ets_printf.c"
"source/crc.c"
"source/phy_init.c"
"source/reset_reason.c"
"source/startup.c"
@ -52,7 +53,7 @@ else()
set(include_dirs "include" "include/driver")
set(requires "esp_common" "esp_event")
set(priv_requires "wpa_supplicant" "log" "spi_flash" "tcpip_adapter" "esp_ringbuf" "bootloader_support" "nvs_flash" "util")
set(priv_requires "wpa_supplicant" "log" "spi_flash" "tcpip_adapter" "esp_ringbuf" "bootloader_support" "nvs_flash")
set(fragments linker.lf ld/esp8266_fragments.lf ld/esp8266_bss_fragments.lf)
idf_component_register(SRCS "${srcs}"
@ -63,7 +64,7 @@ else()
REQUIRED_IDF_TARGETS esp8266)
target_link_libraries(${COMPONENT_LIB} PUBLIC "-L ${CMAKE_CURRENT_SOURCE_DIR}/lib" "-lstdc++")
target_compile_definitions(${COMPONENT_LIB} PUBLIC -DUSING_IBUS_FASTER_GET)
if(NOT CONFIG_NO_BLOBS)
set(blobs "gcc" "hal" "core" "net80211" "phy" "rtc" "clk" "pp" "smartconfig" "ssc" "wpa" "espnow" "wps" "wpa2")
foreach(blob ${blobs})

3
components/esp8266/component.mk
View File

@ -2,7 +2,7 @@
# Component Makefile
#
ifdef IS_BOOTLOADER_BUILD
COMPONENT_OBJS := source/ets_printf.o
COMPONENT_OBJS := source/ets_printf.o source/crc.o
COMPONENT_SRCDIRS := source
else
COMPONENT_ADD_INCLUDEDIRS += include
@ -20,6 +20,7 @@ LIBS += gcc hal core_dbg net80211_dbg \
endif
endif
CFLAGS += -DUSING_IBUS_FASTER_GET
#Linker scripts used to link the final application.
#Warning: These linker scripts are only used when the normal app is compiled; the bootloader
#specifies its own scripts.

0
components/util/include/esp_crc.h → components/esp8266/include/esp_crc.h
View File

0
components/util/include/esp_sha.h → components/esp8266/include/esp_sha.h
View File

0
components/util/include/ibus_data.h → components/esp8266/include/ibus_data.h
View File

0
components/util/include/util_assert.h → components/esp8266/include/util_assert.h
View File

2
components/util/src/crc.c → components/esp8266/source/crc.c
View File

@ -14,7 +14,7 @@
#include <stdint.h>
#include "crc.h"
#include "rom/crc.h"
#include "ibus_data.h"
static const uint32_t crc32_le_table[256] = {

2
components/esp8266/source/system_api.c
View File

@ -19,7 +19,7 @@
#include "esp_system.h"
#include "internal/esp_system_internal.h"
#include "crc.h"
#include "rom/crc.h"
#include "esp8266/eagle_soc.h"
#include "esp8266/efuse_register.h"

22
components/mbedtls/CMakeLists.txt
View File

@ -1,12 +1,13 @@
idf_component_register(INCLUDE_DIRS "port/include" "port/esp8266/include" "mbedtls/include"
REQUIRES lwip util)
idf_build_get_property(target IDF_TARGET)
idf_component_register(INCLUDE_DIRS "port/include" "port/include/${target}" "mbedtls/include"
REQUIRES lwip)
# Only build mbedtls libraries
set(ENABLE_TESTING CACHE BOOL OFF)
set(ENABLE_PROGRAMS CACHE BOOL OFF)
# Needed to for include_next includes to work from within mbedtls
include_directories("${COMPONENT_DIR}/port/include" "${COMPONENT_DIR}/port/esp8266/include")
include_directories("${COMPONENT_DIR}/port/include" "${COMPONENT_DIR}/port/include/${target}")
# Import mbedtls library targets
add_subdirectory(mbedtls)
@ -25,10 +26,17 @@ target_sources(mbedtls PRIVATE "${COMPONENT_DIR}/port/mbedtls_debug.c"
target_sources(mbedcrypto PRIVATE "${COMPONENT_DIR}/port/esp_hardware.c"
"${COMPONENT_DIR}/port/esp_mem.c"
"${COMPONENT_DIR}/port/esp_timing.c"
"${COMPONENT_DIR}/port/esp8266/aes.c"
"${COMPONENT_DIR}/port/esp8266/sha1.c"
"${COMPONENT_DIR}/port/esp8266/sha256.c"
"${COMPONENT_DIR}/port/esp8266/sha512.c")
"${COMPONENT_DIR}/port/esp_aes.c"
"${COMPONENT_DIR}/port/esp_sha1.c"
"${COMPONENT_DIR}/port/esp_sha256.c"
"${COMPONENT_DIR}/port/esp_sha512.c"
"${COMPONENT_DIR}/port/${target}/aes.c"
"${COMPONENT_DIR}/port/${target}/arc4.c"
"${COMPONENT_DIR}/port/${target}/base64.c"
"${COMPONENT_DIR}/port/${target}/md5.c"
"${COMPONENT_DIR}/port/${target}/sha1.c"
"${COMPONENT_DIR}/port/${target}/sha256.c"
"${COMPONENT_DIR}/port/${target}/sha512.c")
foreach(target ${mbedtls_targets})
target_compile_definitions(${target} PUBLIC -DMBEDTLS_CONFIG_FILE="mbedtls/esp_config.h" -DCONFIG_SSL_USING_MBEDTLS)

71
components/mbedtls/Kconfig
View File

@ -552,4 +552,75 @@ menu "mbedTLS"
# end of Elliptic Curve options
menu "Util"
config util_assert
bool "Enable assert for util components"
default n
help
Enable this option, util components will use assert to check if input
parameters are correct.
Disable this option will speed up the process of some calculation a lot.
config ESP_SHA
bool "Enable Espressif SHA"
default n
help
Enable Espressif SHA1, SHA256, SHA384 & SHA512 for other components to
save code size for ESP8285(ESP8266 + 1MB flash) users.
Although this option is disable, bootloader will use it if booloader
is configured to use SHA256 to check hash.
Disabling the "assert" function at menuconfig can speed up the calculation.
config ESP_AES
bool "Enable Espressif AES"
default y
help
Enable Espressif AES ECB, CBC, CFB128, CFB8 & CRT for other components to
speed up process speed and save code size.
ESP8285 is like ESP8266 + 1MB flash, but its internal I/O connection from CPU
core to flash is DIO not QIO, which makes it read flash data slower.
So the function will speed up ESP8285 obviously.
The calculation uses "ibus_data" to speed up load data from instruction bus.
Disabling the "assert" function at menuconfig can speed up the calculation.
config ESP_MD5
bool "Enable Espressif MD5"
default y
help
Enable Espressif MD5 for other components to
speed up process speed and save code size.
ESP8285 is like ESP8266 + 1MB flash, but its internal I/O connection from CPU
core to flash is DIO not QIO, which makes it read flash data slower.
So the function will speed up ESP8285 obviously.
The calculation uses "ibus_data" to speed up load data from instruction bus.
Disabling the "assert" function at menuconfig can speed up the calculation.
config ESP_ARC4
bool "Enable Espressif ARC4"
default y
help
Enable Espressif ARC4 for other components to
speed up process speed and save code size.
ESP8285 is like ESP8266 + 1MB flash, but its internal I/O connection from CPU
core to flash is DIO not QIO, which makes it read flash data slower.
So the function will speed up ESP8285 obviously.
The calculation uses "ibus_data" to speed up load data from instruction bus.
Disabling the "assert" function at menuconfig can speed up the calculation.
endmenu # Util
endmenu # mbedTLS

4
components/mbedtls/component.mk
View File

@ -2,9 +2,9 @@
# Component Makefile
#
COMPONENT_ADD_INCLUDEDIRS := port/include mbedtls/include port/esp8266/include
COMPONENT_ADD_INCLUDEDIRS := port/include mbedtls/include port/include/$(IDF_TARGET)
COMPONENT_SRCDIRS := mbedtls/library port port/esp8266
COMPONENT_SRCDIRS := mbedtls/library port port/$(IDF_TARGET)
COMPONENT_OBJEXCLUDE := mbedtls/library/net_sockets.o

1180
components/mbedtls/port/esp8266/aes.c
View File

File diff suppressed because it is too large Load Diff

0
components/util/src/arc4.c → components/mbedtls/port/esp8266/arc4.c
View File

0
components/util/src/base64.c → components/mbedtls/port/esp8266/base64.c
View File

2
components/util/src/md5.c → components/mbedtls/port/esp8266/md5.c
View File

@ -28,7 +28,7 @@ static const uint8_t esp_md5_padding[64] =
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
int esp_md5_process(esp_md5_context_t *ctx, const uint8_t data[64])
static int esp_md5_process(esp_md5_context_t *ctx, const uint8_t data[64])
{
uint32_t X[64], Y[4];
util_assert(ctx);

203
components/mbedtls/port/esp8266/sha1.c
View File

@ -1,68 +1,165 @@
/**
* \brief AES block cipher, ESP8266 accelerated version
* Based on mbedTLS FIPS-197 compliant version.
*
* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
* Additions Copyright (C) 2016-2017, Espressif Systems (Shanghai) PTE Ltd
* SPDX-License-Identifier: Apache-2.0
*
* 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.
*
*/
// 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 "mbedtls/sha1.h"
#include "util_assert.h"
#include <sys/errno.h>
#include "esp_sha.h"
#include "esp_log.h"
#if defined(MBEDTLS_SHA1_ALT)
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
void mbedtls_sha1_init(mbedtls_sha1_context *ctx)
#define blk0(i) (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \
(rol(block->l[i], 8) & 0x00FF00FF))
#define blk(i) (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ \
block->l[(i + 8) & 15] ^ block->l[(i + 2) & 15] ^ block->l[i & 15], 1))
#define R0(v,w,x,y,z,i) \
z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
w = rol(w, 30);
#define R1(v,w,x,y,z,i) \
z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
w = rol(w, 30);
#define R2(v,w,x,y,z,i) \
z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30);
#define R3(v,w,x,y,z,i) \
z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
w = rol(w, 30);
#define R4(v,w,x,y,z,i) \
z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
w=rol(w, 30);
typedef union {
uint8_t c[64];
uint32_t l[16];
} block_t;
static void esp_sha1_transform(uint32_t state[5], const uint8_t buffer[64])
{
memset(ctx, 0, sizeof(mbedtls_sha1_context));
uint32_t a, b, c, d, e;
block_t workspace;
block_t *block = &workspace;
memcpy(block, buffer, 64);
a = state[0];
b = state[1];
c = state[2];
d = state[3];
e = state[4];
R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
state[4] += e;
}
void mbedtls_sha1_free(mbedtls_sha1_context *ctx)
int esp_sha1_init(esp_sha1_t *ctx)
{
memset(ctx, 0, sizeof(mbedtls_sha1_context));
util_assert(ctx);
ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89;
ctx->state[2] = 0x98BADCFE;
ctx->state[3] = 0x10325476;
ctx->state[4] = 0xC3D2E1F0;
ctx->total[0] = ctx->total[1] = 0;
return 0;
}
void mbedtls_sha1_clone(mbedtls_sha1_context *dst, const mbedtls_sha1_context *src)
int esp_sha1_update(esp_sha1_t *ctx, const void *src, size_t size)
{
memcpy(dst, src, sizeof(mbedtls_sha1_context));
uint32_t i, j;
const uint8_t *data = (const uint8_t *)src;
util_assert(ctx);
util_assert(src);
util_assert(size);
j = (ctx->total[0] >> 3) & 63;
if ((ctx->total[0] += size << 3) < (size << 3))
ctx->total[1]++;
ctx->total[1] += (size >> 29);
if ((j + size) > 63) {
memcpy(&ctx->buffer[j], data, (i = 64-j));
esp_sha1_transform(ctx->state, ctx->buffer);
for ( ; i + 63 < size; i += 64)
esp_sha1_transform(ctx->state, &data[i]);
j = 0;
} else
i = 0;
memcpy(&ctx->buffer[j], &data[i], size - i);
return 0;
}
int mbedtls_sha1_starts_ret(mbedtls_sha1_context *ctx)
int esp_sha1_finish(esp_sha1_t *ctx, void *dest)
{
return esp_sha1_init(ctx);
uint32_t i;
uint32_t index;
uint8_t finalcount[8];
uint8_t *digest = (uint8_t *)dest;
util_assert(ctx);
util_assert(dest);
for (i = 0; i < 8; i++)
finalcount[i] = (uint8_t)((ctx->total[(i >= 4 ? 0 : 1)] >> ((3-(i & 3)) * 8) ) & 255);
index = 0x80;
esp_sha1_update(ctx, (uint8_t *)&index, 1);
while ((ctx->total[0] & 504) != 448) {
index = 0;
esp_sha1_update(ctx, (uint8_t *)&index, 1);
}
esp_sha1_update(ctx, finalcount, 8);
for (i = 0; i < 20; i++)
digest[i] = (uint8_t)((ctx->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
return 0;
}
int mbedtls_sha1_update_ret(mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen)
{
return esp_sha1_update(ctx, input, ilen);
}
int mbedtls_sha1_finish_ret(mbedtls_sha1_context *ctx, unsigned char output[64])
{
return esp_sha1_finish(ctx, output);
}
int mbedtls_internal_sha1_process(mbedtls_sha1_context *ctx, const unsigned char data[128])
{
return esp_sha1_update(ctx, data, 64);
}
// int mbedtls_sha512_ret(const unsigned char *input, size_t ilen, unsigned char output[64], int is384)
// {
// }
#endif /* MBEDTLS_AES_ALT */

275
components/mbedtls/port/esp8266/sha256.c
View File

@ -1,75 +1,252 @@
/**
* \brief AES block cipher, ESP8266 accelerated version
* Based on mbedTLS FIPS-197 compliant version.
*
* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
* Additions Copyright (C) 2016-2017, Espressif Systems (Shanghai) PTE Ltd
* SPDX-License-Identifier: Apache-2.0
*
* 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.
*
*/
// 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 "mbedtls/sha256.h"
#include "util_assert.h"
#include <sys/errno.h>
#include "esp_sha.h"
#include "esp_log.h"
#if defined(MBEDTLS_SHA256_ALT)
#define ESP_GET_BE32(a) ((((uint32_t) (a)[0]) << 24) | (((uint32_t) (a)[1]) << 16) | \
(((uint32_t) (a)[2]) << 8) | ((uint32_t) (a)[3]))
void mbedtls_sha256_init(mbedtls_sha256_context *ctx)
#define ESP_PUT_BE64(a, val) \
do { \
(a)[0] = (uint8_t) (((uint64_t) (val)) >> 56); \
(a)[1] = (uint8_t) (((uint64_t) (val)) >> 48); \
(a)[2] = (uint8_t) (((uint64_t) (val)) >> 40); \
(a)[3] = (uint8_t) (((uint64_t) (val)) >> 32); \
(a)[4] = (uint8_t) (((uint64_t) (val)) >> 24); \
(a)[5] = (uint8_t) (((uint64_t) (val)) >> 16); \
(a)[6] = (uint8_t) (((uint64_t) (val)) >> 8); \
(a)[7] = (uint8_t) (((uint64_t) (val)) & 0xff); \
} while (0)
#define ESP_PUT_BE32(a, val) \
do { \
(a)[0] = (uint8_t) ((((uint32_t) (val)) >> 24) & 0xff); \
(a)[1] = (uint8_t) ((((uint32_t) (val)) >> 16) & 0xff); \
(a)[2] = (uint8_t) ((((uint32_t) (val)) >> 8) & 0xff); \
(a)[3] = (uint8_t) (((uint32_t) (val)) & 0xff); \
} while (0)
#define RORc(x, y) \
( ((((uint32_t) (x) & 0xFFFFFFFFUL) >> (uint32_t) ((y) & 31)) | \
((uint32_t) (x) << (uint32_t) (32 - ((y) & 31)))) & 0xFFFFFFFFUL)
#define Ch(x,y,z) (z ^ (x & (y ^ z)))
#define Maj(x,y,z) (((x | y) & z) | (x & y))
#define S(x, n) RORc((x), (n))
#define R(x, n) (((x)&0xFFFFFFFFUL)>>(n))
#define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22))
#define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25))
#define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3))
#define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10))
#ifndef MIN
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#endif
#define RND(a,b,c,d,e,f,g,h,i) \
t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \
t1 = Sigma0(a) + Maj(a, b, c); \
d += t0; \
h = t0 + t1;
static const uint32_t K[64] = {
0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, 0x3956c25bUL,
0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, 0xd807aa98UL, 0x12835b01UL,
0x243185beUL, 0x550c7dc3UL, 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL,
0xc19bf174UL, 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, 0x983e5152UL,
0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, 0xc6e00bf3UL, 0xd5a79147UL,
0x06ca6351UL, 0x14292967UL, 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL,
0x53380d13UL, 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, 0xd192e819UL,
0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 0x19a4c116UL, 0x1e376c08UL,
0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL,
0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
};
static void esp_sha256_transform(esp_sha256_t *ctx, const uint8_t *buf)
{
memset(ctx, 0, sizeof(mbedtls_sha256_context));
uint32_t S[8], W[64], t0, t1;
uint32_t t;
int i;
for (i = 0; i < 8; i++)
S[i] = ctx->state[i];
for (i = 0; i < 16; i++)
W[i] = ESP_GET_BE32(buf + (4 * i));
for (i = 16; i < 64; i++)
W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
for (i = 0; i < 64; ++i) {
RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], i);
t = S[7]; S[7] = S[6]; S[6] = S[5]; S[5] = S[4];
S[4] = S[3]; S[3] = S[2]; S[2] = S[1]; S[1] = S[0]; S[0] = t;
}
for (i = 0; i < 8; i++)
ctx->state[i] = ctx->state[i] + S[i];
}
void mbedtls_sha256_free(mbedtls_sha256_context *ctx)
int esp_sha256_init(esp_sha256_t *ctx)
{
memset(ctx, 0, sizeof(mbedtls_sha256_context));
util_assert(ctx);
ctx->is224 = 0;
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x6A09E667UL;
ctx->state[1] = 0xBB67AE85UL;
ctx->state[2] = 0x3C6EF372UL;
ctx->state[3] = 0xA54FF53AUL;
ctx->state[4] = 0x510E527FUL;
ctx->state[5] = 0x9B05688CUL;
ctx->state[6] = 0x1F83D9ABUL;
ctx->state[7] = 0x5BE0CD19UL;
return 0;
}
void mbedtls_sha256_clone(mbedtls_sha256_context *dst, const mbedtls_sha256_context *src)
int esp_sha224_init(esp_sha224_t *ctx)
{
memcpy(dst, src, sizeof(mbedtls_sha256_context));
util_assert(ctx);
ctx->is224 = 1;
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0xC1059ED8;
ctx->state[1] = 0x367CD507;
ctx->state[2] = 0x3070DD17;
ctx->state[3] = 0xF70E5939;
ctx->state[4] = 0xFFC00B31;
ctx->state[5] = 0x68581511;
ctx->state[6] = 0x64F98FA7;
ctx->state[7] = 0xBEFA4FA4;
return 0;
}
int mbedtls_sha256_starts_ret(mbedtls_sha256_context *ctx, int is224)
int esp_sha256_update(esp_sha256_t *ctx, const void *src, size_t size)
{
int ret;
size_t fill;
uint32_t left;
const uint8_t *input = (const uint8_t *)src;
if (is224)
ret = esp_sha224_init(ctx);
else
ret = esp_sha256_init(ctx);
util_assert(ctx);
util_assert(src);
util_assert(size);
return ret;
left = ctx->total[0] & 0x3F;
fill = 64 - left;
ctx->total[0] += size;
ctx->total[0] &= 0xFFFFFFFF;
if (ctx->total[0] < size)
ctx->total[1]++;
if (left && size >= fill) {
memcpy(ctx->buffer + left, input, fill);
esp_sha256_transform(ctx, ctx->buffer);
input += fill;
size -= fill;
left = 0;
}
while (size >= 64) {
esp_sha256_transform(ctx, input);
input += 64;
size -= 64;
}
if (size > 0)
memcpy(ctx->buffer + left, input, size);
return 0;
}
int mbedtls_sha256_update_ret(mbedtls_sha256_context *ctx, const unsigned char *input, size_t ilen)
int esp_sha224_update(esp_sha224_t *ctx, const void *src, size_t size)
{
return esp_sha256_update(ctx, input, ilen);
util_assert(ctx);
util_assert(src);
util_assert(size);
return esp_sha256_update(ctx, src, size);
}
int mbedtls_sha256_finish_ret(mbedtls_sha256_context *ctx, unsigned char output[64])
int esp_sha224_finish(esp_sha224_t *ctx, void *dest)
{
return esp_sha256_finish(ctx, output);
uint32_t used;
uint32_t high, low;
uint8_t *out = (uint8_t *)dest;
util_assert(ctx);
util_assert(dest);
used = ctx->total[0] & 0x3F;
ctx->buffer[used++] = 0x80;
if (used <= 56) {
memset(ctx->buffer + used, 0, 56 - used);
} else {
memset(ctx->buffer + used, 0, 64 - used);
esp_sha256_transform(ctx, ctx->buffer);
memset(ctx->buffer, 0, 56);
}
high = (ctx->total[0] >> 29) | (ctx->total[1] << 3);
low = (ctx->total[0] << 3);
ESP_PUT_BE32(ctx->buffer + 56, high);
ESP_PUT_BE32(ctx->buffer + 60, low);
esp_sha256_transform(ctx, ctx->buffer);
ESP_PUT_BE32(out + 0, ctx->state[0]);
ESP_PUT_BE32(out + 4, ctx->state[1]);
ESP_PUT_BE32(out + 8, ctx->state[2]);
ESP_PUT_BE32(out + 12, ctx->state[3]);
ESP_PUT_BE32(out + 16, ctx->state[4]);
ESP_PUT_BE32(out + 20, ctx->state[5]);
ESP_PUT_BE32(out + 24, ctx->state[6]);
if (!ctx->is224) {
ESP_PUT_BE32(out + 28, ctx->state[7]);
}
return( 0 );
}
int mbedtls_internal_sha256_process(mbedtls_sha256_context *ctx, const unsigned char data[128])
int esp_sha256_finish(esp_sha256_t *ctx, void *dest)
{
return esp_sha256_update(ctx, data, 64);
util_assert(ctx);
util_assert(dest);
esp_sha224_finish(ctx, dest);
return 0;
}
// int mbedtls_sha512_ret(const unsigned char *input, size_t ilen, unsigned char output[64], int is384)
// {
// }
#endif /* MBEDTLS_AES_ALT */

323
components/mbedtls/port/esp8266/sha512.c
View File

@ -1,75 +1,302 @@
/**
* \brief AES block cipher, ESP8266 accelerated version
* Based on mbedTLS FIPS-197 compliant version.
*
* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
* Additions Copyright (C) 2016-2017, Espressif Systems (Shanghai) PTE Ltd
* SPDX-License-Identifier: Apache-2.0
*
* 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.
*
*/
// 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 "mbedtls/sha512.h"
#include "util_assert.h"
#include <sys/errno.h>
#include "esp_sha.h"
#include "esp_log.h"
#if defined(MBEDTLS_SHA512_ALT)
#define UL64(x) x##ULL
void mbedtls_sha512_init(mbedtls_sha512_context *ctx)
{
memset(ctx, 0, sizeof(mbedtls_sha512_context));
#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) \
do \
{ \
temp1 = (h) + S3(e) + F1((e),(f),(g)) + (K) + (x); \
temp2 = S2(a) + F0((a),(b),(c)); \
(d) += temp1; (h) = temp1 + temp2; \
} while( 0 )
#define GET_UINT64_BE(n,b,i) \
{ \
(n) = ( (uint64_t) (b)[(i) ] << 56 ) \
| ( (uint64_t) (b)[(i) + 1] << 48 ) \
| ( (uint64_t) (b)[(i) + 2] << 40 ) \
| ( (uint64_t) (b)[(i) + 3] << 32 ) \
| ( (uint64_t) (b)[(i) + 4] << 24 ) \
| ( (uint64_t) (b)[(i) + 5] << 16 ) \
| ( (uint64_t) (b)[(i) + 6] << 8 ) \
| ( (uint64_t) (b)[(i) + 7] ); \
}
void mbedtls_sha512_free(mbedtls_sha512_context *ctx)
{
memset(ctx, 0, sizeof(mbedtls_sha512_context));
#define PUT_UINT64_BE(n,b,i) \
{ \
(b)[(i) ] = (uint8_t) ( (n) >> 56 ); \
(b)[(i) + 1] = (uint8_t) ( (n) >> 48 ); \
(b)[(i) + 2] = (uint8_t) ( (n) >> 40 ); \
(b)[(i) + 3] = (uint8_t) ( (n) >> 32 ); \
(b)[(i) + 4] = (uint8_t) ( (n) >> 24 ); \
(b)[(i) + 5] = (uint8_t) ( (n) >> 16 ); \
(b)[(i) + 6] = (uint8_t) ( (n) >> 8 ); \
(b)[(i) + 7] = (uint8_t) ( (n) ); \
}
void mbedtls_sha512_clone(mbedtls_sha512_context *dst, const mbedtls_sha512_context *src)
static const uint64_t K[80] =
{
memcpy(dst, src, sizeof(mbedtls_sha512_context));
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)
};
static int esp_sha512_transform(esp_sha512_t *ctx, const uint8_t *data)
{
int i;
uint64_t temp1, temp2, W[80];
uint64_t A, B, C, D, E, F, G, H;
for( i = 0; i < 16; i++ ) {
GET_UINT64_BE(W[i], data, i << 3);
}
for( ; i < 80; i++ )
W[i] = S1(W[i - 2]) + W[i - 7] + S0(W[i - 15]) + W[i - 16];
A = ctx->state[0];
B = ctx->state[1];
C = ctx->state[2];
D = ctx->state[3];
E = ctx->state[4];
F = ctx->state[5];
G = ctx->state[6];
H = ctx->state[7];
i = 0;
do {
P(A, B, C, D, E, F, G, H, W[i], K[i]); i++;
P(H, A, B, C, D, E, F, G, W[i], K[i]); i++;
P(G, H, A, B, C, D, E, F, W[i], K[i]); i++;
P(F, G, H, A, B, C, D, E, W[i], K[i]); i++;
P(E, F, G, H, A, B, C, D, W[i], K[i]); i++;
P(D, E, F, G, H, A, B, C, W[i], K[i]); i++;
P(C, D, E, F, G, H, A, B, W[i], K[i]); i++;
P(B, C, D, E, F, G, H, A, W[i], K[i]); i++;
} while (i < 80);
ctx->state[0] += A;
ctx->state[1] += B;
ctx->state[2] += C;
ctx->state[3] += D;
ctx->state[4] += E;
ctx->state[5] += F;
ctx->state[6] += G;
ctx->state[7] += H;
return( 0 );
}
int mbedtls_sha512_starts_ret(mbedtls_sha512_context *ctx, int is384)
int esp_sha512_init(esp_sha512_t *ctx)
{
int ret;
util_assert(ctx);
if (is384)
ret = esp_sha384_init(ctx);
else
ret = esp_sha512_init(ctx);
ctx->is384 = 0;
return ret;
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = UL64(0x6A09E667F3BCC908);
ctx->state[1] = UL64(0xBB67AE8584CAA73B);
ctx->state[2] = UL64(0x3C6EF372FE94F82B);
ctx->state[3] = UL64(0xA54FF53A5F1D36F1);
ctx->state[4] = UL64(0x510E527FADE682D1);
ctx->state[5] = UL64(0x9B05688C2B3E6C1F);
ctx->state[6] = UL64(0x1F83D9ABFB41BD6B);
ctx->state[7] = UL64(0x5BE0CD19137E2179);
return 0;
}
int mbedtls_sha512_update_ret(mbedtls_sha512_context *ctx, const unsigned char *input, size_t ilen)
int esp_sha384_init(esp_sha384_t *ctx)
{
return esp_sha512_update(ctx, input, ilen);
util_assert(ctx);
ctx->is384 = 1;
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = UL64(0xCBBB9D5DC1059ED8);
ctx->state[1] = UL64(0x629A292A367CD507);
ctx->state[2] = UL64(0x9159015A3070DD17);
ctx->state[3] = UL64(0x152FECD8F70E5939);
ctx->state[4] = UL64(0x67332667FFC00B31);
ctx->state[5] = UL64(0x8EB44A8768581511);
ctx->state[6] = UL64(0xDB0C2E0D64F98FA7);
ctx->state[7] = UL64(0x47B5481DBEFA4FA4);
return 0;
}
int mbedtls_sha512_finish_ret(mbedtls_sha512_context *ctx, unsigned char output[64])
int esp_sha512_update(esp_sha512_t *ctx, const void *src, size_t size)
{
return esp_sha512_finish(ctx, output);
size_t fill;
uint32_t left;
const uint8_t *input = (const uint8_t *)src;
util_assert(ctx);
util_assert(src);
util_assert(size);
left = (uint32_t) (ctx->total[0] & 0x7F);
fill = 128 - left;
ctx->total[0] += (uint64_t)size;
if( ctx->total[0] < (uint64_t)size)
ctx->total[1]++;
if (left && size >= fill) {
memcpy(ctx->buffer + left, input, fill);
esp_sha512_transform(ctx, ctx->buffer);
input += fill;
size -= fill;
left = 0;
}
while (size >= 128) {
esp_sha512_transform(ctx, input);
input += 128;
size -= 128;
}
if (size > 0)
memcpy((void *) (ctx->buffer + left), input, size);
return( 0 );
}
int mbedtls_internal_sha512_process(mbedtls_sha512_context *ctx, const unsigned char data[128])
int esp_sha384_update(esp_sha384_t *ctx, const void *src, size_t size)
{
return esp_sha512_update(ctx, data, 128);
util_assert(ctx);
util_assert(src);
util_assert(size);
return esp_sha512_update(ctx, src, size);
}
// int mbedtls_sha512_ret(const unsigned char *input, size_t ilen, unsigned char output[64], int is384)
// {
int esp_sha384_finish(esp_sha384_t *ctx, void *dest)
{
uint8_t used;
uint64_t high, low;
uint8_t *output = (uint8_t *)dest;
// }
util_assert(ctx);
util_assert(dest);
#endif /* MBEDTLS_AES_ALT */
used = ctx->total[0] & 0x7F;
ctx->buffer[used++] = 0x80;
if (used <= 112)
memset(ctx->buffer + used, 0, 112 - used);
else {
memset(ctx->buffer + used, 0, 128 - used);
esp_sha512_transform(ctx, ctx->buffer);
memset(ctx->buffer, 0, 112);
}
high = (ctx->total[0] >> 61) | (ctx->total[1] << 3);
low = (ctx->total[0] << 3);
PUT_UINT64_BE(high, ctx->buffer, 112);
PUT_UINT64_BE(low, ctx->buffer, 120);
esp_sha512_transform(ctx, ctx->buffer);
PUT_UINT64_BE(ctx->state[0], output, 0);
PUT_UINT64_BE(ctx->state[1], output, 8);
PUT_UINT64_BE(ctx->state[2], output, 16);
PUT_UINT64_BE(ctx->state[3], output, 24);
PUT_UINT64_BE(ctx->state[4], output, 32);
PUT_UINT64_BE(ctx->state[5], output, 40);
if (!ctx->is384) {
PUT_UINT64_BE(ctx->state[6], output, 48);
PUT_UINT64_BE(ctx->state[7], output, 56);
}
return 0;
}
int esp_sha512_finish(esp_sha512_t *ctx, void *dest)
{
util_assert(ctx);
util_assert(dest);
esp_sha384_finish(ctx, dest);
return 0;
}

181
components/mbedtls/port/esp_aes.c Normal file
View File

@ -0,0 +1,181 @@
/**
* \brief AES block cipher, ESP8266 accelerated version
* Based on mbedTLS FIPS-197 compliant version.
*
* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
* Additions Copyright (C) 2016-2017, Espressif Systems (Shanghai) PTE Ltd
* SPDX-License-Identifier: Apache-2.0
*
* 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 <string.h>
#include "mbedtls/aes.h"
#if defined(MBEDTLS_AES_ALT)
void mbedtls_aes_init(mbedtls_aes_context *ctx)
{
memset(ctx, 0, sizeof(mbedtls_aes_context));
}
void mbedtls_aes_free(mbedtls_aes_context *ctx)
{
memset(ctx, 0, sizeof(mbedtls_aes_context));
}
#if defined(MBEDTLS_CIPHER_MODE_XTS)
void mbedtls_aes_xts_init(mbedtls_aes_xts_context *ctx)
{
memset(ctx, 0, sizeof(mbedtls_aes_xts_context));
}
void mbedtls_aes_xts_free(mbedtls_aes_xts_context *ctx)
{
memset(ctx, 0, sizeof(mbedtls_aes_xts_context));
}
int mbedtls_aes_xts_setkey_enc(mbedtls_aes_xts_context *ctx,
const unsigned char *key,
unsigned int keybits)
{
return esp_aes_xts_set_encrypt_key(ctx, key, keybits);
}
int mbedtls_aes_xts_setkey_dec(mbedtls_aes_xts_context *ctx,
const unsigned char *key,
unsigned int keybits)
{
return esp_aes_xts_set_decrypt_key(ctx, key, keybits);
}
int mbedtls_aes_crypt_xts(mbedtls_aes_xts_context *ctx,
int mode,
size_t length,
const unsigned char data_unit[16],
const unsigned char *input,
unsigned char *output)
{
return esp_aes_crypt_xts(ctx, MBEDTLS_AES_ENCRYPT == mode, length, data_unit, input, output);
}
#endif
int mbedtls_aes_setkey_enc(mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits)
{
return esp_aes_set_encrypt_key(ctx, key, keybits);
}
int mbedtls_aes_setkey_dec(mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits)
{
return esp_aes_set_decrypt_key(ctx, key, keybits);
}
int mbedtls_aes_crypt_ecb(mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16])
{
if (MBEDTLS_AES_DECRYPT == mode)
return esp_aes_decrypt_ecb(ctx, input, output);
else
return esp_aes_encrypt_ecb(ctx, input, output);
}
#if defined(MBEDTLS_CIPHER_MODE_CBC)
int mbedtls_aes_crypt_cbc(mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output)
{
if (MBEDTLS_AES_DECRYPT == mode)
return esp_aes_decrypt_cbc(ctx, input, length, output, length, iv);
else
return esp_aes_encrypt_cbc(ctx, input, length, output, length, iv);
}
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
int mbedtls_aes_crypt_cfb128(mbedtls_aes_context *ctx,
int mode,
size_t length,
size_t *iv_off,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output)
{
if (MBEDTLS_AES_DECRYPT == mode)
return esp_aes_decrypt_cfb128(ctx, input, length, output, length, iv, iv_off);
else
return esp_aes_encrypt_cfb128(ctx, input, length, output, length, iv, iv_off);
}
int mbedtls_aes_crypt_cfb8(mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output)
{
if (MBEDTLS_AES_DECRYPT == mode)
return esp_aes_decrypt_cfb8(ctx, input, length, output, length, iv);
else
return esp_aes_encrypt_cfb8(ctx, input, length, output, length, iv);
}
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
int mbedtls_aes_crypt_ofb(mbedtls_aes_context *ctx,
size_t length,
size_t *iv_off,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output)
{
return esp_aes_crypt_ofb(ctx, length, iv_off, iv, input, output);
}
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
int mbedtls_aes_crypt_ctr(mbedtls_aes_context *ctx,
size_t length,
size_t *nc_off,
unsigned char nonce_counter[16],
unsigned char stream_block[16],
const unsigned char *input,
unsigned char *output)
{
return esp_aes_encrypt_ctr(ctx, nc_off, nonce_counter, stream_block, input,
length, output, length);
}
#endif
int mbedtls_internal_aes_encrypt(mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16])
{
return esp_aes_encrypt(ctx, input, 16, output, 16);
}
int mbedtls_internal_aes_decrypt(mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16])
{
return esp_aes_decrypt(ctx, input, 16, output, 16);
}
#endif /* MBEDTLS_AES_ALT */

68
components/mbedtls/port/esp_sha1.c Normal file
View File

@ -0,0 +1,68 @@
/**
* \brief AES block cipher, ESP8266 accelerated version
* Based on mbedTLS FIPS-197 compliant version.
*
* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
* Additions Copyright (C) 2016-2017, Espressif Systems (Shanghai) PTE Ltd
* SPDX-License-Identifier: Apache-2.0
*
* 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 <string.h>
#include "mbedtls/sha1.h"
#if defined(MBEDTLS_SHA1_ALT)
void mbedtls_sha1_init(mbedtls_sha1_context *ctx)
{
memset(ctx, 0, sizeof(mbedtls_sha1_context));
}
void mbedtls_sha1_free(mbedtls_sha1_context *ctx)
{
memset(ctx, 0, sizeof(mbedtls_sha1_context));
}
void mbedtls_sha1_clone(mbedtls_sha1_context *dst, const mbedtls_sha1_context *src)
{
memcpy(dst, src, sizeof(mbedtls_sha1_context));
}
int mbedtls_sha1_starts_ret(mbedtls_sha1_context *ctx)
{
return esp_sha1_init(ctx);
}
int mbedtls_sha1_update_ret(mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen)
{
return esp_sha1_update(ctx, input, ilen);
}
int mbedtls_sha1_finish_ret(mbedtls_sha1_context *ctx, unsigned char output[64])
{
return esp_sha1_finish(ctx, output);
}
int mbedtls_internal_sha1_process(mbedtls_sha1_context *ctx, const unsigned char data[128])
{
return esp_sha1_update(ctx, data, 64);
}
// int mbedtls_sha512_ret(const unsigned char *input, size_t ilen, unsigned char output[64], int is384)
// {
// }
#endif /* MBEDTLS_AES_ALT */

75
components/mbedtls/port/esp_sha256.c Normal file
View File

@ -0,0 +1,75 @@
/**
* \brief AES block cipher, ESP8266 accelerated version
* Based on mbedTLS FIPS-197 compliant version.
*
* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
* Additions Copyright (C) 2016-2017, Espressif Systems (Shanghai) PTE Ltd
* SPDX-License-Identifier: Apache-2.0
*
* 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 <string.h>
#include "mbedtls/sha256.h"
#if defined(MBEDTLS_SHA256_ALT)
void mbedtls_sha256_init(mbedtls_sha256_context *ctx)
{
memset(ctx, 0, sizeof(mbedtls_sha256_context));
}
void mbedtls_sha256_free(mbedtls_sha256_context *ctx)
{
memset(ctx, 0, sizeof(mbedtls_sha256_context));
}
void mbedtls_sha256_clone(mbedtls_sha256_context *dst, const mbedtls_sha256_context *src)
{
memcpy(dst, src, sizeof(mbedtls_sha256_context));
}
int mbedtls_sha256_starts_ret(mbedtls_sha256_context *ctx, int is224)
{
int ret;
if (is224)
ret = esp_sha224_init(ctx);
else
ret = esp_sha256_init(ctx);
return ret;
}
int mbedtls_sha256_update_ret(mbedtls_sha256_context *ctx, const unsigned char *input, size_t ilen)
{
return esp_sha256_update(ctx, input, ilen);
}
int mbedtls_sha256_finish_ret(mbedtls_sha256_context *ctx, unsigned char output[64])
{
return esp_sha256_finish(ctx, output);
}
int mbedtls_internal_sha256_process(mbedtls_sha256_context *ctx, const unsigned char data[128])
{
return esp_sha256_update(ctx, data, 64);
}
// int mbedtls_sha512_ret(const unsigned char *input, size_t ilen, unsigned char output[64], int is384)
// {
// }
#endif /* MBEDTLS_AES_ALT */

75
components/mbedtls/port/esp_sha512.c Normal file
View File

@ -0,0 +1,75 @@
/**
* \brief AES block cipher, ESP8266 accelerated version
* Based on mbedTLS FIPS-197 compliant version.
*
* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
* Additions Copyright (C) 2016-2017, Espressif Systems (Shanghai) PTE Ltd
* SPDX-License-Identifier: Apache-2.0
*
* 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 <string.h>
#include "mbedtls/sha512.h"
#if defined(MBEDTLS_SHA512_ALT)
void mbedtls_sha512_init(mbedtls_sha512_context *ctx)
{
memset(ctx, 0, sizeof(mbedtls_sha512_context));
}
void mbedtls_sha512_free(mbedtls_sha512_context *ctx)
{
memset(ctx, 0, sizeof(mbedtls_sha512_context));
}
void mbedtls_sha512_clone(mbedtls_sha512_context *dst, const mbedtls_sha512_context *src)
{
memcpy(dst, src, sizeof(mbedtls_sha512_context));
}
int mbedtls_sha512_starts_ret(mbedtls_sha512_context *ctx, int is384)
{
int ret;
if (is384)
ret = esp_sha384_init(ctx);
else
ret = esp_sha512_init(ctx);
return ret;
}
int mbedtls_sha512_update_ret(mbedtls_sha512_context *ctx, const unsigned char *input, size_t ilen)
{
return esp_sha512_update(ctx, input, ilen);
}
int mbedtls_sha512_finish_ret(mbedtls_sha512_context *ctx, unsigned char output[64])
{
return esp_sha512_finish(ctx, output);
}
int mbedtls_internal_sha512_process(mbedtls_sha512_context *ctx, const unsigned char data[128])
{
return esp_sha512_update(ctx, data, 128);
}
// int mbedtls_sha512_ret(const unsigned char *input, size_t ilen, unsigned char output[64], int is384)
// {
// }
#endif /* MBEDTLS_AES_ALT */

0
components/mbedtls/port/esp8266/include/aes_alt.h → components/mbedtls/port/include/aes_alt.h
View File

0
components/mbedtls/port/esp8266/include/arc4_alt.h → components/mbedtls/port/include/arc4_alt.h
View File

0
components/util/include/esp_aes.h → components/mbedtls/port/include/esp8266/esp_aes.h
View File

0
components/util/include/esp_arc4.h → components/mbedtls/port/include/esp8266/esp_arc4.h
View File

0
components/util/include/esp_base64.h → components/mbedtls/port/include/esp8266/esp_base64.h
View File

0
components/util/include/esp_md5.h → components/mbedtls/port/include/esp8266/esp_md5.h
View File

0
components/mbedtls/port/esp8266/include/md5_alt.h → components/mbedtls/port/include/md5_alt.h
View File

0
components/mbedtls/port/esp8266/include/sha1_alt.h → components/mbedtls/port/include/sha1_alt.h
View File

0
components/mbedtls/port/esp8266/include/sha256_alt.h → components/mbedtls/port/include/sha256_alt.h
View File

0
components/mbedtls/port/esp8266/include/sha512_alt.h → components/mbedtls/port/include/sha512_alt.h
View File

0
components/util/test/test_aes.c → components/mbedtls/test/test_aes.c
View File

0
components/util/test/test_arc4.c → components/mbedtls/test/test_arc4.c
View File

0
components/util/test/test_base64.c → components/mbedtls/test/test_base64.c
View File

2
components/util/test/test_crc.c → components/mbedtls/test/test_crc.c
View File

@ -15,7 +15,7 @@
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include "crc.h"
#include "rom/crc.h"
#include "unity.h"
#define TEST_CRC_COUNT 4096

0
components/util/test/test_md5.c → components/mbedtls/test/test_md5.c
View File

0
components/util/test/test_sha.c → components/mbedtls/test/test_sha.c
View File

2
components/nvs_flash/CMakeLists.txt
View File

@ -1,6 +1,6 @@
set(COMPONENT_SRCDIRS "src")
set(COMPONENT_ADD_INCLUDEDIRS "include")
set(COMPONENT_PRIV_REQUIRES "spi_flash" "util")
set(COMPONENT_PRIV_REQUIRES "spi_flash")
register_component()

2
components/nvs_flash/component.mk
View File

@ -6,4 +6,4 @@ COMPONENT_ADD_INCLUDEDIRS := include
COMPONENT_SRCDIRS := src
CPPFLAGS += -DNVS_CRC_HEADER_FILE=\"crc.h\"
CPPFLAGS += -DNVS_CRC_HEADER_FILE=\"rom/crc.h\"

4
components/nvs_flash/src/nvs_page.cpp
View File

@ -12,11 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include "nvs_page.hpp"
#if defined(ESP_PLATFORM)
#include <rom/crc.h>
#else
#include "crc.h"
#endif
#include <cstdio>
#include <cstring>

4
components/nvs_flash/src/nvs_types.cpp
View File

@ -13,11 +13,7 @@
// limitations under the License.
#include "nvs_types.hpp"
#if defined(ESP_PLATFORM)
#include <rom/crc.h>
#else
#include "crc.h"
#endif
namespace nvs
{

8
components/util/CMakeLists.txt
View File

@ -1,8 +0,0 @@
set(COMPONENT_SRCDIRS "src")
set(COMPONENT_ADD_INCLUDEDIRS "include")
register_component()
if(NOT BOOTLOADER_BUILD)
target_compile_definitions(${COMPONENT_LIB} PUBLIC -DUSING_IBUS_FASTER_GET)
endif()

69
components/util/Kconfig
View File

@ -1,69 +0,0 @@
menu "Util"
config util_assert
bool "Enable assert for util components"
default n
help
Enable this option, util components will use assert to check if input
parameters are correct.
Disable this option will speed up the process of some calculation a lot.
config ESP_SHA
bool "Enable Espressif SHA"
default n
help
Enable Espressif SHA1, SHA256, SHA384 & SHA512 for other components to
save code size for ESP8285(ESP8266 + 1MB flash) users.
Although this option is disable, bootloader will use it if booloader
is configured to use SHA256 to check hash.
Disabling the "assert" function at menuconfig can speed up the calculation.
config ESP_AES
bool "Enable Espressif AES"
default y
help
Enable Espressif AES ECB, CBC, CFB128, CFB8 & CRT for other components to
speed up process speed and save code size.
ESP8285 is like ESP8266 + 1MB flash, but its internal I/O connection from CPU
core to flash is DIO not QIO, which makes it read flash data slower.
So the function will speed up ESP8285 obviously.
The calculation uses "ibus_data" to speed up load data from instruction bus.
Disabling the "assert" function at menuconfig can speed up the calculation.
config ESP_MD5
bool "Enable Espressif MD5"
default y
help
Enable Espressif MD5 for other components to
speed up process speed and save code size.
ESP8285 is like ESP8266 + 1MB flash, but its internal I/O connection from CPU
core to flash is DIO not QIO, which makes it read flash data slower.
So the function will speed up ESP8285 obviously.
The calculation uses "ibus_data" to speed up load data from instruction bus.
Disabling the "assert" function at menuconfig can speed up the calculation.
config ESP_ARC4
bool "Enable Espressif ARC4"
default y
help
Enable Espressif ARC4 for other components to
speed up process speed and save code size.
ESP8285 is like ESP8266 + 1MB flash, but its internal I/O connection from CPU
core to flash is DIO not QIO, which makes it read flash data slower.
So the function will speed up ESP8285 obviously.
The calculation uses "ibus_data" to speed up load data from instruction bus.
Disabling the "assert" function at menuconfig can speed up the calculation.
endmenu # Util

11
components/util/component.mk
View File

@ -1,11 +0,0 @@
#
# Component Makefile
#
COMPONENT_ADD_INCLUDEDIRS := include
COMPONENT_SRCDIRS := src
ifndef IS_BOOTLOADER_BUILD
CFLAGS += -DUSING_IBUS_FASTER_GET
endif

17
components/util/include/crc.h
View File

@ -1,17 +0,0 @@
// Copyright 2019-2020 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.
#pragma once
#include "esp_crc.h"

1045
components/util/src/aes.c
View File

File diff suppressed because it is too large Load Diff

165
components/util/src/sha1.c
View File

@ -1,165 +0,0 @@
// 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 rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
#define blk0(i) (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \
(rol(block->l[i], 8) & 0x00FF00FF))
#define blk(i) (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ \
block->l[(i + 8) & 15] ^ block->l[(i + 2) & 15] ^ block->l[i & 15], 1))
#define R0(v,w,x,y,z,i) \
z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
w = rol(w, 30);
#define R1(v,w,x,y,z,i) \
z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
w = rol(w, 30);
#define R2(v,w,x,y,z,i) \
z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30);
#define R3(v,w,x,y,z,i) \
z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
w = rol(w, 30);
#define R4(v,w,x,y,z,i) \
z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
w=rol(w, 30);
typedef union {
uint8_t c[64];
uint32_t l[16];
} block_t;
static void esp_sha1_transform(uint32_t state[5], const uint8_t buffer[64])
{
uint32_t a, b, c, d, e;
block_t workspace;
block_t *block = &workspace;
memcpy(block, buffer, 64);
a = state[0];
b = state[1];
c = state[2];
d = state[3];
e = state[4];
R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
state[4] += e;
}
int esp_sha1_init(esp_sha1_t *ctx)
{
util_assert(ctx);
ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89;
ctx->state[2] = 0x98BADCFE;
ctx->state[3] = 0x10325476;
ctx->state[4] = 0xC3D2E1F0;
ctx->total[0] = ctx->total[1] = 0;
return 0;
}
int esp_sha1_update(esp_sha1_t *ctx, const void *src, size_t size)
{
uint32_t i, j;
const uint8_t *data = (const uint8_t *)src;
util_assert(ctx);
util_assert(src);
util_assert(size);
j = (ctx->total[0] >> 3) & 63;
if ((ctx->total[0] += size << 3) < (size << 3))
ctx->total[1]++;
ctx->total[1] += (size >> 29);
if ((j + size) > 63) {
memcpy(&ctx->buffer[j], data, (i = 64-j));
esp_sha1_transform(ctx->state, ctx->buffer);
for ( ; i + 63 < size; i += 64)
esp_sha1_transform(ctx->state, &data[i]);
j = 0;
} else
i = 0;
memcpy(&ctx->buffer[j], &data[i], size - i);
return 0;
}
int esp_sha1_finish(esp_sha1_t *ctx, void *dest)
{
uint32_t i;
uint32_t index;
uint8_t finalcount[8];
uint8_t *digest = (uint8_t *)dest;
util_assert(ctx);
util_assert(dest);
for (i = 0; i < 8; i++)
finalcount[i] = (uint8_t)((ctx->total[(i >= 4 ? 0 : 1)] >> ((3-(i & 3)) * 8) ) & 255);
index = 0x80;
esp_sha1_update(ctx, (uint8_t *)&index, 1);
while ((ctx->total[0] & 504) != 448) {
index = 0;
esp_sha1_update(ctx, (uint8_t *)&index, 1);
}
esp_sha1_update(ctx, finalcount, 8);
for (i = 0; i < 20; i++)
digest[i] = (uint8_t)((ctx->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
return 0;
}

252
components/util/src/sha256.c
View File

@ -1,252 +0,0 @@
// 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 ESP_GET_BE32(a) ((((uint32_t) (a)[0]) << 24) | (((uint32_t) (a)[1]) << 16) | \
(((uint32_t) (a)[2]) << 8) | ((uint32_t) (a)[3]))
#define ESP_PUT_BE64(a, val) \
do { \
(a)[0] = (uint8_t) (((uint64_t) (val)) >> 56); \
(a)[1] = (uint8_t) (((uint64_t) (val)) >> 48); \
(a)[2] = (uint8_t) (((uint64_t) (val)) >> 40); \
(a)[3] = (uint8_t) (((uint64_t) (val)) >> 32); \
(a)[4] = (uint8_t) (((uint64_t) (val)) >> 24); \
(a)[5] = (uint8_t) (((uint64_t) (val)) >> 16); \
(a)[6] = (uint8_t) (((uint64_t) (val)) >> 8); \
(a)[7] = (uint8_t) (((uint64_t) (val)) & 0xff); \
} while (0)
#define ESP_PUT_BE32(a, val) \
do { \
(a)[0] = (uint8_t) ((((uint32_t) (val)) >> 24) & 0xff); \
(a)[1] = (uint8_t) ((((uint32_t) (val)) >> 16) & 0xff); \
(a)[2] = (uint8_t) ((((uint32_t) (val)) >> 8) & 0xff); \
(a)[3] = (uint8_t) (((uint32_t) (val)) & 0xff); \
} while (0)
#define RORc(x, y) \
( ((((uint32_t) (x) & 0xFFFFFFFFUL) >> (uint32_t) ((y) & 31)) | \
((uint32_t) (x) << (uint32_t) (32 - ((y) & 31)))) & 0xFFFFFFFFUL)
#define Ch(x,y,z) (z ^ (x & (y ^ z)))
#define Maj(x,y,z) (((x | y) & z) | (x & y))
#define S(x, n) RORc((x), (n))
#define R(x, n) (((x)&0xFFFFFFFFUL)>>(n))
#define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22))
#define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25))
#define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3))
#define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10))
#ifndef MIN
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#endif
#define RND(a,b,c,d,e,f,g,h,i) \
t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \
t1 = Sigma0(a) + Maj(a, b, c); \
d += t0; \
h = t0 + t1;
static const uint32_t K[64] = {
0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, 0x3956c25bUL,
0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, 0xd807aa98UL, 0x12835b01UL,
0x243185beUL, 0x550c7dc3UL, 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL,
0xc19bf174UL, 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, 0x983e5152UL,
0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, 0xc6e00bf3UL, 0xd5a79147UL,
0x06ca6351UL, 0x14292967UL, 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL,
0x53380d13UL, 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, 0xd192e819UL,
0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 0x19a4c116UL, 0x1e376c08UL,
0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL,
0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
};
static void esp_sha256_transform(esp_sha256_t *ctx, const uint8_t *buf)
{
uint32_t S[8], W[64], t0, t1;
uint32_t t;
int i;
for (i = 0; i < 8; i++)
S[i] = ctx->state[i];
for (i = 0; i < 16; i++)
W[i] = ESP_GET_BE32(buf + (4 * i));
for (i = 16; i < 64; i++)
W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
for (i = 0; i < 64; ++i) {
RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], i);
t = S[7]; S[7] = S[6]; S[6] = S[5]; S[5] = S[4];
S[4] = S[3]; S[3] = S[2]; S[2] = S[1]; S[1] = S[0]; S[0] = t;
}
for (i = 0; i < 8; i++)
ctx->state[i] = ctx->state[i] + S[i];
}
int esp_sha256_init(esp_sha256_t *ctx)
{
util_assert(ctx);
ctx->is224 = 0;
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x6A09E667UL;
ctx->state[1] = 0xBB67AE85UL;
ctx->state[2] = 0x3C6EF372UL;
ctx->state[3] = 0xA54FF53AUL;
ctx->state[4] = 0x510E527FUL;
ctx->state[5] = 0x9B05688CUL;
ctx->state[6] = 0x1F83D9ABUL;
ctx->state[7] = 0x5BE0CD19UL;
return 0;
}
int esp_sha224_init(esp_sha224_t *ctx)
{
util_assert(ctx);
ctx->is224 = 1;
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0xC1059ED8;
ctx->state[1] = 0x367CD507;
ctx->state[2] = 0x3070DD17;
ctx->state[3] = 0xF70E5939;
ctx->state[4] = 0xFFC00B31;
ctx->state[5] = 0x68581511;
ctx->state[6] = 0x64F98FA7;
ctx->state[7] = 0xBEFA4FA4;
return 0;
}
int esp_sha256_update(esp_sha256_t *ctx, const void *src, size_t size)
{
size_t fill;
uint32_t left;
const uint8_t *input = (const uint8_t *)src;
util_assert(ctx);
util_assert(src);
util_assert(size);
left = ctx->total[0] & 0x3F;
fill = 64 - left;
ctx->total[0] += size;
ctx->total[0] &= 0xFFFFFFFF;
if (ctx->total[0] < size)
ctx->total[1]++;
if (left && size >= fill) {
memcpy(ctx->buffer + left, input, fill);
esp_sha256_transform(ctx, ctx->buffer);
input += fill;
size -= fill;
left = 0;
}
while (size >= 64) {
esp_sha256_transform(ctx, input);
input += 64;
size -= 64;
}
if (size > 0)
memcpy(ctx->buffer + left, input, size);
return 0;
}
int esp_sha224_update(esp_sha224_t *ctx, const void *src, size_t size)
{
util_assert(ctx);
util_assert(src);
util_assert(size);
return esp_sha256_update(ctx, src, size);
}
int esp_sha224_finish(esp_sha224_t *ctx, void *dest)
{
uint32_t used;
uint32_t high, low;
uint8_t *out = (uint8_t *)dest;
util_assert(ctx);
util_assert(dest);
used = ctx->total[0] & 0x3F;
ctx->buffer[used++] = 0x80;
if (used <= 56) {
memset(ctx->buffer + used, 0, 56 - used);
} else {
memset(ctx->buffer + used, 0, 64 - used);
esp_sha256_transform(ctx, ctx->buffer);
memset(ctx->buffer, 0, 56);
}
high = (ctx->total[0] >> 29) | (ctx->total[1] << 3);
low = (ctx->total[0] << 3);
ESP_PUT_BE32(ctx->buffer + 56, high);
ESP_PUT_BE32(ctx->buffer + 60, low);
esp_sha256_transform(ctx, ctx->buffer);
ESP_PUT_BE32(out + 0, ctx->state[0]);
ESP_PUT_BE32(out + 4, ctx->state[1]);
ESP_PUT_BE32(out + 8, ctx->state[2]);
ESP_PUT_BE32(out + 12, ctx->state[3]);
ESP_PUT_BE32(out + 16, ctx->state[4]);
ESP_PUT_BE32(out + 20, ctx->state[5]);
ESP_PUT_BE32(out + 24, ctx->state[6]);
if (!ctx->is224) {
ESP_PUT_BE32(out + 28, ctx->state[7]);
}
return( 0 );
}
int esp_sha256_finish(esp_sha256_t *ctx, void *dest)
{
util_assert(ctx);
util_assert(dest);
esp_sha224_finish(ctx, dest);
return 0;
}

302
components/util/src/sha512.c
View File

@ -1,302 +0,0 @@
// 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 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) \
do \
{ \
temp1 = (h) + S3(e) + F1((e),(f),(g)) + (K) + (x); \
temp2 = S2(a) + F0((a),(b),(c)); \
(d) += temp1; (h) = temp1 + temp2; \
} while( 0 )
#define GET_UINT64_BE(n,b,i) \
{ \
(n) = ( (uint64_t) (b)[(i) ] << 56 ) \
| ( (uint64_t) (b)[(i) + 1] << 48 ) \
| ( (uint64_t) (b)[(i) + 2] << 40 ) \
| ( (uint64_t) (b)[(i) + 3] << 32 ) \
| ( (uint64_t) (b)[(i) + 4] << 24 ) \
| ( (uint64_t) (b)[(i) + 5] << 16 ) \
| ( (uint64_t) (b)[(i) + 6] << 8 ) \
| ( (uint64_t) (b)[(i) + 7] ); \
}
#define PUT_UINT64_BE(n,b,i) \
{ \
(b)[(i) ] = (uint8_t) ( (n) >> 56 ); \
(b)[(i) + 1] = (uint8_t) ( (n) >> 48 ); \
(b)[(i) + 2] = (uint8_t) ( (n) >> 40 ); \
(b)[(i) + 3] = (uint8_t) ( (n) >> 32 ); \
(b)[(i) + 4] = (uint8_t) ( (n) >> 24 ); \
(b)[(i) + 5] = (uint8_t) ( (n) >> 16 ); \
(b)[(i) + 6] = (uint8_t) ( (n) >> 8 ); \
(b)[(i) + 7] = (uint8_t) ( (n) ); \
}
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)
};
static int esp_sha512_transform(esp_sha512_t *ctx, const uint8_t *data)
{
int i;
uint64_t temp1, temp2, W[80];
uint64_t A, B, C, D, E, F, G, H;
for( i = 0; i < 16; i++ ) {
GET_UINT64_BE(W[i], data, i << 3);
}
for( ; i < 80; i++ )
W[i] = S1(W[i - 2]) + W[i - 7] + S0(W[i - 15]) + W[i - 16];
A = ctx->state[0];
B = ctx->state[1];
C = ctx->state[2];
D = ctx->state[3];
E = ctx->state[4];
F = ctx->state[5];
G = ctx->state[6];
H = ctx->state[7];
i = 0;
do {
P(A, B, C, D, E, F, G, H, W[i], K[i]); i++;
P(H, A, B, C, D, E, F, G, W[i], K[i]); i++;
P(G, H, A, B, C, D, E, F, W[i], K[i]); i++;
P(F, G, H, A, B, C, D, E, W[i], K[i]); i++;
P(E, F, G, H, A, B, C, D, W[i], K[i]); i++;
P(D, E, F, G, H, A, B, C, W[i], K[i]); i++;
P(C, D, E, F, G, H, A, B, W[i], K[i]); i++;
P(B, C, D, E, F, G, H, A, W[i], K[i]); i++;
} while (i < 80);
ctx->state[0] += A;
ctx->state[1] += B;
ctx->state[2] += C;
ctx->state[3] += D;
ctx->state[4] += E;
ctx->state[5] += F;
ctx->state[6] += G;
ctx->state[7] += H;
return( 0 );
}
int esp_sha512_init(esp_sha512_t *ctx)
{
util_assert(ctx);
ctx->is384 = 0;
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = UL64(0x6A09E667F3BCC908);
ctx->state[1] = UL64(0xBB67AE8584CAA73B);
ctx->state[2] = UL64(0x3C6EF372FE94F82B);
ctx->state[3] = UL64(0xA54FF53A5F1D36F1);
ctx->state[4] = UL64(0x510E527FADE682D1);
ctx->state[5] = UL64(0x9B05688C2B3E6C1F);
ctx->state[6] = UL64(0x1F83D9ABFB41BD6B);
ctx->state[7] = UL64(0x5BE0CD19137E2179);
return 0;
}
int esp_sha384_init(esp_sha384_t *ctx)
{
util_assert(ctx);
ctx->is384 = 1;
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = UL64(0xCBBB9D5DC1059ED8);
ctx->state[1] = UL64(0x629A292A367CD507);
ctx->state[2] = UL64(0x9159015A3070DD17);
ctx->state[3] = UL64(0x152FECD8F70E5939);
ctx->state[4] = UL64(0x67332667FFC00B31);
ctx->state[5] = UL64(0x8EB44A8768581511);
ctx->state[6] = UL64(0xDB0C2E0D64F98FA7);
ctx->state[7] = UL64(0x47B5481DBEFA4FA4);
return 0;
}
int esp_sha512_update(esp_sha512_t *ctx, const void *src, size_t size)
{
size_t fill;
uint32_t left;
const uint8_t *input = (const uint8_t *)src;
util_assert(ctx);
util_assert(src);
util_assert(size);
left = (uint32_t) (ctx->total[0] & 0x7F);
fill = 128 - left;
ctx->total[0] += (uint64_t)size;
if( ctx->total[0] < (uint64_t)size)
ctx->total[1]++;
if (left && size >= fill) {
memcpy(ctx->buffer + left, input, fill);
esp_sha512_transform(ctx, ctx->buffer);
input += fill;
size -= fill;
left = 0;
}
while (size >= 128) {
esp_sha512_transform(ctx, input);
input += 128;
size -= 128;
}
if (size > 0)
memcpy((void *) (ctx->buffer + left), input, size);
return( 0 );
}
int esp_sha384_update(esp_sha384_t *ctx, const void *src, size_t size)
{
util_assert(ctx);
util_assert(src);
util_assert(size);
return esp_sha512_update(ctx, src, size);
}
int esp_sha384_finish(esp_sha384_t *ctx, void *dest)
{
uint8_t used;
uint64_t high, low;
uint8_t *output = (uint8_t *)dest;
util_assert(ctx);
util_assert(dest);
used = ctx->total[0] & 0x7F;
ctx->buffer[used++] = 0x80;
if (used <= 112)
memset(ctx->buffer + used, 0, 112 - used);
else {
memset(ctx->buffer + used, 0, 128 - used);
esp_sha512_transform(ctx, ctx->buffer);
memset(ctx->buffer, 0, 112);
}
high = (ctx->total[0] >> 61) | (ctx->total[1] << 3);
low = (ctx->total[0] << 3);
PUT_UINT64_BE(high, ctx->buffer, 112);
PUT_UINT64_BE(low, ctx->buffer, 120);
esp_sha512_transform(ctx, ctx->buffer);
PUT_UINT64_BE(ctx->state[0], output, 0);
PUT_UINT64_BE(ctx->state[1], output, 8);
PUT_UINT64_BE(ctx->state[2], output, 16);
PUT_UINT64_BE(ctx->state[3], output, 24);
PUT_UINT64_BE(ctx->state[4], output, 32);
PUT_UINT64_BE(ctx->state[5], output, 40);
if (!ctx->is384) {
PUT_UINT64_BE(ctx->state[6], output, 48);
PUT_UINT64_BE(ctx->state[7], output, 56);
}
return 0;
}
int esp_sha512_finish(esp_sha512_t *ctx, void *dest)
{
util_assert(ctx);
util_assert(dest);
esp_sha384_finish(ctx, dest);
return 0;
}

5
components/util/test/component.mk
View File

@ -1,5 +0,0 @@
#
#Component Makefile
#
COMPONENT_ADD_LDFLAGS = -Wl,--whole-archive -l$(COMPONENT_NAME) -Wl,--no-whole-archive

2
components/wpa_supplicant/CMakeLists.txt
View File

@ -1,7 +1,7 @@
set(COMPONENT_SRCDIRS "src/crypto" "src/fast_crypto" "src/wps" "src/wpa2/eap_peer" "src/wpa2/tls" "src/wpa2/utils" "port" "src")
set(COMPONENT_ADD_INCLUDEDIRS "include" "port/include")
set(COMPONENT_PRIV_REQUIRES "mbedtls" "freertos" "heap" "newlib" "util")
set(COMPONENT_PRIV_REQUIRES "mbedtls" "freertos" "heap" "newlib")
register_component()

2
examples/wifi/espnow/main/espnow_example_main.c
View File

@ -27,7 +27,7 @@
#include "esp_system.h"
#include "esp_now.h"
#include "rom/ets_sys.h"
#include "crc.h"
#include "rom/crc.h"
#include "espnow_example.h"
static const char *TAG = "espnow_example";

2
tools/cmake/build.cmake
View File

@ -154,7 +154,7 @@ function(__build_init idf_path)
endforeach()
# Set components required by all other components in the build
set(requires_common newlib freertos heap log lwip util)
set(requires_common newlib freertos heap log lwip)
idf_build_set_property(__COMPONENT_REQUIRES_COMMON "${requires_common}")
__build_get_idf_git_revision()