Merge branch 'master' into feat_two_stage_ssltls_protocol_support

Author: dirkx

CMakeLists.txt

@@ -50,12 +50,14 @@ set(CORE_SRCS
   cores/esp32/Esp.cpp
   cores/esp32/FunctionalInterrupt.cpp
   cores/esp32/HardwareSerial.cpp
+  cores/esp32/HEXBuilder.cpp
   cores/esp32/IPAddress.cpp
   cores/esp32/libb64/cdecode.c
   cores/esp32/libb64/cencode.c
   cores/esp32/main.cpp
   cores/esp32/MD5Builder.cpp
   cores/esp32/Print.cpp
+  cores/esp32/SHA1Builder.cpp
   cores/esp32/stdlib_noniso.c
   cores/esp32/Stream.cpp
   cores/esp32/StreamString.cpp

boards.txt

@@ -17897,6 +17897,178 @@ heltec_wireless_stick_lite.menu.EraseFlash.all.upload.erase_cmd=-e
 
 ##############################################################
 
+heltec_wireless_tracker.name=Heltec Wireless Tracker
+heltec_wireless_tracker.vid.0=0x303a
+heltec_wireless_tracker.pid.0=0x1001
+
+heltec_wireless_tracker.bootloader.tool=esptool_py
+heltec_wireless_tracker.bootloader.tool.default=esptool_py
+
+heltec_wireless_tracker.upload.tool=esptool_py
+heltec_wireless_tracker.upload.tool.default=esptool_py
+heltec_wireless_tracker.upload.tool.network=esp_ota
+
+heltec_wireless_tracker.upload.maximum_size=3342336
+heltec_wireless_tracker.upload.maximum_data_size=327680
+heltec_wireless_tracker.upload.flags=
+heltec_wireless_tracker.upload.extra_flags=
+heltec_wireless_tracker.upload.use_1200bps_touch=false
+heltec_wireless_tracker.upload.wait_for_upload_port=false
+
+heltec_wireless_tracker.serial.disableDTR=false
+heltec_wireless_tracker.serial.disableRTS=false
+
+heltec_wireless_tracker.build.tarch=xtensa
+heltec_wireless_tracker.build.bootloader_addr=0x0
+heltec_wireless_tracker.build.target=esp32s3
+heltec_wireless_tracker.build.mcu=esp32s3
+heltec_wireless_tracker.build.core=esp32
+heltec_wireless_tracker.build.variant=heltec_wireless_tracker
+heltec_wireless_tracker.build.board=HELTEC_WIRELESS_TRACKER
+
+heltec_wireless_tracker.build.usb_mode=1
+heltec_wireless_tracker.build.cdc_on_boot=0
+heltec_wireless_tracker.build.msc_on_boot=0
+heltec_wireless_tracker.build.dfu_on_boot=0
+heltec_wireless_tracker.build.f_cpu=240000000L
+heltec_wireless_tracker.build.flash_size=8MB
+heltec_wireless_tracker.build.flash_freq=80m
+heltec_wireless_tracker.build.flash_mode=dio
+heltec_wireless_tracker.build.boot=qio
+heltec_wireless_tracker.build.boot_freq=80m
+heltec_wireless_tracker.build.partitions=default_8MB
+heltec_wireless_tracker.build.loop_core=
+heltec_wireless_tracker.build.event_core=
+heltec_wireless_tracker.build.psram_type=qspi
+heltec_wireless_tracker.build.memory_type={build.boot}_{build.psram_type}
+
+heltec_wireless_tracker.menu.LoopCore.1=Core 1
+heltec_wireless_tracker.menu.LoopCore.1.build.loop_core=-DARDUINO_RUNNING_CORE=1
+heltec_wireless_tracker.menu.LoopCore.0=Core 0
+heltec_wireless_tracker.menu.LoopCore.0.build.loop_core=-DARDUINO_RUNNING_CORE=0
+
+heltec_wireless_tracker.menu.EventsCore.1=Core 1
+heltec_wireless_tracker.menu.EventsCore.1.build.event_core=-DARDUINO_EVENT_RUNNING_CORE=1
+heltec_wireless_tracker.menu.EventsCore.0=Core 0
+heltec_wireless_tracker.menu.EventsCore.0.build.event_core=-DARDUINO_EVENT_RUNNING_CORE=0
+
+heltec_wireless_tracker.menu.USBMode.hwcdc=Hardware CDC and JTAG
+heltec_wireless_tracker.menu.USBMode.hwcdc.build.usb_mode=1
+heltec_wireless_tracker.menu.USBMode.default=USB-OTG (TinyUSB)
+heltec_wireless_tracker.menu.USBMode.default.build.usb_mode=0
+
+heltec_wireless_tracker.menu.CDCOnBoot.default=Enabled
+heltec_wireless_tracker.menu.CDCOnBoot.default.build.cdc_on_boot=1
+heltec_wireless_tracker.menu.CDCOnBoot.cdc=Enabled
+heltec_wireless_tracker.menu.CDCOnBoot.cdc.build.cdc_on_boot=1
+
+heltec_wireless_tracker.menu.MSCOnBoot.default=Disabled
+heltec_wireless_tracker.menu.MSCOnBoot.default.build.msc_on_boot=0
+heltec_wireless_tracker.menu.MSCOnBoot.msc=Enabled (Requires USB-OTG Mode)
+heltec_wireless_tracker.menu.MSCOnBoot.msc.build.msc_on_boot=1
+
+heltec_wireless_tracker.menu.DFUOnBoot.default=Disabled
+heltec_wireless_tracker.menu.DFUOnBoot.default.build.dfu_on_boot=0
+heltec_wireless_tracker.menu.DFUOnBoot.dfu=Enabled (Requires USB-OTG Mode)
+heltec_wireless_tracker.menu.DFUOnBoot.dfu.build.dfu_on_boot=1
+
+heltec_wireless_tracker.menu.UploadMode.default=UART0 / Hardware CDC
+heltec_wireless_tracker.menu.UploadMode.default.upload.use_1200bps_touch=false
+heltec_wireless_tracker.menu.UploadMode.default.upload.wait_for_upload_port=false
+heltec_wireless_tracker.menu.UploadMode.cdc=USB-OTG CDC (TinyUSB)
+heltec_wireless_tracker.menu.UploadMode.cdc.upload.use_1200bps_touch=true
+heltec_wireless_tracker.menu.UploadMode.cdc.upload.wait_for_upload_port=true
+
+heltec_wireless_tracker.menu.CPUFreq.240=240MHz (WiFi)
+heltec_wireless_tracker.menu.CPUFreq.240.build.f_cpu=240000000L
+heltec_wireless_tracker.menu.CPUFreq.160=160MHz (WiFi)
+heltec_wireless_tracker.menu.CPUFreq.160.build.f_cpu=160000000L
+heltec_wireless_tracker.menu.CPUFreq.80=80MHz (WiFi)
+heltec_wireless_tracker.menu.CPUFreq.80.build.f_cpu=80000000L
+heltec_wireless_tracker.menu.CPUFreq.40=40MHz
+heltec_wireless_tracker.menu.CPUFreq.40.build.f_cpu=40000000L
+heltec_wireless_tracker.menu.CPUFreq.20=20MHz
+heltec_wireless_tracker.menu.CPUFreq.20.build.f_cpu=20000000L
+heltec_wireless_tracker.menu.CPUFreq.10=10MHz
+heltec_wireless_tracker.menu.CPUFreq.10.build.f_cpu=10000000L
+
+heltec_wireless_tracker.menu.UploadSpeed.921600=921600
+heltec_wireless_tracker.menu.UploadSpeed.921600.upload.speed=921600
+heltec_wireless_tracker.menu.UploadSpeed.115200=115200
+heltec_wireless_tracker.menu.UploadSpeed.115200.upload.speed=115200
+heltec_wireless_tracker.menu.UploadSpeed.256000.windows=256000
+heltec_wireless_tracker.menu.UploadSpeed.256000.upload.speed=256000
+heltec_wireless_tracker.menu.UploadSpeed.230400.windows.upload.speed=256000
+heltec_wireless_tracker.menu.UploadSpeed.230400=230400
+heltec_wireless_tracker.menu.UploadSpeed.230400.upload.speed=230400
+heltec_wireless_tracker.menu.UploadSpeed.460800.linux=460800
+heltec_wireless_tracker.menu.UploadSpeed.460800.macosx=460800
+heltec_wireless_tracker.menu.UploadSpeed.460800.upload.speed=460800
+heltec_wireless_tracker.menu.UploadSpeed.512000.windows=512000
+heltec_wireless_tracker.menu.UploadSpeed.512000.upload.speed=512000
+
+heltec_wireless_tracker.menu.DebugLevel.none=None
+heltec_wireless_tracker.menu.DebugLevel.none.build.code_debug=0
+heltec_wireless_tracker.menu.DebugLevel.error=Error
+heltec_wireless_tracker.menu.DebugLevel.error.build.code_debug=1
+heltec_wireless_tracker.menu.DebugLevel.warn=Warn
+heltec_wireless_tracker.menu.DebugLevel.warn.build.code_debug=2
+heltec_wireless_tracker.menu.DebugLevel.info=Info
+heltec_wireless_tracker.menu.DebugLevel.info.build.code_debug=3
+heltec_wireless_tracker.menu.DebugLevel.debug=Debug
+heltec_wireless_tracker.menu.DebugLevel.debug.build.code_debug=4
+heltec_wireless_tracker.menu.DebugLevel.verbose=Verbose
+heltec_wireless_tracker.menu.DebugLevel.verbose.build.code_debug=5
+
+heltec_wireless_tracker.menu.LORAWAN_REGION.0=REGION_EU868
+heltec_wireless_tracker.menu.LORAWAN_REGION.0.build.band=REGION_EU868
+heltec_wireless_tracker.menu.LORAWAN_REGION.1=REGION_EU433
+heltec_wireless_tracker.menu.LORAWAN_REGION.1.build.band=REGION_EU433
+heltec_wireless_tracker.menu.LORAWAN_REGION.2=REGION_CN470
+heltec_wireless_tracker.menu.LORAWAN_REGION.2.build.band=REGION_CN470
+heltec_wireless_tracker.menu.LORAWAN_REGION.3=REGION_US915
+heltec_wireless_tracker.menu.LORAWAN_REGION.3.build.band=REGION_US915
+heltec_wireless_tracker.menu.LORAWAN_REGION.4=REGION_AU915
+heltec_wireless_tracker.menu.LORAWAN_REGION.4.build.band=REGION_AU915
+heltec_wireless_tracker.menu.LORAWAN_REGION.5=REGION_CN779
+heltec_wireless_tracker.menu.LORAWAN_REGION.5.build.band=REGION_CN779
+heltec_wireless_tracker.menu.LORAWAN_REGION.6=REGION_AS923
+heltec_wireless_tracker.menu.LORAWAN_REGION.6.build.band=REGION_AS923
+heltec_wireless_tracker.menu.LORAWAN_REGION.7=REGION_KR920
+heltec_wireless_tracker.menu.LORAWAN_REGION.7.build.band=REGION_KR920
+heltec_wireless_tracker.menu.LORAWAN_REGION.8=REGION_IN865
+heltec_wireless_tracker.menu.LORAWAN_REGION.8.build.band=REGION_IN865
+heltec_wireless_tracker.menu.LORAWAN_REGION.9=REGION_US915_HYBRID
+heltec_wireless_tracker.menu.LORAWAN_REGION.9.build.band=REGION_US915_HYBRID
+
+heltec_wireless_tracker.menu.LoRaWanDebugLevel.0=None
+heltec_wireless_tracker.menu.LoRaWanDebugLevel.0.build.LoRaWanDebugLevel=0
+heltec_wireless_tracker.menu.LoRaWanDebugLevel.1=Freq
+heltec_wireless_tracker.menu.LoRaWanDebugLevel.1.build.LoRaWanDebugLevel=1
+heltec_wireless_tracker.menu.LoRaWanDebugLevel.2=Freq && DIO
+heltec_wireless_tracker.menu.LoRaWanDebugLevel.2.build.LoRaWanDebugLevel=2
+heltec_wireless_tracker.menu.LoRaWanDebugLevel.3=Freq && DIO && PW
+heltec_wireless_tracker.menu.LoRaWanDebugLevel.3.build.LoRaWanDebugLevel=3
+
+heltec_wireless_tracker.menu.LORAWAN_DEVEUI.0=CUSTOM
+heltec_wireless_tracker.menu.LORAWAN_DEVEUI.0.build.LORAWAN_DEVEUI_AUTO=0
+heltec_wireless_tracker.menu.LORAWAN_DEVEUI.1=Generate By ChipID
+heltec_wireless_tracker.menu.LORAWAN_DEVEUI.1.build.LORAWAN_DEVEUI_AUTO=1
+
+heltec_wireless_tracker.menu.LORAWAN_PREAMBLE_LENGTH.0=8(default)
+heltec_wireless_tracker.menu.LORAWAN_PREAMBLE_LENGTH.0.build.LORAWAN_PREAMBLE_LENGTH=8
+heltec_wireless_tracker.menu.LORAWAN_PREAMBLE_LENGTH.1=16(For M00 and M00L)
+heltec_wireless_tracker.menu.LORAWAN_PREAMBLE_LENGTH.1.build.LORAWAN_PREAMBLE_LENGTH=16
+
+heltec_wireless_tracker.build.defines=-D{build.band} -DLoRaWAN_DEBUG_LEVEL={build.LoRaWanDebugLevel} -DACTIVE_REGION=LORAMAC_{build.band} -DLORAWAN_PREAMBLE_LENGTH={build.LORAWAN_PREAMBLE_LENGTH} -DLORAWAN_DEVEUI_AUTO={build.LORAWAN_DEVEUI_AUTO} -D{build.board}
+
+heltec_wireless_tracker.menu.EraseFlash.none=Disabled
+heltec_wireless_tracker.menu.EraseFlash.none.upload.erase_cmd=
+heltec_wireless_tracker.menu.EraseFlash.all=Enabled
+heltec_wireless_tracker.menu.EraseFlash.all.upload.erase_cmd=-e
+
+##############################################################
+
 espectro32.name=ESPectro32
 
 espectro32.bootloader.tool=esptool_py
@@ -29743,3 +29915,119 @@ nano_nora.menu.USBMode.hwcdc.build.openocdscript=esp32s3-builtin.cfg
 nano_nora.menu.USBMode.hwcdc.build.debugconfig=esp32s3-arduino.json
 
 ##############################################################
+
+makergo_c3_supermini.name=MakerGO ESP32 C3 SuperMini
+makergo_c3_supermini.vid.0=0x303a
+makergo_c3_supermini.pid.0=0x1001
+
+makergo_c3_supermini.bootloader.tool=esptool_py
+makergo_c3_supermini.bootloader.tool.default=esptool_py
+
+makergo_c3_supermini.upload.tool=esptool_py
+makergo_c3_supermini.upload.tool.default=esptool_py
+makergo_c3_supermini.upload.tool.network=esp_ota
+
+makergo_c3_supermini.upload.maximum_size=1310720
+makergo_c3_supermini.upload.maximum_data_size=327680
+makergo_c3_supermini.upload.flags=
+makergo_c3_supermini.upload.extra_flags=
+makergo_c3_supermini.upload.use_1200bps_touch=false
+makergo_c3_supermini.upload.wait_for_upload_port=false
+
+makergo_c3_supermini.serial.disableDTR=true
+makergo_c3_supermini.serial.disableRTS=true
+
+makergo_c3_supermini.build.tarch=riscv32
+makergo_c3_supermini.build.target=esp
+makergo_c3_supermini.build.mcu=esp32c3
+makergo_c3_supermini.build.core=esp32
+makergo_c3_supermini.build.variant=makergo_c3_supermini
+makergo_c3_supermini.build.board=MAKERGO_C3_SUPERMINI
+makergo_c3_supermini.build.bootloader_addr=0x0
+
+makergo_c3_supermini.build.cdc_on_boot=1
+makergo_c3_supermini.build.f_cpu=160000000L
+makergo_c3_supermini.build.flash_size=4MB
+makergo_c3_supermini.build.flash_freq=80m
+makergo_c3_supermini.build.flash_mode=dio
+makergo_c3_supermini.build.boot=qio
+makergo_c3_supermini.build.partitions=default
+makergo_c3_supermini.build.defines=
+
+makergo_c3_supermini.menu.CDCOnBoot.default=Enabled
+makergo_c3_supermini.menu.CDCOnBoot.default.build.cdc_on_boot=1
+makergo_c3_supermini.menu.CDCOnBoot.dis_cdc=Disabled
+makergo_c3_supermini.menu.CDCOnBoot.dis_cdc.build.cdc_on_boot=0
+
+makergo_c3_supermini.menu.PartitionScheme.default=Default 4MB with spiffs (1.2MB APP/1.5MB SPIFFS)
+makergo_c3_supermini.menu.PartitionScheme.default.build.partitions=default
+makergo_c3_supermini.menu.PartitionScheme.defaultffat=Default 4MB with ffat (1.2MB APP/1.5MB FATFS)
+makergo_c3_supermini.menu.PartitionScheme.defaultffat.build.partitions=default_ffat
+makergo_c3_supermini.menu.PartitionScheme.no_ota=No OTA (2MB APP/2MB SPIFFS)
+makergo_c3_supermini.menu.PartitionScheme.no_ota.build.partitions=no_ota
+makergo_c3_supermini.menu.PartitionScheme.no_ota.upload.maximum_size=2097152
+makergo_c3_supermini.menu.PartitionScheme.noota_3g=No OTA (1MB APP/3MB SPIFFS)
+makergo_c3_supermini.menu.PartitionScheme.noota_3g.build.partitions=noota_3g
+makergo_c3_supermini.menu.PartitionScheme.noota_3g.upload.maximum_size=1048576
+makergo_c3_supermini.menu.PartitionScheme.noota_ffat=No OTA (2MB APP/2MB FATFS)
+makergo_c3_supermini.menu.PartitionScheme.noota_ffat.build.partitions=noota_ffat
+makergo_c3_supermini.menu.PartitionScheme.noota_ffat.upload.maximum_size=2097152
+makergo_c3_supermini.menu.PartitionScheme.noota_3gffat=No OTA (1MB APP/3MB FATFS)
+makergo_c3_supermini.menu.PartitionScheme.noota_3gffat.build.partitions=noota_3gffat
+makergo_c3_supermini.menu.PartitionScheme.noota_3gffat.upload.maximum_size=1048576
+makergo_c3_supermini.menu.PartitionScheme.huge_app=Huge APP (3MB No OTA/1MB SPIFFS)
+makergo_c3_supermini.menu.PartitionScheme.huge_app.build.partitions=huge_app
+makergo_c3_supermini.menu.PartitionScheme.huge_app.upload.maximum_size=3145728
+
+
+makergo_c3_supermini.menu.CPUFreq.160=160MHz (WiFi)
+makergo_c3_supermini.menu.CPUFreq.160.build.f_cpu=160000000L
+makergo_c3_supermini.menu.CPUFreq.80=80MHz (WiFi)
+makergo_c3_supermini.menu.CPUFreq.80.build.f_cpu=80000000L
+makergo_c3_supermini.menu.CPUFreq.40=40MHz
+makergo_c3_supermini.menu.CPUFreq.40.build.f_cpu=40000000L
+makergo_c3_supermini.menu.CPUFreq.20=20MHz
+makergo_c3_supermini.menu.CPUFreq.20.build.f_cpu=20000000L
+makergo_c3_supermini.menu.CPUFreq.10=10MHz
+makergo_c3_supermini.menu.CPUFreq.10.build.f_cpu=10000000L
+
+
+makergo_c3_supermini.menu.FlashFreq.80=80MHz
+makergo_c3_supermini.menu.FlashFreq.80.build.flash_freq=80m
+makergo_c3_supermini.menu.FlashFreq.40=40MHz
+makergo_c3_supermini.menu.FlashFreq.40.build.flash_freq=40m
+
+makergo_c3_supermini.menu.UploadSpeed.921600=921600
+makergo_c3_supermini.menu.UploadSpeed.921600.upload.speed=921600
+makergo_c3_supermini.menu.UploadSpeed.115200=115200
+makergo_c3_supermini.menu.UploadSpeed.115200.upload.speed=115200
+makergo_c3_supermini.menu.UploadSpeed.256000.windows=256000
+makergo_c3_supermini.menu.UploadSpeed.256000.upload.speed=256000
+makergo_c3_supermini.menu.UploadSpeed.230400.windows.upload.speed=256000
+makergo_c3_supermini.menu.UploadSpeed.230400=230400
+makergo_c3_supermini.menu.UploadSpeed.230400.upload.speed=230400
+makergo_c3_supermini.menu.UploadSpeed.460800.linux=460800
+makergo_c3_supermini.menu.UploadSpeed.460800.macosx=460800
+makergo_c3_supermini.menu.UploadSpeed.460800.upload.speed=460800
+makergo_c3_supermini.menu.UploadSpeed.512000.windows=512000
+makergo_c3_supermini.menu.UploadSpeed.512000.upload.speed=512000
+
+makergo_c3_supermini.menu.DebugLevel.none=None
+makergo_c3_supermini.menu.DebugLevel.none.build.code_debug=0
+makergo_c3_supermini.menu.DebugLevel.error=Error
+makergo_c3_supermini.menu.DebugLevel.error.build.code_debug=1
+makergo_c3_supermini.menu.DebugLevel.warn=Warn
+makergo_c3_supermini.menu.DebugLevel.warn.build.code_debug=2
+makergo_c3_supermini.menu.DebugLevel.info=Info
+makergo_c3_supermini.menu.DebugLevel.info.build.code_debug=3
+makergo_c3_supermini.menu.DebugLevel.debug=Debug
+makergo_c3_supermini.menu.DebugLevel.debug.build.code_debug=4
+makergo_c3_supermini.menu.DebugLevel.verbose=Verbose
+makergo_c3_supermini.menu.DebugLevel.verbose.build.code_debug=5
+
+makergo_c3_supermini.menu.EraseFlash.none=Disabled
+makergo_c3_supermini.menu.EraseFlash.none.upload.erase_cmd=
+makergo_c3_supermini.menu.EraseFlash.all=Enabled
+makergo_c3_supermini.menu.EraseFlash.all.upload.erase_cmd=-e
+
+##############################################################

cores/esp32/HEXBuilder.cpp

@@ -0,0 +1,71 @@
+/*
+  Copyright (c) 2015 Hristo Gochkov. All rights reserved.
+  This file is part of the esp32 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include <Arduino.h>
+#include <HEXBuilder.h>
+
+static uint8_t hex_char_to_byte(uint8_t c)
+{
+    return  (c >= 'a' && c <= 'f') ? (c - ((uint8_t)'a' - 0xa)) :
+            (c >= 'A' && c <= 'F') ? (c - ((uint8_t)'A' - 0xA)) :
+            (c >= '0' &&  c<= '9') ? (c - (uint8_t)'0') : 0x10; // unknown char is 16
+}
+
+size_t HEXBuilder::hex2bytes(unsigned char * out, size_t maxlen, String &in) {
+    return hex2bytes(out, maxlen, in.c_str());
+}
+
+size_t HEXBuilder::hex2bytes(unsigned char * out, size_t maxlen, const char * in) {
+    size_t len = 0;
+    for(;*in;in++) {
+        uint8_t c = hex_char_to_byte(*in);
+        // Silently skip anything unknown.
+        if (c > 15)
+            continue;
+
+        if (len & 1) {
+            if (len/2 < maxlen)
+                out[len/2] |= c;
+        } else {
+            if (len/2 < maxlen)
+                 out[len/2] = c<<4;
+        }
+        len++;
+    }
+    return (len + 1)/2;
+}
+
+size_t HEXBuilder::bytes2hex(char * out, size_t maxlen, const unsigned char * in, size_t len) {
+    for(size_t i = 0; i < len; i++) {
+        if (i*2 + 1 < maxlen) {
+            sprintf(out + (i * 2), "%02x", in[i]);
+        }
+    }
+    return len * 2 + 1;
+}
+
+String HEXBuilder::bytes2hex(const unsigned char * in, size_t len) {
+    size_t maxlen = len * 2 + 1;
+    char * out = (char *) malloc(maxlen);
+    if (!out) return String();
+    bytes2hex(out, maxlen, in, len);
+    String ret = String(out);
+    free(out);
+    return ret;
+}

cores/esp32/HEXBuilder.h

@@ -0,0 +1,34 @@
+/*
+  Copyright (c) 2015 Hristo Gochkov. All rights reserved.
+  This file is part of the esp32 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef HEXBuilder_h
+#define HEXBuilder_h
+
+#include <WString.h>
+#include <Stream.h>
+
+class HEXBuilder {
+public:
+	static size_t hex2bytes(unsigned char * out, size_t maxlen, String & in);
+	static size_t hex2bytes(unsigned char * out, size_t maxlen, const char * in);
+
+	static String bytes2hex(const unsigned char * in, size_t len);
+	static size_t bytes2hex(char * out, size_t maxlen, const unsigned char * in, size_t len);
+};
+#endif

cores/esp32/HardwareSerial.cpp

@@ -114,7 +114,7 @@ _eventTask(NULL)
 
 HardwareSerial::~HardwareSerial()
 {
-    end(true); // explicit Full UART termination
+    end(); // explicit Full UART termination
 #if !CONFIG_DISABLE_HAL_LOCKS
     if(_lock != NULL){
         vSemaphoreDelete(_lock);
@@ -329,16 +329,22 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
     // map logical pins to GPIO numbers
     rxPin = digitalPinToGPIONumber(rxPin);
     txPin = digitalPinToGPIONumber(txPin);
+    // IDF UART driver keeps Pin setting on restarting. Negative Pin number will keep it unmodified.
+    // it will detach previous UART attached pins
 
-    if(_uart) {
-        // in this case it is a begin() over a previous begin() - maybe to change baud rate
-        // thus do not disable debug output
-        end(false);  // disables IDF UART driver and UART event Task + sets _uart to NULL
+    // indicates that uartbegin() has to initilize a new IDF driver
+    if (_testUartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, _rxBufferSize, _txBufferSize, invert, rxfifo_full_thrhd)) {
+        _destroyEventTask(); // when IDF uart driver must be restarted, _eventTask must finish too
     }
 
     // IDF UART driver keeps Pin setting on restarting. Negative Pin number will keep it unmodified.
     // it will detach previous UART attached pins
     _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, _rxBufferSize, _txBufferSize, invert, rxfifo_full_thrhd);
+    if (_uart == NULL) {
+        log_e("UART driver failed to start. Please check the logs.");
+        HSERIAL_MUTEX_UNLOCK();
+        return;
+    }
     if (!baud) {
         // using baud rate as zero, forces it to try to detect the current baud rate in place
         uartStartDetectBaudrate(_uart);
@@ -348,11 +354,14 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
             yield();
         }
 
-        end(false);  // disables IDF UART driver and UART event Task + sets _uart to NULL
-
         if(detectedBaudRate) {
             delay(100); // Give some time...
             _uart = uartBegin(_uart_nr, detectedBaudRate, config, rxPin, txPin, _rxBufferSize, _txBufferSize, invert, rxfifo_full_thrhd);
+            if (_uart == NULL) {
+                log_e("UART driver failed to start. Please check the logs.");
+                HSERIAL_MUTEX_UNLOCK();
+                return;
+            }
         } else {
             log_e("Could not detect baudrate. Serial data at the port must be present within the timeout for detection to be possible");
             _uart = NULL;
@@ -389,22 +398,17 @@ void HardwareSerial::updateBaudRate(unsigned long baud)
   uartSetBaudRate(_uart, baud);
 }
 
-void HardwareSerial::end(bool fullyTerminate)
+void HardwareSerial::end()
 {
     // default Serial.end() will completely disable HardwareSerial,
     // including any tasks or debug message channel (log_x()) - but not for IDF log messages!
-    if(fullyTerminate) {
-        _onReceiveCB = NULL;
-        _onReceiveErrorCB = NULL;
-        if (uartGetDebug() == _uart_nr) {
-            uartSetDebug(0);
-        }
-        _rxFIFOFull = 0;
-        uartEnd(_uart_nr);  // fully detach all pins and delete the UART driver
-    } else {
-      // do not invalidate callbacks, detach pins, invalidate DBG output
-      uart_driver_delete(_uart_nr);
+    _onReceiveCB = NULL;
+    _onReceiveErrorCB = NULL;
+    if (uartGetDebug() == _uart_nr) {
+        uartSetDebug(0);
     }
+    _rxFIFOFull = 0;
+    uartEnd(_uart_nr);  // fully detach all pins and delete the UART driver
     _destroyEventTask(); // when IDF uart driver is deleted, _eventTask must finish too
     _uart = NULL;
 }
@@ -564,3 +568,4 @@ size_t HardwareSerial::setTxBufferSize(size_t new_size) {
     _txBufferSize = new_size;
     return _txBufferSize;
 }
+

cores/esp32/HardwareSerial.h

@@ -252,7 +252,7 @@ class HardwareSerial: public Stream
     // invert will invert RX/TX polarity
     // rxfifo_full_thrhd if the UART Flow Control Threshold in the UART FIFO (max 127)
     void begin(unsigned long baud, uint32_t config=SERIAL_8N1, int8_t rxPin=-1, int8_t txPin=-1, bool invert=false, unsigned long timeout_ms = 20000UL, uint8_t rxfifo_full_thrhd = 112);
-    void end(bool fullyTerminate = true);
+    void end(void);
     void updateBaudRate(unsigned long baud);
     int available(void);
     int availableForWrite(void);

cores/esp32/HashBuilder.h

@@ -0,0 +1,60 @@
+// Copyright 2024 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.
+
+#ifndef HashBuilder_h
+#define HashBuilder_h
+
+#include <WString.h>
+#include <Stream.h>
+
+#include "HEXBuilder.h"
+
+class HashBuilder : public HEXBuilder
+{
+public:
+    virtual ~HashBuilder() {}
+    virtual void begin() = 0;
+
+    virtual void add(uint8_t* data, size_t len) = 0;
+    virtual void add(const char* data)
+    {
+        add((uint8_t*)data, strlen(data));
+    }
+    virtual void add(char* data)
+    {
+        add((const char*)data);
+    }
+    virtual void add(String data)
+    {
+        add(data.c_str());
+    }
+
+    virtual void addHexString(const char* data) = 0;
+    virtual void addHexString(char* data)
+    {
+        addHexString((const char*)data);
+    }
+    virtual void addHexString(String data)
+    {
+        addHexString(data.c_str());
+    }
+
+    virtual bool addStream(Stream& stream, const size_t maxLen) = 0;
+    virtual void calculate() = 0;
+    virtual void getBytes(uint8_t* output) = 0;
+    virtual void getChars(char* output) = 0;
+    virtual String toString() = 0;
+};
+
+#endif

cores/esp32/MD5Builder.cpp

@@ -16,39 +16,30 @@
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
+
 #include <Arduino.h>
+#include <HEXBuilder.h>
 #include <MD5Builder.h>
 
-static uint8_t hex_char_to_byte(uint8_t c)
-{
-    return  (c >= 'a' && c <= 'f') ? (c - ((uint8_t)'a' - 0xa)) :
-            (c >= 'A' && c <= 'F') ? (c - ((uint8_t)'A' - 0xA)) :
-            (c >= '0' &&  c<= '9') ? (c - (uint8_t)'0') : 0;
-}
-
 void MD5Builder::begin(void)
 {
     memset(_buf, 0x00, ESP_ROM_MD5_DIGEST_LEN);
     esp_rom_md5_init(&_ctx);
 }
 
-void MD5Builder::add(uint8_t * data, uint16_t len)
+void MD5Builder::add(uint8_t * data, size_t len)
 {
     esp_rom_md5_update(&_ctx, data, len);
 }
 
 void MD5Builder::addHexString(const char * data)
 {
-    uint16_t i, len = strlen(data);
+    size_t len = strlen(data);
     uint8_t * tmp = (uint8_t*)malloc(len/2);
     if(tmp == NULL) {
         return;
     }
-    for(i=0; i<len; i+=2) {
-        uint8_t high = hex_char_to_byte(data[i]);
-        uint8_t low = hex_char_to_byte(data[i+1]);
-        tmp[i/2] = (high & 0x0F) << 4 | (low & 0x0F);
-    }
+    hex2bytes(tmp, len/2, data);
     add(tmp, len/2);
     free(tmp);
 }
@@ -105,9 +96,7 @@ void MD5Builder::getBytes(uint8_t * output)
 
 void MD5Builder::getChars(char * output)
 {
-    for(uint8_t i = 0; i < ESP_ROM_MD5_DIGEST_LEN; i++) {
-        sprintf(output + (i * 2), "%02x", _buf[i]);
-    }
+    bytes2hex(output, ESP_ROM_MD5_DIGEST_LEN*2+1, _buf, ESP_ROM_MD5_DIGEST_LEN);
 }
 
 String MD5Builder::toString(void)

cores/esp32/MD5Builder.h

@@ -1,7 +1,7 @@
-/* 
+/*
   Copyright (c) 2015 Hristo Gochkov. All rights reserved.
-  This file is part of the esp8266 core for Arduino environment.
- 
+  This file is part of the esp32 core for Arduino environment.
+
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
@@ -15,51 +15,39 @@
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+  Modified 10 Jan 2024 by Lucas Saavedra Vaz (Use abstract class HashBuilder)
 */
-#ifndef __ESP8266_MD5_BUILDER__
-#define __ESP8266_MD5_BUILDER__
+#ifndef MD5Builder_h
+#define MD5Builder_h
 
 #include <WString.h>
 #include <Stream.h>
 
 #include "esp_system.h"
 #include "esp_rom_md5.h"
 
-class MD5Builder
+#include "HashBuilder.h"
+
+class MD5Builder : public HashBuilder
 {
 private:
     md5_context_t _ctx;
     uint8_t _buf[ESP_ROM_MD5_DIGEST_LEN];
 public:
-    void begin(void);
-    void add(uint8_t * data, uint16_t len);
-    void add(const char * data)
-    {
-        add((uint8_t*)data, strlen(data));
-    }
-    void add(char * data)
-    {
-        add((const char*)data);
-    }
-    void add(String data)
-    {
-        add(data.c_str());
-    }
-    void addHexString(const char * data);
-    void addHexString(char * data)
-    {
-        addHexString((const char*)data);
-    }
-    void addHexString(String data)
-    {
-        addHexString(data.c_str());
-    }
-    bool addStream(Stream & stream, const size_t maxLen);
-    void calculate(void);
-    void getBytes(uint8_t * output);
-    void getChars(char * output);
-    String toString(void);
-};
+    void begin(void) override;
 
+    using HashBuilder::add;
+    void add(uint8_t * data, size_t len) override;
+
+    using HashBuilder::addHexString;
+    void addHexString(const char * data) override;
+
+    bool addStream(Stream & stream, const size_t maxLen) override;
+    void calculate(void) override;
+    void getBytes(uint8_t * output) override;
+    void getChars(char * output) override;
+    String toString(void) override;
+};
 
 #endif

cores/esp32/SHA1Builder.cpp

@@ -0,0 +1,367 @@
+/*
+ *  FIPS-180-1 compliant SHA-1 implementation
+ *
+ *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
+ *  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.
+ *
+ *  This file is part of mbed TLS (https://tls.mbed.org)
+ *  Modified for esp32 by Lucas Saavedra Vaz on 11 Jan 2024
+ */
+
+#include <Arduino.h>
+#include <SHA1Builder.h>
+
+// 32-bit integer manipulation macros (big endian)
+
+#ifndef GET_UINT32_BE
+#define GET_UINT32_BE(n,b,i)                   \
+{                                              \
+    (n) = ((uint32_t) (b)[(i)    ] << 24)      \
+        | ((uint32_t) (b)[(i) + 1] << 16)      \
+        | ((uint32_t) (b)[(i) + 2] <<  8)      \
+        | ((uint32_t) (b)[(i) + 3]      );     \
+}
+#endif
+
+#ifndef PUT_UINT32_BE
+#define PUT_UINT32_BE(n,b,i)                   \
+{                                              \
+    (b)[(i)    ] = (uint8_t) ((n) >> 24);      \
+    (b)[(i) + 1] = (uint8_t) ((n) >> 16);      \
+    (b)[(i) + 2] = (uint8_t) ((n) >>  8);      \
+    (b)[(i) + 3] = (uint8_t) ((n)      );      \
+}
+#endif
+
+// Constants
+
+static const uint8_t sha1_padding[64] =
+{
+ 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,
+    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, 0
+};
+
+// Private methods
+
+void SHA1Builder::process(const uint8_t* data)
+{
+    uint32_t temp, W[16], A, B, C, D, E;
+
+    GET_UINT32_BE(W[ 0], data,  0);
+    GET_UINT32_BE(W[ 1], data,  4);
+    GET_UINT32_BE(W[ 2], data,  8);
+    GET_UINT32_BE(W[ 3], data, 12);
+    GET_UINT32_BE(W[ 4], data, 16);
+    GET_UINT32_BE(W[ 5], data, 20);
+    GET_UINT32_BE(W[ 6], data, 24);
+    GET_UINT32_BE(W[ 7], data, 28);
+    GET_UINT32_BE(W[ 8], data, 32);
+    GET_UINT32_BE(W[ 9], data, 36);
+    GET_UINT32_BE(W[10], data, 40);
+    GET_UINT32_BE(W[11], data, 44);
+    GET_UINT32_BE(W[12], data, 48);
+    GET_UINT32_BE(W[13], data, 52);
+    GET_UINT32_BE(W[14], data, 56);
+    GET_UINT32_BE(W[15], data, 60);
+
+#define sha1_S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
+
+#define sha1_R(t)                                   \
+(                                                   \
+    temp = W[(t -  3) & 0x0F] ^ W[(t - 8) & 0x0F] ^ \
+           W[(t - 14) & 0x0F] ^ W[ t      & 0x0F],  \
+    (W[t & 0x0F] = sha1_S(temp,1))                  \
+)
+
+#define sha1_P(a,b,c,d,e,x)                                           \
+{                                                                     \
+    e += sha1_S(a,5) + sha1_F(b,c,d) + sha1_K + x; b = sha1_S(b,30);  \
+}
+
+    A = state[0];
+    B = state[1];
+    C = state[2];
+    D = state[3];
+    E = state[4];
+
+#define sha1_F(x,y,z) (z ^ (x & (y ^ z)))
+#define sha1_K 0x5A827999
+
+    sha1_P(A, B, C, D, E, W[0]);
+    sha1_P(E, A, B, C, D, W[1]);
+    sha1_P(D, E, A, B, C, W[2]);
+    sha1_P(C, D, E, A, B, W[3]);
+    sha1_P(B, C, D, E, A, W[4]);
+    sha1_P(A, B, C, D, E, W[5]);
+    sha1_P(E, A, B, C, D, W[6]);
+    sha1_P(D, E, A, B, C, W[7]);
+    sha1_P(C, D, E, A, B, W[8]);
+    sha1_P(B, C, D, E, A, W[9]);
+    sha1_P(A, B, C, D, E, W[10]);
+    sha1_P(E, A, B, C, D, W[11]);
+    sha1_P(D, E, A, B, C, W[12]);
+    sha1_P(C, D, E, A, B, W[13]);
+    sha1_P(B, C, D, E, A, W[14]);
+    sha1_P(A, B, C, D, E, W[15]);
+    sha1_P(E, A, B, C, D, sha1_R(16));
+    sha1_P(D, E, A, B, C, sha1_R(17));
+    sha1_P(C, D, E, A, B, sha1_R(18));
+    sha1_P(B, C, D, E, A, sha1_R(19));
+
+#undef sha1_K
+#undef sha1_F
+
+#define sha1_F(x,y,z) (x ^ y ^ z)
+#define sha1_K 0x6ED9EBA1
+
+    sha1_P(A, B, C, D, E, sha1_R(20));
+    sha1_P(E, A, B, C, D, sha1_R(21));
+    sha1_P(D, E, A, B, C, sha1_R(22));
+    sha1_P(C, D, E, A, B, sha1_R(23));
+    sha1_P(B, C, D, E, A, sha1_R(24));
+    sha1_P(A, B, C, D, E, sha1_R(25));
+    sha1_P(E, A, B, C, D, sha1_R(26));
+    sha1_P(D, E, A, B, C, sha1_R(27));
+    sha1_P(C, D, E, A, B, sha1_R(28));
+    sha1_P(B, C, D, E, A, sha1_R(29));
+    sha1_P(A, B, C, D, E, sha1_R(30));
+    sha1_P(E, A, B, C, D, sha1_R(31));
+    sha1_P(D, E, A, B, C, sha1_R(32));
+    sha1_P(C, D, E, A, B, sha1_R(33));
+    sha1_P(B, C, D, E, A, sha1_R(34));
+    sha1_P(A, B, C, D, E, sha1_R(35));
+    sha1_P(E, A, B, C, D, sha1_R(36));
+    sha1_P(D, E, A, B, C, sha1_R(37));
+    sha1_P(C, D, E, A, B, sha1_R(38));
+    sha1_P(B, C, D, E, A, sha1_R(39));
+
+#undef sha1_K
+#undef sha1_F
+
+#define sha1_F(x,y,z) ((x & y) | (z & (x | y)))
+#define sha1_K 0x8F1BBCDC
+
+    sha1_P(A, B, C, D, E, sha1_R(40));
+    sha1_P(E, A, B, C, D, sha1_R(41));
+    sha1_P(D, E, A, B, C, sha1_R(42));
+    sha1_P(C, D, E, A, B, sha1_R(43));
+    sha1_P(B, C, D, E, A, sha1_R(44));
+    sha1_P(A, B, C, D, E, sha1_R(45));
+    sha1_P(E, A, B, C, D, sha1_R(46));
+    sha1_P(D, E, A, B, C, sha1_R(47));
+    sha1_P(C, D, E, A, B, sha1_R(48));
+    sha1_P(B, C, D, E, A, sha1_R(49));
+    sha1_P(A, B, C, D, E, sha1_R(50));
+    sha1_P(E, A, B, C, D, sha1_R(51));
+    sha1_P(D, E, A, B, C, sha1_R(52));
+    sha1_P(C, D, E, A, B, sha1_R(53));
+    sha1_P(B, C, D, E, A, sha1_R(54));
+    sha1_P(A, B, C, D, E, sha1_R(55));
+    sha1_P(E, A, B, C, D, sha1_R(56));
+    sha1_P(D, E, A, B, C, sha1_R(57));
+    sha1_P(C, D, E, A, B, sha1_R(58));
+    sha1_P(B, C, D, E, A, sha1_R(59));
+
+#undef sha1_K
+#undef sha1_F
+
+#define sha1_F(x,y,z) (x ^ y ^ z)
+#define sha1_K 0xCA62C1D6
+
+    sha1_P(A, B, C, D, E, sha1_R(60));
+    sha1_P(E, A, B, C, D, sha1_R(61));
+    sha1_P(D, E, A, B, C, sha1_R(62));
+    sha1_P(C, D, E, A, B, sha1_R(63));
+    sha1_P(B, C, D, E, A, sha1_R(64));
+    sha1_P(A, B, C, D, E, sha1_R(65));
+    sha1_P(E, A, B, C, D, sha1_R(66));
+    sha1_P(D, E, A, B, C, sha1_R(67));
+    sha1_P(C, D, E, A, B, sha1_R(68));
+    sha1_P(B, C, D, E, A, sha1_R(69));
+    sha1_P(A, B, C, D, E, sha1_R(70));
+    sha1_P(E, A, B, C, D, sha1_R(71));
+    sha1_P(D, E, A, B, C, sha1_R(72));
+    sha1_P(C, D, E, A, B, sha1_R(73));
+    sha1_P(B, C, D, E, A, sha1_R(74));
+    sha1_P(A, B, C, D, E, sha1_R(75));
+    sha1_P(E, A, B, C, D, sha1_R(76));
+    sha1_P(D, E, A, B, C, sha1_R(77));
+    sha1_P(C, D, E, A, B, sha1_R(78));
+    sha1_P(B, C, D, E, A, sha1_R(79));
+
+#undef sha1_K
+#undef sha1_F
+
+    state[0] += A;
+    state[1] += B;
+    state[2] += C;
+    state[3] += D;
+    state[4] += E;
+}
+
+// Public methods
+
+void SHA1Builder::begin(void)
+{
+    total[0] = 0;
+    total[1] = 0;
+
+    state[0] = 0x67452301;
+    state[1] = 0xEFCDAB89;
+    state[2] = 0x98BADCFE;
+    state[3] = 0x10325476;
+    state[4] = 0xC3D2E1F0;
+
+    memset(buffer, 0x00, sizeof(buffer));
+    memset(hash, 0x00, sizeof(hash));
+}
+
+void SHA1Builder::add(uint8_t* data, size_t len)
+{
+    size_t fill;
+    uint32_t left;
+
+    if(len == 0)
+    {
+        return;
+    }
+
+    left = total[0] & 0x3F;
+    fill = 64 - left;
+
+    total[0] += (uint32_t) len;
+    total[0] &= 0xFFFFFFFF;
+
+    if(total[0] < (uint32_t) len)
+    {
+        total[1]++;
+    }
+
+    if(left && len >= fill)
+    {
+        memcpy((void *) (buffer + left), data, fill);
+        process(buffer);
+        data += fill;
+        len -= fill;
+        left = 0;
+    }
+
+    while(len >= 64)
+    {
+        process(data);
+        data += 64;
+        len -= 64;
+    }
+
+    if(len > 0) {
+        memcpy((void *) (buffer + left), data, len);
+    }
+}
+
+void SHA1Builder::addHexString(const char * data)
+{
+    uint16_t len = strlen(data);
+    uint8_t * tmp = (uint8_t*)malloc(len/2);
+    if(tmp == NULL) {
+        return;
+    }
+    hex2bytes(tmp, len/2, data);
+    add(tmp, len/2);
+    free(tmp);
+}
+
+bool SHA1Builder::addStream(Stream & stream, const size_t maxLen)
+{
+    const int buf_size = 512;
+    int maxLengthLeft = maxLen;
+    uint8_t * buf = (uint8_t*) malloc(buf_size);
+
+    if(!buf) {
+        return false;
+    }
+
+    int bytesAvailable = stream.available();
+    while((bytesAvailable > 0) && (maxLengthLeft > 0)) {
+
+        // determine number of bytes to read
+        int readBytes = bytesAvailable;
+        if(readBytes > maxLengthLeft) {
+            readBytes = maxLengthLeft ;    // read only until max_len
+        }
+        if(readBytes > buf_size) {
+            readBytes = buf_size;    // not read more the buffer can handle
+        }
+
+        // read data and check if we got something
+        int numBytesRead = stream.readBytes(buf, readBytes);
+        if(numBytesRead< 1) {
+            free(buf);
+            return false;
+        }
+
+        // Update SHA1 with buffer payload
+        add(buf, numBytesRead);
+
+        // update available number of bytes
+        maxLengthLeft -= numBytesRead;
+        bytesAvailable = stream.available();
+    }
+    free(buf);
+    return true;
+}
+
+void SHA1Builder::calculate(void)
+{
+    uint32_t last, padn;
+    uint32_t high, low;
+    uint8_t msglen[8];
+
+    high = (total[0] >> 29) | (total[1] << 3);
+    low = (total[0] << 3);
+
+    PUT_UINT32_BE(high, msglen, 0);
+    PUT_UINT32_BE(low, msglen, 4);
+
+    last = total[0] & 0x3F;
+    padn = (last < 56) ? (56 - last) : (120 - last);
+
+    add((uint8_t*)sha1_padding, padn);
+    add(msglen, 8);
+
+    PUT_UINT32_BE(state[0], hash,  0);
+    PUT_UINT32_BE(state[1], hash,  4);
+    PUT_UINT32_BE(state[2], hash,  8);
+    PUT_UINT32_BE(state[3], hash, 12);
+    PUT_UINT32_BE(state[4], hash, 16);
+}
+
+void SHA1Builder::getBytes(uint8_t * output)
+{
+    memcpy(output, hash, SHA1_HASH_SIZE);
+}
+
+void SHA1Builder::getChars(char * output)
+{
+    bytes2hex(output, SHA1_HASH_SIZE*2+1, hash, SHA1_HASH_SIZE);
+}
+
+String SHA1Builder::toString(void)
+{
+    char out[(SHA1_HASH_SIZE * 2) + 1];
+    getChars(out);
+    return String(out);
+}

cores/esp32/SHA1Builder.h

@@ -0,0 +1,51 @@
+// Copyright 2024 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.
+
+#ifndef SHA1Builder_h
+#define SHA1Builder_h
+
+#include <WString.h>
+#include <Stream.h>
+
+#include "HashBuilder.h"
+
+#define SHA1_HASH_SIZE 20
+
+class SHA1Builder : public HashBuilder
+{
+private:
+    uint32_t total[2];             /* number of bytes processed  */
+    uint32_t state[5];             /* intermediate digest state  */
+    unsigned char buffer[64];      /* data block being processed */
+    uint8_t hash[SHA1_HASH_SIZE];  /* SHA-1 result               */
+
+    void process(const uint8_t* data);
+
+public:
+    void begin() override;
+
+    using HashBuilder::add;
+    void add(uint8_t* data, size_t len) override;
+
+    using HashBuilder::addHexString;
+    void addHexString(const char* data) override;
+
+    bool addStream(Stream& stream, const size_t maxLen) override;
+    void calculate() override;
+    void getBytes(uint8_t* output) override;
+    void getChars(char* output) override;
+    String toString() override;
+};
+
+#endif

cores/esp32/esp32-hal-uart.c

@@ -1,4 +1,4 @@
-// Copyright 2015-2023 Espressif Systems (Shanghai) PTE LTD
+// Copyright 2015-2024 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.
@@ -33,19 +33,25 @@
 #include "hal/gpio_hal.h"
 #include "esp_rom_gpio.h"
 
-static int s_uart_debug_nr = 0;
+static int s_uart_debug_nr = 0;               // UART number for debug output
 
 struct uart_struct_t {
 
 #if !CONFIG_DISABLE_HAL_LOCKS
-    SemaphoreHandle_t lock;
+    SemaphoreHandle_t lock;                   // UART lock
 #endif
 
-    uint8_t num;
-    bool has_peek;
-    uint8_t peek_byte;
-    QueueHandle_t uart_event_queue;   // export it by some uartGetEventQueue() function
-    int8_t _rxPin, _txPin, _ctsPin, _rtsPin; // UART GPIOs
+    uint8_t num;                               // UART number for IDF driver API
+    bool has_peek;                             // flag to indicate that there is a peek byte pending to be read
+    uint8_t peek_byte;                         // peek byte that has been read but not consumed
+    QueueHandle_t uart_event_queue;            // export it by some uartGetEventQueue() function
+    // configuration data:: Arduino API tipical data
+    int8_t _rxPin, _txPin, _ctsPin, _rtsPin;   // UART GPIOs
+    uint32_t _baudrate, _config;               // UART baudrate and config
+    // UART ESP32 specific data
+    uint16_t _rx_buffer_size, _tx_buffer_size; // UART RX and TX buffer sizes
+    bool _inverted;                            // UART inverted signal
+    uint8_t _rxfifo_full_thrhd;                // UART RX FIFO full threshold
 };
 
 #if CONFIG_DISABLE_HAL_LOCKS
@@ -54,12 +60,12 @@ struct uart_struct_t {
 #define UART_MUTEX_UNLOCK()
 
 static uart_t _uart_bus_array[] = {
-    {0, false, 0, NULL, -1, -1, -1, -1},
+    {0, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0},
 #if SOC_UART_NUM > 1
-    {1, false, 0, NULL, -1, -1, -1, -1},
+    {1, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0},
 #endif
 #if SOC_UART_NUM > 2
-    {2, false, 0, NULL, -1, -1, -1, -1},
+    {2, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0},
 #endif
 };
 
@@ -69,12 +75,12 @@ static uart_t _uart_bus_array[] = {
 #define UART_MUTEX_UNLOCK()  if(uart->lock != NULL) xSemaphoreGive(uart->lock)
 
 static uart_t _uart_bus_array[] = {
-    {NULL, 0, false, 0, NULL, -1, -1, -1, -1},
+    {NULL, 0, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0},
 #if SOC_UART_NUM > 1
-    {NULL, 1, false, 0, NULL, -1, -1, -1, -1},
+    {NULL, 1, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0},
 #endif
 #if SOC_UART_NUM > 2
-    {NULL, 2, false, 0, NULL, -1, -1, -1, -1},
+    {NULL, 2, false, 0, NULL, -1, -1, -1, -1, 0, 0, 0, 0, false, 0},
 #endif
 };
 
@@ -97,7 +103,12 @@ static bool _uartDetachPins(uint8_t uart_num, int8_t rxPin, int8_t txPin, int8_t
     // detaches pins and sets Peripheral Manager and UART information
     if (rxPin >= 0 && uart->_rxPin == rxPin && perimanGetPinBusType(rxPin) == ESP32_BUS_TYPE_UART_RX) {
         gpio_hal_iomux_func_sel(GPIO_PIN_MUX_REG[rxPin], PIN_FUNC_GPIO);
-        esp_rom_gpio_connect_in_signal(GPIO_FUNC_IN_LOW, UART_PERIPH_SIGNAL(uart_num, SOC_UART_RX_PIN_IDX), false);
+        // avoids causing BREAK in the UART line
+        if (uart->_inverted) {
+            esp_rom_gpio_connect_in_signal(GPIO_FUNC_IN_LOW, UART_PERIPH_SIGNAL(uart_num, SOC_UART_RX_PIN_IDX), false);
+        } else {
+            esp_rom_gpio_connect_in_signal(GPIO_FUNC_IN_HIGH, UART_PERIPH_SIGNAL(uart_num, SOC_UART_RX_PIN_IDX), false);
+        }
         uart->_rxPin = -1;  // -1 means unassigned/detached
         if (!perimanClearPinBus(rxPin)) {
             retCode = false;
@@ -355,28 +366,121 @@ bool uartSetHwFlowCtrlMode(uart_t *uart, uart_hw_flowcontrol_t mode, uint8_t thr
     return retCode;
 }
 
-uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t rx_buffer_size, uint16_t tx_buffer_size, bool inverted, uint8_t rxfifo_full_thrhd)
+// This helper function will return true if a new IDF UART driver needs to be restarted and false if the current one can continue its execution
+bool _testUartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t rx_buffer_size, uint16_t tx_buffer_size, bool inverted, uint8_t rxfifo_full_thrhd)
 {
     if(uart_nr >= SOC_UART_NUM) {
-        return NULL;
+        return false;  // no new driver has to be installed
     }
     uart_t* uart = &_uart_bus_array[uart_nr];
-
+    // verify if is necessary to restart the UART driver
     if (uart_is_driver_installed(uart_nr)) {
-        uartEnd(uart_nr);
+        // some parameters can't be changed unless we end the UART driver
+        if ( uart->_rx_buffer_size != rx_buffer_size || uart->_tx_buffer_size != tx_buffer_size || uart->_inverted != inverted || uart->_rxfifo_full_thrhd != rxfifo_full_thrhd) {
+            return true;   // the current IDF UART driver must be terminated and a new driver shall be installed
+        } else {
+            return false;  // The current IDF UART driver can continue its execution
+        }
+    } else {
+        return true;       // no IDF UART driver is running and a new driver shall be installed
     }
+}
+
+uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t rx_buffer_size, uint16_t tx_buffer_size, bool inverted, uint8_t rxfifo_full_thrhd)
+{
+    if(uart_nr >= SOC_UART_NUM) {
+        log_e("UART number is invalid, please use number from 0 to %u", SOC_UART_NUM - 1);
+        return NULL;  // no new driver was installed
+    }
+    uart_t* uart = &_uart_bus_array[uart_nr];
+    log_v("UART%d baud(%ld) Mode(%x) rxPin(%d) txPin(%d)", uart_nr, baudrate, config, rxPin, txPin);
 
 #if !CONFIG_DISABLE_HAL_LOCKS
     if(uart->lock == NULL) {
         uart->lock = xSemaphoreCreateMutex();
         if(uart->lock == NULL) {
             log_e("HAL LOCK error.");
-            return NULL;
+            return NULL; // no new driver was installed
         }
     }
 #endif
-    UART_MUTEX_LOCK();
 
+    if (uart_is_driver_installed(uart_nr)) {
+        log_v("UART%d Driver already installed.", uart_nr);
+        // some parameters can't be changed unless we end the UART driver
+        if ( uart->_rx_buffer_size != rx_buffer_size || uart->_tx_buffer_size != tx_buffer_size || uart->_inverted != inverted || uart->_rxfifo_full_thrhd != rxfifo_full_thrhd) {
+            log_v("UART%d changing buffer sizes or inverted signal or rxfifo_full_thrhd. IDF driver will be restarted", uart_nr);
+            uartEnd(uart_nr);
+        } else {
+            bool retCode = true;
+            UART_MUTEX_LOCK();
+            //User may just want to change some parameters, such as baudrate, data length, parity, stop bits or pins
+            if (uart->_baudrate != baudrate) {
+                if (ESP_OK != uart_set_baudrate(uart_nr, baudrate)) {
+                    log_e("UART%d changing baudrate failed.", uart_nr);
+                    retCode = false;
+                } else {
+                    log_v("UART%d changed baudrate to %d", uart_nr, baudrate);
+                    uart->_baudrate = baudrate;
+                }   
+            }
+            uart_word_length_t data_bits = (config & 0xc) >> 2;
+            uart_parity_t parity = config & 0x3;
+            uart_stop_bits_t stop_bits = (config & 0x30) >> 4;
+            if (retCode && (uart->_config & 0xc) >> 2 != data_bits) {
+                if (ESP_OK != uart_set_word_length(uart_nr, data_bits)) {
+                    log_e("UART%d changing data length failed.", uart_nr);
+                    retCode = false;
+                } else {
+                    log_v("UART%d changed data length to %d", uart_nr, data_bits + 5);
+                }
+            }
+            if (retCode && (uart->_config & 0x3) != parity) {
+                if (ESP_OK != uart_set_parity(uart_nr, parity)) {
+                    log_e("UART%d changing parity failed.", uart_nr);
+                    retCode = false;
+                } else {
+                    log_v("UART%d changed parity to %s", uart_nr, parity == 0 ? "NONE" : parity == 2 ? "EVEN" : "ODD");
+                }                
+            }
+            if (retCode && (uart->_config & 0xc30) >> 4 != stop_bits) {
+                if (ESP_OK != uart_set_stop_bits(uart_nr, stop_bits)) {
+                    log_e("UART%d changing stop bits failed.", uart_nr);
+                    retCode = false;
+                } else {
+                    log_v("UART%d changed stop bits to %d", uart_nr, stop_bits == 3 ? 2 : 1);
+                }                
+            }
+            if (retCode) uart->_config = config;
+            if (retCode && rxPin > 0 && uart->_rxPin != rxPin) {
+                retCode &= _uartDetachPins(uart_nr, uart->_rxPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
+                retCode &= _uartAttachPins(uart_nr, rxPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
+                if (!retCode) {
+                    log_e("UART%d changing RX pin failed.", uart_nr);
+                } else {
+                    log_v("UART%d changed RX pin to %d", uart_nr, rxPin);
+                }
+            }
+            if (retCode && txPin > 0 && uart->_txPin != txPin) {
+                retCode &= _uartDetachPins(uart_nr, UART_PIN_NO_CHANGE, uart->_txPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
+                retCode &= _uartAttachPins(uart_nr, UART_PIN_NO_CHANGE, txPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
+                if (!retCode) {
+                    log_e("UART%d changing TX pin failed.", uart_nr);
+                } else {
+                    log_v("UART%d changed TX pin to %d", uart_nr, txPin);
+                }   
+            }
+            UART_MUTEX_UNLOCK();
+            if (retCode) {
+                // UART driver was already working, just return the uart_t structure, syaing that no new driver was installed
+                return uart;
+            }
+            // if we reach this point, it means that we need to restart the UART driver
+            uartEnd(uart_nr);
+        }
+    } else {
+        log_v("UART%d not installed. Starting installation", uart_nr);
+    }
     uart_config_t uart_config;
     uart_config.data_bits = (config & 0xc) >> 2;
     uart_config.parity = (config & 0x3);
@@ -386,7 +490,10 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
     uart_config.baud_rate = baudrate;
     // CLK_APB for ESP32|S2|S3|C3 -- CLK_PLL_F40M for C2 -- CLK_PLL_F48M for H2 -- CLK_PLL_F80M for C6
     uart_config.source_clk = UART_SCLK_DEFAULT;
+
+    UART_MUTEX_LOCK();
     bool retCode = ESP_OK == uart_driver_install(uart_nr, rx_buffer_size, tx_buffer_size, 20, &(uart->uart_event_queue), 0);
+
     if (retCode) retCode &= ESP_OK == uart_param_config(uart_nr, &uart_config);
 
     // Is it right or the idea is to swap rx and tx pins? 
@@ -395,19 +502,31 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
         retCode &= ESP_OK == uart_set_line_inverse(uart_nr, UART_SIGNAL_TXD_INV | UART_SIGNAL_RXD_INV);    
     }
 
+    if (retCode) {
+        uart->_baudrate = baudrate;
+        uart->_config = config;
+        uart->_inverted = inverted;
+        uart->_rxfifo_full_thrhd = rxfifo_full_thrhd;
+        uart->_rx_buffer_size = rx_buffer_size;
+        uart->_tx_buffer_size = tx_buffer_size;
+        uart->_ctsPin = -1;
+        uart->_rtsPin = -1;
+        uart->has_peek = false;
+        uart->peek_byte = 0;
+    }
     UART_MUTEX_UNLOCK();
+
     // uartSetPins detaches previous pins if new ones are used over a previous begin()
     if (retCode) retCode &= uartSetPins(uart_nr, rxPin, txPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
-
-    if (retCode) uartFlush(uart);
-    else {
+    if (!retCode) {
         uartEnd(uart_nr);
         uart = NULL;
         log_e("UART%d initialization error.", uart->num);
+    } else {
+        uartFlush(uart);
+        log_v("UART%d initialization done.", uart->num);
     }
-
-    log_v("UART%d baud(%ld) Mode(%x) rxPin(%d) txPin(%d)", uart_nr, baudrate, config, rxPin, txPin);
-    return uart;
+    return uart;  // a new driver was installed
 }
 
 // This function code is under testing - for now just keep it here
@@ -658,6 +777,7 @@ void uartSetBaudRate(uart_t* uart, uint32_t baud_rate)
     if(uart_get_sclk_freq(UART_SCLK_DEFAULT, &sclk_freq) == ESP_OK){
         uart_ll_set_baudrate(UART_LL_GET_HW(uart->num), baud_rate, sclk_freq);
     }
+    uart->_baudrate = baud_rate;
     UART_MUTEX_UNLOCK();
 }
 
@@ -1025,3 +1145,4 @@ int uart_send_msg_with_break(uint8_t uartNum, uint8_t *msg, size_t msgSize)
 }
 
 #endif /* SOC_UART_SUPPORTED */
+

cores/esp32/esp32-hal-uart.h

@@ -32,6 +32,7 @@ extern "C" {
 struct uart_struct_t;
 typedef struct uart_struct_t uart_t;
 
+bool _testUartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t rx_buffer_size, uint16_t tx_buffer_size, bool inverted, uint8_t rxfifo_full_thrhd);
 uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t rx_buffer_size, uint16_t tx_buffer_size, bool inverted, uint8_t rxfifo_full_thrhd);
 void uartEnd(uint8_t uart_num);
 

docs/en/api/preferences.rst

@@ -177,6 +177,45 @@ Arduino-esp32 Preferences API
 
    **Note** 
       * A message providing the reason for a failed call is sent to the arduino-esp32 ``log_e`` facility.
+  
+  
+``isKey``
+*************
+
+   Check if a key-value pair from the currently open namespace exists.
+   
+   .. code-block:: arduino
+   
+       bool isKey(const char * key)
+   ..
+
+   **Parameters**
+      * ``key`` (Required)
+         -  the name of the key to be checked. 
+   
+   **Returns**
+      * ``true`` if key-value pair exists; ``false`` otherwise.
+   
+   **Note** 
+      * Attempting to check a key without a namespace being open will return false.
+  
+  
+``getType``
+*************
+
+   Returns the type of a key-value pair from the currently open namespace.
+   
+   .. code-block:: arduino
+   
+       PreferenceType getType(const char * key)
+   ..
+
+   **Parameters**
+      * ``key`` (Required)
+         -  the name of the key to be checked. 
+   
+   **Returns**
+      * PreferenceType element contaning the type of the key-value pair or PT_INVALID on error.
 
 
 ``putChar, putUChar``

docs/en/esp-idf_component.rst

@@ -73,16 +73,17 @@ After the setup you can save and exit:
 - Close confirmation window [Enter] or [Space] or [Esc]
 - Quit [Q]
 
-Option 1. Using Arduino setup() and loop()
-******************************************
+As the Arduino libraries use C++ features, you will need to swap some file extensions from ``.c`` to ``.cpp``:
 
 - In main folder rename file `main.c` to `main.cpp`.
+- In main folder open file `CMakeLists.txt` and change `main.c` to `main.cpp` as described below.
 
-- In main folder open file `CMakeList.txt` and change `main.c` to `main.cpp` as described below.
+Option 1. Using Arduino setup() and loop()
+******************************************
 
-- Your main.cpp should be formatted like any other sketch.
+Your main.cpp should be formatted like any other sketch. Don't forget to include ``Arduino.h``.
 
-.. code-block:: c
+.. code-block:: cpp
 
     //file: main.cpp
     #include "Arduino.h"
@@ -102,14 +103,14 @@ Option 1. Using Arduino setup() and loop()
 Option 2. Using ESP-IDF appmain()
 *********************************
 
-In main.c or main.cpp you need to implement ``app_main()`` and call ``initArduino();`` in it.
+In main.cpp you need to implement ``app_main()`` and call ``initArduino();`` in it.
 
 Keep in mind that setup() and loop() will not be called in this case.
 Furthermore the ``app_main()`` is single execution as a normal function so if you need an infinite loop as in Arduino place it there.
 
 .. code-block:: cpp
 
-    //file: main.c or main.cpp
+    //file: main.cpp
     #include "Arduino.h"
 
     extern "C" void app_main()
@@ -141,7 +142,7 @@ Build, flash and monitor
 
   - After a successful flash, you may need to press the RST button again
 
-  - To terminate the serial monitor press [Ctrl] + [ ] ]
+  - To terminate the serial monitor press ``Ctrl`` + ``]``
 
 Logging To Serial
 -----------------
@@ -179,7 +180,7 @@ Download the library:
 
 .. code-block:: bash
 
-    cd ~/esp/esp-idf/components/arduino-esp32/
+    cd ~/esp/esp-idf/components/arduino/
     git clone --recursive git@github.com:Author/new_library.git libraries/new_library
 
 

libraries/ESP32/examples/Utilities/HEXBuilder/HEXBuilder.ino

@@ -0,0 +1,71 @@
+#include <HEXBuilder.h>
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial) { delay(10); }
+  Serial.println("\n\n\nStart.");
+
+  // Convert a HEX string like 6c6c6f20576f726c64 to a binary buffer
+  {
+    const char * out = "Hello World";
+    const char * hexin = "48656c6c6f20576f726c6400"; // As the string above is \0 terminated too
+
+    unsigned char buff[256];
+    size_t len = HEXBuilder::hex2bytes(buff, sizeof(buff), hexin);
+
+    if (len != 1 + strlen(out))
+      Serial.println("Odd - length 1 is wrong");
+
+    if (memcmp(buff,  out, len) != 0)
+      Serial.println("Odd - decode 1 went wrong");
+
+    // Safe to print this binary buffer -- as we've included a \0 in the hex sequence.
+    Serial.printf("IN: <%s>\nOUT <%s\\0>\n", hexin, buff);
+  };
+
+  {
+    String helloHEX = "48656c6c6f20576f726c64";
+    const char hello[] = "Hello World";
+
+    unsigned char buff[256];
+    size_t len = HEXBuilder::hex2bytes(buff, sizeof(buff), helloHEX);
+
+    if (len != strlen(hello))
+      Serial.println("Odd - length 2 is wrong");
+
+    if (strcmp((char *) buff,  hello) != 0)
+      Serial.println("Odd - decode 2 went wrong");
+  }
+
+  {
+    const unsigned char helloBytes[] = { 0x48, 0x56, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64 };
+    String helloHEX = "48566c6c6f20576f726c64";
+
+
+    String out = HEXBuilder::bytes2hex(helloBytes, sizeof(helloBytes));
+    if (out.length() != 2 * sizeof(helloBytes))
+      Serial.println("Odd - length 3 is wrong");
+
+    // we need to ignore case - as a hex string can be spelled in uppercase and lowercase
+    if (!out.equalsIgnoreCase(helloHEX)) {
+      Serial.println("Odd - decode 3 went wrong");
+    }
+  }
+
+  {
+    const unsigned char helloBytes[] = { 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64 };
+    const char helloHex[] = "6c6c6f20576f726c64";
+
+    char buff[256];
+    size_t len = HEXBuilder::bytes2hex(buff, sizeof(buff), helloBytes, sizeof(helloBytes));
+    if (len != 1 + 2 * sizeof(helloBytes))
+      Serial.println("Odd - length 4 is wrong");
+
+    // we need to ignore case - as a hex string can be spelled in uppercase and lowercase
+    if (strcasecmp(buff, helloHex))
+      Serial.println("Odd - decode 4 went wrong");
+  }
+  Serial.println("Done.");
+}
+
+void loop() {}

libraries/ESP32/examples/Utilities/MD5Builder/MD5Builder.ino

@@ -0,0 +1,96 @@
+#include <MD5Builder.h>
+
+// Occasionally it is useful to compare a password that the user
+// has entered to a build in string. However this means that the
+// password ends up `in the clear' in the firmware and in your
+// source code.
+//
+// MD5Builder helps you obfuscate this (it is not terribly secure, MD5
+// has been phased out as insecure eons ago) by letting you create an
+// MD5 of the data the user entered; and then compare this to an MD5
+// string that you have put in your code.
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial) { delay(10); }
+  Serial.println("\n\n\nStart.");
+
+  // Check if a password obfuscated in an MD5 actually
+  // matches the original string.
+  //
+  // echo -n "Hello World" | openssl md5
+  {
+    String md5 = "b10a8db164e0754105b7a99be72e3fe5";
+    String password = "Hello World";
+
+    MD5Builder md;
+
+    md.begin();
+    md.add(password);
+    md.calculate();
+
+    String result = md.toString();
+
+    if (!md5.equalsIgnoreCase(result))
+      Serial.println("Odd - failing MD5 on String");
+    else
+      Serial.println("OK!");
+  }
+
+  // Check that this also work if we add the password not as
+  // a normal string - but as a string with the HEX values.
+  {
+    String passwordAsHex = "48656c6c6f20576f726c64";
+    String md5 = "b10a8db164e0754105b7a99be72e3fe5";
+
+    MD5Builder md;
+
+    md.begin();
+    md.addHexString(passwordAsHex);
+    md.calculate();
+
+    String result = md.toString();
+
+    if (!md5.equalsIgnoreCase(result)) {
+      Serial.println("Odd - failing MD5 on hex string");
+      Serial.println(md5);
+      Serial.println(result);
+    }
+    else
+      Serial.println("OK!");
+
+  }
+
+  // Check that this also work if we add the password as
+  // an unsigned byte array.
+  {
+    uint8_t password[] = { 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64 };
+    String md5 = "b10a8db164e0754105b7a99be72e3fe5";
+    MD5Builder md;
+
+    md.begin();
+    md.add(password, sizeof(password));
+    md.calculate();
+
+    String result = md.toString();
+
+    if (!md5.equalsIgnoreCase(result))
+      Serial.println("Odd - failing MD5 on byte array");
+    else
+      Serial.println("OK!");
+
+    // And also check that we can compare this as pure, raw, bytes
+    uint8_t raw[16] = {   0xb1, 0x0a, 0x8d, 0xb1, 0x64, 0xe0, 0x75, 0x41,
+                          0x05, 0xb7, 0xa9, 0x9b, 0xe7, 0x2e, 0x3f, 0xe5
+                      };
+    uint8_t res[16];
+    md.getBytes(res);
+    if (memcmp(raw, res, 16))
+      Serial.println("Odd - failing MD5 on byte array when compared as bytes");
+    else
+      Serial.println("OK!");
+
+  }
+}
+
+void loop() {}

libraries/ESP32/examples/Utilities/SHA1Builder/SHA1Builder.ino

@@ -0,0 +1,97 @@
+#include <SHA1Builder.h>
+
+// Occasionally it is useful to compare a password that the user
+// has entered to a build in string. However this means that the
+// password ends up `in the clear' in the firmware and in your
+// source code.
+//
+// SHA1Builder helps you obfuscate this (This is not much more secure.
+// SHA1 is past its retirement age and long obsolte/insecure, but it helps
+// a little) by letting you create an (unsalted!) SHA1 of the data the
+// user entered; and then compare this to an SHA1 string that you have put
+// in your code.
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial) { delay(10); }
+  Serial.println("\n\n\nStart.");
+
+  // Check if a password obfuscated in an SHA1 actually
+  // matches the original string.
+  //
+  // echo -n "Hello World" | openssl sha1
+  {
+    String sha1_str = "0a4d55a8d778e5022fab701977c5d840bbc486d0";
+    String password = "Hello World";
+
+    SHA1Builder sha;
+
+    sha.begin();
+    sha.add(password);
+    sha.calculate();
+
+    String result = sha.toString();
+
+    if (!sha1_str.equalsIgnoreCase(result))
+      Serial.println("Odd - failing SHA1 on String");
+    else
+      Serial.println("OK!");
+  }
+
+  // Check that this also work if we add the password not as
+  // a normal string - but as a string with the HEX values.
+  {
+    String passwordAsHex = "48656c6c6f20576f726c64";
+    String sha1_str = "0a4d55a8d778e5022fab701977c5d840bbc486d0";
+
+    SHA1Builder sha;
+
+    sha.begin();
+    sha.addHexString(passwordAsHex);
+    sha.calculate();
+
+    String result = sha.toString();
+
+    if (!sha1_str.equalsIgnoreCase(result)) {
+      Serial.println("Odd - failing SHA1 on hex string");
+      Serial.println(sha1_str);
+      Serial.println(result);
+    }
+    else
+      Serial.println("OK!");
+
+  }
+
+  // Check that this also work if we add the password as
+  // an unsigned byte array.
+  {
+    uint8_t password[] = { 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64 };
+    String sha1_str = "0a4d55a8d778e5022fab701977c5d840bbc486d0";
+    SHA1Builder sha;
+
+    sha.begin();
+    sha.add(password, sizeof(password));
+    sha.calculate();
+
+    String result = sha.toString();
+
+    if (!sha1_str.equalsIgnoreCase(result))
+      Serial.println("Odd - failing SHA1 on byte array");
+    else
+      Serial.println("OK!");
+
+    // And also check that we can compare this as pure, raw, bytes
+    uint8_t raw[20] = {   0x0a, 0x4d, 0x55, 0xa8, 0xd7, 0x78, 0xe5, 0x02, 0x2f, 0xab,
+                          0x70, 0x19, 0x77, 0xc5, 0xd8, 0x40, 0xbb, 0xc4, 0x86, 0xd0
+                      };
+    uint8_t res[20];
+    sha.getBytes(res);
+    if (memcmp(raw, res, 20))
+      Serial.println("Odd - failing SHA1 on byte array when compared as bytes");
+    else
+      Serial.println("OK!");
+
+  }
+}
+
+void loop() {}

libraries/WebServer/examples/HttpAuthCallback/.skip.esp32h2

@@ -0,0 +1,64 @@
+#include <WiFi.h>
+#include <ESPmDNS.h>
+#include <ArduinoOTA.h>
+#include <WebServer.h>
+
+const char* ssid = "........";
+const char* password = "........";
+
+WebServer server(80);
+
+typedef struct credentials_t {
+  String username;
+  String password;
+} credentials_t;
+
+credentials_t passwdfile[] = {
+  {  "admin",  "esp32" },
+  {  "fred",  "41234123" },
+  {  "charlie",  "sdfsd" },
+  {  "alice",  "vambdnkuhj" },
+  {  "bob",  "svcdbjhws12" },
+};
+const size_t N_CREDENTIALS = sizeof(passwdfile) / sizeof(credentials_t);
+
+String * credentialsHandler(HTTPAuthMethod mode, String username, String params[])
+{
+  for (int i = 0; i < N_CREDENTIALS; i++) {
+    if (username == passwdfile[i].username)
+      return new String(passwdfile[i].password);
+  }
+  return NULL;
+}
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial) { delay(10); }
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.println("WiFi Connect Failed! Rebooting...");
+    delay(1000);
+    ESP.restart();
+  }
+  ArduinoOTA.begin();
+
+  server.on("/", []() {
+    if (!server.authenticate(&credentialsHandler)) {
+      server.requestAuthentication();
+      return;
+    }
+    server.send(200, "text/plain", "Login OK");
+  });
+  server.begin();
+
+  Serial.print("Open http://");
+  Serial.print(WiFi.localIP());
+  Serial.println("/ in your browser to see it working");
+}
+
+void loop() {
+  ArduinoOTA.handle();
+  server.handleClient();
+  delay(2);//allow the cpu to switch to other tasks
+}

libraries/WebServer/examples/HttpAuthCallback/HttpAuthCallback.ino

@@ -0,0 +1,67 @@
+#include <WiFi.h>
+#include <ESPmDNS.h>
+#include <ArduinoOTA.h>
+#include <WebServer.h>
+
+const char* ssid = "........";
+const char* password = "........";
+
+WebServer server(80);
+
+typedef struct credentials_t {
+  char * username;
+  char * password;
+} credentials_t;
+
+credentials_t passwdfile[] = {
+  {  "admin",  "esp32" },
+  {  "fred",  "41234123" },
+  {  "charlie",  "sdfsd" },
+  {  "alice",  "vambdnkuhj" },
+  {  "bob",  "svcdbjhws12" },
+  { NULL, NULL }
+};
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial) { delay(10); }
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.println("WiFi Connect Failed! Rebooting...");
+    delay(1000);
+    ESP.restart();
+  }
+  ArduinoOTA.begin();
+
+  server.on("/", []() {
+    if (!server.authenticate([](HTTPAuthMethod mode, String username, String params[]) -> String * {
+      // Scan the password list for the username and return the password if
+      // we find the username.
+      //
+      for (credentials_t * entry = passwdfile; entry->username; entry++) {
+        if (username == entry->username) {
+          return new String(entry->password);
+        };
+      };
+      // we've not found the user in the list.
+      return NULL;
+    }))
+    {
+      server.requestAuthentication();
+      return;
+    }
+    server.send(200, "text/plain", "Login OK");
+  });
+  server.begin();
+
+  Serial.print("Open http://");
+  Serial.print(WiFi.localIP());
+  Serial.println("/ in your browser to see it working");
+}
+
+void loop() {
+  ArduinoOTA.handle();
+  server.handleClient();
+  delay(2);//allow the cpu to switch to other tasks
+}

libraries/WebServer/examples/HttpAuthCallbackInline/.skip.esp32h2

@@ -0,0 +1,72 @@
+#include <WiFi.h>
+#include <ESPmDNS.h>
+#include <ArduinoOTA.h>
+#include <WebServer.h>
+
+// Rather than specify the password as plaintext; we
+// provide it as an (unsalted!) SHA1 hash. This is not
+// much more secure (SHA1 is past its retirement age,
+// and long obsolte/insecure) - but it helps a little.
+
+const char* ssid = "........";
+const char* password = "........";
+
+WebServer server(80);
+
+// Passwords as plaintext - human readable and easily visible in
+// the sourcecode and in the firmware/binary.
+const char* www_username = "admin";
+const char* www_password = "esp32";
+
+// The sha1 of 'esp32' (without the trailing \0) expressed as 20
+// bytes of hex. Created by for example 'echo -n esp32 | openssl sha1'
+// or http://www.sha1-online.com.
+const char* www_username_hex = "hexadmin";
+const char* www_password_hex = "8cb124f8c277c16ec0b2ee00569fd151a08e342b";
+
+// The same; but now expressed as a base64 string (e.g. as commonly used
+// by webservers). Created by ` echo -n esp32 | openssl sha1 -binary | openssl base64`
+const char* www_username_base64 = "base64admin";
+const char* www_password_base64 = "jLEk+MJ3wW7Asu4AVp/RUaCONCs=";
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial) { delay(10); }
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.println("WiFi Connect Failed! Rebooting...");
+    delay(1000);
+    ESP.restart();
+  }
+  ArduinoOTA.begin();
+
+  server.on("/", []() {
+    if (server.authenticate(www_username, www_password)) {
+      server.send(200, "text/plain", "Login against cleartext password OK");
+      return;
+    }
+    if (server.authenticateBasicSHA1(www_username_hex, www_password_hex)) {
+      server.send(200, "text/plain", "Login against HEX of the SHA1 of the password OK");
+      return;
+    }
+    if (server.authenticateBasicSHA1(www_username_base64, www_password_base64)) {
+      server.send(200, "text/plain", "Login against Base64 of the SHA1 of the password OK");
+      return;
+    }
+    Serial.println("No/failed authentication");
+    return server.requestAuthentication();
+  });
+
+  server.begin();
+
+  Serial.print("Open http://");
+  Serial.print(WiFi.localIP());
+  Serial.println("/ in your browser to see it working");
+}
+
+void loop() {
+  ArduinoOTA.handle();
+  server.handleClient();
+  delay(2);//allow the cpu to switch to other tasks
+}

libraries/WebServer/examples/HttpAuthCallbackInline/HttpAuthCallbackInline.ino

@@ -0,0 +1,117 @@
+#include <WiFi.h>
+#include <ESPmDNS.h>
+#include <ArduinoOTA.h>
+#include <WebServer.h>
+#include <SHA1Builder.h>
+
+// We have two options - we either come in with a bearer
+// token - i.e. a special header or API token; or we
+// get a normal HTTP style basic auth prompt.
+//
+// To do a bearer fetch - use something like Swagger or with curl:
+//
+//    curl https://myesp.com/  -H "Authorization: Bearer SecritToken"
+//
+// We avoid hardcoding this "SecritToken" into the code by
+// using a SHA1 instead (which is not paricularly secure).
+
+// Create the secret token SHA1 with:
+//        echo -n SecritToken | openssl sha1
+
+String secret_token_hex = "d2cce6b472959484a21c3194080c609b8a2c910b";
+
+// Wifi credentials
+
+const char* ssid = "........";
+const char* password = "........";
+
+WebServer server(80);
+
+// Rather than specify the admin password as plaintext; we
+// provide it as an (unsalted!) SHA1 hash. This is not
+// much more secure (SHA1 is past its retirement age,
+// and long obsolte/insecure) - but it helps a little.
+
+// The sha1 of 'esp32' (without the trailing \0) expressed as 20
+// bytes of hex. Created by for example 'echo -n esp32 | openssl sha1'
+// or http://www.sha1-online.com.
+const char* www_username_hex = "admin";
+const char* www_password_hex = "8cb124f8c277c16ec0b2ee00569fd151a08e342b";
+
+static unsigned char _bearer[20];
+
+String* check_bearer_or_auth(HTTPAuthMethod mode, String authReq, String params[]) {
+  // we expect authReq to be "bearer some-secret"
+  String lcAuthReq = authReq;
+  lcAuthReq.toLowerCase();
+  if (mode == OTHER_AUTH && (lcAuthReq.startsWith("bearer "))) {
+    String secret = authReq.substring(7);
+    secret.trim();
+
+    uint8_t sha1[20];
+    SHA1Builder sha_builder;
+
+    sha_builder.begin();
+    sha_builder.add((uint8_t*) secret.c_str(), secret.length());
+    sha_builder.calculate();
+    sha_builder.getBytes(sha1);
+
+    if (memcmp(_bearer, sha1, sizeof(_bearer)) == 0) {
+      Serial.println("Bearer token matches");
+      return new String("anything non null");
+    } else {
+      Serial.println("Bearer token does not match");
+    }
+  } else if (mode == BASIC_AUTH) {
+    bool ret = server.authenticateBasicSHA1(www_username_hex, www_password_hex);
+    if (ret) {
+      Serial.println("Basic auth succeeded");
+      return new String(params[0]);
+    } else {
+      Serial.println("Basic auth failed");
+    }
+  }
+
+  // No auth found
+  return NULL;
+};
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial) { delay(10); }
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.println("WiFi Connect Failed! Rebooting...");
+    delay(1000);
+    ESP.restart();
+  }
+  ArduinoOTA.begin();
+
+  // Convert token to a convenient binary representation.
+  size_t len = HEXBuilder::hex2bytes(_bearer, sizeof(_bearer), secret_token_hex);
+  if (len != 20)
+    Serial.println("Bearer token does not look like a valid SHA1 hex string ?!");
+
+  server.on("/", []() {
+    if (!server.authenticate(&check_bearer_or_auth)) {
+      Serial.println("No/failed authentication");
+      return server.requestAuthentication();
+    }
+    Serial.println("Authentication succeeded");
+    server.send(200, "text/plain", "Login OK");
+    return;
+  });
+
+  server.begin();
+
+  Serial.print("Open http://");
+  Serial.print(WiFi.localIP());
+  Serial.println("/ in your browser to see it working");
+}
+
+void loop() {
+  ArduinoOTA.handle();
+  server.handleClient();
+  delay(2);//allow the cpu to switch to other tasks
+}

libraries/WebServer/examples/HttpBasicAuthSHA1/.skip.esp32h2

@@ -23,6 +23,7 @@
 
 #include <Arduino.h>
 #include <esp32-hal-log.h>
+#include <libb64/cdecode.h>
 #include <libb64/cencode.h>
 #include "esp_random.h"
 #include "WiFiServer.h"
@@ -31,7 +32,8 @@
 #include "FS.h"
 #include "detail/RequestHandlersImpl.h"
 #include "MD5Builder.h"
-
+#include "SHA1Builder.h"
+#include "base64.h"
 
 static const char AUTHORIZATION_HEADER[] = "Authorization";
 static const char qop_auth[] PROGMEM = "qop=auth";
@@ -40,7 +42,6 @@ static const char WWW_Authenticate[] = "WWW-Authenticate";
 static const char Content_Length[] = "Content-Length";
 static const char ETAG_HEADER[] = "If-None-Match";
 
-
 WebServer::WebServer(IPAddress addr, int port)
 : _corsEnabled(false)
 , _server(addr, port)
@@ -128,91 +129,185 @@ static String md5str(String &in){
   return md5.toString();
 }
 
-bool WebServer::authenticate(const char * username, const char * password){
-  if(hasHeader(FPSTR(AUTHORIZATION_HEADER))) {
-    String authReq = header(FPSTR(AUTHORIZATION_HEADER));
-    if(authReq.startsWith(F("Basic"))){
-      authReq = authReq.substring(6);
-      authReq.trim();
-      char toencodeLen = strlen(username)+strlen(password)+1;
-      char *toencode = (char *)malloc(toencodeLen + 1);
-      if(toencode == NULL){
-        authReq = "";
-        return false;
-      }
-      char *encoded = (char *)malloc(base64_encode_expected_len(toencodeLen)+1);
-      if(encoded == NULL){
-        authReq = "";
-        free(toencode);
-        return false;
-      }
-      sprintf(toencode, "%s:%s", username, password);
-      if(base64_encode_chars(toencode, toencodeLen, encoded) > 0 && authReq.equalsConstantTime(encoded)) {
-        authReq = "";
-        free(toencode);
-        free(encoded);
-        return true;
-      }
-      free(toencode);
-      free(encoded);;
-    } else if(authReq.startsWith(F("Digest"))) {
-      authReq = authReq.substring(7);
-      log_v("%s", authReq.c_str());
-      String _username = _extractParam(authReq,F("username=\""),'\"');
-      if(!_username.length() || _username != String(username)) {
-        authReq = "";
-        return false;
-      }
-      // extracting required parameters for RFC 2069 simpler Digest
-      String _realm    = _extractParam(authReq, F("realm=\""),'\"');
-      String _nonce    = _extractParam(authReq, F("nonce=\""),'\"');
-      String _uri      = _extractParam(authReq, F("uri=\""),'\"');
-      String _response = _extractParam(authReq, F("response=\""),'\"');
-      String _opaque   = _extractParam(authReq, F("opaque=\""),'\"');
-
-      if((!_realm.length()) || (!_nonce.length()) || (!_uri.length()) || (!_response.length()) || (!_opaque.length())) {
-        authReq = "";
-        return false;
-      }
-      if((_opaque != _sopaque) || (_nonce != _snonce) || (_realm != _srealm)) {
-        authReq = "";
-        return false;
-      }
-      // parameters for the RFC 2617 newer Digest
-      String _nc,_cnonce;
-      if(authReq.indexOf(FPSTR(qop_auth)) != -1 || authReq.indexOf(FPSTR(qop_auth_quoted)) != -1) {
-        _nc = _extractParam(authReq, F("nc="), ',');
-        _cnonce = _extractParam(authReq, F("cnonce=\""),'\"');
-      }
-      String _H1 = md5str(String(username) + ':' + _realm + ':' + String(password));
-      log_v("Hash of user:realm:pass=%s", _H1.c_str());
-      String _H2 = "";
-      if(_currentMethod == HTTP_GET){
-          _H2 = md5str(String(F("GET:")) + _uri);
-      }else if(_currentMethod == HTTP_POST){
-          _H2 = md5str(String(F("POST:")) + _uri);
-      }else if(_currentMethod == HTTP_PUT){
-          _H2 = md5str(String(F("PUT:")) + _uri);
-      }else if(_currentMethod == HTTP_DELETE){
-          _H2 = md5str(String(F("DELETE:")) + _uri);
-      }else{
-          _H2 = md5str(String(F("GET:")) + _uri);
-      }
-      log_v("Hash of GET:uri=%s", _H2.c_str());
-      String _responsecheck = "";
-      if(authReq.indexOf(FPSTR(qop_auth)) != -1 || authReq.indexOf(FPSTR(qop_auth_quoted)) != -1) {
-          _responsecheck = md5str(_H1 + ':' + _nonce + ':' + _nc + ':' + _cnonce + F(":auth:") + _H2);
-      } else {
-          _responsecheck = md5str(_H1 + ':' + _nonce + ':' + _H2);
-      }
-      log_v("The Proper response=%s", _responsecheck.c_str());
-      if(_response == _responsecheck){
+bool WebServer::authenticateBasicSHA1(const char * _username, const char * _sha1Base64orHex) {
+  return WebServer::authenticate([_username,_sha1Base64orHex](HTTPAuthMethod mode, String username, String params[])->String * {
+    // rather than work on a password to compare with; we take the sha1 of the
+    // password received over the wire and compare that to the base64 encoded
+    // sha1 passed as _sha1base64. That way there is no need to have a
+    // plaintext password in the code/binary (though note that SHA1 is well
+    // past its retirement age). When that matches - we `cheat' by returning
+    // the password we got in the first place; so the normal BasicAuth
+    // can be completed. Note that this cannot work for a digest auth -
+    // as there the password in the clear is part of the calculation.
+
+    if (params == nullptr) {
+      log_e("Something went wrong. params is NULL");
+      return NULL;
+    }
+
+    uint8_t sha1[20];
+    char sha1calc[48]; // large enough for base64 and Hex represenation
+    String ret;
+    SHA1Builder sha_builder;
+    base64 b64;
+
+    log_v("Trying to authenticate user %s using SHA1.", username.c_str());
+    sha_builder.begin();
+    sha_builder.add((uint8_t*) params[0].c_str(), params[0].length());
+    sha_builder.calculate();
+    sha_builder.getBytes(sha1);
+
+    // we can either decode _sha1base64orHex and then compare the 20 bytes;
+    // or encode the sha we calculated. We pick the latter as encoding of a
+    // fixed array of 20 bytes is safer than operating on something external.
+    if (strlen(_sha1Base64orHex) == 20 * 2) { // 2 chars per byte
+      sha_builder.bytes2hex(sha1calc, sizeof(sha1calc), sha1, sizeof(sha1));
+      log_v("Calculated SHA1 in hex: %s", sha1calc);
+    } else {
+      ret = b64.encode(sha1, sizeof(sha1));
+      ret.toCharArray(sha1calc, sizeof(sha1calc));
+      log_v("Calculated SHA1 in base64: %s", sha1calc);
+    }
+
+    return ((username.equalsConstantTime(_username)) &&
+            (String((char*)sha1calc).equalsConstantTime(_sha1Base64orHex)) &&
+            (mode == BASIC_AUTH) /* to keep things somewhat time constant. */
+            ) ? new String(params[0]) : NULL;
+  });
+}
+
+bool WebServer::authenticate(const char * _username, const char * _password) {
+  return WebServer::authenticate([_username,_password](HTTPAuthMethod mode, String username, String params[])->String * {
+    return username.equalsConstantTime(_username) ? new String(_password) : NULL;
+  });
+}
+
+bool WebServer::authenticate(THandlerFunctionAuthCheck fn) {
+  if (!hasHeader(FPSTR(AUTHORIZATION_HEADER))) {
+    return false;
+  }
+
+  String authReq = header(FPSTR(AUTHORIZATION_HEADER));
+  if (authReq.startsWith(AuthTypeBasic)) {
+    log_v("Trying to authenticate using Basic Auth");
+    bool ret = false;
+
+    authReq = authReq.substring(6); // length of AuthTypeBasic including the space at the end.
+    authReq.trim();
+
+    /* base64 encoded string is always shorter (or equal) in length */
+    char* decoded = (authReq.length() < HTTP_MAX_BASIC_AUTH_LEN) ? new char[authReq.length()] : NULL;
+    if (decoded) {
+      char* p;
+      if (base64_decode_chars(authReq.c_str(), authReq.length(), decoded) && (p = index(decoded, ':')) && p) {
         authReq = "";
-        return true;
+        /* Note: rfc7617 guarantees that there will not be an escaped colon in the username itself.
+         * Note:  base64_decode_chars() guarantees a terminating \0
+         */
+        *p = '\0';
+        char * _username = decoded, * _password = p + 1;
+        String params[] = {
+          _password,
+          _srealm
+        };
+        String* password = fn(BASIC_AUTH, _username, params);
+
+        if (password) {
+          ret = password->equalsConstantTime(_password);
+          // we're more concerned about the password; as the attacker already
+          // knows the _pasword. Arduino's string handling is simple; it reallocs
+          // even when smaller; so a memset is enough (no capacity/size).
+          memset((void *)password->c_str(), 0, password->length());
+          delete password;
+        }
       }
+      delete[] decoded;
+    }
+    authReq = "";
+    log_v("Authentication %s", ret ? "Success" : "Failed");
+    return ret;
+  } else if (authReq.startsWith(AuthTypeDigest)) {
+    log_v("Trying to authenticate using Digest Auth");
+    authReq = authReq.substring(7);
+    log_v("%s", authReq.c_str());
+
+    // extracting required parameters for RFC 2069 simpler Digest
+    String _username = _extractParam(authReq, F("username=\""), '\"');
+    String _realm = _extractParam(authReq, F("realm=\""), '\"');
+    String _uri = _extractParam(authReq, F("uri=\""), '\"');
+    if (!_username.length())
+      goto exf;
+
+    String params[] = {
+      _realm,
+      _uri
+    };
+    String* password = fn(DIGEST_AUTH, _username, params);
+    if (!password)
+      goto exf;
+
+    String _H1 = md5str(String(_username) + ':' + _realm + ':' + * password);
+    // we're extra concerned; as digest request us to know the password
+    // in the clear.
+    memset((void *) password->c_str(), 0, password->length());
+    delete password;
+    _username = "";
+
+    String _nonce = _extractParam(authReq, F("nonce=\""), '\"');
+    String _response = _extractParam(authReq, F("response=\""), '\"');
+    String _opaque = _extractParam(authReq, F("opaque=\""), '\"');
+
+    if ((!_realm.length()) || (!_nonce.length()) || (!_uri.length()) || (!_response.length()) || (!_opaque.length()))
+      goto exf;
+
+    if ((_opaque != _sopaque) || (_nonce != _snonce) || (_realm != _srealm))
+      goto exf;
+
+    // parameters for the RFC 2617 newer Digest
+    String _nc, _cnonce;
+    if (authReq.indexOf(FPSTR(qop_auth)) != -1 || authReq.indexOf(FPSTR(qop_auth_quoted)) != -1) {
+      _nc = _extractParam(authReq, F("nc="), ',');
+      _cnonce = _extractParam(authReq, F("cnonce=\""), '\"');
+    }
+
+    log_v("Hash of user:realm:pass=%s", _H1.c_str());
+    String _H2 = "";
+    if (_currentMethod == HTTP_GET) {
+      _H2 = md5str(String(F("GET:")) + _uri);
+    } else if (_currentMethod == HTTP_POST) {
+      _H2 = md5str(String(F("POST:")) + _uri);
+    } else if (_currentMethod == HTTP_PUT) {
+      _H2 = md5str(String(F("PUT:")) + _uri);
+    } else if (_currentMethod == HTTP_DELETE) {
+      _H2 = md5str(String(F("DELETE:")) + _uri);
+    } else {
+      _H2 = md5str(String(F("GET:")) + _uri);
+    }
+    log_v("Hash of GET:uri=%s", _H2.c_str());
+    String _responsecheck = "";
+    if (authReq.indexOf(FPSTR(qop_auth)) != -1 || authReq.indexOf(FPSTR(qop_auth_quoted)) != -1) {
+      _responsecheck = md5str(_H1 + ':' + _nonce + ':' + _nc + ':' + _cnonce + F(":auth:") + _H2);
+    } else {
+      _responsecheck = md5str(_H1 + ':' + _nonce + ':' + _H2);
     }
     authReq = "";
+
+    log_v("The Proper response=%s", _responsecheck.c_str());
+    bool ret = _response == _responsecheck;
+    log_v("Authentication %s", ret ? "Success" : "Failed");
+    return ret;
+  } else if (authReq.length()) {
+    // OTHER_AUTH
+    log_v("Trying to authenticate using Other Auth, authReq=%s", authReq.c_str());
+    String* ret = fn(OTHER_AUTH, authReq, {});
+    if (ret) {
+      log_v("Authentication Success");
+      return true;
+    }
   }
+exf:
+  authReq = "";
+  log_v("Authentication Failed");
   return false;
 }
 
@@ -232,11 +327,11 @@ void WebServer::requestAuthentication(HTTPAuthMethod mode, const char* realm, co
     _srealm = String(realm);
   }
   if(mode == BASIC_AUTH) {
-    sendHeader(String(FPSTR(WWW_Authenticate)), String(F("Basic realm=\"")) + _srealm + String(F("\"")));
+    sendHeader(String(FPSTR(WWW_Authenticate)), AuthTypeBasic + String(F(" realm=\"")) + _srealm + String(F("\"")));
   } else {
     _snonce=_getRandomHexString();
     _sopaque=_getRandomHexString();
-    sendHeader(String(FPSTR(WWW_Authenticate)), String(F("Digest realm=\"")) +_srealm + String(F("\", qop=\"auth\", nonce=\"")) + _snonce + String(F("\", opaque=\"")) + _sopaque + String(F("\"")));
+    sendHeader(String(FPSTR(WWW_Authenticate)), AuthTypeDigest + String(F(" realm=\"")) +_srealm + String(F("\", qop=\"auth\", nonce=\"")) + _snonce + String(F("\", opaque=\"")) + _sopaque + String(F("\"")));
   }
   using namespace mime;
   send(401, String(FPSTR(mimeTable[html].mimeType)), authFailMsg);
@@ -411,8 +506,8 @@ void WebServer::_prepareHeader(String& response, int code, const char* content_t
     }
     if (_corsEnabled) {
         sendHeader(String(FPSTR("Access-Control-Allow-Origin")), String("*"));
-	sendHeader(String(FPSTR("Access-Control-Allow-Methods")), String("*"));
-	sendHeader(String(FPSTR("Access-Control-Allow-Headers")), String("*"));
+        sendHeader(String(FPSTR("Access-Control-Allow-Methods")), String("*"));
+        sendHeader(String(FPSTR("Access-Control-Allow-Headers")), String("*"));
     }
     sendHeader(String(F("Connection")), String(F("close")));
 
@@ -543,9 +638,9 @@ String WebServer::pathArg(unsigned int i) {
 
 String WebServer::arg(String name) {
   for (int j = 0; j < _postArgsLen; ++j) {
-	    if ( _postArgs[j].key == name )
-	      return _postArgs[j].value;
-	  }
+    if ( _postArgs[j].key == name )
+      return _postArgs[j].value;
+  }
   for (int i = 0; i < _currentArgCount; ++i) {
     if ( _currentArgs[i].key == name )
       return _currentArgs[i].value;
@@ -571,9 +666,9 @@ int WebServer::args() {
 
 bool WebServer::hasArg(String  name) {
   for (int j = 0; j < _postArgsLen; ++j) {
-	    if (_postArgs[j].key == name)
-	      return true;
-	  }
+    if (_postArgs[j].key == name)
+      return true;
+  }
   for (int i = 0; i < _currentArgCount; ++i) {
     if (_currentArgs[i].key == name)
       return true;

libraries/WebServer/examples/HttpBasicAuthSHA1/HttpBasicAuthSHA1.ino

@@ -34,7 +34,7 @@
 enum HTTPUploadStatus { UPLOAD_FILE_START, UPLOAD_FILE_WRITE, UPLOAD_FILE_END,
                         UPLOAD_FILE_ABORTED };
 enum HTTPClientStatus { HC_NONE, HC_WAIT_READ, HC_WAIT_CLOSE };
-enum HTTPAuthMethod { BASIC_AUTH, DIGEST_AUTH };
+enum HTTPAuthMethod { BASIC_AUTH, DIGEST_AUTH, OTHER_AUTH };
 
 #define HTTP_DOWNLOAD_UNIT_SIZE 1436
 
@@ -46,6 +46,7 @@ enum HTTPAuthMethod { BASIC_AUTH, DIGEST_AUTH };
 #define HTTP_MAX_POST_WAIT 5000 //ms to wait for POST data to arrive
 #define HTTP_MAX_SEND_WAIT 5000 //ms to wait for data chunk to be ACKed
 #define HTTP_MAX_CLOSE_WAIT 2000 //ms to wait for the client to close the connection
+#define HTTP_MAX_BASIC_AUTH_LEN 256 // maximum length of a basic Auth base64 encoded username:password string
 
 #define CONTENT_LENGTH_UNKNOWN ((size_t) -1)
 #define CONTENT_LENGTH_NOT_SET ((size_t) -2)
@@ -82,12 +83,41 @@ class WebServer
   virtual void close();
   void stop();
 
+  const String AuthTypeDigest = F("Digest");
+  const String AuthTypeBasic = F("Basic");
+
+  /* Callbackhandler for authentication. The extra parameters depend on the
+   * HTTPAuthMethod mode:
+   *
+   * BASIC_AUTH         enteredUsernameOrReq	contains the username entered by the user
+   *                    param[0]		          password entered (in the clear)
+   *                    param[1]		          authentication realm.
+   *
+   * To return - the password the user entered password is compared to. Or Null on fail.
+   *
+   * DIGEST_AUTH        enteredUsernameOrReq    contains the username entered by the user
+   *                    param[0]                autenticaiton realm
+   *                    param[1]                authentication URI
+   *
+   * To return - the password of which the digest will be based on for comparison. Or NULL
+   * to fail.
+   *
+   * OTHER_AUTH         enteredUsernameOrReq    rest of the auth line.
+   *                    params                  empty array
+   *
+   * To return - NULL to fail; or any string.
+   */
+  typedef std::function<String * (HTTPAuthMethod mode, String enteredUsernameOrReq, String extraParams[])> THandlerFunctionAuthCheck;
+
+  bool authenticate(THandlerFunctionAuthCheck fn);
   bool authenticate(const char * username, const char * password);
+  bool authenticateBasicSHA1(const char * _username, const char * _sha1AsBase64orHex);
+
   void requestAuthentication(HTTPAuthMethod mode = BASIC_AUTH, const char* realm = NULL, const String& authFailMsg = String("") );
 
   typedef std::function<void(void)> THandlerFunction;
   void on(const Uri &uri, THandlerFunction fn);
-  void on(const Uri &uri, HTTPMethod method, THandlerFunction fn); 
+  void on(const Uri &uri, HTTPMethod method, THandlerFunction fn);
   void on(const Uri &uri, HTTPMethod method, THandlerFunction fn, THandlerFunction ufn); //ufn handles file uploads
   void addHandler(RequestHandler* handler);
   void serveStatic(const char* uri, fs::FS& fs, const char* path, const char* cache_header = NULL );

libraries/WebServer/examples/HttpBasicAuthSHA1orBearerToken/.skip.esp32h2

@@ -0,0 +1,297 @@
+/* Peripheral Manager test
+ *
+ * This test is using Serial to check if the peripheral manager is able to
+ * attach and detach peripherals correctly on shared pins.
+ * Make sure that the peripheral names contain only letters, numbers and underscores.
+ *
+ * This test skips the following peripherals:
+ * - USB: USB is not able to be detached
+ * - SDMMC: SDMMC requires a card to be mounted before the pins are attached
+ * - ETH: ETH requires a ethernet port to be connected before the pins are attached
+ */
+
+#if SOC_I2S_SUPPORTED
+#include "ESP_I2S.h"
+#endif
+
+#if SOC_I2C_SUPPORTED
+#include "Wire.h"
+#endif
+
+#if SOC_GPSPI_SUPPORTED
+#include "SPI.h"
+#endif
+
+/* Definitions */
+
+#define UART1_RX_DEFAULT 4
+#define UART1_TX_DEFAULT 5
+
+#define ADC1_DEFAULT A4
+
+#if CONFIG_IDF_TARGET_ESP32
+# define ADC2_DEFAULT A5
+#else
+# define ADC2_DEFAULT A3
+#endif
+
+#if CONFIG_IDF_TARGET_ESP32
+# define TOUCH1_DEFAULT T0
+# define TOUCH2_DEFAULT T2
+#else
+# define TOUCH1_DEFAULT T4
+# define TOUCH2_DEFAULT T5
+#endif
+
+/* Global variables */
+
+bool test_executed = false;
+String current_test;
+int8_t uart1_rx_pin;
+int8_t uart1_tx_pin;
+
+/* Callback functions */
+
+void onReceive_cb(void) {
+  // This is a callback function that will be activated on UART RX events
+  size_t available = Serial1.available();
+  while (available --) {
+    Serial.print((char)Serial1.read());
+  }
+}
+
+// This function is called by before each test is run
+void setup_test(String test_name, int8_t rx_pin = UART1_RX_DEFAULT, int8_t tx_pin = UART1_TX_DEFAULT) {
+  log_v("Setting up %s test", test_name.c_str());
+
+  current_test = test_name;
+  uart1_rx_pin = rx_pin;
+  uart1_tx_pin = tx_pin;
+  test_executed = false;
+
+  pinMode(uart1_rx_pin, INPUT_PULLUP);
+  pinMode(uart1_tx_pin, OUTPUT);
+  Serial1.setPins(uart1_rx_pin, uart1_tx_pin);
+  uart_internal_loopback(1, uart1_rx_pin);
+  delay(100);
+  log_v("Running %s test", test_name.c_str());
+}
+
+// This function is called after each test is run
+void teardown_test(void) {
+  log_v("Tearing down %s test", current_test.c_str());
+  if (test_executed) {
+    pinMode(uart1_rx_pin, INPUT_PULLUP);
+    pinMode(uart1_tx_pin, OUTPUT);
+    Serial1.print(current_test);
+    Serial1.println(" test: This should not be printed");
+    Serial1.flush();
+
+    Serial1.setPins(uart1_rx_pin, uart1_tx_pin);
+    uart_internal_loopback(1, uart1_rx_pin);
+    delay(100);
+  }
+
+  Serial1.print(current_test);
+  Serial1.println(" test: This should be printed");
+  Serial1.flush();
+
+  log_v("Finished %s test", current_test.c_str());
+}
+
+/* Test functions */
+/* These functions must call "setup_test" and "teardown_test" and set "test_executed" to true
+ * if the test is executed
+ */
+
+void gpio_test(void) {
+  setup_test("GPIO");
+  test_executed = true;
+  pinMode(uart1_rx_pin, INPUT);
+  pinMode(uart1_tx_pin, OUTPUT);
+  digitalRead(uart1_rx_pin);
+  digitalWrite(uart1_tx_pin, HIGH);
+  teardown_test();
+}
+
+void sigmadelta_test(void) {
+  setup_test("SigmaDelta");
+#if SOC_SDM_SUPPORTED
+  test_executed = true;
+  if (!sigmaDeltaAttach(uart1_rx_pin, 312500)) {
+    Serial.println("SigmaDelta init failed");
+  }
+  if (!sigmaDeltaAttach(uart1_tx_pin, 312500)) {
+    Serial.println("SigmaDelta init failed");
+  }
+#endif
+  teardown_test();
+}
+
+void adc_oneshot_test(void) {
+#if !SOC_ADC_SUPPORTED
+  setup_test("ADC_Oneshot");
+#else
+  setup_test("ADC_Oneshot", ADC1_DEFAULT, ADC2_DEFAULT);
+  test_executed = true;
+  analogReadResolution(12);
+  pinMode(ADC1_DEFAULT, INPUT);
+  pinMode(ADC2_DEFAULT, INPUT);
+  analogRead(ADC1_DEFAULT);
+  analogRead(ADC2_DEFAULT);
+#endif
+  teardown_test();
+}
+
+#if SOC_ADC_SUPPORTED
+volatile bool adc_coversion_done = false;
+void ARDUINO_ISR_ATTR adcComplete() {
+  adc_coversion_done = true;
+}
+#endif
+
+void adc_continuous_test(void) {
+#if !SOC_ADC_SUPPORTED
+  setup_test("ADC_Continuous");
+#else
+  setup_test("ADC_Continuous", ADC1_DEFAULT, ADC2_DEFAULT);
+  test_executed = true;
+  uint8_t adc_pins[] = {ADC1_DEFAULT, ADC2_DEFAULT};
+  uint8_t adc_pins_count = 2;
+  adc_continuos_data_t * result = NULL;
+
+  analogContinuousSetWidth(12);
+  analogContinuousSetAtten(ADC_11db);
+
+  analogContinuous(adc_pins, adc_pins_count, 6, 20000, &adcComplete);
+  analogContinuousStart();
+
+  while (adc_coversion_done == false) {
+    delay(1);
+  }
+
+  if (!analogContinuousRead(&result, 0)) {
+    Serial.println("ADC continuous read failed");
+  }
+
+  analogContinuousStop();
+#endif
+  teardown_test();
+}
+
+void dac_test(void) {
+#if !SOC_DAC_SUPPORTED
+  setup_test("DAC");
+#else
+  setup_test("DAC", DAC1, DAC2);
+  test_executed = true;
+  dacWrite(DAC1, 255);
+  dacWrite(DAC2, 255);
+#endif
+  teardown_test();
+}
+
+void ledc_test(void) {
+  setup_test("LEDC");
+#if SOC_LEDC_SUPPORTED
+  test_executed = true;
+  if (!ledcAttach(uart1_rx_pin, 5000, 12)) {
+    Serial.println("LEDC init failed");
+  }
+  if (!ledcAttach(uart1_tx_pin, 5000, 12)) {
+    Serial.println("LEDC init failed");
+  }
+#endif
+  teardown_test();
+}
+
+void rmt_test(void) {
+  setup_test("RMT");
+#if SOC_RMT_SUPPORTED
+  test_executed = true;
+  if (!rmtInit(uart1_rx_pin, RMT_TX_MODE, RMT_MEM_NUM_BLOCKS_1, 10000000)) {
+    Serial.println("RMT init failed");
+  }
+  if (!rmtInit(uart1_tx_pin, RMT_RX_MODE, RMT_MEM_NUM_BLOCKS_1, 10000000)) {
+    Serial.println("RMT init failed");
+  }
+#endif
+  teardown_test();
+}
+
+void i2s_test(void) {
+  setup_test("I2S");
+#if SOC_I2S_SUPPORTED
+  test_executed = true;
+  I2SClass i2s;
+
+  i2s.setPins(uart1_rx_pin, uart1_tx_pin, -1);
+  i2s.setTimeout(1000);
+  if (!i2s.begin(I2S_MODE_STD, 16000, I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_STEREO)) {
+    Serial.println("I2S init failed");
+  }
+#endif
+  teardown_test();
+}
+
+void i2c_test(void) {
+  setup_test("I2C");
+#if SOC_I2C_SUPPORTED
+  test_executed = true;
+  if (!Wire.begin(uart1_rx_pin, uart1_tx_pin)) {
+    Serial.println("I2C init failed");
+  }
+#endif
+  teardown_test();
+}
+
+void spi_test(void) {
+  setup_test("SPI");
+#if SOC_GPSPI_SUPPORTED
+  test_executed = true;
+  SPI.begin(uart1_rx_pin, uart1_tx_pin, -1, -1);
+#endif
+  teardown_test();
+}
+
+void touch_test(void) {
+#if !SOC_TOUCH_SENSOR_SUPPORTED
+  setup_test("Touch");
+#else
+  setup_test("Touch", TOUCH1_DEFAULT, TOUCH2_DEFAULT);
+  test_executed = true;
+  touchRead(TOUCH1_DEFAULT);
+  touchRead(TOUCH2_DEFAULT);
+#endif
+  teardown_test();
+}
+
+/* Main functions */
+
+void setup() {
+  Serial.begin(115200);
+  while(!Serial) { delay(10); }
+
+  Serial1.setPins(UART1_RX_DEFAULT, UART1_TX_DEFAULT);
+  Serial1.begin(115200);
+  while(!Serial1) { delay(10); }
+  Serial1.onReceive(onReceive_cb);
+  uart_internal_loopback(1, uart1_rx_pin);
+
+  gpio_test();
+  sigmadelta_test();
+  ledc_test();
+  rmt_test();
+  i2s_test();
+  i2c_test();
+  spi_test();
+  adc_oneshot_test();
+  adc_continuous_test();
+  dac_test();
+  touch_test();
+
+  // Print to Serial1 to avoid buffering issues
+  Serial1.println("Peripheral Manager test done");
+}
+
+void loop() {}

libraries/WebServer/examples/HttpBasicAuthSHA1orBearerToken/HttpBasicAuthSHA1orBearerToken.ino

@@ -0,0 +1,26 @@
+def test_periman(dut):
+    peripherals = ["GPIO", "SigmaDelta", "LEDC", "RMT", "I2S", "I2C", "SPI",
+                   "ADC_Oneshot", "ADC_Continuous", "DAC", "Touch"]
+
+    pattern = rb"(?:\b\w+\b test: This should(?: not)? be printed|Peripheral Manager test done)"
+
+    while True:
+        try:
+            res = dut.expect(pattern, timeout=10)
+        except:
+            assert False, f"Could not detect end of test"
+
+        console_output = res.group(0).decode("utf-8")
+        peripheral = console_output.split()[0]
+
+        if "Peripheral Manager test done" in console_output:
+            break
+
+        if peripheral in peripherals:
+            if "not" in console_output:
+                assert False, f"Peripheral {peripheral} printed when it should not"
+            peripherals.remove(peripheral)
+        else:
+            assert False, f"Unknown peripheral: {peripheral}"
+
+    assert peripherals == [], f"Missing peripherals output: {peripherals}"

libraries/WebServer/src/WebServer.cpp

@@ -78,11 +78,11 @@ void start_serial(unsigned long baudrate = 115200) {
 // This function stops all the available test UARTs
 void stop_serial(bool hard_stop = false) {
   #if SOC_UART_NUM >= 2
-    Serial1.end(hard_stop);
+    Serial1.end(/*hard_stop*/);
   #endif
 
   #if SOC_UART_NUM >= 3
-    Serial2.end(hard_stop);
+    Serial2.end(/*hard_stop*/);
   #endif
 }
 
@@ -139,6 +139,19 @@ void task_delayed_msg(void *pvParameters) {
 // This function is automatically called by unity before each test is run
 void setUp(void) {
   start_serial(115200);
+#if SOC_UART_NUM == 2
+  log_d("Setup internal loop-back from and back to Serial1 (UART1) TX >> Serial1 (UART1) RX");
+
+  Serial1.onReceive([]() {onReceive_cb(Serial1);});
+  uart_internal_loopback(1, RX1);
+#elif SOC_UART_NUM == 3
+  log_d("Setup internal loop-back between Serial1 (UART1) <<--->> Serial2 (UART2)");
+
+  Serial1.onReceive([]() {onReceive_cb(Serial1);});
+  Serial2.onReceive([]() {onReceive_cb(Serial2);});
+  uart_internal_loopback(1, RX2);
+  uart_internal_loopback(2, RX1);
+#endif
 }
 
 // This function is automatically called by unity after each test is run
@@ -393,7 +406,7 @@ void disabled_uart_calls_test(void) {
 
 // This test checks if the pins can be changed and if the message can be transmitted and received correctly after the change
 void change_pins_test(void) {
-  stop_serial();
+  //stop_serial();
 
   log_d("Disabling UART loopback");
 
@@ -453,7 +466,7 @@ void auto_baudrate_test(void) {
     selected_serial = &Serial2;
   #endif
 
-  selected_serial->end(false);
+  //selected_serial->end(false);
 
   log_d("Starting delayed task to send message");
 

libraries/WebServer/src/WebServer.h

@@ -76,6 +76,12 @@ static constexpr uint8_t A7         = 14;
 
 #endif
 
+// Aliases
+
+static constexpr uint8_t LEDR = LED_RED;
+static constexpr uint8_t LEDG = LED_GREEN;
+static constexpr uint8_t LEDB = LED_BLUE;
+
 // alternate pin functions
 
 static constexpr uint8_t LED_BUILTIN = D13;

tests/periman/periman.ino

@@ -0,0 +1,77 @@
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include <stdint.h>
+#include "soc/soc_caps.h"
+
+#define WIRELESS_TRACKER true
+
+#define DISPLAY_HEIGHT 80
+#define DISPLAY_WIDTH  160
+
+#define USB_VID 0x303a
+#define USB_PID 0x1001
+
+static const uint8_t LED_BUILTIN = 18;
+#define BUILTIN_LED  LED_BUILTIN // backward compatibility
+#define LED_BUILTIN LED_BUILTIN  // allow testing #ifdef LED_BUILTIN
+
+
+static const uint8_t TX = 43;
+static const uint8_t RX = 44;
+
+static const uint8_t SDA = 5;
+static const uint8_t SCL = 6;
+
+static const uint8_t SS    = 8;
+static const uint8_t MOSI  = 10;
+static const uint8_t MISO  = 11;
+static const uint8_t SCK   = 9;
+
+static const uint8_t A0 = 1;
+static const uint8_t A1 = 2;
+static const uint8_t A2 = 3;
+static const uint8_t A3 = 4;
+static const uint8_t A4 = 5;
+static const uint8_t A5 = 6;
+static const uint8_t A6 = 7;
+static const uint8_t A7 = 8;
+static const uint8_t A8 = 9;
+static const uint8_t A9 = 10;
+static const uint8_t A10 = 11;
+static const uint8_t A11 = 12;
+static const uint8_t A12 = 13;
+static const uint8_t A13 = 14;
+static const uint8_t A14 = 15;
+static const uint8_t A15 = 16;
+static const uint8_t A16 = 17;
+static const uint8_t A17 = 18;
+static const uint8_t A18 = 19;
+static const uint8_t A19 = 20;
+
+static const uint8_t T1 = 1;
+static const uint8_t T2 = 2;
+static const uint8_t T3 = 3;
+static const uint8_t T4 = 4;
+static const uint8_t T5 = 5;
+static const uint8_t T6 = 6;
+static const uint8_t T7 = 7;
+static const uint8_t T8 = 8;
+static const uint8_t T9 = 9;
+static const uint8_t T10 = 10;
+static const uint8_t T11 = 11;
+static const uint8_t T12 = 12;
+static const uint8_t T13 = 13;
+static const uint8_t T14 = 14;
+
+static const uint8_t Vext = 3;
+static const uint8_t LED  = 18;
+
+static const uint8_t ST7735_CS_PIN    = 38;
+static const uint8_t ST7735_RST_PIN   = 39;
+static const uint8_t ST7735_DC_PIN    = 40;
+static const uint8_t ST7735_SCLK_PIN  = 41;
+static const uint8_t ST7735_MOSI_PIN  = 42;
+static const uint8_t ST7735_LED_K_PIN = 21;
+
+#endif /* Pins_Arduino_h */

tests/periman/test_periman.py

@@ -0,0 +1,34 @@
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include <stdint.h>
+
+#define TX1 0
+#define RX1 1
+
+static const uint8_t LED_BUILTIN = 8;
+#define BUILTIN_LED  LED_BUILTIN // backward compatibility
+#define LED_BUILTIN LED_BUILTIN  // allow testing #ifdef LED_BUILTIN
+
+static const uint8_t BOOT_BUILTIN = 9; // built-in boot button
+
+static const uint8_t TX = 21;
+static const uint8_t RX = 20;
+
+static const uint8_t SDA = 8;
+static const uint8_t SCL = 9;
+
+static const uint8_t SS    = 7;
+static const uint8_t MOSI  = 6;
+static const uint8_t MISO  = 5;
+static const uint8_t SCK   = 4;
+
+static const uint8_t A0 = 0;
+static const uint8_t A1 = 1;
+static const uint8_t A2 = 2;
+static const uint8_t A3 = 3;
+static const uint8_t A4 = 4;
+static const uint8_t A5 = 5;
+
+#endif /* Pins_Arduino_h */
+