TRANSCRIÇÃO · CC BY 3.0

Philippe Laulheret - Introdução ao Hacking de Hardware - Conferência DEF CON 27

Tradução automática para o português do Brasil. Gerada e salva em 2026-10-23. Pode conter erros; confira os termos e as citações na versão em inglês e no vídeo original. Os horários são os mesmos da fonte. A transcrição original em inglês está disponível abaixo.

Philippe Laulheret usa telefones VoIP para explicar a pesquisa de segurança de hardware, desde o reconhecimento e as interfaces de depuração até a investigação de firmware.

DEFCONConference · Publicado em · 46 min · Inglês · Licença: CC BY 3.0 · Fonte: assistir no YouTube

Fonte da transcrição: legendas enviadas pelo criador no YouTube. Pontuação por IA adicionada pelo Vidleaf; redação original e âncoras de carimbo de tempo preservadas. A transcrição original está disponível abaixo.

Resumo gerado por IA

Philippe Laulheret usa uma investigação de um telefone VoIP para explicar o processo de pesquisa de segurança de hardware. A palestra passa da documentação pública e da inspeção da placa às interfaces de depuração, à análise de firmware e aos problemas encontrados ao longo do caminho. Seu valor está em mostrar como observações em diferentes camadas podem informar umas às outras, incluindo abordagens que não funcionaram. Um estudo de caso posterior conecta a investigação do dispositivo a uma vulnerabilidade de software e a uma demonstração de suas consequências. A discussão final retorna a medidas defensivas, incluindo a aplicação de patches do fornecedor, o monitoramento de redes e a separação adequada de dispositivos.

Pontos-chave

  • [4:37] A investigação inclui abordagens malsucedidas e enfatiza um processo que pode variar entre dispositivos.
  • [26:19] A análise de firmware é uma parte de entender como um dispositivo embarcado se comporta.
  • [45:17] A palestra termina com recomendações defensivas sobre aplicação de patches, monitoramento e segmentação de rede.

Gerado a partir da transcrição. Verifique as passagens vinculadas em relação ao vídeo original. Resumo e pontos-chave revisados pelo Vidleaf em 2026-10-21.

Visão geral completa

Philippe Laulheret, pesquisador sênior de segurança na McAfee Advanced Threat Research, apresenta uma introdução ao hacking de hardware usando telefones VoIP Avaya da série 9, incluindo o 9611g, como exemplo recorrente. Ele argumenta que o hacking de hardware importa porque é divertido e empoderador, e pragmaticamente porque o software está se tornando mais difícil de quebrar, enquanto abrir um dispositivo e soldar alguns fios pode ser mais fácil, oferecendo frutas ao alcance da mão. A palestra enfatiza o processo em vez dos resultados, compartilhando o que não funcionou e observando que o que funciona para um dispositivo pode não funcionar para outro. Abrange reconhecimento por meio de fotos internas da FCC, manuais e fóruns, interfaces de depuração de hardware como UART, JTAG e pontos de teste, taxas de transmissão, e resistores de pull-up e pull-down, e termina com ferramentas e segurança, incluindo ferros de solda, fluxo, fio com revestimento de verniz, malha de dessoldagem, pistola de calor e multímetro. Um segundo lote pesquisa ferramentas como analisadores lógicos, cabos seriais FTDI, o Bus Pirate, depuradores JTAG como o fly swatter, J Link e o JTagulator, e leitores de flash, observando que ferramentas mais caras provavelmente são mais confiáveis com melhor software; descreve injeção de falhas com ChipWhisperer para telefones com flash criptografado e sem UART ou firmware, três abordagens para obter um shell (console UART, recuperação de flash e download de firmware online, que funcionou porque o firmware não era criptografado), despejo de flash em circuito e fora de circuito, despejo de RAM via JTAG, glitching USB de Scanlime em um tablet Wacom, e análise de firmware com Binwalk com um aviso de falso positivo, antes de começar a reverter o bootloader ARM para descobrir por que o console foi definido como /dev/null. O palestrante então percorre o hacking de caixa preta do Avaya 9611g, localizando o endereço do bootloader no IDA por meio de strings como 'EEPROM read successful', examinando a EEPROM SPI com um analisador lógico e datasheet, e corrigindo a função de configuração do console; após soldar fios no chip minúsculo e usar um Bus Pirate, teste de continuidade no pad UART e sondagem de pinos com um cabo FTDI resulta em um shell root, e um cabo Ethernet é lixado para caber na porta RJ45 MOD com chave. O reconhecimento encontra o DHClient, que falha por conta própria e carrega um copyright 2007; comparar o original de código aberto com o código-fonte corrigido mostra um memcpy limitado por 4 na versão corrigida, mas não no tratamento vulnerável da máscara de sub-rede, e o IDA confirma que não há canário de pilha e nem 4 mágico. Ele configura emulação Full-System do QEMU (Userland não funcionará porque o DHCP modifica um IP), reimplementa o lado do socket de nome em Python compartilhado via Socat, e muda para um exploit baseado em Scapy enviando uma opção de máscara de sub-rede superdimensionada com dados padronizados para identificar registradores controlados; o controle do PC é confirmado, e como a pilha parece não executável, uma chamada de sistema no binário (possivelmente adicionada pela Avaya) é usada com um R4 controlado apontando para uma string encontrada via opção de domínio, com ASLR desabilitado. Uma demonstração mostra um cliente DHCP malicioso e servidor web exfiltrando áudio do alto-falante principal para o VLC no laptop do atacante, e ele aconselha monitoramento de rede, segmentação e confirmar que a TI realmente aplica o patch da Avaya de cerca de um mês atrás. Nas considerações finais, ele enfatiza que sistemas embarcados não são caixas pretas e incentiva todos a examiná-los, então convida perguntas via Twitter e agradece à audiência.

Resumos de capítulos com carimbos de tempo

Palestra de Introdução ao Hacking de Hardware

  • [0:00] Philippe, originalmente da França e baseado em Portland, é apresentado para falar sobre invadir dispositivos embarcados, incluindo telefones.
  • [0:35] Philippe Laulheret dá uma introdução ao hacking de hardware.
  • [0:48] Ele é pesquisador sênior de segurança na McAfee Advanced Threat Research, fazendo pesquisa de software e hardware em telefones.
  • [0:53] Ele pode ser encontrado no Twitter em PHLaul.
  • [0:58] Antes da McAfee, ele passou 2 anos fazendo segurança embarcada e, antes disso, era desenvolvedor C++.

Por que o Hacking de Hardware Importa

  • [1:13] Duas razões principais para se importar com hacking de hardware: é divertido e empoderador abrir um dispositivo em vez de tratá-lo como uma caixa preta.
  • [1:30] Pragmaticamente, o software está se tornando muito mais difícil de quebrar, então encontrar uma vulnerabilidade em um servidor web por si só é meio difícil.
  • [1:45] Abrir o dispositivo e soldar alguns fios para obter um shell é muito mais fácil.
  • [1:53] O hacking de hardware é ótimo porque também oferece muitas frutas ao alcance da mão.

Telefones VoIP Avaya e Hacking de Hardware

  • [1:58] A palestra aborda telefones Avaya, especialmente a série 9, com o modelo 9611g mostrado no slide.
  • [2:03] A Avaya é descrita como uma das maiores provedoras de soluções VoIP, encontrada em todos os lugares.
  • [2:08] Diz-se que a Avaya está em cerca de 90% das empresas Fortune 100, e esse modelo específico de telefone começou em 2006 e está se aproximando do fim de vida útil por volta do final do ano.
  • [2:22] Uma captura de tela de slide mostra firmware antigo de telefone que só podia ser baixado por clientes do DOD, indicando que os telefones chegam a muitos lugares diferentes.
  • [2:41] Trabalhos anteriores em hacking de hardware incluem posts de blogs na internet e tutoriais, o Hardware Hacking Village, e CTFs para praticar o lado mais soft.
  • [3:02] Os links estão nos slides, e os slides enviados têm mais texto para serem mais autônomos.
  • [3:11] O palestrante diz que encontrou 2 RCs no mesmo telefone há cerca de cinco anos.

Processo de Hacking de Hardware e Firmware Não Corrigido

  • [3:22] O palestrante recomenda uma palestra da RSA chamada Stepping P3wns disponível online.
  • [3:26] Os próximos 40 minutos cobrirão hacking de hardware, usando o telefone como exemplo de apoio.
  • [3:36] Cerca de 12 anos atrás, via Fox e código aberto, patches de segurança nunca foram aplicados.
  • [3:51] Ao mexer no dispositivo, o palestrante encontrou um problema que passou despercebido por cerca de 10 anos, ligado a um CVE lançado cerca de 10 anos atrás para a Defcon.
  • [4:04] A palestra aborda encontrar algo no firmware, mas foca mais no processo de como e por que o palestrante fez as coisas.
  • [4:21] O palestrante compartilhará o que não funcionou, já que o que funciona para um dispositivo pode não funcionar para outro.
  • [4:37] A principal lição é aprender o processo para verificar qualquer dispositivo que você tenha.
  • [4:47] O palestrante, vindo de formação em software, diz que hacking de hardware não é tão difícil com um bom processo e paciência, e que todos na sala podem fazer isso.

Reconhecimento Antes de Hackear Telefones de Escritório

  • [5:06] Ver telefones baseados em Linux com acesso à rede e microfones em cada mesa de escritório levantou a questão de quão seguros eles são.
  • [5:27] Um passo inicial é desmontar fisicamente o telefone de um colega de trabalho para inspecioná-lo.
  • [5:31] Dispositivos com Wi-Fi ou Bluetooth devem aparecer no site da FCC para conformidade, o que fornece fotos internas.
  • [5:50] Fotos da FCC revelaram um conector de depuração aleatório e memória flash, que geralmente armazena o sistema de arquivos do telefone.
  • [6:09] Essa inspeção dá uma ideia se o alvo será fácil ou difícil, por exemplo, epóxi preto cobrindo tudo torna mais difícil.
  • [6:27] Reunir material online como folhetos de marketing ajuda a mapear as capacidades do telefone e a superfície de ataque.
  • [6:43] Um manual avançado do usuário indicou que uma conexão serial ao telefone requer uma caixa especial.
  • [7:03] Verificar fóruns revelou senhas padrão para a interface de depuração do telefone e para o administrador do sistema.

Interfaces de Depuração de Hardware do Telefone

  • [7:28] Esta é uma palestra de hacking de hardware e voluntários são fornecidos; o ponto é abrir o telefone primeiro.
  • [7:36] Você geralmente espera encontrar as mesmas coisas dentro; pesquisar no Google os rótulos dos componentes revela o que são.
  • [7:45] No telefone do palestrante, a CPU está no centro com a RAM acima dela, e um header lavanda não populado marcado com um ponto de interrogação pode ser JTAG, mas não foi usado, então isso é incerto.
  • [8:03] A placa tem EEPROMs que guardam configurações, e um RJ45 com chave na parte inferior que é um RJ45 normal com um conector estranho para que coisas erradas não possam ser plugadas.
  • [8:26] UART é como um console serial com pads expostos; na fabricação, pinos pogo geralmente se conectariam aos pads, e você esperaria encontrar o console serial ali.
  • [8:43] Na parte de trás está a flash NAND vista na imagem anterior, que é onde o sistema de arquivos estaria armazenado no dispositivo.
  • [9:00] Pontos de teste e headers de depuração valem a pena ser examinados porque a placa de desenvolvimento geralmente é a mesma da produção e componentes de depuração podem não ser removidos, semelhante a software compilado com símbolos de depuração.
  • [9:26] Pontos de teste podem ser usados na fabricação para gravar o dispositivo ou garantir que ele foi gravado corretamente, e às vezes para análise post mortem quando algo morreu no mundo real.
  • [9:43] Coisas para procurar incluem UART, JTAG e pontos de teste aleatórios rotulados como TP1 ou TP2; às vezes curto-circuitar TP64 com terra reinicia o dispositivo, o que pode ser útil.
  • [10:13] UART vem em 3 ou 4 pinos: terra, transmissão, recepção e, opcionalmente, VCC (3 ou 5 volts), que você geralmente não se importa e não precisa plugar.
  • [10:36] Consoles seriais usam velocidades diferentes chamadas taxas de transmissão com apenas alguns valores comuns; texto sem sentido na tela provavelmente significa que a taxa de transmissão está errada, e alternar entre os valores possíveis acabaria encontrando algo.
  • [10:58] JTAG é para depuração de hardware da CPU, geralmente executando instrução por instrução, e vem em muitos formatos e contagens de pinos com apenas alguns fios interessantes.

Resistores de pull-up/down e leitura de placas

  • [11:53] Resistores de pull-up e pull-down conectam um pino ao terra ou ao VCC.
  • [11:57] O palestrante não sabe o objetivo desses resistores, mas sem eles as coisas podem não funcionar bem ou dá mais trabalho e fica instável.
  • [12:06] Seguir uma especificação, como uma especificação ARM para o resistor necessário, pode permitir ignorá-los, mas você pode perder tempo entendendo por que às vezes fica estranhamente bagunçado.
  • [12:19] O palestrante recomenda os resistores de pull-up e pull-down.
  • [12:24] A placa de um colega aleatório mostra que o conselho é bastante genérico: UART à esquerda, alguns conectores JTAG à direita, e a CPU principal sob uma blindagem.
  • [12:38] A blindagem geralmente é feita para evitar interferências, como em um módulo Wi-Fi.
  • [12:43] A blindagem geralmente é aterrada, então a blindagem ou a carcaça ao redor da porta Ethernet pode ser bastante útil ao procurar terra.

Ferramentas e Segurança para Hacking de Hardware

  • [13:12] Segurança em primeiro lugar: não trabalhe em coisas plugadas na parede, desconecte as coisas e use um ambiente bem ventilado.
  • [13:34] Ferros de solda têm pontas intercambiáveis: pontas grandes para soldas grandes e pontas minúsculas para soldas pequenas.
  • [13:38] Um microscópio é útil para soldas minúsculas; manter o braço reto e bem aterrado ajuda mesmo se você tremer.
  • [14:12] Fluxo é uma substância pegajosa aplicada a pinos ou pads que faz a soldagem de montagem superficial funcionar bem; nunca esqueça o fluxo.
  • [14:29] Fio de cobre com revestimento de verniz evita curtos e é útil para soldagem ponto a ponto minúscula.
  • [14:48] A malha de dessoldagem absorve o excesso de solda quando aquecida com o ferro para limpar erros.
  • [15:15] Uma pistola de calor de cerca de $60 da Home Depot pode remover componentes aquecendo e puxando-os.
  • [15:27] Um multímetro encontra a voltagem de um chip (preto no terra, ponta vermelha para medir) e seu modo de continuidade apita para verificar conexões de solda.
  • [16:03] Um Analisador Lógico (marca Sally) converte sinais em fios em dados reais através de muitos protocolos, agindo como seus olhos ao depurar.
  • [16:36] Um cabo serial FTDI se conecta ao seu laptop e a uma porta UART para fornecer um console, por exemplo, um console serial de Raspberry Pi sem HDMI.
  • [17:01] O Bus Pirate envia dados em vez de absorvê-los, fala muitos protocolos e pode ser programado em Python, útil para ler flash e programar microcontroladores.

Visão geral de ferramentas de hacking de hardware

  • [17:26] Depuradores JTAG se conectam via porta Digitech e vêm em muitas faixas de preço.
  • [17:38] Um mata-moscas custa provavelmente cerca de 30 dólares e funciona bem, enquanto um J Link acima dele é mais sofisticado.
  • [17:47] Ferramentas mais caras provavelmente são mais confiáveis e vêm com software melhor.
  • [17:55] O JTagulator de corpo rosa foi feito por Joe Grand, o mesmo cara que fez aqueles crachás.
  • [18:04] Se você não sabe onde está o JTAG em uma placa, pode conectar todos os pontos de teste ao JTagulator e ele fará força bruta para encontrar tudo.
  • [18:16] Leitores de flash são ferramentas importantes porque o Flash contém o sistema de arquivos e você quer interagir com ele.
  • [18:27] A leitura de flash vem em dois sabores: em circuito com um clipe ou clipe retangular, ou dessoldando o chip e usando um adaptador de soquete.
  • [18:35] O Raspberry Pi é uma boa opção para trabalho em circuito, e o Flash Cat no canto superior direito é útil para o clipe retangular.

Ataques avançados de hardware em celulares

  • [19:06] Quando o Flash é criptografado e não há UART ou firmware, ataques mais extremos como injeção de falhas podem ser tentados.
  • [19:14] O ChipWhisperer é descrito como um dispositivo mais difícil e mais foda para esses ataques.
  • [19:19] A técnica envolve conectar à CPU e cortar a energia da CPU por uma fração de segundo para bagunçar uma instrução e contornar verificações.
  • [19:30] É isso que as pessoas usam para hacking de consoles de videogame.
  • [19:40] Com uma ideia do que há dentro do celular e das ferramentas disponíveis, o próximo passo é prosseguir.

Console UART e tentativas de recuperação de firmware

  • [19:47] Três abordagens potenciais: mexer com o console serial UART, mexer com o flash para recuperar o firmware, ou baixar o firmware online.
  • [19:55] Todas as três são abordagens válidas, e pode ajudar alternar entre elas dependendo do hardware encontrado.
  • [20:03] Ele tentou UART primeiro, conectando um cabo FTDI às portas UART como antes.
  • [20:17] Ver pontos no console geralmente significa que pressionar espaço ou escape pode interromper o processo de boot do celular, mas aqui não funcionou.
  • [20:30] O dispositivo leu algo da EEPROM e então definiu o console para Dev null, o que é indesejável porque a saída não vai a lugar nenhum.
  • [20:43] Ele então inicializa no Linux, confirmando que é uma porta UART, mas nada mais aparece depois, provavelmente por causa da situação do Dev null.
  • [21:07] Ele então tentou recuperar o firmware, e um método online fácil realmente funcionou; neste caso o firmware não estava criptografado.
  • [21:21] Outra opção é farejar uma atualização de firmware, útil para dispositivos IoT em geral, usando um tap de rede ou espelhando a porta em um switch.
  • [21:36] O problema é que as atualizações de firmware frequentemente passam por HTTPS, então você pode ficar preso e precisar de hacking de hardware, como despejar um flash.

Métodos e truques de despejo de flash

  • [21:53] Há duas maneiras de despejar o flash: programação em circuito e fora do circuito.
  • [21:57] Em circuito é conveniente porque você não precisa remover ou quebrar coisas, mas o principal problema é que você precisa alimentar o flash.
  • [22:11] Quando um Raspberry Pi tenta ler o flash enquanto ele ainda está conectado ao sistema inteiro, ele pode tentar alimentar todo o resto na mesma linha de energia.
  • [22:19] O USB Pi pode não ser forte o suficiente para alimentar um telefone VoIP, ou se for forte o suficiente, a CPU pode parar de inicializar e conversar com o flash, bagunçando as coisas.
  • [22:37] Duas escolhas nessa situação: levantar os pinos/bolas de pino, ou manter a CPU em reset.
  • [22:51] Outra abordagem é aterrar pontos de teste aleatórios na placa até o celular acender mas não inicializar.
  • [23:03] Você pode dessoldar o chip com uma pistola de calor, mas tenha cuidado para não puxar com muita força e entortar os pinos.
  • [23:17] Um bom truque é fazer um chapeuzinho de papel alumínio no chip para que os componentes ao redor não esquentem demais.
  • [23:33] Praticar em um pen drive USB aleatório funcionou muito bem; lembre-se de usar fluxo.
  • [23:51] U-Boot é o bootloader mais comum, não usado aqui, mas encontrado em praticamente todos os outros dispositivos.
  • [23:56] Pode-se instruir o U-Boot a carregar o flash na memória e despejá-lo em hexadecimal, mas geralmente os desenvolvedores bloqueiam essa abordagem para que você não possa pressionar espaço para interromper o processo de boot.
  • [24:24] A abordagem Yolo: enquanto o U-Boot carrega do flash, cutucar os pinos do flash NAND com um fio conectado ao terra para bagunçar o que o U-Boot está lendo, e após algumas tentativas ele te dá um shell.

Despejo via JTAG e glitching em dispositivos USB

  • [25:21] Se o JTAG funcionar, você pode despejar a RAM, o que em muitos dispositivos significa despejar o firmware carregado na memória.
  • [25:37] O hacking de hardware permite técnicas malucas, como a abordagem da Scanlime a um tablet Wacom sem superfície de ataque.
  • [25:52] A Scanlime descobriu que plugar USB em um laptop envolve uma troca USB, possivelmente um descritor USB.
  • [26:01] Fazer glitching na CPU naquele momento pode fazê-la perder uma verificação binária e enviar muito mais dados.
  • [26:10] Com esse glitch, ela conseguiu recuperar o flash completo e a memória completa.

Análise de firmware com Binwalk

  • [26:19] O firmware pode ser recuperado simplesmente baixando-o online, como no caso do palestrante.
  • [26:24] Binwalk é a melhor ferramenta para analisar firmware, escaneando binários em busca de arquivos embutidos como arquivos zip e sistemas de arquivos comprimidos como Squashfs e JFFS2.
  • [27:01] Em um caso fácil, o firmware era um arquivo doc já dividido em boot 1, boot 2 e JFFS2, então o Binwalk tinha pouco a fazer e o sistema de arquivos podia ser extraído diretamente.
  • [27:19] Um arquivo de firmware mais interessante rendeu muito mais no Binwalk, incluindo um sistema de arquivos extraível e dados MySQL aleatórios que provavelmente são um falso positivo.
  • [27:36] O Binwalk produz muitos falsos positivos, então sua saída não deve ser confiada cegamente.
  • [27:40] Executar strings naquela imagem revelou strings do U-Boot, significando que o dispositivo usa U-Boot e as técnicas descritas anteriormente poderiam funcionar nele.
  • [27:55] Após extrair o firmware, coisas interessantes para procurar incluem o mecanismo de atualização, segredos como senhas e certificados, binários principais como a pilha VoIP, e o bootloader para comandos ocultos.
  • [28:35] O objetivo era obter um shell no dispositivo, com abordagens incluindo consertar o console serial, mexer com argumentos de boot, ou como último recurso aplicar patch no firmware.
  • [29:03] Aplicar patch no firmware não funcionará aqui porque ele é assinado, a menos que você tente glitching, o que é realmente difícil, mas aplicar patch no sistema de arquivos e regravá-lo diretamente no flash é uma opção.

Engenharia reversa do bootloader ARM

  • [29:23] O palestrante planeja fazer engenharia reversa do bootloader para entender por que o console foi definido como /dev/null.
  • [29:39] Literal pools ARM são pequenos pedaços de dados dentro da seção de código, geralmente usados para carregar endereços absolutos, valores imediatos ou offsets mágicos em registradores.
  • [30:00] Em chamadas de função ARM, os argumentos vão em R0 a R3, o valor de retorno fica em R0, e o endereço de retorno é salvo no LR (link register).
  • [30:15] O bootloader não é um ELF real, então o IDA não pode importá-lo sem encontrar o endereço de carregamento que corresponda a onde o celular o carrega.
  • [30:34] Para encontrar o endereço de carregamento, pode-se olhar os cabeçalhos no arquivo do bootloader ou os vetores de interrupção, já que as CPUs ARM precisam de endereços específicos para interrupções.
  • [30:58] O literal pool é útil porque contém endereços absolutos ou ponteiros para strings; strings embaralhadas indicam um endereço errado.
  • [31:15] Neste caso o endereço foi fácil de encontrar porque o bootloader imprime uma mensagem de salto no boot, e o IDA mostra as strings sendo impressas corretamente, confirmando o carregamento adequado.
  • [31:41] Com o bootloader carregado no IDA, o palestrante procura strings como 'EEPROM read successful' e usa referências cruzadas para encontrar a função de tratamento.

EEPROM SPI e patch do console do bootloader

  • [31:54] A EEPROM da placa é chamada de Spiprom, e SPI é um dos protocolos mencionados anteriormente.
  • [32:00] EEPROM é uma memória pequena, e o protocolo SPI usa cerca de 4 fios, com a CPU enviando comandos e a EEPROM respondendo.
  • [32:12] Um despejo de analisador lógico mostra como o tráfego SPI se parece na vida real, e o datasheet da EEPROM pode ser encontrado online pesquisando o rótulo nela.
  • [32:27] Os pinouts no canto inferior esquerdo do datasheet mostram como conectar à EEPROM, e o lado direito lista quais opcodes mapeiam para comandos SPI, por exemplo, 3 é leitura e 2 é escrita.
  • [32:48] No IDA e no bootloader, o console é definido como Dev null, mas acima disso uma função pode definir o console para UART 0 ou UART 1, e queremos que essas strings sejam impressas.
  • [33:08] Essa função limpa alguns bytes na pilha, lê de um endereço mágico, compara os bytes lidos, e se o valor estiver bom imprime a configuração do console para Dev ttyAMA0.
  • [33:36] A função de leitura da EEPROM foi encontrada facilmente por causa do log destacado em verde dizendo que a leitura da EEPROM falha; caso contrário, poderia se procurar a função SPI que envia 3.
  • [34:05] Encontrar uma função SPI é difícil porque ela usa endereços mágicos de IO mapeado em memória; com um datasheet da CPU os endereços são especificados, mas sem um você tem que adivinhar e é realmente difícil.
  • [34:49] O plano é aplicar patch na EEPROM para que o console possa ser construído, sabendo os comandos de leitura e escrita e querendo interagir com o flash.

Soldando fios e encontrando shell root via UART

  • [34:59] O Bus Pirate foi escolhido como o dispositivo SPI para conectar à EEPROM.
  • [35:09] O chip era pequeno demais para o clipe, e os equipamentos online eram caros com uma espera de cinco semanas, então ele tentou soldar fios pequenos nele.
  • [35:22] Ele esperava que a solda nunca funcionasse, mas acabou que realmente funcionou.
  • [35:30] O código do Bus Pirate é super boilerplate, usando valores mágicos que ele foi solicitado a substituir por imagens.
  • [35:45] O console foi definido como root, mas a entrada ainda não funcionava ao tentar pressionar espaço ou digitar.
  • [36:15] Ele usou teste de continuidade com um multímetro no pad UART para rastrear para onde vai.
  • [36:26] O traço UART vai para o outro lado da placa e para frente e para trás, eventualmente passando sob a porta RJ45 MOD com chave.
  • [36:54] Segurando um cabo jumper no transmit do seu cabo FTDI, ele cutucou os pinos um por um enquanto pressionava as teclas do console, e o segundo pino deu um shell root.

Hack do cabo Ethernet e shell root

  • [37:24] O palestrante plugou o cabo ethernet no plugue como parte de uma configuração adequada.
  • [37:28] Sem saber onde estava a chave RJ45, o palestrante lixou o plástico do cabo ethernet para enfiá-lo, e simplesmente funciona.
  • [37:36] Com um shell root obtido, muitas strings de depuração são impressas.

Reconhecimento do dispositivo e descoberta do DHClient

  • [37:40] Um watchdog reinicia o dispositivo se o console for inundado, então comandos mágicos para matar o processo estão destacados no canto.
  • [37:53] A pesquisa de vulnerabilidades começa olhando os processos em execução e portas abertas, incluindo coisas novas de sequel.
  • [38:11] Enquanto vasculhava em vez de usar o IDA, o palestrante olhou o DHClient.
  • [38:16] Executar o DHClient revela um copyright de 2007, o que o palestrante aponta como não sendo uma coisa boa.
  • [38:20] Executar o DHClient sozinho causa segfault.
  • [38:25] Executado da maneira correta, o DHClient imprime uma mensagem de depuração dizendo que foi modificado para funcionar melhor no dispositivo.

Análise de estouro de pilha na opção DHCP do DHClient

  • [38:40] Jon Oberheide apresentou um exploit da DEFCON para aquela versão específica do DHClient cerca de 10 anos atrás.
  • [38:51] O telefone era vulnerável a um estouro de pilha ao lidar com opções DHCP.
  • [38:56] Como o DHClient é de código aberto, o código-fonte original pode ser comparado com o código-fonte corrigido, levando em conta mitigações como cookies de pilha e ASLR.
  • [39:11] No código vulnerável, um memcpy usa data.len como campo, enquanto a versão corrigida o limita por 4.
  • [39:21] O bug está no tratamento da máscara de sub-rede: a máscara de sub-rede deveria ter 4 bytes, mas a opção DHCP pode enviar até cerca de 255 bytes e era confiada cegamente.
  • [39:34] No IDA, a função real não tem canário de pilha e não usa o magic 4, então ainda é vulnerável e simples de explorar.
  • [39:48] Trabalhando no SO do telefone TDS, o palestrante planejava configurar a emulação QEMU.

Depuração DHCP Full-System no QEMU

  • [39:52] O QEMU pode fazer emulação Userland ou Full-System para ARM.
  • [39:58] A emulação Userland não funcionará aqui porque o DHCP envolve tentar modificar um IP.
  • [40:02] Em vez disso, usa-se emulação Full-System, seguindo tutoriais de configuração.
  • [40:11] A rede deve ser configurada corretamente para interagir com o DHCP, evitando o DHCP embutido do QEMU.
  • [40:29] Executar no QEMU ainda causava segfault; descobriu-se que a Avaya modificou coisas que causam o Segfault.
  • [40:38] O aplicativo cria um name socket para que a pilha VOIP possa conversar com o DHClient e mostrar opções.
  • [40:56] O lado esquerdo envia dados para configurar o DHClient na inicialização; o lado direito foi reimplementado em Python.
  • [41:00] O script Python roda no host e compartilha o name socket via Socat com a imagem QEMU.

Exploit DHCP com Scapy e Shellcode

  • [41:23] Não foi possível compilar a prova de conceito original porque ela usava ferramentas muito antigas, então mudou-se para um exploit baseado em Scapy.
  • [41:32] Scapy é uma biblioteca Python para manipulação de pacotes de rede de baixo nível.
  • [41:47] O bug está na opção de máscara de sub-rede, que usa o formato tag-length-value do DHCP; enviar um comprimento maior que 4 é aceito apesar da especificação DHCP.
  • [42:12] O payload envia a opção de máscara de sub-rede com dados padronizados (AAAA, BBBB, CCCC) para que, ao travar no GDB, os registradores controlados possam ser identificados.
  • [42:33] Eles confirmaram o controle do PC (program counter), dando controle sobre a execução.
  • [42:47] A pilha parece não executável, então o shellcode deve ser criado de outra forma.
  • [42:57] Existe uma chamada de sistema no binário (possivelmente adicionada pela Avaya), e R4 é controlado, então colocar uma string em um endereço conhecido e colocar seu endereço em R4 poderia funcionar.
  • [43:12] O DHClient recebe valores de configuração do servidor, então os valores provavelmente são armazenados em algum lugar; o ASLR está desabilitado.
  • [43:27] Enviar muitas opções preenchidas com A e inspecionar a memória eventualmente encontrou a string via opção de domínio.

Demonstração de Exploração do Telefone e Mitigação

  • [43:49] O telefone está inicializando, com uma janela de 10 minutos mostrada no lado esquerdo.
  • [43:53] Um cliente DHCP rogue roda a partir do payload no lado esquerdo, enquanto um servidor web no lado direito fornece funcionalidade pós-exploração.
  • [44:02] Executar cat /dev/random nas telas produz uma saída semelhante a ruído para verificar se o pacote está em execução.
  • [44:07] O telefone busca dados do servidor web, carregando um arquivo chamado steve.data, nomeado em homenagem ao chefe do palestrante, Steve.
  • [44:24] O áudio está sendo exfiltrado do alto-falante principal e lido no laptop do atacante via VLC, transformando o telefone em um dispositivo de escuta.
  • [44:49] Todas as ferramentas usadas, como Netcat e ferramentas de atenuação de áudio, já estão no telefone, exigindo apenas scripts shell ou bash.
  • [44:58] Como mitigação, monitore sua rede para evitar que bugs enviem tráfego estranho.

Segmentação de Rede e Recomendações de Correção

  • [45:06] O firewall McAfee pode detectar pacotes DHCP.
  • [45:13] Segmente sua rede para que dispositivos como uma cafeteira não possam enviar pacotes DHCP estranhos para seu telefone.
  • [45:17] Certifique-se de que o TI realmente corrija seu telefone, já que a Avaya lançou um patch cerca de um mês atrás.
  • [45:31] Dados técnicos são realmente difíceis de lidar, o que pode explicar por que esse tipo de bug aconteceu.

Considerações finais sobre sistemas embarcados

  • [45:42] Sistemas embarcados não são caixas pretas, então o palestrante incentiva todos a examiná-los.
  • [45:47] O palestrante convida perguntas via Twitter e agradece à audiência pelo tempo.

[0:00] >>Sem mais delongas, porque estamos dentro do cronograma. Philippe está aqui, uh, de uh, de Portland, vindo da uh, França pelo que entendi. E ele vai falar para, falar para nós sobre uh, invadir dispositivos embarcados, incluindo telefones, uh, telefones que você pode ter na sua mesa no trabalho, telefones que podem estar, eu nem vou entrar nisso, telefones que podem estar por aí. Vamos aprender sobre hacking de dispositivos embarcados. Vamos dar uma grande salva de palmas para Philippe. [Aplausos]. Divirta-se, cara. >>Obrigado. Obrigado a todos um, então estou muito empolgado por estar aqui, é uma grande honra e um, sim, então hoje vamos falar sobre hacking de hardware e um, vou mostrar a vocês esta introdução e espero um, poder mostrar um pouco de carinho sobre um, hacking de hardware. Então uh, quem sou eu? Sou Philippe Laulheret um, sou pesquisador sênior de segurança na McAfee, um, Advanced Threat Research. Então eu, eu faço um, pesquisa de software e hardware de telefones, e você pode me encontrar no Twitter em PHLaul. Antes de trabalhar na McAfee, passei 2 anos fazendo uh, segurança embarcada e antes disso eu era Desenvolvedor C++. Então eu

[1:03] não, não venho de um, de um background de software na verdade. Então você pode se perguntar, por que você deveria se importar com um, hacking de hardware em primeiro lugar? Certo? Um, consigo ver dois motivos principais uh, primeiro é que é realmente divertido e empoderador poder um, você sabe, quebrar, abrir um dispositivo que você gostaria de ter em casa no trabalho onde quer que seja. E em vez de considerar que é uma caixa preta, você pode, em vez disso, sabe, começar a mexer nele e entender como funciona. E então de uma forma mais pragmática um, se, se considerarmos a segurança nos últimos dois anos uh, o software está se tornando cada vez mais difícil de quebrar. Como se você tentar uh, eu sei, pwn tipo uh, qualquer tipo de um, dispositivo de mídia como um servidor web, encontrar, encontrar uma vulnerabilidade no servidor web por si só é meio difícil. Com, se em vez disso você puder simplesmente abrir o dispositivo, soldar alguns fios e obter um shell a partir disso, isso é muito mais fácil. Então hacking de hardware é ótimo, porque também tem muitos uh, frutos baixos basicamente. Então uh, hoje, vamos falar sobre uh, telefones Avaya um, e especialmente o 9. A foto do telefone no lado direito do slide é um modelo 9611g. Uh, então a Avaya é tipo uma das maiores uh, VoIP

[2:08] um, provedor de soluções que você pode encontrar em todo lugar. Uh, o Google é tipo 90% da Fortune 100 e acho que esse modelo específico de telefone começou em 2006, e vai ter vida útil suficiente tipo no final do ano ou algo assim. E o engraçado um, no canto inferior direito dos meus slides tem essa engraçada tipo um, capturas de tela de tipo uma página de tipo um firmware de software muito antigo para esses telefones. Onde um, na verdade tipo, você pode ver que um, você só pode baixar esse firmware específico, se você for tipo um cliente do DOD então um, basicamente então, uh, veja que esses telefones vão para muitos lugares diferentes. Então uh, estamos obtendo arte prévia. Uh, em hacking de hardware, é tipo muita informação hoje em dia na internet, tipo você, você pode encontrar muitos posts de blog, tutoriais um, sempre tem tipo a Hardware Hacking Village que vocês todos vão, vão conferir. Uh, CTF também onde você pode tipo praticar, uh, tipo o lado mais soft das coisas e um, nos meus slides, eu tipo um monte de links no final uh, então você pode tipo baixar os slides depois e um, também os slides uh, eu tipo, o que eu enviei eu tipo, mais texto neles. Então é tipo

[3:11] mais tipo autônomo. Então você pode ler mais um, e sim, eu li isso em segurança uh, eu encontrei tipo 2 RCs no mesmo uh, telefone uh, algo tipo cinco anos atrás ou algo assim, um, e eles tipo falam na RSA chamado Stepping P3wns eu também recomendaria conferir online. Então uh, pelos próximos 40 minutos um, então vou falar sobre um, hacking de hardware e usar esse telefone como base para tipo apoiar essa conversa. Um, E basicamente a ideia de toda a situação é um, uh, tipo alguns de tipo, 12 anos atrás, talvez uh, via Fox e códigos de código aberto, e um, eles nunca aplicaram patches de segurança nisso. E um, acontece que tipo eu, mexendo no dispositivo, descobri isso e foi tipo, mulheres tipo despercebido por tipo 10 anos como eles estavam tipo na verdade tipo um CV que foi lançado tipo, sim 10 anos atrás para Defcon. Então vou falar sobre uh, como eu descobri que tipo aquilo era tipo algum tipo de estupidez tipo você sabe Deus dentro daquele firmware. Mas mais interessante, eu acho, é uh, falar sobre todo o processo, você sabe, tipo, como eu fiz isso, um, e por que eu fiz o que fiz Por quê? Oops, desculpe.

[4:15] Por que eu fiz as coisas que fiz quando fiz um, você sabe tipo, mágica tipo compartilhar um, o processo para que. E você sabe, também tipo compartilhar uh, sabe, e se as coisas que eu tentei não funcionaram ou, ou seleção de coisas que não funcionaram, porque, você sabe o quê, o que funciona para um dispositivo pode não funcionar para outro. E ter apenas tipo esse modelo mental do que podemos fazer e do que você não pode uh, ajuda muito ao abordar qualquer tipo de dispositivo. E é isso, eu realmente acho que é o que quero que as pessoas tirem dessa palestra é mais tipo um, aprender o processo de que você pode conferir tipo qualquer dispositivo que você tenha. E sim, queremos tipo insistir que um, se eu posso fazer isso, acho que todos nesta sala podem fazer também. Como eu disse, sou mais de tipo background de software, e o hacking de hardware ainda é tipo, você sabe, tipo um, um pouco assustador, um pouco estranho para mim, mas no final, realmente não é tão difícil se você tiver tipo um bom processo e você sabe, eu trabalhar com paciência. Então uh, como todo o projeto começou uh. Um, uh, para ser honesto, eu estava tipo, você sabe, trabalhando no trabalho, e havia tipo todas essas baias, na, em cada mesa, eu vejo esse tipo de telefone tipo parado na, na mesa. Eu tipo, espera um minuto, esses telefones estão rodando Linux, eles têm você sabe, acesso à rede, eles têm tipo

[5:17] microfones e coisas tipo, como, quão seguro é isso? Você sabe, tipo, eu sei, você, você se pergunta tipo, o que há com isso, as pessoas consideraram a segurança disso? Então um, o primeiro passo antes de você saber mesmo tipo, eu ainda tipo roubando o telefone do meu colega e desmontando, você pode tipo, e isso geralmente [inaudível], você pode conferir os sites da FCC geralmente tipo qualquer dispositivo que tenha Wi Fi ou Bluetooth, tem que estar um, no site da FCC por uma razão de conformidade. Então, foi isso que encontrei. Um, Esse não é meu telefone. Esse é tipo um, também modelo das mesmas marcas, basicamente e tipo bem próximo. Então você vê todas essas fotos legais. Mas mais interessante é o, o interior do telefone. Uh, então podemos então vê-lo e no lado esquerdo em vermelho, em vermelho um, eu destaquei esse tipo de conector de depuração aleatório, não sei o que é, mas é interessante ver que está lá. E no lado direito um, tem tipo aquilo, tipo um, em roxo tem aquela memória flash. Então é aí que geralmente o sistema de arquivos do telefone vai ser armazenado. E o ponto principal disso é apenas ter uma ideia do que esperar, você sabe, antes mesmo de abordar um alvo real, tipo construir hardware e tal. Então um, você, você sabe, tipo se vai ser um alvo fácil ou difícil

[6:23] hã, você sabe, se tudo estivesse coberto com epóxi preto, isso seria mais difícil. Então outro passo importante é tipo descobrir, hã, obter tipo hã, material online, tipo hã, você sabe, hã, folheto de marketing, para você ter uma ideia do que o telefone, quais são as capacidades do telefone no ecossistema ao redor dele, para que você tenha uma ideia da hã, você sabe, tipo da superfície de ataque. E você também pode encontrar tipo manuais de usuário e tal. E por exemplo, eu encontrei um que era bem legal. É tipo um manual de usuário, tipo um manual de usuário avançado que diz, ah, se você quiser uma conexão serial com o telefone, você precisa daquela caixa esquisita. E hã, sim, o que é interessante, ele ensina, ele nos diz que sim, você pode encontrar, é conexão serial e você pode ter tido algum hardware especial para isso, mas, vamos ver isso daqui a pouco. E hã, depois disso, você também quer verificar tipo formulários e hã, para que você possa descobrir o que usuários ruins estão fazendo, tipo por exemplo, eu encontrei tipo as senhas padrão do telefone na interface de depuração, porque hã, e administrador do sistema. Então aqui, hã, falando hã, falando sobre isso online. E hã, se você tiver sorte, você também pode baixar se você tiver mais uma ideia do hã, do que está lá em cima. E aí nós vamos

[7:23] cobrir isso em um minuto. Ok, então hã, o que fazemos agora, hã, agora temos uma ideia de tipo, como pode ser por dentro. Esta é uma palestra de hacking de hardware. Então vamos fornecer voluntários e o ponto é tipo você abrir o telefone primeiro. Hã, e o truque é tipo, geralmente você sempre espera encontrar as mesmas coisas por dentro. E hã, se você olhar os rótulos dos componentes, você vai ver hã, você, e você pesquisa no Google isso hã, você vai descobrir tipo o que é. Então por exemplo esse é meu telefone, e hã, você pode ver o centro da CPU a, acima dele tipo a RAM, numa cor tipo lavanda, tipo algum conector não populado que eu marquei com um ponto de interrogação. Isso, eu acho que do mesmo jeito, tem os que a gente estava tipo vendo na imagem antes e eu, pode ser JTag, eu não precisei usar. Então eu não sei na verdade. Hã, no próprio, temos tipo as Eeproms que é hã, com o todo tipo algumas configurações e tal. Hã, em azul escuro na parte de baixo do hã, do slide é tipo um RJ45 com chave. Então eu estava meio, meio confuso quando olhei para aquilo. E eu nem sabia o termo para isso. E a ideia é só um RJ45 normal, hã, tipo plugue de internet, mas com um hã, conector estranho para que você não possa plugar as, as coisas erradas nele. Hã, e hã, mais interessante

[8:26] em amarelo hã, as UARTs. Então é UART é tipo o console serial e hã, temos tipo esses especialistas tipo hã, pads. E então geralmente tipo em manufatura ou algo assim você teria tipo pinos pogo que tipo geralmente se conectariam aos pads. E esse hã, esse é na verdade muito interessante, porque você encontraria tipo console serial, você esperaria encontrar o console serial nisso. E na parte de trás, podemos ver a flash NAND que vimos na imagem anterior. E hã, sim, a partir disso é tipo onde o sistema de arquivos estaria, tipo armazenado no, no dispositivo. Então ok, você tem hã, você, olhamos as coisas por dentro e a, a tipo, outra coisa interessante de se olhar são pontos de teste e cabeçalhos de depuração. Então, e tipo basicamente todo esse tipo de coisa nesses componentes. E você pode perguntar, por que você esperaria encontrá-los por dentro? E algumas razões tipo uma é tipo, geralmente tipo a placa de desenvolvimento que, que os caras vão usar é a mesma que a placa de produção. E talvez eles não, só não vão remover os outros componentes de depuração. É o mesmo que se você tipo software, e ele foi compilado com tipo símbolos de depuração, por exemplo. E hã, também tipo parte do processo de manufatura hã, você, esses pontos de teste e tal podem ser usados para tipo gravar

[9:30] o dispositivo, ou garantir que ele foi gravado corretamente. E às vezes, você sabe, tipo algo morreu hã, no, no, no mundo real. E eles querem tipo fazer uma autópsia para entender o que aconteceu. E isso é útil também. Então que tipo de coisa você quer procurar nessa situação? Você quer olhar UART que a gente tipo olhou antes. JTag que eu vou, hã, cobrir tipo em um minuto. E aí, tipo você também pode ter tipo ponto de teste aleatório que estão relaxando ali, que tipo por toda parte, hã, por toda a mesa, por toda a placa. E pode haver tipo pontos de teste longos, er, tipo rótulo, tipo TP1, TP2, sei lá. E às vezes isso, isso pode ser tipo não interessante para você, mas às vezes, você pode encontrar coisas interessantes tipo, hã, você pode descobrir que tipo, ah, se você der um curto tipo TP64, hã, com o terra vai resetar o dispositivo, o que pode ser realmente útil em certa medida. Então hã, olhando UART, hã, então como eu disse, é para tipo conexão serial. E vem em tipo 3 ou 4 pinos. Os 3 pinos serão hã, terra hã, transmissão e recepção. E o quarto pino seria tipo DCC, então 3 volts, 5 volts sei lá. E geralmente você não se importa com esse, você nem quer plugar, você não precisa. E pode hã, sim, e hã, o, o truque para saber é hã, o serial

[10:36] console hã, alguns dados em velocidade diferente. E há apenas tipo alguns deles, chamados tipo Baudrates. E havia apenas tipo alguns hã, valores comuns de baud rate, então se você tentar plugar seu, seu sistema no, na UART, e você só vê lixo na tela, o, provavelmente o motivo é, você só está com o baud rate errado e você poderia tipo tentar percorrer tipo todos os possíveis, possíveis e encontraria algo eventualmente eu acho. Hã, JTag é outro que é hã, interessante hã. Então isso é para tipo depuração de hardware e maneiras que você poderia, tipo, você sabe hã, depurar a CPU geralmente, e executar tipo instrução por instrução e tal. E ele, eles vêm em muitos formatos diferentes hã, números de pinos e tal. Então alguns exemplos tipo na parte de baixo dos slides hã, mas na verdade só alguns fios são interessantes e hã, no final dos slides eu tenho tipo um link para um artigo sobre tipo entender melhor o JTag. Mas basicamente, tipo, se você olhar no canto superior direito hã, dos meus slides, tem tipo uma placa de desenvolvimento e digamos tipo um conector JTag legal hã, plugado ali. E por outro lado, tipo no canto inferior direito, é tipo algum hã, dispositivo aleatório que eu

[11:38] estava olhando, que você pode ver, deveria haver um JTag, mas nunca foi soldado e então eu tive que soldar diretamente nessa coisa. E o truque para lembrar aqui, se você tipo soldar seu próprio conector, é hã, você na verdade pode ter que adicionar tipo resistores extras chamados tipo resistores pull up e pull down que conectam tipo um pino ao terra ou um pino tipo ao VCC. E o objetivo disso é, na verdade, eu não sei o objetivo disso, mas hã, a razão é que se você não tiver eles, pode não funcionar bem ou é mais trabalho na maioria das vezes, vai ficar instável. Então hã, e se você seguir as instruções de tipo, por exemplo tipo uma especificação arm, de tipo qual resistor você precisa, então, você pode pular eles, mas aí você pode perder tempo tipo entendendo por que é um estranho, tipo estranhamente fodido às vezes. Então eu recomendaria os resistores pull up e pull down. Então essa é só uma placa aleatória que meu colega de trabalho estava olhando hã, só para mostrar que o que eu disse é na verdade bastante genérico. Hã, no lado esquerdo, temos tipo UART. No lado direito tem tipo alguns conectores JTag. Hã, lá em cima está o mmm, o primário ali é tipo, a CPU principal, sei lá o que está sob tipo um escudo. E geralmente você, você faz isso para hã, prevenir hã, interferências. Então

[12:43] é tipo um módulo Wi Fi, então é por isso. E a coisa boa de saber é que geralmente o escudo é aterrado. Então tipo, se você está procurando o terra na sua coisa, você tipo, ou o escudo nesse tipo de coisa, ou tipo a carcaça ao redor da porta Ethernet ou sei lá também é, na verdade tipo bastante útil. Então hã, agora que aprendemos como hã, olhar dentro das coisas, precisamos saber qual hardware você precisa para hã, interfacear com o que está dentro. Então eu vou apresentar tipo um monte de hã, ferramentas de hacking legais que são importantes. Então a primeira hã, você pode querer esse pino ou tipo os adesivos, eu não sei se você está familiarizado com isso hã, na verdade, tipo, o que é realmente importante é tipo, segurança. Hã, então você sabe, não trabalhe com coisas que estão plugadas na parede. Hã, lembre-se de despluggar as coisas trabalhando tipo em sala bem ventilada, é importante. E hã, sim, só não seja estúpido quando você está tipo hã, mexendo com hardware hã, mas sim. Então próximo hã, foto do laboratório hã, eu estou segurando um hã, ferro de solda. Você geralmente pode trocar a ponta por tipo uma ponta bem grande para tipo solda grande e umas pequenas para solda pequena. Eu tenho um microscópio, então isso é realmente útil para fazer hã, solda minúscula. E o truque é eu, eu costumo beber muito café e eu tremo, então

[13:47] eu vou, eu iria, eu estava pensando tipo eu não conseguiria fazer isso, mas na verdade, se você hã, se você for cuidadoso e o, o truque é tipo realmente tentar hã, você sabe, quando você solda, tipo tentar manter seu braço tipo reto e bem apoiado. E sob o microscópio, você pode na verdade fazer um monte de coisas que é, você simplesmente não pensa, você não conseguiria usar, você pensaria que não deveria ser capaz de fazer, mas você na verdade, na verdade consegue. [Expira], desculpe, hã. Canto superior direito hã, é mais na verdade usado para a solda minúscula e o hã, meio superior direito é tipo fluxo, então é tipo hã, cola mágica, mágica hã, substância grudent, é uma substância que você coloca nos hã, pinos para hã, quando você começa a fazer montagem superficial ou pads para que funcione muito bem. Então não, nunca esqueça o fluxo. Hã, embaixo está hã, sa, tipo, no mesmo hã, tamanho, tipo hã, fios de cobre, tipo um fio de metal que você usa, geralmente para fazer códigos, você sabe, tipo para rádio ou sei lá. Hã, e o truque é que o, o fio é na verdade hã, revestido com hã, verniz para não dar curto. E você pode usá-lo para fazer tipo solda ponto a ponto realmente minúscula, e isso é na verdade muito útil. E logo ao lado, você tem tipo um pouco de

[14:48] malha de dessoldagem. Então tipo, a ideia é, se você colocar solda demais e você ferrar tudo hã, você pode colocar a malha em cima do bloco de solda que você bagunçou e você hã, coloca o ferro de solda em cima disso, vai ficar muito quente, então você quer segurar através tipo da carcaça plástica e vai absorver toda a solda extra. E você pode limpar suas coisas. Aí eu coloquei uma foto de tipo alguns fios jumper aleatórios que são, são, ou geralmente, sempre úteis de se ter. E no canto inferior direito, eu tenho tipo aquela pistola de calor maluca. Hã, é tipo 60 dólares no Home Depot. É destinada a tipo, ajudar a tinta a secar ou algo assim, não tenho certeza, mas é na verdade muito útil se você estiver no chip, se você quiser remover componente só tipo aquecendo eles e puxando eles para fora. Então hã, mais hardware legal hã, que é um multímetro. Hã, se você não está familiarizado com isso, é fácil para, encontrar a voltagem do chip que você não conhece, tipo qual é a voltagem real, então o preto vai para o terra e o, com o vermelho você hã, com o branco provavelmente seleciona cutucando para hã, medir a voltagem. E havia uma coisa muito legal é que você pode configurar no modo de continuidade e quando você tem tipo conexão entre as duas pontas de prova, ele apita. Então se você fizer

[15:51] tipo um trabalho de solda porcaria, como eu estava descrevendo pouco antes, você pode garantir que realmente fez um trabalho adequado, onde tipo tudo está conectado do jeito que você pensa, sabe, garantindo que ambos os lados, quando você provavelmente, os dois lados realmente apitem. E isso é uma ferramenta bem útil, na verdade. A outra é, isto é um Analisador Lógico. O nome é tipo um Sally, hã, isso é uma marca. E a ideia é a mesma que no software, você tem tipo formas de comunicação entre processos, tipo no hardware, você tem tipo formas de comunicação entre chips ou a CPU e o chip. E é, hã, é tipo um monte de padrões diferentes, formas diferentes de fazer as coisas. Mas o analisador lógico tipo conhece muitos deles e vai converter tipo um monte de sinais que estão passando nos fios em dados reais. E isso é realmente muito útil. Esse seria os seus olhos, tipo quando você está fazendo, hã, depuração, sabe.

[16:32] E isso é tipo a sua captura de tipo alguma comunicação SPI, hã, que espiona com algum protocolo aleatório. Hã, isso é tipo um cabo FTDI, também vem em muitos, hã, cabo serial, vem em muitos formatos diferentes e tal. E a ideia é tipo, quando você quer fazer tipo UART, você, você pluga isso no seu notebook, e você conecta o lado do usuário tipo na porta UART e você tem tipo um console, ele aparece como uma porta serial. E, hã, como exemplo eu tenho, hã, no canto inferior direito, hã, tipo um raspberry pi que, você consegue na verdade acessar o console serial e você não precisa tipo de cabo HDMI nem nada para interagir com ele. Uhu. Hã, o Bus Pirate, hã, também é tipo um dispositivo legal, hã, ele faz, hã, Ele, é, é meio que dependente do hardware hacking, hã, desculpa, com o, hã, o analisador lógico Sally, então em vez de absorver dados, ele tipo envia dados, então ele fala um monte de protocolos diferentes e você pode usar Python para programá-lo. Então é extremamente útil se você quer tipo ler flash, programar, hã, microcontroladores e esse tipo de coisa. Hã, mais coisas legais que eu cobri. Eu estava falando sobre JTag, esse é o depurador JTag que você, é aí que você plugaria na verdade tipo a porta Digitech. Eles

[17:38] vêm em muitas faixas de preço diferentes e tal. Então no canto inferior direito está um fly swatter, é tipo, provavelmente tipo 30 dólares, eu acho. E funciona bem, e acima dele é tipo um J Link, que é mais chique. E a ideia é tipo, quanto mais caro o negócio, mais, provavelmente mais confiável ele é. E vem com tipo software melhor e tal. E no canto inferior direito, os corpos rosa são o JTagulator, que o Joe Grand, o mesmo cara que fez aqueles crachás, hã, fez. E é realmente incrível. Então, se você tem tipo aquela placa, você não sabe o que é até tipo um monte de pontos de teste e você tipo, aposto que tem algum JTag em algum lugar nela, mas você não sabe onde. Você pode simplesmente ligar tipo todos os pontos de teste ao JTagulator e ele vai fazer força bruta tipo e tentar encontrar tudo. Então é muito legal. Hã, essas são ferramentas interessantes, importantes, são os, hã, leitores de Flash. Então geralmente o conteúdo da Flash, a Flash como o sistema de arquivos e tal. E, hã, então você quer tipo interagir com isso. E, hã, vem em dois sabores, eu acho, você pode fazer tipo coisas em circuito. Então você tem tipo ou tipo o seu pequeno tipo grampo que você coloca no chip ou um pequeno retangular, hã, para encaixar. Hã, então tipo o Raspberry Pi é bom para isso. E no

[18:42] canto superior direito, é tipo um flash cat, hã, é tipo útil para o retangular. Hã, mas você também pode tipo, escolher tipo, na verdade dessoldar o chip e, nesse caso, você teria tipo algum adaptador de soquete. Então você pode encaixar o chip e então você pluga no seu Flash cat e tal, e ele vai ler. E isso, eu vou cobrir tipo por que, o quê, meu, o quê, por que isso é importante tipo ambos em um minuto. E finalmente, é meio que a, hã, última, hã, esperança. Então digamos, hã, você sabe que sua Flash está criptografada, não há UART, não há firmware. Então você pode tentar fazer tipo as coisas mais malucas como, injeção de falhas e tal ataque. Então esse é o chips whispers, tipo mais tipo um dispositivo difícil, mais badass. E a ideia com isso é, hã, ele, você pode fazer coisas tipo, hã, você o liga, hã, à CPU e você vai derrubar a energia na CPU por tipo uma fração de segundo e ele vai tipo bagunçar alguma instrução e você pode contornar verificações e tal. Isso é pro, o que as pessoas usam para tipo hacking de consoles de videogame e, e, hã, esse tipo de coisa. Então, hã, o que fazemos agora, hã, que temos uma ideia do que tem dentro do celular e, hã, você sabe, hã, as ferramentas que podemos usar. Então tipo, eu acho que são três

[19:47] caminhos potenciais, um é mexer com a UART, então o console serial, e este é, hã, mexer com a flash e tentar recuperar o firmware ou algo assim e então talvez você possa simplesmente baixar o firmware online. E os três são tipo abordagens válidas e às vezes é bom simplesmente ir de uma para outra para outra e você sabe, o que quer que você encontre tipo algum hardware você pode tipo ir de uma para outra. Hã, então eu fui para a UART primeiro e é isso que me recebe quando eu conecto meu cabo FTDI nas portas UART que eu, eu estava fazendo antes. Então, hã, podemos ver que no lado esquerdo, o, o, hã, o negócio do console, é tipo ponto ponto ponto, geralmente quando você vê isso, você pode pressionar espaço ou escape e ele vai interromper o processo de boot do celular. E nessa situação, hã, mas de alguma forma aqui não funcionou. E eu, eu vou cobrir por que em um minuto. E no lado superior direito do slide, hã, podemos ver tipo ele leu algo da EEPROM e então decidiu definir o console para Dev null. Então você não quer que o console seja Dev null porque se isso não vai a lugar nenhum. Mas é interessante saber que, hã, há algum potencial ali. E finalmente, é tipo inicializando em seguida, então ele con, confirma para nós que é uma porta uniques, mas então, hã,

[20:48] não há mais nada, hã, depois disso. Então há algumas coisas boas, coisas ruins. Os problemas são tipo nada aparece depois que o Linux está, como fizemos, provavelmente por causa da situação do Dev null. E quando eu pressiono teclas estão falando e, hã, eu vou tipo aparecer com tipo, por que isso aconteceu. Então naquele ponto, eu ainda estava tipo, ok, eu, eu não posso ir a lugar nenhum. Então eu vou tentar recuperar o firmware para tentar entender o que está acontecendo com isso. Hã, várias formas de recuperar firmwares, hã, é tipo uma forma fácil, tipo você pode fazer online. E na verdade isso funcionou, hã, há tipo uma captura rápida disso, hã, às vezes é criptografado. No nosso caso, não era. Hã, mas, é. Então você também pode tentar farejar uma atualização de firmware, hã, isso é realmente útil para dispositivos IoT em geral. E você pode usar uma aba de rede, que é tipo a coisa mostrada no canto superior direito do slide. Hã, ou você pode espelhar sua porta no seu switch ou algo assim. Hã, o problema com tudo isso é que muitas vezes uma atualização de firmware vai ser feita tipo via, h, HTPS, ou pode ser, neste caso, você está tipo preso. E então você quer ir para tipo algo mais tipo, hã, hardware hacking ou tipo você vai despejar uma flash, por exemplo. E tipo

[21:48] técnicas ainda mais avançadas que eu vou brevemente tipo, hã, falar sobre. Então como você despeja uma flash? Há duas formas, como eu estava mencionando, pouco antes, você pode fazer programação em circuito e, hã, fora do circuito. Então em circuito é legal, porque você não precisa, sabe, tipo remover coisas, quebrar coisas. Mas alguns problemas são que, hã, a ideia principal é ler a flash, você precisa alimentar a flash. E se você, se ela ainda está tipo plugada no sistema inteiro. Hã, ele, quando você está tipo com o Raspberry Pi, por exemplo, vai tentar ler a flash, ele vai tentar, tentar alimentar tipo tudo o mais que está conectado na mesma tipo linha de energia. E ou você sabe, o USB Pi não é forte o suficiente para alimentar tipo um telefone VoIP, o que você esperaria. E nesse caso, hã, mas simplesmente não vai funcionar. Ou talvez seu Raspberry Pi seja realmente forte e vai conseguir, mas então o problema é que a CPU começa a inicializar e vai conversar com a flash e isso vai bagunçar suas coisas. Então nessa situação, você tem tipo duas escolhas geralmente, ou você pode tentar tipo levantar o pino, os pinos de bola, para que isso não aconteça. Ou você pode meio que ir com uma abordagem um pouco mais tipo heroica onde você quer manter a CPU em reset. Então eu tive sucesso com isso muitas vezes

[22:51] ou eu simplesmente tipo começo tipo tentando aterrar tipo pontos de teste aleatórios, de coisas nas placas, rezando para que não vá encontrar nada. E geralmente em, em algum momento tipo, eu vou notar que ok, quando eu faço isso o celular tipo acende, não inicializa, isso é bom. E talvez melhores formas você pode dessoldar o chip com tipo uma pistola de calor ou algo assim. Você tem que ter cuidado, porém, porque se você tipo puxar com muita força, você pode tipo entortar pinos e vai ficar tipo inútil. Hã, um bom truque para saber é que você pode fazer um pequeno tipo, hã, chapéu de alumínio ou algo assim, tipo no chip, para que tipo quando você estiver aquecendo o chip, tipo as coisas ao redor, não fiquem quentes demais. Er, para que você não acidentalmente tipo derrube tipo alguns tipo componentes minúsculos, que seriam tipo um pé no saco para, hã, recolocar. E, hã, no canto inferior direito é tipo eu estava, eu estava, eu pensei que teria que fazer isso no celular. Então eu queria praticar primeiro e então simplesmente peguei tipo um pen drive USB aleatório e tentei. E na verdade, isso funcionou muito bem, legal. Mas o truque é lembrar, eu também coloquei um pouco de fluxo porque ajuda. E, hã, é, só não, tenha cuidado com, quando você tirar. Alguns outros truques que na verdade não funcionaram neste aqui. Mas eu, bom saber. Hã, U-Boot é o bootloader mais comum, hã, não usado aqui, mas é, você encontraria

[23:56] isso em praticamente qualquer outro dispositivo. E a ideia é que você também pode instruir um processo de boot disso e pedir gentilmente, tipo, ei, você pode carregar a flash na memória, e então, hã, o U-Boot também é capaz de despejar em um Hex tipo na tela, hã. A, a memória, é assim, você pode simplesmente obter, escrever no script para fazer isso e recuperar tudo da flash, o que é realmente legal. Mas geralmente tipo os Dev não gostam de deixar você fazer isso. Eles disseram que bloqueiam essa abordagem, então, então você não pode tipo pressionar espaço para interromper o processo de boot. Mas há um truque que eu também chamo tipo de abordagem Yolo onde, em vez disso, quando. A ideia é tipo o U-Boot vai carregar da flash tipo o, o novo scanner ou algo assim. Mas se enquanto isso está acontecendo, você começar tipo a cutucar com, sabe, tipo um fio conectado ao terra e eles começaram a cutucar a flash NAND, tipo alguns dos pinos, vai bagunçar tipo o que o, o u-boot está lendo e depois de algumas tentativas, o u-boot vai ficar tipo, nossa, esse kernel está fodido, eu não sei o que fazer e vai te dar tipo um shell. Então isso é realmente legal. Mas é, como eu disse, esse não funcionou no nosso celular, infelizmente. Mas, hã, só alguns exemplos legais que eu encontrei online foi tipo um cara que na verdade fez isso. E, hã, eu sublinhei em

[24:59] hã, no tipo roxo, na, na parte de baixo, tipo o comando que você precisa usar para tipo registrar o, o, o flash na memória. E no lado direito, o bloco secundário de texto é hã, desculpa, é, como hã, você vai simplesmente entrar em pânico e ficar tipo, é, eu não sei o que fazer com o seu kernel e te dar o, o shell. Então hã, como hã, então mais algumas tipo truques para hã, dum, despejar o flash, então você pode usar JTag. Então geralmente você tem hã, se, se o JTag funcionar, você vai conseguir hã, despejar a RAM. Então nesse caso, isso não vai ser realmente tipo despejar o flash, vai envolver despejar o firmware, mas, em muitos dispositivos vai carregar a coisa toda nas memórias, então se você conseguir despejar a memória você está, vo, você, o mesmo meio que você está bem encaminhado aí. E meio que a última esperança com isso. Essa é uma das minhas favoritas sobre hacking de hardware é, você pode fazer coisas hã, malucas hã, e um exemplo é uma Scanlime hã, aquela pessoa na internet que hã, ela tinha um hã, um tablet Wacom do qual ela queria despejar o hã, o firmware e não havia tipo nenhuma superfície de ataque, até que ela percebeu que tipo quando você [inaudível] coisas de USB, e quando você pluga seu USB hã, nos laptops, há alguma troca de USB que eu

[26:01] não sei nada sobre, mas soa como descritor de USB. E se você, se você glitchar a CPU exatamente naquele momento, hã, vai tipo, sabe, perder tipo uma checagem binária e vai enviar muito mais dados. E com isso hã, ela conseguiu recuperar tipo o flash completo, a memória completa ou algo assim. Então é realmente impressionante, mas, e isso é o que é meio que incrível sobre hacking de hardware. Ok, então hã, nós recuperamos o firmware hã, no meu caso, só baixando online, mas, o que fazemos agora? Queremos analisá-lo. Hã, a melhor ferramenta para isso se chama Binwalk. E é basicamente um dicionário mágico que vai tipo olhar para o seu blob binário de coisas e ficar tipo, mmm, na metade dele parece que há um arquivo zip, vou tentar extraí-lo. Ele tenta, talvez funcione, talvez não dependendo se era realmente um arquivo zip ou não. E ele faz isso para tudo. E hã, ele também pode encontrar tipo sistemas de arquivos comprimidos como Squashfs, JFFS2 etc. E às vezes tipo o seu hã, seu arquivo de firmware pode simplesmente começar com tipo cabeçalhos Elf ou tipo código ARM aleatório que você poderia tipo, olhar. Então eu não tenho trabalhado nisso. Então esse é o arquivo de firmware, eu não sei ele do site.

[27:01] E mais uma vez, é modo fácil, é só um arquivo doc. E eles já tipo dividiram em boot 1, boot 2 e JFFS2. Então tipo, o Binwalk não tem nada a fazer aqui, realmente, e eu posso simplesmente extrair todo o sistema de arquivos. E isso é legal, porque a partir daí, eu posso olhar o que está no celular, assim desse jeito. Hã, mas o caso de uso mais interessante para o Binwalk é, eu peguei tipo um arquivo de firmware diferente para tipo, um celular [inaudível]. E esse aqui é bem mais interessante, porque o Binwalk encontrou tipo muito, muito mais coisas. E hã, eu destaquei, tipo você encontra o sistema de arquivos e consegue extraí-lo. E há também aquelas coisas aleatórias tipo de my SQL, que eu acho que é um falso positivo, então você precisa estar ciente de que haverá muitos falsos positivos, então não confie cegamente no que o Binwalk diz. E hã, uma coisa muito, muito engraçada que eu estava olhando hã, se você rodar strings naquela imagem específica hã, você vai encontrar strings de U-Boot. Então, aquele divertido está usando U-Boot e as coisas legais que eu estava descrevendo antes, na verdade funcionariam naquele, olha. Então agora que você extraiu o arquivo de firmware, o que você quer procurar? Uma das coisas mais hã, interessantes é hã, encontrar o vo, mecanismo de atualização. Então assumindo que você tem hã, firmware criptografado,

[28:04] tipo se você fizer engenharia reversa disso você pode encontrar as chaves e como extr, extrair tipo atualizações de firmware hã, subsequentes sem ter que fazer tipo, nenhuma coisa de hardware. E aí você quer procurar tipo segredos, como hã, senhas, certificados e assim por diante. Hã, originalmente, meu objetivo era olhar os binários principais. Então essa é só a coisa e lidar com tipo a pilha de VoIP. Hã, isso poderia fazer sentido olhar isso. E hã, também você quer olhar o bootloader porque, ele pode ter comandos ocultos, explicar por que todo o console não está funcionando, esse tipo de coisa. Então, lembre-se, o ponto de tudo isso era, eu queria obter um shell no dispositivo e hã, qual é o processo para fazer isso? Então, o que eu quero seguir é, eu quero consertar o console serial, sabe tipo o Dev null não era legal. Hã, mas também a abordagem seria tipo mexer com seus argumentos de boot. Hã, não funcionando aqui, obviamente. Hã, mas você sabe, você pode especificar o console que você quer e o, uniscript pode ser marcado, ah eu quero Bin bash como meu uniscript e você tem um console. Hã, e tipo coisas de último recurso que eu estava considerando também é, você poderia aplicar patch no firmware. No nosso caso o firmware é assinado. Então hã, isso não vai funcionar a menos que você tente glitchar, o que é realmente difícil.

[29:08] Mas você também pode tentar aplicar patch em um sistema de arquivos. Então do jeito que o Binwalk extrai as coisas de JFFS2, você poderia modificá-lo e então tipo reempacotar e gravar direto no flash. E isso geralmente é um método preciso e à prova de falhas tipo, isso funcionaria na maioria dos casos. Então em vez disso, eu vou hã, fazer engenharia hã, reversa hã, do Bootloader. E hã, para isso, hã, porque eu queria entender tipo, por que Dev null, um con, o console estava definido como Dev null e tal. Eu vou só cobrir hã, em muito detalhe e eu recomendaria que você confira os Tutoriais da Azeria Labs que cobrem tudo, o que é só útil aqui hã. Há essa noção em ARM de pool literal.

[29:44] Que é hã, dentro da seção de código, você encontraria algum pequeno pedaço de dados e isso geralmente é tipo usado para ca, carregar registradores, hã, endereços absolutos, valores imediatos, offset mágico, esse tipo de coisa. E hã, a propósito, tipo em cha, no caso de chamadas de função hã, os argumentos vão para R0 até R3. O valor de retorno está em RVO. E quando você tipo, quer retornar do seu chamador, é, o, o endereço de retorno é salvo tipo no registrador LR, que significa tipo registrador de link. Hã, e o grande truque, grande problema aqui é hã, nós estamos tipo tentando carregar o bootloader. Então é hã, não é realmente Elf. Então se você tentasse importar no IDA, o IDA não sabe o que fazer com isso e então você precisa encontrar o endereço de carregamento para essas coisas, para que corresponda a o quê, onde o celular está carregando. Alguns truques hã, então nenhuma das suas chaves de carregamento vai ser impressa na tela, esse é o nosso caso, ótimo. Hã, mas caso contrário, você quer olhar tipo arquivos de cabeçalho, cabeçalhos no, no arquivo do bootloader ou talvez vetores recentes, esse tipo de coisa para tipo, especificamente para ARM, tipo a CPU precisa saber hã, endereços específicos onde tipo, uma recess ou uma intrep acontece e é tipo engraçado tipo, quadrado tipo,

[30:50] como isso está sendo configurado. Então se você encontrar isso e encontrar tipo o que parece ser um manipulador de vetor de intrep ou algo assim, você pode encontrar tipo, ah, esse deve ser o endereço. E hã, finalmente, o pool literal que eu estava mencionando hã, realmente útil com um porque vai conter tipo endereços absolutos ou apontar para strings e tal. Então hã, se, se tipo você tem strings, e elas parecem todas f**didas, você provavelmente tem o endereço errado. E hã, Quarkslab, hã, que blog arrasador, então eu recomendaria que você conferisse. Então como eu disse, no nosso caso, foi fácil. Hã, quando ele inicializa ele imprime hã, o salto, seja lá o que for. E isso na verdade é WIFI carregado.

[31:21] E hã, no lado inferior direito, é tipo um monte de hã, strings hã, então é um monte de endereços que apontam para strings. Hã, o snapshot do sistema do IDA e hã, podemos ver que hã, hã, são todas as strings tipo imprimem bem, então isso significa que está carregado corretamente. Não está tipo todo bagunçado. Ok, então agora que temos o bootloader e podemos tipo trabalhar com ele no IDA, hã, queremos procurar strings hã, que estávamos olhando, sabe, tipo aquela frase tipo EEPROM read successful, seja lá o que for. Então podemos usar tipo referência cruzada no IDA para encontrar de onde a string vem e olhar a função que lida com isso. E hã, sim, só a título de informação, mas tipo EEPROM e Spi, então a EEPROM que está na placa se chama Spiprom e Spi é só um desses protocolos que eu estava mencionando antes. EEPROM é só hã, tipo uma pequena memória, hã, seja lá o que for. E o protocolo spi é só tipo 4 fios hã, e o ID para CPU em comando e EEPROM tipo responde, e hã, e isso é um dump de tipo usar o analisador lógico para dar uma olhada em como seria na vida real. Hã, essa é a folha de dados da EEPROM

[32:22] que você pode encontrar online, se você pesquisar no Google o, o rótulo nela. Hã, a coisa legal é que no canto inferior esquerdo hã, do slide, ele te diz tipo, os pinouts, então você como conectar coisas nela. E no lado direito do slide hã, ele te diz quais, quais, upcodes são para comando Spi que enviaria. Tipo por exemplo, se você enviar hã, 3 vai ser read, read, se você enviar 2, vai ser write. Então isso é hã, isso é algo útil de saber, certo? Oops, desculpa. Voltando ao hã, voltando ao IDA e ao hã, bootloader, podemos ver hã, as strings que estávamos tipo procurando. E algo que para mim é promissor é, podemos ver o hã, console definido como Dev null, mas acima disso, que eu poderia bur, 2 da opção e na verdade está dizendo tipo, ah, definindo console como tipo UART 0 ou UART 1. Então queremos que esses sejam impressos.

[33:08] Hã, essa é uma, essa é uma função que na verdade imprime aquela string. E hã, o que ela faz é mais ou menos hã, limpar, limpar alguns bytes na pilha. E então você lê para mim de um endereço mágico. E vai comparar tipo bytes hã, que acabaram de ser lidos. Quando se temos o valor bom, vai na verdade imprimir no console definindo, o console para hã, Dev ttyAMA0. Então queremos que isso aconteça. Hã, e algo que você pode me perguntar é tipo, ah, como você encontrou aquela função read EEPROM, sabe? E aí há tipo mais algumas maneiras de fazer isso. Hã, o jeito fácil que eu destaquei em verde, naquela captura de tela, é hã, no canto inferior direito, você pode ver algum tipo de log que diz, ah, EEPROM read fails. Então eu sei que aquela função é responsável por ler a EEPROM. Hã, mas talvez, talvez as poucas mais que eu vou olhar não sejam hã, tão hã, variáveis. Nesse caso hã, como eu disse antes, tipo, para ler de uma EEPROM você sabe que tem que enviar 3 via SPI. Então, se você encontrar tipo a função SPI, e você ver tipo enviando 3, você sabe o que é. Isso seja lá o que for destacado em amarelo. Mas aí tipo, como você encontra uma função spi nesse tipo de hã, programa? Hã, 2 maneiras para isso.

[34:07] Hã, meu palpite mais uma vez, foi logado, então foi fácil. Mas geralmente tipo, o truque principal é hã, você tem esse hã, algo chamado hã, IO mapeado hã, IO mapeado em memória. É esse tipo de valores de endereço mágicos na CPU que tipo se você escrever neles, na verdade vai enviar dados via tipo seu auto spi ou seja lá o que for. Se você tiver sorte, você vai ter uma folha de dados para a CPU. E ela especifica exatamente quais são esses endereços. Se você não tiver sorte hã, você tem que adivinhar e isso é realmente difícil. E, na hora, talvez você devesse tipo procurar outra coisa, ou só sabe, você vai gastar muito tempo nisso. Então queremos hã, aplicar patch na EEPROM agora, para que possamos hã, construir o console. O plano de ação é, nós sabemos os comandos de leitura, escrita hã, queremos interagir com o flash. Então para fazer isso hã, hã desculpa, a EEPROM, nós, nós hã, precisávamos tipo de um dispositivo spi hã, e que já vimos antes o Bus Pirate é um candidato perfeito para isso. E precisamos conectar ao chip, hã, infelizmente,

[35:09] como se fosse realmente minúsculo e então tipo o clipe que eu estava mostrando como tipo grande demais para aquilo. Você pode comprar online alguns rigs que as pessoas fazem, hum, é tipo, caro, e leva tipo cinco semanas para recebê-los. Então, em vez disso, eu meio que fiquei louco e tentei soldar tipo hum, fios pequenos na coisa. E eu fiquei tipo, honestamente, isso nunca vai funcionar, mas acabou que realmente funcionou. E isso foi tipo, legal. E uh, é tudo tipo parece uma cruz porque é tipo todo o fluxo que permanece naquilo. Hum, e esse é o código para o Bus Pirate. É super tipo boilerplate uh, coisa. E quando você apenas escreve hum, esses valores mágicos que uh, desculpe, me pediram para tipo, substituí-los por tipo, imagens. Mas uh, a ideia é tipo, logo depois disso você é recebido com o console definido para uh, tipo seu R0, e agora temos muito mais coisas uh, impressas no console, o que é ótimo. Mas infelizmente eu, eu fico tipo assim mais difícil tipo, as entradas ainda tipo não estão funcionando, eu estava tipo tentando pressionar espaço ou digitar tipo, é como, pedindo oh, você quer olhar como root? O que é, eu digito, nada acontece, tipo ah, o que aconteceu? Será que eu apenas cortei a trilha, então você não pode enviar dados? Temos as placas, podemos olhar

[36:09] para isso, hum. Então uh, isso é tipo, tipo um zoom na coisa, e naquele momento, eu estava tipo, você sabe, olhando para o pad UART e começando tipo com meu milímetro, tipo tentando apitar, tipo onde vai, você sabe, seguindo o teste de continuidade. E eventualmente chegou a alguns fios, tipo no lado direito, e fios são aquele buraquinho que conecta um lado da bola ao outro. Então o truque é a trilha real que conecta UART a qualquer uh, vai para o outro lado da placa e vai oh, para frente e para trás. E é tipo realmente, tipo tedioso. E eventualmente eu meio que perdi onde estava indo.

[36:39] Mas estava tipo embaixo daquela porta MOD, uh, que é tipo o RJ45 com chave. Hum, e então hum, lembre-se tipo do lado de recon uh, parte de recon, hum, temos aquela caixa e é tipo ah, droga, isso é, isso é a coisa. Então eu meio que fui pela minha abordagem euro de novo onde, eu estava segurando tipo um, um plugue, tipo um cabo jumper no meu hum, o transmissor do meu cabo FTDI. E uh, então eu tinha tipo esse fio que eu podia cutucar por aí. E do outro lado, eu estava tipo pressionando teclas no console tentando ver se algo acontecia. E enquanto isso, eu estava cutucando tipo os pinos um por um. E acho que no segundo, realmente funcionou. E fui recebido por uh, tipo um shell root no dispositivo. Então isso foi legal hum. Mas o truque foi hum, o, no lado direito de tipo uma configuração adequada, onde eu conectei meu cabo ethernet no plugue. Então naquele momento, eu não queria saber onde estava a chave do RJ45. Então eu estava tipo lixando o plástico do cabo ethernet para poder tipo enfiá-lo, e sim, simplesmente funciona, então isso foi legal.

[37:36] Uh, agora que temos um shell root, é tipo uh, um monte de strings de debug impri, impressas na tela e isso é irritante. Então hum, o gatilho foi tipo, eu quero matar o processo, é tipo, sha, isso está tipo inundando meu console. Uh, há um watchdog que vai reiniciar o dispositivo se isso acontecer, então eu destaco no canto, tipo os comandos mágicos que você pode executar para matar isso. É tipo apenas um material aleatório e único. Uh, então agora podemos finalmente fazer alguma pesquisa de Vuln. Hum, e realmente o que você vai fazer é olhar os processos em execução, cutucar por aí, olhar as portas abertas. Uh, há apenas um monte de processos, uh, coisas de novo sequel, mas hum, é aí que tudo fica interessante. Acho que em algum momento eu estava cansado de olhar no IDA e fiquei tipo, vou cutucar mais. E olhei para o DHClient e tipo huh, e a parte realmente engraçada tipo, eu executo o DHClient e vejo esse tipo 2007 copyright. Eu fiquei tipo, uau, isso não é uma coisa boa. E se você apenas executar o DHClient sozinho, ele dá Segfault, tipo isso é estranho. E se você tipo, executá-lo da maneira certa, eles imprimem uma mensagem de debug que diz oh, nós o modificamos para funcionar melhor no nosso dispositivo. Eu fiquei tipo, huh, isso é interessante. Então, se nós

[38:36] olharmos para trás, e procurarmos a versão específica, acontece que, 10 anos atrás, na verdade, para a DEFCON uh, Jon Oberheide hum, realmente é tipo um exploit para aquela versão específica do DHClient, então eu fiquei tipo, bem, isso é, isso é fácil. Hum, mas queremos ter certeza de que ainda é vil, ainda vulnerável. Então o hum, o telefone estava tipo fazendo tipo hum, Stack Overflow, tipo ao lidar com opções DHCP. Então podemos comparar o código-fonte original com o código-fonte corrigido porque o DHClient é open source. E apenas tenha em mente, isso pode ser tipo mitigação, tipo stack cookies, ASLR e tal. Então, se olharmos para o código vulnerável no lado esquerdo, podemos ver um memcpy tipo destacado em vermelho. Isso está usando tipo data.len como um campo. Ou na versão corrigida que colocamos, que por 4. Então a ideia é tipo, este bug é uh subnet, uh, é um bug na máscara de sub-rede e link, e a máscara de sub-rede deveria ser tipo 4 bytes. Mas, a maneira como a opção HTP funciona, é que você pode enviar até tipo 255 bytes, eu acho, e costumava simplesmente confiar tolamente, o que quer que você esteja enviando, o que é ruim. E se olharmos no IDA tipo a função real, uh, podemos ver que não há canário de pilha e o vinner, o, o, no

[39:39] esquerdo, no lado direito, é, não está usando aquele mágico 4, então é, é obviamente tipo ainda vulnerável. Então é simples explorar essas coisas. Hum, trabalhando no TDS do sistema operacional do telefone, eu fiquei tipo, vou tentar configurar o QEMU hum, se você não está familiarizado com QEMU é tipo uma emulação de coisas ARM ou tipo mini de sistema e pode fazer tanto tipo Userland ou Full-System. Userland não funcionaria aqui porque uh, DHCP é hum, mais vai, tentar modificar um IP e tal e isso não é legal. Hum, mas em vez disso, podemos fazer, fazer uma emulação Full-System e uh, aqueles tutoriais te ensinam como tipo, configurar uma correspondência de consulta para isso. E nós só queremos configurar a rede adequadamente, uh, porque queremos interagir com o DHCP e naturalmente hum, a pilha do QEMU te daria um digi, DHCP para você mesmo, então você tem que ficar tipo não faça isso e, sim. Então eu executo no DH no QEMU e depois tipo [inaudível] falha e ainda dá Segfault e é tipo, huh. Então acontece que tipo, a Avaya modificou coisas que na verdade causam o Segfault. E hum, eu ia voltar rápido demais, porque estou ficando tipo sem tempo. Mas uh, basicamente está criando aquele socket estranho, uh, é tipo

[40:42] um socket de nome e uh, então essa é tipo a aplicação principal com a qual a pilha VOIP pode falar com o DHClient e mostrar opções. Hum, e uh, a ideia é tipo, essa é tipo a aplicação principal, então podemos ver o que ela faz. Isso não é, não é super interessante. Mas basicamente no lado esquerdo, é tipo enviar dados para configurar o DHClient na inicialização e no lado direito, eu reimplementei isso em Python. E uh, você pode executar isso com tipo Socat, hum, então, Socat é tipo, tipo Netcat em hum, em mais tipo hum, mais ferramentas, então você pode compartilhar aquele socket de nome e a ideia, você executa o script Python no host, você no socket no hum, binário QEMU, imagem, e isso simplesmente funciona. Então agora podemos começar a depurar uh, DHClients, hum, você pode executar o GDB, podemos tentar tipo, realmente executar o bug. Eu faço, eu não consegui compilar a prova de conceito original, era tipo usar ferramentas realmente antigas e é tipo depois de tipo, hella, tipo algumas horas tipo, ah foda-se, estou cansado. Então, em vez disso uh, eu uso um exploit baseado em Scapy uh. Scapy é uma biblioteca Python que permite tipo, você sabe, mexer com uh, pacotes de rede, tipo em um nível bem baixo. E hum, então agora queremos tipo alcançar a hum, parte vulnerável, código vulnerável, então hum, eu

[41:47] estava explicando o bug na uh, opção de máscara de sub-rede. E como, a maneira como o DHCP funciona é tipo um chá, tag length value tipo tipo de coisa. Então você diz, Oh, esta opção é uma uh, máscara de sub-rede, aqui está o comprimento, aqui está o valor. E obviamente seria tipo, seria 4, mas se você enviar mais, tudo bem. Mas para as especificações do DHCP. E então podemos usar Scapy para fazer isso. Então uh, esse é o meu, tipo um pedaço do meu script Scapy e apenas o payload adequadamente é interessante. Hum, basicamente apenas enviando a opção de máscara de sub-rede com uh, dados que serão tipo A, A, A, A, B, B, B, B, C, C, C, C e assim por diante. Então isso hum, quando travar no GDB uh, podemos ver tipo todos os registradores que controlamos, e sabemos hum, exatamente hum, você sabe, se quisermos af, afetar qual registrador, qual pedaço do shell code precisamos mudar.

[42:33] E podemos ver que na verdade estamos controlando uh, [“pc’s” então o console do programa, então isso é bom. Sabemos que temos hum, podemos explorar, temos controle, controle para execução. E há tipo mais alguns detalhes que vou pular. Mas hum, precisamos sta, criar um shell code agora. Uh, infelizmente, tipo, parece que a pilha é uh, você não pode executar a pilha, então teremos que trabalhar nisso. E isso é tedioso. Mas hum, coisa legal é tipo se você procurar há tipo uma chamada de sistema, aquele binário que eu acho que também, a Avaya adicionou. E nós controlamos R4. Então se colocarmos nós, se pudermos colocar uma string na memória em um endereço que conhecemos, isso poderia ser um valor tipo, comentário do sistema, e colocar o endereço em R4, estamos bem. Hum, então se você pensar bem, cliente DHCP, DHClient, desculpe, recebe valores de configuração do servidor. Então provavelmente haverá coisas que são armazenadas em algum lugar e hum, acontece que o ASLR está desabilitado, eu, desculpe, esqueci de mencionar isso. Hum, mas então nós, a ideia é tipo, eu apenas tipo, enviando tipo A, A, A, A’s como tipo, um monte de uh, opções e então olhar na memória para ver se eu poderia encontrar aquela string em algum lugar. E eventu, eventualmente, a opção de domínio

[43:36] foi uma boa. E então hum, agora posso mostrar a você uh, uma demo legal que é, o que aconteceu quando você realmente executa tudo. Então uh, no, hum, no lado esquerdo, temos o telefone que está inicializando. O telefone está inicializando e a janela uh, a janela de 10 minutos é tipo, no lado esquerdo é um, cliente DHCP rog executando o payload. E no lado direito é hum, é um servidor web que uh, fornecerá tipo uh, coisas de pós-exploração tipo vida. Então podemos ver o pacote rodando. Para ter certeza de que funciona, eu estava uh, fazendo cat de dev random nas uh, nas telas. É por isso que parece ruído. Está buscando dados do hum, servidor web e e eu não sei se você pode ver, mas está carregando tipo steve.data. Uh, para sua informação, tipo, Steve é na verdade meu uh, chefe. É ele. [Risos] E uh, logo então hum, uh, ainda tipo ex, eu não sei se há som, mas estou ex-filtrando áudio do alto-falante principal. E você pode ver no VLC que quando estou falando e batendo palmas, está na verdade tipo lendo o áudio no laptop do atacante. Então isso é bem assustador porque você pode transformar seu hum, telefone em hum, você

[44:37] sabe, dispositivo de escuta. [Aplausos]. Obrigado. Então, é, e só para constar, tipo, todas as ferramentas que eu uso já estão no celular, tipo, você tem o Netcat, suas coisas para diminuir o áudio para tipo, SDN, então você, só, tipo, escrevendo algum shell script, tipo script bash, tanto faz. Então, é, como conclusão, uh, para mitigação, tipo, você quer ter certeza de monitorar sua rede para não ter tipo bugs enviando uh, você sabe, tipo pacotes DHCP estranhos. E uh, na verdade tipo o firewall do McAfee uh, tipo, consegue detectar isso. Só para constar, você quer segregar sua rede, é, para ter certeza de que, por exemplo, a cafeteira não consegue tipo enviar pacotes DHCP estranhos para o seu celular. E certifique-se de que a TI realmente atualize seu celular, porque você sabe, levou, é a nota de patch lançada tipo, a Avaya lançou um patch tipo um mês atrás. Então certifique-se de que está realmente corrigido. E uh, se você quiser pensar sobre por que esse tipo de bug aconteceu tipo, dados técnicos são realmente difíceis de lidar e, não [inaudível] alguém de boa-fé, é. Ok. É, alguém enfrentaria, é, embaçou as coisas e eles esquecem

[45:42] sobre isso. Então, é, e só como uma rápida, é, sistemas embarcados não são caixas pretas, então eu só encorajaria todo mundo a, é, olhar para eles e uh, você pode fazer isso agora também. Então, se você tiver dúvidas, uh, me pergunte no Twitter ou qualquer coisa e obrigado pelo seu tempo, pessoal. [Aplausos]

Ver a transcrição original em inglês

[0:00] >>Without further adieu, because we stay on schedule. Philippe is here uh, from uh, from Portland, by way of uh, France from what I understand. And he is going to talk to, the, talk to us about uh, breaking into embedded devices, including phones, uh, phones that you might have on your desk at work phones that might be, I'm not even gonna get into that, phones that might be around. Let's learn about embedded device hacking. Let's give Philippe a big round of applause. [Applause]. Have a good time man. >>Thank you. Thank you, everyone um, so I’m really excited to be here, it’s like a big honor and um, yes, so today we are going to talk about hardware hacking and um, I’m going to show you this introduction to it and I hope um, I can show some love about um, hardware hacking. So uh, who am I? I’m Philippe Laulheret um, I’m a senior security researcher at McAfee, um, Advanced Threat Research. So I, I do um, software and hardware phone research, and you can find me on Twitter at PHLaul. Before doing McAfee, I spent 2 years doing uh, embedded security and before that I was a C++ Dev. So I'm

[1:03] not, not coming from a um, software background actually. So you could wonder like, why should you care about um, hardware hacking in the first place? Right? Um, I can see like two main reasons uh, first is that it's actually really fun and empowering to be able to um, you know, break op, break, open a device that you would like have in your home at work wherever. And instead of considering that it's a black box, you can instead you know, like start poking at it and understanding how it works. And then in a more like pragmatic way um, if, if we consider like security in the past couple of years uh, software is becoming much and much harder to like break. Like if you try to uh, I know like, pwn like uh, whatever like um, a media device like a web server like find, finding a vuln in the web server by itself is kind of hard. With, if instead you can just like open the device, solder a couple of wires, and get like a shell from that, that's much easier. So hardware hacking is great, because it's also like a lot of uh, low hanging fruits basically. So uh, today, we're going to talk about uh, Avaya phones um, and especially like the 9. The phone picture on the right side of the slide is a 9611g model. Uh, so Avaya is like one of the biggest uh, VoIP

[2:08] um, solution provider you can find them like all over the place. Uh, Google's like 90% of the Fortune 100 company and I think that's specific model of phone started in 2006, and is going to be enough life like at the end of the year or something. And the funny um, on the bottom right of my slides there is this a funny like um, screenshots from like a page from like a really old software firmware for these phones. Where um, actually like, you can see that um, you can only download that specific firmware, if you're like a DOD customer so um, basically then, uh, see that these phones are going to a lot of different places. So uh, we're getting prior art. Uh, in hardware hacking, it’s like a lot of information nowadays is on the internet, like you, you can find a lot of blog posts, tutorials um, there’s always like the Hardware Hacking Village that you all go, go and check out. Uh, CTF as well where you can like practice, uh, like kind of like the softer side of stuff and um, on my slides, I like a bunch of links at the end uh, so you can like download the slides at later time and um, also the slides uh, I’ve like, the one I've uploaded I’ve like, more text on them. So it's like

[3:11] a more like standalone. So you can read more um, and yeah, I read that in security uh, I found like 2 RC’s in the same uh, phone uh, something like five years ago or something, um, and they like talk at RSA called Stepping P3wns I would also recommend to check out online. So uh, for the next 40 minutes um, so I'm going to talk about um, hardware hacking and use that phone as a base to like support that conversation. Um, And basically the idea of like the whole situation is um, uh, like couple of like, 12 years ago, maybe uh, via Fox and open source codes, and um, they never applied security patches to that. And um, it turns out that like me, by poking at the device, I found that and it was like, women like unnoticed for like 10 years as they were like actually like a CV that got released like, yeah 10 years ago for Defcon. So I'm going to talk about uh, how I found that like that it was like some stupid like you know God inside that firmware. But more interesting, I think is uh, talking about the whole process, you know, like, how I did it, um, and why I did what I did it Why? Oops, sorry.

[4:15] Why I did stuff I did when I did it um, you know like, magic like sharing um, the process so that. And you know, also like sharing uh, know, what if the stuff I tried didn't work or, or selection stuff that didn't work, because, you know what, what works for one device might not work for another. And having just like that mental model of what we can do and what you cannot uh, helps you a lot approaching at any kind of device. And that's, I really think why I want people to take away from that talk is more like um, learning the process of that you can check out like whatever device you have. And yeah, we want to like insist that um, if I can do it, I think everyone in this room can do it as well. As I said I’m more from like software background, and the hardware hacking is still like, you know, like um, little scary, little foreign to me, but it's in the end, it's really not that hard if you have like a good process and you know, me work with patience. So uh, how did whole project start uh. Um, uh, to be honest, I was like, you know, working at work, and there were like all these cubicles, on the, on every desk, I see this like phone like standing on, on the desk. I’m like, wait a minute, these phones are running Linux, they have you know, network access, they have like

[5:17] mics and stuff is like, how, how secure is that? You know, like, I know, you, you wonder like, what's up with it, did people consider the security of this? So um, the first step before you know even like, I still like stealing my coworkers phone and breaking it apart, you can like, and that's generally [inaudible], you can check out the FCC websites usually like any device that has Wi Fi or Bluetooth, has to be um, on the FCC website for a compliance reason. So, that's what I found. Um, That's not my phone. That's like a, also model of same brands, basically and like pretty close. So you see all these cool pictures. But more interesting is the, the inside of the phone. Uh, so we can then see it and on the left side in right, in red um, I’ve highlighted this like random debug connector, I don't know what it is, but that's interesting to see that's there. And on the right side um, there is like that, like um, in purple there is that flash memory. So that's usually where the file system of the phone is going to be stored. And the whole point of that is just to get an idea of what to expect, you know, before even approaching a real target, like building hardware and stuff. So that um, you, you know, like if it's going to be an easy target or hard target

[6:23] uh, you know, if everything was covered in black epoxy, that will be harder. So another important step is like figure, um, getting like um, online material, like um, you know, um, marketing brochure, so you have an idea of what the phone, what are phone capabilities in the ecosystem surrounding it, so that you have an idea of um, you know, like the attack surface. And you can also find like user manuals and stuff. And for instance, I found that one that was pretty cool. It's like a user, like a, advanced user manual that says, oh, if you want a serial connection to the phone, you need that funky box. And uh, yeah, which is interesting it teach, it tells us that yeah, you can find it’s serial connection and you may have had some special hardware for that, but, are we going to see that in a bit. And uh, after that, you also want to check like forms and um, so that you can find out what poor user are doing like for instance, I found like the default passwords for the phone in debug interface, because um, and system admin. So here, uh, talk uh, talking about that online. And uh, if you're lucky, you can also download if you're more of an idea of uh, what's up there. And then we'll

[7:23] cover that in a minute. Okay, so uh, what do we do now, uh, now we have an idea of like, what it might look inside. This is a hardware hacking talk. So we're going to provide volunteers and so the point is like you open the phone first. Um, and the trick is like, usually you always expect to find the same stuff inside. And uh, if you look at the labours of the components, you will see uh, you, and you Google that uh, you will find out like what it is. So for instance that's my phone, and um, you can see the centre of the CPU a, above it like the RAM, in like a lavender ish colour, like some unpopulated like header that I marked with a question mark. This, I think the same way, there are the one we were like seeing in the picture before and I, it might be JTag, I did not have to use it. So I don't know actually. Uh, in proper, we have like the Eeprom’s that’s uh, with the whole like some settings and stuff. Uh, in dark blue in the bottom of the um, of the slide is like a keyed RJ45. So I was kind of, kind of confused when I was looking at that. And I didn't know even the term for it. And the idea is just a regular, RJ45 uh, like Internet plug, but with a weird um, connector so that you cannot plug the, the wrong stuff into it. Um, and uh, more interesting

[8:26] in yellow uh, the UART’s. So it's UART is kind of like the serial console and um, we have like these experts like uh, pads. And so usually like in manufacturing or something you would have like a pogo pins that would like generally connect to the pads. And this uh, that one is actually really interesting, because you would find like serial con, you'd expect to find the serial consol on that. And on the back, we can see the NAND flash that we've seen the previous picture. And um, yeah, from that is like where the file system would be, like stored on, on the device. So okay, you have um, you, we looked at the stuff inside and the, the like, other thing that's interesting to look at is test points and debug headers. So, and like basically all this kind of stuff that on those components. And you can ask, why would you expect to find them inside? And a couple of reasons like ones like just, usually like the Dev board that, that the guys are going to use is the same as the production board. And maybe they're not, just not going to solve the other debug components. It's the same as if you are like software, and it was built with like debug symbols, for instance. And um, also like part of the manufacturing process um, you, this test points and stuff might be used for like flashing

[9:30] the device ,or making sure it's flashed properly. And sometimes, you know, like something died on um, in, in the, in the real world. And they want to like do a post mortem to understand what happened. And that's useful as well. So what kind of stuff you want to look for in that situation? You want to look at UART that we like looking at before. JTag that I'm going to, uh, cover like in a minute. And then like you can also have like random test point that are chilling there that like all over um, the all over the table, all over the board. And there might be like long test points, er, like labour like TP1, TP2, whatever. And sometimes that, that might be like not interesting to you, but sometimes you can find interesting stuff like um, you might find that like oh if you short like TP64 uh, with ground is going to reset the device, which might be actually useful in some extent. So uh, looking at UART uh, so as I said is for like serial connection. And it comes in like 3 or 4 pins. The 3 pins will be uh, ground uh, transmit and receive. And the fourth pin would be like DCC, so 3 volts, 5 volt whatever. And usually you don't care about that one, you don't even want to plug it, you don't have to. And might uh, yeah, and uh, the, the trick to know is uh, the serial

[10:36] console uh, some data at different speed. And there are only like a couple of it's, called like Baudrates. And there was only like a few uh, common baud rates values, so if you try to plug your, your system in on, into the UART, and you just see gibberish on screen, the, probably the reason is, you just have the baud rate wrong and you could just like try to cycle through like all the possible, possible one, and it would find something eventually I think. Um, JTag is another one that's um, interesting um. So that's for like hardware debugging and ways that you could, like, you know uh, debug the CPU usually, and execute like instruction by instruction and whatnot. And it, they come in many different uh, shapes, number of pins and whatnot. So some example like on the bottom of the slides uh, but actually only a couple of wires are interesting and uh, at the end of the slides I have like a link to an article about like understanding JTag better. But basically, like, if you look on the top right side uh, of my slides, there is like a Dev board and say like a nice uh, JTag Connector like plugged there. And on the other hand, like on the bottom right, it's like some uh, random device I

[11:38] was looking at, which you can see, there should be a JTag, but it's never been soldered on and so I had to solder directly onto that stuff. And the trick to remember here, if you kind of like solder your own connector, is uh, you actually may have to add like extra resistors called like pull up and pull down resistors that connects like one pin to ground or one pin to like VCC. And the point of that is, actually, I don’t know the point of that, but uh, the reason is that if you don't have them, it might not work well or it's more work most of the time, it's going to be glitchy. So um, and if you follow the instructions from like, for instance like a arm, a specification for like what resistor you need, so, you might skip them, but then you might waste time like understanding why it's a weird, like weirdly f*****d up sometimes. So I would recommend the pull up and pull down resistors. So that's just random board that my coworker was looking at uh, just to show you that what I said is actually fairly generic. Uh, on the left side, we have like UART. On the right side there like some JTag connectors. Uh, up there is the mmm, the primary there is like, the main CPU, whatever that’s under like a shield. And usually you, you do that for um, preventing um, interferences. So

[12:43] it's like a Wi Fi module, so that's why. And the good thing to know is usually the shield is grounded. So like, if you're looking for the ground on your thing, you're like, either the shield on that kind of stuff, or like the casing around the Ethernet port or whatever is also act, actually like fairly useful. So uh,now that we learn how to uh, look into stuff, we need to know what hardware you need for um, interfacing with what's inside. So I'm going to present like a bunch of uh, cool hacking tool set that's important. So the first one uh, you may want this pin or like the stickers, I don’t know if you're familiar with that um, the actually, like, what's really important is like, safety. Um, so you know, don't work with stuff that’s plugged in the wall. Uh, remember to unplug stuff working like well ventilated room, it's important. And uh, yeah, just don't be stupid when you're like uh, messing with hardware uh, but yeah. So next uh, picture from the lab uh, I'm holding a um, soldering irons. You can usually switch tip for like a fairly large tip for like big soldering and tiny ones for small soldering. I have a microscope, so that's really useful for doing uh, tiny soldering. And the trick is I, I tend to drink a lot of coffee and I shake, so

[13:47] I will, I would, I was thinking like I couldn’t do that, but actually, if you um, if you careful and the, the trick is like really try to um, you know, when you soldering, like try to hold your arm like straight and well grounded. And under the microscope, you can actually do a lot of stuff that’s, you just don’t think, you wouldn't be able to use, you would think you shouldn't be able to do it, but you actually, actually can. [Breathes out], sorry, um. Top right side um, it's more actually used for the tiny soldering and the um, mid sec top right is like flux, so it's kind of um, magic glue, magic uh, gooey sta, it’s a substance that you put on um, pins to uh, when you start doing surface mount or pads so that it works really well. So don't, never forget, flux. Uh, bottom is um, sa, like, in the same uh, size, like uh, copper wires, like a minal wire that you use, usually for making codes, you know, for like radio or whatever. Um, and the trick is that the, the wire is actually um, coated in uh, varnish so it doesn't short. And you can use it to do like really tiny point to point like soldering, and that's actually really useful. And just next to it, you have like some

[14:48] desoldering wick. So like, the idea is, if you put too much solder and you f**k it up uh, you can put the wick on top of the solder block that you messed up with and you um, put the soldering iron on top of that, it's going to get really hot, so you want to hold it through like the plastic casing and it’s going to absorb all the like extra solder. And you can clean up your stuff. Then I put a picture of like some random like uh, jumper wires that are, are, or usually, always useful to have. And on the bottom right, I have like that crazy heat uh, gun. Uh, it's just like 60 bucks at Home Depot. It's meant to like, help paint dry or something, I'm not sure, but it's actually really useful for if you’re on the chip, if you want to remove component by just like heating them and pulling them off. So uh, more cool hardware um, that's a multimeter. Um, if you're not familiar with that, it's easy to for, find voltage of chip you don't know, like what's the actual voltage, so the black goes to ground and the, with the red you uh, with the white probably select poking around to uh, measure the voltage. And there was a really cool stuff is you can set in continuity mode and when you have like connection between the two probes, it beeps. So if you do

[15:51] like crappy soldering job, as I was describing just before, you can make sure that you actually did a proper job where like everything is connected the way you think, by you know making sure that both like, when you probably, both side it actually beeps. And that's actually fairly useful uh, tool. The other one is, this is a Logic Analyzer. Uh, the name is like a Sally, um, that's a brand. And the idea is, the same as in software, you have like ways of communicating between process, like in hardware, you have like ways of communicating between chips or the CPU and the chip. And it’s uh, it's like a lot of different standards, different ways of doing stuff. But the logic analyzer like know a lot of them and it's going to convert like a bunch of signals going , going on to wires into actual data. And that's actually really useful. That would be your eyes, like when you're doing uh, debugging, you know.

[16:32] And that's like your snapshot of like some SPI communication uh, which spies with some random protocol. Uh, that's like an FTDI cable also come in many uh, serial cable, it comes in many different shapes and stuff. And the idea is just like, when you want to do like UART, you, you plug that into your laptop, and you connect the user side to like the UART port and you get like a console, it shows up as a serial port. And uh, as an example I’ve um, on the bottom right um, like a raspberry pi that’s, you can actually get to serial console and you don't need like HDMI cable or anything to interface with that. Whoo. Um, the Bus Pirate uh, also like cool device um, it does um, It, it's kind of dependent of the hardware hacking at um sorry, with um, the Sally logic analyzer, so instead of absorbing data, it's like send data, so it speaks a bunch of different protocol and you can use Python to programme it. So it's extremely useful if you want to like read flash, programme um, microcontrollers and that kind of stuff. Um, more cool stuff I covered. I was talking about JTag, that's the JTag debuggers that you, that's where you would plug actually like the Digitech port on. They

[17:38] come in many different like uh, price range and whatnot. So on the bottom right is a fly swatter it's like, probably like 30 bucks, I think. And it works okay, and above it it's like a J Link, which is more fancy. And the idea like, the more expensive the stuff is, the more, the probably the more reliable it is. And it comes with like better software and whatnot. And on the bottom right, the pink bodies are JTagulator later that Joe Grand, the same guy who made up those badges uh, made. And it's really awesome. So, if you're like that board, you don't know what it is until like a bunch of test point and you like, I bet there is some JTag somewhere in it, but you don't know where. You can just wire like all the test points to the TJagulator and is going to brute force like and try to find everything. So it's really cool. Um, those are interest, important tool is uh, Flash readers. So usually Flash content, the Flash as the file system and stuff. And um, so you want to like interface with that. And uh, it comes in two flavour, I guess, you can do like in circuit stuff. So you have like either like your little like clamp that you put on the chip or a little rectangular one um, in to clip on. Um, so like the Raspberry Pi is a good one for that. And on

[18:42] the top right, is like a flash cat, uh, it’s like useful for the rectangular one. Um, but you can also like, choose to like, actually disorder the chip and, in that case, you would have like some socket adapter. So you can clip the chip on and then you plug it into your Flash cat and whatever, and it's going to read it. And that, I will cover like why, whats, my, whats, why it's important like both in a minute. And finally, it's kind of the um, last uh, hope. So let's say uh, you know your Flash is encrypted, there is no UART , there is no firmware. So you can try to do like the more crazy stuff like, first injection and such an attack. So that's the chips whispers like more like a kind of hard, more badass device. And the idea with that is um, it, you can do stuff like um, you are wire it um, to the CPU and you're going to drop the power on the CPU for like a split second and it’s going to like mess up some instruction and you can bypass checks and stuff. That's pro, what people use for like gaming console hacking and, and um, that kind of stuff. So uh, what do we do now um, that we have an idea of what's inside the phone and um, you know um, the tools we can use. So like, I think it's three

[19:47] posts potential track, one is messing with the UART, so the serial console, and this one is uh, messing with the flash and trying to recover the firmware or something and then maybe you can just download the firmware online. And the three are like valid approach and sometimes it's good to just go from one to another to another and you know what, whatever you find like some hardware you can like go from one to another. Uh, so I went for the UART first and that's what I'm greeted at by when I connect my FTDI cable to the UART ports that I, I was doing before. So um, we can see that on the left side, the, the um, the console thing, it's like dot dot dot, usually when you see that, you can press space or escape and it's going to interrupt the booting process of the phone. And in that situation, uh, but somehow here it didn't work. And I, I will cover that why in a minute. And on the top right side of the slide um, we can see like it read something from the EEPROM and then decided to set the console to Dev null. So you don't want console to be Dev null because if that goes nowhere. But that's interesting to know that um, there is some potential there. And finally, it's like booting in next so it con, confirm us that it's a uniques port, but then uh,

[20:48] there's nothing more uh, after that. So there's some good thing, bad things. The problems are like nothing shows up after like the Linux is as we did, probably because of the Dev null situation. And when I press keys are talking and um, I'm going to like come up with like, why that happened. So at that point, I was still like, okay, I, I cannot go anywhere. So I'm going to try to recover the firmware to try to understand what's up with that. Uh, multiple ways of recovering firmwares uh, is like an easy ways like you can do it online. And actually that worked um, there is like a quick snapshot of that, uh, sometimes it’s encrypted. On our case, it wasn't. Um, but, yeah. So you can also try to sniff a firmware update uh, that’s really useful for IoT devices in general. And you can use a network tab, which is like the thing pictured on the top right of the slide. Um, or you can mirror your port on your switch or whatever. Uh, the problem with all of that is oftentimes a firmware updates going to do over like h, HTPS, or it might be, in this case, you're like stuck. And then you want to go for like a more like uh, hardware hacking stuff or like you’re going to dump a flash, for instance. And like

[21:48] even more advanced techniques that I will briefly like uh, talk about. So how do you dump a flash? There’s two ways, as I was mentioning, just before, you can do in circuit programming and um, out of circuits. So in circuit is cool, because you don't have to, you know, like remove stuff, break stuff. But a couple of issue is that um, the main idea is to read the flash, you need to power the flash. And if you, if it's like still plugged into the whole system. Uh, it, when you're like Raspberry Pi, for instance, going to try to read the flash, it's going to tr, try to power like everything else that's connected to the same like like power line. And either you know, USB Pi is not strong enough to power like a VoIP phone, which you would expect. And in that case uh, but it's just not going to work. Or maybe your Raspberry Pi is really strong and it’s going to do it, but then the problem is the CPU stop booting and it’s going to talk with the flash and that's going onto to mess up your stuff. So in that situation, you have like two choices usually, either you can try to like lift up the pin, the ball pins, so that it doesn't happen. Or you can kind of go a little more like hero approach where you want to keep the CPU in reset. So I've been successful with that many times

[22:51] or I just like starts like trying to ground like random test points, of stuff on the boards, praying that is not going to find anything. And usually at, at some point like, I'm going to notice that okay, when I do that the phone like light up, it doesn't boot, that's good. And maybe better ways you can desolder the chip with it like to be like heatgun or whatnot. You have to be careful though, because if you like pull it too hard, you might like bend pins and is going to be like useless. Um, with a good trick to know is that you can make a little like um, tinfoil hat or whatever, like on the chip, so that like when you're heating up the chip, like the stuff around, it doesn't get too hot. Er, so you don't accidentally like knock off like some like tiny like components, that would be like a pain in the butt to um, put back. And uh, bottom right is like I was, I was, I thought I would have to do that on the phone. So I wanted to practice first and then just took like some random uh, USB thumb drive and I tried. And actually, that worked really ff, nice. But the trick is to remember, I also put some flux because it helps. And uh, yeah, just don't, be careful with, when you put it off. A few other tricks that actually didn't work on this one. But I, good to know. Uh, U-Boot is the most common boot loader uh, not used here, but it's, you would find

[23:56] that on pretty much every other device. And the idea is you can also instruct a boot process of that and asked nicely you would, hey, can you load the flash in memory, and then uh, U-Boot is also able to dump in a Hex like in the screen um. The, the memory, is this way, you can just get, write into the script to do that and recover everything from the flash, which is really cool. But usually like Dev don't like letting you do that. They said they lock that approach, so, so you cannot like press space to interrupt the boot process. But there is a trick that I also call like the Yolo approach where, instead, when. The idea is like U-Boot is going to load from the flash like the, the new scanner or something. But if while it’s happening, you start like poking with, you know, like a wired is connected into ground and they started poking the NAND flash, like some of the pins, it's going to mess up like what’s uh, u-boot is reading and after a couple of tries, u-boot is going to be like, d**n that kernel is f**ked up, I don't know what to do and it’s going to give you like a shell. So that's really cool. But yeah, as I said that one we don’t work on our phone unfortunately. But uh just some cool example that I found online was like some guy actually did that. And uh, I underlined in

[24:59] uh, in the like purple on, on the bottom, like the command you need to use to like log the, the, the flash in memory. And on the right side, the secondary block of text is um, sorry, is, how uh, you will just panicking and be like, er, I don't know how to do with your kernel and give you the, the shell. So uh, how um, so a few more like tricks for um, dum, dumping the flash, so you can use JTag. So usually you have uh, if, if JTag works, you're going have to be able to um, dump the RAM. So in this case, that won't be really like dumping the flash, it will involved dumping the firmware, but, in a lot of devices it’s going to load the whole stuff in memories, so if you can dump the memory you are, you, you the same means you pretty good there. And kind of the last hope with this. That's one of my favourite about hardware hacking is, you can do crazy uh, stuff uh, and an example is a Scanlime um, that person on the internet who um, she had a um, a Wacom tablet that she wanted to dump the um, the firmware off and there was like no attack surface at all, which she realised that like when you [inaudible] USB stuff, and when you plug your USB um, onto the laptops, there is some USB exchange that I

[26:01] don't know anything off, but it sounds like USB descriptor. And if you, if you glitch the CPU just at that time, um, it's going to like, know, miss like a binary check and is going to send a way more data. And with that uh, she was able to recover like the full flash, full memory or something. So it's really impressive, but, and that's what's kind of awesome about hardware hacking. Okay, so uh, we recovered the firmware uh, in my case, just by downloading online, but, what do we do now? We want to analyse it. Um, the best tool for that is called Binwalk. And it's just basically magic dictionary that's going to like look at your binary blog of stuff and be like, mmm, halfway through it looks like there is a zip file, I'm going to try to extract it. It tries, maybe it works, maybe it doesn't depending if it was actually zip filed or not. And it does that for everything. And uh, it might also find like compressed file system such as Squashfs, JFFS2 etc. And sometimes like your um, your firmware file might just start with like Elf headers or just like random like ARM code that you could like, look at. So I haven't been work on. So that's the firmware file, I don't know it from the website.

[27:01] And once again, it's easy mode, it's just a doc file. And they already like split it up into boot 1, boot 2 and JFFS2. So like, Binwalk has nothing to do here, really, and I can just extract the all file system. And that's cool, because from there, I can look at what's on the phone, just like that. Uh, but the more interesting, use case for Binwalk is, I took like a different uh, firmware file for like, a [inaudible] phone. And this one is way more interesting, because Binwalk for, find like a way more lot, lot of stuff. And uh, I've highlighted, like you find the file system and is able to extract it. And there's also that random like my SQL stuff, which I think is a false positive, then you need to be aware that there will be a lot of false positives, so don't blindly trust what the Binwalk says. And uh, really, really funny stuff that I was looking at uh, if you run strings on that specific image um, you will find a U-Boot strings. So, that fun is using U-Boot and the cool stuff I was describing before, would actually work on that one, look. So now that you have extracted the firmware file, what do you want to look for? One of the most uh, interesting stuff is uh, finding the you, update mechanism. So assuming you have uh, encrypted firmware,

[28:04] like if you reverse engineer that you might find the keys and how to extr, to extract like subsequent uh, firmware updates without having to do like, any hardware stuff. And then you want to look for like secrets, like uh, passwords, certificates and so and so forth. Uh, originally, my goal was to look at the main binaries. So that's just the thing and deal with like the VoIP stack. Uh, that could be make sense to look at that. And um, also you want to look at the bootloader because, it may have a hidden commands, explain why all console is not working, that kind of stuff. So, remember, the point of all of that was, I wanted to get a shell on the device and um, what's the process to do that? So, the one I want to go for is, I want to fix the serial console, you know like the Dev null was not cool. Um, but also approach will be like messing with your boot arguments. Um, not working here, obviously. Uhm but you know, you can specify the console you want and the, uniscript can be marked, oh I want Bin bash as my uniscript and you have a console. Uh, and like kind of last resort stuff that I was considering as well is, you could patch the firmware. In our case the firmware is signed. So uh, that won't work unless you try to glitch it, which really hard.

[29:08] But you can also try to patch a file system. So the way Binwalk extract the JFFS2 stuff, you could modify it and then like repackage and flush it directly onto the flash. And that's usually accurate, foolproof methods like, that would work in most cases. So instead, I'm going to uh, reverse uh, um, the Bootloader. And um, for that, um, because I wanted to understand like, why Dev null, a con, the console was set to Dev null and stuff. I'm just going to cover um, in much detail and I would be come on you to check out Azeria Labs Tutorials that cover everything, which just useful here um. There is this notion in ARM of literal pool.

[29:44] Which is um, inside the code section, you would find some little chunk of data and that's usually like used to la, loading registries, um, absolute addressees, imminent values, magic offset, that kind of stuff. And uh, FYI, like in ca, in case of function calls um, the arguments are going to R0 to R3. The rooted value is in RVO. And when you like, want to return from your caller, it's, the, the return address is saved in like the LR register, that stand for like link register. Um, and the big trick, big problem here is um, we're like trying to load the boot loader. So it's uh, it's not really Elf. So if you tried to import in IDA, IDA doesn't know what to do with it and so you need to find the loading address for that stuff, so it match what, where the phone is loading it. Couple of tricks um, so none of your load key is going to be printed on screen, that's our case, sweet. Um, but otherwise, you want to look at like header file, headers in the, in the bootloader file or maybe recent vectors so that stuff for like, specifically for ARM, like the CPU needs to know uh, specific addresses where like, a recess or an intrep happening and it's like funny like um, square like,

[30:50] how it’s being set up. So if you find that and you find like what looks like an intrep vector handle or something, you can find like, ah, that must be the address. And uh, finally, the literal pool I was mentioning uh, really useful with a because it's going to contain like absolute addresses or point to strings and stuff. So uh, if, if like you have strings, and they look like all f**ked up, you probably got the wrong address. And uh, Quarkslab, uh, what a blockbuster blog, so I would recommend you checking it out. So as I said, in our case, it was easy. Um, when it boots it prints uh, the jump, whatever. And that's actually WIFI loaded.

[31:21] And um, on the bottom right side, it's like a bunch of uh, strings um, so it's a bunch of addresses that point to strings. Uh, the system snapshot from IDA and um, we can see that uh, um,it's all the strings like prints well, so that means that it's loaded properly. It's not like all messed up. Okay, so now that we have the bootloader and we can like work it with IDA, uh, we want to search for strings uh, we were looking at, you know, like that sentence like EEPROM read successful, whatever. So we can use like cross reference in IDA to find where the string is coming from and look at the function that handles that. And uh, yeah, just as a FYI, but like EEPROM and Spi, so the EEPROM that's on the board is called a Spiprom and Spi is just one of this protocol I was mentioning before. EEPROM is just uh, like a small memory, um, whatever. And the spi uh, protocol is just like 4 wires um, and the ID to CPU in command and EEPROM like reply, and uh, and that's a dump from like using the logic analyzer to have a look at what it would look like in real life. Uh, that's the data sheets of the EEPROM

[32:22] that you can find on, online, if you google the, the label on it. Um, the cool thing is in the bottom left uh, of the slide, it tells you like, the pinouts, so you how to connect stuff to it. And on the right side of the slide um, it tells you which, which, upcodes are for Spi command would send. Like for instance, if you send uh, 3 it’s going to be read, read, if you send 2, it's going to be write. So that's uh, that's something useful to know, right? Oops, sorry. Back to the um, back to the IDA and the uh, bootloader, we can see uh, the strings we were like looking for. And something is for me promising is, we can see the uh, console set to Dev null, but above that, that I could bur, 2 of the option and it’s actually saying like, oh, setting console to like UART 0 or UART 1. So we want these ones to be printed.

[33:08] Um, that's a, that's a function that actually does print that string. And uh, what it does is roughly um, cleaner, clear some bites on the stack. And then you read for me from from a magic address. And it's going to compare like bytes um, that has just been read. When if we have the good value, it’s going to actually print on the console setting, the console for uh, Dev ttyAMA0. So we want that to happen. Uh, and something you can ask me is like, oh, how did you find that read EEPROM function, you know? And there like more a couple of ways of doing that. Uh, the easy way that I've highlighted in green, that screenshot, is uh, on the bottom right, you can see some like logging that says, oh, EEPROM read fails. So I know that function is responsible for reading EEPROM. Uh, but maybe, maybe the few more I’m going to look is not uh, as uh, variables. In which case um, as I said before, like, to read from a EEPROM you know you have to send 3over SPI. So, if you find like the SPI function, and you see like sending 3, you know what it is. This whatever highlighted in yellow. But then like, how do you find a spi function in this kind of um, programme? Uh, 2 ways for that.

[34:07] Um, my guess once again, it was logged, so it was easy. But usually like, the main trick is um, you have this um, something called um, mapped uh, IO MMO mapped IO. It's this kind of like magic address values in the CPU that like if you write to them, it's actually going to send data over like you auto spi or whatever. If you're lucky, you're going to have a data sheet for the CPU. And it specifies exactly what are those addresses. If you're unlucky um, you have to guess and that's really hard. And, at the time, maybe you should like look for something else, or just you know, you're going to spend a lot of time on that. So we want to uh, patch the EEPROM now, so we can uh, build the console. The plan of action is, we know the read, write comments uh, we want to interface with the flash. So to do that um, uh sorry, the EEPROM, we, we um, we needed like a spiuh, device and that we've seen before the Bus Pirate is a perfect candidate for that. And we need to connect to the chip, uh, unfortunately,

[35:09] like it's really tiny one and so like the clip I was showing how like too big for that. You can buy online some rigs that people make um, it's like, expensive, and it's like five weeks to get them. So instead, I went kind of crazy and I tried to solder like um, little wires onto the thing. And I was like, honestly, that's never going to work, but happened to actually work. And that was like, sweet. And uh, it's all like look like cross because it’s like all the flux that remains on that. Um, and that's the code for the Bus Pirate. It's super like boilerplate uh, thing. And when you just write um, this magic values that uh, sorry, I was asked to like, replace, them with like, images. But uh, the idea is like, just after that you're greeted with console is set to uh, like your R0 and now we have a lot of more stuff uh, printed on console, which is great. But unfortunately I, I get like this a harder like, the input are still like not working, I was like trying to press space or type like, it’s as, asking for oh, you want to look as root? What’s, I type, nothing happens, like ah, what happened? Did I just cut the trace, so you cannot send data? We have the boards, we can look

[36:09] at it, um. So uh, this just like, like a zoom up on the thing and at that time, I was like, you know, looking at the UART pad and start like with my millimetre, like trying to beep out, like where it goes, you know it’s, following the continuity testing. And eventually it reached some wires, like on the right side and wires are that little hole that's connect one side of the ball to the other. So the trick is the actual like trace that connects UART to whatever uh, goes to the other side of the board and goes oh, back and forth. And it's like really, like tedious. And eventually I kind of lost where it was going.

[36:39] But it was kind of under that MOD port, uh, that's like the keyed RJ45. Um, and so um, remember like the recon side uh, recon part, um, we have that box and it’s like ah, d**n, that’s, that’s the thing. So I kind of went via like, my euro approach again where, I was holding like a, a plug, like a jumper cable in my um, the transmit of my FTDI cable. And uh, so I had like this like wire that I could poke around. And on the other side, I was like pressing keys on the console trying to see if something happened. And meanwhile, I was poking like to the pins one by one. And I think at the second one, it actually worked. And I got greeted by uh, like a root shell on the device. So that was cool um. But the trick was um, the, on the right side of like a proper setup, where I plugged my ethernet cable into the plug. So at that time, I didn't want know where the key the RJ45 was. So I was just like sanded the plastic of the ethernet cable so I could like shove it in, and yeah, it just works, so that was nice.

[37:36] Uh, now that we have a root shell is it like uh, a lot of debug strings prin, printed on screen and that's annoying. So um, the trigger was like, I want to kill the process, it's like, sha, that's like flooding my console. Uh, there’s a watchdog that’s going to reboot the device if that happens, so I highlight in the corner, like the magic commands that you can run to kill that. It’s just like a random, unique stuff. Uh, so now we can finally do some Vuln research. Um, and really what you are going to do is look at process running, poke around, look at open ports. Uh, there's just a bunch of processes, uh, new sequel stuff, but um, that’s when it’s all getting interesting. I think at some point I was tired of looking in the IDA and I was like, I’m going to poke more. And I looked at DHClient and like huh, and the really funny parts like, I run the DHClient and I see this like 2007 copyright. I was like, woah, that's not a good thing. And if you just run DHClient by itself, it's Segfaults, like that's weird. And if you like, run it the right way, they print a debug message that say oh, we modified it to work it better on our device. I’m like, huh, that's interesting. So, if we

[38:36] look back, and we look for the specific version, it turns out that, 10 years ago, actually, for DEFCON uh, Jon Oberheide um, really is like an exploit for that specific version of the DHClient, so I was like, well, that's, that's easy. Um, but we want to make sure it's actually vil, still vulnerable. So the um, the phone was like a doing like um, Stack Overflow, like while handling DHCP options. So we can compare the original source code with the patch source code because DHClient is open source. And just keep in mind, that might be like mitigation, like stack cookies, ASLR whatnot. So if we look at the vulnerable code on the left side, we can see a memcpy like highlighted in red. That’s using like data.len as a field. Or on the patched version that we place, that by 4. So the idea is like, this bug is uh subnet, uh, it's a bug in the subnet mask and link, and the subnet mask should be like 4 bytes. But, the way the HTP option works, is that you can send up to like 255 bytes, I think, and it used to just dumly trust, whatever you're sending, which is bad. And if we look in IDA like the actual like function, uh, we can see there is no stack canary and the vinner, the, the, on the

[39:39] left, on the right side, it's, it's not using that magic 4, so it's, it’s obviously like still vulnerable. So it simple to exploit stuff. Um, working on the phone os TDS, I was like, I'm going to try to set up QEMU um, if you're not familiar with QEMU it’s kind like emulation of ARM stuff or like mini of system and can do either like Userland or Full-System. Userland wouldn't work here because uh, DHCP is um, more going, try to modify an IP and stuff and that's not cool. Um, but instead, we can do, do a Full-System emulation and uh, those tutorials tell you how to like, set up a query match for that. And we just want to set up the network properly, uh, because we want to interface with the DHCP and naturally um, the um, QEMU stack would give you a digi, DHCP for yourself, so you have to be, stay like don't do that and, yeah. So I run it in DH in QEMU and after like [inaudible] fault and it's still Segfault and it’s like, huh. So it turns out that like, Avaya modified stuff that actually causing the Segfault. And um, I was going to go back too fast, because I'm running like a little of out of time. But uh, basically it's creating that weird socket, uh, it’s like

[40:42] a name socket and uh, so that’s like the main application that the VOIP stack can talk with DHClient and show options. Um, and uh, the idea’s like, that's like the main application, then we can see what it does. That's non, not super interesting. But basically on the left side, it’s like sending data to configure DHClient at startup and on the right side, I re-implemented that in Python. And uh, you can run that with like Socat, um, so, Socat is just like, kind of like Netcat in um, in more like um, more tools, so you can share that name socket and the idea, you run the Python script on the host, you on socket on the um, QEMU like binar, image, and that just work. So now we can start debugging uh, DHClients, um, you can run GDB, we can try to like, actually run the bug. I do, I couldn't compile the original proof of concepts, it was like using a really old tools and it's just after like, hella, like couple of hours like, ah f**k that, I’m tired. So instead uh, I use a Scapy based uh, exploit. Scapy is a Python library that lets you like, you know, mess with uh, network packets, like a fairly low level. And um, so now we want to like reach the um, vulnerable part, vulnerable code, so um, I

[41:47] was explaining the bug in the uh, subnet mask option. And how, the way DHCP works is like a tea, tag length value like type of stuff. So you say, Oh, this option is a uh, subnet mask, here's the length, here’s the value. And obviously it was like, it would be 4, but if you send more, it's fine. But for the DHCP specs. And so we can use Scapy for doing that. So uh, that's my, like a chunk of my Scapy script and just the payload in properly is interesting. Um, basically just sending the subnet mask option with uh, data that will be like A, A, A, A, B, B, B, B, C, C, C, C and so on and so forth. So that um, when it crashes in GDB uh, we can see like all the register we control, and we know um, exactly um, you know, if we want to af, affect which register, which chunk of the shell code we need to change.

[42:33] And we can see that we actually controlling uh, [“pc’s” so the programme console, so that's good. We know that we have um, we can exploit, we have control, control for execution. And there like a few more details that I'm going to skip over. But um, we need to sta, to craft a shell code now. Uh, unfortunately, like it's it looks like the stack is uh, you cannot execute the stack, so we will have to work it. And that's tedious. But um, cool stuff is like if you look for there is like a system calling, that binary that I think also, Avaya added. And we do control R4. So if we put us, if we can put a string in memory in an address we know, that could be a value like, system comment, and put the address in R4, we good. Um, so if you think about it, DHCP client, DHClient, sorry, receive configuration values from the server. So probably there is going to be stuff that are stored somewhere and um, it turns out that ASLR is disabled, I, sorry, I forgot to mention that. Um, but then we, the idea is like, I just some like, sending like A, A, A, A’s as like, a bunch of uh, options and then look at memory to see if I could find that string somewhere. And eventu, eventually, the domain option

[43:36] was a good one. And so um, now I can show you uh, a cool demo that's, what happened when you actually run the whole stuff. So uh, on the, um, on the left side, we have the phone that's booting. The phone is booting and the window uh, the 10 minute window is like, on the left side is a, rog DHCP client running off payload. And on the right side is um, it's a web server that uh, will provide like uh, life post exploitation kind of stuff. So we can see the packet is running. To make sure it works, I was uh, catting dev random on the uh, on the screens. That's why it's looks like noise. It's fetching data from the um, web server and and I don’t know if you can see but it’s loading like steve.data. Uh, FYI, like, Steve is actually my uh, boss. That's him. [Laughter] And uh, just then um, uh, still like ex, I don’t know if there is sound but I’m ex- filtrating audio from the main speaker. And you can see it in VLC that when I'm speaking and clapping my hands, it's actually like reading the audio on the attacker laptop. So that's pretty scary because you can turn your um, phone into um, you

[44:37] know, listening device. [Applause]. Thank you. So um, yeah, and just FYI like all the tools I use like actually already on the phone, like you're like Netcat, your like stuff to like dim the audio to like, SDN, so you, ju, just like writing some shell script, like bash script, whatever. So um, as conclusion uh, for mitigation, like, you want to make sure you monitor your network so that you don't have like bugs like sending uh, you know, like weird DHCP packets. And uh, actually like McAfee uh, firewall, like can detect that. FYI, you want to segregate your network um, to make sure that, for instance, the coffee pot is not able to like send weird DHCP packets to your phone. And make sure IT actually patch your phone, because you know, it took, it's the patch notes release like, Avaya release a patch like a month ago. So make sure it's actually patched. And uh, if you want to think about why this kind of bug happened like, tech, technical data is really hard to handle and, no [inaudible] someone in good face um. Okay. Um, somebody would face um, fogged the stuff and they forget

[45:42] about it. So um, and just as a really quick um, embedded systems are not black boxes, so I would just encourage everyone to um, look at them and uh, you can do it now as well. So if you have question uh, ask me on Twitter or whatever and thank you for your time, guys. [Applause]

Abrir no ambiente de trabalho do Vidleaf

Pesquise a transcrição, selecione linhas, copie citações com carimbos de data/hora, traduza.

Abrir no ambiente de trabalho →

Atribuição

"Philippe Laulheret - Introdução ao Hardware Hacking - Conferência DEF CON 27" por DEFCONConference (https://www.youtube.com/@defconconference), licenciado sob CC BY 3.0 (https://creativecommons.org/licenses/by/3.0/). Vídeo original: https://www.youtube.com/watch?v=HuCbr2588-w. Esta página é uma transcrição em texto do vídeo com quebras de parágrafo e carimbos de data/hora adicionados; o criador não é afiliado e não endossa o Vidleaf. O Vidleaf adicionou pontuação por IA e um resumo gerado por IA; o texto original permanece disponível nesta página.

Você é o criador ou detentor de direitos? Solicite uma correção ou remoção: copyright@vidleaf.app (veja Sobre estas páginas).

Última atualização