|
Tutoriel pour la
signature numérique
de sources HTML
| |
(c-à-d, comment signer une
page source HTML, de manière "transparente" au parseur)
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:
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.
|
|