Da Kinect a Stampante 3D per paleontologia

Grazie ad un amico sono riuscito ad utilizzare una stampante a 3D.
Lo scopo era quello di, partendo da un fossile, effettuare una scansione 3D con Kinect e poi ottenere nuovamente un modello fisico mediante la stampante 3D

Kinect non e' molto adatto a questo scopo perche' ha un precisione sull'asse verticale di 1 mm e non per modelli piccoli si perde molta risoluzione

Inoltre, dato che la plastica per la stampa 3D e' costosa, mi e' stato concessa una prova su un modello molto ridotto ed alla risoluzione peggiore
La stampa e' durata una 40 (video in tempo estremamente accelerato)

Fotogrammetria da terra per geologia

Visti i due precedenti post (1 e 2) ho voluto provare a mettere alla prova il sistema su un problema geologico

Vicino a casa esiste questa vecchia cava di Macigno (o Pietra Serena)

il problema che mi sono posto e' stato quello di misurare l'orientazione dei due piani che emergono dal fronte di cava soltanto con l'utilizzo delle fotografie

Nella foto sottostante sono individuati i due angoli diedri da misurare (probabilmente si tratta di faglie)

L'area si trova all'interno di una proprieta' privata e comunque il fronte di cava non e' raggiungibile per una misura diretta

Mediante l'utilizzo di un comune telefono cellulare (Moto G) ho scattato una decina di foto dell'affioramento da una distanza calcolato mediante Carta Tecnica Regionale di circa 100 m

Sempre dalla stessa fonte si puo' calcolare (un po' grossolanamente ma la precisione non e' fondamentale) che la cava e' orientata lungo la direzione 60-240° di azimuth

Mediante VisualFSM sono riuscito a calcolare in modo non supervisionato la nuvola dei punti 

e tramite una opportuna rotazione si puo' stimare che l'angolo tra la superficie di faglia e il piano di cava e' di circa 30°. A questo punto si puo' stimare che l'orientazione del piano incognito e' di circa 30-210°

La stessa elaborazione puo' essere fatta , con risultato graficamente piu' gradevoli, anche con AGI Soft Photoscan

ISCSI con FreeNas e Debian

In questo post viene descritto come utilizzare ISCSI con Debian. Per fare cio' e' necessario avere un NAS che offra servizi ISCSI
Per semplicita' ho usato Virtualbox configurando una macchina virtuale con un disco di sistema su cui sara' installato FreeNas ed un disco che sara' condiviso mediante ISCI

L'isntallazione di FreeNas e' banale (ricordarsi di selezionare il primo disco come quello di sistema). Una volta riavviato il sistema viene mostrato l'indirizzo IP a cui far puntare il browser per l'amministrazione web. Il superutente e' root e la password e' quella che e' stata impostata in fase di installazione

La prima cosa da fare e' andare su Storage/Volumes ed importare il volume che corrisponde al disco secondario su /dev/sdb impostando anche un nome (nel caso t1)

Si va poi in Services/ISCSI/Portal/Add Portal settando un nome (lasciare la porta 3260 di default)

Si va poi in Services/ISCSI/Initiatiors e si imposta l'accesso a ALL (nella terminologia ISCSI initiators sono i client mentre i target sono i dischi di rete)

Si clicca quindi Services/ISCSI/Extents e si aggiunga una extent

E' il momento di impostare un target con Service/ISCSI/Targets/Add Target settando il portal group ed initiatori group

Infine si associa il target all'extent con Services/ISCSI/Associated Targets
Si avvia il servizio con Services/Control Services

Questa procedura e' descritta anche qui

Passando al lato client (che si trova nella stesssa sottorete) si deve prima installare il pacchetto open-iscsi

apt-get install open-iscsi


si effettua quindi la ricerca del servizio ISCSI sull'ip di Freenas


iscsiadm -m discovery -t st -p 192.168.43.104

iscsiadm -m node

iscsiadm -m node --taargetname "iqn.2011-03.org.example.istgit:dati" --portal "192.168.43.104:3260" --login

fatto cio' con il comando fdisk -l si vede comparire il device

che pero' non ha un filesytem

Si procede quindi con

fdisk /dev/sdb

creando una nuova partizione primaria e poi formattandolo e montandolo come un qualsiasi dispositivo

mkfs.ext4 /dev/sdb1

mount /dev/sdb1 /mnt

CloudPoint da fotogrammetria con AgiSoft Photoscan

Usando gli stessi dati del post precedente ho provato un software commerciale (Agisoft Photoscan) che ricrea modelli 3D da normali foto. Ogni commento mi sembra superfluo (vedi video)

CloudPoint da fotogrammetria

Mentre stavamo parlando dell'uso di Kinect per realizzare modelli 3D un amico mi ha parlato di fare la stessa cosa usando una comune macchina fotografica e la fotogrammetria. Di istinto ero un po' scettico ma ho comunque voluto dare un'occhiata a cosa trovavo su Internet

La mia attenzione e' stata catturata da VisualFSM un programma opensource che funziona su Windows, Mac e Linux (per gli ultimi si deve partire dai sorgenti mentre per Windows si puo' scaricare il compilato direttamente da qui o qui
Per semplicita' ho provato la versione Windows ATTENZIONE: per funzionare il programma ha bisogno delle librerie di CMVS che non sono comprese nel pacchetto (si devono scaricare i compilati da questo link  e porre i file cmvs.exe, genOption.exe e pmvs2.exe nel path di Windows ..io non per fare prima li ho messi direttamente in c:\windows\) ed i file ed i programmi devono essere messi all'interno di directory con nomi privi di caratteri speciali...C:\Documents and Settings\ non va bene)

Detto cio' ho fatto una decina di foto a questo edificio da diverse angolazioni

Le operazioni con VisualFSM sono molto semplici

1) Prima si importano le foto da File/Open Multi Image
2) Si effettua il confronto a coppie delle immagini con SfM/Pariwise Matching/Compute Missing Matching
3) SfM/Reconstruct Sparse
4) SfM/Reconstruct Dense (viene chiesto dove salvare un file .nvm

come si osserva non si fornisce nessuna informazioni geometrica
Dopo un po' di calcoli e se le immagini sono sufficienti per la ricostruzione viene creati una serie di file che saranno poi gestiti mediante Meshlab (per riferimento si vada a questo link)3

Questa e' la ricostruzione. La nuvola dei punti non e' molto densa ma per essere il primo tentativo non e' male (si veda per confronto la prima foto)

Ruotando l'immagine si osserva che l'angolo dell'edificio e' stato ricostruito in modo corretto con un angolo molto prossimo ai 90°

Un aspetto interessante e' che questo approccio puo' essere utilizzato anche con immagini riprese da droni

LVM su Linux

In questo post viene indicata la procedura per creare un volume LVM (ovvero un metodo per gestire in modo piu' flessibile le partizioni e per poter aggiungere spazio a volumi senza essere limitati dalla dimensione fisica dei dischi rigidi)

Per questa prova, per semplicita', e' stata usata Ubuntu virtualizzata su Virtualbox aggiungendo due dischi fissi (oltre a quello dove e' installato il sistema) da configurare come LVM

Per prima cosa devono essere installati i seguenti pacchetti per la gestione di LVM

apt-get install lvm2 dmsetup mdadm reiserfsprogs xfsprogs
---------------------------------------------------------------------
root@luca-VirtualBox:/home/luca# fdisk -l

Disk /dev/sda: 22.0 GB, 22011707392 bytes
255 heads, 63 sectors/track, 2676 cylinders, total 42991616 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x0007fa80

   Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *        2048    34603007    17300480   83  Linux
/dev/sda2        34605054    42989567     4192257    5  Extended
/dev/sda5        34605056    42989567     4192256   82  Linux swap / Solaris

Disk /dev/sdb: 2147 MB, 2147483648 bytes
255 heads, 63 sectors/track, 261 cylinders, total 4194304 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000

Disk /dev/sdb doesn't contain a valid partition table

Disk /dev/sdc: 2147 MB, 2147483648 bytes
255 heads, 63 sectors/track, 261 cylinders, total 4194304 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000

Disk /dev/sdc doesn't contain a valid partition table

---------------------------------------------------------------------

Il primo passo e' creare una partizione in  in /dev/sdb con

fdisk /dev/sdb

creando una partizione primaria (tasti n/p/1) e cambiando il formato in Linux LVM (tasti t e parametro 8e). Per confermare ed uscire tasto w

Verra' creato un device in /dev/sdb1 e si puo' procedere a configurare LVM. Lo schema e' il seguente

Ripreso da https://www.howtoforge.com/linux_lvm

Si vede come il volumi fisici sono svincolati dalla configurazione logica della struttura dati
Nel caso in esame verra' creato un solo gruppo fileserver ed un solo volume logico backup

Si procede a creare il volume fisico ed il gruppo "fileserver"

root@luca-VirtualBox:/home/luca# pvcreate /dev/sdb1

  Physical volume "/dev/sdb1" successfully created

root@luca-VirtualBox:/home/luca# vgcreate fileserver /dev/sdb1

  Volume group "fileserver" successfully created

si crea quindi il volume logico backup dentro filesever e si impone una dimensione di 1 Giga

root@luca-VirtualBox:/home/luca# lvcreate -L 1G -n backup fileserver

  Logical volume "backup" created

 si deve poi formattare il nuovo dispositivo

root@luca-VirtualBox:/home/luca# mkfs.ext4 /dev/fileserver/backup 

mke2fs 1.42.9 (4-Feb-2014)

Etichetta del filesystem=

OS type: Linux

Dimensione blocco=4096 (log=2)

Dimensione frammento=4096 (log=2)

Stride=0 blocks, Stripe width=0 blocks

65536 inodes, 262144 blocks

13107 blocks (5.00%) reserved for the super user

Primo blocco dati=0

Maximum filesystem blocks=268435456

8 gruppi di blocchi

32768 blocchi per gruppo, 32768 frammenti per gruppo

8192 inode per gruppo

Backup del superblocco salvati nei blocchi: 

        32768, 98304, 163840, 229376

Allocating group tables: fatto                           

Scrittura delle tavole degli inode: fatto                           

Creating journal (8192 blocks): fatto

Scrittura delle informazioni dei superblocchi e dell'accounting del filesystem: fatto

e si monta il filesystem

root@luca-VirtualBox:/home/luca# mkdir /media/lvm

root@luca-VirtualBox:/home/luca# mount /dev/fileserver/backup /media/ lvm/  

mediante df si vede la nuova situazione dei dischi con il disco lvm mappato

root@luca-VirtualBox:/home/luca# df

Filesystem                    1K-blocks    Used Available Use% Mounted on

/dev/sda1                      16897884 7767344   8249132  49% /

none                                  4       0         4   0% /sys/fs/cgroup

udev                            2013212       4   2013208   1% /dev

tmpfs                            404804     956    403848   1% /run

none                               5120       0      5120   0% /run/lock

none                            2024004     152   2023852   1% /run/shm

none                             102400      20    102380   1% /run/user

/dev/mapper/fileserver-backup    999320    1284    929224   1% /media/lvm

Fino a quindi niente di eccezionale. Con il sistema precedente creiamo una partizione primaria in formato LVM anche su /dev/sdc

Disk identifier: 0x0007fa80

   Device Boot      Start         End      Blocks   Id  System

/dev/sda1   *        2048    34603007    17300480   83  Linux

/dev/sda2        34605054    42989567     4192257    5  Extended

/dev/sda5        34605056    42989567     4192256   82  Linux swap / Solaris

Disk /dev/sdb: 2147 MB, 2147483648 bytes

22 heads, 16 sectors/track, 11915 cylinders, total 4194304 sectors

Units = sectors of 1 * 512 = 512 bytes

Sector size (logical/physical): 512 bytes / 512 bytes

I/O size (minimum/optimal): 512 bytes / 512 bytes

Disk identifier: 0xb4504b1b

   Device Boot      Start         End      Blocks   Id  System

/dev/sdb1              63     4194303     2097120+  8e  Linux LVM

Disk /dev/sdc: 2147 MB, 2147483648 bytes

22 heads, 16 sectors/track, 11915 cylinders, total 4194304 sectors

Units = sectors of 1 * 512 = 512 bytes

Sector size (logical/physical): 512 bytes / 512 bytes

I/O size (minimum/optimal): 512 bytes / 512 bytes

Disk identifier: 0x70badccc

   Device Boot      Start         End      Blocks   Id  System

/dev/sdc1            2048     4194303     2096128   8e  Linux LVM

Si deve poi aggiungere il disco sdc al gruppo fileserver

root@luca-VirtualBox:/home/luca# vgextend fileserver /dev/sdc1 

  No physical volume label read from /dev/sdc1

  Physical volume "/dev/sdc1" successfully created

  Volume group "fileserver" successfully extended

e si ridimensiona il volume logico da 1 a 2G

root@luca-VirtualBox:/home/luca# lvextend -L2G /dev/fileserver/backup 

  Extending logical volume backup to 2,00 GiB

  Logical volume backup successfully resized

e si estende il file system
root@luca-VirtualBox:/home/luca# resize2fs /dev/fileserver/backup
resize2fs 1.42.9 (4-Feb-2014)
Filesystem at /dev/fileserver/backup is mounted on /media/lvm; on-line resizing required
old_desc_blocks = 1, new_desc_blocks = 1
The filesystem on /dev/fileserver/backup is now 524288 blocks long.

abbiamo terminato. Adesso tramite il comando df si vede che il disco LVM ha aumentato le proprie dimensioni

root@luca-VirtualBox:/home/luca# df

Filesystem                    1K-blocks    Used Available Use% Mounted on

/dev/sda1                      16897884 7667928   8348548  48% /

none                                  4       0         4   0% /sys/fs/cgroup

udev                            2013212       4   2013208   1% /dev

tmpfs                            404804     960    403844   1% /run

none                               5120       0      5120   0% /run/lock

none                            2024004     152   2023852   1% /run/shm

none                             102400      20    102380   1% /run/user

/dev/mapper/fileserver-backup   2031440    1536   1919152   1% /media/lvm

Video.js

Dopo l'esperienza con JwPlayer () e con JPlayer (), mi sono ritrovato a provare per un progetto di pubblicazione video Video.JS

Il problema maggiore per Jwplayer e' la necessita' di una chiave anche per la versione Free ed il logo sempre presente nell'angolo in alto a sinistra che puo' non essere gradito dai clienti.Peraltro la gestione delle skin su Jwplayer non e' proprio semplicissima (cambia da versione a versione) e nella versione free e' molto limitata

Video.JS e' invece un prodotto open source senza particolari limitazioni e con la presenza di una barra semi trasparente che non rende necessario portare la barra degli strumenti al di fuori della finestra del video

L'installazione e' banale in quanto basta copiare il pacchetto e modificare il file html modificando il puntamento del link del video)

Le configurazioni dell'aspetto della barra sono gestiti tutti a livello di CSS

Essendo un progetto in HTML5 non sono fiducioso che funzioni su tutti i browser ma almeno su Chrome 40, Firefox 33.1 ed Internet Explorer 8 e' stato testato e funziona

PCDuino

Grazie ad un prestito sono riuscito a provare la scheda PCDuino, un calcolatore basato su Arm che unisce due anime in una un quanto e' possibile utilizzarla come una Arduino

Di fatto la scheda si pone a meta' strada come prezzo tra una Raspberry ed una Arduino YUN

Sul modello che ho avuto in prova PCDuino Nano v3 e' disponibile una uscita HDMI, WiFi, connettore SATA, porta ad infrarossi, lettore microSD, Connettore Ethernet

Il sistema operativo non e' contenuto nella SD ma e' su una flash memory (al contrario di Raspberry).

Al boot compaiono due pinguini a testimoniare come il processore sia dual core

La distribuzione installata e' una Linaro-Alip (specifica per Arm che usa apt come gestore dei pacchetti) e LXDE come DM

Le impresssioni di uso di Linux sono decisamente buone ed e' molto piu' fluido ed usabile che su Raspberry

Per programmare la parte Arduino e' presente la IDE preinstallata che comunica su /dev/ttyS1 (di fatto non e' possibile programmare direttamente Arduino via cavo come si fa con le schede tipo Uno e Due ma si deve programmare direttamente da dentro PCDuino)

Al contrario di Raspberry sono presenti, oltre alle porte GPIO accessibili anche tramiti la parte Linux, anche delle porte analogiche con risoluzione anche fino a 12 bit

Sono presenti anche alcuni pulsanti fisici (tra cui quello di reset) al contrario di quanto su Raspberry

Considerando il prezzo vale veramente la spesa e non mi risulta chiaro il motivo della scarsa popolarita' di questo dispositivo (anche in funzione del prezzo di poco superiore a Raspberry a fronte di una dotazione hardware nettamente migliore, anche per la sola presenza del WiFi)

Eagle has landed

Piu' o meno per me e' stata un'esperienza simile a spedire qualcosa sulla Luna.
Un paio di settimane fa un mini computer e' partito da Firenze (configurato per connettersi in automatico ad una VPN in cui il server e' il wrtg54 visto qui) destinazione vulcano Copahue per essere attaccato ad un rete di monitoraggio di cui non conosco i settaggi e le impostazioni di protezione.
Sul posto non c'e' nessuno che poteva modificare i settaggi per cui doveva funzionare alla prima e solo attaccando l'alimentazione ed il cavo di rete

Dopo un viaggio di 12280 km (per lo meno sulla geodetica) ed un paio di settimana di attesa e' arrivata la mail che il computer era stato connesso alla rete e qualche decina di secondi dopo e' comparso nel log del server vpn diventando quindi amministrabile a distanza

XML 2 CSV con XQuery

Il problema di oggi e' prendere un file xml molto lungo, estrarne alcuni campi in base ad alcune regole e poi effettuarne l'esportazione in CSV


La prima cosa che  mi e' venuta in mente e' stata quella di importare l'XML in Mysql, agire con qualche query ed esportare il risultato (Mysql ha filtri nativi sia per xml che csv) ma poi mi sono messo a cercare ed ho trovato XQuery, un linguaggi similSQL che agisce sui file testo xml

Una delle implementazioni di questo linguaggio si trova in xqilla, facilmente reperibile nei repository di Debian

apt-get install xqilla

per semplificare le cose mostrero' come funziona su un file di piccole dimensioni (visualizzato in Firefox che ha un discreto visualizzatore di file xml)

Xqilla non permette di avere un uso interattivo e si deve creare un file con lo script Xquery. L'esempio lo riporto di seguito

esempio.xq
-------------------------------------------------------------
for $x in doc("eventi.xml")/Root/Evento
where $x/Durata>15
return
concat("luca;",
$x/Titolo/text(),
";",
$x/Luogo/text())
-------------------------------------------------------------

la sintassi e' piuttosto semplice
nella prima riga viene caricato il file xml con la gerarchia di interesse
nella seconda riga vengono selezionati i record con la durata maggiore di 15
nelle righe successive avviene l'output concatenando una stringa e due campi (senza specifiche viene mostrato il record con i suoi tag per esempio <Luogo>Firenze</Luogo> mentre con la specifica /text() si ottiene il contenuto del record senza i tag)

lanciando il comando
xqilla esempio.xq

il risultato sara'
luca;Calcio in costume;Firenze

comodo, veloce e scriptabile

FailOver con Corosync/Pacemaker per Apache su Debian/WmWare

Il failover e' un sistema per permettere la continuita' di un servizio di rete mediante due server (di cui uno attivo ed uno passivo) che si sostituiscono nel caso in cui il sistema primario non funzioni in modo corretto

Attenzione : Il sistema indicato gestisce solo i servizi ma non la sincronizzazione dei dati

Per la configurazione e' stata seguita (e parzialmente modificata) la guida a questo link

Per simulare il sistema sono stati creati due server virtuali (deb1 e deb2) ed un client su WMware Player. I server sono stati configurati in modo identico partendo da una Debian base ed installando i pacchetti corosync, pacemaker ed apache2.

Il servizio ad alta disponibilita' (HA) sara' disponibile su 192.168.32.150

deb1 : 192.168.32.138
deb2 : 192.168.32.139
debclient : 192.168.32.140
HA : 192.168.32.150

la prima verifica e' che le macchine siano in grado di pingarsi reciprocamente

per prima cosa e' stato modificato il file /etc/hosts per far risolvere il nome in modo statico dell'altra macchina

per esempio su deb1 e' stato aggiutno
192.168.32.139 deb2.nearbee.it deb2

cosi' da deb1 si puo' pingare direttamente deb2

poi e' stato modificato il file /etc/corosync/corosync.conf  utilizzando il set di indirizzi dei server

interface {
ringnumber: 0
bindnetaddr: 192.168.32.0
 mcastaddr: 226.94.1.1 mcastport: 5405 }

in seguito si verifica /etc/corosync/corosync.conf  abbia ver=0 (di default e' gia' cosi') e si imposta START=yes su /etc/default/corosync

si effettuano le stesse modifiche sia su deb1 che su deb2 e poi si avvia il servizio
/etc/init.d/corosync start

con il comando
crm_mon -1
si devono quindi vedere i due server online

visto che si tratta di una configurazione a due macchine si impostano i seguenti parametri

crm configure property stonith-enabled=false
crm configure property no-quorum-policy=ignore

a questo punto viene impostato l'indirizzo HA 

crm configure primitive VIP ocf:IPaddr2 params ip=192.168.32.150 nic=eth0 op monitor interval=10s 

si verifica che l'ip virtuale 192.168.32.150 sia pingabile

si imposta quindi quale servizio deve essere impostato come high availability (nel nostro caso apache)

(HA-apache e' un nome che puo' essere impostato a piacere

crm configure primitive HA-apache lsb:apache2 op monitor interval=15s
(puo' essere configurato qualsiasi servizio presente in /etc/init.d/)

per verificare che il servizio sia stato modificato usare crm_mon -1

per semplicita' si puo' modificare il file index.html in /var/www inserendo il nome del server per rendere chiaramente visibile quale macchina sta rispondendo

a questo punto il sistema fail over e' completo

con i server deb1 e deb2 accesi e funzionanti, si puo' dal client collegarsi ad 

http://192.168.32.150

e rispondera' il server deb1. Spengendo la macchina virtuale deb1, l'indirizzo virtuale 192.168.32.150 sara' acquisito da deb2, collegandosi quindi ad http://192.168.32.150 sara' la macchina di backup a rispondere

And Now for Something Completely Different

Caserma dei pompieri 

Meccanici di auto

Batman e Joker

Capitan America

Star Wars (Yoda sulla sinistra)

RSync Linux to Mac

Dovendo scambiare qualche tera di dati tra una macchina Linux ed un Mac Os X Server 10.9 ho provato a lanciare un rsync al posto di un piu' comune scp

Il primo problema individuato e' stato che su Linux era installata una versione 3.1.1 di rsync mentre su Mac era presenta una vetusta 2.6.9 (rilasciata nel 2006!!!). Cioe' creava conflitto nella trasmissione dei dati

Grazie al progetto Rudix e' stato possibile installare la versione piu' recente e rendere compatibili nel numero di versione la parte Linux e Mac

Rilanciato lo scambio dati, questo e' iniziato ma non riusciva a copiare alcuni file perche' la codifica dei caratteri del nome file era in UTF-8 multibyte (caratteri speciali in particolar modo lettere accentate)

Uno dei suggerimenti trovati su Internet era quello di definire lo switch

--iconv=utf8,latin1

ma all'atto pratico non ha funzionato (alcuni utenti riportano che sia un problema specifico dello scambio da Linux a Mac

Ha invece avuto successo effettuare prima una conversione dei nomi prima di rsync con il comando

convmv -f latin1 -t utf8  --notest file_name

(l'ultimo switch e' quello che rende operativo il cambio di codifica, senza questo viene solo effettuata una simulazione)

Arduino YUN e Internet Dongle

Nel caso di non disporre di una connessione via cavo o via WiFi, Arduino YUN puo' comunque trasmettere i dati connettendo un internet dongle (nel caso specifico un Hauwei E172 targato Vodafone, anno 2008)

La configurazione e' piuttosto semplice perche' puo' essere effettuata mediante la pagina di amministrazione web

Per fare cio' si devono pero' installare i seguenti pacchetti
opkg install luci-proto-3g (per la parte web)

opkg install kmod-usb-serial-option kmod-usb-serial-wwan luci-proto-3g usb-modeswitch-data usb-
modeswitch (per la gestione dell'harware)

A questo punto si va in Luci Menu e si crea una nuova interfaccia

Si configura la porta (per me /dev/ttyUSB0 visibile da logread) e le impostazioni di rete

e tornando indiestro si attiva l'interfaccia di rete

GNUPG

Per inviare mail criptate end-to-end oppure per siglare una mail in modo che sia impossibile modificarla la soluzione piu' semplice e' quella di usare la segnatura GPG (il corrispondente open della PGP)

la procedura per creare le chiavi su Linux da linea di comando e' la seguente. Conviene utilizzare la chiave a 4096 bit RSA/DSA

luca@debian:~$ gpg --gen-key
gpg (GnuPG) 1.4.12; Copyright (C) 2012 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

gpg: directory `/home/luca/.gnupg' created
gpg: creato un nuovo file di configurazione `/home/luca/.gnupg/gpg.conf'
gpg: ATTENZIONE: le opzioni in `/home/luca/.gnupg/gpg.conf' non sono ancora attive durante questa
esecuzione del programma
gpg: portachiavi `/home/luca/.gnupg/secring.gpg' creato
gpg: portachiavi `/home/luca/.gnupg/pubring.gpg' creato
Per favore scegli che tipo di chiave vuoi:
   (1) RSA and RSA (default)
   (2) DSA and Elgamal
   (3) DSA (firma solo)
   (4) RSA (firma solo)
Cosa scegli? 1

RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048) 4096

La dimensione richiesta della chiave è 4096 bit
Per favore specifica per quanto tempo la chiave sarà valida.
         0 = la chiave non scadrà
      <n>  = la chiave scadrà dopo n giorni
      <n>w = la chiave scadrà dopo n settimane
      <n>m = la chiave scadrà dopo n mesi
      <n>y = la chiave scadrà dopo n anni
Chiave valida per? (0)



You need a user ID to identify your key; the software constructs the user ID
from the Real Name, Comment and Email Address in this form:
    "Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>"

Nome e Cognome: Luca Innocenti
Indirizzo di Email: lucainnoc@gmail.com
Commento:
Hai selezionato questo User Id:
    "Luca Innocenti <lucainnoc@gmail.com>"

Modifica (N)ome, (C)ommento, (E)mail oppure (O)kay/(Q)uit?

gpg: /home/luca/.gnupg/trustdb.gpg: creato il trustdb
gpg: key 48CFC879 marked as ultimately trusted
chiavi pubbliche e segrete create e firmate.

gpg: controllo il trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
pub   4096R/48CFC879 2015-02-13
      Key fingerprint = E656 AD90 9447 4312 9C70  1773 C490 96A0 48CF C879
uid                  Luca Innocenti <lucainnoc@gmail.com>
sub   4096R/D7979695 2015-02-13
-----------------------------------------------------------------------

KeyID = 48CFC879
Key fingerprint = E656 AD90 9447 4312 9C70  1773 C490 96A0 48CF C879

 ----------

A questo punto sono state create la chiave privata (da tenere riservata) e quella pubblica da distribuire agli altri per poterci inviare messaggi codificati. Evidenziate in giallo i codici delle chiavi
Si puo' verificare il contenuto del portachiavi GPG mediante

luca@debian:~$ gpg --list-keys
/home/luca/.gnupg/pubring.gpg
-----------------------------
pub   4096R/48CFC879 2015-02-13
uid                  Luca Innocenti <lucainnoc@gmail.com>
sub   4096R/D7979695 2015-02-13
-------------------------------------------------------------

Per distribuire la chiave pubblica si puo' inviare il file esportato
gpg -armor --output pubkey.txt --export 48CFC879

oppure si puo' inviare la chiave ai server pubblici in cui sono salvate le rubriche delle chiavi (chi vorra' inviarci una mail criptata puo' cercare le nostre credenziali su questi server)

 gpg --send-keys --keyserver hkp://subkeys.pgp.net 48CFC879

gpg --import keyserver2.pgp.comGlobalDirectoryKey.asc
gpg: key CA57AD7C: public key "PGP Global Directory Verification Key" imported
gpg: Numero totale esaminato: 1
gpg:              importate: 1  (RSA: 1)
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u

Per effettuare il backup e copiare le chiavi si puo' seguire

luca@debian:~/Scaricati$ gpg -ao backup_pub.key --export 48CFC879
luca@debian:~/Scaricati$ gpg -ao backup_priv.key --export-secret-keys D7979695

i file delle chiavi sono tutti contenuti nella propria home/.gnupg

/home/luca/.gnupg/pubring.gpg
-----------------------------
pub   4096R/48CFC879 2015-02-13
uid                  Luca Innocenti <lucainnoc@gmail.com>
sub   4096R/D7979695 2015-02-13

pub   2048R/CA57AD7C 2004-12-06
uid                  PGP Global Directory Verification Key
uid                  [jpeg image of size 3400]
uid                  DNR KS1 <do-not-reply@keyserver1.pgp.com>
uid                  DNR-KS2 <do-not-reply@keyserver2.pgp.com>



se si vuole seguire la via semplice invece si puo' usare l'estensione EnigmaMail per Thunderbird. Una volta installata mediante Strumenti/Componenti Aggiuntivi basta seguire i menu' di guida per creare le chiavi GPG e le impostazione di base di invio delle mail (vale per Mac, Windows e Linux)

Con questo sistema e' gestita in modo automatico la pubblicazione di chiavi sui server

Su Gmail esiste una estensione chiamata Mymail-Crypt che pero' mi ha dato problemi con le chiavi a 4096 bit (sembra che accetti solo le chiavi a 2048 bit)

JWPlayer

Tempo fa avevo provato JPlayer, un plugin JQuery per pubblicare video ed audio su web
Adesso e' il tempo di JWPlayer

l'uso e' intuitivo, basta solo indicare la posizione del file, una eventuale immagine di fermoimmagine
---------------------------------------------------------------------------
<script src="jwplayer.js" ></script>
<div id="myElement">Loading the player...</div>

<script type="text/javascript">
    jwplayer("myElement").setup({
        file: "blue_bossa.mp4",
        image: "vlcsnap.png",
width: 640,
        height: 360
    });
</script>
---------------------------------------------------------------------------

il progetto completo puo' essere scaricato da 

https://drive.google.com/file/d/0B_BeE7yoBqdHYWRpMXN1c1ItaTA/view?usp=sharing
(video ripreso da http://blog.naver.com/silverstarca)

AGGIORNAMENTO
Per poter inserire il player sul proprio server Web e' necessario inserire la chiave che si ottiene registrandosi sul sito di jwplayer

Rsync senza password per backup su macchine differenti

Supponiamo di avere due macchine, una di produzione e l'altra di backup, che devono condividere gli stessi dati o per lo meno la seconda macchina deve funzionare come backup del server principale

Il metodo piu' semplice e' utilizzare il comando rsync con lo scambio delle chiavi in modo da non necessitare l'introduzione di una password (per semplicita' su entrambe le macchine ci sara' lo stesso utente)

Si testa prima la connessione copiando i dati dal server principale (192.168.0.1) a quello di backup 192.168.0.2 (ci si mette quindi nella shell del server principale)

rsync -avz -e ssh /home/luca/ luca@192.168.0.2:/home/luca/backup

in questo modo i file della home dell'utente luca sul server sono copiati sulla macchina remota. Si deve inserire manualmente la password

Per evitarlo, stando nella shell del server principale, si creano le chiavi ssh con 

ssh-keygen

(si puo' digitare enter alla richiesta della passphrase)

si copiano quindi le chiavi sul server di backup

ssh-copy-id -i /home/luca/.ssh/id_rsa.pub 192.168.0.2

se ha funzionato possiamo loggarci in ssh come luca da 192.168.0.1 a 192.168.0.2 senza digitare password

ssh 192.168.0.2

terminato cio' se digitiamo di nuovo il comando
rsync -avz -e ssh /home/luca/ luca@192.168.0.2:/home/luca/backup

non verra' richiesta la password, cosa particolarmente utile se si mette la procedura in cron

Port Knocking

Stanco di aver sempre qualcuno che prova ad entrare sul servizio SSH del server mi sono deciso ad implementare il Port Knocking. In estrema sintesi con questo sistema e' possibile modificare le regole del firewall dall'esterno in modo da esporre un servizio che normalmente e' stato mascherato dal firewall e non ammette connessioni. Il trucco si basa sull'invio di una sequenza di pacchetti codificati che vengono letti da un demone sulla macchina che agisce poi in base a regole predefinite

Partiamo da un server in cui siano attive regole di firewall per filtrare tutto il traffico tranne quello entrante su porta 80 ma che comunque abbia attivo ma filtrato un servizio SSH. L'idea e' quello di usare Port Kocking per connettersi dall'esterno su SSH

con questi comandi viene ammesso tutto il traffico su localhost e viene droppato tutto il traffico dall'esterno ad eccezione di quello su porta 80

iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -j DROP

a questo punto si puo' installare il demone per il Port Knocking con

apt-get install knockd

una volta installato il demone non parte in autoesecuzione. Per prima cosa si deve configurare il comportamento dal file /etc/knockd.conf

I numeri della sequenza dovranno esssere specifici per la macchina in uso in quanto corrispondono alla chiave per attivare/disattivare il servizio (non e' necessario che la chiave per disattivare il servizio sia la medesima ma invertita  di quella per attivarlo). Ogni numero corrisponde ad una richiesta su una porta differente (attenzione, se c'e' a monte un firewall che prefiltra il traffico il trucco del port knocking potrebbe non funzionare)

------------------------------------------------------------------------
[options] 

 UseSyslog 

 [openSSH] 

 sequence = 1234,5678,9101 

 seq_timeout = 5 

 command = /sbin/iptables -A INPUT -s %IP% -p tcp --dport 22 -j ACCEPT 

 tcpflags = syn 

 [closeSSH] 

 sequence = 1019,8765,4321 

seq_timeout = 5
command = /sbin/iptables -D INPUT -s %IP% -p tcp --dport 22 -j ACCEPT 

 tcpflags = syn

------------------------------------------------------------------------

come si vede la regola di iptables semplicemente apre la connessione sulla porta 22 per l'ip da cui e' stata riconosciuta la giusta sequenza di bussate. 

Per mandare il servizio in esecuzione automatica si deve settare ad 1 START_KNOCKD in /etc/default/knockd (oppure si avvia a mano il servizio con service knockd start)

fatto partire il servizio si puo' sperimentare con il client

Il comando apt-get install knockd installa oltre al server anche il client per cui si puo' ripetere l'installazione sulla macchina da cui ci si vuole connettere

il comando e' il seguente. Vengono concantenati insieme il  knock porting e l'avvio della sessione SSH

knock ip_server 1234 5678 9101 && ssh luca@ip_server