Nota: Per a veure tota la documentació al complet podeu baixar el PDF (RaspiSecureSystem.pdf).
Projecte per a l'especialitat d'IT de la carrera de Grau en Enginyeria Informàtica de la FIB, que consisteix en crear un petit sistema de seguretat utilitzant una Raspberry Pi (a partir d'ara, Raspi), una càmera IP, un Arduino i varis sensors.
Aquest sistema ens permetrà veure què passa a la nostra casa o habitació des d'una pàgina web, i gràcies a un sensor de movient podrem fer que la càmera faci una foto i ens l'envii per correu o ens avisi amb una notificació al mòbil.
De la mateixa manera farem servir un sensor de temperatura que ens podrà servir com a "detector d'incendis", i podrem fer també que si passa d'una certa temperatura ens avisi d'alguna manera. Afegirem també l'opció de poder encendre o apagar alguns llums remotament (via web), per si arribem tard a casa poder "fer veure" que hi ha algú.
Tant l'accés a la càmera com controlar els llums també es podrà fer des d'una aplicació mòbil.
Els materials que s'han fet servir han estat:
- Raspberry Pi (model 1 B)
- Càmera IP (Dlink DCS-932L)
- Arduino (Mega)
- Targeta de memòria SD de 32GB classe 10
- Sensor de temperatura
- Sensor de moviment
L'índex del contingut d'aquest document és el següent:
A continuació es detalles els passos que s'han seguit per tal de poder congifurar la Raspberry i la càmera IP, ja que de l'APP trobarem el codi a la carpeta Android, igual que els codis d'Arduino i de la web.
La Raspi és el nucli del nostre sistema, pel que és la que més treball requereix de configuració. Els passos que s'han seguit són:
- Instal·lar i preparar el SO
- Assignar una IP estàtica (3 opcions)
- Canviar el port SSH (Opcional)
- Generar una clau SSH a un dispositiu "client" (Opcional)
- Instal·lar i configurar no-ip
- Obrir els ports del router
- Instal·lar i configurar un servidor FTP (Opcional)
- Instal·lar un servidor Web (2 opcions)
- Instal·lar MySQL y phpMyAdmin
- Configurar notificacions amb l'API de Pushover
- Configurar notificacions per Telegram (Opcional)
- Enviar notificacions quan algú fa login
El SO escollit per aquest projecte ha estat Raspbian versió "Pixel", una distribució Linux basada en Debian-Jessie i adaptada pel chip ARM de la Raspi. Per instal·lar el SO ens hem servit de l'eina que ens proporciona la comunitat de Raspberry, anomenada NOOBS, el que ens permet instal·lar el sistema d'una forma senzilla.
El primer que hem de fer és baixar NOOBS de la pàgina de Raspberry Pi i descomprimir-lo. A continuació hem de donar format a la targeta; per això podem fer servir l'eina SDFormatter, oficial de SD Association.
Una vegada tenim la targeta formatejada i NOOBS descomprimit, copiem tot el contingut de la carpeta NOOBS dins de la targeta.
COMPTE: NO copiar la carpeta com a únic arxiu, sino tots els arxius que trobem dins de la mateixa.
Per fer la instal·lació ens ajudarem d'una pantalla amb entrada HDMI, un teclat i un ratolí. Connectem tots els perifèrics a la Raspi i la connectem a la corrent. Després d'uns moments ens apareixerà una pantalla on ens demana quin sistema volem instal·lar. Seleccionem Raspbian i cliquem "Install". Aquest procés pot tardar entre 20 i 30 minuts.
Quan la instal·lació hagi acabat, reiniciem el sistema i ja podrem arrencar Raspbian normalment.
Des del menú d'aplicacions anirem a Preferences --> Mouse and Keyboard Settings, i posarem el teclat en Espanyol (Català).
A continuació anirem a Preferences --> Raspberry Pi Configuration, modificarem el password, i marcarem l'opció de Boot que diu To CLI. Això farà que quan arrenqui la Raspi no carregui l'entorn gràfic, ja que normalment no el farem servir i així tenim més recursos disponibles.
En cas que vulguem accedir a l'entorn gràfic (si tenim la Raspi conectada a una tele o pantalla, per exemple), ho podrem fer amb la comanda startx
startx
De moment encara mantenim la pantalla, teclat i ratolí, ja que ens queda fer algunes configuracions.
###2. Assignar IP estàtica
Una part important i que dóna sentit a una Raspi és el fet de poder accedir a ella des de qualsevol lloc a través d'un terminal. Això ho podem fer sempre i quan sapiguem la seva adreça IP però, com sabem, aquesta pot canviar si el router es reinicia o si reiniciem la Raspi. Per evitar-ho li assignarem una IP estàtica i així ens asegurarem que sempre té la mateixa.
Per fer això tenim varies opcions:
Abans de res ens connectem a la nostra WiFi, d'aquesta manera ja tindrem regisrat el SSID i Password, i a continuació obrim un terminal amb la combinació de tecles Ctrl+Alt+t. Podem fer-ho també des del menú d'aplicacions.
A continuació hem de modificar l'arxiu dhcpcd.conf
sudo nano /etc/dhcpcd.conf
Afegint al final el següent codi si volem fer la connexió per cable:
interface eth0
static ip_address=192.168.1.XX/24
static routers=192.168.1.1
static domain_name_servers=192.168.1.1
O aquest si la volem fer per WiFi:
interface wlan0
static ip_address=192.168.1.XX/24
static routers=192.168.1.1
static domain_name_servers=192.168.1.1
Sortim amb Ctrl+x, acceptem els canvis amb y, i premem enter.
NOTA: Substituim el valor XX per l'adreça que vulguem, tenint en compte de posar un valor que estigui fora del rang DHCP. Normalment es comencen a donar adreces a partir del número 33 (tot i que pot variar), però dificilment comença per adreces baixes. Això ens permet assignar sense cap problema adreces a partir de la 2 o la 3. Igualment, hem de posar l'adreça del router i DNS que correspongui amb el nostre router, i normalment sol ser 192.168.1.1 en els routers domèstics, però assegureu-vos abans per si de cas.
Una altra opció és modificar directament l'arxiu interfaces
sudo nano /etc/network/interfaces
I modifiquem les dades de wlan0 per les següents si farem servir el WiFi:
auto wlan0
allow-hotplug wlan0
iface wlan0 inet static
address 192.168.1.XX
netmask 255.255.255.0
gateway 192.168.1.1
wpa-passphrase wifi-password
wpa-ssid my-ssid
Canviant wifi-password pel password de la nostra xarxa, my-ssid pel nom de la nostra xarxa, i modificant el valor XX per l'adreça que volem.
O les dades de eth0 si ens connectarem per cable:
auto eth0
iface eth0 inet static
address 192.168.1.XX
netmask 255.255.255.0
gateway 192.168.1.1
Sortim amb Ctrl+x, acceptem els canvis amb y, i premem enter.
Ens queda encara una alternativa, que és fer servir l'arxiu wpa_supplicant.conf
sudo nano /etc/wpa_supplicant/wpa_supplicant.conf
Aquest arxiu és l'encarregat de guardar els noms i contrassenyes de les xarxes WiFi, i per tant haurem d'afegir al final la nostra xarxa si no ens hem connectat amb anterioritat a la xarxa WiFi. Si ja tenim una xarxa amb el nom i password correctes, no cal fer res:
network={
ssid="WiFi_name"
psk="Wifi_password"
}
Sortim amb Ctrl+x, acceptem els canvis amb y, i premem enter.
Ara anem a modificar l'arxiu interfaces
sudo nano /etc/network/interfaces
I canviem la part de wlan0 pel següent si farem servir la connexió WiFi:
allow-hotplug wlan0
iface wlan0 inet static
address 192.168.1.XX
netmask 255.255.255.0
gateway 192.168.1.1
wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf
O la part de eth0 si ens connectarem per cable:
auto eth0
iface eth0 inet static
address 192.168.1.XX
netmask 255.255.255.0
gateway 192.168.1.1
Com veiem, els canvis d'aquest arxiu son molt semblants a l'opció 2, però aquí no posem explícitament el nom i password de la nostra xarxa, sino que ens servim de l'arxiu wpa_supplicant.conf. Pensar a canviar el valor XX de l'adreça IP.
Una vegada modificada la configuració de la IP reiniciarem la Raspi:
sudo reboot now
I quan hagi tornat a arrencar, comprovarem que ens ha assignat l'adreça que li hem dit amb ifconfig:
ifcongif
En cas que no ho hagi fet, revisem els arxius que hem modificat per si ens hem errat en alguna cosa.
En aquest moment ja ens podem desfer de la pantalla, teclat i ratolí, ja que totes les comunicacions les farem per ssh. La manera d'accedir a la Raspi és, des d'un terminal de Linux/Mac teclejar el següent:
Ens demanarà la contrassenya que hem modificat al punt 1 (Mentre s'escriu la contrassenya no es veurà res per pantalla.) i ja estarem connectats a la Raspi.
Nota: Si fem servir Windows, hi podrem accedir mitjançant l'aplicació PuTTY.
Addicionalment podriem voler emprar un port SSH diferent de l'standart (per defecte és el 22). Això ens pot ser útil si volem accedir a la Raspi des de fora de casa i el port 22 ja està utilitzat, o per intentar tenir una mica més de seguretat evitant valors per defecte.
Per fer-ho modifiquem l'arxiu sshd_config
sudo nano /etc/ssh/sshd_config
Busquem la linia on indica el port i el canviem pel que ens interessi, ja sigui modificant la linia en qüestió o comentant aquesta i afegint una nova
#port 22
port 2234
Per comoditat, lo més pràctic és afegir 2 valors més al 22 inicial, així ens serà més fàcil d'associar el port a SSH, per exemple 2234, però podem posar el que vulguem (sempre i quan no estigui ja utilitzat)
Finalment reiniciem el servidor ssh
sudo service ssh restart
Una vegada fet el canvi, la manera d'accedir a la Raspi per terminal serà
ssh -p 2234 [email protected]
Sent XX l'adreça que li haurem donat a la Raspi en el punt 2.
Una opció interessant de connectar-nos a la nostra Raspi per SSH és mitjançant claus. Això ens permet una connexió més ràpida ja que no haurem d'introduir la nostra contrassenya cada vegada i, per extensió, més segura, i és necessària per realitzar certes accions (com còpies de seguretat en dispositius remots, com és el nostre cas, i que s'explicarà a l'apartat d'scripts).
Per aconseguir aquesta connexió, primer necessitem generar les claus tant públiques com privades des del dispositiu client, que en aquest cas serà el nostre portàtil (ja que la Raspi faria de "servidor"). Per això, des d'un terminal executem la següent comanda
ssh-keygen -t rsa
Una vegada executada ens farà algunes preguntes, però ens bastarà amb premer enter fins que ens mostri un missatge semblant al següent
ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/user/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/user/.ssh/id_rsa.
Your public key has been saved in /home/user/.ssh/id_rsa.pub.
The key fingerprint is:
4a:dd:0a:c6:35:4e:3f:ed:27:38:8c:74:44:4d:93:67 user@a
The key's randomart image is:
+--[ RSA 2048]----+
| .oo. |
| . o.E |
| + . o |
| . = = . |
| = S = . |
| o + = + |
| . o + o . |
| . o |
| |
+-----------------+
Això genera les claus públiques i privades del nostre dispositiu, i les guarda a /home/user/.sshd/id_rsa.pub i /home/user/.sshd/id_rsa respectivament.
Una vegada tenim les claus, executarem la següent comanda
ssh-copy-id [email protected]
Sent XX l'adreça que li haurem donat a la Raspi prèviament.
Segurament ens sortirà un missatge semblant al següent, ons ens demanarà acceptar la connexió i introduir la contrassenya
The authenticity of host '12.34.56.78 (12.34.56.78)' can't be established.
RSA key fingerprint is b1:2d:33:67:ce:35:4d:5f:f3:a8:cd:c0:c4:48:86:12.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '12.34.56.78' (RSA) to the list of known hosts.
[email protected]'s password:
Now try logging into the machine, with "ssh '[email protected]'", and check in:
~/.ssh/authorized_keys
to make sure we haven't added extra keys that you weren't expecting.
A partir d'ara, les connexions que es facin des del nostre dispositiu cap a la Raspi no requeriran de contrassenya.
NOTA: Si el que volem és guardar la clau per fer connexions des de fora de la xarxa, farem
ssh-copy-id [email protected]
Però com crear dominis i accedir des de fora de la xarxa local s'explica al següent punt.
Si el que volem fer és eliminar la clau que acabem de guardar a la nostra Raspi (per revocar l'accés automàtic, per exemple), el que farem serà obrir el següent fitxer
sudo nano ~/.ssh/known_hosts
Cercar la línia que correspon al nostre dispositiu (generalment serà la darrera línia del fitxer si no s'han afegit més claus) i l'esborrem.
A partir d'ara, ens tornarà a demanar contrassenya a cada connexió.
De la mateixa manera que les direccions IP locals poden canviar, també ho fan les direccions IP públiques, pel que potser que ara en tiguem una i demà una altra. Això és un problems si intentem accedir a la Raspi des de fora de la xarxa local, ja que no sabrem quina direcció tenim assignada. Per evitar aquest problema ens ajudarem del servei no-ip.
No-ip és un servidor DNS que el que fa és traduir una direcció web (http://www.google.com) a la seva IP pública (http://74.125.224.72, per exemple). Així, el que farem ara serà accedir a noip.com, crear un compte (gratuit) i registrar un domini, per exemple elmeudomini.ddns.net.
Quan ja tenim el nostre domini registrat, toca instal·lar el client a la Raspi.
Hi accedim per ssh amb:
Abans ens assegurarem de tenir el sistema actualitzat, pel que farem un update i un upgrade. Això pot tardar fins a 20 o 30 minuts, depenent del que s'hagi d'actualitzar.
sudo apt-get update && sudo apt-get upgrade
És recomanable fer aquest procés cada cert temps, ja que hi pot haver actualitzacions de seguretat del sistema o d'alguna altra aplicació.
A continuació descarreguem el client de no-ip
wget http://www.no-ip.com/client/linux/noip-duc-linux.tar.gz
El descomprimim
tar -zxvf noip-duc-linux.tar.gz
Accedim a la carpeta que s'ha creat
cd noip-2.1.9-1
I l'instal·lem
sudo make
sudo make install
En aquest punt ens demanarà el nom d'usuari i la contrassenya del nostre compte de no-ip, i degut a que només tindrem un domini registrat, agafarà aquest per defecte. El temps de refresc el podem deixar per defecte, i a la següent pregunta, respondrem que NO (n).
Ara creem un nou fitxer que li direm noip2
sudo nano /etc/init.d/noip2
I afegim la següent comanda
sudo /usr/local/bin/noip2
Guardem el fitxer amb Ctrl+x --> y --> enter, i li donem permissos d'execució
sudo chmod +x /etc/init.d/noip2
Actualitzem el fitxer d'inici perquè arrenqui cada vegada que engeguem la Raspi
sudo update-rc.d noip2 defaults
I posem el servei en marxa
sudo /usr/local/bin/noip2
Ens falta un darrer punt molt important, i que justifica la importància del punt 2. Per poder accedir des de fora de la xarxa, necessitem saber l'adreça pública (problema que hem solucionat amb no-ip), però també necessitem saber a quina adreça privada volem anar. Això se soluciona fent "port-forwarding" al router i indicant que tot el que vingui des de fora que vulgui anar al port 22 (o el que haguem configurat si hem fet el punt 3), vagi a la nostra Raspi. Aquí veiem la importància de tenir una IP estàtica.
Per aconseguir això necessitem accedir al router teclejant la seva adreça a qualsevol navegador, que normalment sol ser 192.168.1.1, i posem el nom d'usuari i contrassenya. Els nous routers de fibra òptica de Movistar només demanen una contrassenya que es troba abaix del router, i els més antics normalment tenen "admin" com a usuari, i "admin" o "1234" com a contrassenya (sense cometes). En cas que no vagi bé, s'haurien de cercar les credencials d'accés a Internet.
Una vegada dins cerquem alguna opció que es digui "Ports" (depèn molt de cada fabricant), i creem una nova regla que indiqui el següent:
Port: 22 (o el que correspongui)
Tipus de protocol: TCP/UDP
Adreça destinació: 192.168.1.XX
Aquesta és la informació rellevant, sent XX l'adreça que hem assignat en el punt 2. Potser ens demana també un nom, que li podem posar SSH, per exemple.
Amb això ja tenim configurat no-ip i el port 22 del router obert, pel que hauriem de poder accedir a la nostra raspi des de qualsevol lloc fora de la nostra xarxa local. No ho podrem provar sempre que estiguiem connectats a la pròpia xarxa, però ho podem provar des del mòbil (amb una aplicació com JuiceSSH per Android) o demanant a algú que estigui en una altra xarxa que ens ho miri.
Des del terminal (o PuTTY si estem utilitzant Windows) teclegem
O si hem canviat el port ssh
ssh -p 2234 [email protected]
Si ens demana contrassenya, vol dir que tot ha sortit bé, i ja podrem accedir a la nostra Raspi des de qualsevol banda (inclús des del mòbil).
En el punt anterior hem vist com obrir un port del nostre router, i aquí aprofitarem per obrir tots els que ens faci falta pels propers serveis. Així, una vegada dins del router, i com que ja sabem quins tipus de serveis farem servir, aprofitarem per obrir-los tots de cop i ens estalviem haver de fer-ho després un per un.
En el nostre cas, a banda del port 22, obrirem els següents apuntant també a l'adreça de la nostra Raspi:
Ports: 80 (servidor web per defecte), 21 (servidor FTP per defecte)
Protocols: TCP/UDP
IP destí: 192.168.1.XX
A més a més, ja que també farem servir una càmera IP, podem obrir el port que li correspondrà:
Port: 8081 (per exemple)
Protocols: TCP/UDP
IP destí: 192.168.1.XY
Canviarem XY per l'adreça que posteriorment li donarem a la nostra càmera, i així ja no haurem de tornar a configurar el router una vegada instal·lada.
Un servidor ftp ens pot servir per agafar dades de la Raspi d'una forma senzilla. Per això, tot i que les captures i vídeo de la càmera es faran directament sobre la seva IP, inicialment vam fer servir el servidor ftp per enviar les fotos, pel que creiem convenient explicar el seu procés de configuració.
Farem servir el servidor vsftpd, pel que procedim a la seva instal·lació
sudo apt-get install vsftpd
I un cop instal·lat, obrim l'arxiu de configuració per realitzar alguns canvis
sudo nano /etc/vsftpd.conf
Modificarem les linies que es mostren a continuació:
anonymous_enable=NO
....
local_enable=YES
...
write_enable=YES
...
Amb això permetrem poder interactuar amb els arxius, i no permetem l'accés anònim.
Tot i així, si no fem cap més modificació, tots els usuaris podrien accedir a tots els arxius. Si volem restringir només l'accés a les carpetes de cada usuari, modifiquem la següent linia:
chroot_local_user=YES
Si volem afegir un certificat SSL a la nostra conexió, realitzarem els següents passos.
Primer creem el certificat amb la següent comanda:
sudo openssl req -x509 -nodes -days 365 -newkey rsa:1024 \
-keyout /etc/ssl/private/vsftpd.pem -out /etc/ssl/private/vsftpd.pem
Això ens crea varis arxius, la ruta dels quals haurem d'afegir al fitxer de configuració del servidor. Per tant, el tornem a obrir
sudo nano /etc/vsftpd.conf
I al final de l'arxiu cerquem la línia que habilita l'accés per ssl i la descomentem. Afegim també, si cal, les rutes dels certificats
rsa_cert_file=/etc/ssl/private/vsftpd.pem
rsa_private_key_file=/etc/ssl/private/vsftpd.pem
ssl_enable=YES
I afegim les següents linies al final del fitxer
allow_anon_ssl=NO
force_local_data_ssl=YES
force_local_logins_ssl=YES
ssl_tlsv1=YES
ssl_sslv2=NO
ssl_sslv3=NO
require_ssl_reuse=NO
ssl_ciphers=HIGH
Un cop hem guardat l'arxiu (Ctrl+x --> y --> enter), ens queda reiniciar el servidor:
sudo service vsftpd restart
Igual que hem fet amb el port ssh, podem tenir la necessitat de modificar el port ftp. Per això, obrim el fitxer de configuració
sudo nano /etc/vsftpd.conf
I realitzaem els següents canvis a les linies corresponents
#connect_from_port_20=YES
ftp_data_port=2121
listen_port=2121
Aquí, com amb ssh, podem posar el port que vulguem sempre i quan estigui disponible, però la millor opció és mantenir el 21 inicial (per fer referència a ftp), i afegim dos digits més.
I per acabar, reiniciem el servidor
sudo service vsftpd restart
De servidors web n'hi ha varis, i potser un dels més coneguts sigui Apache. Tot i que la Raspi no té problemes per treballar amb Apache, depen del seu proposit potser amb un de més lleuger com nginx o lighttph ja en tenim prou.
Aquí es detalla la instal·lació d'Apache i nginx juntament amb php, i en el nostre cas degut a que utilitzem llibreries JSON per interactuar amb l'aplicació mòbil, ens hem quedat amb Apache.
La instal·lació d'Apache és relativament senzilla, però requereix d'alguns preparatius.
Primer crearem un nou grup www-data
sudo addgroup www-data
I afegim els usuaris al grup
sudo usermod -a -G www-data www-data
Ara, per instal·lar el servidor, ho farem amb
sudo apt-get install apache2 apache2-utils php5 libapache2-mod-php5
Iniciem el servidor
sudo /etc/init.d/apache2 restart
I provem que funciona accedint a la direcció IP de la Raspi si estem a la mateixa xarxa
http://IP_ADDRESS
O al nom del domini que hem creat a no-ip si estem a una xarxa externa
http://elmeudomini.ddns.net
Per provar php, creem el següent fitxer
sudo nano /var/www/html/info.php
Amb el següent contingut
<?php
phpinfo();
?>
I provem que funciona accedint a
http://ID_ADDRESS/info.php
Per instal·lar nginx, només hem de executar la comanda
sudo apt-get install nginx php5 libapache2-mod-php5
Una vegada instal·lat, creem la carpeta /var/www/html en cas que no existeixi
sudo mkdir /var/www/html
I modifiquem l'arxiu de configuració de nginx
sudo nano /etc/nginx/sites-available/default
Deixant-lo de la següent manera
server {
listen 80;
server_name $domain_name;
root /var/www/html;
index index.html index.htm;
access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log;
}
Reiniciem el servidor
sudo service nginx restart
I comprovem que funciona escrivint a qualsevol navegador l'adreça IP de la Raspi si estem connectats a la mateixa xarxa
http://IP_ADDRESS
o el nom del nostre domini si estem a una xarxa diferent.
http://elmeudomini.ddns.net
Per instal·lar php executem
sudo apt-get install php5 libapache2-mod-php5
Obrim l'arxiu de configuració
sudo nano /etc/nginx/sites-available/default
I el deixem de la següent manera
server {
listen 80;
server_name $domain_name;
root /var/www/html;
index index.html index.htm;
access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log;
location ~\.php$ {
fastcgi_pass unix:/var/run/php5-fpm.sock;
fastcgi_split_path_info ^(.+\.php)(/.*)$;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param HTTPS off;
try_files $uri =404;
include fastcgi_params;
}
}
Ara només ens falta reiniciar el servidor
sudo service nginx restart
Crear un fitxer php
sudo nano /var/www/test.php
Amb el següent codi de prova
<?php
phpinfo();
?>
I provar que el php funciona correctament accedint a
http://IP_ADDRESS/test.php
o des de fora de la xarxa
http://elmeudomini.ddns.net/test.php
Instal·lem els arxius de MySQL
sudo apt-get install mysql-server mysql-client php5-mysql
Durant l'instal·lació ens demanarà certa informació, que anirem emplenant.
Una vegada acabada la instal·lació, reiniciem el servei amb
sudo service mysql start
I provem si funciona
mysql -u root -p
Introduïm el password que hem escollit durant la instal·lació, i si carrega correctament la instal·lació ha sortit bé.
Premem Ctrl+c per sortir.
Per instal·lar phpMyAdmin fem
sudo apt-get install libapache2-mod-auth-mysql php5-mysql phpmyadmin
Durant aquesta instal·lació li direm quin servidor fem anar, quan ens demani si volem fer servir MySQL li direm que sí, i posarem una contrassenya per phpMyAdmin.
A continuació obrirem el següent fitxer
sudo nano /etc/php5/apache2/php.ini
I afegirem la següent linia al principi del fitxer
extension=mysql.so
Després executem la següent comanda
sudo ln -s /etc/phpmyadmin/apache.conf /etc/apache2/conf.d/phpmyadmin.conf
I reiniciem el servidor
sudo /etc/init.d/apache2 reload
Provem a veure si podem accedir a phpMyAdmin amb
http://IP_ADDRESS/phpmyadmin
Nota: Tots els fitxers html, php, etc. que farem servir es troben a la carpeta "web" del repositori.
Ja que les notificacions push natives en la nostra pròpia aplicació requereixen de certs passos una mica farragosos (registrar l'app a Google, tenir compte de Google Developer, etc.), hem optat per servir-nos d'una aplicació que ens proporciona aquesta funcionalitat: Pushover.
El que necessitem primer de tot és crear un compte a la web de Pushover (la qual cosa ens generarà una clau única d'usuari) i posteriorment crearem una "aplicació" (que no és més que generar un Token per fer servir juntament amb l'API de Pushover). Posteriorment baixarem l'app de Pushover de Google Play o Apple Store.
Una vegada tenim la nostra clau d'usuari, el token de la nostra aplicació i l'aplicació mòbil instal·lada, anem a la Raspi i creem un nou arxiu que li direm, per exemple, notificacions.sh.
Una recomanació és crear una carpeta al nostre home on guardar els nostres scripts, així ho tenim tot més ordenat.
mkdir scripts
cd scripts
sudo nano notifications.sh
I dins d'aquest fitxer copiem el següent codi:
#!/bin/bash
MSG="message=Escriure aquí el missatge desitjat"
curl -s \
--form-string "token=APPTOKEN" \
--form-string "user=USERTOKEN" \
--form-string "$MSG" \
https://api.pushover.net/1/messages.json
exit 0
Aquí haurem de substituir APPTOKEN i USERTOKEN pel token de la nostra app i la clau d'usuari, respectivament.
I finalment li hem de donar permisos d'execució
sudo chmod +x notificacions.sh
Aquest seria l'script base per enviar notificacions des de la Raspi al nostre mòbil, i ho podem provar simplement executant l'script
./notificacions.sh
A partir d'aquí, ens podem crear tants scripts com vulguem per enviar notificacions depenent del que ens interessi. Inclús podem cridar aquest script des d'un altre script, si volem.
Telegram és una aplicació de missatgeria molt versàtil i gràcies a que és de programari lliure ens permet treballar amb ella més enllà d'enviar missatges als nostres amics.
Per instal·lar Telegram, primer necessitem les següents llibreries
sudo apt-get install libreadline-dev libconfig-dev libssl-dev \
lua5.2 liblua5.2-dev libevent-dev libjansson-dev libpython-dev make
I després baixar el fork de Telegram per Linux
git clone --recursive https://github.com/vysheng/tg.git && cd tg
I fem
./configure
make
Una vegada instal·lat l'executem amb
bin/telegram-cli -k tg-server.pub -W
NOTA: Potser en aquest punt ens dóna un error com el següent
pi@raspberrypi:~/tg $ bin/telegram-cli -k tg-server.pub -W
Telegram-cli version 1.4.1, Copyright (C) 2013-2015 Vitaly Valtman
Telegram-cli comes with ABSOLUTELY NO WARRANTY; for details type 'show_license'.
This is free software, and you are welcome to redistribute it
under certain conditions; type 'show_license' for details.
Telegram-cli uses libtgl version 2.1.0
Telegram-cli includes software developed by the OpenSSL Project
for use in the OpenSSL Toolkit. (http://www.openssl.org/)
I: config dir=[/home/pi/.telegram-cli]
> telegram-cli: tgl/mtproto-utils.c:101: BN2ull: Assertion '0' failed.
SIGNAL received
Si és així, haurem de modificar el fitxer tgl/mtproto-utils.c, comentar les linies 101 i 105, i tornar a compilar.
Quan el tenim correctament instal·lat, la primera vegada que l'executem ens demanarà el nostre número de telèfon, al qual haurem d'incloure el codi de país (+34 en el cas d'Espanya), i introduir el codi que rebrem via Telegram al nostre mòbil.
Ara, per enviar missatges ho farem amb la següent comanda
msg Name_Lastname message
NOTA: Name és el nom del nostre contacte i Lastname el cognom tal i com ens el mostra Telegram a l'aplicació, i s'han de separar amb la barra baixa (_)
Podem crear varis scripts per enviar missatges més còmodament sense haver de tenir el client en marxa continuament. Per això, crearem un script amb el nom que vulguem
sudo nano /home/pi/scripts/tg.sh
i hi afegirem el següent codi
#!/bin/bash
to=$1
msg=$2
tgpath=/path/to/telegram/tg
cd ${tgpath}
cmd="bin/telegram-cli -W -k server.pub -e \"msg $to $msg\""
eval $cmd
NOTA: Tenir en compte que la variable tgpath ha de contenir la ruta on hem ubicat la carpeta tg que ens hem baixat del reposiroti.
I li donem els permisos necessaris
sudo chmod 0655 /home/pi/scripts/tg.sh
Per executar-lo, fem
tg.sh Name_Lastname Message
Amb això, podriem utilitzar Telegram per enviar missatges al nostre mòbil en comptes de fer servir Pushover.
Una funcionalitat interessant és la d'enviar una notificació quan algun usuari accedeix a la Raspi. Per això farem servir un scrip molt similar al del punt 10. Creem el nou script
sudo nano loginNotification.sh
I hi afegim el següent codi
#!/bin/bash
#Using PAM
MSG="message=Login from user $PAM_USER"
if [ "$PAM_TYPE" != "close_session" ]; then
curl -s \
--form-string "token=APPTOKEN" \
--form-string "user=USERTOKEN" \
--form-string "$MSG" \
https://api.pushover.net/1/messages.json
fi
exit 0
El que fa aquest codi és executar el curl només quan es fa login gràcies a la condició, ja que en principi no ens interessa saber quan es desconnecta. En cas que també ho vulguem saber, n'hi ha prou amb treure el condicional.
Li hem de donar també els permisos d'execució
sudo chmod +x loginNotification.sh
I per fer que aquest script funcioni, ens queda modificar un arxiu, i és important fer-ho amb cura ja que un error ens pot bloquejar l'accés a la Raspi.
Obrim el següent fitxer
sudo nano /etc/pam.d/sshd
Busquem la part de codi següent, i afegim les linies corresponents al nostre script, tenint cura de no modificar la resta de codi
.............
# SELinux needs to be the first session rule. This ensures that any
# lingering context has been cleared. Without this it is possible that a
# module could execute code in the wrong domain.
session [success=ok ignore=ignore module_unknown=ignore default=bad] pam_selinux.so close
# El meu script
session required pam_exec.so seteuid /home/pi/scripts/loginNotification.sh
# Fi del meu script
# Set the loginuid process attribute.
session required pam_loginuid.so
# Create a new session keyring.
session optional pam_keyinit.so force revoke
............
Guardem el fitxer amb Ctrl+x --> y --> enter.
Ara, per provar que tot ha sortit bé, obrirem un nou terminal amb Ctrl+alt+t, i provarem a fer login amb el nostre usuari
Si després d'introduir la contrassenya aconseguim entrar, és que tot ha sortit com esperàvem. En cas que una vegada introduïda la contrassenya ens tregui fora de la sessió, hem de revisar el que hem fet i buscar algun error. Per això és important fer aquesta prova des d'un altre terminal, ja que si hem fet alguna cosa malament i sortim de la sessió actual no podriem tornar a accedir a la Raspi.
En quant a la càmera IP, normalment tenen de per sí una interficie web amb la que podem configurar ja algunes opcions, però en el nostre cas ens interessa dependre lo mínim possible d'aquest sistema i interactuar directament amb ella a través de la seva IP.
Això ens dóna la llibertat de poder crear la nostra pròpia web o aplicació mòbil i accedir a la imatge de la càmera o fer captures gràcies als sensors que muntarem a l'Arduino. Tot i així, per configurar la càmera farem servir la pròpia interficie web, ja que al ser un entorn gràfic és més còmode.
Segons les instruccions del fabricant, les càmeres IP tenen una adreça establerta a la qual s'hi pot accedir des d'un navegador si la connectem a un ordinador per cable ethernet, pel que la configuració inicial la farem des d'un ordinador. Una vegada sabem quina adreça té, i després d'haver introduït el nom d'usuari i contrassenya per defecte, farem les següents configuracions:
- Assignar un port diferent del port 80 que ve per defecte, que serà el que hem obert al router abans, destinat a la càmera.
- Canviar la contrassenya d'accés
- Configurar la connexió FTP per comunicar-se amb la Raspi (Opcional)
- Anotar l'adreça MAC de la càmera
- Configurar la connexió WiFi afegint el SSID i contrassenya de la nostra xarxa
Nota: Cada càmera té la seva interfície, pel que on està cada opció pot variar.
Pel que fa referència a la IP, com podem imaginar també li hem d'assignar una IP estàtica, però en aquest cas hem optat per fer-ho des del router utilitzant l'adreça mac de la càmera, ja que no podem editar cap fitxer a la càmera (o no tan fàcilment) com sí podiem fer amb la Raspi.
Accedim al router i anem a l'opció de control MAC (novament, cada router és diferent). Afegim la MAC de la càmera i li assignem la mateixa IP que hem posat al obrir el port corresponent en el punt 5.
Després d'això, ja podem desconnectar la càmera de l'ordinador, apagar-la i tornar-la a encendre. Si tot ha sortit com esperavem, no hi hauria d'haver problema en accedir a la càmera des de qualsevol navegador web, simplement posant l'adreça IP seguida de : i el port, si estem dins de la xarxa local
http://192.168.1.XY:8081
O fent servir el nostre domini de no-ip, i que gràcies a la Raspi sempre estarà actualitzat (requereix haver obert els ports del router previament i haver redirigit les peticions a la IP de la càmera)
http://elmeudomini.ddns.net:8081
Amb això accedim al menú de la pròpia càmera i podrem realitzar les configuracions pertinents en cas de ser necessari, però com hem dit abans, no serà aquesta la forma en que agafarem les fotos, sino que ens servirem de les peticions per http que ens ofereix (i que podem consultar als foros de Dlikn). Si es fa servir una càmera diferent, s'haura de consultar el manual d'usuari i les comandes necessaries per configurar la càmera i addecir a ella.
Ja podem col·locar la càmera on vulguem, sempre que estigui dins de la cobertura WiFi.
En aquest apartat mostrarem els scripts que creiem més rellevants de cara al nostre projecte, però per veure'ls tots ens podem dirigir a la carpeta scripts del repositori
#!/bin/bash
MSG="message=Message to send"
curl -s \
--form-string "token=APPTOKEN" \
--form-string "user=USERTOKEN" \
--form-string "$MSG" \
https://api.pushover.net/1/messages.json
exit 0
#!/bin/bash
#Using PAM
MSG="message=Login from user $PAM_USER"
MSG2="message=Logout from user $PAM_USER"
if [ "$PAM_TYPE" == "open_session" ]; then
curl -s \
--form-string "token=APPTOKEN" \
--form-string "user=USERTOKEN" \
--form-string "$MSG" \
https://api.pushover.net/1/messages.json
elif [ "$PAM_TYPE" == "close_session" ]; then
curl -s \
--form-string "token=APPTOKEN" \
--form-string "user=USERTOKEN" \
--form-string "$MSG2" \
https://api.pushover.net/1/messages.json
fi
exit 0
#!/bin/bash
if [ ! -f /path/to/save/pid/process.pid ]; then
python /path/to/script/process.py &
echo $! > /path/to/save/pid/process.pid
else
echo "Process is running"
fi
#!/bin/bash
pid=$(cat /path/to/saved/pid/process.pid)
kill -9 $pid
rm /path/to/saved/pid/process.pid
import serial
import os
import time
arduino=serial.Serial('/dev/ttyACM0',9600)
#arduino.open()
while True:
time.sleep(0.5)
x = arduino.read().rstrip()
if x == ("d"):
print "Movement detected"
#os.system("/home/pi/scripts/pushNotification.sh > /dev/null")
arduino.flushInput()
arduino.close()
#!/bin/bash
to=$1
msg=$2
tgpath=/path/to/tg/folder
cd ${tgpath}
cmd="bin/telegram-cli -W -k server.pub -e \"msg $to $msg\""
eval $cmd
#!/bin/sh
MSG="message=Backup completed"
MSG2="message=ERROR: Backup Failed"
sudo tar -cf "/home/pi/backups/backup_$(date '+%F').tar" /home /var/www/
rsync -ae ssh /home/pi/backups/* [email protected]:/media/hdd/backups/pti
sudo rm /home/pi/backups/*
if [ "$?" -eq "0" ] || [ "$?" -eq "1" ];
then
curl -s \
--form-string "token=XXX" \
--form-string "user=XXX" \
--form-string "$MSG" \
https://api.pushover.net/1/messages.json
else
curl -s \
--form-string "token=XXX" \
--form-string "user=XXX" \
--form-string "$MSG2" \
https://api.pushover.net/1/messages.json
fi