Tutoriel pour la signature numérique
de sources  HTML
(c-à-d, comment signer une page source HTML, de manière "transparente" au parseur)

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)

    Disclaimer    

Le but de ce tutoriel est d'expliquer comment il est possible de signer une page Web en OpenPGP, en ne laissant  aucune trace de la signature après le parsing du browser. 

NOTE: Dans ce document, le terme OpenPGP est utilisé comme s'il s'agissait d'un logiciel, bien que ne le soit pas: avec ce terme nous entendons n'importe quel logiciel  conforme au standard OpenPGP. Des exemples de tels logiciels sont GnuPG et PGP.

Les informations suivantes sont valides pour le code HTML statique (inclus  JavaScript, CSS et tout autre source qui soit interprété du "côté client").
[Je tiens à préciser que avec le terme "DHTML" on entend une "page avec du contenu dynamique", bien que le code HTML source soit statique. Ce tutoriel est donc valable pour ce type de page également.]
Des éventuels sources dynamiques, générés du côté serveur (par exemple, ASP, CGI, PERL, PHP), sont incompatibles avec la technique décrite ci-dessous car ils sont générés dynamiquement à chaque fois par le serveur web, ce qui rend la signature des pages impossible. Étant donnée la manière dont la signature numérique d'une page est effectuée, il n'est donc possible de signer que du code statique (c-à-d, qui est présent "statiquement" sur le serveur  web). Il est par contre possible de prévoir une signature automatique du code généré par le serveur, en utilisant un script du côté serveur. Cela implique que la clé utilisée pour la signature soit enregistrée dans un emplacement non sécurisé et donc que telle signature ne puisse pas être considérée aussi sûre qu'une signature manuelle de l'auteur.

Il ne faut pas considérer cette méthode comme une alternative à SSL/TLS car, entre autre, ne permet pas de crypter la connexion, et elle est unidirectionnelle "serveur -> client". Par contre, étant donné que cette méthode n'est pas implantée par le côté serveur, elle dévient très utile lorsque le serveur web n'est pas sous le contrôle  du "web-désigner". Dans ce cas l'utilisation de SSL/TLS serait donc impossible (par exemple, lorsque  l'auteur d'une page web veut signer une page personnelle hébergée par un tiers tel que Altervista.org).
Dans un grand nombre de cas, cette technique est la seule possibilité pour authentifier une page HTML.




  Création du code HTML signé 

Pour être en mesure de reproduire le comportement de ce document, il est nécessaire d'insérer des balises d'ouverture et fermeture d'un commentaire, en début et fin respectivement du code HTML à signer, de la manière suivante:

 -->
<HTML>
 [Texte ou code HTML à signer]
</HTML>
 <!--

Remarquez que la balise de fermeture du commentaire ("-->"), est précédé d'un espace.

 -->
<HTML>
 [
Texte ou code HTML à signer]
</HTML>
 <!--

Ceci sert à éviter que au moment de la signature par OpenPGP, ce dernier ajoute (conformément aux spécifications OpenPGP) la chaîne de caractères "- " (tiret espace) à cette ligne, la transformant donc en "- -->".
Note: la présence de "- " n'influence pas le parsing, mais son absence rendra le source HTML plus propre.

N.B.: Si dans vos pages, pour n'importe quelle raison, devait apparaître un tiret  "-" comme premier caractère d'une ligne, il sera nécessaire d'ajouter une balise de commentaire en première colonne. De cette manière, on évitera que OpenPGP ajoute un tiret-espace en introduisant la signature en clair.
Le code résultant sera donc  "<!-- -->-". Cela ne modifiera le code au parsing, mais évitera que OpenPGP le modifie.

Maintenant, vous pouvez sélectionner tout le code HTML de la page (y compris le caractère de "retour à la ligne" en fin du document):

 -->
<HTML>
 [Texte ou code HTML à signer]
</HTML>
 <!--
 


et le faire traiter par  OpenPGP pour la signature en clair ("Clear Text Signature").

N.B.: Si vous utilisez des outils tels que PGP ou GPGshell, n'oubliez pas de désactiver le "word wrap", faute de quoi vous risquez de modifier votre source HTML et de le rendre non interpretable par le browser.

Après signature, vous pouvez coller à nouveau le code signé en clair ("Clearsigned Text") dans votre éditeur HTML préféré:

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

 -->
<HTML>
 [
Texte ou code HTML à signer]
</HTML>
 <!--

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

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

et ajouter deux balises de commentaire en début et fin du code source:

 <!--

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

 -->
<HTML>
 [
Texte ou code HTML à signer]
</HTML>
 <!--

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

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

 -->

Si vous avez suivi toutes les étapes présentées jusqu'à ici, votre code HTML devrait être composé comme suit:

 <!--

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

 -->
<HTML>
 [Texte ou code HTML à signer]
</HTML>
 <!--

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

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

 -->


Le texte en vert verra considéré par le browser en tant que commentaire, et donc, ne sera pas "parsé". Le texte en jaune correspond à nôtre code HTML, et sera interprété par le parseur comme si la signature insérée par OpenPGP n'existait pas.

Cette page montre le résultat final pour ce code HTML (bien évidemment ceci est seulement un exemple trivial, et donc, la signature ne sera pas vérifiable. Un exemple réel de page signée avec cette technique, est ma page des X-Face ou celle de mes clés OpenPGP).

N.B.: Dans le cas que la page nécessite une mise à jour, le nouveau code source doit être signé à nouveau. En cas contraire, la signature ne serait plus valide.


Bien évidemment, n'étant la signature numérique pas visible par le browser, il serait opportun de signaler sa présence en bas de la page à travers un lien qui renvoie vers un tutoriel expliquant sa signification.

A ce propos, j'ai crée un logo qui peut être librement utilisé pour signaler la présence d'une signature numérique OpenPGP:   
OpenPGP Digitally Signed HTML
Ce logo est disponible en deux formats graphiques et pourrait être ajouté au fond de chaque page dans laquelle une signature numérique OpenPGP est présente.
Si vous souhaitez utiliser cette technique pour authentifier vos pages HTML, merci d'utiliser ce logo et de respecter ces quelques règles. Ceci sera un très grand honneur pour moi.




 Vérification du code HTML signé

Maintenant nous allons voir comment une page signée via OpenPGP est vérifiée.

La procédure de vérification du code est très simple.
Il suffit de prendre le code source HTML de la page en question (tout browser permet d'effectuer cette opération; en général, une option du menu appropriée est disponible en faisant un clic droit sur la page) et de le vérifier via OpenPGP.
Si la signature présente est vérifiée, cela signifiera que la page n'a pas été modifiée. Dans le cas contraire, cela signifiera que la page a été contrefaite (ou, en tout cas, ne correspond plus au code source qui a été signé).



Note pour les utilisateurs Gecko



Mozilla v1.7.8 et FireFox v2.0.0.14 (et je pense tous les autres browsers s'appuyant sur Gecko) ne permettent pas de vérifier correctement les sources HTML signées avec cette technique car, lorsque le code affiché par la fonction fournie pas le browser même (touche droite -> "Code source de la page") est copié dans le presse-papier,  ce dernier ajoute arbitrairement des lignes vides au code.  Ces modifications, bien qu'elles soient  inoffensives pour le parsing, elles rendent la signature numérique OpenPGP non valide. D'autres browsers, tels que Opera et Internet Explorer, permettent par contre de copier correctement le code dans le presse-papier sans l'altérer. Un tracker su Bugzilla concernant ce bug existe. Vous y trouverez des informations concernant la signalisation de ce bug et son suivi. Vous pouvez également noter le bug pour augmenter sa "priorité" dans le but de le voir un jour résolu.



Pour pallier cet inconvénient, les utilisateurs Gecko peuvent sauvegarder la page HTML localement  à l'aide de la combinaison des touches Ctrl+S, ou bien au en choisissant l'option approprié du menu "File".
La sauvegarde du code HTML à partir de l'afficheur des sources ne devrait poser aucun problème. Si par contre on choisit d'effectuer cette opération à partir de la DialogBox de sauvegarde du browser, il est nécessaire de choisir  "Page web, HTML uniquement" et non pas  "Page web complète", car tel format aurait comme effet la modification des liens externes à la page (par ex. les images) pour les lier enfin à des copies locales.
Après avoir sauvegardé localement les sources  HTML, il sera possible de les afficher avec n'importe quel éditeur et d'en vérifier la signature  avec OpenPGP.
J'ignore la manière dont les browsers, autres que ceux que j'ai pu tester (Opera, Mozilla, FireFox et Internet Explorer) se comportent. Toute information à tel propos est bien évidemment la bienvenue.




Création d'une partie de document signée

Il est bien évidemment possible d'éteindre le discours précédent à des portions réduites à l'intérieur d'une page.

Ça peut arriver qu'une page, contenant les informations à vérifier, nécessite d'être traduite en plusieurs langues. Lorsque telles informations ne nécessitent pas d'une traduction (par ex. le checksum de certaines distributions), il suffira de signer seulement les portions du document les contenant. Cela permettra de traduire le reste de la page sans invalider la signature effectuée par l'auteur du document original.

Ceci pourrait être un exemple de code source présentant cette particularité:

<HTML>
<HEAD>
<TITLE>Exemple</TITLE>
</HEAD>
<BODY>
[Texte ou code HTML à traduire ou modifiable]
 <!--

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

 -->
<TABLE>
 [Texte ou code HTML signé]
</TABLE>
 <!--

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

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

 -->
[Encore du texte ou code HTML à traduire ou modifiable]
</BODY>
</HTML>


Dans cet exemple, les parties mises en évidence en rouge peuvent être traduites ou modifiées sans  invalider la signature.

Les parties en vert correspondent à la signature (et sont ignorées par le parseur). Elle ne peuvent donc pas être modifiées.

La partie en jaune est celle qui a été signé par l'auteur, et pour cela, elle ne doit pas être modifiée, autrement la signature ne sera pas valide.

Un exemple concret de cet usage est disponible à cette adresse. Si les signatures présentes dans cette page étaient de Werner Koch, et non pas les miennes, on aurait eu la garantie de la validité de ces checksums, sans besoin de chercher ultérieures informations (comme conseillé dans la page originale).


ATTENTION: Veuillez remarquer que les deux pages signées par moi et présentes sur mon site n'ont aucune validité et sont données à titre d'information.


Évidemment, un document peut contenir des portions signées pas des auteurs différents. Cela permet par exemple une première signature de l'auteur du document original sur une partie de texte ou code, et une deuxième signature du document entier par l'auteur de la traduction. Cela permet donc d'imbriquer différentes signatures, chacune étant valide à son propre niveau. Voici un exemple :


 ,----------[ Signature traducteur "T" ]-----------.
 |                                                 | 
 |  Portion de texte traduite par "T"              |
 |                                                 |
 |                                                 |
 |  ,---------[ Signature auteur "A" ]----------.  |
 |  |                                           |  |
 |  |  Texte écrit et signé par l'auteur "A"    |  |
 |  |                                           |  |
 |  `-------------------------------------------'  |
 |                                                 |
 |  Encore une portion traduite par "T"            |
 |                                                 |
 |                                                 |
 |  ,---------[ Signature auteur "B" ]----------.  |
 |  |                                           |  |
 |  |  
Texte écrit et signé par l'auteur "B"    |  |
 |  |                                           |  |
 |  `-------------------------------------------'  |
 |                                                 |
 |  ,---------[ 
Signature auteur "C" ]----------.  |
 |  |                                           |  |
 |  |  
Texte écrit et signé par l'auteur "C"    |  |
 |  |                                           |  |
 |  `-------------------------------------------'  |
 |                                                 |
 |  ,------[ Autre
signature auteur "B" ]-------.  |
 |  |                                           |  |
 |  |  
Texte écrit et signé par l'auteur "B"    |  |
 |  |                                           |  |
 |  `-------------------------------------------'  |
 |                                                 |
 |  
Encore une portion traduite par "T"            |
 |                                                 |
 |                                                 |
 |  ,------[ 
Autre signature auteur "A" ]-------.  |
 |  |                                           |  |
 |  |  
Texte écrit et signé par l'auteur "A"    |  |
 |  |                                           |  |
 |  `-------------------------------------------'  |
 |                                                 |
 |  
Encore une portion traduite par "T"            |
 |                                                 |
 `-------------------------------------------------'


Dans le schéma à gauche, on peut remarquer que toute modification au niveau d'un  cadre interne au document rende les signatures de l'auteur et du traducteur invalides.

Si la modification intervient au niveau d'une portion traduite par "T" (parties externes au cadres internes), seulement la signature du traducteur sera invalidée.  Les signatures des différents auteurs resteront donc valides.

Dans le cas où l'auteur original veuille certifier la traduction, il peut signer la page entière après la signature effectuée par le traducteur, comme montré ci-dessous :


 ,-----------[ Deuxième signature auteur "A" ]-----------.
 |                                                       |
 |  ,----------[ Signature traducteur "T" ]-----------.  |
 |  |                                                 |  | 
 |  |  Texte traduit par "T"                          |  |
 |  |                                                 |  |
 |  |                                                 |  |
 |  |  ,---------[ Signature auteur "A" ]----------.  |  |
 |  |  |                                           |  |  |
 |  |  |  Texte écrit et signé par auteur "A"      |  |  |
 |  |  |                                           |  |  |
 |  |  `-------------------------------------------'  |  |
 |  |                                                 |  |
 |  |  Encore du texte traduit par "T"                |  |
 |  |                                                 |  |
 |  `-------------------------------------------------'  |
 |                                                       |
 `-------------------------------------------------------'


Dans cet exemple, l'auteur "A" a créé un texte (ou du code HTML) et il l'a signé.

Ensuite, le traducteur "T" a traduit la portion du texte  dans une autre langue et il l'a signé avec sa propre clé.

Finalement, l'auteur d'origine "A" signe à nouveau la page entière avec sa clé. Cela permet donc de certifier la traduction effectuée par "T" (sans aucune modification supplémentaire du code HTML).




 Certifier les objets liés à la page (pour les paranos) 

Il se peut qu'il soit nécessaire de certifier également "les objets", plus particulièrement les images, contenues dans la page.
Dans ce cas, il est possible de calculer le checksum de tels objets (via MD5 ou SHA1) et d'annoter ces checksum à l'intérieur du commentaire signé.
Cela, différemment d'une simple signature ("Detached ASCII-armored Signature") des objets, donne la possibilité de réduire considérablement l'espace nécessaire, tout en gardant la certification valide. D'ailleurs, la signature numérique, n'est rien d'autre la certification d'un résumé d'un objet ... et cela est exactement ce qu'on va démontrer dans la suite.
Bien évidemment, toutes les images ne nécessitent pas une certification ... seulement les images significatives pour la vérification seront authentifiées.  Cela signifie que, par exemple, les puces, les gif animés décoratives et des fonds éventuels (au moins qu'elles ne jouent un rôle important dans la page)  ne seront pas certifiées à travers le calcul d'un checksum.

Voici un exemple pratique appliquant cette technique.

Ci-dessous est reporté le code HTML qu'on souhaite signer:

 -->

<HTML>
<HEAD>
<TITLE>
Exemple d'authentification des images</TITLE>
</HEAD>
<BODY BACKGROUND="
Fond.gif">

<DIV>
 [Texte ou code HTML signé]
 
 <IMG SRC="Image1.jpg">
 <IMG SRC="Image2.gif">
 
 <IMG SRC="Cadre.gif">
 
 <IMG SRC="Image3.jpg">
 <IMG SRC="Image4.png">
 
 [Texte ou code HTML signé]
</DIV>

</BODY>
</HTML>

 <!--

Liste des checksums des images:

Nom fichier | Dimensions | Checksum MD5
------------+------------+------------------------------------
Image1.jpg  | 46338 byte | E2EE9822 BFF5407D 696B573E FB2989C0 
Image2.gif  | 17379 byte | F1AD8852 6150B054 4DF46226 2B7D6BD4
Image3.jpg  | 40762 byte | 8A4F262F E336F854 077714E7 ABF3C911
Image4.png  | 18065 byte | F06A61F2 6808B01A B9EEF949 F1577264


Dans cet exemple, j'ai mis en évidence le code HTML en utilisant des couleurs différentes:
 bleu  les balises,
 vert  les commentaires correctement saisis,
 noir  les texte affiché par le parseur,
 orange  les fichiers à certifier,
 violet  les fichiers sans intérêt,
 gris  tout ce qui devrait aller en commentaire (bien que pas encore correctement saisi).

Cela permet d'identifier au simple coup d'oeil les différentes parties du code que nous allons analyser.

Après avoir signé ce document, le code HTML se présente comme illustré ci-dessous:

 <!--

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

 -->

<HTML>
<HEAD>
<TITLE>
Exemple d'authentification des images</TITLE>
</HEAD>
<BODY BACKGROUND="
Fond.gif">

<DIV>
 [
Texte ou code HTML signé]
 
 <IMG SRC="Image1.jpg">
 <IMG SRC="Image2.gif">
 
 <IMG SRC="Cadre.gif">
 
 <IMG SRC="Image3.jpg">
 <IMG SRC="Image4.png">
 
 [
Texte ou code HTML signé]
</DIV>

</BODY>
</HTML>

 <!--

Liste des checksums des images:

Nom fichier | Dimensions | Checksum MD5
------------+------------+------------------------------------
Image1.jpg  | 46338 byte | E2EE9822 BFF5407D 696B573E FB2989C0 
Image2.gif  | 17379 byte | F1AD8852 6150B054 4DF46226 2B7D6BD4
Image3.jpg  | 40762 byte | 8A4F262F E336F854 077714E7 ABF3C911
Image4.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 structure du tableau (ou la liste des fichiers certifiés, si on ne veut pas utiliser de tableau), est purement explicative, mais pour qu'elle soit utile, elle devra reporter au minimum le nom de l'objet (son parcours et son extension pour en identifier le type), sa dimension en octets et son checksum (en spécifiant l'algorithme adopté pour le calcul).

Cela implique que, si une seule de ces valeurs (type, dimension ou checksum) devait être modifiée (par exemple, un changement d'image), la signature de la page ne serait plus valide.

Donc, si la portion de code HTML signée résulte authentifiée, cela nous garantit que les checksums relatifs aux images (ou d'autres objets) présentes sont valides.
De cette manière, il nous suffit de calculer le checksum de l'image dont on veut vérifier l'authenticité, le croiser avec sa dimension et son type, pour avoir la certitude que l'image en question n'est pas contrefaite.

Cette technique peut être appliqué à d'autres objets tels que les CSS, les animations flash, les fichiers texte, etc.

Il est bien de tenir compte du fait que tels objets devraient être sous le contrôle de l'auteur de la signature. En cas contraire, une éventuelle modification effectuée par le réel propriétaire de l'objet, rendrait la vérification du checksum impossible.

Pour ce qui concerne des éventuels archives compressés ou bien des fichiers exécutables, il est opportun de signaler la présence du checksum de manière traditionnelle. Cela permettra donc une vérification du fichier suite à son téléchargement en utilisant la technique classique.
Une autre bonne technique consiste à associer une signature séparée au fichier ("Detached Signature").


Méthode alternative

Une alternative à la méthode présente ci-dessus, le checksum peut être incrusté directement dans le lien de l'objet. De cette manière, chaque checksum sera associé directement à l'objet même.

Voici ci-dessous un exemple de cette technique:

 <IMG SRC="Image1.jpg" CHKSUM="46338;MD5;E2EE9822BFF5407D696B573EFB2989C0">
 <IMG SRC="
Image2.gif" CHKSUM="17379;MD5;F1AD88526150B0544DF462262B7D6BD4">
 
 <IMG SRC="Cadre.gif">
 
 <IMG SRC="Image3.jpg" CHKSUM="40762;SHA1;C9E92C38CB325186E749A0FD5C27678827724E5F"> 
 <IMG SRC="
Image4.png" CHKSUM="18065;MD5;F06A61F26808B01AB9EEF949F1577264">

Dans la première ligne (pour des raisons explicatives) des parties ont été mises en évidence en utilisant des couleurs différentes: en  jaune  la balise, en  rouge  la dimension de l'objet en octets, en  vert  l'algorithme de hash utilisé, en  bleu ciel  le checksum de l'objet, calculé avec tel algorithme.

Évidemment, cette technique introduit une balise ("CHKSUM") non valide pour le parseur. Cela signifie que aucun browser interprétera telle balise, qui restera donc invisible. Par contre, cette source HTML pourrait ne pas être valide selon le "W3C Validator".

De cette manière, il sera possible que un browser (de manière native ou à travers un plugin, tel que Enigmail) vérifie directement la validité d'un objet via le calcul de son checksum.

Finalement, si la page sera validée et ces balises seront vérifiées, nous aurons donc obtenu notre résultat attendu.




 Signing portions of JavaScript code 
    If someone is able to translate this paragraph in french, could send me an .    

Since JavaScript, like HTML, is a code to be executed client side, it is also possible to sign portions of JavaScript code, both "embedded" in the HTML code or "included" from an external .js file.
Our HTML page already contains all the "embedded" JavaScript parts, so they are already signed together with the whole page.

On the other hand, it will be necessary to explicitly sign the JavaScript code contained in any external .js file.
To sign such an external code, it will be necessary to create some "commented out" parts in every .js file to insert the signature, like we already did with the HTML code.

In the following example we see how to sign a portion of JavaScript code:

 */

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

 /*

As you may have already noticed, there are an "end comment" (" */ ") at the beginning of the JavaScript code and a "start comment" (" /* ") at the end. All you need to do is to select the content of the .js file to be signed, to sign it and to add the two comment delimiters before and after the signed part, as in the following:

 /*

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

 */

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

 /*

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

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

 */

The green lines, like in the case of the HTML code, will be ignored by the JavaScript interpreter, while the yellow part will be considered:

 /*

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

 */


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


 /*

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

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

 */

Also in this case we can add the checksums of the objects related to the JavaScript code, as in the following example:

 /*

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

 */


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


 /*

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

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

 */

In fact, all that appears after the "line commented" symbol (" // ") will be ignored by the JavaScript interpreter, and it will be used only to certify the related objects (like it already happens in the case of the HTML code).

To verify the signed JavaScript code, therefore, it will be enough to open the .js file and to verify the signature.

Last change: 


Le contenu de cette page peut être utilisé et diffusé librement
selon les règles décrites en Creative Commons Public License v3.0, bien qu'il reste propriété exclusive de TJL73.

Si vous souhaité reporter une partie ou la totalité de ce tutoriel, vous avez l'obligation de citer la source dans votre document.
J'espère qu'une traduction en autres langues soit bientôt disponible.
Tout commentaire, suggestion ou signalisation d'erreur est le bienvenue.

Un grand merci à Theoretical pour avoir demandé et obtenu cette page et à Carlo Luciano Bianco, Rinux,
Lapo Luchini, Stefano Winzozz, Martin Lukáč et Vincenzo Reale pour avoir supporté cette folie avec patience.


The translators are the only responsibles for the content of the translated texts.
I, TJL73, am just hosting their translations, without assuming any responsibility
on the content of such non-Italian versions of the page.


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!