Desenvolvimento para Sistemas Embarcados (CEA 513) Codificação Segura para Embarcados

Transcrição

1 Universidade Federal de Ouro Preto Departamento de Computação e Sistemas - DECSI Desenvolvimento para Sistemas Embarcados (CEA 513) Codificação Segura para Embarcados Vicente Amorim vicente.amorim.ufop@gmail.com

2 Sumário * Introdução *

3 Introdução

4 Introdução * Desenvolvimento atualmente para embarcados se ancora basicamente em duas linguagens: C/C++ - Linguagem antiga? Sem uso? Ultrapassada? - TIOBE (09/2014)

5 Introdução * História da linguagem C : Ken Thompson criou o Unix (Bell Labs), em Assembly à partir de ideias do sistema operacional MULTICS : UNIX reescrito para PDP : Dennis Ritchie criou a linguagem C, a partir da linguagem B (Ken Thompson) e BCPL. - Linguagem C utilizada para escrever o UNIX! : Linguagem oficialmente publicada com o livro The C Programming Language.

6 Introdução * História da linguagem C /1990: 1o padrão: ANSI criou o comitê X3J11 em 1983 para a criação de um padrão para a linguagem, o que efetivamente só aconteceu em Tal padrão também foi aceito pela ISO e nomeado ISO/IEC (C90) /1996: Lançado o C95 através de várias correções em padrões anteriores : 2o padrão: ISO/IEC 9899:1999, conhecido como C : 3o padrão: ISO/IEC 9899:2011, conhecido como C11.

7 Introdução * C e Embarcados - Linguagem utilizada em uma série de ambientes e soluções. - Em embarcados talvez o contexto mais apropriado. - Na presença de um Sistema Operacional: Ex.: Linux.

8 Introdução * C e Embarcados - Entretanto, pode não haver um Sistema Operacional:

9 Introdução * C e Embarcados - C é flexível, portável entre arquiteturas distintas e enxuta (44 keywords). - Nem tudo são flores: Verificação em tempo de execução do C é pobre: Entretanto, código é pequeno e eficiente. Erros mais comuns encontrados: Manipulação de strings; Pilha; Alocação dinâmica de memória.

10 Introdução * C e Embarcados - Maioria dos erros são causados por humanos. Padrões de codificação podem ajudar na redução dos mesmos: MISRA-C (aplicado na aviação). Netrino s Embedded C coding standard. CERT C.

11 Introdução * Problemas podem aparecer durante o processo de desenvolvimento. * Ferramentas podem auxiliar na busca automatizada por erros e falhas: - Avaliação dos padrões através de ferramentas de análise: Estáticas: QA-C, CodeCheck, PC-lint,... Grátis: Splint. Dinâmicas: Valgrind / DUMA.

12 Introdução * Testes, validação e confiabilidade: - Testes podem provar a existência de erros, mas não a falta deles. - Quanto melhor a cobertura dos testes, mais confiável é seu programa. - Ferramentas para automatização de testes: Unity CppUTest

13

14 * Desenvolvedores em C/C++ comumente cometem erros parecidos. * Linguagem possui particularidades que precisam ser respeitadas. * Medidas a se evitar o pior caso são normalmente a alternativa mais comum: programação defensiva. * Conhecer o erros/problemas mais comuns ajuda a evitá-los.

15 * Manipulação de strings: - Cópias de strings sem limites; - Erros de off-by-one; - Null-termination; - Strings truncadas.

16 * Manipulação de strings: - Cópias de strings sem limites: Problema: Os dados são copiados de uma origem sem delimitação para um array de caracteres com tamanho fixo. Exemplo: Uso da função gets() -> deprecated no padrão C99 e inexistente no C11. MSC34-C: Do not use deprecated or obsolescent functions. STR35-C. Do not copy data from an unbounded source to a fixedlength array.

17 * Manipulação de strings: - Cópias de strings sem limites: - Exemplo 1: Problema?? Buffer Overflow!!! #include <stdio.h> static void get_user_name(void); static void get_user_name(void) { char name[8]; puts("insira seu nome: "); gets(name); if (name[0] == '\0') { printf("nenhum dado inserido!\n"); else { printf("muito obrigado!\n"); //TODO: processamento... int main(void) { get_user_name(); return 0;

18 * Manipulação de strings: - Cópias de strings sem limites: $ splint Exemplo1.c Splint May 2009 Exemplo1.c: (in function get_user_name) Exemplo1.c:8:5: Return value (type int) ignored: puts("insira seu... Result returned by function call is not used. If this is intended, can cast result to (void) to eliminate message. (Use -retvalint to inhibit warning) Exemplo1.c:9:5: Use of gets leads to a buffer overflow vulnerability. Use fgets instead: gets Use of function that may lead to buffer overflow. (Use -bufferoverflowhigh to inhibit warning) Exemplo1.c:9:5: Return value (type char *) ignored: gets(name) Result returned by function call is not used. If this is intended, can cast result to (void) to eliminate message. (Use -retvalother to inhibit warning) Finished checking code warnings

19 * Manipulação de strings: - Cópias de strings sem limites: - Exemplo 2: Corrigido! #include <stdio.h> static void get_user_name(void); static void get_user_name(void) { char name[8]; (void) puts("insira seu nome: "); if (fgets(name, (int) sizeof(name), stdin) == NULL) { printf("nenhum dado inserido!\n"); else { printf("nome: %s\n",name); printf("muito obrigado!\n"); // TODO: processamento... int main(void) { get_user_name(); return 0;

20 * Manipulação de strings: - Cópias de strings sem limites: - Corrigido: $ splint Exemplo2.c Splint May 2009 Finished checking --- no warnings - Outras funções perigosas: strcpy -> strncpy, stdup (não presente em C99 e C11) strcat -> strncat sprintf -> snprintf Never use gets(). Because it is impossible to tell without knowing the data in advance how many characters gets() will read, and because gets() will continue to store characters past the end of the buffer, it is extremely dangerous to use. It has been used to break computer security. Use fgets() instead. Fonte:

21 * Manipulação de strings: - Off-by-One: - Problema: Devido a um erro de indexação, é acessada uma posição além dos limites do buffer criado. - Exemplo 3: Problema?? #include <string.h> #include <stdio.h> #include <stdlib.h> int main(void) { char s1[] = " "; char s2[] = " "; char *dest; int i; strncpy(s1, s2, sizeof(s2)); dest = (char *) malloc(strlen(s1)); for (i = 1; i <= 11; i++) { dest[i] = s1[i]; dest[i] = '\0'; printf("dest = %s", dest); free(dest); return 0;

22 * Manipulação de strings: - Off-by-One: $ splint Exemplo3.c Splint May 2009 Exemplo3.c: (in function main) Exemplo3.c:16:9: Index of possibly null pointer dest: dest A possibly null pointer is dereferenced. Value is either the result of a function which may return null (in which case, code should check it is not null), or a global, parameter or structure field declared with the null qualifier. (Use -nullderef to inhibit warning) Exemplo3.c:13:12: Storage dest may become null Finished checking code warning - Problema: Acesso indevido a posição inexistente do buffer.

23 * Manipulação de strings: - NULL-termination: #include <string.h> #include <stdio.h> #include <stdlib.h> - Problema: Não terminar uma string com o caractere NULL ( \0 ). - Exemplo 4: int main(void) { char a[16]; char b[16]; char c[16]; $ splint Exemplo4.c Splint May 2009 Finished checking --- no warnings strncpy(a, " abcdef", sizeof(a)); strncpy(b, " abcdef", sizeof(b)); strcpy(c, a); return 0; STR32-C. Null-terminate byte strings as required. CERT C Secure Coding Standard

24 * Manipulação de strings: - NULL-termination: - Correção: Não terminar uma string com o caractere NULL ( \0 ). $ splint Exemplo5.c Splint May 2009 Finished checking --- no warnings - Exemplo 5: #include <string.h> #include <stdio.h> #include <stdlib.h> int main(void) { char a[16]; char b[16]; char c[16]; strncpy(a, " abcdef", sizeof(a)); a[sizeof(a) - 1] = '\0'; strncpy(b, " abcdef", sizeof(b)); b[sizeof(b) - 1] = '\0'; strcpy(c, a); return 0;

25 * Manipulação de strings: - Strings truncadas: - Problema: Determinado array de caracteres não é grande o bastante para armazenar uma string. - Exemplo 6: #include <stdio.h> int main(int argc, char *argv[]) { int i = 0; char buffer[32]; char *arg1 = argv[1]; if (argc == 1) { printf("sem argumentos!\n"); return -1; - Funções perigosas: Se não as uso, não tenho com o que me preocupar, certo?? $ splint Exemplo6.c Splint May 2009 Finished checking --- no warnings while (arg1[i]!= '\0') { buffer[i] = arg1[i]; i++; buffer[i] = '\0'; printf("buffer = %s\n", buffer); return 0;

26 * Manipulação de strings: - Strings truncadas: - Solução: Uma das possíveis é trocar a cópia iterativa por uma função segura (strncpy). - Iterativamente, deve-se levar em conta o tamanho do buffer destino. - Exemplo 7: (correção) #include <stdio.h> int main(int argc, char *argv[]) { char buffer[32]; char *arg1 = argv[1]; if (argc == 1) { printf("sem argumentos!\n"); return -1; strncpy(buffer, arg1, sizeof(arg1)); printf("buffer = %s\n", buffer); return 0;

27 * Vulnerabilidades gerais - Tainted data Tratamento de strings: Difícil saber o conteúdo dos dados recebidos e o seu tamanho. Usuários podem acidentalmente prover dados incorretos. Usuários podem deliberadamente prover dados incorretos. Então, dados podem estar contaminados (tainted). Como tratar?

28 * Vulnerabilidades gerais - Tainted data Validação dos dados é necessária. Problemas: Uso da função gets(); Não tratamento dos dados vindos do usuário; FIO04-C: Detect and handle input and output errors. CERT C Secure Coding Standard - Exemplo 8: #include <stdio.h> #include <string.h> #include <stdbool.h> bool IsPasswordOK(void) { char Password[12]; gets(password); return (0 == strcmp(password,"goodpass")); int main(void) { bool PwStatus; puts("enter your password: "); PwStatus = IsPasswordOK(); if (PwStatus == false) { puts("access denied!!"); return -1; else { puts("access granted!"); return 0;

29 * Vulnerabilidades gerais - Uma falha de segurança não indica, necessariamente, uma vulnerabilidade. - Vulnerabilidade se caracterizará se o intruso tiver acesso aos dados de entrada do sistema. - Intruso obteve acesso... E agora? O que pode acontecer? Arc Injection; e Code Injection. - Entretanto... Antes, um pouco de teoria.

30 * Vulnerabilidades gerais - Buffer Overflows 16 Bytes of Data Source Memory Destination Memory Copy Operation Allocated Memory (12 Bytes) Other Memory

31 * Vulnerabilidades gerais - Organização das regiões de memória em um processo:

32

33 * Vulnerabilidades gerais - Stack (pilha) Estrutura de dados dinâmica que suporta a execução de uma aplicação.: Quando uma função é chamada, esta estrutura armazena: 1) Dados passados por funções; 2) Variáveis locais; 3) Endereços de retorno das funções chamadoras; 4) Endereço base da pilha da função chamadora. Este conjunto de informações = Stack frame.

34 * Vulnerabilidades gerais - Stack (pilha)

35 * Vulnerabilidades gerais - Stack (pilha) Review funções principais registradores arquitetura x86 Intel: Registrador ebp esp eax ecx edx eip Função base pointer register stack pointer register accumulator register counter register (loop counter) data register index pointer register (inst. atual)

36 * Vulnerabilidades gerais - Stack (pilha) Exemplo 9: #include <stdio.h> void foo(int, char *); int main(void) { int MyInt = 1; char *MyStrPtr = "MyString"; foo(myint,mystrptr); 2o argumento colocado na pilha!! (MyStrPtr) foo(myint,mystrptr); 19: 8b c mov eax,dword PTR [esp+0x1c] 1d: mov DWORD PTR [esp+0x4],eax 21: 8b mov eax,dword PTR [esp+0x18] 25: mov DWORD PTR [esp],eax 28: e8 fc ff ff ff call 29 <main+0x29> Chamada ao método!! (foo(myint, MyStrPtr) return 0; 1o argumento colocado na pilha!! (MyInt) void foo(int MyInt, char *MyStrPtr) { char LocalChar[24]; int LocalInt; LocalInt++; return;

37 * Vulnerabilidades gerais - Stack (pilha) antes da chamada Endereço Valor Descrição Tamanho xbffff338 1 Variável local MyInt(int) 4 0xbffff33C 0x "MyString" Variável local MyStrPtr(char*) 4 0xbffff340? Endereço stack frame do SO 4 0xbffff344 0x804841d Endereço de retorno do SO 4 0xbffff348 SO (1) Primeiro argumento main (argc) 4 0xbffff34C 0xb7e3a4d3 Endereço que chamou main 4 $ebp $eip

38 * Vulnerabilidades gerais - Stack (pilha) Função foo() prólogo: Instruções que são executadas no início da função chamada: void foo(int MyInt, char *MyStrPtr) { 34: 55 push ebp 35: 89 e5 mov ebp,esp 37: 83 ec 38 sub esp,0x38 Função foo() epílogo: Instruções que são executadas ao final da função chamada: return; 4b: 8b 45 f4 mov eax,dword PTR [ebp-0xc] 4e: xor eax,dword PTR gs:0x14 55: je 5c <foo+0x28> 57: e8 fc ff ff ff call 58 <foo+0x24> 5c: c9 leave 5d: c3 ret

39 * Vulnerabilidades gerais - Stack (pilha) Função foo() é chamada e seus parâmetros são adicionados a pilha. Variáveis locais precisam ser consideradas. Contexto da função main() é mantido na pilha.

40 * Vulnerabilidades gerais - Stack (pilha) durante a chamada Endereço Valor Descrição Tamanho 0xbffff2ec 0x "MyString" Segundo argumento de foo() 4 0xbffff2f0 - Variável local LocalInt 4 0xbffff2f4 - Variável local LocalChar 24 0xbffff318 0xbffff348 Endereço stack frame da função main() 4 0xbffff31c 0x Endereço de retorno da função main() 4 0xbffff320 1 Primeiro argumento de foo() xbffff338 1 Variável local MyInt(int) 4 0xbffff33c 0x "MyString" Variável local MyStrPtr(char*) 4 0xbffff340? Endereço stack frame do SO 4 0xbffff344 0x804841d Endereço de retorno do SO 4 0xbffff348 SO (1) Primeiro argumento main (argc) 4 0xbffff34C 0xb7e3a4d3 Endereço que chamou main 4 $ebp $eip $ebp $eip

41 * Vulnerabilidades gerais - Stack (pilha) Ao final da função foo(), é necessário retomar o contexto da função main(). Variáveis locais precisam ser novamente consideradas. Contexto da função main() é mantido na pilha - mesmo na chamada de foo().

42 * Vulnerabilidades gerais - Stack (pilha) após a chamada Endereço Valor Descrição Tamanho 0xbffff2ec?????? 4 0xbffff2f0?????? 4 0xbffff2f4?????? 24 0xbffff318?????? 4 0xbffff31c?????? 4 0xbffff320?????? xbffff338 1 Variável local MyInt(int) 4 0xbffff33c 0x "MyString" Variável local MyStrPtr(char*) 4 0xbffff340? Endereço stack frame do SO 4 0xbffff344 0x804841d Endereço de retorno do SO 4 0xbffff348 SO (1) Primeiro argumento main (argc) 4 0xbffff34C 0xb7e3a4d3 Endereço que chamou main 4 $ebp $eip

43 * Vulnerabilidades gerais - Stack Smashing Como visto, buffer overflow pode causar danos. Na memória de pilha recebe o nome de stack smashing. Pode causar sérios problemas de confiabilidade de segurança. Buffer overflow na pilha pode permitir um atacante modificar valores de variáveis automáticas. Perda da integridade ou perda de dados confiáveis. Pior: Execução de código arbitrário!!!

44 * Vulnerabilidades gerais - Stack Smashing O exemplo de obtenção de senha do usuário pode sofrer com esse tipo de ataque. Antes da chamada ao IsPasswordOK(): $eip... puts("enter your password: "); PwStatus = IsPasswordOK(); if (PwStatus == false) { puts("access denied!!"); return -1; else { puts("access granted!"); return 0; $esp Stack Arm. de PwStatus (4bytes) %ebp q/ chamou (OS 4bytes) Endereço retorno main (OS 4bytes)

45 * Vulnerabilidades gerais - Stack Smashing Durante a chamada ao IsPasswordOK(): $eip... puts("enter your password: "); PwStatus = IsPasswordOK(); if (PwStatus == false) { puts("access denied!!"); return -1; else { puts("access granted!"); return 0; $esp Stack Arm. de Password (12bytes) %ebp q/ chamou (main 4bytes) Endereço retorno chamador (main 4bytes) Arm. de PwStatus (4bytes) %ebp q/ chamou (OS 4bytes) Endereço retorno main (OS 4bytes) bool IsPasswordOK(void) { char Password[12]; gets(password); return (0 == strcmp(password,"goodpass"));

46 * Vulnerabilidades gerais - Stack Smashing Após a chamada ao IsPasswordOK(): $eip... puts("enter your password: "); PwStatus = IsPasswordOK(); if (PwStatus == false) { puts("access denied!!"); return -1; else { puts("access granted!"); return 0; $esp Stack Arm. de Password (12bytes) %ebp q/ chamou (main 4bytes) Endereço retorno chamador (main 4bytes) Arm. de PwStatus (4bytes) %ebp q/ chamou (OS 4bytes) Endereço retorno main (OS 4bytes)

47 * Vulnerabilidades gerais - Stack Smashing Falha de segurança em IsPasswordOK(): Tentativa de armazenar um password maior que 11 caracteres gera crash. Com uma entrada de 20 caracteres, 21 caracteres são necessários para armazenar password: = 9 bytes restantes. 9 bytes restantes sobrescrevem alguma posição de memória previamente alocada.

48 * Vulnerabilidades gerais - Stack Smashing Durante a chamada ao IsPasswordOK(): $eip bool IsPasswordOK(void) { char Password[12]; gets(password); return (0 == strcmp(password,"goodpass")); $esp Stack Arm. de Password (12bytes) %ebp q/ chamou (main 4bytes) 3456 Endereço retorno chamador (main 4bytes) 7890 Arm. de PwStatus (4bytes) `\0` %ebp q/ chamou (OS 4bytes) Endereço retorno main (OS 4bytes)

49 * Vulnerabilidades gerais - Stack Smashing Falha de segurança em IsPasswordOK(): Quando uma falha ocorre, um usuário comum simplesmente tentará reiniciar o programa como forma de sanar o problema. Usuário mais experiente irá investigar e tentar descobrir a causa da falha e se a mesma pode ser explorada. Crash ocorre em razão de se sobrescrever o endereço de retorno. Memória no endereço: 1) Sem instrução de CPU válida; 2) Contém uma instrução mas valores nos registradores são inválidos; 3) Não é executável.

50 * Vulnerabilidades gerais - Arc Injection No exemplo anterior, entrada especial pode fazer com q/ o prog. produza saída inexperada. Em memória, os 4bytes da linha destacada alteram o endereço de retorno. Redirecionamento para outro trecho de código. Stack Arm. de Password (12bytes) %ebp q/ chamou (main 4bytes) 3456 Endereço retorno chamador (main 4bytes) ÄHP Arm. de PwStatus (4bytes) `\0` %ebp q/ chamou (OS 4bytes) Endereço retorno main (OS 4bytes)

51 * Vulnerabilidades gerais - Code Injection Raramente um endereço de retorno sobrescrito irá apontar para alguma instrução válida. Consequentemente, transferir o controle para o endereço especificado causa uma exceção e corrupção da pilha. Entretanto, uma entrada especialmente criada por um atacante pode causar a execução de um código malicioso.

52 * Vulnerabilidades gerais - Code Injection Quando a função chamada retorna para o endereço especificado - sobrescrito - o controle é transferido para outro código. Código malicioso irá executar com as mesmas permissões que o programa vulnerável - daí a constante busca pela exploração do root. Frequentemente o código inserido buscará formas de abrir - ou possibilitar a abertura - de um shell remoto.

53 $esp * Vulnerabilidades gerais - Code Injection Voltando ao código do Exemplo 8: Stack Arm. de Password (12bytes) #include <stdio.h> #include <string.h> #include <stdbool.h> bool IsPasswordOK(void) { char Password[12]; gets(password); return (0 == strcmp(password,"goodpass")); int main(void) { bool PwStatus; %ebp q/ chamou (main 4bytes) Endereço retorno chamador (main 4bytes) Arm. de PwStatus (4bytes) %ebp q/ chamou (OS 4bytes) Endereço retorno main (OS 4bytes) $eip puts("enter your password: "); PwStatus = IsPasswordOK(); if (PwStatus == false) { puts("access denied!!"); return -1; else { puts("access granted!"); return 0;

54 * Vulnerabilidades gerais - Code Injection Nova entrada para execução de Exemplo 8:

55 * Vulnerabilidades gerais - Stack Canary Aplicativos que fazem uso de sistemas operacionais e hardware com suporte a MMU podem facilmente detectar stack overflow. Utilizando GCC, a detecção de stack overflow é possível através de uma técnica conhecida como canary. Canary: Valor inteiro aleatório, gerado pelo processo atual que é adicionado pelo compilador em uma posição entre o endereço de retorno para a função chamadora e as variáveis locais da função.

56 * Vulnerabilidades gerais - Stack Canary Sem proteção:

57 * Vulnerabilidades gerais - Stack Canary Com proteção:

58 * Alocação Dinâmica de Memória - Posso utilizar alocação dinâmica em sistemas embarcados? Em geral: Utilizada quando não há conhecimento de antemão - tempo de compilação - do espaço de memória a ser utilizado. Principais pontos: Recursos voláteis são limitados (RAM, SRAM, DDRAM, etc); Implementação - ou existência - do gerenciador de memória; Determinismo: Necessário em sist. embarcados; Tratamento de erros;

59 * Alocação Dinâmica de Memória - Posso utilizar alocação dinâmica em sistemas embarcados? Principais pontos: (cont.) Normalmente funções de alocação não são reentrantes, o que pode ser um problema para sistemas multithreaded. Uma aplicação no PC pode gerar uma mensagem de erro, mas não um módulo de injeção do carro, um navegador do avião, etc.

60 * Alocação Dinâmica de Memória - Fragmentação de memória (8KB disponível)... p1 = malloc(1024); p2 = malloc(2048); p3 = malloc(1024);... free(p3); free(p2); free(p1);...

61 * Alocação Dinâmica de Memória - Fragmentação de memória (8KB disponível)... p1 = malloc(1024); p2 = malloc(2048); p3 = malloc(1024);... free(p3); free(p1);... Total: 8KB Alocado: 4KB Desalocado: 2KB Disponível: 6KB malloc(6* 1024) funciona??

62 * Alocação Dinâmica de Memória - Fragmentação de memória (8KB disponível)... p1 = malloc(1024); p2 = malloc(2048); p3 = malloc(1024);... free(p3); free(p1);... Não funciona! Existe memória livre, mas não memória contínua suficiente. Disponível continuamente: (max) 4KB!

63 * Alocação Dinâmica de Memória - Alternativas Memory Pool: Pools de memória contendo um número de blocos de tamanho fixo. Vantagem: Elimina fragmentação.. Desvantagem: Perda de memória (blocos de tamanho 8, 16, 32,... mas preciso de 17bytes);

64 * Alocação Dinâmica de Memória - Alternativas Garbage Collector: Aproxima os blocos de memória utilizados. Utilizado em linguagens como C#, Java, VisualBasic onde o acesso é feito a uma espécie de memória virtual. Vantagem: Elimina fragmentação aumentando o espaço livre conseguinte. Desvantagem: Não determinístico. Quando será executado? Quanto tempo levará para executar?

65 * Alocação Dinâmica de Memória - Implementação em sistemas bare-metal Dependente do ambiente usado (GNU, IAR, Keil, Renesas, etc). Se GNU pode ser usada uma biblioteca específica: Ex.: newlib - Implementa funcionalidade mínima para usar malloc e faz uso do símbolo _end criado no script do linker).

66 * Alocação Dinâmica de Memória - Implementação em sistemas com sistema operacional RTOS: Oferece implementação própria. Uso de memory pools e allocation call. Linux Embarcado: Utiliza a glibc/uclibc/etc que usam esquema de página típico de SOs unixlike. (4KB cada página) malloc (<= 4KB): Usa uma página do heap do processo; malloc (> 4KB): Usa mmap().

67 * Alocação Dinâmica de Memória Exemplo 10: #include <stdlib.h> int main(void) { char *x = malloc(10); x[10] = 'a'; return 0; $ splint Exemplo10.c Splint May 2009 Exemplo10.c: (in function main) Exemplo10.c:5:2: Index of possibly null pointer x: x A possibly null pointer is dereferenced. Value is either the result of a function which may return null (in which case, code should check it is not null), or a global, parameter or structure field declared with the null qualifier. (Use -nullderef to inhibit warning) Exemplo10.c:4:12: Storage x may become null Exemplo10.c:7:11: Fresh storage x not released before return A memory leak has been detected. Storage allocated locally is not released before the last reference to it is lost. (Use -mustfreefresh to inhibit warning) Exemplo10.c:4:23: Fresh storage x created Finished checking code warnings

68 * Alocação Dinâmica de Memória Exemplo 10: #include <stdlib.h> int main(void) { char *x = malloc(10); x[10] = 'a'; return 0; $ valgrind./exemplo10 ==3322== Memcheck, a memory error detector ==3322== Copyright (C) , and GNU GPL'd, by Julian Seward et al. ==3322== Using Valgrind and LibVEX; rerun with -h for copyright info ==3322== Command:./Exemplo10 ==3322== ==3322== Invalid write of size 1 ==3322== at 0x : main (in /media/sf_android_card/codigos/exemplo10) ==3322== Address 0x41f1032 is 0 bytes after a block of size 10 alloc'd ==3322== at 0x402BE68: malloc (in /usr/lib/valgrind/vgpreload_memcheck-x86- linux.so) ==3322== by 0x80483F8: main (in /media/sf_android_card/codigos/exemplo10) ==3322== ==3322== ==3322== HEAP SUMMARY: ==3322== in use at exit: 10 bytes in 1 blocks ==3322== total heap usage: 1 allocs, 0 frees, 10 bytes allocated ==3322== ==3322== LEAK SUMMARY: ==3322== definitely lost: 10 bytes in 1 blocks ==3322== indirectly lost: 0 bytes in 0 blocks ==3322== possibly lost: 0 bytes in 0 blocks ==3322== still reachable: 0 bytes in 0 blocks ==3322== suppressed: 0 bytes in 0 blocks ==3322== Rerun with --leak-check=full to see details of leaked memory ==3322== ==3322== For counts of detected and suppressed errors, rerun with: -v ==3322== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

69 * Alocação Dinâmica de Memória Exemplo 11: #include <stdlib.h> #include <string.h> #define BUFF_SIZE 10 int main(void) { char *x = malloc(buff_size); $ splint Exemplo11.c Splint May 2009 Finished checking --- no warnings if (x!= NULL) { memset(x, 0, BUFF_SIZE); x[buff_size-1] = 'a'; free(x); return 0;

70 * Alocação Dinâmica de Memória Exemplo 11: #include <stdlib.h> #include <string.h> #define BUFF_SIZE 10 int main(void) { char *x = malloc(buff_size); if (x!= NULL) { memset(x, 0, BUFF_SIZE); x[buff_size-1] = 'a'; free(x); return 0; $ valgrind./exemplo11 ==3338== Memcheck, a memory error detector ==3338== Copyright (C) , and GNU GPL'd, by Julian Seward et al. ==3338== Using Valgrind and LibVEX; rerun with -h for copyright info ==3338== Command:./Exemplo11 ==3338== ==3338== ==3338== HEAP SUMMARY: ==3338== in use at exit: 0 bytes in 0 blocks ==3338== total heap usage: 1 allocs, 1 frees, 10 bytes allocated ==3338== ==3338== All heap blocks were freed -- no leaks are possible ==3338== ==3338== For counts of detected and suppressed errors, rerun with: -v ==3338== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

71 Referências

72 Referências * Codificação Segura em C para Sistemas Embarcados. Henrique Pérsico Rossi. 07, /07/16/tdc2013-codificacao-segura-em-c-para-sistemasembarcados/ * Secure Coding in C and C++ (2nd Edition). Seacord, Robert C. Addison-Wesley, * Secure Programming With Static Analysis. Chess, Brian. West, Jacob. Addison-Wesley, 2007.