Le avventure di TecnoGeppetto: luglio 2016

sabato 9 luglio 2016

Hacking firmware La Fonera Atheros AR2315

Frugando nei cassetti è saltata fuori una vecchia Fonera, un Access Point che Fon ha commercializzato qualche anno fa ad un prezzo particolarmente conveniente (per l'epoca) e che consentiva di collegarsi alla rete Fon in tutto il mondo per assicurarsi una connessione WiFi gratis.
Ormai nei cassetti da almeno 7 - 8 anni e' venuto il momento di passarla in rassegna e di tentare di utilizzarla in qualche modo.
In giro per la rete si trovano molti articoli su come modificarne il firmware ed installare OpenWrt, il noto programma di gestione per Router.
Ho quindi tentato anche io la strada dell'hacking.
La maggior parte degli articoli la mettono giu' complicata, considerando la connessione seriale al connettore ICSP come una cosa estremamente difficile ed onerosa; Io non ho trovato tutta questa difficolta, devo essere sincero, anzi, e' stato piu' pesante il lavoro di lettura ed analisi dei tanti sistemi alternativi alla semplice connessione seriale, che sconsiglio proprio di percorrere le strade proposte nella maggior parte dei Blog, che indicano come preferibile la strada di modificare il firmware originale facendo un down-grade, per utilizzare un bug di una vecchia versione Fon ed ottenere i privilegi di root.

Semplicemente collegando un convertitore seriale alla porta ICSP, facilmente individuabile all'interno del circuito, si ottiene immediatamente la possibilita' di comunicare con il Bootloader della macchina.

Hardware

Architecture	MIPS 4KEc
Vendor	n/a
Bootloader	RedBoot
System-On-Chip	Atheros AR2315
CPU Speed	183 MHz
Flash size	8 MiB
RAM	16 MiB
Wireless	Integrated Atheros 802.11b/g
Ethernet	1x RJ45
USB	No
Serial	Yes
JTAG	No

Puoi guardare la foto del mio circuito i cavi sono collegati cosi:
Grigio -- GND
Viola -- RX
Arancio ----TX

Qui invece sono riportate le connessioni viste da dietro della scatola:

+-------------------+
|GND| . |TXD|RXD| . |
|VCC| . | . | . | . |
+-------------------+
+-----+ +--------+    +---+
|Power| |Ethernet|    |Ant|

Collegato il tutto e fatto partire il programma di lettura dei dati ricevuti su seriale (per Windows per esempio Putty e in Linux o MacOsx puoi usare Minicom) questo riportato qui di seguito e' quello che dovresti leggere

+PHY ID is 0022:5521
Ethernet eth0: MAC address xx:xx:xx:xx:xx
IP: 0.0.0.0/255.255.255.255, Gateway: 0.0.0.0
Default server: 0.0.0.0
RedBoot(tm) bootstrap and debug environment [ROMRAM]
Non-certified release, version v1.3.0 - built 16:57:58, Aug  7 2006
Copyright (C) 2000, 2001, 2002, 2003, 2004 Red Hat, Inc.
Board: ap51
RAM: 0x80000000-0x81000000, [0x80040450-0x80fe1000] available
FLASH: 0xa8000000 - 0xa87f0000, 128 blocks of 0x00010000 bytes each.
== Executing boot script in 1.000 seconds - enter ^C to abort
^C
RedBoot>

RedBoot> fis list
Name              FLASH addr  Mem addr    Length      Entry point
RedBoot           0xA8000000  0xA8000000  0x00030000  0x00000000
rootfs            0xA8030000  0xA8030000  0x00700000  0x00000000
vmlinux.bin.l7    0xA8730000  0x80041000  0x000B0000  0x80041000
FIS directory     0xA87E0000  0xA87E0000  0x0000F000  0x00000000
RedBoot config    0xA87EF000  0xA87EF000  0x00001000  0x00000000

Il firmware piu' aggiornato al momento in cui scrivo lo puoi trovare a questo indirizzo

Scarica i due file e passali nella cartella su cui punta il server TFTP che avrai gia' predisposto magari leggendo questa guida che ho fatto proprio ieri

Con questa istruzione setterai il numero IP del AP (-l)ocal e quello del server dove si collegherà con la prossima istruzione per scaricare il firmware (il tuo server TFTP) (-h)ost

RedBoot> ip_address -h 192.168.0.2 -l 192.168.0.1/24

Con questa istruzione il AP si collega al Server TFTP e si scarica il novo Firmware:

RedBoot> load -r -b %{FREEMEMLO} openwrt-atheros-vmlinux.lzma
Using default protocol (TFTP)
Raw file loaded [...], assumed entry at [...]

Questa istruzione serve per cancellare dalla Flash memory il precedente firmware (sei sicuro???)

RedBoot> fis init

Poi si installa il nuovo :

RedBoot> fis create -e 0x80041000 -r 0x80041000 vmlinux.bin.l7
... Erase from 0xa8730000-0xa87e0000: ...........
... Program from 0x80041000-0x800f1000 at 0xa8730000: ...........
... Erase from 0xa87e0000-0xa87f0000: .
... Program from 0x80ff0000-0x81000000 at 0xa87e0000: .

Stessa cosa per le partizioni:

RedBoot> load -r -b %{FREEMEMLO} openwrt-atheros-root.squashfs
Using default protocol (TFTP)

Raw file loaded 0x80041000-0x80200fff, assumed entry at 0x80041000

RedBoot> fis create rootfs
... Erase from 0xa8030000-0xa8730000: ................................................................................................................
... Program from 0x80041000-0x80741000 at 0xa8030000: ..............................................................................................................
... Erase from 0xa87e0000-0xa87f0000: .
... Program from 0x80ff0000-0x81000000 at 0xa87e0000: .

il comando sotto serve per controllare che tutto sia andato a buon fine

fconfig -l -n

Nel caso che il parametro boot_script_data sia diverso da

.. fis load -l vmlinux.bin.l7 
.. exec

Allora :

RedBoot> fconfig boot_script_data 
boot_script_data: 
.. fis load -l vmlinux.bin.1
.. exec
Enter script, terminate with empty line
>> fis load -l vmlinux.bin.l7
>> exec
>> 
Update RedBoot non-volatile configuration - continue (y/n)? y
... Erase from 0xa87e0000-0xa87f0000: .
... Program from 0x80ff0000-0x81000000 at 0xa87e0000: .
RedBoot>

A questo punto si puo' resettare il nostro nuovo AP

RedBoot> reset

Adesso dovresti trovare il tuo nuovo Access Point con OpenWrt che risponderà chimandolo con un browser web all'indirizzo:
http://192.168.1.1

E' inutile dire che devi avere i parametri corretti per poterlo collegare nella configurazione della tua scheda di rete.

venerdì 8 luglio 2016

RS485 + FTDI232 + Arduino test di linea

Per un nuovo progetto in questi giorni ho dovuto testare il funzionamento di una connessione RS485 attraverso un cavo lungo più di 100 metri.

Se cercate un po' in giro ci sono tanti tutorial sul funzionamento di questo metodo di trasmissione. Anche io non ho fatto altro che leggere qualche tutorial in giro e poi costruire il semplice circuito composto da 2 moduli RS485 che si parleranno a distanza attraverso il cavo.

La teoria dice che circuiti come quello riportato nello schema qui sotto possono raggiungere i 1200 metri senza problemi di decadimento della comunicazione, ma considerato che il progetto e' particolarmente importante in termini di sicurezza, e' stato fondamentale per me poter mettere sotto stress la comunicazione per poter controllare il regolare funzionamento anche sulla tratta di circa 100 metri di cui ho necessità.

Come si può vedere nello schema sia in testa che in fondo al cavo sono previsti dei carichi, che nel nostro caso sono già inseriti nel modulo che ho scelto per questo progetto.
Infatti nel modulino della LC Electronics di cui riporrto lo schema qui a fianco, ci sono già tutte le resistenze che servono per il corretto funzionamento del circuito.

Durante i test ho anche potuto sperimentare che il modulo e' anche molto sensibile alle sovratensioni, infatti prolungati periodi di sovra alimentazione anche di solo 1 volt in piu' hanno provocato la rottura del Max232 che e' l'integrato contenuto nel circuito del modulo.

Dopo aver fatto i primi test collegando un adattatore seriale USB-TTL come interfaccia tra il pc ed il modulo RS485, utilizzando un FTDI232, poi ho scelto di costruire un sistema basato su Arduino che si preoccupi di mantenere sempre viva la comunicazione e che segnali eventuali anomalie, nel caso la comunicazione non andasse a buon fine.

Il circuito e' molto semplice, dal FTDI232 prendiamo la alimentazione per il modulo collegando VCC e GND , nel caso del MASTER i due PIN DE ed RE devono essere collegati anch'essi a GND, mentre DI ed RO rispettivamente a TX ed RX della seriale.
DI -- TX ed RO -- RX

Per il modulo scelto per essere SLAVE (quello che trasmette l'informazione) si dovra' solamente collegare i PIN DE ed RE a Vcc anziche' a GND

DE+RE --- GND (master), in questo modo abbiamo ottenuto un circuito che consente di trasmettere solamente in un verso l'informazione ( da Master a Slave ) che vengono definiti appunto scegliendo di mettere allo stato BASSO DE ed RE per il Master ed allo stato ALTO per lo Slave.
Per le prime prove va bene, ovviamente, ma per poter testare meglio in tutti e due i "sensi di marcia", per non fare lo switch degli stati a mano, ho preferito montare un circuito basato su Arduino.

Ho quindi montato il circuito che dal lato master invia un messaggio contenente un carattere (1), poi si mette in ascolto, se riceve un carattere stabilito come ACK (7) fa lampeggiare il suo LED collegato al PIN13, altrimente ripete l'invio del messaggio.

Dal lato Slave, il modulo sta sempre in ascolto, quando riceve un messaggio stabilito (1) si mette in trasmissione, mandando un segnale convenzionale (7) per confermare l'avvenuta ricezione, e poi torna subito in ricezione per attendere il nuovo messaggio.

Prendendo l'alimentazione dei moduli RS485 direttamente da Arduino, ho lasciato fare lo switch degli stati al PIN 3 ed ho utilizzato questi due programmini per gestire la comunicazione:

**************************************

// software per lo SLAVE

void setup() {
Serial.begin(57600);
pinMode(3, OUTPUT);
pinMode(13, OUTPUT);
digitalWrite(3,LOW);
digitalWrite(13,LOW);
}

void loop() {
while (Serial.available()) {
digitalWrite(3,LOW);
delay(1);
char c = Serial.read(); //gets one byte from serial buffer
if (c == '1') {

// fai quello che devi fare
digitalWrite(3,HIGH);
delay(10);
Serial.print(7);
delay(1);
digitalWrite(3,LOW);

}else{

// fai quello che devi fare se non e' arrivato il carattere giusto
for(int i=1 ; i=10 ; i++){
digitalWrite(13,HIGH);
delay(100);
digitalWrite(13,LOW);
delay(100);
}
}
}

}

***********************************************************

// software per lo MASTER

void setup() {
Serial.begin(57600);
pinMode(3, OUTPUT);
pinMode(13, OUTPUT);
digitalWrite(3,HIGH);
digitalWrite(13,LOW);
}

void loop() {
// while (Serial.available()) {

digitalWrite(3,HIGH);
delay(10);
Serial.println(1);
delay(1);

digitalWrite(3,LOW);
delay(1);
char c = Serial.read(); //gets one byte from serial buffer
if (c == '7') {

// fai quello che devi fare
// Serial.print("sentito il ACK");
lampeggia();

}

}

}
void lampeggia(){
for(int i=1 ; i<3 i="" p=""> digitalWrite(13,HIGH);
delay(100);
digitalWrite(13,LOW);
delay(100);
}
}

Creare un server TFTP in 4 mosse su Ubuntu

Durante uno degli ultimi hack (peraltro tuttora in corso!) ho avuto la necessita' di creare un server tftp per poter far fare un veloce upload del nuovo firmware al mio device sotto tortura.

In pratica il server in oggetto e' un semplice server ftp automatico che mette a disposizione i file (in questo caso del nuovo firmware) a qualsiasi device che si colleghi con il protocollo tftp. Non e' previsto blocco di password, non e' previsto upload da parte del device, ma soltanto la semplice funzione di download alla connessione.
Avevo gia' fatto altre prove del genere in passato, per modificare il firmware dei vecchi telefonini WiFi Aladino, telefoni Voip che la Telecom commercializzava un decennio fa'.

Ok veniamo alle 4 mosse da percorrere per installare il server sul sitema Ubuntu e farlo girare.

Prima di tutto si dovra' scaricare il software necessario con apt-get


sudo apt-get install xinetd tftpd tftp

dopodiche' creiamo un file di configurazione con Vim (per esempio oppure con nano)

sudo vi /etc/xinetd.d/tftp

inserendo questi comandi

service tftp
{
protocol        = udp
port            = 69
socket_type     = dgram
wait            = yes
user            = nobody
server          = /usr/sbin/in.tftpd
server_args     = /tftpboot
disable         = no
}

Adesso creiamo la cartella che conterra' i file da condividere e sistemiamo i permessi con:

sudo mkdir /tftpboot
sudo chmod -R 777 /tftpboot
sudo chown -R nobody /tftpboot

ora si fara' ripartire il server appena creato con il comando

sudo service xinetd restart

Adesso possiamo gi' fare le prime prove inserendo nella cartella /tftpboot appena creata un file di test (per esempio proprio test )

e da un'altra macchina nella propria rete si potrà chiamare il nuovo server e prelevare il file test
cosi:

tftp IP_SERVER
tftp> get test
Sent 159 bytes in 0.0 seconds

tftp> quit

cat test