Extraindo firmware com JTAG

- por Sergio Prado

Categorias: Engenharia Reversa Tags: ,

JTAG é uma interface física provida pelo hardware que possibilita, dentre outras coisas, a extração da imagem do firmware de dispositivos eletrônicos.

O firmware, código que executa de forma dedicada e com um propósito específico em um microcontrolador ou microprocessador, fica normalmente gravado em um dispositivo de armazenamento persistente como uma memória flash ou EEPROM.

O processo de extração envolve ler e copiar a imagem do firmware gravado na memória do dispositivo para um arquivo na sua máquina. Este processo de extração de firmware também é chamado de dumping ou snarfing.

Mas porque extrair o firmware de um dispositivo eletrônico?

Motivações

Imagine um dispositivo eletrônico qualquer como um roteador, uma câmera IP ou uma máquina fotográfica.

Agora imagine que você queira entender melhor como o dispositivo funciona, mas não tem muita informação sobre ele. Extrair e analisar a imagem do firmware pode ser uma opção viável para entender seu funcionamento.

Talvez você queira melhorar ou alterar o comportamento do dispositivo. Sem acesso ao código-fonte, uma possibilidade é extrair o firmware para realizar as alterações necessárias e depois atualizar a imagem no dispositivo.

E se você perdeu as credenciais de acesso ao dispositivo? Uma possibilidade para recuperar o acesso é extrair e alterar a imagem do firmware.

Caso você seja um pesquisador de segurança, talvez queira extrair o firmware do dispositivo para procurar por vulnerabilidades no software.

E se o dispositivo for bem antigo e não estiver sendo mais fabricado ou vendido pelo fabricante? Você pode querer fazer um clone dele, e a extração da imagem do firmware será essencial neste processo.

Perceba então que são muitas as situações que podem te motivar a extrair o firmware de um dispositivo eletrônico. Nem que seja apenas por diversão! :-)

Técnicas para extração do firmware

Diversas técnicas podem ser utilizadas para extrair o firmware de um dispositivo eletrônico.

Mas antes de começar, verifique se a imagem do firmware não está disponível no site do fabricante. Muitos fabricantes de dispositivos como roteadores e câmeras disponibilizam imagens atualizadas do firmware na Internet para que seus clientes possam baixar e atualizar o dispositivo. Neste caso, o esforço para extração do firmware é zero!

Com acesso físico ao dispositivo, uma técnica para extrair o firmware é lendo diretamente a memória de armazenamento do dispositivo. Podemos identificar e remover o chip de memória (flash) da placa de circuito impresso, soldá-lo em uma outra placa e extrair o firmware. Funciona, mas pode ser bastante trabalhoso e também um pouco arriscado (existe a possibilidade de queimar o chip de memória durante o processo de extração).

Uma técnica menos arriscada é simplesmente ler a memória de armazenamento do dispositivo através de uma conexão com o bootloader ou sistema operacional.

Por exemplo, com acesso ao bootloader (via uma conexão serial), podemos tentar ler a memória do dispositivo e enviar os dados para a nossa máquina. Da mesma forma, com acesso a um terminal de comandos no sistema operacional (serial, ssh, etc) e com privilégios de execução, podemos tentar fazer um dump da memória de armazenamento do dispositivo e enviar para a nossa máquina.

Perceba que diferentes técnicas podem ser utilizadas para extrair o firmware de um dispositivo, dependendo dos recursos disponíveis.

E se nenhuma destas técnicas for viável, a interface JTAG pode ser uma boa opção!

O que é a interface JTAG?

Antigamente, testes em placas de circuito impresso eram feitos através de um sistema chamado de cama-de-pregos (bed-of-nails).

Nesse sistema, a placa de circuito impresso era projetada com diversos pontos de teste que se conectavam a uma placa de testes. E esta placa de testes executava rotinas de verificação de funcionamento dos circuitos integrados, das conexões e dos componentes eletrônicos da placa.

bed of nails

Conforme a complexidade das placas de circuito eletrônico aumentava, ficava cada vez mais difícil e complicado projetar uma cama-de-pregos para ela.

Então começaram a surgir algumas interfaces de teste e debug providas pelos próprios componentes de hardware (processador, microcontrolador, SoC, FPGA, etc).

Exatamente com este propósito, em 1985 foi criada a interface JTAG (Joint Test Action Group), um padrão (IEEE 1149.1) para testar placas de circuito impresso depois de sua fabricação.

Com o tempo, JTAG se tornou uma das mais populares interfaces de teste de circuitos eletrônicos, ganhando outras funcionalidades como debugging e gravação de firmware na memória flash.

Atualmente, esta interface é utilizada e está disponível na maioria dos processadores e microcontroladores de diversas arquiteturas como ARM, x86, MIPS e PPC.

Como a interface JTAG funciona?

Apesar de haver algumas variações do padrão, a interface JTAG é implementada normalmente pelo fabricante do chip através de 4 pinos obrigatórios (TDI, TDO, TCK, TMS) e 1 pino opcional (TRST):

  • TDI (Test Data In): entrada de dados.
  • TDO (Test Data Out): saída de dados.
  • TCK (Test Clock): clock cuja frequência máxima depende do chip (normalmente de 10MHz a 100MHz).
  • TMS (Test Mode Select): pino de controle da máquina de estados.
  • TRST (Test Reset): é um pino opcional para resetar a máquina de estados da controladora JTAG.

Os pinos da interface JTAG se conectam internamente ao chip através de um módulo chamado TAP (Test Access Port).

O TAP implementa o protocolo básico de comunicação com o chip via JTAG, e diversos TAPs podem ser conectados simultâneamente em uma arquitetura de anel (daisy chain).

jtag pins

O TAP implementa uma máquina de estados finita (16 estados) que permite acessar um grupo de registradores (IR, DR) para instrumentar o chip. O controle desta máquina de estados é feita através dos pinos TMS E TCK. Através desta máquina de estados, é possível selecionar uma operação através do registrador IR (Instruction Register) e parametrizar a operação ou verificar o resultado no registrador DR (Data register).

jtag state machine

O tamanho do registrador IR e a quantidade de instruções suportadas é definida pelo fabricante do chip. Por exemplo, um registrador IR de 5 bits irá suportar até 32 instruções.

Cada instrução tem o seu registrador de dados (DR), que possui tamanho variável. Três instruções são definidas pelo padrão JTAG (IEEE 1149.1) e devem ser obrigatoriamente implementadas pelo fabricante (BYPASS, EXTEST, SAMPLE/PRELOAD). Outras instruções são opcionais, mas também são normalmente implementadas (ex: IDCODE).

  • BYPASS: instrução que seleciona um registrador de 1 bit que faz um rotacionamento do TDI para o TDO, bastante útil para testar a interface JTAG.
  • EXTEST: instrução que seleciona o registrador BSR (Boundary Scan Register) para ler e alterar o estado dos pinos do chip.
  • SAMPLE/PRELOAD: instrução que seleciona o registrador BSR (Boundary Scan Register) para ler o estado dos pinos do chip.
  • IDCODE: instrução que seleciona o registrador device ID (32 bits) que contém o ID do chip.

Além das instruções definidas pelo padrão, o fabricante do chip pode implementar outras instruções conforme a necessidade. Desta forma, muitos fabricantes estendem a interface JTAG com funções de debugging e gravação de firmware em flash (ex: MIPS EJTAG).

Informações sobre as instruções JTAG suportadas e os pinos de um chip são normalmente documentadas em um arquivo chamado BSDL (Boundary Scan Description Language), um subset da VHDL (VHSIC Hardware Description Language).

Por exemplo, segue um pequeno trecho do BSDL do STM32F1 disponibilizado pela ST. Podemos perceber, por exemplo, que a interface JTAG deste microcontrolador suporta até 32 instruções (5 bits).

[...]
 
 entity STM32F1_High_density_LFBGA144 is
 
 -- This section identifies the default device package selected.
 
   generic (PHYSICAL_PIN_MAP: string:= "BGA144_PACKAGE");
 
-- This section declares all the ports in the design.
 
   port ( 
	  BOOT0		: in 	bit;
	  JTDI		: in 	bit;
	  JTMS		: in 	bit;
	  JTCK		: in 	bit;
	  JTRST		: in 	bit;
	  JTDO		: out	bit;
	  OSC_IN        : inout bit;
	  OSC_OUT       : inout bit;
	  PA0		: inout	bit;
	  PA1		: inout	bit;
	  PA2		: inout	bit;
	  PA3		: inout	bit;
 
[...]
 
-- Specifies the number of bits in the instruction register.
 
   attribute INSTRUCTION_LENGTH of STM32F1_High_density_LFBGA144: entity is 5;
 
-- Specifies the boundary-scan instructions implemented in the design and their opcodes.
 
   attribute INSTRUCTION_OPCODE of STM32F1_High_density_LFBGA144: entity is 
     "BYPASS  (11111)," &
     "EXTEST  (00000)," &
     "SAMPLE  (00010)," &
     "PRELOAD (00010)," &
     "IDCODE  (00001)";

Agora que conhecemos um pouco sobre a interface JTAG, o que podemos fazer com ela na prática?

A interface JTAG na prática

Com JTAG podemos controlar a execução do firmware (parar a execução, inspecionar a memória, colocar breakpoints, executar passo-a-passo, etc). Desta forma, podemos inspecionar o estado do processador e de seus registradores, ler/escrever na memória e acionar dispositivos de I/O.

Através de um recurso chamado Boundary Scan, a interface JTAG permite o acesso a todos os pinos do chip! Desta forma, podemos ler e escrever individualmente em cada pino, e consequentemente manipular os periféricos conectados ao processador/microcontrolador (GPIO, memória, flash, etc).

Na prática, com a interface JTAG podemos:

  • Identificar informações sobre o hardware (processador, memória, etc).
  • Fazer um dump da memória RAM e obter acesso a dados sensíveis como senhas e chaves criptográficas.
  • Alterar o comportamento de programas em tempo de execução para obter acesso privilegiado ao sistema.
  • Capturar dados sensíveis de dispositivos de hardware, como informações armazenadas em uma EEPROM.
  • Acionar periféricos e mudar seu comportamento, como ligar ou desligar um pino de I/O.
  • Fazer um dump da memória flash para extrair o firmware do dispositivo!

Perceba que a interface JTAG é perfeita para inspecionar a execução do firmware e explorar vulnerabilidades em dispositivos eletrônicos.

Mas se a interface JTAG é tão insegura, porque muitos fabricantes de hardware não removem ou desabilitam o acesso a esta interface?

Porque a interface JTAG é bastante conveniente para o desenvolvimento e a produção do hardware! Os desenvolvedores utilizam a interface JTAG para depurar o firmware em execução no dispositivo. Além disso, a interface JTAG é utilizada como ferramenta de programação e testes do dispositivo em produção.

Porém, alguns fabricantes podem utilizar algumas contra-medidas ao uso de JTAG no produto final, incluindo:

  • Obfuscação (cortar trilhas, remover resistores, etc).
  • Reconfiguração dos pinos em software.
  • Criptografia/assinatura do firmware.

Outros fabricantes vão além e desabilitam completamente a interface JTAG através de alguns fuses (bits internos do chip que, uma vez programados, não podem mais ser alterados).

Mesmo assim, ainda é possível reabilitar a interface JTAG com técnicas como silicon die attack, capazes de alterar a configuração dos fuses. Afinal, segurança é sempre uma questão de quanto tempo, conhecimento e recursos você tem, certo?

Mas vamos ao que interessa!

Extraindo firmware com JTAG

Estas são as quatro principais etapas para extrair o firmware de um dispositivo com JTAG:

  1. Identificar os pinos de conexão JTAG.
  2. Testar a conexão com um adaptador JTAG.
  3. Levantar informações sobre o mapeamento de memória do chip.
  4. Extrair o firmware da memória flash.

Enquanto explico o processo, irei exemplificar na prática através da extração do firmware do roteador Linksys WRT54G.

Passo 1: Identificar os pinos JTAG

Encontrar os sinais da interface JTAG e identificar sua pinagem pode ser bastante trabalhoso! Isso porque o fabricante do dispositivo pode esconder, obfuscar ou desabilitar a interface JTAG.

Antes de começar, faça buscas na Internet para verificar se o trabalho de identificação da interface JTAG já não foi feito e publicado por alguém.

Caso não encontre nada na Internet, procure na placa por um grupo de pinos juntos e não populados através de inspeção visual. Os pinos da interface JTAG podem estar escondidos debaixo de algum outro componente (capacitor, bateria, etc). Atente-se também aos diversos padrões diferentes de conectores JTAG (2×10, 2×8, 2×7, 2×5, etc).

jtag pinout

Baixe o datasheet do chip para identificar os pinos JTAG e faça testes com um multímetro, osciloscópio ou analisador lógico. Uma ferramenta de força-bruta como o JTAGulator também pode ajudar bastante!

jtagulator

Às vezes a interface JTAG está bastante evidente e documentada na Internet, como a do roteador WRT54G:

jtag wrt54g

Às vezes não está tão evidente assim, com os pinos da interface JTAG deste disco rígido da Western Digital:

jtag western digital

Portanto, o processo de identificação da interface JTAG pode ser bastante trabalhoso e vai exigir muita paciência!

Passo 2: Testar a conexão JTAG

Com os pinos identificados, podemos iniciar o processo de comunicação com a interface JTAG. Para isso, precisamos basicamente de dois componentes: um adaptador JTAG e um software de comunicação JTAG.

O adaptador JTAG é responsável pela comunicação física com o dispositivo através da interface JTAG, normalmente se conectando ao PC através de uma interface USB. E o software de comunicação JTAG é responsável por se comunicar com a interface JTAG através do adaptador JTAG.

jtag adapter

Existem diversos adaptadores JTAG disponíveis no mercado, alguns bastante caros com foco no uso profissional e outros mais acessíveis, sendo alguns de hardware aberto:

  • SEGGER J-Link
  • Keil ULINK
  • Flyswatter/Flyswatter2
  • Bus Blaster
  • Bus Pirate
  • Black Magic Probe
  • Shikra

Nos meus testes irei utilizar o Flyswatter da Tin Can Tools.

Para se comunicar com a interface JTAG, existem diversas opções de software, muitas delas proprietárias. Dentre as opções de código-aberto, temos o OpenOCD e o UrJTAG.

O OpenOCD (Open On-Chip Debugging) é uma ferramenta de código-aberto para comunicação via JTAG. O projeto tem muitos anos de existência, se conecta facilmente ao GDB e possui um suporte bastante abrangente de controladores JTAG e dispositivos de hardware.

O UrJTAG é um projeto mais novo, moderno e com uma interface mais amigável, porém com suporte a hardware mais limitado.

Nos meus testes, irei utilizar o UrJTAG, que pode ser instalado em uma distribuição baseada no Debian conforme abaixo:

$ sudo apt install -y urjtag
 
$ jtag 
 
UrJTAG 0.10 #2007
Copyright (C) 2002, 2003 ETC s.r.o.
Copyright (C) 2007, 2008, 2009 Kolja Waschk and the respective authors
 
UrJTAG is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
There is absolutely no warranty for UrJTAG.
 
warning: UrJTAG may damage your hardware!
Type "quit" to exit, "help" for help.
 
jtag>

Com o adaptador JTAG conectado ao WRT54G, podemos utilizar o UrJTAG para testar a comunicação com a interface JTAG e extrair o ID do dispositivo através da instrução IDCODE (este ID é um número único atribuído pela JEDEC a cada modelo de chip fabricado no mundo).

Como podemos ver nos comandos abaixo, a comunicação com a interface JTAG está funcionando e o device ID do chip do WRT54G é 0x0535217F.

jtag> cable Flyswatter
Connected to libftdi driver.
 
jtag> detect
IR length: 8
Chain length: 1
Device Id: 00000101001101010010000101111111 (0x0535217F)
  Manufacturer: Broadcom (0x17F)
  Part(0):      BCM5352 (0x5352)
  Stepping:     V1
  Filename:     /usr/local/share/urjtag/broadcom/bcm5352/bcm5352
ImpCode=00000000100000000000100100000100
EJTAG version: <= 2.0
EJTAG Implementation flags: R4k DMA MIPS32
Clear memory protection bit in DCR
Clear Watchdog
Potential flash base address: [0x0], [0x0]
Processor successfully switched in debug mode.
 
jtag> instruction IDCODE::shift ir::shift dr::dr
00000101001101010010000101111111 (0x0535217F)

Passo 3: Identificar informações sobre a memória

O próximo passo é analisar o modelo e o endereçamento de memória do chip para identificar o endereço inicial e o tamanho da memória flash do dispositivo.

Uma inspeção visual pode ajudar a identificar o chip da flash. Buscas na Internet por informações sobre a plataforma de hardware ou produtos com hardware similar também podem ajudar, assim como a documentação do chip (SoC, processador, etc).

Caso tenha acesso a um terminal de comandos no dispositivo, procure no bootloader ou nos logs do sistema operacional alguma mensagem referente ao modelo e endereçamento da memória flash.

Às vezes, é necessário utilizar algum método de tentativa e erro ou força bruta para identificar o endereçamento da memória flash do dispositivo.

No meu caso, como estou utilizando um roteador de arquitetura MIPS, posso utilizar as instruções EJTAG (uma extensão da interface JTAG), para identificar o mapeamento de memória do chip.

Pelos comandos abaixo, podemos identificar a flash no endereço 0x1FC00000 (linha 19).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
jtag> initbus ejtag_dma
ImpCode=00000000100000000000100100000100
EJTAG version: <= 2.0
EJTAG Implementation flags: R4k DMA MIPS32
Clear memory protection bit in DCR
Clear Watchdog
Potential flash base address: [0x0], [0x0]
Processor successfully switched in debug mode.
Initialized bus 1, active bus 0
 
jtag> print	
 No. Manufacturer              Part                 Stepping Instruction          Register                        
-------------------------------------------------------------------------------------------------------------------
   0 Broadcom                  BCM5352              V1       EJTAG_CONTROL        EJCONTROL                       
 
Active bus:
*0: EJTAG compatible bus driver via DMA (JTAG part No. 0)
	start: 0x00000000, length: 0x1E000000, data width: 32 bit, (USEG : User addresses)
	start: 0x1E000000, length: 0x02000000, data width: 16 bit, (FLASH : Addresses in flash (boot=0x1FC00000))
	start: 0x20000000, length: 0x60000000, data width: 32 bit, (USEG : User addresses)
	start: 0x80000000, length: 0x20000000, data width: 32 bit, (KSEG0: Kernel Unmapped Cached)
	start: 0xA0000000, length: 0x20000000, data width: 32 bit, (KSEG1: Kernel Unmapped Uncached)
	start: 0xC0000000, length: 0x20000000, data width: 32 bit, (SSEG : Supervisor Mapped)
	start: 0xE0000000, length: 0x20000000, data width: 32 bit, (KSEG3: Kernel Mapped)

Podemos confirmar o endereço com o comando detectflash:

jtag> detectflash 0x1fc00000
Query identification string:
	Primary Algorithm Command Set and Control Interface ID Code: 0x0002 (AMD/Fujitsu Standard Command Set)
	Alternate Algorithm Command Set and Control Interface ID Code: 0x0000 (null)
Query system interface information:
	Vcc Logic Supply Minimum Write/Erase or Write voltage: 2700 mV
	Vcc Logic Supply Maximum Write/Erase or Write voltage: 3600 mV
	Vpp [Programming] Supply Minimum Write/Erase voltage: 0 mV
	Vpp [Programming] Supply Maximum Write/Erase voltage: 0 mV
	Typical timeout per single byte/word program: 16 us
	Typical timeout for maximum-size multi-byte program: 0 us
	Typical timeout per individual block erase: 1024 ms
	Typical timeout for full chip erase: 0 ms
	Maximum timeout for byte/word program: 512 us
	Maximum timeout for multi-byte program: 0 us
	Maximum timeout per individual block erase: 16384 ms
	Maximum timeout for chip erase: 0 ms
Device geometry definition:
	Device Size: 4194304 B (4096 KiB, 4 MiB)
	Flash Device Interface Code description: 0x0002 (x8/x16)
	Maximum number of bytes in multi-byte program: 1
	Number of Erase Block Regions within device: 2
	Erase Block Region Information:
		Region 0:
			Erase Block Size: 8192 B (8 KiB)
			Number of Erase Blocks: 8
		Region 1:
			Erase Block Size: 65536 B (64 KiB)
			Number of Erase Blocks: 63
Primary Vendor-Specific Extended Query:
	Major version number: 1
	Minor version number: 1
	Address Sensitive Unlock: Required
	Erase Suspend: Read/write
	Sector Protect: 4 sectors per group
	Sector Temporary Unprotect: Not supported
	Sector Protect/Unprotect Scheme: 29BDS640 mode (Software Command Locking)
	Simultaneous Operation: Not supported
	Burst Mode Type: Supported
	Page Mode Type: Not supported
	ACC (Acceleration) Supply Minimum: 11500 mV
	ACC (Acceleration) Supply Maximum: 12500 mV
	Top/Bottom Sector Flag: Bottom boot device

Passo 4: Extraindo o firmware

Para extrair o firmware, basta utilizar o software de comunicação JTAG para ler o intervalo de memória identificado no passo anterior e salvar em um arquivo.

Dependendo do tamanho da flash e da velocidade de comunicação com a interface JTAG, o processo pode levar vários minutos!

Com a ferramenta UrJTAG, o firmware do WRT54G pode ser extraído com o comando readmem:

jtag> readmem 0x1fc00000 0x400000 flash.bin                         
address: 0x1FC00000
length:  0x00400000
reading:
addr: 0x20000000
Done.

Depois de vários minutos, a imagem extraída da memória flash estará disponível para análise:

$ ls -lh flash.bin
-rw-r--r-- 1 sprado sprado 4,0M fev 18 22:12 flash.bin

Agora podemos analisar a imagem do firmware com a ferramenta binwalk:

$ binwalk --signature flash.bin 
 
DECIMAL       HEXADECIMAL     DESCRIPTION
--------------------------------------------------------------------------------
211412        0x339D4         Copyright string: "Copyright (C) 2000,2001,2002,2003 Broadcom Corporation."
234095        0x3926F         Copyright string: "Copyright 1995-1998 Mark Adler "
239104        0x3A600         CRC32 polynomial table, little endian
262144        0x40000         TRX firmware header, little endian, image size: 3211264 bytes, CRC32: 0xA293EEE4, flags: 0x0, version: 1, header size: 28 bytes, loader offset: 0x1C, linux kernel offset: 0x904, rootfs offset: 0x84800
262172        0x4001C         gzip compressed data, maximum compression, from Unix, last modified: 1970-01-01 00:00:00 (null date)
264452        0x40904         LZMA compressed data, properties: 0x6D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes
804864        0xC4800         Squashfs filesystem, little endian, version 3.0, size: 2604183 bytes, 692 inodes, blocksize: 65536 bytes, created: 2011-04-04 11:37:10
3473408       0x350000        JFFS2 filesystem, little endian
3604480       0x370000        JFFS2 filesystem, little endian
4001816       0x3D1018        Zlib compressed data, compressed
4002248       0x3D11C8        JFFS2 filesystem, little endian
4004760       0x3D1B98        Zlib compressed data, compressed
4005968       0x3D2050        JFFS2 filesystem, little endian
4006772       0x3D2374        Zlib compressed data, compressed
4007356       0x3D25BC        Zlib compressed data, compressed
4008168       0x3D28E8        Zlib compressed data, compressed
4009192       0x3D2CE8        Zlib compressed data, compressed
4010552       0x3D3238        Zlib compressed data, compressed
4012236       0x3D38CC        JFFS2 filesystem, little endian
4014352       0x3D4110        Zlib compressed data, compressed
4014516       0x3D41B4        JFFS2 filesystem, little endian
4015916       0x3D472C        Zlib compressed data, compressed
4016672       0x3D4A20        JFFS2 filesystem, little endian
4038596       0x3D9FC4        JFFS2 filesystem, little endian
4062896       0x3DFEB0        Zlib compressed data, compressed
4063232       0x3E0000        JFFS2 filesystem, little endian

E extrair o sistema de arquivos da imagem!

$ binwalk --extract --quiet flash.bin 
$ ls _flash.bin.extracted/squashfs-root/
bin  boot  dev  etc  jffs  lib  mnt  proc  README  rom  root  sbin  sys  tmp  usr  var  www

A interface JTAG é uma ferramenta fantástica para fazer pesquisas de segurança em dispositivos eletrônicos. E hoje existem diversos adaptadores JTAG abertos, populares e baratos que podem facilitar o processo, exigindo apenas um pouco de conhecimento e tempo livre. Diversão garantida!

Um abraço,

Sergio Prado

Navegue
Creative Commons Este trabalho de Sergio Prado é licenciado pelo
Creative Commons BY-NC-SA 3.0.