Qual é motivo do reset do microcontrolador STM32F

No post anterior vê-se como configurar os dois Watchdogs do microcontrolador STM32F.

Porém, é possível saber qual o motivo que causou o reset? O microcontrolador ligou? Foi pressionado o botão de reset? Ou foi algum dos Watchdogs?

A resposta é: sim, é possível determinar a causa do reset.

Para determinar o motivo do reset, basta avaliar o valor lido no registrador RCC_CSR. Os seis bits mais significativos são utilizados para determinar a fonte do reset:

BitValorMotivo
310x80000000Low-power reset
Reset de baixo-consumo
300x40000000Window watchdog
Watchdog de janela
290x20000000Independent watchdog
Watchdog independente
280x10000000Software reset
Reset por software
270x08000000POR/PDR reset
Reset de energização
260x04000000Pin reset
Reset pelo pino

Abaixo segue o código que lê a fonte do reset, limpa o registrador e determina a fonte, executando blocos de acordo. Com isso é possível determinar tomar ações diferenciadas para cada um dos casos. Note que é usada a operação lógica & (E bit-a-bit).

Para obter apenas o motivo do último reset é necessário realizar a limpeza do registrador. Isso é necessário porque quando ocorre um reset, os bits do registrador não são limpados para zero, mas apenas setados para um, fazendo-os acumular cada uma das fontes de reset que ocorreram.

  uint32_t reset_source = 0;

  // Lê a fonte do reset
  reset_source = RCC->CSR;

  // Limpa o registrador
  __HAL_RCC_CLEAR_RESET_FLAGS();

  if (reset_source & RCC_CSR_LPWRRSTF) {
    // 0x80000000 Low-power reset
  }

  if (reset_source & RCC_CSR_WWDGRSTF) {
    // 0x40000000 Window watchdog reset
  }

  if (reset_source & RCC_CSR_IWDGRSTF) {
    // 0x20000000 Independent watchdog reset
  }

  if (reset_source & RCC_CSR_SFTRSTF) {
    // 0x10000000 Software reset
  }

  if (reset_source & RCC_CSR_PORRSTF) {
    // 0x08000000 POR/PDR reset
  }

  if (reset_source & RCC_CSR_PINRSTF) {
    // 0x04000000 Pin reset
  }

Veja abaixo dois casos:

  • Quando o debugger grava e inicia o debug do programa, obtém-se o valor 0x14000000, indicando que houve dois resets:
    • Reset por software; e
    • Reset pelo pino.
  • Quando o reset é causado ao pressionar o pino de reset, obtém-se o valor 0x04000000.

Conclusão

Portanto, podemos verificar qual a fonte de um reset, ou seja, qual o seu motivo. Dessa forma, podemos determinar se houve um reset por algum Watchdog, pino, energização, etc. Com isso podemos ter uma dica do que pode ter acontecido logo antes do reset.

Os Dois Watchdogs do microcontrolador STM32F

No post anterior foi visto como configurar o clock do microcontrolador STM32F para rodar a 72 MHz, baseado no cristal externo.

Neste post serão explicados pra que são e como configurar os dois Watchdogs do STM32F (IWDG e WWDG).

O que é um Watchdog

O Watchdog (cão de guarda) é um periférico interno do microcontrolador que serve para identificar mal funcionamento do programa e reiniciar o sistema a partir de um reset.

É preciso recarregar/alimentar (reload/feed) periodicamente o Watchdog para que ele não cause um reset.

Então, quando um programa entra em um laço infinito ou entra em algum estado inconsistente que evita que o Watchdog seja adequadamente recarregado, o sistema vai resetar em um tempo máximo estipulado pela configuração do Watchdog.

IWDG – Independent Watchdog

O IWDG (Watchdog Independente) é chamado assim porque ele utiliza uma fonte de clock independente do clock do sistema.

Para habilitar o IWDG:

  • Abra o arquivo IOC do projeto, entrar em “Pinout & Configuration > IWDG” e então habilitá-lo em “Activated”.
  • O valor do prescaler (divisor de clock) e o valor de reload (recarregamento) podem ser configurados para se obter um tempo máximo de reset com precisão.
  • Note que o clock usado pelo IWDG vem de um oscilador RC interno de 40 kHz, o que pode ser visto em “Clock Configuration”.

O IWDG pode ser recarregado a qualquer momento, independente do valor do seu contador. Ele vai causar um reset quando seu contador chegar até zero.

Com um clock de 40 kHz, prescaler igual a 16 e valor de recarregamento 4095, o IWDG causará um reset em de 1,6 segundos.

T = 16*(4095+1)/40000

Para evitar isso, chamamos a função que reseta o IWDG no fim do laço while(1){…}, o qual demora 1.0 segundo para ser executado:

int main(void) {
  // ...
  while (1)
  {
    // ...

    // Recarrega o IWDG
    HAL_IWDG_Refresh(&hiwdg);

    // ...
  }
   // ...
}

Note que, para poder debugar o microcontrolador com o IWDG ativo, é necessário configurá-lo para que pare a contagem quando o processador pára em um breakpoint.

Na função MX_IWDG_Init() adicione as linhas a seguir:

static void MX_IWDG_Init(void)
{
  // ...

  // Necessário para parar o IWDG quando
  // o programa para em um breakpoint
  __HAL_DBGMCU_FREEZE_IWDG();

  // ...
}

WWDG – Window Watchdog

O WWDG (Watchdog de Janela) é chamado assim porque com ele é possível configurar uma janela de tempo onde ele deve ser recarregado, de forma a não gerar um reset do microcontrolador. Se recarregar antes do tempo ou depois do tempo o reset ocorre.

Em outras palavras, o WWDG pode ser configurado para exigir um tempo mínimo e máximo entre os recarregamentos, causando um reset caso seja recarregado antes do tempo mínimo ou caso não seja recarregado no tempo máximo.

Este Watchdog funciona de forma um pouco diferente:

  • Você configura um valor de recarregamento, por exemplo 127 (0x7F) a partir do qual o contador é decrementado. Se o valor do contador é reduzido a 63 (0x3F) ocorre o reset.
  • Você também configura um valor de janela, o valor a partir do qual é permitido recarregar o WWDG. Se, quando recarregado, o contador é maior que este valor, o WWDG causa um reset. Se é menor ou igual, o WWDG é recarregado com sucesso, sem gerar um reset.
    • Se você configurar este valor como sendo igual ao valor de recarregamento, o WWDG funciona como um Watchgod normal, sem o tempo mínimo.
  • Você pode habilitar a interrução do WWDG, que ocorre quando o o valor do contador é reduzido a 64 (0x40).

Para habilitar o WWDG:

  • Abra o arquivo IOC do projeto, entrar em “Pinout & Configuration > WWDG” e então habilitá-lo em “Activated”.
  • Configure em “prescaler” o valor do divisor de clock.
  • Configure em “window value” o valor da janela (início da janela).
  • Configure em “down-counter” o valor do recarregamento (início da contagem).
  • Habilite a interrupção do WWDG e, na aba “NVIC Settings” habilite a interrupção.

Com um clock de 72 MHz, portanto 36 MHz em APB1, prescaler igual a 8 e valor de recarregamento igual a 127, o WWDG causará um reset em de 58,2 milissegundos após o o recarregamento anterior.

T1 = 8*4096*(127-63)/36000000

Com o valor da janela igual a 64, a janela de recarregamento inicia em 57,3 milissegundos após o recarregamento anterior.

T2 = 8*4096*(127-64)/36000000

Dessa forma há uma janela de tempo de 0,091 milissegundos para que o recarregamento ocorra: depois de T2 e antes de T1.

ΔT = T1-T2 = 8*4096*(64-63)/36000000

+--------------------------+
| Recarrega          Reset |
| |-------------|----|     |
| T0            T2   T1    |
|                <-->      |
|                Janela    |
+--------------------------+

Para evitar isso, no arquivo main.c (ou em qualquer arquivo) criamos a função HAL_WWDG_EarlyWakeupCallback(), a qual chama a função de reset do WWDG.

Essa função criada é automaticamente chamada pelo tratamento da interrupção do WWDG.

void HAL_WWDG_EarlyWakeupCallback(WWDG_HandleTypeDef *hwwdg) {
  // Recarrega o WWDG
  HAL_WWDG_Refresh(hwwdg);
}

De forma semelhante ao IWDG, para que seja possível debugar o microcontrolador com o WWDG ativo, é necessário configurá-lo para que pare a contagem quando a execução é pausada em um breakpoint.

Na função MX_WWDG_Init() adicione as linhas a seguir:

static void MX_WWDG_Init(void)
{
  // ...

  // Necessário para parar o WWDG quando
  // o programa para em um breakpoint
  __HAL_DBGMCU_FREEZE_WWDG();

  // ...
}

Por que dois Watchdogs?

Você pode se perguntar porque seriam necessários dois Watchdogs?

Caso o clock principal do sistema falhe, o que pode acontecer por exemplo escrevendo indevidamente em certos registradores, o WWDG vai parar de contar e, portanto, não causará reset. Nesse caso o IWDG entrará em ação, reiniciando o microcontrolador.

Além disso, como foi feito neste exemplo, ambos podem cuidar de dois escopos diferentes:

  • IWDG pode ser recarregado a cada 1 segundo, garantindo que o laço de execução principal está sendo executado; e
  • WWDG pode ser recarregado pela sua interrupção, garantindo que as interrupções não ficam desabilitadas por períodos muito longos.

Conclusão

Assim, com o uso de ambos os Watchdogs do STM32F, podemos obter uma garantia de que o programa está operando de forma correta: executando todas as suas tarefas e mantendo interrupções habilitadas.

Configurando Clock do microcontrolador STM32F

No post anterior foi explicado como configurar um projeto no STM32CubeIDE e debugar o microcontrolador STM32F usando o debugger ST-LINK V2.

Neste post será visto como configurar o clock do microcontrolador para rodar com uma frequência de 72 MHz, utilizando o cristal de 8MHz que vem na placa de desenvolvimento. Na foto este cristal está logo à direita do microcontrolador.

Por padrão o clock do microcontrolador STM32F vem de um oscilador RC interno de 8MHz, calibrado em fábrica. Porém, de acordo com o datasheet, sua frequência pode variar até 2,5 %, o que facilmente se torna problemático em sistemas que fazem uso de comunicação ou de alguma outra forma dependem da precisão do tempo.

Um cristal, por sua vez possui uma variação muito menor na frequência de operação, por exemplo 100 ppm, ou seja, 0,01 %.

Configurando o clock para 72 MHz

Para habilitar e configurar o cristal oscilador:

  • Abra o arquivo IOC do projeto.
  • Habilite o cristal: entre em “Pinout & Configuration > System Core > RCC” e habilite o cristal “Crystal/Ceramic Resonator”.
    • Se necessário, ajuste a tensão de operação, que neste caso é 3,3 V.
  • Configure o clock: entre em “Clock Configuration” e ajuste:
    • “PLL Source Mux” para HSE.
    • “PLL Mul” para x9 (multiplica 8 MHz do cristal por 9).
    • “System Clock Mux” para PLLCLK.
    • “APB1 Prescaler para /2 (divide o clock de 72 MHz por 2).
  • Caso alguma configuração do clock estiver inadequada (fora da especificação do fabricante), os pontos onde há erros são destacados pela interface gráfica.
  • Agora basta salvar e confirmar que quer gerar o código.

Comparando os clocks de 8 MHz e de 72 MHz

Para comparar o clock anterior com o atual, pode-se usar o bloco de código abaixo, colocado logo antes do laço while(1){…}.

  // Conta quanto incrementos faz em 1 segundo
  // Clock 72 MHz: Cristal externo
  {
    uint32_t wait = 1000; // 1 segundo
    uint32_t count = 0;
    uint32_t tickstart = HAL_GetTick();

    while ((HAL_GetTick() - tickstart) < wait)
    {
        count++;
    }

    count = 0;
  }

Este código conta quantas vezes a variável count é incrementada enquanto se espera o delay de 1 segundo. O código foi adaptado da função HAL_Delay().

Executando para cada uma das configurações temos o seguinte resultado:

OsciladorFrequênciaIncrementosProporção
RC interno8 MHz274.0301 x
Cristal externo72 MHz1.892.9686.9 x

Dessa forma, rodando a 72 MHz o contador é incrementado 6.9 vezes mais rápido do que quando rodando a 8 MHz. Revelando um ganho em velocidade, porém menor do que as 9.0 vezes que o clock foi acelerado.

Conclusão

Dessa forma, configurando o clock em 72 MHz usando o cristal externo de 8 MHz, podemos acelerar o processamento e aumentar a precisão temporal do microcontrolador.

Portanto, podemos fazer o LED piscar com mais precisão e fazer mais trabalho entre cada uma das piscadas.

Debugando microcontrolador STM32F

Esta semana chegou em minhas mãos uma pequena placa de desenvolvimento e o seu gravador.

Esta placa possui o microcontrolador STM32F103C8T6, um ARM Cortex-M3 que roda em até 72 MHz, com 64 kB de flash (programa), 20 kB de RAM (variáveis) e diversas interfaces de comunicação.

Criando um projeto

Para programar vamos usar a STM32CubeIDE, uma IDE focada em microcontroladores fornecida pela STM. Vamos criar o projeto:

  • Crie o projeto
    • Menu File > New > STM32 Project.
    • Menu Arquivo > Novo > Projeto STM 32.
  • Em “Part Number” (à esquerda) digite o código do microcontrolador: STM32F103C8. Selecione na lista e avance (Next).
  • Dê um nome ao projeto: Blink (piscar). Finalize (Finish).
  • Abrirá este arquivo Blink.ioc, que contém as configurações do microcontrolador para geração automática do código do hardware.
  • Configure a interface de debug: à esquerda entre em SYS, selecione “Serial Wire” em Debug e selecione “SysTick” em Timebase Source (fonte de temporização). Note que dois pinos são marcados em verde, pois são usados pela interface de debug.
  • Na placa, o LED é indicado como PC13, então configuramos este como saída (GPIO_Output).
  • Agora basta salvar e confirmar que deseja gerar o código.

Programando para o LED piscar

Para fazer o LED piscar é muito simples. Usamos duas funções:

  • HAL_GPIO_WritePin(), para alterar o valor o IO que controla o LED; e
  • HAL_Delay(), para aguardar o tempo passar.

O arquivo com a função main() se encontra em Core/Src/main.c. Este é um dos arquivos gerados automaticamente pela IDE.

Note que você pode modificar o código entre os comentários de início (USER CODE BEGIN XXX) e fim (USER CODE END XXX).

A IDE usa estes comentários para saber onde inserir o código gerado automaticamente. O que estiver fora das regiões permitidas será eliminado na próxima vez que o arquivo Blink.ioc for editado e o código for gerado novamente.

Encontre o laço infinito [while(1){…}] e adicione as chamadas de função para aguardar (delay) e escrever no pino (write pin).

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    // Desligar LED
    HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
    HAL_Delay(500);

    // Ligar LED
    HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
    HAL_Delay(500);

    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */

Configurando o debug

Para configurar o debug basta seguir os passos abaixo:

  • Primeiro é necessário compilar o projeto.
    • Menu Project > Build Project
    • Menu Projeto > Compilar Projeto
  • Abra as configurações de debug
    • Menu Run > Debug Configurations…
    • Menu Executar > Configurações de Debug/Depuração…
  • Selecione a opção “STM32 Cortex-M C/C++ Application”, clique nela com o botão contrário e crie uma nova configuração (New Configuration).
  • A configuração de debug deve se parecer com as duas da imagem. Abas: Main e Debugger.
  • Inicie o debugger clicando em “Debug”.
  • O programa vai parar no início da função main().
  • Então é possível usar:
    • “Step Into (F5)” para prosseguir passo a passo, entrando nas funções chamadas;
    • “Step Over (F6)” para prosseguir passo a passo, sem entrar nas funções chamadas;
    • “Step Return (F7)” para parar no retorno da função atual; e
    • “Resume (F8)” para continuar, parando no próximo breakpoint.
  • Para criar breakpoints basta dar um clique duplo no número da linha.

Conclusão

Agora é só se divertir com a placa de desenvolvimento: configure os pinos como entrada ou saída, escreva e leia eles.

Autenticação Criptográfica

Resumão

MAC significa Código de Autenticação de Mensagem (Message Authentication Code). Este código é enviado junto com a mensagem, para provar sua integridade e autenticidade.

Integridade: Se algum bit da mensagem for alterado o MAC fica inválido. Semelhante a enviar a mensagem junto com sua hash.

Autenticidade: Apenas quem possui a chave criptográfica K é capaz de criar e verificar uma mensagem autenticada com esta chave.

A partir da chave e da mensagem criamos o código de autenticação, também chamado de TAG de autenticação. Enviamos o par (MENSAGEM, TAG) e quem recebe este par pode verificar a integridade e autenticidade da mensagem usando a chave K.

A chave K e a tag de autenticação precisam ambas ter comprimentos de acordo com o nível de segurança da aplicação.

Autenticação HMAC

A primeira opção é HMAC, que usa uma Função Hash para criar o código de autenticação. Eis o algoritmo:

se (comprimento(K) > Hash.Tamanho_Bloco) { K = Hash(K) }
enquanto (comprimento(K) < Hash.Tamanho_Bloco) { K = K || 00 }
K1 = K XOR 5C…5C
K2 = K XOR 36…36
TEMP = Hash(K2 || MENSAGEM)
TAG = Hash(K1 || TEMP)

Usamos uma chave para criar duas chaves diferentes. Cada uma é usada em uma etapa: criar uma hash da mensagem (TEMP) e tag de autenticação (TAG). Note que estamos utilizando o símbolo || com o significado de concatenação.

Antes de gerar K1 e K2, a chave K deve ter o tamanho do bloco da função hash. Este preenchimento do bloco permite pré-computar Hash(K1) e Hash(K2), acelerando a autenticação.

Se o comprimento da chave K for maior que o bloco de entrada da função hash (64 bytes/512 bits para SHA-256 ou 128 bytes/1024 bits SHA-512), primeiro realizamos a hash da chave.

Então, se o comprimento da cahve K for menor que o tamanho do bloco de entrada da função hash adicionamos zeros até completar o tamanho.

Podemos usar qualquer função hash com HMAC.

TAG =HMAC-SHA256(K, MENSAGEM)
TAG =HMAC-SHA512(K, MENSAGEM)

Obviamente vamos utilizar hashes que são criptograficamente seguras, por exemplo SHA2 e SHA3, e com comprimentos de saída adequados para o nível de segurança exigido pela aplicação. A chave K também precisa ser longa o suficiente para ser segura.

Autenticação KMAC

KMAC é uma extensão do padrão SHA3 usando XOFs (funções hash com saída de comprimento variável) baseada na esponja criptográfica Keccak.

Uma vantagem clara de usar KMAC, é que permite diferentes comprimentos de saída, gerando TAGs completamente diferentes para cada comprimento de saída.

KMAC é mais flexível e complicada que HMAC. Não vamos entrar em detalhes.

Podemos escolher entre os níveis de segurança máximos de 128 e 256 bits.

TAG =KMAC-128(K, MENSAGEM, COMPRIMENTO_TAG)
TAG =KMAC-256(K, MENSAGEM, COMPRIMENTO_TAG)

A chave K e a TAG precisam ter comprimentos compatíveis com o nível de segurança da aplicação e a função KMAC também precisa ser escolhida adequadamente. Ex: chave 256 bits e tag 256 bits só fazem sentido com KMAC-256.

Autenticação CBC-MAC

É possível também usar o sistema de autenticação CBC-MAC, que usa cifras em blocos como AES em modo CBC.

CBC-MAC possui características semelhantes a HMAC. Usa duas chaves diferentes K1 e K2, geradas a partir de uma chave mestre K. Primeiro calculamos Cn, o último bloco do modo CBC com a chave K1. Então criptografamos este bloco com a chave K2, gerando a tag de autenticação.

K1 = K XOR 5C…5C
K2 = K XOR 36…36
C0 = EK1(IV)
Ci = EK1(Pi XOR Ci-1)
Cn = EK1(Pn XOR Cn-1)
TAG = EK2(Cn)

A tag de autenticação tem o mesmo comprimento do bloco da cifra, 128 bits no caso de AES.

TAG = CBC-MAC-AES(K, MENSAGEM)

Porque não usar HMAC ou KMAC sempre? Em sistemas embarcados com pouca memória de programa, por exemplo, pode ser inviável implementar uma cifra (como AES-128) e também uma hash (como SHA2 ou SHA3). Então usa-se a cifra para ambos criptografia e autenticação.

Vetor de inicialização e MACs

Note que no modo CBC-MAC, deixamos explícito a existência de um vetor de inicialização (IV).

Este é um nonce, um número utilizado apenas uma vez com a chave K. Ele pode ser aleatório ou um contador incrementado a cada mensagem.

O nonce serve para que duas mensagens tenham tags diferentes, mesmo se o conteúdo seja idêntico.

HMAC e KMAC também podem utilizar um IV, basta colocá-lo logo antes da mensagem:

MENSAGEM = IV || MENSAGEM

Isso é semelhante ao CBC-MAC, que coloca o IV no bloco zero, antes da mensagem.

Se considerarmos os IV como sendo parte da mensagem, sua função é de fazer com que sempre tenhamos uma mensagem diferente sendo autenticada, gerando sempre uma tag diferente.

Note que o vetor de inicialização (IV) é enviado junto com a mensagem, ou seja, não é secreto. Em alguns casos ele não é transmitido, se pode ser identificado pelo contexto.

Links Externos

Wikipedia HMAC

HMAC – FIPS PUB 198-1 – The Keyed-Hash Message Authentication Code

KMAC – NIST 800-185 – SHA-3 Derived Functions

Wikipedia CBC-MAC

CBC-MAC – FIPS PUB 113 – Computer Data Authentication

Leia mais:

Veja mais posts na Categoria Criptografia!

Criptografia Modos de Operação

Resumão

Exitem diversos modos de operação de criptografia com os quais podemos utilizar cifras de blocos, como a Criptografia AES.

Cada um tem suas características, que os fazem mais ou menos adequados para certas aplicações.

Os modos de operação mais comuns são: ECB, CBC, OFB, CFB, CTR.

EBC – Electronic Codebook

Livro Eletrônico de Códigos.

Cada chave criptográfica possui um livro de códigos, que relaciona dados plenos com dados cifrados. Este modo de operação é o mais simples, mas dificilmente é recomendado.

Encriptar:
Ci = EK(Pi)

Para n blocos, envia-se:
C1, C2, …, Cn

Decriptar:
Pi = DK(Ci)

Note que este modo revela igualdade igualdade de blocos.

Este modo exige que as mensagens sejam de tamanho divisível pelo tamanho do bloco (16 bytes para AES). Caso contrário, a mensagem deve ser preenchida (padding). [TODO Link padding.]

CBC – Cipher Block Chaining

Cadeia de Blocos Cifrados.

Os dados plenos Pi são misturados (XOR) com a cifra Ci-1 do bloco anterior antes de encriptar.

Encriptar:
C0 = EK(IV)
Ci = EK(Pi XOR Ci-1)

Para n blocos, envia-se:
IV, C1, C2, …, Cn

Decriptar:
C0 = EK(IV)
Pi = DK(Ci) XOR Ci-1

Este modo utiliza um vetor de inicialização (IV) que deve ser um número utilizado apenas uma vez (nonce) para cada chave K, ou seja, cada mensagem criptografada com a chave K precisa de um IV diferente. O IV não precisa ser secreto, pode ser transmitido junto com a mensagem.

Se repetir o mesmo IV os dados cifrados revelam igualdade dos primeiros blocos e a diferença (XOR) do primeiro bloco diferente. Conhecendo uma mensagem, revela-se a outra, exceto depois do bloco diferente. Isso no melhor dos casos, ou seja, com uma cifra ideal. Algumas cifras são extremamente fracas caso houver repetição de IV.

Note que o primeiro bloco cifrado é misturado com C0, que é o IV encriptado. Não se envia C0.

Este modo, assim como ECB, também exige que as mensagens sejam de tamanho divisível pelo tamanho do bloco ou que o último bloco seja preenchido (padding).

OFB – Output Feedback

Realimentação da saída.

Este modo transforma uma cifra de blocos (block cipher) em uma cifra de corrente (stream cipher).

Os dados plenos Pi são misturados (XOR) com a fonte pseudo-aleatória Oi-1 para realizar a encriptação.

Encriptar:
O0 = EK(IV)
Oi = EK(Oi-1)
Ci = Pi XOR Oi-1

Para n blocos, envia-se:
IV, C1, C2, …, Cn

Decriptar (idêntico a encriptar):
O0 = EK(IV)
Oi = EK(Oi-1)
Pi = Ci XOR Oi-1

Este modo utiliza um vetor de inicialização (IV) que deve ser um número utilizado apenas uma vez (nonce) para cada chave K, ou seja, cada mensagem criptografada com a chave K precisa de um IV diferente. O IV não precisa ser secreto, pode ser transmitido junto com a mensagem.

Se repetir o mesmo IV os dados cifrados revelam igualdade dos blocos e a diferença (XOR) dos blocos diferentes. Conhecendo uma mensagem, revela-se a outra. [Novamente… Isso no melhor dos casos, ou seja, com uma cifra ideal. Algumas cifras são extremamente fracas caso houver repetição de IV.]

Este modo não exige preenchimento (padding). Se o último bloco não está completo com dados plenos, podemos enviar apenas estes bytes encriptados de Cn, ignorando o restante dos bytes. Note que isso revela o tamanho da mensagem. Se o tamanho da mensagem deve ser secreto ou obfuscado é necessário realizar o preenchimento (padding).

CFB – Cipher Feedback

Realimentação de cifra.

Este modo transforma uma cifra de blocos (block cipher) em uma cifra de corrente (stream cipher).

Os dados plenos Pi são misturados (XOR) com a cifra anterior Ci-1 para realizar a encriptação.

Encriptar:
C0 = IV
Ci = Pi XOR EK(Ci-1)

Para n blocos, envia-se:
IV, C1, C2, …, Cn

Decriptar (idêntico a encriptar):
C0 = IV
Pi = Ci XOR EK(Ci-1)

Este modo utiliza um vetor de inicialização (IV) que deve ser um número utilizado apenas uma vez (nonce) para cada chave K, ou seja, cada mensagem criptografada com a chave K precisa de um IV diferente. O IV não precisa ser secreto, pode ser transmitido junto com a mensagem.

Como no modo CBC, se repetir o mesmo IV os dados cifrados revelam igualdade dos primeiros blocos e a diferença (XOR) do primeiro bloco diferente. Conhecendo uma mensagem, revela-se a outra, exceto depois do bloco diferente. [Novamente… Isso no melhor dos casos, ou seja, com uma cifra ideal. Algumas cifras são extremamente fracas caso houver repetição de IV.]

Este modo não exige preenchimento (padding). Se o último bloco não está completo com dados plenos, podemos enviar apenas estes bytes encriptados de Cn, ignorando o restante dos bytes. Note que isso revela o tamanho da mensagem. Se o tamanho da mensagem deve ser secreto ou obfuscado é necessário realizar o preenchimento (padding).

Outros modos

Existem ainda outros modos de operação.

CTR (Counter): Usa um nonce (número usado apenas uma vez) em conjunto com um contador para gerar uma sequência pseudo-aleatória e realizar XOR com os dados plenos (parecido com o que acontece nos modos OFB e CFB).

CFB “parcial”: É possível usar blocos menores do que o bloco da cifra no modo CFB.

Links Externos

Wikipedia Block Cipher Modes of Operation

NIST Recommendation for Block Cipher Modes of Operation

Leia mais:

Veja mais posts na Categoria Criptografia!

Criptografia AES

Resumão

A criptografia AES é um padrão de criptografia simétrica em blocos.

A criptografia tem o objetivo de esconder uma mensagem de uma pessoa que não deve lê-la. Uma função criptográfica possui uma chave e uma função inversa. Existem dois tipos de criptografia: simétrica e assimétrica.

Criptografia simétrica tem a característica de que todas as pessoas realizando a comunicação devem possuir a mesma chave.

Mesma chave = Criptografia simétrica.

Atualmente existem dois padrões de função criptográfica simétrica considerados seguros: AES e 3DES (DES triplo). Recomenda-se sempre utilizar AES, pois é mais rápido e mais seguro que 3DES.

O padrão AES trabalha em blocos de dados de 128 bits (16 bytes), ou seja, a entrada e a saída da função criptográfica tem este tamanho, e pode utilizar chaves criptográficas de 128, 192 e 256 bits, dependendo do nível de segurança necessário para a aplicação.

O padrão 3DES trabalha com blocos de 64 bits (8 bytes) e possui chaves de 112 bits.

Se a aplicação exige n bits de segurança, utilize uma função criptográfica de segurança equivalente. Na dúvida ou se não estiver especificado, utilize 128 bits de segurança.

Na dúvida ou se não estiver especificado, utilize 128 bits de segurança.

Função criptográficaTamanho do bloco (Entrada/Saída)Tamanho da chave (Segurança)Função hash equivalente
3DES (DES triplo)64 bits (8 bytes)112 bitsSHA-224
SHA3-224
AES-128128 bits (16 bytes)128 bitsSHA-256
SHA3-256
AES-192128 bits (16 bytes)192 bitsSHA-384
SHA3-384
AES-256128 bits (16 bytes)256 bitsSHA-512
SHA3-512
Funções criptográficas simétricas seguras AES e 3DES, tamanho do bloco, tamanho da chave, segurança e funções hash de segurança equivalente.

Hash e Criptografia

Funções Hash e Funções de Criptografia tem objetivos diferentes.

A hash serve para gerar um valor associado a uma mensagem. Qualquer outra pessoa pode calcular esse valor a partir da mensagem, desde que conheça qual algoritmo usar.

A criptografia serve para esconder uma mensagem de quem não possua a chave utilizada para encriptar. Mesmo sabendo o algoritmo utilizado, sem saber a chave deve ser muito difícil (praticamente impossível) determinar qual a mensagem a partir dela encriptada.

Ainda, diferente de uma função hash, uma função de criptografia possui uma chave e uma função inversa. Uma função hash é utilizada por todos da mesma maneira para dar o mesmo resultado, enquanto uma função criptográfica pode ser utilizada com chaves diferentes, dando resultados diferentes. A operação inversa é importante pois quem recebe a mensagem criptografada deve ser capaz de, através da chave, reverter ela para a mensagem original.

Para uma função criptográfica ser considerada segura: sua segurança deve depender apenas da chave; a mensagem criptografada deve ser indistinguível de valores gerados aleatoriamente; e conhecendo a mensagem e a mensagem criptografada, não deve ser possível determinar a chave.

Padrão de Criptografia AES

O padrão AES (Advanced Encryption Standard – Padrão de Criptografia Avançado) é um padrão de criptografia simétrica de blocos.

“Simétrica” significa que a mesma chave é utilizada para encriptar e para decriptar. “Blocos” significa que ela opera em um número fixo de bits.

A criptografia AES opera em blocos de 128 bits (16 bytes), ou seja, pega um bloco como entrada e gera como saída outro bloco de mesmo tamanho, com os bits misturados de acordo com a chave utilizada.

A chave utilizada na criptografia AES pode ser de três tamanhos: 128, 192, 256 bits. O tamanho da chave é escolhido a partir do nível de segurança exigido pela aplicação.

Encriptar um bloco com o algoritmo da criptografia AES consiste em executar diversas rodadas (turnos) de quatro operações: AddRoundKey, SubBytes, ShiftRows, MixColumns. Cada uma dessas operações possui uma função dentro do algoritmo.

Cada uma dessas operações tem uma operação inversa, utilizada na decriptação.

Adicionar chave da rodada (AddRoundKey)

Faz-se XOR do bloco com um a chave da rodada.

Essa é a única parte do algoritmo AES onde a chave criptográfica é utilizada e é ela que faz cada chave dar uma saída diferente.

A “chave da rodada” é um valor obtido a partir da chave de criptográfica, utilizando o algoritmo de escalonamento de chaves (key sechedule).

Adição ou XOR?

Note que no nome “AddRoundKey” falamos em “adicionar”, mas a operação utilizada é XOR. Eis a explicação:

O padrão AES não pensa nos bytes como números, mas como polinômios em GF(28).

Cada bit representa um coeficiente do polinômio. Por exemplo o byte 00001001, em vez do número 1×23 + 1×20 = 9, é o polinômio 1×x3 + 1×x0 = x3 + 1.

Os coeficientes só podem ser 0 ou 1 e, quando fazemos adição, consideramos sempre módulo 2, ou seja 0+0=0, 1+0=1, 0+1=1 e 1+1=0, o que é igual a operação binária XOR.

Por que usar essa matemática esquisita? Ela tem vantagens, características interessantes, que são utilizadas!

Substituição não-linear (SubBytes)

Cada um dos 16 bytes do bloco são trocados por outros 16 bytes, de acordo com uma tabela de substituição.

Esta é a única operação não-linear do algoritmo AES. A existência de operações não-lineares dificultam a utilização de técnicas lineares de criptanálise.

Esta substituição faz difusão dos bits dentro de um byte, ou seja, espalha os bits dentro de um byte.

DE onde veio tal tabela?

Note que a tabela não foi simplesmente inventada.

Ela foi criada a partir de uma propriedade muito legal dos polinômios GF(28). Lembra?

Todo polinômio tem um inverso multiplicativo, ou seja, todo polinômio p possui um inverso q = 1/p tal que pq = 1.

Devemos considerar a multiplicação de p e q módulo (resto da divisão por) um outro polinômio, que deve ser irredutível. Polinômio irredutível é como se fosse um “polinômio primo”, não pode ser divisível por outro polinômio, similar a números primos não serem divisíveis por outros números. O polinômio do módulo utilizado no algoritmo é x8 + x4 + x3 + x + 1.

Esta é a parte não linear: o inverso.

Depois de tirar o inverso do byte, faz-se uma multiplicação dos bits por uma matriz e uma soma (XOR) com constante. Isso serve para atrapalhar alguma criptanalise de utilizar a relação de inverso recém utilizada.

Em vez de fazer todos esses cálculos toda vez, utilizamos uma tabela.

Trocar linhas (ShiftRows)

Considerando o bloco de 16 bytes como sendo uma matriz 4×4, esta operação troca a posição dos bytes de cada linha.

A primeira linha é mantida, a segunda linha é deslizada um byte, a terceira linha é deslizada dois bytes e a quarta linha é deslizada três bytes.

Não tem segredo!

Esta substituição faz difusão dos bits nas linhas, que são blocos de 32 bits (4 bytes).

Misturar colunas (MixColumns)

Novamente consideramos o bloco de 16 bytes como sendo uma matriz 4×4, esta operação mistura cada uma das colunas.

Esta mistura faz difusão dos bits nas colunas, que também são blocos de 32 bits (4 bytes).

Por algum motivo (qual?), essa operação não é realizada na última rodada.

Mas como se calcula?

Aqui não há uma operação equivalente ou uma tabela.

Selecionamos uma coluna, cada byte dessa coluna é considerado um coeficiente GF(28) de um polinômio de terceiro grau em Z. Essa é a parte esquisita, onde todo mundo quebra a cabeça: Os coeficientes do polinômio são polinômios.

Note que estou usando o Z maiúsculo para os polinômios-coluna com coeficientes em GF(28). Anteriormente usei x minúsculo para os polinômios-byte GF(28).

Reiterando a explicação: cada coeficiente do “polinômio-coluna-em-Z” é um “polinômio-byte-em-x”.

Fazemos uma multiplicação do polinômio-coluna pelo polinômio {3}Z3 + {1}Z2 + {1}Z + {2}, módulo ao polinômio é Z4 + 1.

Como os coeficientes estão em GF(28), multiplicações são sempre calculadas módulo algum polinômio irredutível de oitavo grau. Usamos o mesmo polinômio citado anteriormente: x8 + x4 + x3 + x + 1.

Então, se a coluna é formada por 255, 1, 2 e 3, o polinômio é
{255}Z3 + {1}Z2 + {2}Z + {3}.

Lembre-se que os coeficientes são, na verdade, polinômios em GF(28). Então o polinômio acima, na verdade é…
(x7+x6+x5+x4+x3+x2+x+1)Z3 + (1)Z2 + (x)Z + (x+1)

E o polinômio multiplicador {3}Z3 + {1}Z2 + {1}Z + {2}, na verdade é…
(x+1)Z3 + (1)Z2 + (1)Z + (x)

É isso ai, os coeficientes do polinômio em Z são polinômios em x.

Fazendo a multiplicação do polinômio-coluna com o polinômio 3Z3 + Z2 + Z + 2 obtemos um polinômio de sexto grau. Então fazemos a redução módulo Z4 + 1 e obtemos um polinômio de terceiro grau {231}Z3 + {248}Z2 + {255}Z + {31}.

Assim, depois da operação MixColumns, a coluna formada pelos números 255, 1, 2 e 3 é transformada na coluna 231, 248, 255 e 31.

Existe um atalho, que evita realizar as operações de multiplicação em Z e redução módulo Z4 + 1. Basta realizar uma multiplicação de um vetor (que representa a coluna) por uma matriz (que representa o polinômio multiplicador). Relembrando que os bytes sendo multiplicados, na verdade são polinômios em GF(28) e devem ser reduzidos módulo x8 + x4 + x3 + x + 1.

Número de rodadas

As quatro operações acima (AddRoundKey, SubBytes, ShiftRows, MixColumns) são realizadas diversas vezes, com o objetivo de realizar difusão (propagação de diferenças) e tornar mais difícil um ataque de criptanálise.

O número de rodadas executadas depende do tamanho da chave. Enquanto maior a chave, mais rodadas são necessárias.

Tamanho da chaveNúmero de rodadas
128 bits10
192 bits12
256 bits14
Número de rodadas da criptografia simétrica AES em relação ao tamanho da chave.

Links externos

Wikipedia AES

Especificação AES

Leia mais:

Veja mais posts na Categoria Criptografia!

Funções HASH Criptográficas

Resumão

Uma função hash processa uma mensagem de tamanho arbitrário (qualquer número de bytes) e cria a partir dela uma sequência de bytes de tamanho fixo.

Ela deve ser uma função unidirecional, ou seja, não deve ser possível (ao menos na prática) realizar sua inversa. Deve dar resultados iguais para mensagens iguais e resultados claramente diferentes para mensagens diferentes. Mesmo para mensagens parecidas (trocando ou adicionando um bit ou uma letra) a diferença no resultado deve ser bem evidente.

Atualmente existem dois padrões de função hash considerados criptograficamente seguros: SHA2 e SHA3.

Ambos padrões definem hashes de diferentes tamanhos de saída e, consequentemente, diferentes níveis de segurança criptográficos: 224, 256, 384 e 512 bits.

Para uma aplicação que exige n bits de segurança criptográfica, usa-se uma hash com 2n bits de saída. Por exemplo, se eu preciso de 128 bits de segurança eu vou utilizar SHA-256 (SHA2) ou SHA3-256, que possuem o dobro de bits de saída.

Na dúvida ou se não estiver especificado, utilize 128 bits de segurança.

HashSaídaSegurançaUsado em conjunto
com criptografia
SHA-224
SHA3-224
224 bits112 bits3DES (DES triplo)
SHA-256
SHA3-256
256 bits128 bitsAES-128
SHA-384
SHA3-384
384 bits192 bitsAES-192
SHA-512
SHA3-512
512 bits256 bitsAES-256
Hashes criptográficas seguras SHA2 e SHA3, tamanho da saída, segurança e algorítimos de criptografia com segurança equivalente.

Para que serve uma função Hash?

As funções hash servem ser utilizadas para diferentes propósitos.

Integridade de dados. Pode ser utilizada para confirmar que uma mensagem (ou arquivo) foi enviado corretamente. Quem envia a mensagem manda junto sua hash. Quem recebe a mensagem calcula a hash da mensagem e compara com a recebida.

Assinatura digital. Diretamente assinar digitalmente uma mensagem (ou arquivo) de tamanho arbitrário é complicado. Especialmente se muito grande exigiria chaves criptográficas tão grande quanto as mensagens. A assinatura digital então é realizada sobre a hash da mensagem, que tem um comprimento fixo.

Funções Hash Criptográficas

Funções hash criptográficas, além de associar uma saída de tamanho fixo com uma mensagem de tamanho arbitrário, tem objetivo de resistir a ataques criptográficos. Dessa forma elas podem ser utilizadas em conjunto com esquemas de criptografia.

Para isso ela deve resistir a três diferentes ataques: pré-imagem, segunda pré-imagem e colisão. Eles são discutidos abaixo.

Ataque Pré-imagem de Hash

Deve ser muito difícil (praticamente impossível) de encontrar uma mensagem x que gere uma hash pré-definida y. Ou seja, a função hash não deve ser invertível.

Por exemplo, o só o gênio da lâmpada poderia atender a este desejo:
“Eu quero encontrar uma mensagem cujo valor da SHA3-256 é e05dbb98c0c3665c1c95290a8c2245ba32ad7e366502f2a5fdb37b4001054692.”
Talvez nem ele.

Resposta: Uma palavra, dez letras, sem acentos, tudo minúsculo. Se calcular SHA3-224 dá 80ab895e2f664ab13a76581f41e8226a85540d5d9617eab2c29a5792.
Quer tentar? Você tem 2610 = 141.167.095.653.376 chances. Calculadora online SHA3-256.

Alguém capaz de realizar a pré-imagem, pode descobrir qual a mensagem a partir de sua hash.

De onde vem esse nome “pré-imagem”? Vem do conteúdo de matemática chamado funções. Uma função y = f(x) tem seu domínio (valores de x) e sua imagem (valores de y). Para uma função hash, o algoritmo é f, o domínio são as mensagens x e a imagem são os valores das hashes y. Pré-imagem significa ter a imagem e, a partir dela, determinar o domínio correspondente (como uma função inversa).

Ataque Segunda Pré-imagem de Hash

Se eu tenho uma mensagem x1 que tem uma hash y, deve ser muito difícil (praticamente impossível) de encontrar uma mensagem diferente x2 que dê a mesma hash y.

Pode soar muito parecido com o anterior. Sim, é!

Mas este ataque considera que o atacante conhece a mensagem original e quer descobrir uma segunda mensagem com mesma hash. Ou seja, conhecer a mensagem não deve dar nenhuma vantagem adicional para um ataque.

Eis aqui mais um pedido para o gênio da lâmpada:
“Eu quero uma mensagem diferente que dê a mesma SHA3-256 que ‘Olá, banco! Envie R$1.000,00 para Oscar. Obrigado!’ “

Alguém capaz de realizar a segunda pré-imagem, pode forjar assinaturas digitais. Pode trocar a mensagem assinada por uma outra mensagem, sem que isso seja percebido.

De onde vem esse nome “segunda pré-imagem”? Já temos uma pré-imagem: a pré-imagem de y é x1. Mas queremos uma segunda pré-imagem x2.

Ataque Colisão de Hash

Deve ser muito difícil (praticamente impossível) de encontrar duas mensagens diferentes x1 e x2 que dão uma mesma hash y.

Pode soar muito parecido com o anterior. Sim, é!

Mas este ataque não faz nenhuma restrição com respeito as mensagens, nem ao valor da hash.

Eis aqui mais um pedido para o gênio da lâmpada:
“Eu quero duas mensagens diferentes que dão a mesma SHA3-256. Não importa qual valor final da hash.”

Alguém capaz de realizar colisões pode gerar muita confusão e dor de cabeça em sistemas que dependem de hashes.

De onde vem esse nome “colisão”? Imagine que as mensagens são carros e o resultado da hash seja a vaga do estacionamento que devem usar. Mesmo quando da mesma marca, modelo, ano… são carros diferente e vão estacionar em vagas diferentes. Dois carros querendo entrar na mesma vaga geram uma colisão.

Links Externos

Wikipedia SHA2

Especificação SHA2

Wikipedia SHA3

Especificação SHA3

Leia mais:

Veja mais posts na Categoria Criptografia!

Operadores com ponto no MATLAB/OCTAVE

Que negógio é esse de .* .^ .’?

No MATLAB/OCTAVE temos muitas operações e as vezes nos deparamos com algumas operações estranhas.

O que é .*?

O asterisco (A*B) denota a multiplicação das matrizes A  e B. O número de colunas de A deve ser o mesmo número de linhas de B.

O ponto-asterisco (A.*B) denota multiplicação elemento a elemento (elementwise multiplication). O número de linhas e colunas de A deve ser o mesmo de B.

O que é .^?

O circunflexo (A^x) denota a potenciação da matriz A pelo número x, ou seja, A elevado a x. Por exemplo A^2 = A*A e A^3 = A*A*A.

O ponto-circunflexo (A.^x) denota a potenciação elemento a elemento (elementwise power), ou seja, cada elemento terá seu valor elevado a potência x.

O que é .’?

Essa aqui confunde mesmo, pois não tem nada a ver com operações elemento a elemento.

O apóstrofo (A’) denota a matriz TRANSPOSTA e COMPLEXO CONJUGADA. A matriz é transposta (troca-se as linhas pelas colunas) e os elementos são conjugados (a parte imaginária dos números complexos mudam de sinal).

O ponto-apóstrofo(A.’) denota matriz TRANSPOSTA. A matriz é transposta (troca-se as linhas pelas colunas) mas nesse caso os elementos NÃO são conjugados.

Para matrizes com apenas números reais ambas operações fazem a mesma coisa.

Concurso: Tensão em capacitor

Esta questão vem do NC-UFPR, Concurso da Itaipu para Engenharia Eletrônica em 2019.

Questão sobre a tensão sobre um capacitor a partir da corrente conduzida por ele. Na minha opinião não foi muito bem formulada: você sabe dizer qual a unidade que em que a corrente é dada?

Questão

46 – A tensão e a corrente entre os terminais de um capacitor de 0,6 μF é 0 para t<0. Quando t≥0, a corrente passa a ser descrita por 3cos(50t). Assinale a alternativa correta para v(t) quando t≥0.

a) sen(50t) + cos(100t) V.

b) 50cos(100t) V.

c) 100sen(50t) V.

d) (sen 50t)/(cos 50t) V.

e) 100te-t V. Continue lendo “Concurso: Tensão em capacitor”