Programmazione e gestione della sicurezza: Verbale elettronico

1,117 views

Published on

Realizzare un applicativo che permetta di verbalizzare gli esami in forma digitale. Ogni esame sarà formato dal nome dell'insegnamento, la data dell'esame, il nome e il numero di matricola dello studente che sostiene l'esame, il numero di crediti, alcune possibili note o domande effettuate durante l'esame e naturalmente dal voto in trentesimi. L'esame così costituito dovrà essere firmato digitalmente dallo studente. Ogni esame sarà memorizzato in un verbale che conterrà il nome della facoltà, il nome del corso di laurea, il nome dell'insegnamento, la lista dei docenti in commissione. Il verbale per essere “chiuso” dovrà essere corredato da un timestamping e firmato digitalmente da ogni componente della commissione.

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
1,117
On SlideShare
0
From Embeds
0
Number of Embeds
4
Actions
Shares
0
Downloads
7
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Programmazione e gestione della sicurezza: Verbale elettronico

  1. 1. Università degli Studi di Perugia LAUREA SPECIALISTICA IN INFORMATICA Prof.ri Silvia Suriani, Roberto Rossi - A. A. 2008/2009 Programmazione e gestione della sicurezza con laboratorio Progetto: Verbale elettronico Studenti: Manfucci Andrea Ciambelli Davide 1
  2. 2. Indice generale 1 Introduzione...................................................................................................................................3 1.1 Il problema.................................................................................................................................3 1.2 Descrizione................................................................................................................................3 1.3 Ambiente di sviluppo.................................................................................................................3 2 Il Database uni_db.sql.................................................................................................................4 2.1 Introduzione e implementazione................................................................................................4 3 Il Keystore keystore_di_prova...................................................................................................7 3.1 Generazione del keystore...........................................................................................................7 4 Funzionamento del software......................................................................................................8 4.1 Form iscrizione Professore/Studente.........................................................................................8 4.2 Form login Professore/Studente...............................................................................................10 4.3 Form Menù Studente................................................................................................................11 4.4 Form Menù Professore.............................................................................................................13 4.5 Form Firma verbale.................................................................................................................14 2
  3. 3. 1 Introduzione 1.1 Il problema Realizzare un applicativo che permetta di verbalizzare gli esami in forma digitale. Ogni esame sarà formato dal nome dell'insegnamento, la data dell'esame, il nome e il numero di matricola dello studente che sostiene l'esame, il numero di crediti, alcune possibili note o domande effettuate durante l'esame e naturalmente dal voto in trentesimi. L'esame così costituito dovrà essere firmato digitalmente dallo studente. Ogni esame sarà memorizzato in un verbale che conterrà il nome della facoltà, il nome del corso di laurea, il nome dell'insegnamento, la lista dei docenti in commissione. Il verbale per essere “chiuso” dovrà essere corredato da un timestamping e firmato digitalmente da ogni componente della commissione. 1.2 Descrizione Il software realizzato consiste in un programma utile alla gestione degli esami e dei rispettivi verbali. L'accesso al sistema è consentito a due categorie di individui: • Studenti, il cui scopo è quello di prenotare, sostenere e firmare digitalmente gli esami; • Professori, il cui scopo è quello di valutare gli esami di ciascuno studente e firmare digitalmente i verbali degli esami. L'analisi del programma mette in evidenza le seguenti caratteristiche: per quanto riguarda gli Studenti si prevedono le seguenti funzioni: • prenotazione degli esami da sostenere nelle corrispondenti date di appello; • rifiuto o firma degli esami superati. Per quanto riguarda i Professori invece, si prevedono le seguenti funzioni: • valutazione degli esami sostenuti dagli studenti; • firma e chiusura dei verbali relativi a ciascun esame. 1.3 Ambiente di sviluppo Per questo tipo di progettazione si è scelta una metodologia di sviluppo orientata agli oggetti sfruttando il Java come linguaggio di programmazione e l'IDE NetBeans come ambiente di sviluppo. Inoltre è stata realizzata una base di dati per contenere tutte le informazioni relative agli individui e agli insegnamenti utilizzando il DBMS MySQL. Per generare il keystore contenente tutte le coppie di chiavi da assegnare a ciascun individuo abbiamo utilizzato Keytool, strumento connesso con Java(TM) 2 Platform Standard Edition 6 Update 12 distribuito da Sun Microsystems, Inc.. 3
  4. 4. 2 Il Database uni_db.sql 2.1 Introduzione e implementazione Per implementare il programma è stato necessario l'utilizzo di un database per il salvataggio dei dati relativi a ciascun individuo e di tutti gli insegnamenti. Il database è costituito da sette tabelle ed è stato salvato con il nome db_uni.sql. Come già detto la base di dati è stata implementata utilizzando MySQL mediante l'utilizzo del driver JDBC. Il driver MySQL Connector/J fornisce un accesso diretto e ottimizzato al database senza alcuna perdita di prestazioni. È il produttore stesso del database, infatti, che distribuisce il driver JDBC ed in questo modo vengono sfruttate a pieno tutte le caratteristiche del database. Vediamo ora l'implementazione del database: CREATE TABLE cdil ( nome varchar(50) NOT NULL, facolta varchar(50) NOT NULL, PRIMARY KEY (nome, facolta) ) TYPE = InnoDB DEFAULT CHARSET = UTF8; CREATE TABLE studente ( matricola numeric(6) PRIMARY KEY, password varchar(200) NOT NULL, nome varchar(50) NOT NULL, cognome varchar(50) NOT NULL, salt varchar(200) NOT NULL, cdil varchar(50) NOT NULL, facolta varchar(50) NOT NULL, FOREIGN KEY (cdil, facolta) REFERENCES cdil(nome, facolta) ON UPDATE CASCADE ON DELETE CASCADE ) TYPE = InnoDB DEFAULT CHARSET = UTF8; CREATE TABLE esame ( 4
  5. 5. nome varchar(50) NOT NULL, data date NOT NULL, cfu numeric(2) NOT NULL, firmato char(2) NOT NULL, cdil varchar(50) NOT NULL, facolta varchar(50) NOT NULL, PRIMARY KEY (nome, data), FOREIGN KEY (cdil, facolta) REFERENCES cdil(nome, facolta) ON UPDATE CASCADE ON DELETE CASCADE ) TYPE = InnoDB DEFAULT CHARSET = UTF8; CREATE TABLE sostiene ( studente numeric(6) NOT NULL, esame varchar(50) NOT NULL, data date NOT NULL, prenotato char(2), sostenuto char(2), firmato char(2), roba_da_firmare varchar(100), firma varchar(400), voto char(3), note varchar(400), verificato char(2), PRIMARY KEY (studente, esame, data), FOREIGN KEY (studente) REFERENCES studente(matricola) ON UPDATE CASCADE ON DELETE CASCADE, FOREIGN KEY (esame, data) REFERENCES esame(nome, data) ON UPDATE CASCADE ON DELETE CASCADE ) TYPE = InnoDB DEFAULT CHARSET = UTF8; CREATE TABLE professore ( codice numeric(6) PRIMARY KEY, passwd varchar(5000) NOT NULL, nomep varchar(50) NOT NULL, cognomep varchar(50) NOT NULL, saltp varchar(200) NOT NULL ) TYPE = InnoDB DEFAULT CHARSET = UTF8; CREATE TABLE insegna ( professore numeric(6) NOT NULL, esame varchar(50) NOT NULL, data date NOT NULL, PRIMARY KEY (professore, esame, data), FOREIGN KEY (professore) REFERENCES professore(codice) ON UPDATE CASCADE ON DELETE CASCADE, FOREIGN KEY (esame, data) REFERENCES esame(nome, data) ON UPDATE CASCADE ON DELETE CASCADE ) TYPE = InnoDB DEFAULT CHARSET = UTF8; CREATE TABLE commissione ( prof numeric(6) NOT NULL, exam varchar(50) NOT NULL, data date NOT NULL, PRIMARY KEY (prof, exam, data), FOREIGN KEY (prof) REFERENCES professore(codice) ON UPDATE CASCADE ON DELETE CASCADE, FOREIGN KEY (exam, data) REFERENCES esame(nome, data) ON UPDATE CASCADE ON DELETE CASCADE ) TYPE = InnoDB DEFAULT CHARSET = UTF8; CREATE TABLE verbale 5
  6. 6. ( esame varchar(50) NOT NULL, data date NOT NULL, verbale varchar(5000), titolare varchar(400), membro varchar(400), flag char(2), PRIMARY KEY (esame, data), FOREIGN KEY (esame, data) REFERENCES esame(nome, data) ON UPDATE CASCADE ON DELETE CASCADE ) TYPE = InnoDB DEFAULT CHARSET = UTF8; 6
  7. 7. 3 Il Keystore keystore_di_prova 3.1 Generazione del keystore Per realizzare il keystore da utilizzare nel progetto è stato necessario generare una coppia di chiavi da memorizzare all'interno dello stesso. Il keystore è un database che viene utilizzato per gestire le chiavi e i certificati generati. Per generare il keystore e i certificati è stato utilizzato Keytool, applicazione fornita con il JDK. Questo è il comando per generare il keystore e la relativa coppia di chiavi: Keytool -keystore path -alias superchiave -genkey dove path è il percorso dove salvare il keystore e superchiave è il nome utilizzato per firmare le chiavi dei nuovi iscritti (Studenti e Professori). Per viasualizzare il contenuto del keystore viene utilizzato il comando: Keytool -keystore path -list dove path è il percorso dove si trova il keystore è -list è l'opzione per visualizzarne il contenuto. Questo è un esempio di output per il comando: Dalla figura si può notare che il keystore contiene 8 entry. Ciascuna di esse è composta da: • alias, che nel nostro caso è l'identificativo dello studente o del professore; • data, è la data di creazione del certificato; • PrivateKeyEntry, indica che l'alias associato possiede una coppia di chiavi (pubblica/privata); • Impronta digitale certificato (MD5), che rappresenta l'hash del certificato. Inoltre va specificato che l'entry “superchiave” non rappresenta né uno studente né un professore ma il firmatario di tutti gli altri certificati. 7
  8. 8. 4 Funzionamento del software Una volta lanciato il software compare una finestra nella quale è possibile inserire le credenziali di accesso per effettuare il login. In mancanza di questi dati è possibile procedere all'iscrizione. 4.1 Form iscrizione Professore/Studente Per accedere al sistema è necessaria l'iscrizione da parte di ciascuno individuo. Tale sezione è una delle più importanti in quanto vengono registrate le credenziali di accesso nel db_uni e viene generata la coppia di chiavi associata ad ogni utente e salvata all'interno del keystore. I campi da riempire sono il nome e cognome dell'utente, la matricola/codice (corrispondente all'username) la password e, nel caso dello studente, il corso di laurea. La memorizzazione della password nella base di dati avviene seguendo questa procedura: • innanzi tutto viene creato un nuovo salt casuale da anteporre alla password; • il secondo passo è quello di applicare l'algoritmo di hash al salt concatenato alla password; • il terzo e ultimo passo è quello di anteporre lo stesso salt del punto 1 all'hash ottenuto al punto 2 e memorizzare il risultato nel database. Questa è la funzione utilizzata per generare il digest, che rappresenta la password codificata da inserire nella base di dati: public static byte[] digest(String password, byte[] salt) { MessageDigest sha = null; try { sha = MessageDigest.getInstance("SHA-1"); } catch (NoSuchAlgorithmException e) { System.out.println("Algoritmo richiesto non supportato"); } sha.update(salt); sha.update(password.getBytes()); byte[] impronta = sha.digest(); 8
  9. 9. byte[] risultato = new byte[impronta.length + salt.length]; System.arraycopy(impronta, 0, risultato, 0, impronta.length); System.arraycopy(salt, 0, risultato, impronta.length, salt.length); return risultato; } Al momento dell'iscrizione ogni individuo riceve anche una coppia di chiavi (pubblica e privata). Questa è la funzione utilizzata per la generazione della coppia: public void generateKeyPair(String matricola, String pass) { long CERT_DURATION = 10l * 365l * 24l * 60l * 60l * 1000l; // durata // del certificato String alias = matricola; // una matricola di uno studente o prof String issuer = "superchiave"; // alias della coppia di chiavi creata // con keytool // al momento della creazione del keystore. Questo // alias firma tutte le altre chiavi String password = pass; // La password della chiave privata // dell'individuo (la stessa usata per la registrazione) try { KeyPairGenerator keygen = KeyPairGenerator.getInstance("DSA"); SecureRandom secrand = new SecureRandom(); keygen.initialize(1024, secrand); KeyPair keys = keygen.generateKeyPair(); pub = keys.getPublic(); priv = keys.getPrivate(); // CERTIFICATO Date start = new Date(); // Prende la data odierna Date expiry = new Date(start.getTime() + CERT_DURATION); BigInteger serial = BigInteger.ONE; X509V1CertificateGenerator generatore = new X509V1CertificateGenerator(); X509Name dn = new X509Name("CN=" + alias); generatore.setSerialNumber(serial); generatore.setIssuerDN(new X509Name("CN=" + issuer)); generatore.setNotBefore(start); generatore.setNotAfter(expiry); generatore.setSubjectDN(dn); generatore.setPublicKey(pub); generatore.setSignatureAlgorithm("SHA1WITHDSA"); Certificate cert = generatore.generate(priv, secrand); k.setKeyEntry(alias, priv, password.toCharArray(), new Certificate[]{cert}); } catch (Exception ex) { Logger.getLogger(KeyStore.class.getName()).log(Level.WARNING, "Error while generating keypair", ex); } } Una volta generate, le chiavi vengono salvate nel keystore insieme all'alias dell'individuo. Ogni individuo, per poter firmare con la propria chiave privata, deve inserire la password fornita al momento dell'iscrizione al sistema. 9
  10. 10. 4.2 Form login Professore/Studente Per poter accedere al sistema è necessario effettuare il login. In questa form viene verificata la corrispondenza dei dati salvati nel database al momento dell'iscrizione di ciascun individuo. In particolare viene effettuata l'autenticazione della password seguendo questa procedura: • alla password inserita si antepone il salt della password memorizzata in precedenza; • si applica l'algoritmo di hash alla nuova coppia salt, password; • infine si confronta l'hash del punto 2 concatenato al salt con quello memorizzato in precedenza nel database. Se le due stringhe coincidono l'individuo viene correttamente autenticato e quindi potrà accedere al sistema altrimenti viene restituito un messaggio di errore. 10
  11. 11. 4.3 Form Menù Studente In questa sezione lo studente ottiene tutte le informazioni riguardanti il suo piano di studi. In particolare può visualizzare una tabella contenente lo storico di tutti gli esami sostenuti e da sostenere, può iscriversi a tutti gli esami ancora da sostenere e può rifiutare o firmare gli esami appena sostenuti. La sezione più interessante è quella relativa alla firma degli esami. Ogni volta che lo studente supera un esame può decidere se rifiutarlo (nel caso in cui non sia soddisfatto del voto) oppure accettarlo. Nel caso in cui decida di accettare il voto si devono raccogliere, tramite una query al database, tutte le informazioni riguardanti lo studente e l'esame. Fatto ciò la query viene firmata con la chiave privata dello studente. La coppia firma, query firmata viene poi spedita al professore per la successiva verifica. La query appena firmata non è nient'altro che un occorrenza del verbale. Questa è la funzione per generare la firma relativa ad uno studente: public String sign(String alias, String password, String toSign) { try { Signature signer = Signature.getInstance("SHA1WITHDSA"); PrivateKey priv = (PrivateKey) k.getKey(alias, password.toCharArray()); signer.initSign(priv, new SecureRandom()); signer.update(toSign.getBytes()); return new String(Base64.encode(signer.sign())); } catch (Exception ex) { Logger.getLogger(KeyStore.class.getName()).log(Level.WARNING, "Cannot sign '" + toSign + "' as " + alias, ex); } return "errore"; } 11
  12. 12. 4.4 Form Menù Professore In questa sezione il professore ottiene tutte le informazioni riguardanti gli esami da lui presenziati. In particolare può valutare gli studenti che hanno sostenuto gli esami, verificare le firme di quelli che hanno accettato le sue valutazioni per un certo esame e può accedere alla sezione per firmare i verbali. Anche qui la parte più importante è quella relativa alla verifica delle firme. Per ogni studente che firma un esame, il professore deve essere in grado di verificare la corrispondenza tra firma e individuo che ha firmato. Dalla sezione “Verifica firma studente” il professore sceglie la coppia matricola, esame sostenuto e premendo il tasto è in grado di verificare se la firma che corrisponde allo studente (con quella matricola) è valida o meno. Questo è possibile tramite la funzione verifica descritta sotto: public boolean verify(String alias, String robaFirmata, String firma) { try { Signature verifier = Signature.getInstance("SHA1WITHDSA"); verifier.initVerify(k.getCertificate(alias)); verifier.update(robaFirmata.getBytes()); return verifier.verify(Base64.decode(firma.getBytes())); } catch (Exception ex) { return false; } } 12
  13. 13. 4.5 Form Firma verbale In questa sezione il professore è in grado di firmare i verbali dei suoi corsi e di quelli in cui è in commissione. Nel primo caso è in grado di firmare solo se possiede tutte le firme degli studenti che hanno sostenuto l'esame e tutte le firme dei professori presenti in commissione. In questo caso il verbale può essere chiuso e corredato da un timestamping. Nel secondo caso invece si limita a firmare tutti i verbali degli esami in cui è inserito in commissione. 13

×