Difenditi con ARTILLERY

Artillery Honeypot All-in-one

Artillery Honeypot All-in-one

In questo articolo parleremo di un tool che si pone come interessante aiuto verso la sicurezza delle nostre macchine in rete, il suo nome e’ Artillery , esso è un interessante software scritto interamente in python. La cosa molto interessante di questo tool e’ che lo possiamo intendere come una combinazione tra un honeypot, un tool di monitoraggio, ed un sistema di alerting. Uahoooo, tutto in un’unico strumento…….

I principi di funzionamento si caratterizzano dal fatto che in presenza di determinate attività di networking esso si comporta parzialmente come un honeypot, adottando anche manovre evasive e, contemporaneamente monitorizza il cambiamento di file sensibili; in entrambi i casi avvisando di quanto riscontrato i destinatari designati.
Artillery si pone in ascolto su di un certo numero di porte di uso comune (peraltro configurabile, tramite la variabile PORTS), e qualora riceva una richiesta di connessione per uno qualsiasi dei servizi fasulli, blocca in modo permanente l’indirizzo IP sorgente aggiungendo una relativa regola con target DROP a iptables.

Artillery può essere anche usato per prevenire attacchi di tipo brute force

L’ installazione ed il lancio di Artillery sono molto semplici: una volta effettuato il download via git, occorre lanciare uno script installer, editare un file di configurazione (“all’inizio questo passaggio sara’ meglio farlo su macchina virtuale per fare pratica della configurazione delle regole”) e poi mandarlo in esecuzione:

# cd /opt
apt-get update && apt-get install git [solo se ancora non avete installato il pacchetto git]
# git clone https://github.com/trustedsec/artillery/ artillery/
# cd artillery
# sudo ./setup.py

Welcome to the Artillery installer. Artillery is a honeypot, file monitoring, and overall security tool used to protect your nix systems.

Written by: Dave Kennedy (ReL1K)

Do you want to install Artillery and have it automatically run when you restart [y/n]: y
[*] Beginning installation. This should only take a moment.
[*] Adding artillery into startup through init scripts..
[*] Triggering update-rc.d on artillery to automatic start…
Do you want to keep Artillery updated? (requires internet) [y/n]: y
[*] Checking out Artillery through github to /var/artillery
Cloning into ‘/var/artillery’…
remote: Counting objects: 876, done.
remote: Total 876 (delta 0), reused 0 (delta 0), pack-reused 876
Receiving objects: 100% (876/876), 207.83 KiB | 293.00 KiB/s, done.
Resolving deltas: 100% (568/568), done.
Checking connectivity… done.
[*] Finished. If you want to update Artillery go to /var/artillery and type ‘git pull’
Would you like to start Artillery now? [y/n]: y
Starting Artillery… Ok
[*] Installation complete. Edit /var/artillery/config in order to config artillery to your liking..

Durante il processo di installazione verranno poste, come potete leggere qui sopra, alcune domande:
Do you want to install Artillery and have it automatically run when you restart [y/n]:
Do you want to keep Artillery updated? (requires internet) [y/n]:
Would you like to start Artillery now? [y/n]:

Artillery verrà installato come servizio sotto /etc/init.d/
E’ sempre consigliabile leggere con attenzione prima d’ impostare il file di configurazione.
In ogni caso, una volta effettuate delle modifiche alla configurazione, si può impartire e renderle immediatamente operanti:
# python restart_server.py

Fate attenzione a non commettere l’errore di editare invece i files risultanti dal download via git. Una volta che che lo script di installazione sia stato eseguito, per modificarne la configurazione posizionatevi piuttosto nella directory /var/artillery.

Il contenuto del file config è piuttosto chiarificatore delle funzionalità del software:
# determina se attivare l’attività di monitoraggio dell’integrità di files sensibili
MONITOR=YES
#
# le directories da monitorare, se ne possono ancora aggiungere “/root”,”/var/”, ecc.
MONITOR_FOLDERS=”/var/www”,”/etc/”
#
# frequenza del controllo in secondi.
MONITOR_FREQUENCY=60
#
# esclusione dal controllo per certe directories o files, ad esempio: /etc/passwd,/etc/hosts.allow
EXCLUDE=
#
# determina se attivare l’attività di HONEYPOT
HONEYPOT=YES
#
# ban automatico HONEYPOT
HONEYPOT_BAN=YES
#
# WHITELIST di indirizzi IP non vincolati dalle regole di controllo
WHITELIST_IP=127.0.0.1,localhost
#
# PORTS su cui attivare il monitoring
PORTS=”135,445,22,1433,3389,8080,21,5900,25,53,110,1723,1337,10000,5800,44443″
#
# determina se attivare l’alerting via email
EMAIL_ALERTS=OFF
#
# username SMTP
USERNAME=”thisisjustatest@gmail.com”
#
# password SMTP
PASSWORD=”pass”
#
# destinatario
SMTP_TO=”testing@test.com”
#
# server per l’invio, per default gmail
SMTP_ADDRESS=”smtp.gmail.com”
#
# Porta SMTP per l’invio. Di default è quella gmail con TTLS
SMTP_PORT=”587″
#
# Indirizzo EMAIL su cui ricevere gli ALERTS
ALERT_USER_EMAIL=”user@whatever.com”
#
# determina se l’invio delle email di alerting debba avvenire seguendo una certa frequenza. Se impostato a off, gli alerts
# verranno inviati automaticamente in tempo reale (può significare un mucchio di spam)
EMAIL_TIMER=ON
#
# la frequenza con la quale saranno inviati gli ALERTS per email (per default ogni 10 minuti)
EMAIL_FREQUENCY=600
#
# Attivazione del monitoraggio dei tentativi BRUTE FORCE contro SSH
SSH_BRUTE_MONITOR=ON
#
# Quanti tentativi prima del BAN
SSH_BRUTE_ATTEMPTS=4
#
# Per effettuare degli aggiornamenti automatici
AUTO_UPDATE=OFF
#
# ANTI DOS imposta la macchina a limitare le connessioni, e va impostato ad OFF nel caso non lo si intenda utilizzare
ANTI_DOS=ON
#
# Le porte dotate di protezione ANTI-DOS
ANTI_DOS_PORTS=80,443
#
# I parametri che limitano le connessioni come misura anti DOS
ANTI_DOS_THROTTLE_CONNECTIONS=50
ANTI_DOS_LIMIT_BURST=200
#

Artillery ha un set di porte (comuni o comunemente attaccate) preimpostato sulle quali si pone in ascolto.
A rivelarle basta un semplice:

# netstat -antp |grep LISTEN
tcp 0 0 0.0.0.0:21 0.0.0.0:* LISTEN 2428/python
tcp 0 0 0.0.0.0:53 0.0.0.0:* LISTEN 827/dnsmasq
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN 637/sshd
tcp 0 0 127.0.0.1:631 0.0.0.0:* LISTEN 706/cupsd
tcp 0 0 0.0.0.0:1433 0.0.0.0:* LISTEN 2428/python
tcp 0 0 0.0.0.0:1337 0.0.0.0:* LISTEN 2428/python
tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN 2428/python
tcp 0 0 0.0.0.0:90 0.0.0.0:* LISTEN 734/nginx -g daemon
tcp 0 0 0.0.0.0:44443 0.0.0.0:* LISTEN 2428/python
tcp 0 0 0.0.0.0:1723 0.0.0.0:* LISTEN 2428/python
tcp 0 0 0.0.0.0:47323 0.0.0.0:* LISTEN 616/rpc.statd
tcp 0 0 0.0.0.0:445 0.0.0.0:* LISTEN 2428/python
tcp 0 0 0.0.0.0:3389 0.0.0.0:* LISTEN 2428/python
tcp 0 0 0.0.0.0:135 0.0.0.0:* LISTEN 2428/python
tcp 0 0 0.0.0.0:5800 0.0.0.0:* LISTEN 2428/python
tcp 0 0 127.0.0.1:3306 0.0.0.0:* LISTEN 1089/mysqld
tcp 0 0 0.0.0.0:5900 0.0.0.0:* LISTEN 2428/python
tcp 0 0 0.0.0.0:110 0.0.0.0:* LISTEN 2428/python
tcp 0 0 0.0.0.0:111 0.0.0.0:* LISTEN 606/rpcbind
tcp 0 0 0.0.0.0:10000 0.0.0.0:* LISTEN 2428/python
tcp 0 0 0.0.0.0:8080 0.0.0.0:* LISTEN 2428/python
tcp6 0 0 :::53 :::* LISTEN 827/dnsmasq
tcp6 0 0 :::22 :::* LISTEN 637/sshd
tcp6 0 0 ::1:631 :::* LISTEN 706/cupsd
tcp6 0 0 :::46327 :::* LISTEN 616/rpc.statd
tcp6 0 0 :::90 :::* LISTEN 734/nginx -g daemon
tcp6 0 0 :::111 :::* LISTEN 606/rpcbind
tcp6 0 0 :::80 :::* LISTEN 1153/apache2

P.S.: L’esclusione dell’indirizzo IP che non riesca ad autenticarsi validamente viene effettuata attraverso il controllo del file /var/log/auth.log (per le distribuzioni basate su Debian).

Il tool e’ potente ed altamente configurabile; non rimane che dare un’occhiata alla configurazione e fare qualche prova, magari all’inizio giocando con qualche servizio aperto su di una VM.

 

Virtualizzazione e provisioning senza sforzo

Vagrant Virtualization Box

Vagrant Virtualization Box

La virtualizzazione ha sicuramente cambiato il modo di lavorare e di pensare alla gestione dei sistemi informatici aziendali o dei service provider, ed il cloud ha aggiunto un’ulteriore strato, sia di liberta’, ma anche di complicazione in piu’, nella gestione dei nuovi sistemi ad alta affidabilita’ che devono essere in grado di scalare nel minor tempo possibile ecc….

Queste esigenze hanno portato alla nascita di innumerevoli sistemi di virtualizzazione, tra i piu’ conosciuti sicuramente ci sono Xen, Vmware, Kvm, Virtuozzo, Virtualbox, Openvz …..! che per certi versi si trasformano in un incubo per gli amministratori di sistema, costretti ad avere diversi ambienti di gestione delle VM su diversi sistemi e con molteplici file di configurazione da settare.

Infatti quando ci troviamo ad amministrare un ambiente cloud con molte macchine, il rischio di dover aggiungere una macchina in più e doverla successivamente configurare in poco tempo per il deploy e la messa in produzione insieme a tutte le altre è molto alto. In più, se siamo all’interno di un’architettura che deve scalare rapidamente per rispondere in modo agile alle esigenze degli utenti (e chiaramente dell’azienda), dover attendere l’installazione del sistema operativo e poi del software non è certamente divertente. Per tutte queste esigenze, Vagrant potrebbe risultare la giusta soluzione che può semplificarci la vita, permettendoci di aggirare tutte queste “rogne”

Vagrant è un gestore di macchine virtuali che può usare parecchi hypervisor tra cui VirtualBox, il predefinito, ma anche VMWare, Xen e KVM. Attraverso questo software infatti potremo basarci su una struttura di base comune a tutte le macchine, che contiene il sistema operativo (anche se poi vedremo come personalizzare questa alberatura), e mantenere degli step comuni nella configurazione delle nostre istanze virtuali, per poi dedicarci solo alle rifiniture, risparmiando tantissimo tempo grazie alle capacità di elaborazione dei datacenter che abbiamo in-house o magari in cloud.

Per inizializzare il nostro primo progetto Vagrant, abbiamo solo bisogno di spostarci in una directory vuota e dare il comando (avendo già installato il software):

Installazione Vagrant

### Verificare di aver installati i seguenti pacchetti : rubygems ruby1.9.1-dev virtualbox-4.2 (o superiori)
# sudo apt-get install vagrant
# vagrant plugin install vagrant-vbguest

Le Box di Vagrant
Il primo concetto fondamentale da fare nostro, per quanto riguarda Vagrant, è quello del concetto di Box. Una Box per quanto riguarda questo ambiente di virtualizzazione infatti è una vera e propria scatola che contiene il sistema operativo, e tutto quello di cui abbiamo bisogno come i software di base ed ogni loro configurazione di base. Al punto di partenza abbiamo delle Box rese disponibili dai server di Vagrant, ma possiamo tranquillamente aggiungerne altre: tutto quello di cui abbiamo bisogno è un po’ di fantasia coi nomi, e di conoscere l’URL remoto tramite il quale scaricare la Box (ne trovate parecchie già fatte su Vagrantbox.es oppure su Hasicorp), con questa sintassi da riga di comando.

# vagrant init
# vagrant box add name url

che, traducendolo con un esempio reale:

# vagrant box add precise32 http://files.vagrantup.com/precise32.box

Che non farà altro che aggiungere al nostro progetto Vagrant una Box Ubuntu 12.04 a 32 bit.

Il Vagrantfile
Una volta scaricata la nostra Box di partenza, possiamo cominciare a configurare il nostro progetto Vagrant tramite il Vagrantfile che abbiamo a disposizione e che si presenta essenzialmente come un file Ruby con vari namespace, ma niente paura, non è necessario conoscere direttamente Ruby per la configurazione (anche se può aiutare), ed è possibile fare riferimento alla documentazione per conoscere i vari prefissi e le possibilità che abbiamo a disposizione. Ogni volta che eseguiamo un comando Vagrant, il Vagrantfile viene cercato in tutte le directory di livello superiore nell’albero.

Il file può avere grossomodo un aspetto del genere:

Esempio di un cluster di 7 Boxes. Preso da:
### https://github.com/patrickdlee/vagrant-examples

domain   = 'example.com'
 
nodes = [
  { :hostname => 'ex7proxy',   :ip => '192.168.0.42', :box => 'precise32' },
  { :hostname => 'ex7db',      :ip => '192.168.0.43', :box => 'precise32' },
  { :hostname => 'ex7web1',    :ip => '192.168.0.44', :box => 'precise32' },
  { :hostname => 'ex7web2',    :ip => '192.168.0.45', :box => 'precise32' },
  { :hostname => 'ex7static1', :ip => '192.168.0.46', :box => 'precise32' },
  { :hostname => 'ex7static2', :ip => '192.168.0.47', :box => 'precise32' },
  { :hostname => 'ex7cache',   :ip => '192.168.0.48', :box => 'precise32' },
]
 
Vagrant::Config.run do |config|
  nodes.each do |node|
    config.vm.define node[:hostname] do |node_config|
      node_config.vm.box = node[:box]
      node_config.vm.host_name = node[:hostname] + '.' + domain
      node_config.vm.network :hostonly, node[:ip]
 
      memory = node[:ram] ? node[:ram] : 256;
      node_config.vm.customize [
        'modifyvm', :id,
        '--name', node[:hostname],
        '--memory', memory.to_s
      ]
    end
  end
 
  config.vm.provision :puppet do |puppet|
    puppet.manifests_path = 'puppet/manifests'
    puppet.manifest_file = 'site.pp'
    puppet.module_path = 'puppet/modules'
  end
end

Prima di arrivare a questo livello tuttavia, è necessario cominciare dalle basi: il primo file di configurazione di Vagrant che andremo a scrivere conterrà ben poche specifiche, e si baserà esclusivamente sulla Box che abbiamo scelto per la nostra prima macchina virtuale.

# Una singola Box.
#
Vagrant.configure(“2”) do |config|
config.vm.box = “precise32”
end

Esempio per una singola Box.

Vagrant.configure("2") do |config|
config.vm.box = "precise32"
end

Inoltre il Vagrantfile deve essere soggetto a version control (tramite git ad esempio) per tenere traccia di ogni modifica e rendere il tutto facilmente riportabile in una nuova architettura

Avviamo la Box

# sudo vagrant up
Bringing machine 'default' up with 'virtualbox' provider...
[default] Importing base box 'precise32'...
[default] Matching MAC address for NAT networking...
[default] Setting the name of the VM...
[default] Clearing any previously set forwarded ports...
[default] Clearing any previously set network interfaces...
[default] Preparing network interfaces based on configuration...
[default] Forwarding ports...
[default] -- 22 => 2222 (adapter 1)
[default] Booting VM...
[default] Waiting for machine to boot. This may take a few minutes...
[default] Mounting shared folders...
[default] -- /vagrant

Adesso che abbiamo il nostro progetto funzionante, basterà dare

# vagrant ssh
Last login: Fri Apr 15 05:43:58 2011 from 10.0.2.2
[vagrant@localhost ~]$

per collegarci ed esserne subito operativi all’interno della nostra box.

Provisioning
Vagrant non è solo un sistema per avviare velocemente delle macchine virtuali, infatti ci permette anche di controllarle, e di controllarne le impostazioni nel tempo, insieme al software installato. Possiamo quindi gestire la configurazione automatica secondo le nostre esigenze delle varie Box che abbiamo, attraverso una struttura di provisioning abbastanza flessibile che supporta normali shell script (Bash), il buon vecchio Puppet, ma anche Chef e Ansible.

Tramite questa infrastruttura possiamo modificare il Vagrantfile per eseguire quindi qualsiasi istruzione, che sia configurata per script Puppet oppure attraverso Bash. Ad esempio, possiamo utilizzare la piccola struttura riportata di seguito, che proviene direttamente dalla documentazione di Vagrant e che mostra come sia facile scriversi uno script di configurazione da mandare poi in pasto alla propria Box.

$script = <<SCRIPT
echo I am provisioning...
date > /etc/vagrant_provisioned_at
SCRIPT
Vagrant.configure("2") do |config|
config.vm.provision "shell", inline: $script
end

Non solo VirtualBox

Una volta imparato a usare Vagrant, avremo comunque basato tutto il nostro lavoro su VirtualBox. Tuttavia, potremmo anche avere qualcosa in contrario sull’uso di VirtualBox, e voler usare altri provider che ci permettano un’amministrazione più efficace o semplicemente il riciclo di competenze che già abbiamo. Ad esempio, Vagrant supporta tramite plugin anche l’integrazione con VMWare o con Xen; questi plugin sono installabili attraverso il gestore integrato nel software, semplicemente tramite un singolo comando, esattamente come in un classico gestore di pacchetti:

# vagrant plugin install vagrant-vmware-fusion

Oppure se invece di VMWare Fusion usate la variante Workstation:

# vagrant plugin install vagrant-vmware-workstation

Una volta installato il plugin, ed ovviamente il software di providing delle macchine virtuali che vogliamo testare, ci bastera’ modificare il Vagrantfile, con istruzioni come queste nell’ esempio:

Esempio tratto da [ http://puppetlabs.com/blog/new-vmware-provider-gives-vagrant-a-boost ]

config.vm.provider :vmware_workstation do |v|
v.vmx["memsize"] = "2048"
end

Vagrant può ovviamente essere configurato per essere alla base di una complessa configurazione in ambiente cloud, o della propria infrastruttura più modesta.

Se questo primo articolo vi ha incuriositi, la documentazione ufficiale, passo passo, vi sta aspettando : VAGRANT DOC

Nel prossimo articolo vedremo come sfruttare le potenzialita’ di Vagrant + Docker.

#VagrantVirtualizzazioneeProvisioning

Metasploit Framework

metasploit_logoTestiamo la nostra Sicurezza

Oggi giorno sempre piu’ servizi sono online e tra questi troviamo anche cose importanti come la gestione del conto bancario oppure il nostro profilo INPS ecc….; tutto cio’ e’ molto comodo ma e’ anche piu’ facile che una falla sui sistemi che usiamo possa rendere facile a persone poco raccomandabili di intercettare qualche nostro dato “sensibile” per poi servirsene a piacimento.

Certamente molti di noi si affidano al fatto che confidiamo nell’alto livello di sicurezza dei gestori di questi servizi, ma pochi pensano che in ogni conversazione, compresa quella tra computer in un luogo pubblico come Internet, deve avere entrambi i soggetti SICURI , quindi come fare per essere certi il piu’ possibile (dato che sicuro e’ morto) che noi per primi siamo esenti da bug ???? Un buon metodo e’ tenersi sempre aggiornati sui bug piu’ noti e pericolosi e poi testare la propria macchina. Il metodo migliore per farlo e’ quello di usare un Framework come Metasploit.

I metodi per usare Metasploit sono tanti e disparati , dall’usare un Live-CD, installarlo su di una Pen-Drive, creare una VM apposita ecc…
Stessa cosa si puo’ dire per i metodi d’installazione del Framework in questione quindi vi descrivero’ quello che preferisco e che trovo piu’ funzionale.

INSTALLAZIONE

mkdir git
cd git
git clone https://github.com/mcfakepants/metasploit-framework.git

…..a questo punto potete verificare cosa e’ stato scaricato nella DIR entrandoci e lanciando un ls -L
il risultato dovrebbe essere una lista come questa

git/metasploit-framework$ ls -L
config           external      modules     msfencode    msfrpcd    scripts
CONTRIBUTING.md  Gemfile       msfbinscan  msfmachscan  msfupdate  spec
COPYING          Gemfile.lock  msfcli      msfpayload   msfvenom   test
data             HACKING       msfconsole  msfpescan    plugins    tools
db               lib           msfd        msfrop       Rakefile
documentation    LICENSE       msfelfscan  msfrpc       README.md

a questo punto prima di lanciare la console di Metasploit per l’installazione conviene assicurarci di avere tutti i pacchetti per gli script in Ruby installati, per completare questa operazione possiamo lanciare il seguente comando :

gem install bundler

ora non ci rimane che lanciare l’installazione del Framework in questione tramite

sudo ./msfconsole -L

se dovessimo riscontrare un errore come questo: Could not find rake-10.0.4 in any of the sources potremo risolvere fermando l’installazione in corso con un Ctrl+C , ed eseguire, dalla stessa posizione in cui ci troviamo, il comando bundle install che installaera’ tutte le “GEMME” mancanti; rilanciamo pure l’installazione come prima con : # sudo ./msfconsole -L

Ci vorra’ qualche minuto per ultimare questa fase in quanto i pacchetti da scaricare sono diversi; al termine dell’installazione ci ritroveremo catapultati all’interno della console amministrativa di Metasploit, con una schermata di questo tipo

< metasploit >
 ------------
       \   ,__,
        \  (oo)____
           (__)    )\
              ||--|| *

=[ metasploit v4.9.0-dev [core:4.9 api:1.0] ]
+ -- --=[ 1288 exploits - 705 auxiliary - 203 post ]
+ -- --=[ 334 payloads - 35 encoders - 8 nops      ]

msf >

Ora tutto quello che ci rimane da fare e’ testare quelle criticita’ che ci sembrano piu’ rischiose e capire cosi’ se il nostro PC ne e’ affetto.

Una di quelle da verificare, per fare il nostro primo test, e’ quella relativa ad un bug nel parsing dei font presenti nei file SWF (i file Flash) di Adobe, grazie al quale un malintenzionato potrebbe essere in grado di eseguire codice malevolo sulla macchina della vittima fino ad arrivare ad ottenere il controllo di una shell remota, senza necessita’ di inserire una password. Questo bug e’ molto problematico in quanto colpisce tutti i sistemi operativi e tutti i PC che abbiamo installata una versione di Flash precedente alla 11.3

Per verificare se il vostro PC e’ affetto tornate nella console di metasploit ed eseguite il test lanciando la seguente stringa :

msf  > use exploit/windows/browser/adobe_flash_otf_font

Eseguendo questo exploit , metasploit costruira’ in pratica un falso webserver sulla vostra macchina locale, ed un finto client che va a leggere  una pagina HTML contenente un file SWF (che si trova nella cartella metasploit-framework/data/exploits/CVE-2012-1535), in modo da eseguire il test automaticamente.

In generale per avere più informazioni sull’utilizzo di qualsiasi comando basta invocare l’help dedicato:

msf > nomecomando -h

Vediamo adesso i comandi per interagire con le librerie di exploit e payload. Il primo da conoscere è show che serve per mostrare il contenuto delle librerie, ad esempio:

msf > show exploits

Con questo comando verrà stampata la lista di tutti gli exploit presenti.

Per visualizzare i payload similmente useremo:

msf > show payloads

Per cercare un elemento specifico possiamo servirci del comando search:

msf > search cve:2012 type:exploit app:client

Search utilizza keyword (type, app, platform, name, etc) per affinare la ricerca. Al solito è buona norma consultare l’help del comando per avere un’idea di tutte le sue funzionalità:

msf > search -h

Prossimamente verranno aggiunti su questo Blog altri articoli relativi ai Bug piu’ pericoli da testare grazie a Metasploit, fino ad allora buona pratica e buon divertimento.

Vedi anche precedente articolo KaliLinux

Seafile un Cloud privato

seafile_cloud… in pochi clic

L’incremento di velocita’ delle reti e di Internet ci ha portati a modificare le nostre abitudini per quanto riguarda la conservazione dei dati, che sono aumentati in modo esponenziale. In poco tempo sono nati diversi servizi online gratuiti (da DropBox, Ubuntu One, Google Drive, iCloud Box ecc…) che offrono spazio per lo storage di contenuti quali video, audio, foto, documenti ecc…,

Archiviazione e sincronizzazione dei dati sono i principali servizi messi a disposizione ma, negli ultimi tempi, si nota una nuova tendenza ad integrare anche strumenti di condivisione dei file con altri utenti. Cosa molto interessante, quest’ultima, utile anche a livello aziendale, e non solo, perche’ permette la creazione di gruppi di lavoro in cui ogni membro riceve automaticamente i file piu’ aggiornati , senza la seccatura di andare a controllare continuamente cosa e’ stato modificato.

In passato ho provato praticamente quasi tutti i servizi sopra citati, ma oggi esiste anche un’altra possibilita’ ed e’ data da Seafile
In pratica e’ un altro strumento open source di sincronizzazione, tipo Dropbox , che è stato progettato per essere più adatto al lavoro di squadra con alcune specifiche caratteristiche che sono orientate a questo obiettivo come ad esempio:

  • Gli utenti possono creare e partecipare a gruppi, quindi condividere i file al gruppo. Questo facilita il lavoro di squadra.
  • I file sono organizzati in librerie, ognuna sincronizzato in maniera selettiva con il client sul proprio computer. Le librerie possono essere sincronizzate con qualsiasi cartella locale.
  • Funzioni di collaborazione on-line per i file, come anteprima dei file PDF ed Office e la possibilità di lasciare commenti.

Seafile è quindi un servizio cloud storage che consente di condividere una libreria privata di file on the cloud con amici e colleghi. I file vengono sincronizzati con tutti gli utenti invitati, ciascuno dei quali ha la possibilità di editare un documento, il programma sincronizzerà automaticamente i cambiamenti così che gli altri utenti possano visualizzarli.
Il servizio assegna a ciascun membro del gruppo un server al quale nessun altro può avere accesso, aumentando così il livello di sicurezza. È possibile inoltre recuperare interamente la libreria di files grazie ai backup effettuati dal programma. Un alto livello di protezione è dato infine dal criptamento dei files protetti ciascuno da password, in maniera da renderli illeggibili ai non autorizzati. Seafile è un programma gratuito, scaricabile dal sito web ufficiale che mette a disposizione tutte le istruzioni e video per settare al meglio i propri gruppi di lavoro. Seafile è disponibile per Windows, Mac, Linux e per dispositivi mobili Android e iOS.

Caratteristiche

Seafile usa il modello di controllo di versione di GIT, ma semplificato per la sincronizzazione automatica, e non dipende da GIT. Ogni libreria è come un repository GIT. Ha la sua storia unica, che consiste in un elenco di commit. Un commit punta alla radice di uno snapshot del file system. Lo snapshot è composto da directory e file. I file sono ulteriormente suddivisi in blocchi per un trasferimento di rete ed utilizzo dello storage più efficiente

Differenze da git :

  • La sincronizzazione automatica
  • I client non conserva la cronologia dei file, evitando così il sovraccarico di memorizzazione dei dati due volte. GIT non è efficiente per file di grosse dimensioni (come le immagini)
  • I file sono ulteriormente suddivise in blocchi per il trasferimento in rete e l’utilizzo dello storage più efficiente
  • Il trasferimento dei file può essere ripreso
  • Supporta backend di memorizzazione differenti lato server
  • Supporta il download da server di più blocchi per accelerare il trasferimento di file
  • La gestione dei conflitti tra file è più user-friendly e simile a Dropbox (aggiunge nome dell’utente come suffisso al file in conflitto).

La nuova versione di Seafile (la 3.0), oltretutto, introduce delle novità sostanziali per quanto riguarda il server, mettendo sul piatto delle prestazioni notevolmente migliorate, insieme ad un sostanziale re-design della home page dell’applicazione, che adesso mostra molte più informazioni che riguardano il singolo file.

Tutto questo però comporta uno svantaggio: dato che sostanzialmente è cambiato il modello relativamente al quale il database viene strutturato, Seafile 2 e Seafile 3 non sono interoperabili: questo significa che un client Seafile 2.x non potrà scaricare nuove librerie create con il server 3.x, e viceversa un client 3.x non potrà creare librerie su un server con Seafile 2.x.