LUISS Enlabs – Security challenge

Segnaliamo per conto di Lupo Heusch un’opportunità lanciata all’interno dell’acceleratore di startup LUISS ENLABS.
Si tratta di un programma in partnership con Cisco Systems, InfoCert e NTT Data rivolto sia a startup che singoli talenti interessati a formare e/o unirsi ad un team per creare una startup nel settore della cybersecurity.

Il programma consiste in due fasi:
1) pre-accelerazione (formazione gratuita e rimborsata – 1.000€ ) della durata di 3 mesi
2) accelerazione (con pre-seed di 80.000€) della durata di 4 mesi per i team migliori.

Il 21 settembre, Augusto Coppola (direttore del programma di accelerazione a LUISS ENLABS) e Cisco saranno a Milano per presentare il programma e per un seminario su cosa vuol dire fare startup.

Di seguito il link per registrarsi all’evento, con tutte le informazioni:
http://luissenlabs.com/event/security-challenge-startups-wanted-milano/

Per saperne di piu’ e iscriversi al programma (deadline: 23 settembre) potete visitare il link:
http://luissenlabs.com/securitychallenge/

[#development #snippet] Singleton in Python

Ciao,

pubblico uno snippet che avevo prodotto per il mio progetto di tesi, che può tornare utile a chiunque, per implementare il pattern singleton in Python.

from __future__ import absolute_import
from functools import wraps
__author__ = 'Patrizio Tufarolo'

class SingletonException(Exception):
    pass

class Singleton(object):
    _instances = {}
    _configured = False
    def __new__(class_, *args, **kwargs):
        if class_ not in class_._instances:
            class_._instances[class_] = super(Singleton, class_).__new__(class_, *args, **kwargs)
        return class_._instances[class_]

    def configure(self):
        self._configured = True

    def check_configured(self):
        return self._configured

    @staticmethod
    def _if_configured(this_exception):
        if not this_exception or not issubclass(this_exception, SingletonException):
            this_exception = SingletonException

        def _configured_decorator(func):
            @wraps(func)
            def wrapper(inst, *args, **kwargs):
                if not inst.check_configured():
                    raise this_exception("Object not configured properly")
                else:
                    return func(inst, *args, **kwargs)

            return wrapper

        return _configured_decorator

L’implementazione fornita contiene però una peculiarità:
la mia necessità era quella di poter istanziare delle classi Singleton per lanciare delle routine di configurazione prima di poter effettivamente utilizzare un oggetto.
Alcuni metodi della mia classe Singleton, pertanto, devono poter essere eseguiti solo dopo la configurazione dell’oggetto.
L’espediente da me utilizzato per risolvere il problema è piuttosto banale: ho utilizzato un flag booleano (_configured), inizialmente settato a False.
Il metodo check_configure ne restituisce il valore, e il metodo configure lo imposta a True.
Per dichiarare poi i metodi eseguibili solo ad oggetti configurati utilizzo poi il decoratore _if_configured, la quale, nel caso l’oggetto non sia ancora stato configurato, solleva un’eccezione (anche personalizzabile, se la classe viene passata come parametro).

Per utilizzare il mio codice è sufficiente far ereditare la propria classe dalla classe Singleton da me fornita:

class CustomException(Exception):
    pass

class MioOggettoSingleton(Singleton):
    def __init__(self):
        '''do something cool'''
        Singleton.__init__(self)

    def configure(self):
        Singleton.configure(self)

    @Singleton._if_configured
    def metodo_eseguibile_solo_se_configurato(self):
        print("Ok oggetto configurato")

    def metodo_eseguibile_sempre(self):
        print("Vabbe io funziono sempre")

    @Singleton._if_configured(CustomException)
    def metodo_eseguibile_solo_se_configurato(self):
        print("Ok oggetto configurato")
        '''se non fosse configurato ritornerebbe un'eccezione'''

Spero vi sia utile!

Filibusta LUG 2015/2016 – Devuan Q/A

#!/bin/bash
cat > /dev/yourbrain << EOF
Ciao!
Venerdì 2 Ottobre alle 14.30 presenteremo Filibusta.
A partire dalle ore 15.00 si assisterà all'evento Devuan Q/A in diretta dal dipartimento di Comelico, con la partecipazine di Franco Lanza, fondatore del progetto Devuan.
Cosa aspetti? Unisciti a noi!
Ti aspettiamo in AULA 5 SUD!

Per maggiori informazioni sull’evento consultare Facebook all’indirizzo:
https://www.facebook.com/events/400879923443205/
Evento Devuan Q&A tenuto in via Comelico, in videoconferenza streaming presso il dipartimento di Crema:
https://www.facebook.com/events/967189586698098/
EOF

JCLOUDS – multi-cloud toolkit

Ciao a tutti,
visto che ci eravamo prefissati di aggiungere qualche post, e dato che mi farà comodo in futuro aver scritto qualcosa per poi ritornare a rileggerlo quando ne avrò bisogno, spero di fare cosa gradita postando questo semplice esempio che mostra come fare il deployment di una macchina virtuale su Openstack utilizzando jclouds.

Il vantaggio di utilizzare questa libreria java è il fatto di poter utilizzare lo stesso approccio per interfacciarsi con diverse tecnologie cloud ( Amazon AWS, CloudSigma, Openstack, HPCloud, SoftLayer, etc).

Per seguire questo tutorial i requisiti sono:

  • Avere una minima conoscenza del concetto di Cloud e di IaaS
  • Saper programmare utilizzando il linguaggio java
  • Avere una versione funzionante di openstack con una immagine registrata in glance pronta a essere deployata (in futuro prevedo di postare qualche tutorial per parlare piu’ in generale di cloud e in specifico di openstack, almeno la sua installazione e configurazione AllInOneNode)

 

jclouds è una libreria e in quanto tale deve essere importata nel vostro progetto. In questo tutorial ho utilizzato la versione 1.6 e in caso vi piaccia l’approccio maven (e dovreste) eccovi qui le librerie da usare:

 <dependency>  
    <groupid>org.jclouds.driver</groupid>  
    <artifactid>jclouds-log4j</artifactid>  
    <version>1.6.0</version>  
   </dependency>  
   <dependency>  
    <groupid>org.apache.jclouds</groupid>  
    <artifactid>jclouds-core</artifactid>  
    <version>1.6.1-incubating</version>  
   </dependency>  
   <dependency>  
    <groupid>org.jclouds.driver</groupid>  
    <artifactid>jclouds-slf4j</artifactid>  
    <version>1.6.0</version>  
   </dependency>  
   <dependency>  
    <groupid>org.jclouds.api</groupid>  
    <artifactid>openstack-nova</artifactid>  
    <version>1.6.0</version>  
   </dependency>  

L’utlizzo di jclouds per la creazione di una VM prevede 3 step principali (gli stessi che troveremo in qualsiasi altra situzione con approccio a un servizio cloud IaaS):

  1. la connessione al cloud provider (attraverso le credenziali)
  2. la creazione di un template
  3. il deployment

Il progetto java scaricabile qui è composto da 2 classi:

  • Deployer
  • Configuration

 

Configuration contiene tutte le informazioni necessarie alla connessione al cloud provider, mentre Deployer contiene la parte di core.

E’ quindi necessario inserire i propri dati nella parte di configurazione

 public class Configuration {
public static final String KEYSTONE_AUTH_URL = "http://192.xx.xx.xxx:35357/v2.0";
public static final String KEYSTONE_USERNAME = "xxxx";
public static final String KEYSTONE_PASSWORD = "xxxx";
public static final String KEYSTONE_ENDPOINT = "http://xxx.xx.xx.xxx:35357/v2.0";
public static final String TENANT_NAME = "xxxx";
public static final String NOVA_ENDPOINT = "http://xxx.xx.xx.xxx:5000/v2";
public static final String CEILOMETER_ENDPOINT = "";
}

Questi informazioni vengono poi utilizzate nello step1 per connettersi al cloud provider:

 ComputeServiceContext context = ContextBuilder.newBuilder("openstack-nova")
.endpoint(Configuration.NOVA_ENDPOINT)
.credentials(identity, credential)
.modules(modules)
.overrides(overrides)
.buildView(ComputeServiceContext.class);

Otteniamo così il compute service:

 ComputeService computeService = context.getComputeService(); 

Possiamo passare allo Step2 del processo. La creazione del template. jclouds mette a disposizione un TemplateBuilder in modo da mantenere l’astrazione fra il suo uso e le specifiche della cloud di destinazione. Nell’esempio il template creato richiede a openstack di fare il deployment utilizzanto un flavour che abbia almeno 512Mb di Ram e di instanziare una VM dall’immagine “RegionOne/f72885a5-e681-4219-b931-bb062d74c591” (precedentemente caricata in glance). jclouds per quanto riguarda le immagini salvate in opestack richiede la formattazione “<RegionIdentifier>/<ImageID>”.

Il codice di creazione del template:

 TemplateBuilder tb = computeService.templateBuilder(); 
tb.minRam(Integer.parseInt("512")); 
tb.imageId("RegionOne/f72885a5-e681-4219-b931-bb062d74c591");  

Creato il template non resta che passare allo step3 inviando il comando di deployment a Openstack.

 TemplateBuilder tb = computeService.templateBuilder();  
        NodeMetadata node1=null;  
           try {  
                node1 = getOnlyElement(computeService.createNodesInGroup(groupName, 1, tb.build()));  
           } catch (RunNodesException e) {  
                e.printStackTrace();  
           }  
        System.out.printf("<< node %s: %s%n", node1.getId(),  
         concat(node1.getPrivateAddresses(), node1.getPublicAddresses()));  

Come è facile intuire il concetto di VM, che si mappa come server in Openstack per jclouds è interpretato dalla classe Node.

Buon Divertimento!

Install Fest del 2 Aprile

Salve a tutti,
vi ricordo che per domani è previsto l’Install Fest, occasione nella quale avrete modo di installare Linux su una macchina virtuale o come sistema operativo secondario o principale sul vostro computer.
Si tratta di una fase essenziale per ogni partecipante del LUG.
Grazie a questa occasione potremo tutti allinearci dal punto di vista software, in modo da poter iniziare a toccare con mano il sistema operativo in tutti i suoi utilizzi e sfaccettature, ed organizzare talk su argomenti più avanzati.
Chiedo dunque che siano presenti, oltre agli interessati all’installazione, anche coloro che già sono esperti nell’utilizzo di questo sistema operativo, per aiutare chiunque avesse bisogno.
Un po’ di divertimento sarà garantito a tutti mediante un LAN party al gioco Urban Terror.
Ci troveremo dalle ore 16.00 in poi in LABORATORIO EST.
Tutto il materiale necessario è reperibile all’indirizzo:
http://filibusta.crema.unimi.it/~patrizio/install_fest/

All’indirizzohttp://filibusta.crema.unimi.it/~patrizio/install_fest/isos/troverete le ISO di
a) Debian 7.4 64bit
b) Fedora 20 64bit
c) Ubuntu 12.04.4 LTS 64bit
d) Ubuntu 13.10 64bit

All’indirizzo http://filibusta.crema.unimi.it/~patrizio/install_fest/virtualbox/
potete trovare il setup di Virtualbox sia per Windows che per Mac.

All’indirizzohttp://filibusta.crema.unimi.it/~patrizio/install_fest/games/urban_terror/
potete trovare il setup di Urban Terror (multipiattaforma).

– Invito tutti ad avvantaggiarsi nel download del materiale, onde non sovraccaricare troppo il server sul momento, che vi ricordo essere un Pentium 4. Per evitare ciò disporrò anche un mirror secondario per il download nella giornata di domani, e cercherò di portare un hard disk con il materiale per passarvelo via USB per le emergenze.

– Invito chiunque volesse installare Linux come sistema operativo principale (NON VIRTUALIZZATO) a portare con sé una pennetta USB funzionante di almeno 2GB.

– Invito ciascuno a portare un cavo Ethernet, onde lasciare la disponibilità delle patch del laboratorio agli altri studenti non interessati al LUG. Non staccate i cavi ethernet dalle macchine di laboratorio 

I router per il LAN party li porto io,
Buona serata, ci vediamo domani 

Slide del primo incontro (26/03/2014) e programmazione dell install-fest del 2 Aprile

Ciao a tutti,
grazie a coloro che hanno partecipato al primo incontro del Linux User Group nella giornata di oggi, e anche a chi non ha potuto partecipare ma che parteciperà le prossime volte 🙂
L’incontro introduttivo è stato da me incentrato sul sistema operativo Linux e sulle sue caratteristiche. Durante il talk ho mostrato le slide che vi allego qui sotto.

Ci siamo anche accordati per il prossimo meeting, che avverrà in data 2 aprile e si articolerà in un install-fest (installazione collettiva di una distribuzione Linux qualunque, aiutati e assistiti da chi già è esperto nell’utilizzo di questo sistema operativo) seguito da un LAN party (partita colllettiva in rete) con giochi open-source e free come Open Arena e Urban Terror.
Tutto il materiale sarà prossimamente e temporaneamente disponibile per il download sul server di Filibusta.

Durante il talk sono state avanzate anche molte proposte, come conferenze e lezioni a stampo sistemistico e tutorial su argomenti più o meno avanzati.

Tra le iniziative che abbiamo in mente, c’è anche la realizzazione del blog collettivo (verosimilmente questo). Chi voglia l’account su Filibusta e sulla piattaforma WordPress installata (per scrivere articoli sul sito) è pregato di chiedermelo inviandomi una mail all’indirizzo patrizio[dot]tufarolo[at]studenti[dot]unimi[dot]it.
Per scrivermi usate l’indirizzo di ateneo, così da poter verificare che mi arrivino le mail solo da effettivi membri e studenti dell’Università (per motivi di sicurezza non posso offrire l’accesso ai sistemi informatici dell’Università a gente esterna).

Spero che abbiate potuto apprezzare la mia iniziativa, così da poter formare un grande gruppo e diffondere la cultura open-source e il software libero.
Un saluto anche da Majin Tux che vi trasformerà tutti in chocotux.
Majin TuxChocoTux

Primo incontro di Filibusta

Ciao a tutti,
vi informo che Mercoledì 26 Marzo si svolgerà il primo incontro del LUG alle ore 16 e 15.
Si tratterà di un’assemblea introduttiva nella quale potremo esprimere le nostre singolari esigenze e quello che ci aspettiamo che avvenga nel gruppo.
Inizierò col mostrarvi le principali distribuzioni Linux, le loro differenze e i principali utilizzi di questo Sistema Operativo.
L’iniziativa l’ho presa io, ciò nonostante chiunque abbia qualcosa da dire o da mostrare, può tranquillamente farsi avanti… Linux è comunità!
Vi prego però di portare i vostri computer, in quanto non è possibile (credo momentaneamente) utilizzare Linux sulle macchine dell’Università.
Lunedì vi farò sapere l’aula che ci verrà assegnata.
Ciao 🙂

EDIT

L’incontro è confermato per Mercoledì 26 Marzo in aula 4 SUD alle 16.15 🙂 Vi aspettiamo!

IL LUG riapre!

Salve a tutti,
come avete potuto notare dalle innumerevoli rotture di palle tramite Facebook, e dai volantini appesi dove potevo in Università, il Linux User Group di Crema riapre, o almeno, ci provo.
Ho terminato oggi il remake grafico del sito, spero che lo apprezziate.
Spero che apprezzerete questa iniziativa, e mi auguro che possa costituire un punto di partenza per creare un gruppo di utenti Linux all’interno del nostro fantastico ateneo.

A breve mi armo per organizzare un primo incontro, nel frattempo vi invito a rimanere aggiornati tramite Facebook e questo blog per eventuali eventi.

Se avete voglia, iniziate a registrarvi , almeno vediamo di riempire un po’ questo blog ^_^
Buona serata a tutti!

Patrizio

Autenticazione automatica con OPENVPN

Ciao a tutti,
è un bel po che non scrivo sul sito del LUG.

Quello che vi propongo oggi è un metodo per autenticarsi automaticamente usando l’OPENVPN fornito dall’università per autenticarsi sulla rete wireless. So che non c’entra un cazzo con Linux, però è l’unica cosa che mi è venuta in mente di spiegare e mi sembra che come filosofia sia molto simile a quella del pinguino, ovvero fare il minimo possibile ottenendo ottimi risultati.

http://it.wikipedia.org/wiki/Virtual_Private_Network

Prima di tutto occorre scaricare l’openvpn adatto per connettersi all’hotspot presente in università, questo si può fare accedendo a questa pagina: http://vpn.divtlc.unimi.it/vpn.html. Ci sono due tipi di openvpn, a noi interessa la versione @studenti.unimi.it, se siamo studenti. Questo avviene perché professori (o corpo docente in generale) hanno accesso a differenti risorse.

La guida qui presente è ispirata da questa pagina http://tkhere.blogspot.com/2006/03/auto-authenticate-program-for-openvpn.html.

Si tratta di scaricare il programma AutoHotKey http://www.autohotkey.com/download/. Quest’ultimo permette di registrare delle macro scriptando codice a manina.

Una volta scaricato serve Notepad, con la quale scriveremo questo script:

#Persistent
SetTimer, EnterAuth, 250
return

EnterAuth:
Process, wait, openvpn-gui.exe, 2
If %ErrorLevel% = 0 
{
Run, %A_Programs%\OpenVPN\YourShortcuthere.lnk
Sleep, 2000
}
IfWinExist OpenVPN - User Authentication
{
ControlSetText, Edit1, YourUsernamehere, OpenVPN - User Authentication ahk_class #32770
ControlSetText, Edit2, YourPasswordhere, OpenVPN - User Authentication ahk_class #32770
ControlSend, Edit1, {Enter}, OpenVPN - User Authentication ahk_class #32770
}
return

Cambiando i campi YourUsernamehere con la vostra login (ad.es. mario.rossi@studenti.unimi.it) e YourPasswordhere.

Una volta fatto questo basta salvare il file con estensione .ahk.

A questo punto lo script è pronto, rimane da fare una cosa per “comodità”, ovvero convertire lo scritp in un .exe per facilitare il tutto. Scorrendo nel menù avvio è possibile trovare il convertitore da ahk a exe. A questo punto ci basta salvare l’exe sul desktop e con un semplice doppio click ci troviamo connessi alla wireless 🙂