External, emulated non-volatile memory over UART

uart-flash
Daniele Lacamera 2020-04-03 14:10:16 +02:00
parent 46058f0437
commit 7ffcdca098
12 changed files with 973 additions and 1 deletions

View File

@ -118,13 +118,24 @@ ifeq ($(SPI_FLASH),1)
WOLFCRYPT_OBJS+=hal/spi/spi_drv_$(SPI_TARGET).o
endif
ifeq ($(UART_FLASH),1)
EXT_FLASH=1
endif
ifeq ($(EXT_FLASH),1)
CFLAGS+= -DEXT_FLASH=1 -DPART_UPDATE_EXT=1 -DPART_SWAP_EXT=1
ifeq ($(NO_XIP),1)
CFLAGS+=-DPART_BOOT_EXT=1
endif
ifeq ($(UART_FLASH),1)
CFLAGS+=-DUART_FLASH=1
OBJS+=src/uart_flash.o
WOLFCRYPT_OBJS+=hal/uart/uart_drv_$(UART_TARGET).o
endif
endif
ifeq ($(ALLOW_DOWNGRADE),1)
CFLAGS+= -DALLOW_DOWNGRADE
endif

View File

@ -15,6 +15,8 @@ ARCH_FLASH_OFFSET=0x0
# Default SPI driver name
SPI_TARGET=$(TARGET)
# Default UART driver name
UART_TARGET=$(TARGET)
## Hash settings
ifeq ($(HASH),SHA256)
@ -129,6 +131,7 @@ ifeq ($(TARGET),lpc)
CFLAGS+=-I$(MCUXPRESSO_DRIVERS)/drivers -I$(MCUXPRESSO_DRIVERS) -DCPU_$(MCUXPRESSO_CPU) -I$(MCUXPRESSO_CMSIS)/Include -DDEBUG_CONSOLE_ASSERT_DISABLE=1
OBJS+=$(MCUXPRESSO_DRIVERS)/drivers/fsl_clock.o $(MCUXPRESSO_DRIVERS)/drivers/fsl_flashiap.o $(MCUXPRESSO_DRIVERS)/drivers/fsl_power.o $(MCUXPRESSO_DRIVERS)/drivers/fsl_reset.o
OBJS+=$(MCUXPRESSO_DRIVERS)/mcuxpresso/libpower_softabi.a $(MCUXPRESSO_DRIVERS)/drivers/fsl_common.o
OBJS+=$(MCUXPRESSO_DRIVERS)/drivers/fsl_usart.o $(MCUXPRESSO_DRIVERS)/drivers/fsl_flexcomm.o
endif

View File

@ -0,0 +1,35 @@
ARCH?=ARM
TARGET?=stm32f4
SIGN?=ECC256
HASH?=SHA256
MCUXPRESSO?=/home/dan/src/FRDM-K64F
MCUXPRESSO_CPU?=MK64FN1M0VLL12
MCUXPRESSO_DRIVERS?=/home/dan/src/FRDM-K64F/devices/MK64F12
MCUXPRESSO_CMSIS?=/home/dan/src/FRDM-K64F/CMSIS
FREEDOM_E_SDK?=/home/dan/src/freedom-e-sdk
STM32CUBE?=/home/dan/STM32Cube/Repository/STM32Cube_FW_WB_V1.3.0
DEBUG?=1
VTOR?=1
CORTEX_M0?=0
NO_ASM?=0
EXT_FLASH?=0
SPI_FLASH?=0
NO_XIP?=0
UART_FLASH?=1
ALLOW_DOWNGRADE?=0
NVM_FLASH_WRITEONCE?=0
WOLFBOOT_VERSION?=0
V?=0
SPMATH?=1
RAM_CODE?=0
DUALBANK_SWAP?=0
IMAGE_HEADER_SIZE?=256
PKA?=1
WOLFTPM?=0
WOLFBOOT_PARTITION_SIZE?=0x4000
WOLFBOOT_SECTOR_SIZE?=0x4000
WOLFBOOT_PARTITION_BOOT_ADDRESS?=0x8000
WOLFBOOT_PARTITION_UPDATE_ADDRESS?=0x00000
WOLFBOOT_PARTITION_SWAP_ADDRESS?=0x4000
WOLFBOOT_LOAD_ADDRESS?=0x200000
WOLFBOOT_LOAD_DTS_ADDRESS?=0x400000

View File

@ -0,0 +1,113 @@
/* uart_drv_lpc.c
*
* Driver for the back-end of the UART_FLASH module.
*
* Example implementation for LPC54xxx, using UART0.
*
* Copyright (C) 2020 wolfSSL Inc.
*
* This file is part of wolfBoot.
*
* wolfBoot is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* wolfBoot 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
*/
#include "fsl_common.h"
#include "fsl_iocon.h"
#include "fsl_usart.h"
#include "target.h"
#include "wolfboot/wolfboot.h"
#include "hal.h"
#define IOCON_PIO_DIGITAL_EN 0x0100u /*!<@brief Enables digital function */
#define IOCON_PIO_FUNC1 0x01u /*!<@brief Selects pin function 1 */
#define IOCON_PIO_INPFILT_OFF 0x0200u /*!<@brief Input filter disabled */
#define IOCON_PIO_INV_DI 0x00u /*!<@brief Input function is not inverted */
#define IOCON_PIO_MODE_INACT 0x00u /*!<@brief No addition pin function */
#define IOCON_PIO_OPENDRAIN_DI 0x00u /*!<@brief Open drain is disabled */
#define IOCON_PIO_SLEW_STANDARD 0x00u /*!<@brief Standard mode, output slew rate control is enabled */
static void uart_pin_init(void)
{
/* Enables the clock for the IOCON block. 0 = Disable; 1 = Enable.: 0x01u */
CLOCK_EnableClock(kCLOCK_Iocon);
const uint32_t port0_pin29_config = (/* Pin is configured as FC0_RXD_SDA_MOSI */
IOCON_PIO_FUNC1 |
/* No addition pin function */
IOCON_PIO_MODE_INACT |
/* Input function is not inverted */
IOCON_PIO_INV_DI |
/* Enables digital function */
IOCON_PIO_DIGITAL_EN |
/* Input filter disabled */
IOCON_PIO_INPFILT_OFF |
/* Standard mode, output slew rate control is enabled */
IOCON_PIO_SLEW_STANDARD |
/* Open drain is disabled */
IOCON_PIO_OPENDRAIN_DI);
/* PORT0 PIN29 (coords: B13) is configured as FC0_RXD_SDA_MOSI */
IOCON_PinMuxSet(IOCON, 0U, 29U, port0_pin29_config);
const uint32_t port0_pin30_config = (/* Pin is configured as FC0_TXD_SCL_MISO */
IOCON_PIO_FUNC1 |
/* No addition pin function */
IOCON_PIO_MODE_INACT |
/* Input function is not inverted */
IOCON_PIO_INV_DI |
/* Enables digital function */
IOCON_PIO_DIGITAL_EN |
/* Input filter disabled */
IOCON_PIO_INPFILT_OFF |
/* Standard mode, output slew rate control is enabled */
IOCON_PIO_SLEW_STANDARD |
/* Open drain is disabled */
IOCON_PIO_OPENDRAIN_DI);
/* PORT0 PIN30 (coords: A2) is configured as FC0_TXD_SCL_MISO */
IOCON_PinMuxSet(IOCON, 0U, 30U, port0_pin30_config);
}
int uart_tx(const uint8_t c)
{
while((USART_GetStatusFlags(USART0) & kUSART_TxFifoEmptyFlag) == 0)
;
USART_WriteByte(USART0, c);
return 1;
}
int uart_rx(uint8_t *c)
{
if ((USART_GetStatusFlags(USART0) & kUSART_RxFifoNotEmptyFlag) != 0) {
*c = USART_ReadByte(USART0);
return 1;
}
return 0;
}
int uart_init(uint32_t bitrate, uint8_t data, char parity, uint8_t stop)
{
uint8_t ch;
usart_config_t config;
uart_pin_init();
USART_GetDefaultConfig(&config);
config.baudRate_Bps = bitrate;
config.enableTx = true;
config.enableRx = true;
CLOCK_AttachClk(kFRO12M_to_FLEXCOMM0);
USART_Init(USART0, &config, CLOCK_GetFlexCommClkFreq(0));
uart_send_current_version();
return 0;
}

View File

@ -0,0 +1,148 @@
/* uart_drv_stm32.c
*
* Driver for the back-end of the UART_FLASH module.
*
* Example implementation for stm32F4, using UART3.
*
* Pinout: RX=PD9, TX=PD8
*
* Copyright (C) 2020 wolfSSL Inc.
*
* This file is part of wolfBoot.
*
* wolfBoot is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* wolfBoot 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
*/
#include <stdint.h>
/* Driver hardcoded to work on UART3 (PD8/PD9) */
#define UART3 (0x40004800)
#define UART3_PIN_AF 7
#define UART3_RX_PIN 9
#define UART3_TX_PIN 8
#define UART3_SR (*(volatile uint32_t *)(UART3))
#define UART3_DR (*(volatile uint32_t *)(UART3 + 0x04))
#define UART3_BRR (*(volatile uint32_t *)(UART3 + 0x08))
#define UART3_CR1 (*(volatile uint32_t *)(UART3 + 0x0c))
#define UART3_CR2 (*(volatile uint32_t *)(UART3 + 0x10))
#define UART_CR1_UART_ENABLE (1 << 13)
#define UART_CR1_SYMBOL_LEN (1 << 12)
#define UART_CR1_PARITY_ENABLED (1 << 10)
#define UART_CR1_PARITY_ODD (1 << 9)
#define UART_CR1_TX_ENABLE (1 << 3)
#define UART_CR1_RX_ENABLE (1 << 2)
#define UART_CR2_STOPBITS (3 << 12)
#define UART_SR_TX_EMPTY (1 << 7)
#define UART_SR_RX_NOTEMPTY (1 << 5)
#define CLOCK_SPEED (168000000)
#define APB1_CLOCK_ER (*(volatile uint32_t *)(0x40023840))
#define UART3_APB1_CLOCK_ER_VAL (1 << 18)
#define AHB1_CLOCK_ER (*(volatile uint32_t *)(0x40023830))
#define GPIOD_AHB1_CLOCK_ER (1 << 3)
#define GPIOD_BASE 0x40020c00
#define GPIOD_MODE (*(volatile uint32_t *)(GPIOD_BASE + 0x00))
#define GPIOD_AFL (*(volatile uint32_t *)(GPIOD_BASE + 0x20))
#define GPIOD_AFH (*(volatile uint32_t *)(GPIOD_BASE + 0x24))
#define GPIO_MODE_AF (2)
static void uart_pins_setup(void)
{
uint32_t reg;
AHB1_CLOCK_ER |= GPIOD_AHB1_CLOCK_ER;
/* Set mode = AF */
reg = GPIOD_MODE & ~ (0x03 << (UART3_RX_PIN * 2));
GPIOD_MODE = reg | (2 << (UART3_RX_PIN * 2));
reg = GPIOD_MODE & ~ (0x03 << (UART3_TX_PIN * 2));
GPIOD_MODE = reg | (2 << (UART3_TX_PIN * 2));
/* Alternate function: use high pins (8 and 9) */
reg = GPIOD_AFH & ~(0xf << ((UART3_TX_PIN - 8) * 4));
GPIOD_AFH = reg | (UART3_PIN_AF << ((UART3_TX_PIN - 8) * 4));
reg = GPIOD_AFH & ~(0xf << ((UART3_RX_PIN - 8) * 4));
GPIOD_AFH = reg | (UART3_PIN_AF << ((UART3_RX_PIN - 8) * 4));
}
int uart_tx(const uint8_t c)
{
uint32_t reg;
do {
reg = UART3_SR;
} while ((reg & UART_SR_TX_EMPTY) == 0);
UART3_DR = c;
return 1;
}
int uart_rx(uint8_t *c)
{
volatile uint32_t reg = UART3_SR;
if ((reg & UART_SR_RX_NOTEMPTY) != 0) {
reg = UART3_DR;
*c = (uint8_t)(reg & 0xff);
return 1;
}
return 0;
}
int uart_init(uint32_t bitrate, uint8_t data, char parity, uint8_t stop)
{
uint32_t reg;
/* Enable pins and configure for AF7 */
uart_pins_setup();
/* Turn on the device */
APB1_CLOCK_ER |= UART3_APB1_CLOCK_ER_VAL;
UART3_CR1 &= ~(UART_CR1_UART_ENABLE);
/* Configure for TX + RX */
UART3_CR1 |= (UART_CR1_TX_ENABLE | UART_CR1_RX_ENABLE);
/* Configure clock */
UART3_BRR = CLOCK_SPEED / bitrate;
/* Configure data bits */
if (data == 8)
UART3_CR1 &= ~UART_CR1_SYMBOL_LEN;
else
UART3_CR1 |= UART_CR1_SYMBOL_LEN;
/* Configure parity */
switch (parity) {
case 'O':
UART3_CR1 |= UART_CR1_PARITY_ODD;
/* fall through to enable parity */
/* FALL THROUGH */
case 'E':
UART3_CR1 |= UART_CR1_PARITY_ENABLED;
break;
default:
UART3_CR1 &= ~(UART_CR1_PARITY_ENABLED | UART_CR1_PARITY_ODD);
}
/* Set stop bits */
reg = UART3_CR2 & ~UART_CR2_STOPBITS;
if (stop > 1)
UART3_CR2 = reg & (2 << 12);
else
UART3_CR2 = reg;
/* Turn on uart */
UART3_CR1 |= UART_CR1_UART_ENABLE;
return 0;
}

View File

@ -23,6 +23,7 @@
#include "image.h"
#include "hal.h"
#include "spi_flash.h"
#include "uart_flash.h"
#include "wolfboot/wolfboot.h"
#ifdef RAM_CODE
@ -172,6 +173,10 @@ int main(void)
{
hal_init();
spi_flash_probe();
#ifdef UART_FLASH
uart_init((4 * 115200), 8, 'N', 1);
uart_send_current_version();
#endif
#ifdef WOLFTPM2_NO_WOLFCRYPT
wolfBoot_tpm2_init();
#endif

179
src/uart_flash.c 100644
View File

@ -0,0 +1,179 @@
/* uart_flash.c
*
* Generic implementation of the read/write/erase
* functionalities, on top of the spi_drv_*.c API.
*
* This interface creates the communication to access an emulated
* non-volatile memory, hosted on a remote machine, through the UART
* interface.
*
*
* Copyright (C) 2020 wolfSSL Inc.
*
* This file is part of wolfBoot.
*
* wolfBoot is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* wolfBoot 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
*/
#include "wolfboot/wolfboot.h"
#include "hal.h"
#include <stdint.h>
#include <string.h>
#define CMD_HDR_WOLF 'W'
#define CMD_HDR_WRITE 0x01
#define CMD_HDR_READ 0x02
#define CMD_HDR_ERASE 0x03
#define CMD_ACK 0x06
#define WAIT_CYCLES 500000
#define ERASE_TIMEOUT 5
#define READ_TIMEOUT 1
int uart_tx(const uint8_t c);
int uart_rx(uint8_t *c);
static int wait_ack(void)
{
volatile int count = 0;
while(++count < WAIT_CYCLES) {
uint8_t c;
if ((uart_rx(&c) == 1) && (c == CMD_ACK))
return 0;
}
return -1;
}
static int uart_rx_timeout(uint8_t *c)
{
volatile int count = 0;
while(++count < (WAIT_CYCLES * READ_TIMEOUT)) {
if (uart_rx(c) == 1) /* Success */
return 0;
}
*c = 0x00;
return -1;
}
int ext_flash_write(uintptr_t address, const uint8_t *data, int len)
{
int i;
uint8_t cmd[10];
cmd[0] = CMD_HDR_WOLF;
cmd[1] = CMD_HDR_WRITE;
cmd[2] = address & 0xFF;
cmd[3] = (address >> 8) & 0xFF;
cmd[4] = (address >> 16) & 0xFF;
cmd[5] = (address >> 24) & 0xFF;
cmd[6] = len & 0xFF;
cmd[7] = (len >> 8) & 0xFF;
cmd[8] = (len >> 16) & 0xFF;
cmd[9] = (len >> 24) & 0xFF;
for (i = 0; i < 10; i++) {
uart_tx(cmd[i]);
if (wait_ack() != 0)
return -1;
}
for (i = 0; i < len; i++) {
uart_tx(data[i]);
if (wait_ack() != 0)
return -1;
}
return i;
}
int ext_flash_read(uintptr_t address, uint8_t *data, int len)
{
int i;
uint8_t cmd[10];
cmd[0] = CMD_HDR_WOLF;
cmd[1] = CMD_HDR_READ;
cmd[2] = address & 0xFF;
cmd[3] = (address >> 8) & 0xFF;
cmd[4] = (address >> 16) & 0xFF;
cmd[5] = (address >> 24) & 0xFF;
cmd[6] = len & 0xFF;
cmd[7] = (len >> 8) & 0xFF;
cmd[8] = (len >> 16) & 0xFF;
cmd[9] = (len >> 24) & 0xFF;
for (i = 0; i < 10; i++) {
uart_tx(cmd[i]);
if (wait_ack() != 0)
return -1;
}
for (i = 0; i < len; i++) {
if (uart_rx_timeout(&data[i]) != 0)
return 0;
uart_tx(CMD_ACK);
}
return len;
}
int ext_flash_erase(uintptr_t address, int len)
{
int i;
uint8_t cmd[10];
cmd[0] = CMD_HDR_WOLF;
cmd[1] = CMD_HDR_ERASE;
cmd[2] = address & 0xFF;
cmd[3] = (address >> 8) & 0xFF;
cmd[4] = (address >> 16) & 0xFF;
cmd[5] = (address >> 24) & 0xFF;
cmd[6] = len & 0xFF;
cmd[7] = (len >> 8) & 0xFF;
cmd[8] = (len >> 16) & 0xFF;
cmd[9] = (len >> 24) & 0xFF;
for (i = 0; i < 10; i++) {
uart_tx(cmd[i]);
if (wait_ack() != 0)
return -1;
}
/* Wait for extra ack at the end of Erase */
if (wait_ack() == 0)
return 0;
return -1;
}
void ext_flash_lock(void)
{
wait_ack();
}
void ext_flash_unlock(void)
{
wait_ack();
}
void uart_send_current_version(void)
{
uint32_t version = wolfBoot_current_firmware_version();
uart_tx('V');
if (wait_ack() != 0)
return;
uart_tx(version & 0x000000FF);
if (wait_ack() != 0)
return;
uart_tx((version >> 8) & 0x000000FF);
if (wait_ack() != 0)
return;
uart_tx((version >> 16) & 0x000000FF);
if (wait_ack() != 0)
return;
uart_tx((version >> 24) & 0x000000FF);
if (wait_ack() != 0)
return;
}

View File

@ -16,6 +16,7 @@ ifeq ($(HASH),SHA256)
CFLAGS+=-DWOLFBOOT_HASH_SHA256
endif
ifeq ($(HASH),SHA3_384)
WOLFCRYPT_OBJS+=./lib/wolfssl/wolfcrypt/src/sha3.o
CFLAGS+=-DWOLFBOOT_HASH_SHA3_384
@ -56,6 +57,11 @@ ifeq ($(SPI_FLASH),1)
APP_OBJS+=../hal/spi/spi_drv_$(SPI_TARGET).o ../src/spi_flash.o
endif
ifeq ($(UART_FLASH),1)
CFLAGS+=-DUART_FLASH=1
APP_OBJS+= ../src/uart_flash.o ../hal/uart/uart_drv_$(UART_TARGET).o
endif
ifeq ($(TARGET),kinetis)
CFLAGS+= -I$(MCUXPRESSO_DRIVERS)/drivers -I$(MCUXPRESSO_DRIVERS) -DCPU_$(MCUXPRESSO_CPU) -I$(MCUXPRESSO_CMSIS)/Include -DDEBUG_CONSOLE_ASSERT_DISABLE=1 -DNVM_FLASH_WRITEONCE=1
APP_OBJS+= $(MCUXPRESSO_DRIVERS)/drivers/fsl_clock.o $(MCUXPRESSO_DRIVERS)/drivers/fsl_ftfx_flash.o $(MCUXPRESSO_DRIVERS)/drivers/fsl_ftfx_cache.o \

View File

@ -17,6 +17,7 @@ ifeq ($(ARCH),)
EXT_FLASH?=0
SPI_FLASH?=0
NO_XIP?=0
UART_FLASH?=0
ALLOW_DOWNGRADE?=0
NVM_FLASH_WRITEONCE?=0
WOLFBOOT_VERSION?=0
@ -41,7 +42,7 @@ endif
CONFIG_VARS:= ARCH TARGET SIGN HASH MCUXPRESSO MCUXPRESSO_CPU MCUXPRESSO_DRIVERS \
MCUXPRESSO_CMSIS FREEDOM_E_SDK STM32CUBE DEBUG VTOR CORTEX_M0 NO_ASM EXT_FLASH \
SPI_FLASH NO_XIP ALLOW_DOWNGRADE NVM_FLASH_WRITEONCE WOLFBOOT_VERSION V \
SPI_FLASH NO_XIP UART_FLASH ALLOW_DOWNGRADE NVM_FLASH_WRITEONCE WOLFBOOT_VERSION V \
SPMATH RAM_CODE DUALBANK_SWAP IMAGE_HEADER_SIZE PKA WOLFTPM \
WOLFBOOT_PARTITION_SIZE WOLFBOOT_SECTOR_SIZE \
WOLFBOOT_PARTITION_BOOT_ADDRESS WOLFBOOT_PARTITION_UPDATE_ADDRESS \

View File

@ -0,0 +1,10 @@
CC=$(CROSS_COMPILE)gcc
CFLAGS=-Wall -DWOLFSSL_DTLS -DWOLFSSL_DEBUG -DTFM_TIMING_RESISTANT -DWOLFBOOT_SIGN_ECC256 -DWOLFBOOT_HASH_SHA256 -g -ggdb -I../../include -I../../hal -Wextra
EXE=ufserver
$(EXE): $(EXE).o ../../src/libwolfboot.o
$(CC) -o $@ $^ $(CFLAGS) $(LIBS)
clean:
rm -f *.o $(EXE) ../../src/libwolfboot.o

View File

@ -0,0 +1,44 @@
# UART interface for secure local updates
This directory contains a daemon that can be used on a host machine to emulate a remote
non-volatile memory on the target, using a UART channel.
## wolfBoot interface
The [Uart Flash](../../src/uart_flash.c) driver uses the same API as other external flash
memories. The target can be connected through a serial line to a host that can provide update
images by emulating the UPDATE partition on the target.
wolfBoot must be compiled with the option `UART_FLASH=1`. The back-end drivers to access the
UART interfaces are in the [uart drivers](../../hal/uart/) directory on this repository.
## ufserver usage
The 'uart flash server' (ufserver) requires two arguments:
- The path to the signed firmware update image (e.g. `../../../test-app/image_v2_signed.bin`)
- The serial port connected to the target (e.g. `/dev/ttyS0`)
When a new image is processed for the first time, an update flag is set automatically to indicate
that the update is available.
The bootloader will use the image file as its update+swap partition, so the file will be modified
by wolfboot during and after an update.
## Authentication
The daemon does not perform any signature verification, nor it checks the integrity of the firmware
image passed as command line argument. wolfBoot is still in charge of verifying integrity and authenticity
of the received update, and more in general, of every image before it is staged to boot.
## Swap and fail-safe operations
When installing an update using this mechanism, wolfBoot will erase the content of the file on the
filesystem and will overwrite its content with a copy of the older version.
As long as the daemon is running, wolfBoot will still be able to roll-back to a previous version if
booting the update fails.

View File

@ -0,0 +1,417 @@
/* ufserver.c
*
* UART flash server
*
* Run on HOST machine to export an emulated external, non-volatile memory.
*
* Copyright (C) 2020 wolfSSL Inc.
*
* This file is part of wolfBoot.
*
* wolfBoot is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* wolfBoot 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
*/
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include "wolfboot/wolfboot.h"
#include "hal.h"
#include <sys/mman.h>
#include <sys/stat.h>
#include <termios.h>
#include <errno.h>
#include <string.h>
#include <libgen.h>
#define CMD_HDR_WOLF 'W'
#define CMD_HDR_VER 'V'
#define CMD_HDR_WRITE 0x01
#define CMD_HDR_READ 0x02
#define CMD_HDR_ERASE 0x03
#define CMD_ACK 0x06
#define FIRMWARE_PARTITION_SIZE 0x4000
#define SWAP_SIZE 0x4000
const char msgSha[] = "Verifying SHA digest...";
const char msgReadUpdate[] = "Fetching update blocks ";
const char msgReadSwap[] = "Reading SWAP blocks ";
const char msgWriteUpdate[] = "Writing backup blocks ";
const char msgWriteSwap[] = "Writing SWAP blocks ";
const char msgEraseUpdate[] = "Erase update blocks ";
const char msgEraseSwap[] = "Erase swap blocks ";
extern uint16_t wolfBoot_find_header(uint8_t *haystack, uint16_t type, uint8_t **ptr);
const char blinker[]="-\\|/";
void printmsg(const char *msg)
{
static const char *cur_msg = NULL;
static int b_idx = 0;
if (cur_msg != msg) {
cur_msg = msg;
}
b_idx++;
if (b_idx > 3)
b_idx = 0;
printf("\r[%c] %s\t\t\t", blinker[b_idx], msg);
fflush(stdout);
}
int hal_flash_write(uint32_t address, const uint8_t *data, int len)
{
(void)address;
(void)data;
(void)len;
return -1;
}
int hal_flash_erase(uint32_t address, int len)
{
(void)address;
(void)len;
return -1;
}
void hal_flash_unlock(void)
{
}
void hal_flash_lock(void)
{
}
#include <termio.h>
#include <fcntl.h>
#include <err.h>
#include <linux/serial.h>
static int rate_to_constant(int baudrate) {
#define B(x) case x: return B##x
switch(baudrate) {
B(50); B(75); B(110); B(134); B(150);
B(200); B(300); B(600); B(1200); B(1800);
B(2400); B(4800); B(9600); B(19200); B(38400);
B(57600); B(115200); B(230400); B(460800); B(500000);
B(576000); B(921600); B(1000000);B(1152000);B(1500000);
default: return 0;
}
#undef B
}
/* Open serial port in raw mode, with custom baudrate if necessary */
static int serial_open(const char *device, int rate)
{
struct termios options;
struct serial_struct serinfo;
int fd;
int speed = 0;
/* Open and configure serial port */
if ((fd = open(device,O_RDWR|O_NOCTTY)) == -1)
return -1;
speed = rate_to_constant(rate);
if (speed == 0) {
/* Custom divisor */
serinfo.reserved_char[0] = 0;
if (ioctl(fd, TIOCGSERIAL, &serinfo) < 0)
return -1;
serinfo.flags &= ~ASYNC_SPD_MASK;
serinfo.flags |= ASYNC_SPD_CUST;
serinfo.custom_divisor = (serinfo.baud_base + (rate / 2)) / rate;
if (serinfo.custom_divisor < 1)
serinfo.custom_divisor = 1;
if (ioctl(fd, TIOCSSERIAL, &serinfo) < 0)
return -1;
if (ioctl(fd, TIOCGSERIAL, &serinfo) < 0)
return -1;
if (serinfo.custom_divisor * rate != serinfo.baud_base) {
warnx("actual baudrate is %d / %d = %f",
serinfo.baud_base, serinfo.custom_divisor,
(float)serinfo.baud_base / serinfo.custom_divisor);
}
}
fcntl(fd, F_SETFL, 0);
tcgetattr(fd, &options);
cfsetispeed(&options, speed ?: B38400);
cfsetospeed(&options, speed ?: B38400);
cfmakeraw(&options);
options.c_cflag |= (CLOCAL | CREAD);
options.c_cflag &= ~CRTSCTS;
if (tcsetattr(fd, TCSANOW, &options) != 0)
return -1;
return fd;
}
uint8_t *mmap_firmware(const char *fname)
{
uint8_t *base_fw;
struct stat st;
int fd;
if (stat(fname, &st) != 0) {
perror ("stat");
return (void *)-1;
}
fd = open(fname, O_RDWR);
if (fd < 0)
{
perror("open");
return (void *)-1;
}
if (st.st_size < FIRMWARE_PARTITION_SIZE) {
uint8_t pad = 0xFF;
int i;
const char update_flags[] = "pBOOT";
int fsize = st.st_size;
lseek(fd, FIRMWARE_PARTITION_SIZE + SWAP_SIZE, SEEK_SET);
lseek(fd, fsize, SEEK_SET);
for (i = 0; i < (FIRMWARE_PARTITION_SIZE - (fsize + 5)); i++)
write(fd, &pad, 1);
write(fd, update_flags, 5);
for (i = 0; i < SWAP_SIZE; i++)
write(fd, &pad, 1);
}
base_fw = mmap(NULL, FIRMWARE_PARTITION_SIZE + SWAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (base_fw == (void *)(-1)) {
perror("mmap");
return (void *)-1;
}
return base_fw;
}
uint32_t fw_version(uint8_t *fw)
{
uint16_t l;
uint8_t *p;
uint32_t ver;
l = wolfBoot_find_header(fw + 8, HDR_VERSION, &p);
if (l != 4)
return (uint32_t)-1;
ver = p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
return ver;
}
int open_uart(const char *uart_dev)
{
return serial_open(uart_dev, 4 * 115200);
}
static void send_ack(int ud)
{
uint8_t ack = CMD_ACK;
write(ud, &ack, 1);
fsync(ud);
}
static int read_word(int ud, uint32_t *w)
{
uint32_t i;
uint8_t *b = (uint8_t *)w;
int ret;
for (i = 0; i < 4; i++) {
ret = read(ud, &b[i], 1);
if (ret != 1)
return 0;
send_ack(ud);
}
return 4;
}
static void uart_flash_erase(uint8_t *base, int ud)
{
uint32_t address;
uint32_t len;
uint32_t i;
if (read_word(ud,&address) != 4)
return;
if (read_word(ud,&len) != 4)
return;
if (address + len > (FIRMWARE_PARTITION_SIZE + SWAP_SIZE))
return;
if (address < FIRMWARE_PARTITION_SIZE) {
printmsg(msgEraseUpdate);
} else {
printmsg(msgEraseSwap);
}
for (i = 0; i < len; i++) {
base[address + i] = 0xFF;
}
/* Send additional ack at the end of erase */
send_ack(ud);
msync(base, FIRMWARE_PARTITION_SIZE + SWAP_SIZE, MS_SYNC);
}
static void uart_flash_read(uint8_t *base, int ud)
{
uint32_t address;
uint32_t len;
uint32_t i;
uint8_t ack;
if (read_word(ud,&address) != 4)
return;
if (read_word(ud,&len) != 4)
return;
if (len == 16) {
printmsg(msgSha);
} else if (address < FIRMWARE_PARTITION_SIZE) {
printmsg(msgReadUpdate);
} else {
printmsg(msgReadSwap);
}
if (address + len > (FIRMWARE_PARTITION_SIZE + SWAP_SIZE))
return;
for (i = 0; i < len; i++) {
write(ud, base + address + i, 1);
read(ud, &ack, 1);
}
}
static void uart_flash_write(uint8_t *base, int ud)
{
uint32_t address;
uint32_t len;
uint32_t i;
if (read_word(ud,&address) != 4)
return;
if (read_word(ud,&len) != 4)
return;
if (address < FIRMWARE_PARTITION_SIZE) {
printmsg(msgWriteUpdate);
} else {
printmsg(msgWriteSwap);
}
if (address + len > (FIRMWARE_PARTITION_SIZE + SWAP_SIZE))
return;
for (i = 0; i < len; i++) {
read(ud, base + address + i, 1);
send_ack(ud);
}
msync(base, FIRMWARE_PARTITION_SIZE + SWAP_SIZE, MS_SYNC);
}
static void serve_update(uint8_t *base, const char *uart_dev)
{
int ret = 0;
uint8_t buf[8];
int ud = open_uart(uart_dev);
if (ud < 0) {
fprintf(stderr, "Cannot open serial port %s: %s.\n", uart_dev, strerror(errno));
exit(3);
}
while (1) {
/* read STX */
ret = read(ud, buf, 1);
if (ret < 0) {
return;
}
if (ret == 0)
continue;
if ((buf[0] != CMD_HDR_WOLF) && (buf[0] != CMD_HDR_VER)) {
printf("bad hdr: %02x\n", buf[0]);
continue;
}
if (buf[0] == CMD_HDR_VER) {
uint32_t v;
int idx = 1;
send_ack(ud);
while (idx < 5) {
ret = read(ud, buf + idx, 1);
if (ret > 0) {
send_ack(ud);
idx++;
}
else {
printf("UART error while reading target version\n");
break;
}
}
if (idx == 5) {
printf("\r\n** TARGET REBOOT **\n");
v = buf[1] + (buf[2] << 8) + (buf[3] << 16) + (buf[4] << 24);
printf("Version running on target: %u\n", v);
}
continue;
}
/* send ack */
send_ack(ud);
ret = read(ud, buf, 1);
if (ret < 0) {
return;
}
if (ret == 0) {
printf("Timeout!\n");
continue;
}
/* Read command code */
switch(buf[0]) {
case CMD_HDR_ERASE:
send_ack(ud);
uart_flash_erase(base, ud);
break;
case CMD_HDR_READ:
send_ack(ud);
uart_flash_read(base, ud);
break;
case CMD_HDR_WRITE:
send_ack(ud);
uart_flash_write(base, ud);
break;
default:
fprintf(stderr, "Unrecognized command: %02X\n", buf[0]);
break;
}
}
}
void usage(char *pname)
{
printf("Usage: %s binary_file serial_port\nExample:\n%s firmware_v3_signed.bin /dev/ttyUSB0\n", pname, pname);
exit(1);
}
int main(int argc, char *argv[])
{
uint8_t *base_fw;
uint32_t base_fw_ver = 0;
if (argc != 3) {
usage(argv[0]);
}
base_fw = mmap_firmware(argv[1]);
if (base_fw == (void *)(-1)) {
fprintf(stderr, "Error opening binary file '%s'.\n", argv[1]);
exit(2);
}
if (strncmp((char *)base_fw, "WOLF", 4) != 0) {
fprintf(stderr, "Warning: the binary file provided does not appear to contain a valid firmware partition file.\n");
} else {
printf("%s has a wolfboot manifest header\n", basename(argv[1]));
base_fw_ver = fw_version(base_fw);
printf("%s contains version %u\n", basename(argv[1]), base_fw_ver);
}
serve_update(base_fw, argv[2]);
return 0;
}