Verifieer 'n handtekening
Hoekom dit saak maak Elke sagteware-opdatering wat jou foon installeer, elke sertifikaat agter 'n hangslot, en elke passkey-inloggans op een kontrole berus: "is dit werklik deur die regte sleutel geteken?" Om daardie kontrole self een keer te doen, verander signatures van magie in iets wat jy kan verduidelik.
A-handtekening werk soos 'n wasseël wat met 'n ring gestempel is wat net die eienaar het. Enige iemand wat weet hoe die ring se patroon lyk kan die seël nagaan, maar niemand anders kan dit maak nie. En as die brief na die versegeling verander word, pas die seël nie meer nie.
Digitale handtekening: 'n nommer wat uit 'n boodskap en 'n private sleutel gemaak is. Enige iemand met die ooreenstemmende publieke sleutel kan nagaan dat die eienaar dit gemaak het, en dat die boodskap nie daarna verander het nie.
Stap 1: vingerafdruk die boodskap met 'n hash
Hash: 'n funksie wat enige data in 'n kort vingerafdruk met 'n vaste grootte verander. Dieselfde input gee altyd dieselfde vingerafdruk, 'n klein verandering gee 'n heeltemal ander een, en jy kan dit nie terugwerk nie. SHA-256 is 'n algemene een.
import hashlib
print(hashlib.sha256(b"Lunch at 1pm").hexdigest()[:16])
print(hashlib.sha256(b"Lunch at 2pm").hexdigest()[:16])
# two completely different fingerprintsOm die vingerafdruk teen die hele boodskap te teken hou dinge klein en vinnig. Om wiskunde daarop te doen, verander die 32 bytes na een groot heelgetal met int.from_bytes(digest, "big"), dan neem die res na deling deur n met % n sodat dit by die sleutel pas.
Stap 2: herstel die handtekening met die publieke sleutel
In les 81 se speletjie RSA teken die eienaar deur pow(fingerprint, d, n) met die private d te bereken. Om dit te kontroleer bereken jy pow(signature, e, n) met die publieke e. As die resultaat gelyk is aan die vingerafdruk wat jy self bereken het is die handtekening egtig.
In Python is 'n sleutel 'n paar getalle in 'n tuple, soos public_key = (n, e). Die reël n, e = public_key unpacks dit: dit sit die eerste getal in n en die tweede in e.
signer: signature = pow(fingerprint, d, n) # needs the private key
checker: pow(signature, e, n) == fingerprint ? # needs only the public keyAs iemand die boodskap verander, verander die vingerafdruk en dit pas nie meer nie. As hulle die handtekening verander, gee die ongedoen aksie 'n ander nommer. En as iemand met hul eie private sleutel teken terwyl hulle maak asof hulle Ana is (die afsender in hierdie oefening), faal jou kontrole met Ana se publieke sleutel. Al drie word deur een vergelyking opgespoor.
Belangrik: dit is speelding RSA met klein sleutels en geen padding nie, net vir leerdoeleindes. Regte signatures gebruik getoetsde libraries en skemas soos Ed25519 of RSA met PSS padding. Moenie ooit selfgemaakte kriptografie gebruik om regte data te beskerm nie.
'n algemene wanbelewing: " 'n handtekening verberg die boodskap". Dit doen nie; die boodskap beweeg in duidelike sig. 'n Handtekening bewys wie dit gemaak het en dat dit onveranderd is. Om dit te verberg is enkripsie se werk.
In ander tale
Regte kode verifieer met 'n library. Elke call gee true of false terug (of gooi 'n error) in plaas daarvan om getalle by hand te vergelyk.
# Python, with the cryptography package (Ed25519)
from cryptography.exceptions import InvalidSignature
try:
public_key.verify(signature, message) # raises if it does not match
ok = True
except InvalidSignature:
ok = False// JavaScript (browser Web Crypto, ECDSA)
const ok = await crypto.subtle.verify(
{ name: "ECDSA", hash: "SHA-256" }, publicKey, signature, messageBytes);// Go (crypto/ed25519)
ok := ed25519.Verify(publicKey, message, signature)// PHP (libsodium, built in)
$ok = sodium_crypto_sign_verify_detached($signature, $message, $publicKey);// C# (.NET)
bool ok = ecdsa.VerifyData(message, signature, HashAlgorithmName.SHA256);Opsomming
- A-handtekening bewys wie 'n boodskap gemaak het en dat dit nie verander het nie. Dit verberg dit nie nie.
- Hash die boodskap eerste, dan kontroleer die signature teen daardie fingerprint.
- Kontrole het net die publieke sleutel nodig; ondertekening het die private sleutel nodig.
- Toy RSA is vir begrip; regte kode gebruik getoets biblioteke.
Ana teken haar boodskappe met toy RSA. Haar publieke sleutel is PUBLIC_KEY = (n, e), en INBOX bevat (message, signature) pare, waarvan sommige gemanipuleer is. Skryf drie funksies:
message_number(message, n): gee die SHA-256 digest van die boodskap (UTF-8 bytes) terug, as 'n getal vanafint.from_bytes(digest, "big"), modulon.verify(message, signature, public_key): pakn, euit, en geeTrueterug net aspow(signature, e, n)gelyk is aanmessage_number(message, n), andersFalse.genuine_messages(inbox, public_key): gee 'n lys van die boodskapte waarvan die signatures verifieer, in inbox-orde.
Sien jy 'n probleem in hierdie les? Rapporteer dit · Vra oor hierdie les
Hierdie oefening open binnekort
Voltooi die lesie voor dit en hierdie een sal ontvanklik wees. Die hele kursus is gratis, geen rekening nodig nie, en jy kan hierdie les nou lees.
Hierdie blutser blokkeer koekies vir learn.floati.life, so lesse wat jy hier voltooi het kan nie in volgorde oopgaan nie. Laat koekies vir hierdie webwerf toe en laai nuut.