Kurrikulum Leson 84 van 156 · Enkripsie wat jy kan verduidelik
Enkripsie wat jy kan verduidelik

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.

'n

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 fingerprints

Om 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 key

As 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.
Jou beurt

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:

  1. message_number(message, n): gee die SHA-256 digest van die boodskap (UTF-8 bytes) terug, as 'n getal vanaf int.from_bytes(digest, "big"), modulo n.
  2. verify(message, signature, public_key): pak n, e uit, en gee True terug net as pow(signature, e, n) gelyk is aan message_number(message, n), anders False.
  3. genuine_messages(inbox, public_key): gee 'n lys van die boodskapte waarvan die signatures verifieer, in inbox-orde.
Die laaste reëls druk die regte boodskappe. Toetse gebruik nuwe boodskappe en sleutels, so die antwoord kan nie hard-coded wees nie.

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.