# Gere o arquivo e a assinatura de atualização de firmware
<a name="lorawan-script-fwupdate-sigkey"></a>

As etapas desse procedimento são opcionais e dependem do gateway que você está usando. Os fabricantes de gateway oferecem a própria atualização de firmware na forma de um arquivo de atualização ou script, e o Basics Station executa esse script em segundo plano. Nesse caso, você provavelmente encontrará o arquivo de atualização do firmware nas notas de lançamento do gateway que está usando. Em vez disso, você pode usar esse arquivo ou script de atualização e passar para [Fazer upload do arquivo de firmware para um bucket do S3 e adicionar um perfil do IAM](lorawan-upload-firmware-s3bucket.md).

Se você não tiver esse script, a seguir são mostrados os comandos a serem executados para gerar o arquivo de atualização do firmware. As atualizações também podem ser assinadas para garantir que o código não tenha sido alterado ou corrompido e que os dispositivos executem códigos publicados somente por autores confiáveis.

**Topics**
+ [Gerar o arquivo de atualização de firmware](#lorawan-firmware-update-script)
+ [Gerar a assinatura de atualização de firmware](#lorawan-generate-signature-fwupdate)
+ [Reveja as próximas etapas](#lorawan-fwupdate-sigkey-next-steps)

## Gerar o arquivo de atualização de firmware
<a name="lorawan-firmware-update-script"></a>

O software LoRa Basics Station executado no gateway é capaz de receber atualizações de firmware na resposta do CUPS. Se você não tiver um script fornecido pelo fabricante, consulte o seguinte script de atualização de firmware escrito para o RAKWireless Gateway baseado em Raspberry Pi. Temos um script básico e o novo binário da estação, arquivo de versão, e `station.conf` estão anexados a ele.

**nota**  
O script é específico para o RAKWireless Gateway. Por isso, será necessário adaptá-lo ao seu aplicativo, dependendo do gateway que você estiver usando.

**Script básico**  
A seguir é mostrado um exemplo de script básico para o RAKWireless Gateway baseado em Raspberry Pi. Você pode salvar os seguintes comandos em um arquivo `base.sh` e, em seguida, executar o script no terminal do navegador da Web do Raspberry Pi.

```
*#!/bin/bash*
execution_folder=/home/pi/Documents/basicstation/examples/aws_lorawan
station_path="$execution_folder/station"
version_path="$execution_folder/version.txt"
station_conf_path="$execution_folder/station_conf"

# Function to find the Basics Station binary at the end of this script 
# and store it in the station path
function prepare_station()
{
 match=$(grep --text --line-number '^STATION:$' $0 | cut -d ':' -f 1) 
 payload_start=$((match + 1)) 
 match_end=$(grep --text --line-number '^END_STATION:$' $0 | cut -d ':' -f 1) 
 payload_end=$((match_end - 1)) 
 lines=$(($payload_end-$payload_start+1)) 
 head -n $payload_end $0 | tail -n $lines  > $station_path
}

# Function to find the version.txt at the end of this script 
# and store it in the location for version.txt
function prepare_version()
{
  match=$(grep --text --line-number '^VERSION:$' $0 | cut -d ':' -f 1) 
  payload_start=$((match + 1))        
  match_end=$(grep --text --line-number '^END_VERSION:$' $0 | cut -d ':' -f 1) 
  payload_end=$((match_end - 1)) 
  lines=$(($payload_end-$payload_start+1)) 
  head -n $payload_end $0 | tail -n $lines  > $version_path
}

# Function to find the version.txt at the end of this script 
# and store it in the location for version.txt
function prepare_station_conf()
{
 match=$(grep --text --line-number '^CONF:$' $0 | cut -d ':' -f 1) 
 payload_start=$((match + 1)) 
 match_end=$(grep --text --line-number '^END_CONF:$' $0 | cut -d ':' -f 1) 
 payload_end=$((match_end - 1)) 
 lines=$(($payload_end-$payload_start+1)) 
 head -n $payload_end $0 | tail -n $lines  > $station_conf_path
}

# Stop the currently running Basics station so that it can be overwritten
# by the new one
killall station

# Store the different files
prepare_station
prepare_versionp
prepare_station_conf

# Provide execute permission for Basics station binary
chmod +x $station_path

# Remove update.bin so that it is not read again next time Basics station starts
rm -f /tmp/update.bin

# Exit so that rest of this script which has binaries attached does not get executed
exit 0
```

**Adicionar script de carga**  
Ao script básico, anexamos o binário Basics Station, o version.txt que identifica a versão para a qual atualizar e `station.conf` em um script chamado `addpayload.sh`. Em seguida, execute este script.

```
*#!/bin/bash
*
base.sh > fwstation

# Add station
echo "STATION:" >> fwstation
cat $1 >> fwstation
echo "" >> fwstation
echo "END_STATION:" >> fwstation

# Add version.txt
echo "VERSION:" >> fwstation
cat $2 >> fwstation
echo "" >> fwstation
echo "END_VERSION:" >> fwstation

# Add station.conf
echo "CONF:" >> fwstation
cat $3 >> fwstation
echo "END_CONF:" >> fwstation

# executable
chmod +x fwstation
```

Depois de executar esses scripts, você pode executar o seguinte comando no terminal para gerar o arquivo de atualização do firmware, `fwstation`.

```
$ ./addpayload.sh station version.txt station.conf
```

## Gerar a assinatura de atualização de firmware
<a name="lorawan-generate-signature-fwupdate"></a>

O software LoRa Basics Station oferece atualizações de firmware assinadas com assinaturas ECDSA. Para oferecer suporte a atualizações assinadas, você precisará:
+ Uma assinatura que deve ser gerada por uma chave privada ECDSA e com menos de 128 bytes. 
+ A chave privada que é usada para a assinatura e deve ser armazenada no gateway com o nome do arquivo do formato `sig-%d.key`. Recomendamos usar o nome do arquivo `sig-0.key`.
+ Um CRC de 32 bits sobre a chave privada.

A assinatura e o CRC serão passados para as APIs AWS IoT Core for LoRaWAN. Para gerar os arquivos anteriores, você pode usar o script `gen.sh` a seguir, inspirado no exemplo [basicstation](https://github.com/lorabasics/basicstation/blob/master/examples/cups/prep.sh) no repositório do GitHub.

```
*#!/bin/bash

*function ecdsaKey() {
    # Key not password protected for simplicity    
    openssl ecparam -name prime256v1 -genkey | openssl ec -out $1
}

# Generate ECDSA key
ecdsaKey sig-0.prime256v1.pem

# Generate public key
openssl ec -in sig-0.prime256v1.pem -pubout -out sig-0.prime256v1.pub

# Generate signature private key
openssl ec -in sig-0.prime256v1.pub -inform PEM -outform DER -pubin | tail -c 64 > sig-0.key

# Generate signature
openssl dgst -sha512 -sign sig-0.prime256v1.pem $1 > sig-0.signature

# Convert signature to base64
openssl enc -base64 -in sig-0.signature -out sig-0.signature.base64

# Print the crc
crc_res=$(crc32 sig-0.key)printf "The crc for the private key=%d\n" $((16#$crc_res))

# Remove the generated files which won't be needed later
rm -rf sig-0.prime256v1.pem sig-0.signature sig-0.prime256v1.pub
```

A chave privada gerada pelo script deve ser salva no gateway. O arquivo da chave está em formato binário.

```
./gen_sig.sh fwstation 
read EC key
writing EC key
read EC key
writing EC key
read EC key
writing EC key
The crc for the private key=3434210794

$ cat sig-0.signature.base64 
MEQCIDPY/p2ssgXIPNCOgZr+NzeTLpX+WfBo5tYWbh5pQWN3AiBROen+XlIdMScv
AsfVfU/ZScJCalkVNZh4esyS8mNIgA==

$ ls sig-0.key
sig-0.key

$ scp sig-0.key pi@192.168.1.11:/home/pi/Documents/basicstation/examples/iotwireless
```

## Reveja as próximas etapas
<a name="lorawan-fwupdate-sigkey-next-steps"></a>

Agora que você gerou o firmware e a assinatura, vá para o próximo tópico para fazer o upload do arquivo de firmware, `fwstation`, em um bucket do Amazon S3. O bucket é um contêiner que armazenará o arquivo de atualização do firmware como um objeto. Você pode adicionar um perfil do IAM que dará ao servidor CUPS permissão para ler o arquivo de atualização do firmware no bucket do S3.