Tutorial per la firma digitale
dei sorgenti HTML
(ossìa, come firmare un sorgente HTML, in modo "trasparente" al parser)

Pagina disponibile anche in
- italiano -
(di TJL73)
Page also available in
- english -
(by Carlo Luciano Bianco)
Stránka je dostupná aj v
- slovenčine -
(preložil )
Page également disponible en
- français -
(par Rinux)

Lo scopo di questo tutorial è quello di spiegare come sia possibile firmare, con OpenPGP, una pagina web, senza che vi sia traccia di questa firma dopo il parsing del browser.

PREMESSA: In questo documento, viene utilizzato impropriamente il termine OpenPGP, come si trattasse di un software, anche se così non è: si intende, con tale termine, qualsiasi software sia aderente allo standard OpenPGP. Esempi di tali software, sono, GnuPG e PGP.

Quanto segue, è da considerarsi valido per il codice HTML statico (comprensivo di JavaScript, CSS e quant'altro venga interpretato "lato client").
[Tengo a precisare che, con il termine "DHTML", si intende un "pagina con contenuti dinamici", mentre il suo codice HTML sorgente è statico. Quanto segue è quindi applicabile anche a questo tipo di pagine.]
Eventuali sorgenti dinamici, generati da linguaggi "lato server" (come, ad esempio, ASP, CGI, PERL, PHP), sono incompatibili con la tecnica qui descritta, poiché vengono generati dinamicamente, di volta in volta, dal web server, rendendo non attuabile la firma da parte dell'autore. Per come è concepita la firma digitale, è quindi possibile, per l'autore, firmare esclusivamente del codice statico (ossìa, residente "staticamente" sul web server). Si può, eventualmente, prevedere una firma automatica del codice dinamico generato dal server, mediante uno script sul server stesso. Questo implica che la chiave, con cui tale firma viene apposta, risieda in luogo non sicuro e, quindi, che tale firma, non possa essere considerata sicura quanto una firma apposta manualmente dall'autore.

Non bisogna considerare questo metodo, come un'alternativa a SSL/TLS, visto che, ad esempio, non consente la cifratura della connessione ed è assolutamente unidirezionale "server -> client". Proprio per questo, però, dato che non deve essere implementato "lato server", risulta utilissimo tutte le volte che il web server non è sotto il controllo del web-designer e l'uso di SSL/TLS sarebbe quindi impossibile da gestire (l'esempio più comune è quello in cui l'autore di una pagina web vuole firmare una pagina personale su sistemi di hosting come questo, fornito gratuitamente da Altervista.org).
In molti casi, si rivela l'unica possibilità per autenticare una pagina HTML.




 Creazione del codice HTML firmato 

Per poter riprodurre ciò che avviene in questo documento, è necessario apporre due marcatori di chiusura e apertura commento, rispettivamente all'inizio e alla fine del codice HTML che si vuole firmare, nel seguente modo:

 -->
<HTML>
 [Testo o codice HTML da firmare]
</HTML>
 <!--

Da notare (e se non lo avete notato voi, ve lo faccio notare io), che il marcatore di chiusura commento ("-->"), è preceduto da uno spazio.

 -->
<HTML>
 [Testo o codice HTML da firmare]
</HTML>
 <!--

Questo serve ad evitare che, al momento dell'apposizione della firma digitale da parte di OpenPGP, questi vada ad aggiungere (conformemente alle specifiche OpenPGP) un "- " (trattino spazio) a quella riga, trasformandolo quindi in "- -->".
Si noti che la presenza di quel "- " non inficierà il corretto parsing, ma la sua assenza renderà il sorgente HTML più pulito.

NOTA: Se nelle vostre pagine, per qualsiasi motivo, dovesse comparire un trattino "-" come primo carattere di una riga, sarà necessario aggiungere un delimitatore di commento in prima colonna. In questo modo si eviterà che OpenPGP aggiunga un trattino-spazio, apponendo la firma in chiaro.
Il codice risultante, quindi, sarà: "<!-- -->-". Ciò non varierà il codice al parsing, ma eviterà che OpenPGP lo modifichi.

A questo punto, potete selezionare tutto il codice HTML della pagina (compreso l' "a-capo" alla fine del documento):

 -->
<HTML>
 [Testo o codice HTML da firmare]
</HTML>
 <!--
 


e darlo "in pasto" a OpenPGP per la firma in chiaro ("Clear Text Signature").

NOTA: Se utilizzate tool come PGP o GPGshell, ricordatevi di disattivare il "word wrap" (a capo automatico), altrimenti rischiereste di modificare il vostro sorgente HTML, rendendolo non più interpretabile da parte del browser.


Dopo la firma, potete incollare nuovamente il codice firmato in chiaro ("Clearsigned Text") nel vostro editor HTML preferito:

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

 -->
<HTML>
 [Testo o codice HTML firmato]
</HTML>
 <!--

-----BEGIN PGP SIGNATURE-----
Version: OpenPGP
Comment: Clearsigned HTML Source Code

xX0XXXXXxXxxXxxxXxX0xXXXXx0XXX0XXxxXxxXxxx0XXXXXxX+X0XxX0XXxXxxx
X0XXXxXxxxXXXxx0XXxxxxX=
=xXxX
-----END PGP SIGNATURE-----

e aggiungere due marcatori di commento all'inizio e alla fine del sorgente:

 <!--

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

 -->
<HTML>
 [Testo o codice HTML firmato]
</HTML>
 <!--

-----BEGIN PGP SIGNATURE-----
Version: OpenPGP
Comment: Clearsigned HTML Source Code

xX0XXXXXxXxxXxxxXxX0xXXXXx0XXX0XXxxXxxXxxx0XXXXXxX+X0XxX0XXxXxxx
X0XXXxXxxxXXXxx0XXxxxxX=
=xXxX
-----END PGP SIGNATURE-----

 -->

A questo punto, avremo il sorgente HTML, così composto:

 <!--

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

 -->
<HTML>
 [Testo o codice HTML firmato]
</HTML>
 <!--

-----BEGIN PGP SIGNATURE-----
Version: OpenPGP
Comment: Clearsigned HTML Source Code

xX0XXXXXxXxxXxxxXxX0xXXXXx0XXX0XXxxXxxXxxx0XXXXXxX+X0XxX0XXxXxxx
X0XXXxXxxxXXXxx0XXxxxxX=
=xXxX
-----END PGP SIGNATURE-----

 -->


Il testo evidenziato in verde verrà considerato "commento" da parte del browser e, quindi, non verrà analizzato dal parser, mentre la parte con sfondo giallo sarà il nostro codice HTML e verrà interpretato come se la firma digitale apposta da OpenPGP non esistesse.

Su questa pagina, si può vedere il risultato di quel codice HTML (ovviamente questo è solo un banale esempio, quindi la firma non sarà verificabile. Per vedere un esempio reale di una pagina firmata con questa tecnica, si può fare riferimento alla mia pagina delle X-Face o a quella delle mie chiavi OpenPGP).

NOTA: Nel caso in cui la pagina dovesse essere aggiornata, bisognerà firmare nuovamente il sorgente. In caso contrario, la firma non sarà più verificata.


Ovviamente, non essendo visibile da browser, in alcun modo, la presenza della firma digitale, sarebbe bene aggiungere, al fondo della pagina, la dicitura che ne segnala l'esistenza e che rimanda al tutorial in cui si spiega di cosa si tratta.
Ho creato un logo che può essere liberamente utilizzato per segnalare la presenza di una firma digitale OpenPGP:   OpenPGP Digitally Signed HTML
Tale logo è disponibile in due formati grafici e andrebbe posto al fondo di ogni pagina su cui è stata apposta una firma digitale OpenPGP.
Se, poi, vorrete utilizzare questa tecnica di autenticazione nelle vostre pagine HTML, vi chiedo di riportare questo logo, rispettando queste semplici regole. Per me, sarà sicuramente un onore.




 Verifica del codice HTML firmato 

Procediamo ora alla verifica della pagina firmata mediante OpenPGP.

La procedura di verifica del codice è molto semplice.
Basterà prendere il sorgente HTML della pagina in questione (ogni browser consente di effettuare questa operazione; in genere è disponibile una voce di menu appropriata, premendo il tasto destro sulla pagina) e verificarlo con OpenPGP.
Se la firma digitale apposta al codice sarà verificata, vuol dire che la pagina non è stata modificata; se non sarà verificata, significherà che la pagina è stata contraffatta (o, comunque, non corrisponde più al sorgente che era stato firmato).

Nota per gli utenti Gecko

Mozilla v1.7.8 e FireFox v2.0.0.14 (e, credo, tutti i browser che si affidano al parser Gecko) non consentono di verificare correttamente i sorgenti HTML firmati con questa tecnica, poiché, quando il codice visualizzato dal "Visualizzatore Sorgenti" interno al browser, viene copiato all'interno della clipboard, questi aggiunge arbitrariamente alcune linee vuote. Queste modifiche, ovviamente, pur lasciando valido, al parsing, il codice HTML, invalidano la firma digitale OpenPGP. Altri browser, come Opera e Internet Explorer, invece, consentono di copiare correttamente nella clipboard il sorgente originale, facendo sì che la firma digitale apposta sia verificata con successo.
A proposito di tale bug, è già presente un tracker su Bugzilla. Lì, potete seguire l'andamento di questa segnalazione e, eventualmente, dare voti al bug, per aumentarne la "priorità".

Per ovviare a questo inconveniente, gli utenti di Gecko, possono salvare la pagina in locale, dal "Visualizzatore Sorgenti" o dal browser, mediante la combinazione tasti Ctrl+S o scegliendo la voce appropriata dal menu "File".
Salvare il codice HTML dal "Visualizzatore Sorgenti" non dovrebbe comportare alcun problema. Se, invece, si sceglie di effettuare questa operazione dal browser, nella finestra di salvataggio si deve avere l'accortezza di scegliere "Pagina web, solo HTML" e non "Pagina web, completa", poiché tale formato andrebbe a modificare i collegamenti esterni alla pagina, per collegarli agli oggetti (es. "immagini") salvati in locale.
Dopo aver salvato localmente il sorgente HTML, sarà possibile visualizzarlo con qualsiasi editor e verificarne la firma digitale con OpenPGP.
Non so come si comportino browser differenti da quelli da me testati (Opera, Mozilla, FireFox e Internet Explorer).
Segnalazioni in merito sono, ovviamente, ben accette.




 Creazione di una porzione firmata del documento 

È possibile, ovviamente, estendere il discorso fatto precedentemente anche a sole porzioni della pagina.

Può capitare che una pagina, che contiene informazioni importanti da verificare, debba essere tradotta in più lingue. Se tali informazioni non hanno la necessità di essere tradotte (come, ad esempio, i checksum di alcune distribuzioni), basterà firmare solo queste porzioni, lasciando la possibilità di tradurre tutto il resto della pagina, senza che questo vada ad invalidare la firma apposta dall'autore originale.

Questo potrebbe essere un esempio di codice sorgente che esprime questo concetto:

<HTML>
<HEAD>
<TITLE>Esempio</TITLE>
</HEAD>
<BODY>
[Testo o codice HTML da tradurre o comunque modificabile]
 <!--

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

 -->
<TABLE>
 [Testo o codice HTML firmato]
</TABLE>
 <!--

-----BEGIN PGP SIGNATURE-----
Version: OpenPGP
Comment: Clearsigned HTML Source Code

xX0XXXXXxXxxXxxxXxX0xXXXXx0XXX0XXxxXxxXxxx0XXXXXxX+X0XxX0XXxXxxx
X0XXXxXxxxXXXxx0XXxxxxX=
=xXxX
-----END PGP SIGNATURE-----

 -->
[Altro testo o codice HTML da tradurre o comunque modificabile]
</BODY>
</HTML>


In tale esempio, le parti evidenziate in rosso saranno quelle che potranno essere tradotte o modificate, senza che questo vada a invalidare la firma.

Le parti in verde saranno quelle che comporranno la firma digitale (e che verranno ignorate dal parser). Non possono, quindi, essere modificate.

Le parti gialle saranno quelle su cui l'autore originale ha apposto la propria firma digitale. Anche queste, come quelle verdi, non dovranno essere modificate, altrimenti la firma risulterà non valida.

Un esempio concreto di questa estensione è disponibile su questa pagina. Se le firme presenti in quella pagina fossero di Werner Koch, invece che mie, si potrebbe avere la garanzia, senza ombra di dubbio, che quei checksum siano validi, senza dover andare a cercare in rete ulteriori informazioni a riguardo (come, invece, consigliato sulla pagina originale). Qui le due versioni in italiano, della stessa pagina: originale e firmata.


ATTENZIONE: Faccio presente che le due pagine da me firmate, presenti sul mio sito, non hanno alcuna validità, se non puramente esplicativa.


Ovviamente, il documento può contenere porzioni firmate da autori differenti, consentendo, ad esempio, la firma dell'autore (o autori) originale su porzioni di testo o codice, e la firma di tutto il sorgente della pagina da parte dell'autore della traduzione. Questo, consente di poter nidificare le firme, lasciandole tutte valide, ciascuna al proprio livello, come nel seguente schema d'esempio:


 ,----------[ Firma del traduttore "T" ]-----------.
 |                                                 | 
 |  Porzione di testo tradotta da "T"              |
 |                                                 |
 |                                                 |
 |  ,---------[ Firma dell'autore "A" ]---------.  |
 |  |                                           |  |
 |  |  Testo scritto e firmato dall'autore "A"  |  |
 |  |                                           |  |
 |  `-------------------------------------------'  |
 |                                                 |
 |  Altra porzione di testo tradotta da "T"        |
 |                                                 |
 |                                                 |
 |  ,---------[ Firma dell'autore "B" ]---------.  |
 |  |                                           |  |
 |  |  Testo scritto e firmato dall'autore "B"  |  |
 |  |                                           |  |
 |  `-------------------------------------------'  |
 |                                                 |
 |  ,---------[ Firma dell'autore "C" ]---------.  |
 |  |                                           |  |
 |  |  Testo scritto e firmato dall'autore "C"  |  |
 |  |                                           |  |
 |  `-------------------------------------------'  |
 |                                                 |
 |  ,------[ Altra firma dell'autore "B" ]------.  |
 |  |                                           |  |
 |  |  Testo scritto e firmato dall'autore "B"  |  |
 |  |                                           |  |
 |  `-------------------------------------------'  |
 |                                                 |
 |  Altra porzione di testo tradotta da "T"        |
 |                                                 |
 |                                                 |
 |  ,------[ Altra firma dell'autore "A" ]------.  |
 |  |                                           |  |
 |  |  Testo scritto e firmato dall'autore "A"  |  |
 |  |                                           |  |
 |  `-------------------------------------------'  |
 |                                                 |
 |  Altra porzione di testo tradotta da "T"        |
 |                                                 |
 `-------------------------------------------------'


Nello schema qui a sinistra, è possibile notare che, modificando una delle porzioni contenute nei riquadri piccoli, vengono a mancare sia la verifica della firma del relativo autore che quella del traduttore (a meno che la modifica sia stata effettuata prima della firma del traduttore).

Modificando, invece, una delle porzioni esterne ai riquadri piccoli, solo la firma del traduttore non sarà verificata, lasciando invece autentiche le firme dei relativi autori.

Nel caso, invece, l'autore originale volesse certificare anche la traduzione, potrebbe firmare la pagina dopo che la firma del traduttore è stata apposta, come nello schema sottostante:


 ,-----------[ Seconda firma dell'autore "A" ]-----------.
 |                                                       |
 |  ,----------[ Firma del traduttore "T" ]-----------.  |
 |  |                                                 |  | 
 |  |  Porzione di testo tradotta da "T"              |  |
 |  |                                                 |  |
 |  |                                                 |  |
 |  |  ,---------[ Firma dell'autore "A" ]---------.  |  |
 |  |  |                                           |  |  |
 |  |  |  Testo scritto e firmato dall'autore "A"  |  |  |
 |  |  |                                           |  |  |
 |  |  `-------------------------------------------'  |  |
 |  |                                                 |  |
 |  |  Altra porzione di testo tradotta da "T"        |  |
 |  |                                                 |  |
 |  `-------------------------------------------------'  |
 |                                                       |
 `-------------------------------------------------------'


Qui, l'autore "A", ha creato un testo (o un codice HTML) e l'ha firmato.

Successivamente, il traduttore "T" ha tradotto le porzioni di testo nella propria lingua, firmandole con la propria chiave.

In un terzo tempo, l'autore originale "A" ha firmato nuovamente, con la propria chiave, tutta la pagina, certificando la traduzione effettuata da "T" (senza apporre alcuna ulteriore modifica al codice HTML).




 Certificare anche gli oggetti correlati (per i più paranoici) 

Può capitare ci sia l'esigenza di certificare anche "gli oggetti" contenuti nella pagina. Mi riferisco, più che altro, alle immagini.
In tal caso, si può procedere al calcolo del checksum di tali oggetti (mediante MD5 o SHA1) e all'annotazione di tali checksum all'interno della parte di commento firmata.
Questo, a differenza della singola firma ("Detached ASCII-armored Signature") dei vari oggetti, dà la possibilità di ridurre notevolmente lo spazio richiesto, pur mantenendo di uguale valore la certificazione. D'altronde, la firma digitale altro non è che la certificazione di un sunto dell'oggetto; e noi proprio questo andremo a fare.
Ovviamente, non tutte le immagini avranno la necessità di essere certificate... solo quelle che rivestono reale importanza ai fini della verifica verranno autenticate. Questo significa che, ad esempio, i vari pallini, gif animate decorative ed eventuali sfondi (sempre che non ricoprano un ruolo importante, all'interno della pagina) non avranno la necessità di essere certificate mediante il calcolo del checksum.

Procediamo con un esempio pratico di questa tecnica.

Questo è il codice HTML che andremo a firmare:

 -->

<HTML>
<HEAD>
<TITLE>
Esempio di autenticazione delle immagini</TITLE>
</HEAD>
<BODY BACKGROUND="
Sfondo.gif">

<DIV>
 [Testo o codice HTML firmato]
 
 <IMG SRC="Immagine1.jpg">
 <IMG SRC="Immagine2.gif">
 
 <IMG SRC="Cornicetta.gif">
 
 <IMG SRC="Immagine3.jpg">
 <IMG SRC="Immagine4.png">
 
 [Testo o codice HTML firmato]
</DIV>

</BODY>
</HTML>

 <!--

Elenco checksum delle immagini:

Nome file     | Dimensioni | Checksum MD5
--------------+------------+------------------------------------
Immagine1.jpg | 46338 byte | E2EE9822 BFF5407D 696B573E FB2989C0 
Immagine2.gif | 17379 byte | F1AD8852 6150B054 4DF46226 2B7D6BD4
Immagine3.jpg | 40762 byte | 8A4F262F E336F854 077714E7 ABF3C911
Immagine4.png | 18065 byte | F06A61F2 6808B01A B9EEF949 F1577264


In questo esempio, ho marcato in modo differente il codice HTML, colorando:
in  blu  i tag,
in  verde  i commenti delimitati correttamente,
in  nero  il testo visualizzato dal parser,
in  arancione  i file che vogliamo certificare,
in  viola  quelli di cui non ci interessa,
in  grigio  ciò che sarebbe un commento, ma non è ancora delimitato correttamente.

Ciò consente di visualizzare "a colpo d'occhio", le varie parti del codice che stiamo analizzando.

Ciò che segue, invece, è il codice HTML dopo l'apposizione della firma digitale:

 <!--

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

 -->

<HTML>
<HEAD>
<TITLE>
Esempio di autenticazione delle immagini</TITLE>
</HEAD>
<BODY BACKGROUND="
Sfondo.gif">

<DIV>
 [Testo o codice HTML firmato]
 
 <IMG SRC="Immagine1.jpg">
 <IMG SRC="Immagine2.gif">
 
 <IMG SRC="Cornicetta.gif">
 
 <IMG SRC="Immagine3.jpg">
 <IMG SRC="Immagine4.png">
 
 [Testo o codice HTML firmato]
</DIV>

</BODY>
</HTML>

 <!--

Elenco checksum delle immagini:

Nome file     | Dimensioni | Checksum MD5
--------------+------------+------------------------------------
Immagine1.jpg | 46338 byte | E2EE9822 BFF5407D 696B573E FB2989C0 
Immagine2.gif | 17379 byte | F1AD8852 6150B054 4DF46226 2B7D6BD4
Immagine3.jpg | 40762 byte | 8A4F262F E336F854 077714E7 ABF3C911
Immagine4.png | 18065 byte | F06A61F2 6808B01A B9EEF949 F1577264

-----BEGIN PGP SIGNATURE-----
Version: OpenPGP
Comment: Clearsigned HTML Source Code

xX0XXXXXxXxxXxxxXxX0xXXXXx0XXX0XXxxXxxXxxx0XXXXXxX+X0XxX0XXxXxxx
X0XXXxXxxxXXXxx0XXxxxxX=
=xXxX
-----END PGP SIGNATURE-----

 -->


La struttura della tabella (o l'elenco dei file certificati, se non si vuole utilizzare una forma tabellare), è puramente esplicativa, ma, per avere un valore "minimo", dovrà almeno riportare il nome dell'oggetto (comprensivo di percorso ed estensione, in modo da identificarne il tipo), la sua dimensione in byte e il checksum (specificando l'algoritmo di hash utilizzato per calcolarlo).

Questo implica che, se anche uno solo dei valori di: tipo, dimensione o checksum dovesse essere modificato (per giustificare un tentativo di sostituzione o modifica di un'immagine), la firma della pagina non sarebbe più verificata.

Quindi, se la porzione di codice HTML firmata, sorgente della pagina, dovesse risultare autentica ad una verifica della firma, avremmo la garanzia che quei checksum, relativi alle immagini (o altri oggetti) presenti, siano validi.
In questo modo, ci basterà calcolare il checksum dell'immagine di cui siamo interessati a verificare l'autenticità, incrociarlo con le sue dimensioni e tipo, per avere garanzia che tale immagine non sia stata contraffatta.

Questo, parlando di "oggetti", può essere applicato, oltre che alle immagini, anche ai CSS e ad altri file collegati, quali, ad esempio, animazioni flash, file di testo o altro.

È bene tener conto che tali oggetti dovranno essere sotto il controllo dell'autore della firma, poiché, se risiedessero fuori dal suo controllo, una loro eventuale modifica, da parte del reale proprietario, invaliderebbe il confronto dei checksum.

Per quanto riguarda, invece, eventuali archivi compressi o file eseguibili, scaricabili da quella pagina, è sempre buona abitudine segnalare il checksum in modo tradizionale, cosicché chi dovesse scaricarli potrebbe verificarne la validità con la tecnica classica.
Altro buon metodo è quello di associare una firma separata ("Detached Signature") al file.


Metodo alternativo

Alternativamente al metodo sopra descritto, si può far in modo di apporre un checksum direttamente nel link all'oggetto. In questo modo, ogni checksum sarà associato direttamente all'oggetto stesso.

Di seguito, un esempio di questa tecnica:

 <IMG SRC="Immagine1.jpg" CHKSUM="46338;MD5;E2EE9822BFF5407D696B573EFB2989C0">
 <IMG SRC="Immagine2.gif" CHKSUM="17379;MD5;F1AD88526150B0544DF462262B7D6BD4">
 
 <IMG SRC="Cornicetta.gif">
 
 <IMG SRC="Immagine3.jpg" CHKSUM="40762;SHA1;C9E92C38CB325186E749A0FD5C27678827724E5F"> 
 <IMG SRC="Immagine4.png" CHKSUM="18065;MD5;F06A61F26808B01AB9EEF949F1577264">

Nella prima linea dell'esempio (per puro chiarimento), sono stati evidenziati: in  giallo  il tag, in  rosso  la dimensione dell'oggetto in byte, in  verde  l'algoritmo di hash utilizzato, in  azzurro  il checksum dell'oggetto, calcolato con tale algoritmo.

Ovviamente, tale tecnica introduce un tag ("CHKSUM") non valido per il parser. Questo significa che nessun browser interpreterà tale tag, restando quindi invisibile. Per contro, tale sorgente HTML potrebbe non essere più valido da parte del "W3C Validator".

In questo modo, però, sarà possibile, da parte del browser (nativamente o tramite un plugin, quale ad esempio Enigmail), verificare direttamente la validità di un oggetto, mediante il calcolo del suo checksum.

Quindi, se la pagina sarà validata e questi tag saranno verificati, avremo ottenuto ciò che volevamo.




 Certificare porzioni di codice JavaScript 

È altresì possibile firmare porzioni di codice JavaScript (essendo, come l'HTML, un codice da eseguire "lato client"), che questo sia "embedded" (inserito all'interno del codice HTML) o "included" (contenuto in un file .js esterno).
Per ciò che riguarda il codice "embedded", la nostra pagina HTML ingloba anche le porzioni JavaScript, quindi, esse saranno già certificate dalla firma apposta alla nostra pagina.

Per quanto riguarda, invece, le parti di codice contenute nei file .js esterni, sarà opportuno apporre le firme direttamente al codice JavaScript ivi contenuto.
Al fine di ottenere una firma anche di questa porzione di codice esterno, sarà necessario creare delle parti "commentate" in modo da poter apporre la firma, come abbiamo effettuato con il codice HTML.

Nell'esempio che segue, vediamo come effettuare le firme del codice JavaScript:

 */

var List = new Array (
"Elemento 1","Elemento 2","Elemento 3","Elemento 4","Elemento 5"
)

 /*

Come avrete potuto notare, ci sono una chiusura di commento (" */ ") prima del codice JavaScript e un'apertura di commento (" /* ") al termine del codice stesso.
A questo punto, basterà selezionare il contenuto del file .js cui vogliamo apporre la certificazione, firmarlo e aggiungere i due delimitatori di commento prima e dopo la porzione firmata, come segue:

 /*

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

 */

var List = new Array (
"Elemento 1","Elemento 2","Elemento 3","Elemento 4","Elemento 5"
)

 /*

-----BEGIN PGP SIGNATURE-----
Version: OpenPGP
Comment: Clearsigned JavaScript Source Code

xX0XXXXXxXxxXxxxXxX0xXXXXx0XXX0XXxxXxxXxxx0XXXXXxX+X0XxX0XXxXxxx
X0XXXxXxxxXXXxx0XXxxxxX=
=xXxX
-----END PGP SIGNATURE-----

 */

La parte in verde, come nel caso del codice HTML, verrà ignorata dal'interprete JavaScript, mentre la parte in giallo verrà presa in considerazione:

 /*

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

 */


var List = new Array (
"Elemento 1","Elemento 2","Elemento 3","Elemento 4","Elemento 5"
)


 /*

-----BEGIN PGP SIGNATURE-----
Version: OpenPGP
Comment: Clearsigned JavaScript Source Code

xX0XXXXXxXxxXxxxXxX0xXXXXx0XXX0XXxxXxxXxxx0XXXXXxX+X0XxX0XXxXxxx
X0XXXxXxxxXXXxx0XXxxxxX=
=xXxX
-----END PGP SIGNATURE-----

 */

Anche in questo caso, potremo aggiungere i checksum degli oggetti correlati al codice JavaScript, come nell'esempio che segue:

 /*

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

 */


var List = new Array ( // Checksum: "Algo;Size;Digest"
"Elemento 1",          // Checksum: "SHA1;1234;E1EC203D81C37D201D18BB8D9AEE50E37DB6E21A"
"Elemento 2",          // Checksum: "SHA1;5678;BB8D9AEE50E37DBE1EC203D8E21A01D181C37D26"
"Elemento 3",          // Checksum: "SHA1;9012;C203D8137D26BB8D9AEE50E37DBCE1EE21A01D18"
"Elemento 4",          // Checksum: "SHA1;3456;6E21A01D18BB8EE50E37DB1EC203D81C37D2D9AE"
"Elemento 5"           // Checksum: "SHA1;7890;1A01D18BB8E1ECD26E2D9AEE50E37DB203D81C37"
)


 /*

-----BEGIN PGP SIGNATURE-----
Version: OpenPGP
Comment: Clearsigned JavaScript Source Code

xX0XXXXXxXxxXxxxXxX0xXXXXx0XXX0XXxxXxxXxxx0XXXXXxX+X0XxX0XXxXxxx
X0XXXxXxxxXXXxx0XXxxxxX=
=xXxX
-----END PGP SIGNATURE-----

 */

Infatti, tutto ciò che compare dopo il simbolo di linea commentata (" // "), verrà ignorato dall'interprete JavaScript e verrà utilizzato al solo fine di certificazione degli oggetti correlati (alla stessa stregua di ciò che già avviene nel caso dell'HTML).

Per verificare il codice JavaScript firmato, quindi, basterà aprire il file .js e verificarne la certificazione.

Ultima modifica: 


Quanto contenuto in questa pagina è da considerarsi di libero utilizzo e diffusione,
secondo le regole descritte nella Creative Commons Public License v3.0, pur rimanendo di proprietà esclusiva di TJL73.

Se riportate anche solo parte di questo tutorial, avete l'obbligo di citare la fonte, nei vostri documenti.
Spero possa essere presto disponibile una traduzione di questa pagina in altre lingue.
Sono, ovviamente, ben accetti commenti, suggerimenti e segnalazioni d'errore.

Ringraziamenti a Theoretical per aver pressantemente richiesto ed ottenuto questa pagina e a Carlo Luciano Bianco,
Rinux, Lapo Luchini, Stefano Winzozz, Martin Lukáč e Vincenzo Reale per aver pazientemente testato questa follìa.


Invalid 3WC HMTL code Invalid 3WC CCS code Made with Notepad 100% recycled bytes Best viewed by Any Browser Creative Commons Public License v3.0 "HD ready" Web Site "USB 3.0 compliant" Web Site NO Facebook, pls!