Università degli Studi di Napoli Federico II Facoltà di ... - Scope

Università degli Studi di Napoli Federico IIFacoltà di Scienze MM.FF.NN.Corso di Laurea in InformaticaTesi Sperimentale di Laurea TriennaleAutenticazione su Grid mediante certificati Robot X.509Relatore CandidatoProf. G. RussoLuca GerardoDr. S. Pardi matr. 566/2636Anno accademico 2008/2009

RingraziamentiDesidero ringraziare il Prof. Guido Russo ed il Dott. Silvio Pardi per laloro immensa disponibilità e per la cortesia dimostratami durante losvolgimento dell'attività formativa. Ringrazio “i colleghi” della ControlRoom, in particolare Marco Alfano, per il supporto che mi hanno fornito.Ringrazio i compagni del corso di studi con cui ho condiviso le mieesperienze universitarie e gli amici del “Sabato pomeriggio” per inumerosi consigli di vita che mi hanno dato e che continuano a darmi.Un ringraziamento speciale va alla mia famiglia, che ha creduto in me enelle mie capacità e che mi ha sostenuto moralmente ed economicamentein tutti questi anni. Ringrazio mia madre per i tanti caffè che mi hapreparato e mio padre per i numerosi momenti che mi ha dedicato dopopranzo. Ringrazio mio fratello per essere stato una guida, oltre cheuniversitaria, di vita; mia sorella Marilena e Rino per avermi regalato duenipotini che mi hanno permesso di sorridere anche nei momenti piùdifficili, ed Antonella, con la speranza che me ne regali qualcuno anche lei.Infine, il ringraziamento più grande va a Bice, per il supporto morale chemi ha fornito, per aver creduto nelle mie capacità e per essermi statasempre vicino.A tutti, infinitamente grazie di cuore!!!

Indice generale1. Introduzione...............................................................................................................32. Il Grid Computing.......................................................................................................62.1 Introduzione.........................................................................................................62.2 Il modello a clessidra...........................................................................................72.3 Il concetto di Virtual Organization.....................................................................133. L'infrastruttura ScoPE e le nuove comunità scientifiche.........................................163.1 Introduzione.......................................................................................................163.2 Il progetto SCoPE.............................................................................................163.3 L'architettura della Griglia Computazionale......................................................194. Il modello di sicurezza GSI ed il servizio VOMS.....................................................244.1 Introduzione.......................................................................................................244.2 I certificati X.509................................................................................................264.3 Public Key Infrastructure...................................................................................324.4 La mutua autenticazione server........................................................................344.5 Il servizio VOMS................................................................................................355. Un'estensione del servizio VOMS con certificati Robot..........................................415.1 Concetto di certificato Robot.............................................................................415.2 Estensione delle facility del VOMS...................................................................416. L'attività sperimentale..............................................................................................466.1 Descrizione dell'applicazione web....................................................................466.2 L'architettura della Web Application..................................................................516.3 Le tecnologie utilizzate......................................................................................536.4 Use Case...........................................................................................................556.5 Diagrammi di Cockburn.....................................................................................566.6 Class Diagram...................................................................................................616.7 Sequence Diagram...........................................................................................63Luca Gerardo 566/2636 Pagina 1 di 113

7. Testing e scenari applicativi.....................................................................................687.1 Validazione e Testing........................................................................................687.2 Applicazione per creare portali web di accesso alla GRID...............................708 Conclusioni...............................................................................................................749. Bibliografia...............................................................................................................7510. Appendice: Codice ...............................................................................................76Luca Gerardo 566/2636 Pagina 2 di 113

1. IntroduzioneLa presente tesi, effettuata presso il Data Center S.Co.P.E., ha l'obiettivo di studiare esperimentare l'utilizzo di certificati robot in ambiente Grid senza perdere informazionisull'effettivo utilizzatore. È stata quindi proposta ed implementata una strategiaestendendo le funzionalità del servizio di Virtual Organization Membership tramite larealizzazione di un'applicazione web per l'iscrizione ad una Grid Virtual Organization.Tale applicazione prevede, per l'iscrizione dell'utente, l'associazione ad un certificatorobot piuttosto che l'identificazione tramite certificato personale.Attualmente, infatti, l'iscrizione ad una VO è concessa solo ad utenti in possesso di unceritificato personale rilasciato dall'autorità competente CA (Certification Autority)dopo che una RA (Registration Autority) abbia accertato la loro identità.Solo nel momento in cui si dispone di tale certificato, può essere effettuata unarichiesta di iscrizione ad una o più VO: una volta iscritti, è possibile sfruttare i servizida essa offerti.Dato che un certificato personale ha validità annuale, ogni utente deve, di volta involta, richiederne il rinnovo all'autorità competente.La richiesta di rilascio del suddetto certificato da parte di un utente, al fine di potersfruttare le risorse hardware e software fornite da una VO, potrebbe essere visto comeun limite.L'obiettivo principale dell'applicazione da me realizzata è quello di ampliare i serviziofferti dalla VO e di rendere più veloce ed accessibile l'iscrizione e, di conseguenza,l'utilizzo dei servizi che vengono messi a disposizione dell'utente, favorendo così lasua diffusione ed ampliando così il suo bacino di utenza.Per poter raggiungere tale obiettivo, la mia applicazione prevede l'associazione di uncertificato Robot a più utenti, evitando quindi che questi ultimi richiedano uncertificato personale.Il certificato Robot è un certificato particolare salvato su un supporto fisso (e-tokenUSB) che è legato ad un'applicazione piuttosto che ad una persona.La problematica principale a cui si va incontro nel momento in cui si associa talecertificato a più persone contemporaneamente, è quella di tenere traccia dell'effettivoLuca Gerardo 566/2636 Pagina 3 di 113

utilizzatore del certificato.Infatti, attualmente, associare uno stesso certificato Robot a più utenti, comportal'impossibilità di risalire all'identità del singolo utente che ha utilizzato o stautilizzando il certificato in un preciso momento.La soluzione, adottata per risolvere il problema, è quella di creare un role univoco perciascun utente ed associare quindi tale role al certificato Robot, in modo da riuscire atener traccia delle operazioni effettuate dai singoli utenti che fanno uso di talecertificato.Il role utilizzato per ciascun utente è la propria mail. Questo fa sì che venga garantital'univocità.In particolare l'applicazione, da me sviluppata, offre la possibilità a qualsiasi utente diaccedere ad una pagina di iscrizione, nella quale vengono richieste sia diverseinformazioni personali dell'utente, quali nome, cognome ed e-mail, sia l'esplicitarichiesta del certificato robot da usare per l'associazione del role a quest'ultimo.Il modello architetturale dell'applicazione da me realizzata è di tipo Client/Server.Il software è stato suddiviso in tre moduli, quali la User Interface per la presentazionedei dati, la businness logic che è il cuore dell'applicazione e che si occupa della logicaapplicativa, ed il terzo modulo che si occupa di tutto ciò che riguarda la persistenza deidati. Si è scelto l'utilizzo di tale architettura per favorire la portabilità, l'estendibilità ela manutenibilità dell'applicazione stessa.I linguaggi utilizzati per lo sviluppo di tale applicazione sono stati:• html per la presentazione;• javaScript, linguaggio di scripting, utile oltre che per la realizzazionedell'interfccia, anche per un primo controllo dei dati “lato Client”, evitandocosì inutili passaggi di dati fra client e server nel caso in cui questi dovesseroessere errati;• MySQL: per la gestione del Database;• java, in particolare tecnologia servlet/JSP mediante l'utilizzo di server basati sujava per la programmazione Web lato Server.È stato quindi necessario anche l'utilizzo di un Application Server, quale Tomcat. Si èscelto di utilizzare le servlet per motovi di efficienza e scalabilità, che esse forniscono,Luca Gerardo 566/2636 Pagina 4 di 113

e per l'ottima interazione con il server che si ottiene, visto che queste vengonoeseguite dallo stesso processo.Per il reperimento dei dati all'interno del database è stato utilizzato un linguaggio diinterrogazione strutturato, quale SQL.La tesi è stata suddivisa principalmente in dieci capitoli, dove i primi tre risultanoessere introduttivi trattando argomenti come le griglie computazionali e l'infrastrutturaS.Co.Pe.Il quarto capitolo tratta la sicurezza in ambito grid e l'uso dei certificati nei medesimiambienti con relativa autenticazione.Il quinto capitolo tratta i certificati Robot e nel sesto capitolo vengono esposti glistrumenti e le tecniche utilizzate per lo sviluppo della suddetta applicazione nonchél'attività sperimentale.Il settimo capitolo si occupa del testing e dei possibili scenari applicativi.Infine i restanti tre capitoli sono relativi alle conclusioni, alla bibliografia ed al codicein Appendice.Luca Gerardo 566/2636 Pagina 5 di 113

2. Il Grid Computing2.1 IntroduzioneLe Grid o griglie nascono inizialmente per soddisfare richieste di potenza di calcolo, dimemoria e di spazio fisico, presentate da applicazioni della scienza e dell'ingegneriaavanzata le quali, giorno dopo giorno, necessitano, in modo sempre più insistente, di talirequisiti per poter raggiungere i propri obiettivi.Il concetto di fondo delle Grid è collegare, su larga scala, risorse di calcolo eterogenee,distanti tra loro e gestite da persone o enti differenti[1].Una Grid è una infrastruttura che mette a disposizione degli utenti risorse di calcolo, dimemoria e di spazio. Le stesse risorse possono essere utilizzate, in modo differente, aseconda dei vincoli posti sulla condivisione e sugli obiettivi prefissati.Uno degli aspetti importanti, di cui tale infrastruttura deve occuparsi, sono le funzioni dimonitoraggio di tali risorse e la continuità del servizio, che essa deve garantire, in modotale che l'utente finale possa fare sempre affidamento sulla sua disponibilità. Ultimoaspetto, ma non per importanza, di cui la Grid deve tener conto, è l'affidabilità, ovverola capacità di minimizzare quelli che sono i problemi che possono verificarsi in ambitoGrid, come un guasto di un componente hardware o software.La tecnologia Grid non può essere considerata una tecnologia rivoluzionaria in quantoessa contiene al suo interno tecnologie già esistenti quali il calcolo distribuito, il webservices, internet e le diverse tecnologie crittografiche per la sicurezza di taleinfrastruttura. Per questa ragione, la tecnologia Grid viene definita una tecnologia “inprogress”.Il “life motive” che sta alla base della tecnologia Grid è la virtualizzazione. Essapermette di integrare sistemi eterogenei e geograficamente distribuiti, facendo in modoche l'utente possa utilizzarli in modo del tutto trasparente.Esistono diversi tipi di Grid, quali:• le Grid computazionali o computational Grid;• le Grid di dati o data Grid;• le Grid di applicazioni e servizi.Una Grid computazionale è l'aggregazione di risorse computazionali differenti fra loro eLuca Gerardo 566/2636 Pagina 6 di 113

geograficamente distribuite. Tale accorpamento di risorse viene sfruttato concedendopotenza di calcolo su richiesta agli utenti che lo desiderano.Una Grid di dati, invece, nasce per contenere e mettere a disposizione degli utenti unagrande quantità di dati, distribuita in domini differenti.Oltre alle Grid appena enunciate, ne esistono altre come, ad esempio, BioGrid, SensorGrid, Cluster Grid ed altre ancora che, con il passare del tempo, ampliano il loro bacinodi utenza, favorendo così la loro diffusione.Definizione tipica del Grid è “coordinated resource sharing and problem solving indynamic, multi-instituzional virtual organizations”[2]. Come affermatoprecedentemente, per condivisione di risorse non si intende soltanto lo scambio di file,bensì l'accesso diretto a computer, software, dati ed altre risorse. Il concetto di“virtualizzazione” fa sì che l'utente creda, nel momento in cui usufruisce dei serviziofferti dalla grid, di avere a che fare con un unico e super potente calcolatore.2.2 Il modello a clessidraI grandi sistemi informatici sono sempre scomposti in sottosistemi che fornisconoservizi correlati. L'architettura del software influenza diversi fattori, quali prestazioni,affidabilità, sicurezza, protezione, disponibilità e manutenibilità. A seconda delleesigenze, si cerca di soddisfare alcuni di essi a discapito degli altri, cercando comunquedi trovare il giusto compromesso. L'architettura di una Grid è un architettura a strati,dove ognuno di essi mette a disposizione dei servizi, mediante la propria interfaccia,per gli strati superiori e beneficia degli stessi messi a disposizione dagli strati inferiori.Un servizio messo a disposizione da uno strato non è altro che l'insieme dei protocolliannessi “al comportamento” che esso implementa. L'approccio stratificato prediligeaspetti come la protezione, lo sviluppo incrementale del sistema, la manutenibilità e laportabilità: fino a quando le interfacce non vengono modificate, è possibile sostituireogni strato con un altro ad esso equivalente senza influire negativamente sugli stratiadiacenti. Essendo la protezione un requisito critico, si fa in modo che le risorse chedevono essere protette, vengano inserite nello strato più interno dell'architettura.L'architettura stratificata possiede anche degli svantaggi: solitamente gli strati interniLuca Gerardo 566/2636 Pagina 7 di 113

forniscono delle funzionalità basilari o, come nel nostro caso, delle risorse. Il più dellevolte, tali funzionalità sono richieste dalla maggior parte dei livelli. Con un approcciodel genere, la richiesta di una funzionalità da parte di uno strato situato ad un livello piùalto rispetto a quello preso in considerazione, comporterebbe l'interpretazione dellarichiesta ad ogni livello. Quindi, i servizi richiesti da un utente ad un livello superioredevono, per accedere ai servizi offerti dai livelli sottostanti, passare attraverso gli stratiadiacenti. Per sopperire a queste problematiche, l'architettura Grid è organizzata inmodo tale da essere un'architettura a strati aperta. In tale architettura, gli strati cheforniscono servizi basilari sono resi accessibili non solo al livello adiacente, ma anche aquelli situati “più in alto”: verrà così favorita l'estendibilità, l'interoperabilità e laportabilità. Ovviamente, oltre ai vantaggi appena esposti, questo tipo di architetturacomporta anche degli svantaggi: modificare l'interfaccia di un livello al quale accedonopiù strati, significa modificare anche tutti gli strati che sfruttano tali servizi.Per comprendere meglio la scomposizione in strati dell'architettura facciamo riferimentoalla seguente immagine:fig. 1Luca Gerardo 566/2636 Pagina 8 di 113

In figura 1 è possibile notare ciò che è stato descritto precedentemente: il livelloApplication sfrutta i servizi offerti dai livelli Connectivity, Resource e Collective,eliminando quelli che sono gli svantaggi di un'architettura stratificata chiusa a discapitodella manutenibilità. In secondo luogo, sono evidenziati quanti e quali sono i livelli checostituiscono tale architettura, identificando quindi i componenti principali del sistema.Essendo il Grid una struttura che deve permettere relazioni di condivisione tra ipartecipanti, aspetto molto importante è giocato dall'interoperabilità. Nelle retiinformatiche l'interoperabilità è sinonimo di “protocolli comuni”, indi per cuil'architettura Grid è prima di tutto un'architettura di protocolli utilizzati per negoziare,usufruire e gestire relazioni di condivisione di risorse. Ciò che il Grid vuole garantire èla possibilità di iniziare e creare arbitrariamente relazioni di condivisione tra le parti,agevolando l'integrazione di nuovi partecipanti in modo dinamico. In assenza diinteroperabilità, gli utenti sono costretti a creare un accordo bilaterale di condivisione,impedendo che quest'ultimo possa essere esteso anche ad altre parti.La presenza di tali protocolli permette quindi di specificare come gli elementi, che sonoparte del sistema distribuito, interagiscono fra di loro.Oltre a quelli che sono i protocolli, i servizi e l'interoperabilità, un ruolo fondamentalein ambito Grid è rivestito dalle APIs (Application Programming Interfaces) e dall'SDKs(Software Development Kits) che permettono agli sviluppatori di realizzare, in modoveloce e portabile, applicazioni per ambienti Grid corrette e robuste.Un progetto molto importante relativo al Grid Computing è stato Globus. GlobusToolkit, oltre a sviluppare e quindi a fornire protocolli fondamentali per gli ambientiGrid, offre un toolKit, e quindi degli strumenti di sviluppo software, per realizzareapplicazioni Grid portabili, robuste ed efficienti in modo veloce.I livelli dell'architettura Grid sono cinque e vengono di seguito descritti:• Il livello Fabric: fornisce le risorse messe a disposizione dall'architettura, comead esempio risorse computazionali, sistemi di archiviazione e sensori, quandoci riferiamo alle risorse intese come entità fisiche; oppure file systemdistribuiti, quando parliamo di risorse viste come entità logiche. Le risorsepresenti in questo livello dovrebbero mettere in atto meccanismi tali dapermettere agli utilizzatori di conoscere, quanto meno, la propria struttura ed ilLuca Gerardo 566/2636 Pagina 9 di 113

proprio stato; ed agli sviluppatori di implementare servizi di gestione dellerisorse per il controllo del QoS (Quality of Service).Le risorse che possono essere trovate in questo livello sono:• risorse di calcolo, richieste per eseguire programmi e monitorare econtrollore l'esecuzione dei processi creati;• risorse di archiviazione, per il salvataggio e reperimento di file. Ancheper questo tipo di risorse sono utili funzioni atte a rendere noto il lorostato e le caratteristiche hardware e software;• risorse di rete, per il trasferimento dati. Importanti, in questo caso, sonole funzioni di richiesta per determinare lo stato della rete ed il suocarico;• catalogs, specializzato all'archiviazione di risorse;• Il livello Connectivity: gioca un ruolo di fondamentale importanza all'internodella struttura stratificata perché racchiude i protocolli di comunicazione e diautenticazione in ambiente Grid. I protocolli di comunicazione qui presentipermettono lo scambio di dati tra le risorse del livello sottostante. L'insieme deiprotocolli di comunicazione è costituito da protocolli di rete, di trasporto e diapplicazione. Vengono quindi utilizzati i protocolli presenti nello stack delmodello ISO/OSI: ci si riferisce, rispettivamente, ai protocolli IP ed ICMP peril livello di rete, TCP ed UDP per il livello di trasporto e DNS e OSPF ed altriper il livello di applicazione. Per quanto concerne, invece, i protocolli diautenticazione, questi forniscono meccanismi di sicurezza facendo in modo chevenga verificata sia l'identità delle risorse che degli utenti. Le soluzioni diautenticazione per una Virtual Organization dovrebbero possedere le seguenticaratteristiche:• Single sign on : consiste nel dare la possibilità all'utente di autenticarsial sistema un'unica volta, facendo in modo che successivamente possautilizzare le risorse presenti al livello Fabric senza la necessità diulteriori autenticazioni;• Delegation : è un meccanismo che permette ad un utente di delegare unprogramma per lo svolgimento dei compito per cui è stato invocato,Luca Gerardo 566/2636 Pagina 10 di 113

facendo in modo che esso abbia, sulle risorse del sistema, le stesseautorizzazioni dell'utente che lo ha invocato;• Integration with various local securety solutions: ogni fornitore dirisorsa può attuare delle soluzioni di sicurezza locale sulle singolerisorse. Le soluzioni di sicurezza adottate in ambiente Grid devonoessere capaci di interoperare con le soluzioni di sicurezza adottatelocalmente dalle singole risorse.• User-based trust relationschips: si intendono relazioni di fiducia basatasugli utenti. L'utilizzo da parte di un utente di più risorsecontemporaneamente non appartenenti allo stesso sito, non implical'interazione degli amministratori della sicurezza delle singole risorse.• Il livello Resource: tale livello poggia su quello connectivity, sfruttando quindiquelli che sono i servizi messi a disposizione da quest'ultimo. In questo livellole risorse vengono prese in considerazione singolarmente. I protocolli quidefiniti sono utilizzati per la negoziazione delle risorse, per il loro controllo edil loro monitoraggio. Principalmente i protocolli qui presenti si dividono in duetipologie:• Information protocols, usati per reperire informazioni dalle singolerisorse come il loro stato, il loro carico, o la loro politica di utilizzo;• Management protocols, utilizzati per la gestione delle risorse o, permeglio dire, per la negoziazione dell'accesso alle risorse condivise. Inquesta tipologia di protocolli sono presenti anche quelli che prevedono,come detto precedentemente, il monitoraggio dello stato delleoperazioni ed il loro controllo.• Il livello Collective: diversamente dal livello su cui poggia, il livello collectivesi concentra sull'interazione delle singole risorse e quindi considera unacollezione di risorse. Di conseguenza i protocolli qui definiti non sono associatialle singole risorse ma gestiscono appunto la loro interazione. In questo livellosono presenti diversi servizi:• Directory services: permette agli utenti di una Virtual Organization dieffettuare ricerche di risorse per nome, per attributi, per carico o perLuca Gerardo 566/2636 Pagina 11 di 113

disponibilità. I protocolli utilizzati per tali servizi sono il GRIP ed ilGRRP.• Co-allocation, scheduling and brokering services: tali servizipermettono agli utenti di una Virtual Organization l'allocazione di una opiù risorse per fini specifici e la schedulazione dei tasks sulle varierisorse. Il brokering services è un servizio che cerca, data una richiesta,le risorse adatte a soddisfare, nel modo più efficiente, i compiti richiesti.• Monitoring and diagnostics services: utilizzato per monitorare le risorsein termini di errori verificatisi, di sovraccarico e di attacchi subiti.• Altri;• Il livello Applications: è l'ultimo livello dell'architettura stratificata ecomprende le applicazioni utente che operano in ambito Grid. Mediante esse,l'utente accede a quelli che sono i servizi Grid. Dal punto di vista delprogrammatore, un'applicazione è definita e richiama i servizi messi adisposizione dei livelli sottostanti. Come già detto precedentemente, ognilivello mette a disposizione dei livelli superiori, delle interfacce per accedere aipropri servizi. Le applicazioni dell'ultimo livello possono, essendo l'architetturaGrid un 'architettura a strati aperta, accedere ai servizi messi a disposizione daqualsiasi livello sottostante. Per servizi si intende la gestione delle risorse,l'accesso ai dati ed il reperimento delle risorse.Definita quella che è l'architettura di una Grid, possiamo rappresentare quest'ultima conun modello a clessidra (vedi fig. 2): è possibile notare un “collo di bottiglia” al centrodella clessidra. Questa parte della clessidra, che rappresenta gli strati Resource eConnectivity, e di conseguenza i protocolli in essi contenuti, è comunemente dettoanche middleware (strato centrale). All'interno del middleware troviamo quindi API edSDK. Poiché questi ultimi sono fondamentali per la realizzazione di una Grid, iprotocolli presenti negli strati Resource e Connectivity devono essere pochi e bendefiniti. Un middleware di ultima generazione utilizzato in ambito Grid è gLite.Luca Gerardo 566/2636 Pagina 12 di 113

fig. 2Il middleware ha il compito di “far interagire” le applicazioni utente con le risorse veree proprie.Esso fornisce• meccanismi di comunicazione ed autenticazione;• meccanismi per il monitoraggio delle singole risorse e per il loro reperimento;• informazioni inerenti al loro stato.Un middleware è principalmente costituito da due parti fondamentali: i servizi core ed iservizi collective.I servizi core consentono l'inserimento di risorse locali all'interno dell'infrastrutturaGrid, richiedendo management locale quali ad esempio start-up, aggiornamenti etroubleshooting.I servizi collective consentono agli utenti l'uso trasparente delle risorse di storage ecomputing.Entrambi i servizi saranno trattati in modo più approfondito nel capitolo successivo.2.3 Il concetto di Virtual OrganizationIl motivo per cui nascono le griglie computazionali, come già detto, non è tanto peragevolare lo scambio di file, ma piuttosto per fornire un accesso diretto a computer,software, dati e altre risorse in modo tale da sopperire a quelle che sono leLuca Gerardo 566/2636 Pagina 13 di 113

problematiche che i campi della scienza e dell'ingegneria avanzata si trovano, giornodopo giorno, ad affrontare.Il termine Virtual Organization (VO) indica un insieme di individui e/o istituzioni che,per poter raggiungere fini comuni, hanno bisogno di condividere risorse hardware esoftware sulla base di regole ben definite[3]. Le VO differiscono fra loro in dimensione,numero di partecipanti, durata, struttura e fine o tipo di attività svolto. Ciò nonostanteesse sono accomunate da esigenze simili, quali, ad esempio, la necessità dell'esistenzasia di relazione di condivisione altamente flessibile di risorse, sia di livelli di controllosulle risorse condivise nei quali sono inclusi gli accessi controllati, le delegazioni, el'applicazione di politiche locali e globali. Un esempio di VO può essere l'insieme degliingegneri di una compagnia di progettazione aerea, distribuiti su diversi centri, checondividono brevetti, risorse di calcolo e software di simulazione.fig. 3Un organizzazione può essere parte di una o più VO, decidendo di mettere adisposizione dei partecipanti tutte o parte delle proprie risorse, siano essecomputazionali, di storage e quant'altro. La condivisione di risorse è condizionale. Ilproprietario della risorsa può decidere di porre dei vincoli su come, quando e chi deveutilizzare quella specifica risorsa, così come “il consumatore” può porre dei vincoliLuca Gerardo 566/2636 Pagina 14 di 113

sulle risorse da individuare per poter soddisfare le proprie esigenze e svolgere quindi ipropri task, come ad esempio il suo carico. Per poter implementare i vincoli appenacitati, si necessita di meccanismi che offrono la possibilità di esprimere politiche sia alfine di stabilire l'identità dei consumatori e/o delle risorse (in questo caso parliamo diautenticazione), sia al fine di determinare quali operazioni sono consentite ( in questocaso parliamo di autorizzazione). La stessa risorsa può essere usata in modi differenti aseconda degli obiettivi della condivisione. É importante notare che le relazioni dicondivisione possono variare nel tempo e questo giustifica la definizione di VO citataquando si è parlato di dinamicità.fig. 4Nella fig. 4 è rappresentata la struttura di una VO. In essa è presente un manager checura la gestione, i membri della VO, ad ognuno dei quali possono essere associati uno opiù ruoli, e gli utenti che hanno la possibilità di accedere ai servizi offerti dalla VOmediante User Interface. Non possono infine mancare quelle che sono le risorse dacondividere per fornire i servizi ai partecipanti.Luca Gerardo 566/2636 Pagina 15 di 113

3. L'infrastruttura ScoPE e le nuove comunità scientifiche3.1 IntroduzioneNapoli, grazie all'Università degli Studi di Napoli Federico II, è uno dei centri dieccellenza nel settore scientifico. L'ateneo infatti ha dei centri di ricerca e di sviluppoubicati in diverse zone della città e collegati fra di loro grazie ad una infrastruttura adanello di fibra ottica con velocità di 2.4 Gbit/sec upgradabile fino a 10 Gbit/sec.fig. 5Tale collegamento garantisce un'ottima comunicazione fra le varie sedi per lo scambioed il trattamento delle risorse. Per poter unire le sinergie dei dipartimenti e le strutture diricerca afferenti o in collaborazione con la Federico II e per supportare le esigenze dicalcolo dei ricercatori, dei docenti e degli studenti, l'ateneo si è dotato di sistemi dicalcolo e di storage ad alte prestazioni.Viene ideato così il progetto ScoPe.3.2 Il progetto SCoPEIl progetto SCoPE, il cui acronimo sta per “Sistema Cooperativo Distribuito ad altePrestazioni per Elaborazioni Scientifiche Multidisciplinari”, è stato finanziato con iLuca Gerardo 566/2636 Pagina 16 di 113

fondi PON del 2000/2006 per la Ricerca Scientifica, Sviluppo, Sviluppo Tecnologico,Alta Formazione.L'architettura di SCoPE, sulla base di una preesistente infrastruttura di retemetropolitana, che connette al Gbit tutte le maggiori strutture di ricerca dell'ateneo,prevede di integrare le risorse di calcolo e storage attualmente disponibili, con un nuovohardware ad alte prestazioni. Tali risorse verranno poi inglobate in unica piattaforma ditipo Grid, basata su middleware di nuova generazione.L'obbiettivo finale è quindi la realizzazione di un Data Center (Fig. 6) con un sistema dicalcolo ad alte prestazioni, orientato ad applicazioni scientifiche multidisciplinari, cheoperi secondo il paradigma Grid [nota], dedicato alla modellistica computazionale edalla gestione di grandi banche dati per le ricerche nelle aree applicative di interesse delprogetto e quindi a supporto della ricerca di base e delle piccole e medie imprese.fig. 6Le quattro aree applicative del progetto sono:• Scienze del Microcosmo e Macrocosmo, le cui applicazioniriguardano tematiche quali:▪ Astrofisica: studio del modello di analisi dati nell'ambito dellastruttura cosmica su larga scala;▪ Fisica Subnucleare: l'attività consiste nello studio delleinterazioni protone-protone ad altissima energia pressol'accelleratore LHC (Large Hadron Collider) del CERNLuca Gerardo 566/2636 Pagina 17 di 113

(esperimento ATLAS);▪ Elettromagnetismo e telecomunicazioni: progetto in una rete disensori in connessione wireless operanti in architettura Grid erealizzazione di un test-bed per una città sicura.Queste tematiche hanno un alto costo computazionale e richiedonoaccesso sequenziale a grandi quantità di dati.• Scienze dei materiali e dell'ambiente, il cui scopo riguarda losviluppo di metodi teorici e protocolli computazionali per lamodellazione delle proprietà strutturali e spettroscopiche di polimeri edi sistemi nanostrutturati.• Scienze della vita, prevede lo studio modellistico-computazionale deimeccanismi fondamentali alla base di processi di interesse biologico el'interfacciamento di database bioinformatici con metodi di simulazionemolecolare. Le tematiche affrontate sono l'analisi comparative disequenze genomiche, l'analisi di proteomi, la proteomica funzionale.Il Data Center, realizzato su una poternte infrastruttura di calcolo fornito dalla Dell, èstato inaugurato il 1° Dicembre 2008 e si inserisce nel sistema di Grid Computingnazionali ed internazionali, confermandosi tra i centri più compleri d'Italia, grazie aglioltre 300 server, costituiti da doppia CPU quad core per un totale di 2432 core,raggruppati in 16 blade per chassis (fig 7), e 200 Terabyte di spazio disco.fig. 7Il Data Center è parte della “struttura di calcolo avanzato dell'Italia Meridionale edinsulare per la ricerca e l'innovazione tecnologica basata su griglie computazionali adLuca Gerardo 566/2636 Pagina 18 di 113

alte prestazioni” denominata GRISU' (Griglia del Sud).Il progetto SCoPE si è concluso formalmente il 28 Febbraio 2009 e il Data Centerrealizzato è stato affidato dal Rettore in gestione operativa ordinaria al CSI (Centro diServizi di Ateneo) e ad un comitato scientifico che ne individui le linee strategiche e diindirizzo in coerenza con le finalità e con gli obiettivi elencati dagli accordi sottoscritti.3.3 L'architettura della Griglia ComputazionaleL'architettura del Data Center SCoPE è un'architettura stratificata aperta, la cuipeculiarità sta nell'agevolare l'estendibilità, la manutenibilità, l'interoperabilità e laportabilità richieste dalla Griglia Computazionale.La piattaforma di tipo Grid su cui saranno inglobate le risorse gestite dal centro SCoPEsi basa su un middlware di nuova generazione.Middleware, costituisce l'insieme dei protocolli, servizi, API e SDKs necesari alfunzionamento dell'infrastruttura Grid. Fornisce meccanismi di autenticazione eautorizzazione e la possibilità di utilizzare le risorse implementando servizi atti alla loroscoperta e al loro utilizzo. É un software che gestisce tutte le risorse del calcolodistribuito. Il middleware di SCoPE è un INFNGRID: garantisce• piena compatibilità con il middleware EGEE (gLite/LCG);• release e aggiornamenti/bugfix frequenti;• semplicità di integrazione con l'infrastruttura Grid italiana (Grid.it) edeuropea (EGEE);• disponibilità di tool consolidati nati in ambito INFN ed utilizzati indiversi progetti ed infrastrutture Grid esistenti (GridICE, VOMS,DGAS Distributed Grid Accounting System);• supporto tecnico sulla release e sui tool con la possibilità di comunicaredirettamente con gli sviluppatori del middleware.L'architettura generale di un sito Grid mostra il middleware diviso in due areeprincipali:• servizi “core”;• servizi “collective”.Luca Gerardo 566/2636 Pagina 19 di 113

Vi sono inoltre servizi utili e a volte necessari al deployment e alla gestione delleinfrastrutture .fig. 8I servizi “core” sono servizi locali che permettono di condividere, risorse di calcolo e distorage e virtual instruments. Sono presenti in tutti i siti e sono implementati da GridElement , dove per Grid Element si intende un host che:• fornisce uno o più servizi ( siano essi collective o core);• fornisce metodi per l'accesso a tali servizi• è in grado di rendere note informazioni sulle caratteristiche e sullo stato deiservizi;• è capace di interagire con altri elementi grid o con gli utenti direttamente.I servizi core sono:▪▪repository pacchetti del middlware (YAIM) contiene una replica dei pacchettiINFNGRID e degli aggiornamenti del sistema operativo e tool automatici perl'installazione e l'aggiornamento dei nodi Grid; consente inoltre l'installazioneautomatica del sistema operativo tramite PXE (sistema di boot remoto);servizi di computing (Computing Element e Worker Node): i ComputingElement rappresentano l'interfaccia Grid verso una Farm costituita da nodi diLuca Gerardo 566/2636 Pagina 20 di 113

calcolo (Worker Node – WN) e gestiscono i job di calcolo tramite un batchqueuesystem, attraverso il quale è possibile partizionare l'insieme di risorse dicalcolo (CPU) e definire delle policy di utilizzo da parte delle varie VO (CPUtime, numero di job concorrenti) mediante la creazione di code batch. Essi sonodotati di certificato digitale (rilasciato al momento dalla CA INFN) che attestal'attendibilità delle transazioni. I Worker Node rappresentano host disponibiliper l'esecuzione di job e vengono gestiti/allocati dai Computing Element(figura 9) contengono l'execution environment del processo di calcolo (libreriedi esperimento, toolkit, etc.);fig. 9▪▪servizi di storage (Storage Element) costituiscono lo spazio di storage Grid;mettono a disposizione, delle diverse VO, interfacce utili alla gestione dellospazio locale e fanno uso del protocollo GridFTP per il trasferimento di file.Ciascun Storage Element è fornito di certificato digitale (rilasciato dalla CAINFN) che attesta l'attendibilità delle transazioni e che permette la mutuaautenticazione;User Interface (UI) obiettivo principale è permettere l'accesso alle risorsemesse a disposizione dalla Grid. Mediante essa è possibile sottomettere,visualizzare e cancellare job, nonché recuperare il loro output. L''utente puòaccedere all'UI e sfruttare le risorse del Grid tramite collegamento remoto diuna UI di infrastruttura o di gruppo (SSH, et..), oppure tramite un PC desktop onotebook personale configurato con i componenti della UI, ma non prima diaver installato il proprio certificato personale o di poter utilizzare un certificatoRobot.Luca Gerardo 566/2636 Pagina 21 di 113

fig. 10I servizi collective sono servizi distribuiti o centralizzati che lavorano al di sopra dellerisorse locali costituendo l'infrastruttura distribuita. Sono implementati da Grid Elemented hanno valenza collettiva. Essi permettono l'utilizzo “trasparente”, dal punti di vistadell'utente, delle risorse messe a disposizione dalla Grid, quali Storage Element eComputing Element. Richiedono, inoltre, un team di management locale per garantire iservizi di start-up, di aggiornamento e di troubleshooting; il supporto agli utenti finali eai site-manager dei siti periferici e la continuità del servizio.I servizi collective sono:▪ servizio VOMS (Virtual Organization Membership Service) inserisceinformazioni aggiuntive nel certificato proxy di un utente, quali VO diappartenenza, gruppo, ruolo e privilegi facendo in modo, quindi, che lepolitiche di autorizzazioni si basino anche, ma non necessariamente, su questeinformazioni aggiuntive. Consente la gestione degli utenti tramite interfacciaweb e con un solo server VOMS è possibile gestire più VO;▪ servizi di allocazione dei job (Resource Broker) consentono il marchmaking,cioè consentono l'assegnazione di un job (seriale o parallelo) ad una risorsa dicomputing e/o storage, attraverso l'elaborazione di “requirement del job” o lo“stato della Grid”. Ciascun Resource Broker è fornito di certificato digitale(rilasciato dalla CA INFN) che attesta l'attendibilità delle transazioni econsente la mutua autenticazione;▪ servizi informativi (Information Index) forniscono le informazioni inerenti alloLuca Gerardo 566/2636 Pagina 22 di 113

▪stato, al carico e alle caratteristiche di ogni risorsa di calcolo presente nellaGrid tramite il servizio GRIS (Grid Resource Information Service). CiascunGRIS si registra presso un Information Index, il quale preleva le informazionida essi fornite in modo tale da esporre una visione globale delle risorse di tuttal'infrastruttura Grid;logical file catalog (LFC) fornisce servizi di naming ed un filesystem virtualedi alto livello per il mapping di nomi logici a file fisici distribuiti sugli StorageElement della Grid.fig.11Luca Gerardo 566/2636 Pagina 23 di 113

4. Il modello di sicurezza GSI ed il servizio VOMS4.1 IntroduzioneGSI è l'acronimo di Grid Securety Infrastructure ed è parte di Globus Toolkit. Essodefinisce, come suggerisce la parola, l'architettura che fornisce le funzionalitànecessarie atte a garantire la corretta implementazione della sicurezza nelle griglie. Talearchitettura è stata progettata per raggiungere un determinato livello di sicurezza di cuigli ambienti grid necessitano. Essi sono:• Single Sign-On: l'utente deve essere capace di autenticarsi un'unica volta,facendo in modo che possa accedere alle risorse della griglia senza che vengarichiesto nuovamente l'autenticazione.• Delegation of privileges: Si vuole fare in modo che un'entità possa delegare ipropri privilegi sulle risorse ad una seconda entità per fare in modo chequest'ultima possa completare il lavoro che le è stato richiesto dalla primaentità. Ciò può essere fatto mediante l'uso del certificato proxy. Il certificatoproxy unito alla chiave privata è chiamato proxy delle credenziali. Il proxydelle credenziali fornisce un accesso ristretto alle sole risorse di cui la secondaentità necessità per poter portare a termine il lavoro, sebbene i privilegi dellaprima entità siano molto più ampi. La delegazione dei privilegi siffatta è dettadelegazione delle credenziali.• Inter-domain security support: le soluzioni di sicurezza grid devono fornire ilsupporto necessario per l'interazione tra entità disposte in domini di sicurezzadifferenti. L'accesso alle risorse locali è gestito da politiche di sicurezza locali.A tal proposito deve esserci un proxy sul sistema locale che fornisce accessoalle risorse locali a nome del client remoto.• Secure Communication: è necessario un sistema di sicurezza che garantiscauna comunicazione sicura per lo scambio di messaggi fra le entità.L'architettura GSI fornisce tale supporto facendo uso del protocollo TLS,acronimo di transport layer securety. Tale protocollo cifra la comunicazione dasorgente a destinazione.• Authentication and Authorization: le soluzioni di sicurezza in ambito GridLuca Gerardo 566/2636 Pagina 24 di 113

devono prevedere l'autenticazione e le autorizzazioni sicure e scalabili. Ilprocesso di autenticazione permette di stabilire l'identità di un'entità all'internodella griglia. Diversi modelli di autenticazione sono conosciuti nelle reti. Unaautenticazione semplice prevede l'inserimento di username e password. Altritipi di autenticazione più complesse fanno uso di crittografia a chiavisimmetriche, come Kerberos, che fornisce autenticazioni ad applicazioniclient/server. Attualmente negli ambienti Grid l'autenticazione viene fattamediante PKI (Public Key Infrastructure). Questa tecnologia fa uso, perl'autenticazione delle entità, dei certificati X.509. L'autorizzazione avviene solodopo l'esito positivo dell'autenticazione. Essa prevede la verifica dei privilegiassociati all'entità autenticatasi per l'utilizzo delle risorse presenti nella griglia.• Uniform credentials: in ambienti grid è necessario che sia presente unostandard per rappresentare le credenziali di un'entità. GSI utilizza i certicatiX.509 per rappresentare tali credenziali.Luca Gerardo 566/2636 Pagina 25 di 113

4.2 I certificati X.509Per ottenere i diversi meccanismi di sicurezza in ambito Grid si utilizzano i certificatiX.509. Essi servono per verificare l'identità di soggetti e per consentire l'accesso allerisorse della Grid solo alle entità autorizzate. Tali certificati sono sempre firmati da unaterza parte fidata, detta Certification Autority (CA), della quale entrambi si fidano. Ilcontenuto di un certificato digitale X.509 è mostrato nella figura sottostante.fig. 12I certificati sono costituiti da diverse informazioni, quali:• Version: specifica la versione del certificato X.509. Se sono utilizzate delleestensioni all'interno del certificato, allora si tratta della versione 3. Se èpresente l'identificatore univoco allora si tratta della versione 2. Diversamente,se sono utilizzati solo i “campi base” allora si tratta della versione 1.• Serial Number: ogni CA assegna, al certificato che rilascia, un numero seriale.Così facendo il nome della CA, insieme al numero seriale, identificanoLuca Gerardo 566/2636 Pagina 26 di 113

univocamente un certificato rilasciato dalla CA in questione.• AlgorithmIdentifier: identifica l'algoritmo usato all'interno del certificato. Setroviamo, ad esempio, la stringa “md5withRSAEncryption” significa che èstato utilizzato l'algoritmo RSA per la generazione della coppia di chiavi(pubblica e privata) e md5 come algoritmo di hashing.• Issuer: indica la CA che ha rilasciato il certificato.• Validity: indica il tempo di validità del certificato. Tale campo è scomposto indue sottocampi: “not valid after” che indica il limite superiore di validità delcertificato e “not valid before” che indica il limite inferiore di validità delcertificato.• Subject: contiene il nome del propietario del certificato o dell'organizzazioneche ne ha fatto richiesta.• SubjectPublicKeyInfo: questo campo contiene la chiave pubblica delproprietario del certificato.• IssuerUniqueId: questo campo è opzionale e contiene, se usato, l'id che la CAassocia al certificato all'atto della sua generazione.• SubjectUniqueId: specifica l'id univoco associato al proprietario. Anche questocampo è opzionale.• Extension: opzionale. Esso indica la presenza di ulteriori campi oltre a quellibase.• CertificateSignature: è la firma digitale della CA che rilascia il certificatodigitale. Praticamente la CA non fa altro che calcolare l'hash dell'interocertificato, escludendo solo questo campo, e firmando tale funzione con lapropria chiave privata. Questa campo è detto anche autenticatore o blocco diautenticazione. Nel momento in cui un utente vuole verificare l'autenticità delcertificato, non fa altro che usare la chiave pubblica della CA, che ha firmato ilcertificato, per accedere all'hash del certificato. A questo punto, applicherà lafunzione di hash specificata nel campo AlgorithmIdentifier e confronterà il suorisultato con quello all'interno del campo CertificateSignature. Se i due valoricoincidono, allora il certificato è considerato fidato. Questa tecnica vieneutilizzata dagli utenti che fanno uso della chiave pubblica del certificato, perLuca Gerardo 566/2636 Pagina 27 di 113

verificare l'autenticità dello stesso. Nel caso in cui fosse modificato parte delcertificato, i due valori hash non coinciderebbero più e quindi il certificatosarebbe considerato non valido. La figura successiva illustra ciò che è statodescritto poc'anzi.fig 13I certificati X.509 fanno uso, da quanto si è potuto notare, della crittografia a chiavepubblica, detta anche crittografia asimmetrica. Essa nasce per sopperire alleproblematiche che si incontrano con la crittografia a chiave simmetrica. Quest'ultimotipo di crittografia fa uso di una sola chiave, detta chiave segreta, la quale è condivisafra le parti che vogliono scambiarsi dei messaggi ed soltanto questa è utilizzata percrittografare e decrittografare il messaggio. Diversamente, gli algoritmi a chiavepubblica fanno uso, come già detto, di una coppia di chiavi: una viene utilizzata percrittografare il messaggio, solitamente la chiave pubblica (ma non obbligatoriamente), eLuca Gerardo 566/2636 Pagina 28 di 113

l'altra, solitamente la chiave privata, per decrittografare il messaggio. Uno schema dicrittografia a chiave pubblica prevede sei elementi:• Testo in chiaro: è il messaggio dato in input all'algoritmo.• Algoritmo di crittografia: è l'algoritmo che permette la crittografia delmessaggio.• Chiave pubblica e privata: sono la coppia di chiavi utilizzate per la crittografiae decrittografia del messaggio date in input rispettivamente all'algoritmo dicrittografia o decrittografia utilizzato.• Testo cifrato: è il messaggio crittografato ottenuto mediante l'applicazionedell'algoritmo di crittografia che accetta in input il testo in chiaro ed una delledue chiavi.• Algoritmo di decrittografia: accetta in input il testo cifrato e la chiave che nonè stata utilizzata per crittografare il messaggio. Produce come output il testo inchiaro.Nel momento in cui l'utente A vuole inviare un messaggio all'utente B, A non deve farealtro che crittografare il messaggio facendo uso della chiave pubblica di B. Questomodo di agire garantisce a B la segretezza dei dati. Infatti solo B potrà decrittografare ilmessaggio. Quindi un male intenzionato, pur essendo a conoscenza sia dell'algoritmo dicrittografia e di decrittografia, che della chiave pubblica del destinatario, non potrebbecomunque decrittografare il messaggio, visto che l'unico modo per poterlo decifrare èutilizzando la chiave privata del destinatario. Questo garantisce la privatezza dei dati manon l'autenticità.Per fare in modo che sia garantita l'autenticità dei dati, prendendo ancora inconsiderazione la situazione precedente, dove l'utente A vuole inviare un messaggioall'utente B, prima di inviarlo, l'utente A deve crittografare il messaggio con la propriachiave privata, in modo tale che, il ricevente possa decifrare tale messaggio mediante lachiave pubblica del mittente. Visto che l'algoritmo di decrittografia prende in input iltesto cifrato e la chiave non usata per crittografare il messaggio, allora l'utente B ha lacertezza che tale messaggio sia stato inviato effettivamente dall'utente A.Le figure successive illustrano ciò che è stato appena detto.Luca Gerardo 566/2636 Pagina 29 di 113

fig . 14fig. 15Luca Gerardo 566/2636 Pagina 30 di 113

Per garantire sia l'autenticità che la segretezza dei dati contemporaneamente, bisognaquindi applicare l'algoritmo a chiave pubblica due volte. Con ciò si intende dire chestavolta A utilizzerà la propria chiave privata per crittografare il messaggio, garantendol'autenticità di quest'ultimo; dopodiché crittograferà nuovamente il messaggioutilizzando la chiave pubblica di B, destinatario del messaggio, garantendo così anche lasegretezza dei dati. L'unico svantaggio di questo approccio è la doppia applicazionedell'algoritmo a chiave pubblica, già di per se complesso.In realtà negli ambienti Grid, anziché utilizzare i certificati digitali X.509, sonoadoperati i “certificati Proxy X.509”. Ciò è fatto per soddisfare, in modo ancora piùesaustivo, quelle che sono le esigenze attuali della Grid. Un certificato proxy, inparticolare, è usato per soddisfare il requisito di Single Sign-On e delegare in mododinamico i propri privilegi sulle risorse del Grid ad altre entità. Dato che la chiaveprivata di un certificato digitale X.509 è protetta da password, per evitare di immetterlaad ogni muta autenticazione, si ricorre all'uso del certificato proxy. Il formato delcertificato proxy è simile a quello del certificato X.509. Questo permette, alleapplicazioni che fanno uso dei certificati X.509, di utilizzare anche i certificati proxy.Essendo simile il formato dei due certificati, anche il certificato proxy contiene unnumero seriale. Al fine di ottenere l'unicità, sia il numero seriale che il nome univocosono generati usando l'hash della chiave pubblica. Il certificato proxy differiscedall'X.509 per vari aspetti: innanzitutto il certificato proxy è generato dall'utente anzichédalla CA; in secondo luogo, nel campo Subject è immesso un nome univoco, l'unicitàdel quale è garantita anteponendo il nome del proprietario del certificato alla stringaunivoca; inoltre il certificato proxy ha validità limitata, solitamente dodici ore.La validità limitata consente di conservare la chiave privata nel sistema locale senzautilizzare alcun algoritmo di crittografia, in quanto alla scadenza del certificatocorrisponde la generazione di una nuova coppia di chiavi, rendendo obsoleta la vecchia.Questo comporta che nel caso in cui qualcuno dovesse impossessarsi della chiaveprivata, avrebbe comunque un tempo limitato per utilizzarla in modo scorretto. Infine ilcertificato proxy definisce un ulteriore campo, ProxyCertInfo che, se presente, indicache tale certificato è un proxy. Esso è costituito da un sottocampo, proxyPolicy.Quest'ultimo campo è diviso in due parti: una specifica la politica di utilizzo, cioèLuca Gerardo 566/2636 Pagina 31 di 113

specifica l'uso che può essere fatto di tale certificato per le autorizzazioni; l'altra parteindica il linguaggio usato per l'espressione della politica.Così come per testare la validità di un certificato digitale X.509 si ricorre all'uso dellachiave pubblica della CA emittente, allo stesso modo per verificare l'autenticità delcertificato proxy, si utilizza la chiave pubblica del proprietario.Per poter creare un certificato proxy, a partire da un certificato digitale, quest'ultimodeve essere salvato nella propria User Interface. Esiste una cartella specifica nel qualesalvarlo. All'atto dell'esecuzione del comando per la creazione del certificato proxy(voms-proxy-init), è richiesto l'uso della chiave privata associata al certificato digitale.Anch'essa è tenuta nel sistema in modo criptato e protetta da password. Immessa talepassword, è generato il certificato proxy che, come già detto, possiede una nuova coppiadi chiavi, in modo tale che, per qualsiasi uso della chiave privata, non sia necessario“l'intervento umano”. E' possibile ottenere informazioni da questo certificato proxymediante l'esecuzione del comandovoms-proxy-infoed è possibile distruggere un certificato proxy utilizzando il comandogrid-proxy-destroy.4.3 Public Key InfrastructureLa Public Key Infrastructure (PKI) fornisce agli utenti la possibilità di comunicare inmodo sicuro mediante l'utilizzo della chiava pubblica e privata. Questa architetturacoinvolge una terza parte fidata , la Certification Autority (CA), che emette i certificati.Supponiamo che un utente riceva un certificato di un altro utente e voglia verificare chela firma sul certificato sia stata apposta da una CA fidata. Nel caso in cui l'utente nonritiene la CA fidata, allora mediante l'utilizzo della PKI può avere la certezza dellaveridicità della firma di tale CA. Per capire ciò è necessario esporre la struttura PKI.Essa segue una struttura gerarchica per stabilire la catena di fiducia delle entità.Luca Gerardo 566/2636 Pagina 32 di 113

fig. 16Al livello più basso di tale gerarchia troviamo gli utenti finali o gli enti, possessori deicertificati digitali. Al livello successivo, ci sono le CA che sono autorizzate a rilasciarecertificati a livello regionale. Ognuna di queste CA possiede anch'essa un certificatodigitale. Esso è firmato a sua volta da una CA del livello superiore e così via. Si vienecosì a costituire una gerarchia chiamata catena di fiducia (chain of trust). In definitiva,quanto più si sale tanto minore sarà il numero di CA che troveremo a quel livello eminore sarà il numero a cui ogni CA rilascerà certificati. Alla radice della gerarchiatroviamo la CA root, di cui tutti si fidano. Per capire l'utilità dell'architettura PKI,consideriamo nuovamente l'esempio sopracitato: l'utente che vuole constatare laveridicità della firma della CA, può richiederne il certificato. Questo certificato èfirmato a sua volta, come esposto nella gerarchia, da una CA del livello superiore. Diconseguenza l'utente può risalire la gerarchia fino a quando non troverà una CA fidata.Se non ne viene riscontrata alcuna, nemmeno quella root, allora il certificato può essereconsiderato non fidato.Luca Gerardo 566/2636 Pagina 33 di 113

4.4 La mutua autenticazione serverDato che, come detto più volte, una grid è un insieme di persone, organizzazioni,apparati hardware e software che interagiscono fra loro, bisogna rendere queste ultime ilpiù sicure possibile. Questo implica che ciascuna entità che prende parte a taleinterazione deve essere certa dell'identità di ogni altro. Nelle grid ciò viene fattomediante l'utilizzo dei certificati digitali X.509. Il sistema di mutua autenticazione,utilizzato nelle grid, si basa sullo scambio dei certificati personali. Nel momento in cuidue elementi della grid, A e B, vogliono interagire fra loro, si devono autenticaremutuamente. È definita mutua autenticazione perché ognuna delle parti deveautenticarsi nei confronti dell'altra. Supponiamo che sia prima A ad autenticarsi neiconfronti di B. È necessario, innanzitutto, creare un canale di comunicazione fra loro. Aquesto punto A presenta il proprio certificato a B, che verificherà la veridicità delcertificato nel seguente modo:i. controllando se la CA che ha firmato il certificato è riconosciuta come“fidata” (o trusted). Se tale CA non viene ritenuta attendibile perverificare la sua genuinità si ricorre a “PKI”;ii. calcolando l'hash del certificato facendo uso dell'algoritmo dichiaratoall'interno del certificato;iii. decriptando la firma digitale del certificato mediante la chiave pubblicacontenuta in esso;iv. confrontando i due hash;I passi appena elencati sono da considerarsi conseguenziali, ovvero non è possibilepassare da un punto a quello successivo se la condizione del primo non vienesoddisfatta. Tale soddisfacimento, quindi, è una “condicio sine qua non” perl'avanzamento al punto successivo. Le cause per le quali una delle condizioni potrebbenon essere soddisfatta, sono diverse. Considerando il primo step, B potrebbe non risaliread una Certification Autority fidata e ciò implicherebbe la non genuinità del certificato.Per quanto concerne l'ultimo punto, potrebbe non essere soddisfatto il matching dei duehash, implicando la manomissione del certificato. Diversamente, se tutte le condizioniLuca Gerardo 566/2636 Pagina 34 di 113

sono soddisfatte, B ha la certezza che il certificato sia attendibile.Un' altra questione è, poi, risalire al reale utilizzatore del certificato. Potrebbe infattiesserne entrato in possesso un altro utente. A tal proposito, affinché B abbia la certezzadel fatto che l'utilizzatore del certificato ne sia realmente il possessore, è necessario cheinvii un messaggio, costituito da testo casuale, ad A chiedendogli di crittografarlo con lapropria chiave privata.Considerando che la crittografia a chiave pubblica prevede l'utilizzo di due chiavi, dellequali una per la crittografia e l'altra per la decrittografia, in modo indifferente, occorrecrittografare con la chiave privata del mittente il messaggio che potrà, a sua volta,essere decrittografato solo attraverso l'utilizzo della chiave pubblica associata. Quindi,supponendo che A abbia crittografato il messaggio, inviato da B, con la propria chiaveprivata, B, ricevuto il messaggio, lo decrittograferà con la chiave pubblica presente nelcertificato. Se il testo ricevuto coincide con quello inviato, B ha la certezza chel'interlocutore sia realmente il proprietario del certificato.Infine considerando che la CA garantisce l'autenticità del certificato e che la stessaassocia la chiave pubblica di A all'identità di A, l'autenticazione di A nei confronti di Bpuò considerarsi terminata. Ovviamente, trattandosi di mutua autenticazione, B deveseguire lo stesso procedimento per autenticarsi nei confronti di A4.5 Il servizio VOMSVOMS sta per Virtual Organization Memberschip Service. Esso è un sistema per lagesione delle autorizzazioni all'interno di collaborazioni multiistituzionali. Il sistemaVOMS è costituito dalle seguenti parti:• User Server, che riceve le richieste dagli utenti e ritorna informazionecirca questi;• User Client, che contatta il server presentandogli un certificato utenteper ottenere una lista di role, groups e capability;• Administration Client, usato dall'amministratore della VO. Esso dà lapossibilità di aggiungere nuovi gruppi, cambiare ruoli ecc;• Administration Server, che accetta le richieste dagli utenti e modifica ildatabase.Luca Gerardo 566/2636 Pagina 35 di 113

fig 17Il VOMS fornisce un database contenente utenti, ruoli, privilegi ed un insieme distrumenti per accedere e manipolare i dati all'interno del database. Un requisito moltoimportante, dal punto di vista dell'utente, è la creazione di certificati proxy. Per ottenereciò si fa uso del comando vosm-proxy-init usato al posto di grid-proxy-init.fig. 18Come quest'ultimo, il primo comando permette di creare un certificato proxy utente. Ladifferenza sta nel fatto che usando il primo comando, il certificato proxy contieneLuca Gerardo 566/2636 Pagina 36 di 113

informazioni aggiuntive (extension information) presenti nel server VOMS. Inparticolare, questo certificato proxy contiene, oltre alle informazioni di base perl'autenticazione, anche informazioni inerenti al ruolo e alle capacità associate all'utente.Tali credenziali sono compatibili anche con quelle applicazioni grid che non fanno usodelle informazioni aggiuntive prelevate dal server VOMS.fig. 19Luca Gerardo 566/2636 Pagina 37 di 113

fig. 20Il certificato proxy ottenuto mediante l'utilizzo del comando grid-proxy-init noncontiene, invece, informazioni inerenti alla VO.Come già detto, per essere parte di una VO e per poter dunque usufruire delle risorsepresenti nella grid, un utente deve essere innanzitutto in possesso di un certificatodigitale, solitamente caricato in un browser. Mediante un'interfaccia web, l'utentesottomette la richiesta di registrazione ad una VO. A questo punto il manager della VOLuca Gerardo 566/2636 Pagina 38 di 113

decide se accettare o meno la richiesta. Accettata la richiesta, l'utente diviene parte dellaVO a cui si è iscritto. L'operazioni che il manager può eseguire è, oltre alla possibilità diaccettare o meno le richieste utenti, la creazione di gruppi e ruoli. I gruppi presenti nelserver VOMS sono gerarchici, cioè se l'utente A appartiene al gruppo S e quest'ultimo èsottogruppo di T, allora l'utente A appartiene anche al gruppo T. Da ciò si deduce che unutente può essere parte di più gruppi contemporaneamente.Allo stesso modo, è possibile associare più ruoli allo stesso gruppo.Le seguenti immagini mostrano l'interfaccia web del server VOMS Unina:fig. 21Luca Gerardo 566/2636 Pagina 39 di 113

fig. 22Come dicevamo precedentemente, il server VOMS fornisce un database per la gestionedegli utenti iscritti ad una determinata VO. All'interno di tale database sono presentidiverse tabelle, fra le quali:• Usr che contiene informazioni inerenti agli utenti;• groups che contiene informazioni inerenti ai gruppi;• capabilities che contiene informazioni inerenti alle capacità;• roles che contiene informazioni inerenti ai ruoli.Queste sono le tabelle principali che il VOMS fornisce per la gestione di utenti, gruppi,privilegi e ruoli.Luca Gerardo 566/2636 Pagina 40 di 113

5. Un'estensione del servizio VOMS con certificati Robot5.1 Concetto di certificato RobotCome già detto nei capitoli precedenti, i certificati X.509 sono usati per soddisfare lerichieste del modello di sicurezza GSI, utilizzato in ambito Grid.Oltre ai certificati digitali X.509, ne esistono altri, detti certificati Robot, anch'essiX.509, che differiscono dai primi per la modalità d'uso, anche se la procedura per larichiesta di questi ultimi è la stessa di quella che bisogna effettuare per poter ottenere uncertificato digitale X.509. Tali certificati sono stati introdotti da qualche anno affinché leapplicazioni potessero usufruirne e, in particolare, affinché queste ultime potesserosvolgere dei compiti automatizzati a nome dell'utente. Dato che, come già detto, uno deirequisiti del modello GSI è l'autenticazione, anche un'applicazione deve essere in gradodi autenticarsi per poter ottenere le rispettive autorizzazioni. Il processo diautenticazione è necessario al fine di portare a termine il proprio compito e svolgere,dunque, le proprie operazioni facendo uso delle risorse della Grid. Il certificato Robot, adifferenza del classico certificato digitale X.509, è salvato su un supporto fisso (e-tokenUSB), ed è legato ad un'applicazione piuttosto che ad una persona. Per evitare problemi,nel caso in cui dovesse essere smarrito il token USB, il certificato Robot in esso salvatoè criptato mediante password. In verità è possibile salvare all'interno dello stesso tokenUSB più certificati: uno per ogni applicazione. Così come si preferiscono ai certificatidigitali X.509 i rispettivi certificati proxy, creati a partire dai primi, allo stesso modoun'applicazione, anziché utilizzare i certificati Robot, predilige l'uso dei certificatiproxy, creati a partire dai certificati salvati su token USB.5.2 Estensione delle facility del VOMSAttualmente, sia grazie ai certificati digitali personali X.509, sia grazie al VOMS, èpossibile soddisfare tutti i requisiti previsti dal modello architetturale di sicurezza GSI,quali:• single sign on;• delegazione;• Integration with various local securety solutions;Luca Gerardo 566/2636 Pagina 41 di 113

• User-based trust relationschips• non ripudio;• virtualizzazione degli utenti;• privatezza dei messaggi;• integrità dei messaggi;Oltre alla possibilità di accedere alla Griglia mediante certificati personali X.509, neesiste un'altra che permette l'accesso agli utenti oltre che alle applicazioni, mediantecertificati Robot. L'uso di questi certificati, però, sino ad oggi, è stato limitato alle soleapplicazioni. Permettere, infatti, l'uso di tali certificati ad uno o più utenticontemporaneamente invece che ad una applicazione, comporterebbe il nonsoddisfacimento dei requisiti di sicurezza richiesti dal modello GSI. Bisogna tenerpresente, infatti, che il certificato Robot ha un unico responsabile: il richiedente ovveroil possessore. Le informazioni contenute in un proxy, generato a partire dal certificatoRobot da parte di qualsiasi utente, sarebbero inerenti al solo responsabile, tralasciando,quindi, quelle dell'effettivo utilizzatore. Vengono meno, così facendo, diversi requisitirichiesti dal modello GSI, quali:• assenza della tracciabilità delle operazioni svolte dall'utente;• assenza della possibilità di bannare un utente;• impossibilità di imporre vincoli di utilizzo sulle risorse e quindi impossibilitàdi esprimere politiche sulle autorizzazioni e sui permessi in base all'identitàdell'utente;• impossibilità di risalire all'identità dell'effettivo utilizzatore del certificato;Volendo rappresentare quanto appena detto mediante l'ausilio di una tabella, avremo:cert. pers.X.509cert. RobotX.509Single sign on SI SIDelegazione SI SISegretezza dei dati SI SILuca Gerardo 566/2636 Pagina 42 di 113

Non ripudio SI NOAutenticità dei dati SI NOPossibilità di revoca dei dirittiSINO(Autenticazione e Autorizzazione)Tracciabilità attività utenteSINO(Auditing e Accounting)Possibilità di esprimere politiche di SINOautorizzazione in base all'identità dell'utentePossibilità di esprimere vincoli d'uso sulle SINOrisorse in base all'identità dell'utentePossibilità di risalire all'effettivo utilizzatore SINOdel certificatoAutenticazione in base all'identità dell'utente SI NOPossibilità d'uso del certificato nelle Griglie inbase allo stato attualeSINOLa precedente tabella confronta le due tipologie di certificato, sottolineando il nonsoddisfacimento di diversi requisiti di sicurezza richiesti dagli ambienti Grid nelmomento in cui un utente, che non sia il responsabile, fa uso del certificato Robot.È possibile evincere da tale tabella, dunque, il perché della modalità di utilizzo, limitatoalle sole applicazioni, di tale certificato.L'obiettivo di questa tesi è facilitare agli utenti, mediante l'uso dei certificati Robot,l'accesso alla Griglia e, allo stesso tempo, non compromettere, i requisti di sicurezzaprecedentemente esposti.Per poter raggiungere tale obiettivo, si vuole fare in modo che, all'atto del loginmediante UI da parte dell'utente, venga generato un proxy contenente informazioniaggiuntive, tali da poter risalire all'effettivo utilizzatore del certificato e da potersoddisfare tutti i requisiti di sicurezza.Si è dovuto, quindi, realizzare un'applicazione web che permettesse all'utente disottomettere sia una richiesta di utilizzo del certificato Robot, sia, di conseguenza, unarichiesta di iscrizione alla VO relativa, per poter usufruire delle sue risorse. Per renderepossibile ciò, viene presentato all'utente un form che richiede le informazioni personali,Luca Gerardo 566/2636 Pagina 43 di 113

compreso l'indirizzo e-mail. Bisogna inoltre scegliere, fra quelli disponibili nell'elenco,il certificato Robot da usare per accedere alla Griglia. Se tale richiesta sarà accoltadall'amministratore, le informazioni relative all'utente saranno, mediante la medesimaapplicazione Web, mantenute all'interno del server VOMS: in particolare, la maildell'utente sarà usata per creare un nuovo ruolo. A questo punto, all'atto del logindell'utente mediante UI, sarà possibile creare un proxy con informazioni aggiuntive(extension information) prelevate dal server VOMS. In realtà, dovendo rispettare ancorauna volta il modello GSI, il proxy non sarà creato a partire dal certificato Robot, bensìdal proxy generato a partire dal certificato Robot.Per creare, dunque, il proxy, in modo del tutto trasparente all'utente, si farà uso delcomandovoms-proxy-init -- voms “nome VO”:/Role= “ruolo associato all'utente”All'atto dell'esecuzione di tale comando, sarà contattato il Server VOMS relativo,ottenendo così informazioni aggiuntive da inserire all'interno del proxy. Prima divalutare tale richiesta, sarà però necessario che l'utente si autentichi nei confronti delServer e viceversa (mutua autenticazione). Ovviamente il Server possiede un propriocertificato per autenticarsi, mentre l'utente farà uso del proxy, creato a partire dalcertificato Robot all'atto del login sulla UI. Avvenuta, con esito positivo,l'autenticazione, il Server VOMS provvederà a creare un nuovo proxy a partire dalquello presentatogli, inserendo in esso informazioni aggiuntive: in particolare il ruoloche è stato specificato nel comando precedentemente esposto.Il concetto chiave è quello di avere un ruolo per ciascun utente. Avendo usato comeruolo la mail, ed essendo quest'ultima un identificativo univoco dell'utente, l'inserimentodi tale ruolo nelle informazioni aggiuntive del proxy, permetterà il soddisfacimento deirequisiti di sicurezza, quali ad esempio la tracciabilità. Di conseguenza sarà possibileconoscere l'effettivo utilizzatore del certificato in qualsiasi istante.Il raggiungimento di tale obiettivo comporterà diversi vantaggi, quali:• l'utente non dovrà più richiedere alcun certificato, evitando quindi tutto l'iterper tale richiesta;• sarà velocizzato e soprattutto facilitato l'accesso alle Griglie dal punto di vistadell'utente;Luca Gerardo 566/2636 Pagina 44 di 113

• sarà incentivata la diffusione dell'uso delle Griglie, ampliando così il lorobacino d'utenza.In tal modo, oltre ai vantaggi ottenuti, saranno soddisfatti anche i requisiti del modelloGSI, ovvero:• la possibilità di tracciare l'attività dell'effettivo utilizzatore del certificato;• la possibilità di bannare un utente mediante il ruolo assegnatogli;• la possibilità di porre dei vincoli di utilizzo sulle risorse della Griglia medianterestrizioni applicate al ruolo;• la possibilità di risalire all'effettivo utilizzatore del certificato Robot.La soluzione poc'anzi esposta, quindi, giustifica l'introduzione dei certificati Robot ed illoro utilizzo da parte degli utenti, risolvendo, così, tutti gli interrogativi che vi erano inmerito.Luca Gerardo 566/2636 Pagina 45 di 113

6. L'attività sperimentale6.1 Descrizione dell'applicazione webL'applicazione web da me sviluppata prevede innanzi tutto una pagina dedicataall'utente (fig 23), mediante la quale quest'ultimo può sottomettere una richiesta diiscrizione alla VO. Per poter sottomettere tale richiesta, l'utente deve compilare il formche gli viene proposto nella suddetta pagina inserendo le proprie informazioni, quali:nome, cognome, indirizzo di posta elettronica. Deve inoltre scegliere, fra quellidisponibili, il certificato Robot da utilizzare per sfruttare successivamente le risorsedella VO e “spuntare” la casella relativa al consenso, così da accettare le regole impostedalla VO.fig. 23Luca Gerardo 566/2636 Pagina 46 di 113

Cliccando il bottone conferma, se i dati immessi risultano essere corretti, saràvisualizzato un messaggio che informa l'utente di seguire le istruzioni che gli vengonofornite(fig 24).fig. 24Questa operazione comporterà l'inserimento dei dati utente all'interno del database delVOMS. In particolare all'interno della tabella request_pending da me creata. Tale tabellaconterrà nome, cognome, indirizzo e-mail, data richiesta, certificato scelto per accederealla griglia e un campo inerente alla conferma della richiesta dell'utente.A questo punto, utilizzando l'indirizzo di posta elettronica fornito nella paginaprincipale, sarà inviata, all'utente, una e-mail nella quale verrà chiesto di confermare odisdire la richiesta di iscrizione alla VO mediante i link relativi. Ciò è fatto per evitareche qualcuno sottometta richieste a nome di altri utentiNel caso in cui l'utente confermi la richiesta mediante il link relativo, sarà modificato uncampo della riga relativa all'utente nella tabella request_pending, in modo tale che larichiesta utente possa essere visualizzata nella pagina principale dell'amministratore.Infatti, se l'utente non conferma la sottomissione della richiesta, quest'ultima non saràmai presa in considerazione dall'amministratore perché non visualizzata.Diversamente, se l'utente usa il link relativo all'annullamento della richiesta, la rigacorrispondente della tabella request_pending sarà cancellata.La pagina principale dell'amministratore si presenta sotto forma tabellare(fig. 26) edogni riga rappresenta una richiesta utente. Ciascuna riga conterrà le informazioniinserite dall'utente all'atto della sottomissione della richiesta. A questo puntol'amministratore, in base a queste informazioni, deciderà se accogliere o meno larichiesta dell'utente spuntando, rispettivamente, l'opzione “Accept” o “Reject”.Ad operazione conclusa, anche l'amministratore visualizzerà un messaggio(fig. 25) cheLuca Gerardo 566/2636 Pagina 47 di 113

lo informerà dell'operazione conclusa.fig. 25fig. 26Nel caso in cui la richiesta utente non sia accolta dall'amministratore, la rigacorrispondente a tale richiesta, presente nella tabella request_pending del database delVOMS, sarà cancellata.Diversamente, se la richiesta utente è accettata, l'indirizzo e-mail fornito all'atto dellasottomissione della richiesta di iscrizione, sarà usato come “ruolo” da associare alcertificato Robot scelto anch'esso in fase di sottomissione della richiesta.In particolare, tale operazione si rifletterà nel database inserendo l'utente nella tabellausr ed il ruolo nella tabella roles, associando, quindi, l'utente al gruppo principale e ilruolo al certificato Robot.Luca Gerardo 566/2636 Pagina 48 di 113

In tal modo, sarà possibile tenere traccia delle operazioni svolte dall'utente nella VO.A questo punto, per consentire un accesso “trasparente” alla Grid, si è fatto in modo cheall'atto del login sulla UI, l'utente eviti il management del certificato. Si vuole infatti cheall'atto dell'accesso venga generato automaticamente il proxy del certificato Robot conle estensioni VOMS, evitando che questo venga fatto esplicitamente dall'utente.Per rendere possibile quanto appena detto, si è dovuto modificare, nella cartella utente,il file “.bashrc” in modo tale che quest'ultimo chiami, a sua volta, lo script “grisu-initshell.pl”passandogli un parametro inerente al ruolo da associare al proxy creato apartire dal certificato Robot. Questo script, scritto il Perl, richiama a sua voltaun'applicazione scritta in C: “chvo2”. Questa applicazione non fa altro che accedere,mediante apposite librerie, al token usb nel quale è salvato il certificato, al fine digenerare un proxy a partire da esso. Successivamente la stessa applicazione richiama ilcomando per generare il proxy contenente le “voms extension” presentando al serverVOMS il proxy generato precedentemente. A questo punto il server restituisce il nuovoproxy e viene dato il controllo della shall all'utente.Supponendo che un utente abbia richiesto di utilizzare il certificato Robot e che la suamail sia lgerardo_at_unina.it, l'immagine successiva mette in evidenza quanto dettofin'ora: mette in risalto, cioè, la creazione del proxy del certificato Robot con “vomsextension” mediante il solo accesso alla UI da parte dell'utente.Fig. 27Luca Gerardo 566/2636 Pagina 49 di 113

fig. 28Le due figure precedenti mostrano quanto appena detto. All'atto del login mediante UIda parte dell'utente è creato un proxy del certificato Robot con informazioni aggiuntive:la mail dell'utente è usata come ruolo.Luca Gerardo 566/2636 Pagina 50 di 113

6.2 L'architettura della Web ApplicationL'architettura su cui si basa la Web Application realizzata è Client/Server a trelivelli(three-tier):• Il primo livello è dedicato alla presentazione dei dati.• Il secondo livello dedicato alla logica applicativa• Il terzo livello dedicato alla gestione dei datifig. 29Si ha quindi bisogno di un Web Server, un' Application Server ed un DataBase (Fig. 29).L'ambiente, in cui il sistema opera, poggia su un unico server fisico con SistemaOperativo Red Hat AS 5.0, sul quale sono installati sia Tomcat, come ApplicationServer, che MySQL come RDBMS.Il Web Server accetta richiesta da parte dei Client e invia a questi ultimi ciò che gli èstato richiesto. Non avendo una propria logica applicativa, esso non è capace diinterpretare il codice presente all'interno delle pagine e per tale ragione presenta paginepuramente statiche: pagine HTML contenenti testi o immagini.Il Client sottomette le richieste mediante il Web Browser così come, mediantequest'ultimo, ha la possibilità di ottenere risposte dal Web Server.L'Application Server si occupa della logica applicativa. In particolare esso offre unambiente per poter sviluppare ed eseguire applicazioni web che solitamente, come pureLuca Gerardo 566/2636 Pagina 51 di 113

nel nostro caso, sono three-tier e dove ciascun livello, come già detto precedentemente,ha un compito ben preciso.L'Application Server utilizzato è Tomcat. Sia per la sua robustezza sia per il fatto cherisulta essere disponibile per Sistemi Operativi Windows e Linux, e sia perchè esso èattualmente l'Application Server più diffuso.A dire il vero, Tomcat è un Servlet Container ed un JSP Engine. E' quindi capace dieseguire, lato server, applicazoni web basate su tecnologia J2EE e costituite dacomponenti Servlet e da pagine JSP.Oltre a Tomcat esistono alti Application Web come ad esempio Jboss e GlassFishPer quanto concerne la gestione dei dati è stato utilizzato l'RDMB(Relational DatabaseManagement System) MySQL.L'applicazione Web è stata sviluppata secondo il paradigma MVC(Model-View-Control), traendo così i vantaggi insiti in esso. Questo Design Pattern è una linea guidaper la suddivisione delle responsabilità fra le diverse classi che compongonol'applicazione web. Seguendo tale Design Pattern, infatti, l'applicazione viene suddivisain tre componenti principali:• model: rappresenta le classi che si interessano dei dati nudi e crudi;• view: è la porzione dell'applicazione dedicata alla rappresentazione dei dati.Qui sono presenti le classi che, a partire dai dati contenuti nel “model”, offronouna presentazione della pagina all'utente;• controller: questa categoria di classi si interessa dell'interazione con l'utente.Tenendo presente il pattern Observer, il paradigma MVC prevede che le classicontroller siano degli “Observer” che ricevono comandi(eventi) dall'utente eallo stesso modo, le view siano degli “Observer” delle classi model.Luca Gerardo 566/2636 Pagina 52 di 113

fig. 30Sviluppando in tal modo l'applicazione, le richieste poste dall'utente saranno gestitedalla servlet(controller), la quale provvederà a istanziare dei bean(Model) cheserviranno poi alle JSP(View) per la presentazione dei dati.6.3 Le tecnologie utilizzatePer lo sviluppo dell'applicazione web si è fatto uso delle seguenti tecnologie:• JSP/Servlet: JSP è l'acronimo di JavaServer Page. Questa è una tecnologia javaper lo sviluppo di applicazioni Web che forniscono contenuti dinamici.Mediante i suoi tag, è possibile inserire all'interno delle pagine funzioni ocodice Java. Alla tecnologia JSP è correlata quella Servlet. Infatti, all'atto dellachiamata di una JSP, quest'ultima viene tradotta in una Servlet. Per tale ragioneanche le JSP hanno bisogno di un Servlet Container oltre ad aver bisogno di un“motore JSP”. Utilizzando Tomcat, quest'ultimo contiene già al suo interno siaun motore JSP che un Servlet Container. JSP è una tecnologia alternativa aPHP o ad esempio ad ASP. La differenza sostanziale di queste tecnologie stanell'architettura interna del Software che costituisce l'applicazione Web. L'uso,Luca Gerardo 566/2636 Pagina 53 di 113

infatti, di JSP e Servlet offre vantaggi non indifferenti, quali:• velocità di sviluppo;• prestazioni;• portabilità;• ed altri aspetti inerenti alla qualità interna ed esternadell'applicazione Web;• JavaScript: fu originariamente sviluppato da Brendan Eich della NetscapeComunication con il nome di Mocha e successivamente di LiveScript, ma inseguito è stato rinominato "JavaScript". È un linguaggio di scripting orientatoagli oggetti e comunemente utilizzato nei siti Web. Esso risulta avere unasintassi molto vicina a quella Java. La caratteristica principale di questolinguaggio è che un linguaggio interpretato. Il codice viene quindi eseguito aruntime senza la necessità di essere compilato. Un aspetto molto importante èche il codice JavaScript lato client viene eseguito dal client, senza, quindi, lanecessità sollecitare il server. Esso risulta essere uno standard ISO.• HTML: è l'acronimo di HyperText Markup Language. E' un linguaggio usatoper per la stesura dei documenti ipertestuali disponibili nel World Wide Web. Èun linguaggio di markup, vale a dire che descrive il contenuto delle pagine web• CSS: è l'acrinimo di Cascading Style Sheet, cioè fogli di stile. Essi vengonousati per definire la rappresentazione dei fogli dei documenti HTML, XHTMLe XML. Il loro utilizzo è necessario al fine di separare i contenuti dellaformattazione dal resto, permettendo, quindi, una programmazione più chiara.• MySql: è un RDBMS(Relational DataBase Management System) disponibie siaper sistemi Unix che per sistemi Windows. Le sue principali caratteristichesono:• capacità di gestire grandi quantità di dati;• utilizzo di sistemi di protezione e autorizzazione per l'accesso aidati stessi.• Condivisione dei dati fra più utenti e applicazioni;Il modello relazionale si basa sulle relazione dei dati. Insieme al modellorelazionale è stato introdotto il linguaggio SQL(Structured Query Language),Luca Gerardo 566/2636 Pagina 54 di 113

6.4 Use Caseche offre la possibilità di effettuare inserimenti, modifiche e reperimento diinformazioni dalle tabelle che costituiscono la base di dati.fig. 31Luca Gerardo 566/2636 Pagina 55 di 113

Mediante il diagramma precedente (fig. 31), è possibile visualizzare quali sono gliutenti che utilizzano il sistema e cosa essi possono fare. In rosso sono state evidenziatele funzionalità aggiunte al “sistema base” mediante la nostra applicazione web.Con quest'ultima, infatti, l'utente ha la possibilità di sottomettere una richiesta diiscrizione alla VO senza l'uso del certificato personale. Allo stesso modo l'admin puòaccettare gli utenti senza certificato che richiedono l'iscrizione alla VO.6.5 Diagrammi di Cockburna) Richiesta iscrizione alla Vo senza certificato personale.ObiettivoPrecondizioniCondizioni disuccessoCondizioni difallimentoAttorePrimarioTriggerRichiesta iscrizione alla VO senza certificatopersonaleL'utente sottomette la richiesta di iscrizioneall'amministratore della VO.L'utente è posizionato con il browser web sulla paginadi iscrizione.L'utente visualizza la pagina di avvenuta sottomissionedella richiesta.L'utente non sottomette la richiesta di iscrizione.UtenteL'utente riempie il form con i propri dati e clicca sulbottone “Conferma”Descrizione deipassiN°Passo Azione Utente Azione Sistema1 Azione Trigger2 Riempie il formLuca Gerardo 566/2636 Pagina 56 di 113

con i propri dati eclicca sul bottone“Conferma”3 Controlla,salva i datiutente ed inviae-mail perconferma4 L'utente clicca sullink “ConfermaRichiesta”presente nellamail5 Visualizza paginadi avvenutasottomissionedella richiesta.EstensioniN°Passo Azione Utente Azione Sistema3,1,1 Visualizzamessaggio dierrore per il campo“Nome”3,2,1 Visualizzamessaggio dierrore per il campo“Cognome”3,3,1 Visualizzamessaggio dierrore per il campoLuca Gerardo 566/2636 Pagina 57 di 113

“Mail”3,4,1 Visualizzamessaggio dierrore per il campo“Certificato Robot”3,5,1 Visualizzamessaggio dierrore per il campo“Accetta RegoleVO”3,6,1 Visualizzamessaggio dierrore perché lamail è giàassociata alCertificato Robotscelto3,7,1 Il sistema noninvia la mailperché non valida4,1,1 L'utente clicca sullink “AnnullaRichiesta”presente nella mail4,1,2 Visualizza paginache confermala rinuncia diiscrizione.b) Accetta utente senza certificato nella VOObiettivoAccetta utente senza certificato nella VOL'utente è iscritto alla VOLuca Gerardo 566/2636 Pagina 58 di 113

PrecondizioniCondizioni disuccessoCondizioni difallimentoAttorePrimarioTriggerL'utente deve aver sottomesso una richiesta diiscrizione.Visualizza la pagina con il messaggio “OperazioneConclusa”.L'admin non accetta la richiesta dell'utente.AdminL'admin si posiziona alla pagina principaleDescrizione deipassiN°Passo Azione Admin Azione Sistema1 Azione trigger2 Visualizzala paginaprincipale3 Sceglie l'opzione“Accept” e cliccasul bottone“Conferma”4 Iscrive l'utentealla VO5 Associa l'utenteal gruppo6 Controlla e creail ruolo7 Assegna il ruoloal certificatoRobot8 Visualizza laLuca Gerardo 566/2636 Pagina 59 di 113

pagina checonfermal'operazioneEstensioniN°PassoAzioneUtente3,1,1 Sceglie l'opzione“Reject” e cliccasul bottone“Conferma”AzioneSistemaVisualizza lapagina checonfermal'operazioneSubVariationN°PassoAzioneUtenteAzioneSistema5,1,1 Controlla ma noncrea il ruoloperché giàpresente e va allostep 7Luca Gerardo 566/2636 Pagina 60 di 113

6.6 Class DiagramI due diagrammi delle classi successivi descrivono il sistema dal punto di vista statico.Permettono di conoscere i componenti del sistema ed i loro legami. In particolare si ècercato di avere un basso accoppiamento ed un'alta coesione in modo tale da influirepositivamente sulla qualità interna del codice.a) Class Diagram relativo all'utente:b) Class Diagram relativo all'admin:Luca Gerardo 566/2636 Pagina 61 di 113

Luca Gerardo 566/2636 Pagina 62 di 113

6.7 Sequence DiagramLuca Gerardo 566/2636 Pagina 63 di 113

Luca Gerardo 566/2636 Pagina 64 di 113

Sequence UserLuca Gerardo 566/2636 Pagina 65 di 113

Luca Gerardo 566/2636 Pagina 66 di 113

I diagrammi di sequenza descrivono il sistema dal punto di vista dinamico. Permettonodi descrivere, quindi, le interazioni che vi sono fra i vari oggetti ed in particolare imessaggi che quest'ultimi si scambiano, per ottenere il risultato desiderato.Da notare che in ogni Sequence Diagram si è evitato di rappresentare la creazione dioggetti RequestDispatcher e HttpSevletRequest, utili a redirezionare il flusso dicontrollo e a passare riferimenti di oggetti, al fine di migliorare la leggibilità deldiagramma. In sostituzione è stata usata una freccia con stereotipo dovequesto sta ad indicare che il flusso di controllo viene passato all'oggetto che ha verso dise la freccia entrante e che a questo oggetto vengono passati dei riferimenti di altrioggetti in modo tale da poter richiamare i loro metodi.Luca Gerardo 566/2636 Pagina 67 di 113

7. Testing e scenari applicativi7.1 Validazione e TestingAl termine della fase di progettazione e di implementazione, sono stati effettuati dei testsull'applicazione. La prima funzionalità che è stata testata è quella relativaall'immissione dei dati personali dell'utente all'atto della sottomissione della richiesta diiscrizione. Innanzi tutto si è cercato di sottomettere la richiesta, omettendo uno o piùdati relativi all'utente. Ciò che è stato ottenuto è un messaggio di errore relativo allaparte del form che non è stata compilata. Le immagini successive mostrano quelli chesono i messaggi di errore ottenuti durante la fase di testing.fig.32fig. 33fig. 34Luca Gerardo 566/2636 Pagina 68 di 113

fig. 35fig. 36Si è cercato poi di inserire una e-mail (a sua volta usata come ruolo) già presente sia frale richieste pendenti, sia fra quelli nella tabella relativa ai ruoli. Nel primo caso vienevisualizzato un messaggio di errore (fig. 37), mentre nel secondo caso si ha ugualmentela visualizzazione dello stesso messaggio di errore solo se il ruolo è già associato alcertificato Robot che è stato scelto all'atto della sottomissione della richiesta.fig. 37A questo punto si è cercato di testare i link presenti nella mail inviata all'utente. Se illink è usato per la prima volta, allora il sistema mostra la pagina che informa l'utente odell'avvenuta sottomissione della richiesta o della cancellazione della stessa, a secondadel link utilizzato. Se a questo punto si utilizza uno dei due link, il sistema mostra unapagina contenente un messaggio che comunica all'utente che il link non è più validoperché scaduto. Per quanto riguarda la parte dell'applicazione relativaall'amministratore, sono state testate le uniche due possibilità che l'amministratore ha asua disposizione. Quindi prendendo in considerazione più richieste utente, si è fatto inLuca Gerardo 566/2636 Pagina 69 di 113

modo che alcune di esse fossero accolte ed altre, invece, fossero rifiutate. È stato poifatto un controllo sulla tabella del database request_pending al fine di constatare che lerighe relative a tutte le richieste visualizzate dall'amministratore nella pagina principale,fossero state cancellate. A questo punto è stato controllato se, per le richieste accettate,fossero stati effettuati i giusti inserimenti nel database: in particolare è stato controllatoche l'utente fosse stato inserito all'interno della tabella usr, così come è stato controllatoche il ruolo fosse stato creato ed associato al gruppo in modo corretto.Infine, essendo stata eseguita la parte relativa alla sottomissione della richiesta da partedell'utente ed essendo quest'ultima stata accolta dall'amministratore, è stato effettuato unultimo test relativo all'accesso dell'utente alla Grid mediante User Interface comedescritto nel paragrafo 6.1. Anche il risultato di questo test è risultato positivo. Si èavuto infatti l'accesso alla griglia in modo del tutto trasparente all'utente ed è statoassociato in modo corretto il role al certificato Robot.7.2 Applicazione per creare portali web di accesso alla GRIDPer poter valorizzare al meglio l'applicazione realizzata e per poter incentivarel'ampliamento del bacino di utenza delle Grid, lo scenario applicativo principaleriguarda la realizzazione di portali web che permettano l'accesso ai servizi Grid agliutenti che non sono in possesso di un certificato digitale personale. Attualmente perpoter accedere alla Griglia, si ha bisogno di un certificato personale digitale. La prassiper poter ottenere il certificato non incoraggia sicuramente gli utenti ad avvicinarsi agliambienti Grid. È necessario infatti, per poterne ottenere uno, recarsi innanzi tutto pressouna Registratin Autority che ha il compito di accertare l'identità dell'utente. Quest'ultimaprovvederà successivamente a sottomettere la richiesta alla Certification Autority laquale provvederà ad emettere il certificato. Solo a questo punto l'utente potràsottomettere una richiesta di iscrizione ad una VO per ottenere l'accesso alle risorsemesse a disposizione da quest'ultima. Diversamente, grazie all'applicazione da mesviluppata, gli utenti non hanno alcuna necessità di richiedere un certificato personale:viene infatti offerta, a più utenti contemporaneamente, la possibilità di richiederel'accesso alla Grid mediante lo stesso certificato Robot.Il certificato Robot è associato ad un unico utente e fino ad oggi è stato usato solo perLuca Gerardo 566/2636 Pagina 70 di 113

permettere alle applicazioni di svolgere dei tasks automatizzati sulla griglia a nomedell'utente. Esso è conservato in un token USB e criptato con password. Qualsiasi tipodi accesso a tale token, senza l'uso di apposite librerie, renderebbe il suo contenutoinutilizzabile.Attualmente, l'opportunità concessa a più utenti di utilizzare lo stesso certificato Robot,comporterebbe la generazione di proxy contententi informazioni relative al solopossessore del certificato, piuttosto che all'effettivo utilizzatore: non sarebbe piùpossibile, quindi, risalire all'effettivo utilizzatore del certificato, perdendo così latracciabilità delle operazioni svolte dall'utente nella griglia; sarebbe inoltrecompromessa la possibilità di esprimere politiche di accesso a risorse o servizi sullabase dell'identità dell'utente.L'applicazione da me sviluppata offre una soluzione ai problemi esposti poc'anzi,aggiungendo una nuova funzionalità al VOMS, e propone nuovi scenari di utilizzo diquesti certificati.La soluzione adottata per sopperire alle problematiche appena descritte è quella diinserire informazioni aggiuntive all'interno del proxy, generato a partire dal certificatoRobot, in modo tale da poter risalire comunque all'effettivo utilizzatore del certificato eda poter esprimere politiche di accesso a risorse o servizi.Per fare ciò, tale applicazione prevede una pagina di iscrizione dove l'utente va aspecificare, oltre alle informazioni personali, la propria e-mail.Queste informazioni saranno usate dall'applicazione per fare in modo che venganoinserite all'interno del server VOMS: in particolare la mail dell'utente sarà usata percreare un nuovo ruolo, che sarà poi associato al certificato Robot. A questo punto,all'atto della generazione del proxy a partire la certificato Robot, sarà contattato il serverVOMS che provvederà ad aggiungere, alle informazioni già presenti nel certificato, ilruolo.I vantaggi ottenuti dall'adozione di questa soluzione sono diversi: l'utente non ha più lanecessità di richiedere un certificato personale con conseguente disinteressamento dellasua gestione; l'accesso alla griglia risulta molto più semplice, veloce e trasparente. Tuttociò permette, grazie ai vantaggi esposti poc'anzi, un ampliamento del bacino di utenzadella grigliaLuca Gerardo 566/2636 Pagina 71 di 113

Un possibile scenario applicativo, oltre a quello citato nel paragrafo 6.1 che prevedel'accesso alla griglia, per gli utenti sprovvisti di certificato, mediante UI a riga dicomando, è l'accesso alla griglia stessa mediante un portale Web. La funzionalitàaggiuntiva, data al server VOMS, infatti, potrebbe essere sfruttata da un portale WEB inmodo tale da consentire l'accesso alle risorse della griglia anche ad utenti che non sonoin possesso di un certificato digitale personale.fig. 38In particolare, dopo la sottomissione al VOMS, della richiesta da parte dell'utente, nellaquale viene specificato principalmente il certificato Robot a cui l'utente vuole associarsie la propria e-mail, i dati raccolti saranno salvati, come già detto, all'interno del server: aquesto punto la mail, utilizzata come ruolo, sarà associata al certificato Robot.Luca Gerardo 566/2636 Pagina 72 di 113

Ora, essendo il portale l'unico punto di accesso alla griglia, l'utente, per poter sfruttare iservizi offerti da quest'ultima, dovrà innanzi tutto autenticarsi nei confronti del portale,inserendo le proprie credenziali, quali username e password. L'immissione corretta deidati comporta la generazione di un nuovo proxy, creato a partire dal certificato Robot.Mediante questo proxy, il portale contatta il VOMS e richiede a quest'ultimo diassociare al certificato, il ruolo relativo all'utente. Il server VOMS, basandosi sui dati asua disposizione, provvederà a creare un nuovo proxy con le informazioni aggiuntive.Solo a questo punto l'utente avrà la possibilità di accedere alle risorse della Grid.Avendo inserito all'interno del proxy il role relativo all'utente, sarà possibile sia tracciarel'attività da lui svolte all'interno della Grid, sia esprimere politiche di sicurezza sullabase della sua identità, in particolare del ruolo.I vantaggi ottenuti grazie all'adozione del portale Grid, consistono nell'accessotrasparente alle risorse computazionali dell'infrastruttura Grid, agevolando la diffusionedi questo nuovo paradigma agli utilizzatori anche meno esperti.Attualmente già esistono User Interface basate su portale web, che mettono adisposizione dell'utente le stesse operazioni fornite dalla UI a riga di comando, ma inmodo più user-friendly. Considerando, quindi, l'alto grado di portabilità fornitadall'applicazione da me sviluppata, si intende progettare un'implementazione diquest'ultima in modo da integrarla con i portali già esistenti, consentendo, quindi, diaccedere ai servizi grid in modo semplice, veloce e trasparente anche agli utenti che nonfanno uso di una User Interface a riga di comando. L'integrazione di questo servizio conle UI ampiamente utilizzate via web, inciderebbe, in modo ancora più marcato,sull'accrescimento del bacino di utenza dei siti Grid. Infatti, la maggior parte delleorganizzazioni scientifiche, che necessitano delle risorse messe a disposizione dai sitiGrid, non hanno particolare conoscenza della Unix Shell, preferendo tipi di interazionidifferenti. Inoltre, l'adozione di questa politica di utilizzo, consentirebbe agli utenti dievitare la prassi burocratica necessaria per ottenere un certificato digitale personale ed ilsuo management. In definitiva, l'ulteriore sviluppo e deployment dell'applicazioneincentiverebbe qualsiasi tipi di utente ad interfacciarsi agli ambienti Grid.Luca Gerardo 566/2636 Pagina 73 di 113

8 ConclusioniNel seguente lavoro di tesi è stata trattata la problematica di accesso ai sistemi Gridtramite certificato Robot. E' stata effettuata un analisi critica che ha messo in lucealcune debolezze dei certificati robot relativamente alla perdita di informazioni sugliutenti finali. Tali problematiche sono state affrontate studiando ed implementando unastrategia basata sulle VOMS extension, per rendere più espressivi i proxy usati inambito Grid, generati a partire da certificati robot. In particolare sono state estese,tramite una java application, le funzionalità del server di Virtual OrganizationMembership introducendo il concetto di associazione a certificato robot da parte dipersone fisiche.Il software è stato implementato con successo, insieme con tutta la casistica di accesso edi errore, ed è stato altresì testato in tutte le sue funzionalità.Nell'ambito di questo lavoro, è stato quindi creato un codice per la user-interface ingrado di lavorare con i supporti USB-Token (necessari per ospitare certificati robot) e dicreare proxy utilizzando le nuove estensioni VOMS predisposte.Tale codice rappresenta un motore da applicare come base per la creazione di portaliweb e di servizi di cloud computing su piattaforma Grid, basati su autenticazionetramite certificati robot.Software e strategie sono stati testati con successo in un semplice caso d'uso su una userinterface locale per consentire l'accesso ai servizi grid ad utenti non dotati di certificato.Gli sviluppi futuri prevedono l'immediata applicazione del VOMS esteso e del motoredi generazione proxy, per la creazione di user web-based ed interface userfriendly.Luca Gerardo 566/2636 Pagina 74 di 113

9. Bibliografia[1] SCOPE:URL: http://www.scope.unina.it[2] The Anatomy of the Grid - Enabling Scalable Virtual OrganizationsIan Foster e Carl Kesselman Steven Tuecke.[22] PON 2000-2006:URL: http://www.ponricerca.it/Public/PonRicerca/F1329/F1329.aspx[3] GRID: Ian Foster e Carl Kesselman (ed.), The Grid: Blueprint for a New ComputingInfrastructure, 2003, ISBN 1558609334.URL: http://it.wikipedia.org/wiki/GRID; http://www.grid.it[4] GLOBUS: I. Foster: “Globus Toolkit Version 4: Software for Service-OrientedSystems”, IFIP International Conference on Network and Parallel Computing, Springer-Verlag LNCS 3779, pp 2-13, 2005URL: http://www.globus.org/[5] MIDDLEWARE: R. Baldoni, corso Sistemi Operativi II, lezioni all’Università LaSapienza.URL: http://www.dis.uniroma1.it/~baldoni/SOII-middleware.pdf[6] PSE: Stratis Gallopoulos, Elias Houstis and John Rice: "Computer as Thinker/Doer:Problem-Solving Environments for Computational Science" IEEE ComputationalScience and Engineering, Summer, 1994.URL: http://www-cgi.cs.purdue.edu/cgi-bin/acc/pses.cgi[7] SCE: Longsong Lin; Decker, K.M.; Jognson, M.J.; Domain, C.; Souffez, Y.: "ISCN:towards a distributed scientific computing environment", in High PerformanceComputing on the Information Superhighway, 1997. HPC Asia apos;97Volume , Issue ,28 Apr-2 May 1997.URL: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.31.3183Luca Gerardo 566/2636 Pagina 75 di 113

10. Appendice: Codiceform.css:/*Document : formCreated on : 26-ott-2009, 9.25.55Author : lucaDescription:*/.inputField, .selectBox, .searchField {border: 1px solid rgb(200,200,200);}.submitButton {font-size: x-small;font-weight: bold;background-color: white;}.searchSubmitButton {font-weight: bold;background-color: white;}.form tr{}.form td{padding: .5ex;}table .form{border: 1px solid rgb(200,200,200);}.labels{color: #505050;padding-right: 1ex;}.fields{}layout.css/*Document : layoutCreated on : 26-ott-2009, 9.27.27Author : luca*/body{font-family: "Lucida Grande", verdana, lucida, helvetica, sans-serif;font-size: 9pt;background-color: white;color: black;max-width: 775px;min-width: 775px;text-align: center;margin-left: auto;margin-right: auto;padding:0;}#header, #body, #menu,#footer,#messages{Luca Gerardo 566/2636 Pagina 76 di 113

clear:both;padding: 0;}#header{color: #505050;}#headerTitle {float:left;font-size: 9pt;color: white;background-color: #1b5790;text-align: left;width: 775px;}#vaInfo {font-size: smaller;font-weight: bold;float:left;padding: .5em;color: #d2dcf3}#adminDN{font-weight: bold;color: white;}#voInfo{clear: both;float: left;}#headerInfo {clear: both;float: left;text-align:left;font-size: smaller;padding-left: .5em;background-color: #ececec ;}#voName {color: white;font-weight: bold;}.voName{color: #006600;font-weight: bold;font-size: larger;}#helpMenuItem {}#menu{padding: 0;float:left;background-color: #ccdeaf;color: black;width: 100%;}#messages{padding:.1em .1em 0 0;min-height: 2em;font-size: 8pt;font-weight: bold;}#body{Luca Gerardo 566/2636 Pagina 77 di 113

}#footer{margin-top: 1em;border-top: 1px solid rgb(200,200,200);font-size: xx-small;background-color: white;color: #505050;}#leftBar {display: block;float: left;width: 12%;padding-bottom: 0px;padding-left: 0px;padding-right: 0px;min-height:520px;}.leftBarHeader{text-align: center;font-weight: bold;color: #325B0A;padding-top: .5ex;padding-bottom: .5ex;background-color: #ccdeaf;}#userGroupsLeftBar{font-size: 8pt;border: 1px solid rgb(200,200,200);text-align: left;}#centerPane {float: left;display: block;width: 84%;margin-left: 2%;padding-right: 0px;text-align:left;}#oneColCenterPane{min-height:520px;}#createUserPane {float: left;font-size: 8pt;}#searchResultsPane, #searchGroupsResultsPane, #searchRolesResultsPane{clear: both;padding-top: 1em;}#searchUsersPane, #searchGroupsPane, #searchRolesPane, #searchUserAttributesPane{float: left;}#createGroupPane, #createRolePane, #createUserPane, #manageAttributeClassesPane{float: right;font-size: 8pt;margin-bottom: 1ex;max-width: 50%;}#listAttributeDescriptionsPane{margin-top: 2em;}.separator{Luca Gerardo 566/2636 Pagina 78 di 113

clear: both;height: 1ex;}#addACLEntryBox, #addDefaultACLEntryBox{float:right;}#leftBar a:hover{text-decoration: underline;}#leftBar a{padding: .5em;}#leftBar .disabledLink{padding: .5em;}link.css/*Document : linkCreated on : 26-ott-2009, 9.28.33Author : luca*/.vomsLink {font-weight: bold;text-decoration: none;display: block;}.vomsLink:HOVER {font-weight: bold;text-decoration: underline;}.navBarLink {font-weight: bold;text-decoration: none;padding-left: .5ex;padding-right: .5ex;}.navBarLink:HOVER {text-decoration: underline;}.actionLink {font-weight: normal;text-decoration: none;}.actionLink:HOVER {font-weight: normal;text-decoration: underline;}.disabledLink {display: inline;font-weight: bold;text-decoration: underline;display: block;color: rgb(155,155,155);}a,A {color: #456aac;text-decoration: none;Luca Gerardo 566/2636 Pagina 79 di 113

}a:HOVER{text-decoration: underline;}registration.css/*Document : registrationCreated on : 26-ott-2009, 9.31.15Author : luca*/#regDN{color: #006600;}#regCA, #regEmail {}.regLabel{color: #505050;font-weight: bold;}dt{margin-top: 1em;}dd{font-size: smaller;}stileForm.css:/*Document : stileFormCreated on : 24-ott-2009, 18.04.40Author : luca*/.root {display: block;border-left-color: red;border-left-style: solid;border-left-width: 1px;}style.css:/*Document : styleCreated on : 26-ott-2009, 9.33.15Author : luca*/@IMPORT url("layout.css");@IMPORT url("tables.css");@IMPORT url("menu.css");@IMPORT url("link.css");@IMPORT url("form.css");@IMPORT url("registration.css");.userDN {Luca Gerardo 566/2636 Pagina 80 di 113

text-align: left;font-size: small;}.userCA {font-size: x-small;color: #505050;}.userEmail{font-size: smaller;font-weight: bold;}.resultsHeader {font-size: xx-small;display: block;float: right;margin-bottom: .5ex;}.resultsFooter {font-size: xx-small;display: block;float: right;margin-top: .5ex;}.resultsCount {display: table-cell;padding-left: 1ex;padding-right: 1ex;}.resultsNavBarButton {display: inline;}.roleCell {margin-top: .1em;}.role {display: block;float: left;clear: both;font-weight: bold;}.group {text-align: left;font-weight: bold;}.action {display: block;float: right;font-size: x-small;}.roleAssign {font-size: x-small;float: right;clear: both;text-align: right;margin-top: .5em;}.roleAssign .submitButton {font-size: x-small;}.roleAssign .selectBox {font-size: x-small;}Luca Gerardo 566/2636 Pagina 81 di 113

.subscribeGroups {display: block;font-size: x-small;text-align: right;margin-top: .5em;}.subscribeGroups .submitButton {font-size: x-small;}.subscribeGroups .selectBox {font-size: x-small;}.header {display: block;clear: both;width: 100%;font-weight: bold;color: #505050;}.header1{display: block;clear: both;width: 100%;font-weight: bold;color: #505050;border-bottom: 1px solid rgb(200,200,200);margin-bottom: 1em;}.header2 {display: block;clear: both;width: 100%;font-weight: bold;color: #505050;margin-top: 1em;margin-bottom: 1em;}.header3{display: block;clear: both;width: 100%;font-weight: bold;color: #505050;margin-bottom: 1em;}.label {color: #505050;font-weight: bold;text-align: right;}.labels {color: #505050;text-align: right;}.deleteUserForm {text-align: right;}.deleteUserForm .submitButton {font-size: x-small;}.detailsBlock .submitButton {font-size: x-small;Luca Gerardo 566/2636 Pagina 82 di 113

}.attributeName {text-align: left;font-weight: bold;}.attributeValue {font-weight: bold;}.errorMessages {margin: 0;padding: 0;padding-left: 1em;padding-right: 1em;font-weight: bold;text-align: center;}.errorMessage{font-weight: bold;padding: .1em;padding-left: 1ex;padding-right: 1ex;}.errorMessage .message{display: none;}.errorMessage .detailedMessage {background-color: #ffffff;color: #cc0000;display: inline;padding: .1em;padding-left: 1ex;padding-right: 1ex;}.messages {color: #006600;background-color: white;display: inline;text-align: center;padding-left: 1ex;padding-right: 1ex;}.panel{font-size: 8pt;background-color: white;color: black;}.panelHeader{background-color: #ccdeaf;color: #325B0A;;float: left;font-weight: bold;}.panelContent{padding-left: 1ex;padding-right: 1ex;padding-top: .5ex;padding-bottom: .5ex;border-left: 1px solid rgb(200,200,200);border-right: 1px solid rgb(200,200,200);border-bottom: 1px solid rgb(200,200,200);}.panelTitle{Luca Gerardo 566/2636 Pagina 83 di 113

float: left;padding-left: 1ex;padding-top: .5ex;padding-bottom: .5ex;}.panelButton{float: right;padding-right: 1ex;padding-top: .5ex;padding-bottom: .5ex;}.panel .inputField,.selectBox,.caSelectBox,.submitButton{font-size: 8pt;}.admin .userDN{font-size: smaller;font-weight: bold;}.admin .userCA{font-size: x-small;}.voMembershipInfo, .genericAttributesInfo{padding-left: 2em;}.highlight{color: #006600;font-weight: bold;}.configurationInfo{background-color: #ececec ;}table.css/*Document : tablesCreated on : 26-ott-2009, 9.32.25Author : luca*/.table {width: 100%;padding: 0px;display: table;border-bottom: 1px solid rgb(200,200,200);/* border-left: 1px solid rgb(200,200,200); */}.tableHeader {font-weight: bold;text-align: center;display: table-cell;border-bottom: 1px solid rgb(200,200,200);/* border-right: 1px solid rgb(200,200,200); */background-color: #ccdeaf;}.tableHeaderRow {display: table-row;}.tableHeaderRow td{font-weight: bold;Luca Gerardo 566/2636 Pagina 84 di 113

text-align: left;display: table-cell;border-bottom: 1px solid rgb(200,200,200);/*border-top: 1px solid rgb(200,200,200);border-right: 1px solid rgb(200,200,200);*/color: #505050;padding: .2ex;}.tableRowEven {display: table-row;background-color: white;}.tableRowEven td{display: table-cell;text-align: left;/* border-right: 1px solid rgb(200,200,200); */padding: .5ex;}.tableRowOdd td{display: table-cell;text-align: left;padding: .5ex;}.tableRowOdd {background-color: #ececec ;display: table-row;}table{display: table;clear: both;}tr{display: table-row;}td{display: table-cell;}colgroup{display: table-column-group;}col{display: table-column;}menù.css:/*Document : menuCreated on : 26-ott-2009, 9.30.18Author : luca*/.menuItem {font-weight: bold;display: inline;float: left;Luca Gerardo 566/2636 Pagina 85 di 113

text-align: center;padding: .5em;}#helpMenuItem {display: inline;float: right;font-weight: bold;text-align: center;}.menuItem a{color: #325B0A;}.menuItem a:HOVER{color: black;text-decoration: underline;}checkFormDatiUser.jsfunction checkForm(){//riferimento al tag form... ora uso questo per riferirmi ai suoi campi!!!var form = document.SubmitRequestForm;var nome = form.Nome.value;var cognome = form.Cognome.value;var mail = form.mailUser.value;//riferimento al tag select presente all'interno del formvar menu = form.certifRobot;//valore della checkbox all'interno del form. E' true se selezionato, falsediversamentevar box = form.regAcc.checked;// Espressione regolare dell'emailvar email_reg_exp = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-]{2,})+\.)+([a-zA-Z0-9]{2,})+$/;//spiegazione dell'espressione regolare :la divido in parti:// ^([a-zA-Z0-9_\.\-])+ ==> ritorna true se la stringa comincia con uno o piùcaratteri appartenenti// appartenenti all'insieme// \@ ==> ritorna true se c'è il carattere "@"// (([a-zA-Z0-9\-]{2,})+\.)+ ==> ritorna true se la parte di expr reg "[a-zA-Z0-9\-]" è "matchata"//(ritrovata,ripetuta) ALMENO due volte dopodiche c'è il carattere "."//tutto questo ripetuto una o più volte(" il carattere '+' di expr")// ([a-zA-Z0-9]{2,})+$/ ==> ritorna true se la parte di expr reg "[a-zA-Z0-9\-]" è"matchata"//(ritrovata,ripetuta) ALMENO due volte, il tutto ripetuto una o//più volte("carattere '+' "). E così che deve terminare la stringa// (" carattere '$' ")if ( (nome == "") || (nome == "undefined") ){alert("Il campo Nome è obbligatorio.")return false;}else if ( (cognome == "") || (cognome == "undefined") ){alert("Il campo Cognome è obbligatorio.")return false;}else if( !email_reg_exp.test(mail) || (mail == "") || (mail == "undefined") ) {alert("Inserire un indirizzo email corretto.");return false;}else if(menu.selectedIndex == 0){alert("Scegliere un certificato dal menù.");Luca Gerardo 566/2636 Pagina 86 di 113

eturn false;}else if(box == false){alert("Bisogna accettare le regole della VO.");return false;}else {return true;}}-->index.jsp:Document : indexCreated on : 16-nov-2009, 19.26.18Author : luca--%>Iscrizione VO studentiIscrizionealla VO studentiuninaWelcome to voms-admin registration for the studentiVO.To access the VO resources, you must agree to the VO's Usage Rules.Please fill out all fields in the form below and click on the submitbutton at the bottom of the page.After you submit this request, you will receive an email with instructions on howto proceed.Your request will not be forwarded to the VO managers until you confirm that youLuca Gerardo 566/2636 Pagina 87 di 113

have a valid emailaddress by following those instructions.IMPORTANT:By submitting this information you agree that it may be distributed to and storedbyVO and site administrators. You also agree that action may be taken to confirm theinformation youprovideis correct, that it may be used for the purpose of controlling access to VOresources and that it maybeused to contact you in relation to this activity.Nome:Cognome:Indirizzo e-mail:Scegli Certificato Robot:Luca Gerardo 566/2636 Pagina 88 di 113

Mi attengo alle regole della VO.errorPage.jspDocument : errorPageCreated on : 23-nov-2009, 15.43.01Author : luca--%>

Iscrizionealla VO studentiunina Spiacenti, iparametri immessinon sono correttiSpiacenti, i parametri immessi non sono corretti!!!Ritornare alla pagina e inserire i parametri in modo corretto...servletController.java/** To change this template, choose Tools | Templates* and open the template in the editor.*/import java.io.IOException;import java.io.PrintWriter;import javax.mail.MessagingException;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import bean.*;import java.io.FileOutputStream;import java.io.PrintStream;import javax.servlet.RequestDispatcher;/**** @author luca*/public class servletController extends HttpServlet {/*** Processes requests for both HTTP GET and POST methods.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void processRequest(HttpServletRequest request, HttpServletResponseresponse)throws ServletException, IOException {doPost(request,response);response.setContentType("text/html;charset=UTF-8");PrintWriter out = response.getWriter();try {/* TODO output your page hereout.println("");out.println("");out.println("Servlet servletController");out.println("");out.println("");out.println("Servlet servletController at " + request.getContextPath () +"");out.println("");Luca Gerardo 566/2636 Pagina 90 di 113

out.println("");*/} finally {out.close();}}// /*** Handles the HTTP GET method.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {doPost(request,response);processRequest(request, response);}/*** Handles the HTTP POST method.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {//processRequest(request, response);String nome = null;String cognome = null;String email = null;String accetta = null; // gli sarà assegnato il valore della checkboxlong certificato =-1;long id_last_insert_user=-1;Database database =new Database();if (request.getParameter("cmd").equals("requestUseCertificate")){//prendo i parametri dal form e li inserisco nel bean//utente per poi usarle in seguito//creo il beannome = request.getParameter("Nome");cognome = request.getParameter("Cognome");email = request.getParameter("mailUser");//email = email.replaceAll("%40", "@");//certificato = Integer.valueOf(request.getParameter("value")).intValue();certificato = (Long.parseLong(request.getParameter("certifRobot")));//certificato = (int)Long.parseLong(request.getParameter("certifRobot"));utenteBean user = new utenteBean();user.setNome(nome);user.setCognome(cognome);//certifRobot contiene l'id del certificato della tab usruser.setCertificato(certificato);user.setMail(email);user.setAccettaRegoleVo(request.getParameter("regAcc"));//associo l'oggetto user(utenteBean) all'oggetto requestrequest.setAttribute("user",user);request.setAttribute("flagUtente","invalido");//passo i dati alla servlet checkDatiUser per il loro controllo//uso l'url rewriting perchè se in seguito volessi usare la stessa//servlet per altri controlli basterebbe cambiare il comando che leLuca Gerardo 566/2636 Pagina 91 di 113

viene passatoRequestDispatcher rd = getServletContext().getRequestDispatcher("/checkDatiUser?cmdControl=request");rd.include(request, response);if/*(*/((request.getAttribute("flagUtente")).equals("valido") ) /*&&(request.getAttribute("flagUtente").equals("valido")))*/{//richiamo la query per l'inserimento e visualizzo la pagina che informa l'utente//dell'esito positivo dell'immissione della richiestaid_last_insert_user =database.insertRequestPending(nome,cognome,email,certificato);//Richiamo la servlet per l'invio della mailRequestDispatcher rd2 = getServletContext().getRequestDispatcher("/mail?id="+id_last_insert_user);rd2.include(request, response);database.closeConnection();response.sendRedirect("./requestAccepted.jsp");}else{database.closeConnection();chiamo la pagina che visualizza l'errore!!!response.sendRedirect("./errorPage.jsp");}}database.closeConnection();}/*** Returns a short description of the servlet.* @return a String containing servlet description*/public String getServletInfo() {return "Short description";}// }checkDatiUser.java/** To change this template, choose Tools | Templates* and open the template in the editor.*/import java.io.IOException;import java.io.PrintWriter;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import bean.*;import java.io.FileOutputStream;import java.io.PrintStream;import java.util.*;import java.util.regex.Pattern;/**** @author luca*/public class checkDatiUser extends HttpServlet {/*** Processes requests for both HTTP GET and POST methods.* @param request servlet request* @param response servlet responseLuca Gerardo 566/2636 Pagina 92 di 113

* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void processRequest(HttpServletRequest request, HttpServletResponseresponse)throws ServletException, IOException {doPost(request,response);response.setContentType("text/html;charset=UTF-8");PrintWriter out = response.getWriter();try {/* TODO output your page hereout.println("");out.println("");out.println("Servlet checkDatiUser");out.println("");out.println("");out.println("Servlet checkDatiUser at " + request.getContextPath () + "");out.println("");out.println("");*/} finally {out.close();}}// /*** Handles the HTTP GET method.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {doPost(request,response);processRequest(request, response);}/*** Handles the HTTP POST method.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {//processRequest(request, response);Database database =new Database();if (request.getParameter("cmdControl").equals("request")){utenteBean utente = (utenteBean)request.getAttribute("user");String email = utente.getMail();long certificato =utente.getCertificato();boolean flagMail = false;boolean flagMailResponse=false;String flagUtente = null;//espressione regolare per validare l'e-mail dal punto di vista sintatticoString regExpr ="[a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}";//controllo sintattico dell'emailif (Pattern.matches(regExpr, email)){flagMail = true;Luca Gerardo 566/2636 Pagina 93 di 113

}//controllo l'email//controllo se è già stata fatta una richiesta con la stessa mail//o se è già presente un role associato a qeusta e-mailif(certificato!=0 && flagMail){flagMailResponse = database.getResponseEmail(email,certificato);database.closeConnection();if( utente.getNome().equals("") || utente.getCognome().equals("") ||utente.getCertificato() == 0 || (!(utente.getAccettaRegoleVo()!=null)) ||flagMailResponse!=true ){flagUtente = "invalido";request.setAttribute("flagUtente",flagUtente);//da quello che ho capito è qui il problema...vedi perchè//entra in questo if se inserisco tutti i parametri in modo//corretto...se proprio devi,scrivi su file i parametri!!!//cmq dopo togli tutti quegli if nella servlet Controller}else {flagUtente = "valido";request.setAttribute("flagUtente",flagUtente);}}else {flagUtente ="invalido";request.setAttribute("flagUtente",flagUtente);}}database.closeConnection();}/*** Returns a short description of the servlet.* @return a String containing servlet description*/public String getServletInfo() {return "Short description";}// }mail.java/** To change this template, choose Tools | Templates* and open the template in the editor.*/import bean.*;import java.io.FileOutputStream;import java.io.IOException;import java.io.PrintStream;import java.io.PrintWriter;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.mail.*;import javax.mail.internet.*;import java.util.*;/**** @author luca*/public class mail extends HttpServlet {/*** Processes requests for both HTTP GET and POST methods.Luca Gerardo 566/2636 Pagina 94 di 113

* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void processRequest(HttpServletRequest request, HttpServletResponseresponse)throws ServletException, IOException {doPost(request, response);response.setContentType("text/html;charset=UTF-8");PrintWriter out = response.getWriter();try {/* TODO output your page hereout.println("");out.println("");out.println("Servlet mail");out.println("");out.println("");out.println("Servlet mail at " + request.getContextPath () + "");out.println("");out.println("");*/} finally {out.close();}}// /*** Handles the HTTP GET method.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {doPost(request, response);processRequest(request, response);}/*** Handles the HTTP POST method.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {//processRequest(request, response);try {//processRequest(request, response);long request_id = Long.parseLong(request.getParameter("id"));utenteBean utente = (utenteBean) request.getAttribute("user");//server smtpString mailHost = "mail.unina.it";//destinatario mailString to = utente.getMail();// Creazione di una mail sessionProperties props = new Properties();props.put("mail.smtp.host", "localhost");Luca Gerardo 566/2636 Pagina 95 di 113

Session session = Session.getDefaultInstance(props);// Creazione del messaggio da inviareMimeMessage message = new MimeMessage(session);message.setSubject("Conferma Iscrizione VO Studenti!!!");String body = "Prima di essere definitavemente inoltrata la tua richiesta alVOMS Studenti Unina" +"bisogna che tu confermi quest'ultima mediante il seguente link:"+"Conferma richiesta"+"Se invece ritiene di non aver richiesto nulla di tutto ciò usa ilseguente link:"+"Annulla richiesta";message.setContent(body,"text/html");//message.setText("Questa e-mail è stata inviata dalla mia applicazione java!!!");//message.setContent("Questa riga è stata scritta in HTML", "text/html");//message.setContent("Anche questa!!!", "text/html");//message.setContent(" Link text ", "text/html");//message.setContent("Gerardo Luca ", "text/html");// Aggiunta degli indirizzi del mittente e del destinatarioInternetAddress fromAddress = new InternetAddress("spardi@na.infn.it");InternetAddress toAddress = new InternetAddress(to);message.setFrom(fromAddress);message.setRecipient(Message.RecipientType.TO, toAddress);// Invio del messaggioTransport.send(message);} catch (MessagingException ex) {ex.printStackTrace();}}/*** Returns a short description of the servlet.* @return a String containing servlet description*/public String getServletInfo() {return "Short description";}// }Database:/** To change this template, choose Tools | Templates* and open the template in the editor.*/package bean;/**** @author luca*/import java.io.FileOutputStream;import java.io.PrintStream;import java.sql.*;import java.util.*;public class Database {private String nomeDB; // Nome del Database a cui connettersiprivate String nomeUtente; // Nome utente utilizzato per la connessione al Databaseprivate String pwdUtente; // Password usata per la connessione al Databaseprivate String errore; // Raccoglie informazioni riguardo l'ultima eccezionesollevataLuca Gerardo 566/2636 Pagina 96 di 113

private Connection db = null; // La connessione con il Databasepublic Database() {this.nomeDB = "studentivomsdb";this.nomeUtente = "root";this.pwdUtente = "*********";errore = "";}public String getErrore(){return this.errore;}// Apre la connessione con il Databasepublic void connetti() {try {if(db==null){// Carico il driver JDBC per la connessione con il database MySQLClass.forName("com.mysql.jdbc.Driver");// La connessione necessita della passworddb = DriverManager.getConnection("jdbc:mysql://localhost:3306/" + nomeDB + "?user="+ nomeUtente +"&password=" + pwdUtente);// La connessione è avvenuta con successo}}catch (Exception e) { errore = e.getMessage(); }}public void closeConnection(){if(db!=null){try {db.close();db = null;} catch (SQLException ex) {ex.printStackTrace();}}}//querypublic ResultSet getCertRobot() throws SQLException{ResultSet result = null;this.connetti();Statement stmt = db.createStatement();result = stmt.executeQuery("select userid,cn from usr where cn LIKE '%Robot%'");return result;}public boolean getResponseEmail(String email, long certificatoRobot){this.connetti();ResultSet result = null;int count = 0;int countM = 0;long rid=0;//trasformo la mail in "role" perchè mi servirà dopoString emailModif= email.replaceAll("@", "_at_");try {Statement stmt = db.createStatement();result = stmt.executeQuery("select count(*) mail from request_pending where maillike '"+ email+"'");if(result.next()){count = result.getInt(1);}stmt.close();//cancella le successive righeif (count == 0) {//vuol dire che non c'è una richiesta pendente con la stessa mail//e quindi controllo se questo role è già associato al certifRobot//passato al metodo (che sarebbe il certif scelto dall'utente)!!!stmt = db.createStatement();Luca Gerardo 566/2636 Pagina 97 di 113

esult =stmt.executeQuery("select rid from roles where role like'"+emailModif+"'");if(result.next()){ //se la query ritorna un valore...rid=result.getLong(1);}else{ //vuol dire che resul.next()=null!!! quindi assegno io il val a rid//per evitare l'eccezione. Cmq questo significa che non esiste quel//role nel db!!!rid=0;}result.close();if (rid == 0){ //vuol dire che non esiste alcun role con la stessa email!!!return true;//qundi la mail è ok e ripasso il flusso di controllo//per il check degli altri parametri}else{ //vuol dire che già esiste questo role e quindi devo//vedere se è già associato al certificato robot passatomi// N.B. ricorda che il cert robot è "un utente" nella tab usr!!!result = stmt.executeQuery("select count(*) " +"from m " +"where userid= "+certificatoRobot+" and rid="+rid);if(result.next()){countM=result.getInt(1);}if(countM==0){return true; // il ruolo esiste ma non è associato al certRobot richiesto//dall'utente quindi do l'ok al chiamante di proseguire//con il controllo degli altri dati utente!!!}else{ //esiste già un ruolo associato al certif robot e quindi// non accetto la richiesta dell'utente!!!return false;}}}} catch (SQLException ex) {ex.printStackTrace();}return false; //se count!=0 cioè esiste già quella mail nella tab delle//richieste pendenti!!!}public long insertRequestPending(String nome, String cognome, String email, longcertRobot){long id_last_user=-1;try {java.util.Date dateUtil=new java.util.Date();java.sql.Date dateSql=new java.sql.Date(dateUtil.getTime());this.connetti();String sql = "INSERT INTO request_pending(nome, cognome, mail, certif_robot,data_request) VALUES(?,?,?,?,?)";//Creazione dello statementPreparedStatement mystat = db.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);mystat.setString(1, nome);mystat.setString(2, cognome);mystat.setString(3, email);mystat.setLong(4, certRobot);mystat.setDate(5, dateSql);//Esecuzione dello statementmystat.executeUpdate();ResultSet rs = mystat.getGeneratedKeys();while(rs.next()){id_last_user = rs.getLong(1);Luca Gerardo 566/2636 Pagina 98 di 113

}rs.close();//Chiusura dello statementmystat.close();} catch (SQLException ex) {ex.printStackTrace();}return id_last_user;}public ResultSet getRequestPending(){ResultSet result = null;try {this.connetti();String sql = "SELECT * " +"FROM request_pending " +"WHERE confirm_request like 'YES' " +"ORDER BY request_id";Statement stmt = db.createStatement();result = stmt.executeQuery(sql);} catch (SQLException ex) {ex.printStackTrace();}return result;}//ritorna il nome del certificato in base all'id passatopublic String getNomeCertRobot(long id_certificato) throws SQLException{ResultSet result = null;this.connetti();Statement stmt = db.createStatement();result = stmt.executeQuery("select cn from usr where userid= '"+id_certificato+"'");result.next();String nome =result.getString(1);this.closeConnection();return nome;}public void deleteRequestPending(long request_id){try {this.connetti();String sql = "DELETE FROM request_pending " +"WHERE request_id= ?";PreparedStatement mystat=db.prepareStatement(sql);mystat.setLong(1, request_id);mystat.executeUpdate();//this.closeConnection();} catch (SQLException ex) {ex.printStackTrace();}}//mi da le info dell'utente richiedente in base all'id della tab request_pendingche gli passopublic ResultSet getUserRichiedente(long request_id){ResultSet result = null;try {this.connetti();Statement stmt = db.createStatement();result = stmt.executeQuery("select * from request_pending where request_id = " +request_id);} catch (SQLException ex) {ex.printStackTrace();}return result;}Luca Gerardo 566/2636 Pagina 99 di 113

public void confirmRequestPending(long idUser){try {String sql = "update request_pending set confirm_request='YES' where request_id=?";this.connetti();PreparedStatement mystat = db.prepareStatement(sql);mystat.setLong(1, idUser);//Esecuzione dello statementmystat.executeUpdate();//Chiusura dello statementmystat.close();} catch (SQLException ex) {ex.printStackTrace();}}public boolean checkRequestPending(long idUser){ResultSet result = null;String app=null;try {this.connetti();Statement stmt = db.createStatement();result = stmt.executeQuery("select confirm_request from request_pending whererequest_id = " + idUser);if(result.next()){app = result.getString(1);}else{//Non esiste più la riga con quell'id ==> la richiesta è già stata confermata orifiutatareturn false;}stmt.close();result.close();} catch (SQLException ex) {ex.printStackTrace();}if(app.equals("YES")){return false;}return true;}//ritorna il rid del role se nella tab roles esiste già un ruolo uguale a quellopassato//altrimenti ritorna -1public long isRole(String mail){long rid=-1;try {ResultSet result = null;mail = mail.replaceAll("@", "_at_");int count = 0;try {this.connetti();Statement stmt = db.createStatement();result = stmt.executeQuery("select count(*), rid from roles where role like '" +mail + "'");} catch (SQLException ex) {ex.printStackTrace();}if (result.next()) {count = result.getInt(1);if(count > 0){rid = result.getLong(2);}}Luca Gerardo 566/2636 Pagina 100 di 113

esult.close();} catch (SQLException ex) {ex.printStackTrace();}return rid;}public void insertIntoM(long certif_robot, long gid, long rid){String sql;this.connetti();try {//N.B. In questo caso lo userid sarebbe il certificato Robot che viene visto comese//fosse un utente!!!//devi vedere le rid ==-1 vuol dire che sto facendo l'inserimento completo e quindi//devi valutare anche questa ipotesi facendo un if. if rid != -1 fa i questo//else definisci nuovamente sql ma stavolta con due soli punti interrogativiif(rid!=-1){sql = "INSERT INTO m(userid, gid, rid) VALUES(?,?,?)";PreparedStatement mystat = db.prepareStatement(sql);mystat.setLong(1, certif_robot);mystat.setLong(2, gid);mystat.setLong(3, rid);//Esecuzione dello statementmystat.executeUpdate();//Chiusura dello statementmystat.close();}else{sql = "INSERT INTO m(userid, gid) VALUES(?, ?)";PreparedStatement mystat = db.prepareStatement(sql);mystat.setLong(1, certif_robot);mystat.setLong(2, gid);//Esecuzione dello statementmystat.executeUpdate();//Chiusura dello statementmystat.close();}} catch (SQLException ex) {ex.printStackTrace();}}public ResultSet getGid(){ResultSet result = null;try {this.connetti();Statement stmt = db.createStatement();result = stmt.executeQuery("select distinct gid from groups");} catch (SQLException ex) {ex.printStackTrace();}return result;}public ResultSet getAdmin(){ResultSet result = null;this.connetti();String sql = "select adminid from admins where adminid != 3 and adminid != 4 orderby adminid";try {Statement stmt = db.createStatement();result = stmt.executeQuery(sql);} catch (SQLException ex) {ex.printStackTrace();Luca Gerardo 566/2636 Pagina 101 di 113

}return result;}public long insertIntoUsr(String nome, String cognome, String mail){long id_last_user = -1;this.connetti();try {String stringa = null;String nomeCompleto = nome+" "+cognome;stringa = "/C=IT/O=LOCAL/OU=user_of_robot_certificate/L=FedericoII/CN=" +nomeCompleto;String sql = "INSERT INTO usr(dn, cn, mail) VALUES(?, ?, ?)";PreparedStatement mystat = db.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);mystat.setString(1, stringa);mystat.setString(2, nomeCompleto);mystat.setString(3, mail);//mi prendo anche l'id dell'utente appena inserito nella tab usrmystat.executeUpdate();ResultSet rs = mystat.getGeneratedKeys();while(rs.next()){id_last_user = rs.getLong(1);}rs.close();mystat.close();} catch (SQLException ex) {ex.printStackTrace();}return id_last_user;}public long insertIntoRoles(String mail){long last_insert_id = -1;try {this.connetti();mail = mail.replaceAll("@", "_at_");String sql = "INSERT INTO roles(role) VALUES(?)";PreparedStatement mystat = db.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);mystat.setString(1, mail);mystat.executeUpdate();ResultSet rs = mystat.getGeneratedKeys();while (rs.next()) {last_insert_id = rs.getLong(1);}rs.close();mystat.close();} catch (SQLException ex) {ex.printStackTrace();}//ritorno l'id del role appena inseritoreturn last_insert_id;}}utenteBean.java/** To change this template, choose Tools | Templates* and open the template in the editor.Luca Gerardo 566/2636 Pagina 102 di 113

*/package bean;import java.sql.*;/**** @author luca*/public class utenteBean {String nome = "";String cognome = "";String mail = "";String ca = "NULL";String dn = null;String accettaRegoleVo = null;long certificato = -1;Date data = null;//metodi getpublic String getNome(){return this.nome;}public String getCognome(){return this.cognome;}public String getMail(){return this.mail;}public String getCa(){return this.ca;}public String getDn(){return this.dn;}public long getCertificato(){return this.certificato;}public Date getData(){return this.data;}public String getAccettaRegoleVo(){return accettaRegoleVo;}//metodi setpublic void setNome(String nome){this.nome = nome;}public void setCognome(String cognome){this.cognome = cognome;}public void setMail(String mail){this.mail = mail;}public void setDn(String dn){this.dn = dn;}public void setCertificato(long certificato){this.certificato = certificato;}public void setData(Date data){this.data = data;}public void setAccettaRegoleVo(String acc){accettaRegoleVo=acc;Luca Gerardo 566/2636 Pagina 103 di 113

}}indexAdmin.jspIscrizione VO studentiIscrizionealla VO studentiuninaWelcome to voms-admin registration for the studenti VO. RichiestependentiRequest_idNomeCognomeEmailCertificato RobotAcceptReject

while(rs.next()){i++;if(i%2 != 0){%> insertionSuccesful.jsp

Author : luca--%>Iscrizione VO studentiIscrizionealla VO studentiunina OperazioneconclusaOperazione conclusa!servletControllerAdmin.java/** To change this template, choose Tools | Templates* and open the template in the editor.*/import java.io.IOException;import java.io.PrintWriter;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import bean.*;import java.util.Enumeration;import java.util.LinkedList;import javax.servlet.RequestDispatcher;/**** @author luca*/public class servletControllerAdmin extends HttpServlet {/*** Processes requests for both HTTP GET and POST methods.Luca Gerardo 566/2636 Pagina 106 di 113

* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void processRequest(HttpServletRequest request, HttpServletResponseresponse)throws ServletException, IOException {response.setContentType("text/html;charset=UTF-8");PrintWriter out = response.getWriter();try {/* TODO output your page hereout.println("");out.println("");out.println("Servlet servletControllerAdmin");out.println("");out.println("");out.println("Servlet servletControllerAdmin at " + request.getContextPath () +"");out.println("");out.println("");*/} finally {out.close();}}// /*** Handles the HTTP GET method.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {processRequest(request, response);}/*** Handles the HTTP POST method.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {//processRequest(request, response);//Non uso la programmazione generica(ovvero l'uso dei parametrici)//a causa della versione di java che risiede sul server!!!//so cmq che quì ci saranno solo oggetti LongLinkedList accettati = new LinkedList();LinkedList rifiutati = new LinkedList();if (request.getParameter("cmd").equals("acceptUseCertificate")){//LE UNICHE COSE CHE RICEVO DALLA PAGINA PRECEDENTE SONO I RADIO BUTTON!!!/** ECCO COSA FARE:* PER TUTTI I BOTTONI PRESENTI PRENDI IL LORO VALORE.* PER CIASCUNO VEDI SE È DIVERSO DA NULL E DIVERSO DALLA STRINGA* reject. SE È COSÌ ALLORA INSERISCILO IN UNA LISTA* A QUESTO PUNTO SETTI LE LISTE COME ATTRIBUTO A REQUEST E PASSI IL CONTROLLO ADLuca Gerardo 566/2636 Pagina 107 di 113

UN'ALTRA SERVLET* CHE PENSERÀ AD USARE QUESTA LISTA CHE CONTIENE GLI ID DI TUTTI QUELLI CHE SONO* STATI ACCETTATI. QUELLI CHE NON VENGONO ACCETTATI SARANNO INSERITI IN UNA* ALTRA LISTA E SI PROVVEDERÀ A "DISPATCHARE" IL CONTROLLO ALLE DUE SERVLET* CHE GESTISCONO LE DUE LISTE**/Enumeration e =request.getParameterNames();//long app=-1;while(e.hasMoreElements()){String app1 = (String) e.nextElement();if(!(app1.equals("cmd"))){if(request.getParameter(app1).equals("accept")){//inserisci nella lista degli accettatiaccettati.add(Long.valueOf(app1));}else{//inserisci nella lista dei non ammessirifiutati.add(Long.valueOf(app1));}}}request.setAttribute("listaAccettati", accettati);request.setAttribute("listaRifiutati", rifiutati);//chiamo la servlet che si occupa di cancellare le richiesteRequestDispatcher rd =getServletContext().getRequestDispatcher("/cancellaRichiesta");rd.include(request, response);//chiamo la servlet che provvede ad inserire i dati nel DBRequestDispatcher rd2=getServletContext().getRequestDispatcher("/inserisciUtente");rd2.include(request, response);response.sendRedirect("./insertionSuccesful.jsp");}}/*** Returns a short description of the servlet.* @return a String containing servlet description*/public String getServletInfo() {return "Short description";}// }inserisciUtente.java/** To change this template, choose Tools | Templates* and open the template in the editor.*/import java.io.IOException;import java.io.PrintWriter;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import bean.*;import java.sql.*;import java.util.*;Luca Gerardo 566/2636 Pagina 108 di 113

**** @author luca*/public class inserisciUtente extends HttpServlet {/*** Processes requests for both HTTP GET and POST methods.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void processRequest(HttpServletRequest request, HttpServletResponseresponse)throws ServletException, IOException {doPost(request,response);response.setContentType("text/html;charset=UTF-8");PrintWriter out = response.getWriter();try {/* TODO output your page hereout.println("");out.println("");out.println("Servlet inserisciUtente");out.println("");out.println("");out.println("Servlet inserisciUtente at " + request.getContextPath () +"");out.println("");out.println("");*/} finally {out.close();}}// /*** Handles the HTTP GET method.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {doPost(request,response);processRequest(request, response);}/*** Handles the HTTP POST method.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {//processRequest(request, response);Database db = new Database();ResultSet result = null;ResultSet rs_gruppi = null;Luca Gerardo 566/2636 Pagina 109 di 113

ResultSet rs_admin = null;long app=-1;long certif_robot;long rid; //nel caso in cui esiste già questo ruololong gid; //è il gid della tabella groups!!!long last_insert_id_into_usr;long last_insert_id_into_roles;String nome,cognome,mail;LinkedList listaAccettati = new LinkedList();//Lista di tutti i gruppi presenti per usare il nuovo ruolo in ogni gruppoLinkedList gruppi = new LinkedList();listaAccettati = (LinkedList) request.getAttribute("listaAccettati");//prendo un'iteratore per scorrere la lista degli utenti accettati//quì dentro c'è l'id della tab request_pendingIterator i = listaAccettati.iterator();Iterator i2 = null; //questo lo usa per la lista gruppirs_gruppi = db.getGid();try {while (rs_gruppi.next()) { //inserisco tutti i gruppi nella lista gruppigruppi.add(Long.valueOf(rs_gruppi.getLong(1)));}rs_gruppi.close();} catch (SQLException ex) {ex.printStackTrace();}//prendo un iteratore per scorrere la lista gruppi!!!while(i.hasNext()){ //per ogni utente accettato!!!i2 = gruppi.iterator();app = ((Long)i.next()).longValue(); //ora ho l'id della tab request_pendingrelativo all'utenteresult = db.getUserRichiedente(app);//ora in result ho le info dell'utente ed ho due possibilità://o esiste già il role per l'utente perchè si è già associato a qualche altrocertif robot//oppure il role non esiste e quindi devo fare linserimento "per intero"!!!try {if (result.next()) { //sicuramente result non è null!!!nome = result.getString(2);cognome = result.getString(3);mail = result.getString(4);certif_robot = result.getLong(5);rid = db.isRole(mail);if(rid != -1){//vuol dire che il role esiste già e quindi lo devo solo associare al certif robot//perchè se esiste il role, dato che è univoco, esiste già anche lo user!!!while(i2.hasNext()){ //per ogni gruppo presente in groupsgid = ((Long)i2.next()).longValue(); //prendo il giddb.insertIntoM(certif_robot, gid, rid); //e inserisco nella tab m//se non lo voglio fare per ogni gruppo ma solo per il gruppo di default//(che è OBBLIGATORIO) ed il gruppo per gli studenti (nel mio caso 3)//basta mettere una clausula where nella query!!!}}else{ //vuol dire che il role = -1 =>non esiste alcun role del genere nel DB// e quindi devo fare l'inserimento per interolast_insert_id_into_usr = db.insertIntoUsr(nome, cognome, mail);//inserisci il ruolo e mi faccio dare il lastInsertIdlast_insert_id_into_roles = db.insertIntoRoles(mail);//adesso faccio l'ultimo inserimento in m e lo faccio per tutti i gruppi//RIPETO che se non voglio farlo per tutti i gruppi ma solo per quello di//default (l'1 che è obbligatorio) e per quello previsto per gli//utenti che useranno il certificato robot(il 3 nel mio caso) basta//modificare la query relativa.Luca Gerardo 566/2636 Pagina 110 di 113

while(i2.hasNext()){ //per ogni gruppo presente in groupsgid = ((Long)i2.next()).longValue(); //prendo il giddb.insertIntoM(certif_robot, gid, last_insert_id_into_roles); //e inserisco nellatab m//se non lo voglio fare per ogni gruppo ma solo per il gruppo di default//(che è OBBLIGATORIO) ed il gruppo per gli studenti (nel mio caso 3)//basta mettere una clausula where nella query!!!}}}} catch (SQLException ex) {ex.printStackTrace();}//cancello l'utente accettato dalla tab req_pending perchè il suo inserimento//nel db è stato completato!!!db.deleteRequestPending(app);db.closeConnection();}/*Database db = new Database();Enumeration e =request.getParameterNames();long app=-1;//oppure//request.getParameterMap();//long app = Long.parseLong(request.getParameter("scelta3"));response.setContentType("text/html;charset=UTF-8");PrintWriter out = response.getWriter();out.println(" prova ");out.println("");//devo evitare di processare il parametro cmd//da che sarà l'ultimo basta che metto una condizione nell'ifwhile(e.hasMoreElements()){String app1=(String) e.nextElement();if(!(app1.equals("cmd"))){out.println(" Il il valore di "+app1+" è " + request.getParameter(app1)+"");if(request.getParameter(app1).equals("reject")){db.deleteRequestPending(Long.parseLong(app1));}}}out.print("");out.println("");out.close();*/}/*** Returns a short description of the servlet.* @return a String containing servlet description*/public String getServletInfo() {return "Short description";}// }cancellaRichiesta.java/** To change this template, choose Tools | Templates* and open the template in the editor.*/Luca Gerardo 566/2636 Pagina 111 di 113

import java.io.IOException;import java.io.PrintWriter;import java.util.*;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import bean.*;/**** @author luca*/public class cancellaRichiesta extends HttpServlet {/*** Processes requests for both HTTP GET and POST methods.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void processRequest(HttpServletRequest request, HttpServletResponseresponse)throws ServletException, IOException {doPost(request,response);response.setContentType("text/html;charset=UTF-8");PrintWriter out = response.getWriter();try {/* TODO output your page hereout.println("");out.println("");out.println("Servlet cancellaRichiesta");out.println("");out.println("");out.println("Servlet cancellaRichiesta at " + request.getContextPath () +"");out.println("");out.println("");*/} finally {out.close();}}// /*** Handles the HTTP GET method.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occurs* @throws IOException if an I/O error occurs*/protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {doPost(request,response);processRequest(request, response);}/*** Handles the HTTP POST method.* @param request servlet request* @param response servlet response* @throws ServletException if a servlet-specific error occursLuca Gerardo 566/2636 Pagina 112 di 113

* @throws IOException if an I/O error occurs*/protected void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {//processRequest(request, response);Database db=new Database();LinkedList listaRifiutati = new LinkedList();listaRifiutati =(LinkedList) request.getAttribute("listaRifiutati");Iterator i = listaRifiutati.iterator();long app=-1;while (i.hasNext()){//dato che i.next() mi ritorna un tipo Object => faccio il cast a Long//e poi lo trasformo in long!!!app = ((Long)i.next()).longValue();//cancello l'utente!!!db.deleteRequestPending(app);}db.closeConnection();}/*** Returns a short description of the servlet.* @return a String containing servlet description*/public String getServletInfo() {return "Short description";}// }Luca Gerardo 566/2636 Pagina 113 di 113