name: Bitcoin-lompakoiden sisäinen toiminta goal: Sukella Bitcoin-lompakoiden voimanlähteenä toimivien kryptografisten periaatteiden syövereihin. objectives:

Määrittele teoreettiset käsitteet, jotka ovat tarpeen Bitcoinissa käytettyjen kryptografisten algoritmien ymmärtämiseksi.
Ymmärrä täysin deterministisen ja hierarkkisen lompakon rakenne.
Tiedä, kuinka tunnistaa ja vähentää lompakon hallintaan liittyviä riskejä.
Ymmärrä hajautusfunktioiden, kryptografisten avainten ja digitaalisten allekirjoitusten periaatteet.

Matka Bitcoin-lompakoiden sydämeen

Löydä determinististen ja hierarkkisten Bitcoin-lompakoiden salaisuudet CYP201-kurssillamme! Olitpa sitten tavallinen käyttäjä tai innokas harrastaja, joka haluaa syventää tietämystään, tämä kurssi tarjoaa täydellisen sukelluksen näiden päivittäin käyttämiemme työkalujen toimintaan.

Opit hajautusfunktioiden, digitaalisten allekirjoitusten (ECDSA ja Schnorr), mnemonisten fraasien, kryptografisten avainten ja vastaanotto-osoitteiden luomisen mekanismeista, samalla tutkien edistyneitä turvallisuusstrategioita.

Tämä koulutus ei ainoastaan varusta sinua tiedolla Bitcoin-lompakon rakenteen ymmärtämiseksi, vaan myös valmistaa sinut sukeltamaan syvemmälle kryptografian jännittävään maailmaan.

Selkeän pedagogiikan, yli 60 selittävän diagrammin ja konkreettisten esimerkkien avulla CYP201 mahdollistaa sinun ymmärtää alusta loppuun, kuinka lompakkosi toimii, jotta voit navigoida Bitcoin-universumissa luottavaisin mielin. Ota hallintaasi UTXO:si tänään ymmärtämällä, kuinka HD-lompakot toimivat!

Johdanto

Kurssin esittely

Tervetuloa CYP201-kurssille, jossa tutkimme syvällisesti HD Bitcoin-lompakoiden toimintaa. Tämä kurssi on suunniteltu kaikille, jotka haluavat ymmärtää Bitcoinin tekniset perusteet, olivatpa he sitten satunnaisia käyttäjiä, valistuneita harrastajia tai tulevaisuuden asiantuntijoita.

Tämän koulutuksen tavoitteena on antaa sinulle avaimet päivittäin käyttämiesi työkalujen hallintaan. HD Bitcoin-lompakot, jotka ovat käyttökokemuksesi ytimessä, perustuvat joskus monimutkaisiin käsitteisiin, joita pyrimme tekemään ymmärrettäviksi. Yhdessä demystifioimme ne!

Ennen kuin sukellamme Bitcoin-lompakoiden rakenteen ja toiminnan yksityiskohtiin, aloitamme muutamalla luvulla kryptografisista primitiiveistä, jotka on tiedettävä seuraavaa varten. Aloitamme kryptografisista hajautusfunktioista, jotka ovat olennaisia sekä lompakoille että itse Bitcoin-protokollalle. Löydät niiden pääominaisuudet, Bitcoinissa käytetyt erityiset funktiot ja teknisemmässä luvussa opit yksityiskohtaisesti hajautusfunktioiden kuningattaren, SHA256:n, toiminnasta. CYP201

Seuraavaksi keskustelemme digitaalisten allekirjoitusalgoritmien toiminnasta, joita käytät joka päivä UTXO:idesi turvaamiseen. Bitcoin käyttää kahta: ECDSA:ta ja Schnorr-protokollaa. Opit, mitkä matemaattiset primitiivit ovat näiden algoritmien taustalla ja kuinka ne takaavat transaktioiden turvallisuuden.

Kun meillä on hyvä ymmärrys näistä kryptografian elementeistä, siirrymme viimein koulutuksen ytimeen: deterministisiin ja hierarkkisiin lompakoihin! Ensin on osio omistettu mnemonisille fraaseille, näille 12 tai 24 sanan sekvensseille, jotka mahdollistavat lompakkojesi luomisen ja palauttamisen. Löydät, kuinka nämä sanat generoidaan entropian lähteestä ja kuinka ne helpottavat Bitcoinin käyttöä.

CYP201 Koulutus jatkuu BIP39-salasanan, siemenen (ei pidä sekoittaa mnemoniseen lauseeseen), pääketjukoodin ja pääavaimen tutkimisella. Tarkastelemme yksityiskohtaisesti, mitä nämä elementit ovat, niiden vastaavat roolit ja kuinka ne lasketaan. CYP201

Lopuksi, pääavaimesta, tutustumme siihen, kuinka kryptografiset avainparit johdetaan deterministisellä ja hierarkisella tavalla aina vastaanotto-osoitteisiin saakka.

Tämä koulutus mahdollistaa sinulle lompakko-ohjelmiston käytön luottavaisin mielin, samalla parantaen taitojasi tunnistaa ja lieventää riskejä. Valmistaudu tulemaan todelliseksi asiantuntijaksi Bitcoin-lompakoissa!

Häsäfunktiot

Johdanto Häsäfunktioihin

Ensimmäinen Bitcoinissa käytetty kryptografisten algoritmien tyyppi kattaa häsäfunktiot. Ne ovat olennaisessa roolissa eri tasoilla protokollassa, mutta myös Bitcoin-lompakoissa. Tutustutaan yhdessä siihen, mikä häsäfunktio on ja mihin sitä käytetään Bitcoinissa.

Määritelmä ja Häsäyksen Periaate

Häsäys on prosessi, joka muuntaa mielivaltaisen pituisen tiedon toiseksi, kiinteän pituiseksi tiedoksi kryptografisen häsäfunktion avulla. Toisin sanoen, häsäfunktio ottaa syötteenä minkä tahansa kokoisen tiedon ja muuntaa sen kiinteän kokoiseksi sormenjäljeksi, jota kutsutaan "häsäykseksi". Häsäystä voidaan joskus kutsua myös "digestiksi", "tiivisteeksi", "tiivistetyksi" tai "häsätyksi".

Esimerkiksi SHA256-häsäfunktio tuottaa kiinteän pituisen, 256-bittisen häsäyksen. Jos käytämme syötteenä "PlanB", mielivaltaisen pituisen viestin, tuotettu häsäys on seuraava 256-bittinen sormenjälki:

24f1b93b68026bfc24f5c8265f287b4c940fb1664b0d75053589d7a4f821b688

Häsäfunktioiden Ominaisuudet

Näillä kryptografisilla häsäfunktioilla on useita olennaisia ominaisuuksia, jotka tekevät niistä erityisen hyödyllisiä Bitcoinin ja muiden tietojärjestelmien kontekstissa:

Palautumattomuus (tai esikuvan vastustuskyky)
Muutoksenkestävyys (lumivyöryvaikutus)
Kolarinkestävyys
Toisen esikuvan vastustuskyky

1. Palautumattomuus (esikuvan vastustuskyky):

Peruuttamattomuus tarkoittaa, että on helppoa laskea tiiviste annetusta syötetiedosta, mutta käänteinen laskenta, eli alkuperäisen syötteen löytäminen tiivisteestä, on käytännössä mahdotonta. Tämä ominaisuus tekee tiivistefunktioista täydellisiä ainutlaatuisten digitaalisten sormenjälkien luomiseen ilman, että alkuperäinen tieto vaarantuu.

Annetussa esimerkissä häsäyksen 24f1b9… saaminen tietäen syötteen "PlanB" on yksinkertaista ja nopeaa. Kuitenkin viestin "PlanB" löytäminen tietäen vain 24f1b9… on mahdotonta.

Siksi on mahdotonta löytää esikuvaa $m$ häsäykselle $h$ siten, että $h = \text{HASH}(m)$ , missä $\text{HASH}$ on kryptografinen häsäfunktio.

2. Muutoksenkestävyys (lumivyöryvaikutus)

Toisen ominaisuuden nimi on manipuloinnin kestävyys, joka tunnetaan myös lumivyöryefektinä. Tämä ominaisuus havaitaan hajautusfunktiossa, jos pieni muutos syötteen viestissä johtaa radikaaliin muutokseen tulosteessa olevassa hajautusarvossa. Jos palaamme esimerkkiimme syötteellä "PlanB" ja SHA256-funktiolla, olemme nähneet, että tuotettu hajautusarvo on seuraava:

24f1b93b68026bfc24f5c8265f287b4c940fb1664b0d75053589d7a4f821b688

Jos teemme hyvin pienen muutoksen syötteeseen käyttämällä tällä kertaa "Planb", niin pelkästään muuttamalla iso "B" pieneksi "b":ksi muuttaa täysin SHA256:n tulosteena olevan hajautusarvon:

bb038b4503ac5d90e1205788b00f8f314583c5e22f72bec84b8735ba5a36df3f

Tämä ominaisuus varmistaa, että jopa pieni muutos alkuperäisessä viestissä on välittömästi havaittavissa, sillä se ei vain muuta pientä osaa hajautusarvosta, vaan koko hajautusarvon. Tämä voi olla kiinnostavaa eri aloilla viestien, ohjelmistojen tai jopa Bitcoin-siirtojen eheyden varmistamiseksi.

3. Yhteentörmäyksen Kestävyys

Kolmas ominaisuus on yhteentörmäyksen kestävyys. Hajautusfunktio on yhteentörmäyksen kestävä, jos on laskennallisesti mahdotonta löytää kahta erilaista viestiä, jotka tuottavat saman hajautusarvon funktiosta. Formaalisti, on vaikeaa löytää kaksi erillistä viestiä $m_1$ ja $m_2$ siten, että:

 $\text{HASH}(m_1) = \text{HASH}(m_2)$

Todellisuudessa on matemaattisesti väistämätöntä, että hajautusfunktioille esiintyy yhteentörmäyksiä, koska syötteiden koko voi olla suurempi kuin tulosteiden koko. Tämä tunnetaan Dirichletin laatikkoperiaatteena: jos $n$ objektia jaetaan $m$ laatikkoon, joista $m < n$ , niin ainakin yhdessä laatikossa on välttämättä kaksi tai useampi objekti. Hajautusfunktiolle tämä periaate pätee, koska mahdollisten viestien määrä on (lähes) ääretön, kun taas mahdollisten hajautusarvojen määrä on rajallinen ( $2^{256}$ SHA256:n tapauksessa).

Näin ollen tämä ominaisuus ei tarkoita, että hajautusfunktioilla ei olisi yhteentörmäyksiä, vaan pikemminkin, että hyvä hajautusfunktio tekee yhteentörmäyksen löytämisen todennäköisyyden merkityksettömäksi. Esimerkiksi SHA-0 ja SHA-1 algoritmit, SHA-2:n edeltäjät, joille on löydetty yhteentörmäyksiä, eivät enää täytä tätä ominaisuutta. Näitä funktioita suositellaan siis välttämään ja ne katsotaan usein vanhentuneiksi. Hajautusfunktion $n$ bittiä varten, yhteentörmäyksen kestävyys on järjestyksessä $2^{\frac{n}{2}}$ , syntymäpäivähyökkäyksen mukaisesti. Esimerkiksi SHA256:n ( $n = 256$ ) tapauksessa yhteentörmäyksen löytämisen monimutkaisuus on järjestyksessä $2^{128}$ yritystä. Käytännön termein tämä tarkoittaa, että jos funktioon syötetään $2^{128}$ erilaista viestiä, on todennäköistä löytää yhteentörmäys.

4. Toisen Esikuvan Kestävyys

Toisen esikuvan kestävyys on toinen tärkeä hajautusfunktioiden ominaisuus. Se toteaa, että annetun viestin $m_1$ ja sen hajautusarvon $h$ perusteella, on laskennallisesti mahdotonta löytää toista viestiä $m_2 \neq m_1$ siten, että:

 $\text{HASH}(m_1) = \text{HASH}(m_2)$

Näin ollen toisen esikuvan kestävyys on jossain määrin samankaltainen kuin yhteentörmäyksen kestävyys, paitsi että tässä hyökkäys on vaikeampi, koska hyökkääjä ei voi vapaasti valita $m_1$ . CYP201

Hash-funktioiden sovellukset Bitcoinissa

Bitcoinissa eniten käytetty hash-funktio on SHA256 ("Secure Hash Algorithm 256 bits"). NSA suunnitteli sen 2000-luvun alussa ja NIST standardisoi sen. Se tuottaa 256-bittisen hash-tuloksen.

Tätä funktiota käytetään monissa Bitcoinin osa-alueissa. Protokollatasolla se on mukana Proof-of-Work -mekanismissa, jossa sitä sovelletaan kaksinkertaisessa hashauksessa etsittäessä osittaista törmäystä ehdokaslohkon otsikon ja vaikeustavoitteen välillä. Jos tämä osittainen törmäys löytyy, ehdokaslohko muuttuu kelvolliseksi ja sen voi lisätä lohkoketjuun.

SHA256:ta käytetään myös Merkle-puun rakentamisessa, joka on erityisesti transaktioiden tallentamiseen käytetty akkumulaattori lohkoissa. Tätä rakennetta käytetään myös Utreexo-protokollassa, joka mahdollistaa UTXO Setin koon pienentämisen. Lisäksi Taprootin käyttöönoton myötä vuonna 2021, SHA256:ta hyödynnetään MAST:ssa (Merkelised Alternative Script Tree), joka mahdollistaa vain käytetyissä skripteissä käytettyjen kulutusehtojen paljastamisen ilman muiden mahdollisten vaihtoehtojen paljastamista. Sitä käytetään myös transaktioidentiteettien laskennassa, pakettien siirrossa P2P-verkossa, sähköisissä allekirjoituksissa... Lopuksi, ja tämä on erityisen kiinnostavaa tässä koulutuksessa, SHA256:ta käytetään sovellustasolla Bitcoin-lompakoiden rakentamisessa ja osoitteiden johdannaisessa.

Useimmiten, kun törmäät SHA256:n käyttöön Bitcoinissa, on kyseessä itse asiassa kaksinkertainen hash SHA256, merkitty "HASH256", joka yksinkertaisesti koostuu SHA256:n soveltamisesta kahdesti peräkkäin: HASH256(m) = SHA256(SHA256(m))

Tämä kaksinkertaisen hashauksen käytäntö lisää ylimääräisen turvallisuustason tietyiltä mahdollisilta hyökkäyksiltä suojautumiseen, vaikka yksittäinen SHA256 katsotaan nykyään kryptografisesti turvalliseksi.

Toinen Script-kielissä käytettävä hash-funktio vastaanotto-osoitteiden johdannaisessa on RIPEMD160-funktio. Tämä funktio tuottaa 160-bittisen hashin (joka on siis lyhyempi kuin SHA256). Sitä yhdistetään yleensä SHA256:n kanssa muodostamaan HASH160-funktio:

 $\text{HASH160}(m) = \text{RIPEMD160}(\text{SHA256}(m))$

Tätä yhdistelmää käytetään lyhyempien hashien tuottamiseen, erityisesti tietyntyyppisten Bitcoin-osoitteiden luomisessa, jotka edustavat avainten tai skriptien hash-arvoja, sekä avainten sormenjälkien tuottamiseen.

Lopuksi, vain sovellustasolla, joskus käytetään myös SHA512-funktiota, joka epäsuorasti vaikuttaa avainten johdannaisessa lompakoille. Tämä funktio on hyvin samankaltainen kuin SHA256 toiminnassaan; molemmat kuuluvat samaan SHA2-perheeseen, mutta SHA512 tuottaa, kuten nimestä voi päätellä, 512-bittisen hashin, verrattuna SHA256:n 256 bittiin. Tarkastelemme sen käyttöä tarkemmin seuraavissa luvuissa.

Nyt tiedät olennaiset perustiedot hash-funktioista seuraavaa varten. Seuraavassa luvussa ehdotan, että tutustumme yksityiskohtaisemmin funktioon, joka on Bitcoinin ytimessä: SHA256. Pureudumme siihen ymmärtääksemme, miten se saavuttaa tässä kuvatut ominaisuudet. Seuraava luku on melko pitkä ja tekninen, mutta sen ymmärtäminen ei ole olennaista koulutuksen jatkamisen kannalta. Joten, jos et ymmärrä sitä, älä huolestu ja siirry suoraan seuraavaan lukuun, joka on paljon helpommin saavutettavissa.

SHA256:n sisäinen toiminta

905eb320-f15b-5fb6-8d2d-5bb447337deb Olemme aiemmin nähneet, että hajautusfunktiot omaavat tärkeitä ominaisuuksia, jotka oikeuttavat niiden käytön Bitcoinissa. Tutkitaan nyt näiden hajautusfunktioiden sisäisiä mekanismeja, jotka antavat niille nämä ominaisuudet, ja tätä varten ehdotan, että pureudumme SHA256-toiminnon toimintaan. SHA256- ja SHA512-funktiot kuuluvat samaan SHA2-perheeseen. Niiden mekanismi perustuu tiettyyn rakenteeseen, jota kutsutaan Merkle-Damgård -rakenteeksi. Myös RIPEMD160 käyttää tätä samaa rakennetyyppiä.

Muistutuksena, meillä on SHA256:lle syötteenä mielivaltaisen kokoinen viesti, ja lähetämme sen funktion läpi saadaksemme 256-bittisen hajautusarvon tulosteena.

Syötteen esikäsittely

Aloitetaan valmistamalla syöteviestimme $m$ niin, että sillä on standardi pituus, joka on 512 bitin monikerta. Tämä vaihe on ratkaisevan tärkeä algoritmin myöhemmän toiminnan kannalta. Tätä varten aloitamme täytesegmenttien lisäysvaiheella. Lisäämme ensin viestiin erotinbitin 1, jonka jälkeen lisäämme tietyn määrän 0 bittejä. Lisättävien 0 bittien määrä lasketaan niin, että viestin kokonaispituus tämän lisäyksen jälkeen on kongruentti 448 modulo 512 kanssa. Näin ollen viestin $L$ pituus täytesegmenttien kanssa on yhtä suuri kuin:

 $L \equiv 448 \mod 512$

$\text{mod}$ , modulo, on matemaattinen operaatio, joka kahden kokonaisluvun välillä palauttaa ensimmäisen ja toisen Euklidisen jaon jäännöksen. Esimerkiksi: $16 \mod 5 = 1$ . Se on operaatio, jota käytetään laajalti kryptografiassa.

Tässä täytesegmenttien lisäysvaihe varmistaa, että seuraavassa vaiheessa lisättävien 64 bitin jälkeen viestin kokonaispituus on 512 bitin monikerta. Jos alkuperäisen viestin pituus on $M$ bittejä, lisättävien 0 bittien määrä ( $N$ ) on siis:

 $N = (448 - (M + 1) \mod 512) \mod 512$

Esimerkiksi, jos alkuperäinen viesti on 950 bittiä, laskenta olisi seuraava:

 $\begin{align*} M & = 950 \\ M + 1 & = 951 \\ (M + 1) \mod 512 & = 951 \mod 512 \\ & = 951 - 512 \cdot \left\lfloor \frac{951}{512} \right\rfloor \\ & = 951 - 512 \cdot 1 \\ & = 951 - 512 \\ & = 439 \\ \\ 448 - (M + 1) \mod 512 & = 448 - 439 \\ & = 9 \\ \\ N & = (448 - (M + 1) \mod 512) \mod 512 \\ N & = 9 \mod 512 \\ & = 9 \end{align*}$

Näin ollen meillä olisi 9 0 lisäksi erotin 1. Täytesegmenttimme, joka lisätään suoraan viestimme $M$ jälkeen, olisi siis:

1000 0000 00

Täytesegmenttien lisäämisen jälkeen viestiimme $M$ , lisäämme myös 64-bittisen esityksen alkuperäisestä viestin $M$ pituudesta, ilmaistuna binäärilukuna. Tämä mahdollistaa hajautusfunktion herkkyyden bittien järjestykselle ja viestin pituudelle. Jos palaamme esimerkkiimme, jossa alkuperäinen viesti oli 950 bittiä, muutamme desimaaliluvun 950 binääriluvuksi, mikä antaa meille 1110 1101 10. Täydennämme tämän luvun nollilla perään, jotta saamme yhteensä 64 bittiä. Esimerkissämme tämä antaa:

0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 1011 0110

Tämä täytteen koko lisätään seuraamalla bittitäytettä. Näin ollen viesti käsittelyn jälkeen koostuu kolmesta osasta:

Alkuperäinen viesti $M$ ;
Bitti 1 seurattuna usealla bitillä 0 muodostaakseen bittitäytteen;
64-bittinen esitys $M$ :n pituudesta muodostaakseen koon täytteen.

Muuttujien Alustus

SHA256 käyttää kahdeksaa alkuarvomuuttujaa, jotka on merkitty $A$ :sta $H$ :een, kukin 32 bittiä. Nämä muuttujat alustetaan tietyillä vakioilla, jotka ovat ensimmäisten kahdeksan alkuluvun neliöjuurten desimaaliosat. Käytämme näitä arvoja myöhemmin hashausprosessin aikana:

$A = 0x6a09e667$
$B = 0xbb67ae85$
$C = 0x3c6ef372$
$D = 0xa54ff53a$
$E = 0x510e527f$
$F = 0x9b05688c$
$G = 0x1f83d9ab$
$H = 0x5be0cd19$

SHA256 käyttää myös 64 muuta vakioa, jotka on merkitty $K_0$ :sta $K_{63}$ :een, ja jotka ovat ensimmäisten 64 alkuluvun kuutiojuurten desimaaliosat:

 $K[0 \ldots 63] = \begin{pmatrix} 0x428a2f98, & 0x71374491, & 0xb5c0fbcf, & 0xe9b5dba5, \\ 0x3956c25b, & 0x59f111f1, & 0x923f82a4, & 0xab1c5ed5, \\ 0xd807aa98, & 0x12835b01, & 0x243185be, & 0x550c7dc3, \\ 0x72be5d74, & 0x80deb1fe, & 0x9bdc06a7, & 0xc19bf174, \\ 0xe49b69c1, & 0xefbe4786, & 0x0fc19dc6, & 0x240ca1cc, \\ 0x2de92c6f, & 0x4a7484aa, & 0x5cb0a9dc, & 0x76f988da, \\ 0x983e5152, & 0xa831c66d, & 0xb00327c8, & 0xbf597fc7, \\ 0xc6e00bf3, & 0xd5a79147, & 0x06ca6351, & 0x14292967, \\ 0x27b70a85, & 0x2e1b2138, & 0x4d2c6dfc, & 0x53380d13, \\ 0x650a7354, & 0x766a0abb, & 0x81c2c92e, & 0x92722c85, \\ 0xa2bfe8a1, & 0xa81a664b, & 0xc24b8b70, & 0xc76c51a3, \\ 0xd192e819, & 0xd6990624, & 0xf40e3585, & 0x106aa070, \\ 0x19a4c116, & 0x1e376c08, & 0x2748774c, & 0x34b0bcb5, \\ 0x391c0cb3, & 0x4ed8aa4a, & 0x5b9cca4f, & 0x682e6ff3, \\ 0x748f82ee, & 0x78a5636f, & 0x84c87814, & 0x8cc70208, \\ 0x90befffa, & 0xa4506ceb, & 0xbef9a3f7, & 0xc67178f2 \end{pmatrix}$

Syötteen Jakaminen

Nyt kun meillä on tasapainotettu syöte, siirrymme SHA256-algoritmin pääkäsittelyvaiheeseen: tiivistysfunktioon. Tämä vaihe on erittäin tärkeä, koska se on ensisijaisesti se, mikä antaa hajautusfunktiolle sen kryptografiset ominaisuudet, joita tutkimme edellisessä luvussa.

Aloitamme jakamalla tasapainotetun viestimme (esikäsittelyvaiheiden tulos) useisiin 512 bitin lohkoihin $P$ . Jos tasapainotetulla viestillämme on yhteensä $n \times 512$ bittiä, meillä on siis $n$ lohkoa, joista jokainen on 512 bittiä. Jokaista 512 bitin lohkoa käsitellään erikseen tiivistysfunktion toimesta, joka koostuu 64 peräkkäisestä operaatiosta. Nimeämme nämä lohkot $P_1$ , $P_2$ , $P_3$ ...

Loogiset Operaatiot

Ennen kuin tutkimme tiivistysfunktiota yksityiskohtaisesti, on tärkeää ymmärtää siinä käytetyt perusloogiset operaatiot. Nämä operaatiot, jotka perustuvat Booleen algebraan, toimivat bittitasolla. Käytetyt perusloogiset operaatiot ovat:

Konjunktio (AND): merkitään $\land$ , vastaa loogista "JA".
Disjunktio (OR): merkitään $\lor$ , vastaa loogista "TAI".
Negaatio (NOT): merkitään $\lnot$ , vastaa loogista "EI".

Näistä perusoperaatioista voimme määritellä monimutkaisempia operaatioita, kuten "Eksklusiivinen TAI" (XOR) merkitään $\oplus$ , jota käytetään laajalti kryptografiassa. Jokainen looginen operaatio voidaan esittää totuustaulukolla, joka ilmoittaa tuloksen kaikille mahdollisille binäärisyötteiden yhdistelmille (kaksi operandia $p$ ja $q$ ). XOR:lle ( $\oplus$ ):

$p$	$q$	$p \oplus q$
0	0	0
0	1	1
1	0	1
1	1	0

AND:lle ( $\land$ ):

$p$	$q$	$p \land q$
0	0	0
0	1	0
1	0	0
1	1	1

Ei ole ( $\lnot p$ ):

$p$	$\lnot p$
0	1
1	0

Otetaan esimerkki ymmärtääksemme XOR-operaation toimintaa bittitasolla. Jos meillä on kaksi binäärilukua 6 bitissä:

$a = 101100$
$b = 001000$

Silloin:

 $a \oplus b = 101100 \oplus 001000 = 100100$

Soveltamalla XOR bitti bittiltä:

Bittipaikka	$a$	$b$	$a \oplus b$
1	1	0	1
2	0	0	0
3	1	1	0
4	1	0	1
5	0	0	0
6	0	0	0

Tulos on siis $100100$ .

Loogisten operaatioiden lisäksi tiivistysfunktio käyttää bittien siirto-operaatioita, jotka ovat olennaisessa roolissa bittien diffuusiossa algoritmissa.

Ensinnäkin on looginen oikealle siirto -operaatio, joka on merkitty $ShR_n(x)$ , ja joka siirtää kaikki $x$ :n bitit oikealle $n$ paikkaa, täyttäen vasemmalla puolella olevat tyhjät bitit nollilla.

Esimerkiksi, jos $x = 101100001$ (9 bitissä) ja $n = 4$ :

 $ShR_4(101100001) = 000010110$

Kaaviollisesti oikean siirron operaatio voidaan nähdä näin:

CYP201 Toinen SHA256:ssa bittimanipulaatioon käytetty operaatio on oikea kiertävä siirto, merkitty $RotR_n(x)$ , joka siirtää $x$ :n bitit oikealle $n$ paikkaa, asettaen siirretyt bitit merkkijonon alkuun. Esimerkiksi, jos $x = 101100001$ (yli 9 bitissä) ja $n = 4$ :

 $RotR_4(101100001) = 000110110$

Kaaviollisesti oikea kiertävä siirto -operaatio voidaan nähdä näin:

Tiivistysfunktio

Nyt kun olemme ymmärtäneet perusoperaatiot, tarkastellaan SHA256:n tiivistysfunktiota yksityiskohtaisesti.

Edellisessä vaiheessa jaettiin syöte useisiin 512-bittisiin palasiin $P$ . Jokaiselle 512-bittiselle lohkolle $P$ , meillä on:

Viestisanat $W_i$ : $i$ :lle 0:sta 63:een.
Vakiot $K_i$ : $i$ :lle 0:sta 63:een, määritelty edellisessä vaiheessa.
Tilamuuttujat $A, B, C, D, E, F, G, H$ : alustettu arvoilla edellisestä vaiheesta. Ensimmäiset 16 sanaa, $W_0$ - $W_{15}$ , on suoraan poimittu käsitellystä 512-bittisestä lohkosta $P$ . Jokainen sana $W_i$ koostuu 32 peräkkäisestä bitistä lohkosta. Esimerkiksi otamme ensimmäisen syötteen palan $P_1$ , ja jaamme sen edelleen pienempiin 32-bittisiin palasiin, joita kutsumme sanoiksi. Seuraavat 48 sanaa ( $W_{16}$ - $W_{63}$ ) luodaan käyttäen seuraavaa kaavaa:

 $W_i = W_{i-16} + \sigma_0(W_{i-15}) + W_{i-7} + \sigma_1(W_{i-2}) \mod 2^{32}$

Missä:

$\sigma_0(x) = RotR_7(x) \oplus RotR_{18}(x) \oplus ShR_3(x)$
$\sigma_1(x) = RotR_{17}(x) \oplus RotR_{19}(x) \oplus ShR_{10}(x)$

Tässä tapauksessa $x$ on yhtä kuin $W_{i-15}$ $\sigma_0(x)$ :lle ja $W_{i-2}$ $\sigma_1(x)$ :lle.

Kun olemme määrittäneet kaikki sanat $W_i$ 512-bittiselle palalle, voimme siirtyä puristustoimintoon, joka koostuu 64 kierroksen suorittamisesta.

CYP201 Jokaisella kierroksella $i$ välillä 0 - 63, meillä on kolme erilaista syötettä. Ensinnäkin, $W_i$ , jonka juuri määritimme, osittain koostuen viestimme palasta $P_n$ . Seuraavaksi, 64 vakioa $K_i$ . Lopuksi käytämme tilamuuttujia $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ ja $H$ , jotka kehittyvät läpi hajautusprosessin ja muuttuvat jokaisen puristustoiminnon myötä. Kuitenkin ensimmäiselle palalle $P_1$ , käytämme aiemmin annettuja alkuvakioita. Suoritamme sitten seuraavat operaatiot syötteillämme:

Funktio $\Sigma_0$ :

 $\Sigma_0(A) = RotR_2(A) \oplus RotR_{13}(A) \oplus RotR_{22}(A)$

Funktio $\Sigma_1$ :

 $\Sigma_1(E) = RotR_6(E) \oplus RotR_{11}(E) \oplus RotR_{25}(E)$

Funktio $Ch$ ("Valitse"):

 $Ch(E, F, G) = (E \land F) \oplus (\lnot E \land G)$

Funktio $Maj$ ("Enemmistö"):

 $Maj(A, B, C) = (A \land B) \oplus (A \land C) \oplus (B \land C)$

Laskemme sitten 2 väliaikaista muuttujaa:

$temp1$ :

 $temp1 = H + \Sigma_1(E) + Ch(E, F, G) + K_i + W_i \mod 2^{32}$

$temp2$ :

 $temp2 = \Sigma_0(A) + Maj(A, B, C) \mod 2^{32}$

Seuraavaksi päivitämme tilamuuttujat seuraavasti:

 $\begin{cases} H = G \\ G = F \\ F = E \\ E = D + temp1 \mod 2^{32} \\ D = C \\ C = B \\ B = A \\ A = temp1 + temp2 \mod 2^{32} \end{cases}$

Seuraava kaava esittää yhden kierroksen SHA256-tiivistysfunktion toimintaa, kuten juuri kuvailimme:

Nuolet osoittavat datan kulkusuunnan;
Laatikot edustavat suoritettuja operaatioita;
$+$ ympäröidyt edustavat modulo $2^{32}$ lisäystä.

Voimme jo havaita, että tämä kierros tuottaa uudet tilamuuttujat $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ ja $H$ . Nämä uudet muuttujat toimivat syötteenä seuraavalle kierrokselle, joka puolestaan tuottaa uudet muuttujat $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ ja $H$ , joita käytetään seuraavalla kierroksella. Tämä prosessi jatkuu aina 64. kierrokseen asti. 64 kierroksen jälkeen päivitämme tilamuuttujien alkuperäiset arvot lisäämällä ne lopullisiin arvoihin 64. kierroksen lopussa:

 $\begin{cases} A = A_{\text{initial}} + A \mod 2^{32} \\ B = B_{\text{initial}} + B \mod 2^{32} \\ C = C_{\text{initial}} + C \mod 2^{32} \\ D = D_{\text{initial}} + D \mod 2^{32} \\ E = E_{\text{initial}} + E \mod 2^{32} \\ F = F_{\text{initial}} + F \mod 2^{32} \\ G = G_{\text{initial}} + G \mod 2^{32} \\ H = H_{\text{initial}} + H \mod 2^{32} \end{cases}$

Nämä uudet arvot $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ ja $H$ toimivat alkuperäisinä arvoina seuraavalle lohkolle, $P_2$ . Tässä lohkossa $P_2$ toistamme saman tiivistysprosessin 64 kierroksen ajan, sitten päivitämme muuttujat lohkolle $P_3$ , ja niin edelleen, kunnes viimeinen lohko tasattua syötettä on käsitelty.

Kaikkien viestilohkojen käsittelyn jälkeen yhdistämme muuttujien lopulliset arvot $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ ja $H$ muodostaaksemme tiivistysfunktiomme lopullisen 256-bittisen tiivisteen:

 $\text{Tiiviste} = A \Vert B \Vert C \Vert D \Vert E \Vert F \Vert G \Vert H$

Jokainen muuttuja on 32-bittinen kokonaisluku, joten niiden yhdistäminen tuottaa aina 256-bittisen tuloksen, riippumatta viestin syötteen koosta tiivistysfunktioon.

Kryptografisten Ominaisuuksien Perustelu

Mutta miten tämä funktio on peruuttamaton, törmäyskestävä ja manipuloinnin kestävä?

Manipuloinnin kestävyyden ymmärtäminen on melko yksinkertaista. Suoritetaan niin monta laskutoimitusta peräkkäin, jotka riippuvat sekä syötteestä että vakioista, että alkuperäisen viestin pieninkin muutos muuttaa täysin polkua, jota pitkin edetään, ja siten muuttaa täysin lopputuloksen tiivisteen. Tätä kutsutaan lumivyöryvaikutukseksi. Tämä ominaisuus varmistetaan osittain sekoittamalla välitilat alkuperäisiin tiloihin kussakin palassa. Seuraavaksi, kun keskustelemme kryptografisesta hajautusfunktiosta, termiä "irreversibility" (kääntämättömyys) ei yleensä käytetä. Sen sijaan puhumme "preimage resistance" (esikuvan vastustuskyvystä), joka määrittelee, että mille tahansa annetulle $y$ :lle, on vaikeaa löytää sellaista $x$ :ää, että $h(x) = y$ . Tämä esikuvan vastustuskyky taataan algebrallisen monimutkaisuuden ja suoritettujen operaatioiden vahvan epälineaarisuuden, sekä prosessissa tapahtuvan tietyn tiedon häviämisen kautta. Esimerkiksi, annetulle tulokselle moduuli lisäyksessä, on useita mahdollisia operandeja:$$ 3+2 \mod 10 = 5 \ 7+8 \mod 10 = 5 \ 5+10 \mod 10 = 5

 $Tässä esimerkissä, tietäen vain käytetyn moduulin (10) ja tuloksen (5), ei voi varmuudella määrittää, mitkä ovat oikeat operandit lisäyksessä. Sanotaan, että on olemassa useita kongruensseja moduuli 10 suhteen. XOR-operaation kohdalla kohtaamme saman ongelman. Muista totuustaulu tälle operaatiolle: mikä tahansa 1-bittinen tulos voidaan määrittää kahdella eri syötteiden konfiguraatiolla, joilla on täsmälleen sama todennäköisyys olla oikeat arvot. Siksi ei voi varmuudella määrittää XOR:n operandeja tietäen vain sen tuloksen. Jos lisäämme XOR-operandeiden kokoa, mahdollisten syötteiden määrä tietäen vain tuloksen kasvaa eksponentiaalisesti. Lisäksi XOR:ia käytetään usein yhdessä muiden bittitason operaatioiden, kuten $\text{RotR}$ operaation kanssa, jotka lisäävät vielä enemmän mahdollisia tulkintoja tulokseen. Puristusfunktio käyttää myös $\text{ShR}$ operaatiota. Tämä operaatio poistaa osan perustiedosta, jota ei myöhemmin ole mahdollista palauttaa. Jälleen kerran, ei ole algebrallista keinoa kääntää tätä operaatiota. Kaikkia näitä yksisuuntaisia ja tietoa menettäviä operaatioita käytetään hyvin usein puristusfunktioissa. Mahdollisten syötteiden määrä annetulle tulokselle on siis lähes ääretön, ja jokainen käänteislaskuyritys johtaisi yhtälöihin, joissa on hyvin suuri määrä tuntemattomia, jotka kasvaisivat eksponentiaalisesti jokaisessa vaiheessa. Lopuksi, törmäyskestävyyden ominaisuuden osalta, useat parametrit tulevat peliin. Alkuperäisen viestin esikäsittelyllä on olennainen rooli. Ilman tätä esikäsittelyä, törmäysten löytäminen funktiosta saattaisi olla helpompaa. Vaikka teoreettisesti törmäykset ovat olemassa (lintuhäkkiprinsiipin vuoksi), hajautusfunktion rakenne, yhdessä edellä mainittujen ominaisuuksien kanssa, tekee törmäyksen löytämisen todennäköisyyden äärimmäisen matalaksi. Jotta hajautusfunktio olisi törmäyskestävä, on olennaista, että: - Tuloksen ennustamattomuus: Mikä tahansa ennustettavuus voidaan hyödyntää törmäysten löytämiseksi nopeammin kuin brute force -hyökkäyksellä. Funktio varmistaa, että jokainen tuloksen bitti riippuu ei-triviaalilla tavalla syötteestä. Toisin sanoen, funktio on suunniteltu niin, että jokaisen lopputuloksen bitillä on itsenäinen todennäköisyys olla 0 tai 1, vaikka tämä itsenäisyys ei käytännössä olekaan absoluuttinen. - Hajautusten jakautuminen on pseudosatunnainen: Tämä varmistaa, että hajautukset ovat tasaisesti jakautuneet. - Hajautuksen koko on merkittävä: mitä suurempi mahdollisten tulosten tila on, sitä vaikeampi on löytää törmäys. Kryptografit suunnittelevat näitä funktioita arvioimalla parhaita mahdollisia hyökkäyksiä törmäysten löytämiseksi, ja sitten säätävät parametreja tehdäkseen nämä hyökkäykset tehottomiksi. ### Merkle-Damgårdin rakenne SHA256:n rakenne perustuu Merkle-Damgårdin rakenteeseen, joka mahdollistaa puristusfunktion muuntamisen hajautusfunktioksi, joka voi käsitellä mielivaltaisen pituisia viestejä. Juuri tämän olemme nähneet tässä luvussa. Kuitenkin jotkin vanhat hajautusfunktiot kuten SHA1 tai MD5, jotka käyttävät tätä tiettyä rakennetta, ovat haavoittuvaisia pituuden laajennushyökkäyksille. Tämä on tekniikka, joka mahdollistaa hyökkääjän, joka tietää viestin $M$ hajautusarvon ja $M$:n pituuden (tietämättä itse viestiä), laskea hajautusarvon viestille $M'$, joka muodostuu yhdistämällä $M$ lisäsisällön kanssa. SHA256, vaikka se käyttää samaa tyyppistä rakennetta, on teoreettisesti vastustuskykyinen tällaiselle hyökkäykselle, toisin kuin SHA1 ja MD5. Tämä saattaa selittää mysteerin Bitcoinin läpi toteutetusta kaksinkertaisesta hajautuksesta, jonka Satoshi Nakamoto toteutti. Välttääkseen tällaista hyökkäystä, Satoshi on saattanut suosia kaksinkertaista SHA256 käyttöä:$

\text{HASH256}(m) = \text{SHA256}(\text{SHA256}(m))

 $Tämä parantaa turvallisuutta potentiaalisia hyökkäyksiä vastaan, jotka liittyvät Merkle-Damgårdin rakenteeseen, mutta se ei lisää hajautusprosessin turvallisuutta törmäyskestävyyden suhteen. Lisäksi, vaikka SHA256 olisi ollut haavoittuvainen tällaiselle hyökkäykselle, sillä ei olisi ollut vakavaa vaikutusta, koska kaikki hajautusfunktioiden käyttötapaukset Bitcoinissa liittyvät julkisiin tietoihin. Kuitenkin pituuden laajennushyökkäys saattaisi olla hyödyllinen hyökkääjälle vain, jos hajautetut tiedot ovat yksityisiä ja käyttäjä on käyttänyt hajautusfunktiota näiden tietojen autentikointimekanismina, samankaltaisesti kuin MAC. Näin ollen kaksinkertaisen hajautuksen toteutus pysyy mysteerinä Bitcoinin suunnittelussa. Nyt kun olemme tarkastelleet yksityiskohtaisesti hajautusfunktioiden toimintaa, erityisesti SHA256, jota käytetään laajalti Bitcoinissa, keskitymme erityisesti sovellustason kryptografisiin johdannaisalgoritmeihin, erityisesti avainten johdattamiseen lompakkoosi. ## Johdannaisalgoritmien käyttö <chapterId>cc668121-7789-5e99-bf5e-1ba085f4f5f2</chapterId> Bitcoinissa sovellustasolla, hajautusfunktioiden lisäksi, käytetään kryptografisia johdannaisalgoritmeja turvallisten tietojen tuottamiseen alkuperäisistä syötteistä. Vaikka nämä algoritmit nojaavat hajautusfunktioihin, ne palvelevat eri tarkoituksia, erityisesti autentikoinnin ja avainten tuottamisen suhteen. Nämä algoritmit säilyttävät joitakin hajautusfunktioiden ominaisuuksia, kuten peruuttamattomuuden, manipuloinnin vastustuskyvyn ja törmäyskestävyyden. Bitcoin-lompakoissa käytetään pääasiassa kahta johdannaisalgoritmia: - **HMAC (_Hash-based Message Authentication Code_)** - **PBKDF2 (_Password-Based Key Derivation Function 2_)** Tutkimme yhdessä kunkin niiden toimintaa ja roolia. ### HMAC-SHA512 HMAC on kryptografinen algoritmi, joka laskee autentikointikoodin perustuen hajautusfunktion ja salaisen avaimen yhdistelmään. Bitcoin käyttää HMAC-SHA512, HMAC:n varianttia, joka käyttää SHA512 hajautusfunktiota. Olemme jo nähneet edellisessä luvussa, että SHA512 kuuluu samaan hajautusfunktioiden perheeseen kuin SHA256, mutta se tuottaa 512-bittisen tulosteen. Tässä on sen yleinen toimintakaava, jossa $m$ on syötteenä oleva viesti ja $K$ salainen avain: ![CYP201](/courses/cyp201/assets/fr/011.webp) Tutkitaan tarkemmin, mitä tapahtuu tässä HMAC-SHA512 mustassa laatikossa. HMAC-SHA512 toiminto: - $m$: käyttäjän valitsema mielivaltainen kokoinen viesti (ensimmäinen syöte); - $K$: käyttäjän valitsema mielivaltainen salainen avain (toinen syöte); - $K'$: avain $K$ sopeutettuna hajautusfunktion lohkojen kokoon $B$ (1024 bittiä SHA512:lle, eli 128 tavua); - $\text{SHA512}$: SHA512 hajautusfunktio; - $\oplus$: XOR (yksinomainen tai) operaatio; - $\Vert$: yhdistämisoperaattori, joka liittää bittijonot peräkkäin; - $\text{opad}$: vakio, joka koostuu toistuvasta tavusta $0x5c$ 128 kertaa - $\text{ipad}$: vakio, joka koostuu toistuvasta tavusta $0x36$ 128 kertaa Ennen HMAC:n laskemista on tarpeen tasapainottaa avain ja vakiot lohkokoon $B$ mukaisesti. Esimerkiksi, jos avain $K$ on lyhyempi kuin 128 tavua, sitä täydennetään nollilla, kunnes saavutetaan koko $B$. Jos $K$ on pidempi kuin 128 tavua, se tiivistetään käyttäen SHA512:ta, ja sitten siihen lisätään nollia, kunnes saavutetaan 128 tavua. Näin saadaan tasapainotettu avain nimeltä $K'$. Arvot $\text{opad}$ ja $\text{ipad}$ saadaan toistamalla niiden perustavu ($0x5c$ $\text{opad}$:lle, $0x36$ $\text{ipad}$:lle) kunnes saavutetaan koko $B$. Näin ollen, kun $B = 128$ tavua, meillä on:$

\text{opad} = \underbrace{0x5c5c\ldots5c}_{128 , \text{tavua}}

 $Kun esikäsittely on tehty, HMAC-SHA512-algoritmi määritellään seuraavalla yhtälöllä:$

\text {HMAC-SHA512}_K(m) = \text{SHA512} \left( (K' \oplus \text{opad}) \parallel \text{SHA512} \left( (K' \oplus \text{ipad}) \parallel m \right) \right)

 $Tämä yhtälö jaetaan seuraaviin vaiheisiin: - XORaa tasapainotettu avain $K'$ $\text{ipad}$:n kanssa saadaksesi $\text{iKpad}$; - XORaa tasapainotettu avain $K'$ $\text{opad}$:n kanssa saadaksesi $\text{oKpad}$; - Yhdistä $\text{iKpad}$ viestin $m$ kanssa. - Hashaa tämä tulos SHA512:lla saadaksesi välituloksen $H_1$. - Yhdistä $\text{oKpad}$ $H_1$:n kanssa. - Hashaa tämä tulos SHA512:lla saadaksesi lopputuloksen $H_2$. Nämä vaiheet voidaan tiivistää kaaviona seuraavasti: ![CYP201](/courses/cyp201/assets/fr/012.webp) HMAC:ia käytetään erityisesti Bitcoinissa avainjohdannassa HD (Hierarkkisesti Deterministisissä) lompakoissa (josta puhumme tarkemmin tulevissa luvuissa) ja PBKDF2:n osana. ### PBKDF2 PBKDF2 (_Password-Based Key Derivation Function 2_) on avainjohdantoalgoritmi, joka on suunniteltu parantamaan salasanojen turvallisuutta. Algoritmi soveltaa pseudo-satunnaistoimintoa (tässä HMAC-SHA512) salasanaan ja kryptografiseen suolaan, ja toistaa tämän operaation tietyn määrän kertoja tuottaakseen tulosteavaimen. Bitcoinissa PBKDF2:ta käytetään HD-lompakon siemenen generoimiseen mnemonisesta fraasista ja salasanasta (mutta puhumme tästä tarkemmin tulevissa luvuissa). PBKDF2-prosessi on seuraava, jossa: - $m$: käyttäjän mnemoninen fraasi; - $s$: valinnainen salasana turvallisuuden lisäämiseksi (tyhjä kenttä, jos salasanaa ei ole); - $n$: funktion toistojen määrä, meidän tapauksessamme se on 2048. PBKDF2-funktio määritellään iteratiivisesti. Jokainen iteraatio ottaa edellisen tuloksen, syöttää sen HMAC-SHA512:n läpi ja yhdistää peräkkäiset tulokset tuottaakseen lopullisen avaimen:$

\text{PBKDF2}(m, s) = \text{HMAC-SHA512}^{2048}(m, s)

y^2 = x^3 + ax + b

 $### secp256k1 ECDSA:n tai Schnorrin käyttämiseksi on valittava elliptisen käyrän parametrit, eli arvot $a$ ja $b$ käyräyhtälössä. On olemassa erilaisia elliptisten käyrien standardeja, jotka ovat maineikkaita kryptografisesti turvallisina. Tunnetuin on _secp256r1_-käyrä, jonka on määritellyt ja suositellut NIST (_National Institute of Standards and Technology_). Huolimatta tästä, Bitcoinin keksijä Satoshi Nakamoto päätti olla käyttämättä tätä käyrää. Tämän valinnan syy on tuntematon, mutta jotkut uskovat hänen halunneen löytää vaihtoehdon, koska tämän käyrän parametrit saattaisivat sisältää takaportin. Sen sijaan Bitcoin-protokolla käyttää standardia **_secp256k1_**-käyrää. Tämä käyrä on määritelty parametreilla $a = 0$ ja $b = 7$. Sen yhtälö on siis:$

y^2 = x^3 + 7

 $Sen graafinen esitys reaalilukujen kentässä näyttää tältä: ![CYP201](/courses/cyp201/assets/fr/015.webp) Kuitenkin kryptografiassa työskentelemme äärellisten lukujen joukkojen kanssa. Tarkemmin sanottuna työskentelemme äärellisellä kentällä $\mathbb{F}_p$, joka on kokonaislukujen kenttä modulo alkuluku $p$. **Määritelmä**: Alkuluku on luonnollinen kokonaisluku, joka on suurempi tai yhtä suuri kuin 2 ja jolla on vain kaksi erillistä positiivista kokonaislukujakajaa: 1 ja se itse. Esimerkiksi luku 7 on alkuluku, koska sen voi jakaa vain 1:llä ja 7:llä. Toisaalta luku 8 ei ole alkuluku, koska sen voi jakaa 1:llä, 2:lla, 4:llä ja 8:lla. Bitcoinissa käytetty alkuluku $p$ määrittelemään äärellinen kenttä on erittäin suuri. Se on valittu siten, että kentän järjestys (eli elementtien määrä $\mathbb{F}_p$:ssä) on riittävän suuri varmistamaan kryptografisen turvallisuuden. Käytetty alkuluku $p$ on: ```text p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F ``` Desimaalinotaatiossa tämä vastaa:$

p = 2^{256} - 2^{32} - 977

 $Näin ollen elliptisen käyrämme yhtälö on itse asiassa:$

y^2 \equiv x^3 + 7 \mod p

 $Koska tämä käyrä on määritelty äärellisellä kentällä $\mathbb{F}_p$, se ei enää muistuta jatkuvaa käyrää vaan pikemminkin diskreettien pisteiden joukkoa. Esimerkiksi tässä on miltä Bitcoinissa käytetty käyrä näyttää erittäin pienellä $p = 17$: ![CYP201](/courses/cyp201/assets/fr/016.webp) Tässä esimerkissä olen tarkoituksella rajoittanut äärellisen kentän $p = 17$:ään koulutuksellisista syistä, mutta on kuviteltava, että Bitcoinissa käytetty on valtavasti suurempi, lähes $2^{256}$. Käytämme äärellistä kokonaislukujen modulo $p$ kenttää varmistaaksemme käyrällä suoritettavien toimintojen tarkkuuden. Todellakin, elliptiset käyrät reaalilukujen kentässä ovat alttiita epätarkkuuksille pyöristysvirheiden vuoksi laskennallisten laskelmien aikana. Jos käyrällä suoritetaan lukuisia toimintoja, nämä virheet kasaantuvat ja lopputulos voi olla virheellinen tai vaikea toistaa. Positiivisten kokonaislukujen yksinomainen käyttö varmistaa laskelmien täydellisen tarkkuuden ja siten tuloksen toistettavuuden. Elliptisten käyrien matematiikka äärellisillä kentillä on analoginen reaalilukujen kentän matematiikan kanssa, sopeutuksella, että kaikki toiminnot suoritetaan modulo $p$. Selitysten yksinkertaistamiseksi jatkamme seuraavissa luvuissa käsitteiden havainnollistamista käyrällä, joka on määritelty reaalilukujen yli, pitäen mielessä, että käytännössä käyrä on määritelty äärellisellä kentällä. Jos haluat oppia lisää modernin kryptografian matemaattisista perusteista, suosittelen myös tutustumaan tähän toiseen kurssiin Plan ₿ Networkissa: https://planb.network/courses/d2fd9fc0-d9ed-4a87-9fa3-0fdbb3937e28 ## Julkisen avaimen laskeminen yksityisavaimesta <chapterId>fcb2bd58-5dda-5ecf-bb8f-ad1a0561ab4a</chapterId> Kuten aiemmin nähtiin, Bitcoinin digitaalisen allekirjoituksen algoritmit perustuvat matemaattisesti yhteydessä olevaan yksityisen ja julkisen avaimen pariin. Tutkitaan yhdessä, mikä tämä matemaattinen yhteys on ja miten ne luodaan. ### Yksityinen avain Yksityinen avain on yksinkertaisesti satunnainen tai pseudosatunnainen numero. Bitcoinin tapauksessa tämä numero on 256 bittiä suuruinen. Bitcoinin yksityisen avaimen mahdollisuuksien määrä on siis teoreettisesti $2^{256}$. **Huomio**: "Pseudosatunnaisluku" on luku, jolla on ominaisuuksia, jotka ovat lähellä todellisen satunnaisluvun ominaisuuksia, mutta se on tuotettu deterministisellä algoritmilla. Käytännössä elliptisellä käyrällämme secp256k1 on kuitenkin vain $n$ erillistä pistettä, missä $n$ on käyrän generaattoripisteen $G$ järjestys. Näemme myöhemmin, mitä tämä luku vastaa, mutta muista yksinkertaisesti, että kelvollinen yksityisavain on kokonaisluku välillä $1$ ja $n-1$, tietäen, että $n$ on luku, joka on lähellä mutta hieman pienempi kuin $2^{256}$. Siksi on olemassa joitakin 256-bittisiä lukuja, jotka eivät kelpaa Bitcoinin yksityisavaimiksi, erityisesti kaikki luvut välillä $n$ ja $2^{256}$. Jos satunnaisluvun (yksityisavain) tuottaminen tuottaa arvon $k$ siten, että $k \geq n$, se katsotaan kelvottomaksi, ja uusi satunnaisarvo on tuotettava. Bitcoinin yksityisavaimen mahdollisuuksien määrä on siis noin $n$, mikä on luku lähellä $1.158 \times 10^{77}$. Tämä luku on niin suuri, että jos valitset yksityisavaimen satunnaisesti, on tilastollisesti lähes mahdotonta päätyä toisen käyttäjän yksityisavaimelle. Antaaksesi käsityksen mittakaavasta, Bitcoinin mahdollisten yksityisavainten määrä on suuruusluokkaa lähellä arvioitujen atomien määrää havaittavissa olevassa universumissa. Kuten tulevissa luvuissa näemme, nykyään suurin osa Bitcoinissa käytetyistä yksityisavaimista ei ole satunnaisesti generoituja, vaan ne ovat deterministisen johdannaisen tulosta mnemonisesta fraasista, joka itsessään on pseudosatunnainen (tämä on kuuluisa 12 tai 24 sanan fraasi). Tämä tieto ei muuta mitään ECDSA:n kaltaisten allekirjoitusalgoritmien käytössä, mutta auttaa keskittämään popularisointimme Bitcoinin ympärille. Jatkossa yksityisavain merkitään pienellä kirjaimella $k$. ### Julkinen avain Julkinen avain on piste elliptisellä käyrällä, joka on merkitty isolla kirjaimella $K$, ja se lasketaan yksityisavaimesta $k$. Tämä piste $K$ esitetään koordinaattiparina $(x, y)$ elliptisellä käyrällä, kumpikin koordinaatti on kokonaisluku modulo $p$, alkuluku, joka määrittelee äärellisen kentän $\mathbb{F}_p$. Käytännössä pakkaamaton julkinen avain esitetään 512 bitillä (tai 64 tavulla), mikä vastaa kahta 256-bittistä lukua ($x$ ja $y$) peräkkäin. Nämä luvut ovat pisteen $K$ koordinaatit secp256k1-käyrällä. Lisäämällä etuliite, julkisen avaimen kokonaispituus on 520 bittiä. On kuitenkin myös mahdollista esittää julkinen avain pakatussa muodossa käyttäen vain 33 tavua (264 bittiä) säilyttämällä vain käyrän pisteen $x$-koordinaatin ja tavun, joka ilmaisee $y$:n parillisuuden. Tätä kutsutaan pakatuksi julkiseksi avaimiksi. Puhun tästä enemmän koulutuksen viimeisissä luvuissa. Mutta mitä sinun tarvitsee muistaa, on että julkinen avain $K$ on piste, jota kuvaavat $x$ ja $y$. Laskeaksemme pisteen $K$, joka vastaa julkista avaintamme, käytämme skalaarikertolaskua elliptisillä käyrillä, joka määritellään toistuvana lisäyksenä ($k$ kertaa) generaattoripisteestä $G$:$

K = k \cdot G

 $missä: - $k$ on yksityisavain (satunnainen kokonaisluku välillä $1$ ja $n-1$); - $G$ on elliptisen käyrän generaattoripiste, jota kaikki Bitcoin-verkon osallistujat käyttävät; - $\cdot$ edustaa skalaarikertolaskua elliptisellä käyrällä, mikä vastaa pisteen $G$ lisäämistä itseensä $k$ kertaa. Se, että tämä piste $G$ on yhteinen kaikille Bitcoinin julkisille avaimille, mahdollistaa meidän olla varmoja, että sama yksityinen avain $k$ antaa aina saman julkisen avaimen $K$: ![CYP201](/courses/cyp201/assets/fr/017.webp) Tämän toiminnon pääominaisuus on, että se on yksisuuntainen funktio. Julkisen avaimen $K$ laskeminen on helppoa tietäen yksityisen avaimen $k$ ja generaattoripisteen $G$, mutta yksityisen avaimen $k$ laskeminen tietäen vain julkisen avaimen $K$ ja generaattoripisteen $G$ on käytännössä mahdotonta. $k$:n löytäminen $K$:sta ja $G$:stä tarkoittaa elliptisten käyrien diskreetin logaritmin ongelman ratkaisemista, matemaattisesti vaikeaa ongelmaa, jolle ei tunneta tehokasta algoritmia. Edes tehokkaimmat nykyiset laskimet eivät pysty ratkaisemaan tätä ongelmaa kohtuullisessa ajassa. ![CYP201](/courses/cyp201/assets/fr/018.webp) ### Pisteiden yhteenlasku ja kaksinkertaistaminen elliptisillä käyrillä Elliptisten käyrien yhteenlaskun käsite määritellään geometrisesti. Jos meillä on kaksi pistettä $P$ ja $Q$ käyrällä, operaatio $P + Q$ lasketaan piirtämällä viiva, joka kulkee $P$:n ja $Q$:n kautta. Tämä viiva leikkaa käyrän kolmannessa pisteessä $R'$. Otamme sitten tämän pisteen peilikuvan x-akselin suhteen saadaksemme pisteen $R$, joka on yhteenlaskun tulos:$

P + Q = R

 $Graafisesti tämä voidaan esittää seuraavasti: ![CYP201](/courses/cyp201/assets/fr/019.webp) Pisteen kaksinkertaistamisessa, eli operaatio $P + P$, piirrämme tangentin käyrälle pisteen $P$ kohdalla. Tämä tangentti leikkaa käyrän toisessa pisteessä $S'$. Otamme sitten tämän pisteen peilikuvan x-akselin suhteen saadaksemme pisteen $S$, joka on kaksinkertaistamisen tulos:$

2P = S

 $Graafisesti tämä näytetään seuraavasti: ![CYP201](/courses/cyp201/assets/fr/020.webp) Käyttämällä näitä yhteenlaskun ja kaksinkertaistamisen operaatioita, voimme suorittaa pisteen skalaarikertolaskun kokonaisluvulla $k$, merkitty $kP$, suorittamalla toistuvia kaksinkertaistamisia ja yhteenlaskuja. Esimerkiksi, oletetaan että olemme valinneet yksityisen avaimen $k = 4$. Laskeaksemme siihen liittyvän julkisen avaimen, suoritamme:$

K = k \cdot G = 4G

 $Graafisesti tämä vastaa sarjan yhteenlaskuja ja kaksinkertaistamisia suorittamista: - Laske $2G$ kaksinkertaistamalla $G$. - Laske $4G$ kaksinkertaistamalla $2G$. ![CYP201](/courses/cyp201/assets/fr/021.webp) Jos haluamme esimerkiksi laskea pisteen $3G$, meidän on ensin laskettava piste $2G$ kaksinkertaistamalla piste $G$, sitten lisättävä $G$ ja $2G$. Lisätäksemme $G$ ja $2G$, piirrämme yksinkertaisesti viivan yhdistämään nämä kaksi pistettä, haemme yksilöllisen pisteen $-3G$ leikkauspisteestä tämän viivan ja elliptisen käyrän välillä, ja määritämme sitten $3G$ olevan $-3G$:n vastakohta. Meillä on:$

G + G = 2G

2G + G = 3G

 $Graafisesti tämä esitettäisiin seuraavasti: ![CYP201](/courses/cyp201/assets/fr/022.webp) ### Yksisuuntainen Funktio Näiden toimintojen ansiosta voimme ymmärtää, miksi julkisen avaimen johtaminen yksityisestä avaimesta on helppoa, mutta päinvastainen on käytännössä mahdotonta. Palataanpa yksinkertaistettuun esimerkkiimme. Yksityisellä avaimella $k = 4$. Laskiaksemme siihen liittyvän julkisen avaimen, suoritamme:$

K = k \cdot G = 4G

 $Olemme siis pystyneet helposti laskemaan julkisen avaimen $K$ tietäen $k$:n ja $G$:n. Nyt, jos joku tietää vain julkisen avaimen $K$, hän kohtaa diskreetin logaritmin ongelman: löytää $k$ siten, että $K = k \cdot G$. Tätä ongelmaa pidetään vaikeana, koska elliptisille käyrille ei ole olemassa tehokasta algoritmia sen ratkaisemiseksi. Tämä takaa ECDSA- ja Schnorr-algoritmien turvallisuuden. Tietenkin tässä yksinkertaistetussa esimerkissä, jossa $k = 4$, olisi mahdollista löytää $k$ kokeilemalla, koska mahdollisuuksien määrä on pieni. Käytännössä Bitcoinissa $k$ on kuitenkin 256-bittinen kokonaisluku, mikä tekee mahdollisuuksien määrästä astronomisen suuren (noin $1.158 \times 10^{77}$). Siksi $k$:n löytäminen brute force -menetelmällä on käytännössä mahdotonta. ## Allekirjoittaminen yksityisellä avaimella <chapterId>bb07826f-826e-5905-b307-3d82001fb778</chapterId> Nyt kun tiedät, miten johdetaan julkinen avain yksityisestä avaimesta, voit jo vastaanottaa bitcoineja käyttämällä tätä avainparia kulutusehtona. Mutta miten ne kulutetaan? Bitcoinien kuluttamiseksi sinun on avattava _scriptPubKey_, joka on liitetty UTXO:hosi todistaaksesi, että olet sen laillinen omistaja. Tämän tekemiseksi sinun on tuotettava allekirjoitus $s$, joka vastaa _scriptPubKey_:ssä olevaa julkista avainta $K$ käyttäen yksityistä avainta $k$, jota alun perin käytettiin $K$:n laskemiseen. Digitaalinen allekirjoitus on näin ollen kiistaton todiste siitä, että hallussasi on yksityinen avain, joka liittyy väittämääsi julkiseen avimeen. ### Elliptisen Käyrän Parametrit Digitaalisen allekirjoituksen suorittamiseksi kaikkien osallistujien on ensin sovittava käytetyn elliptisen käyrän parametreista. Bitcoinin tapauksessa **secp256k1**-parametrit ovat seuraavat: Äärellinen kenttä $\mathbb{Z}_p$ määritellään:$

p = 2^{256} - 2^{32} - 977

 $```text p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F ``` $p$ on hyvin suuri alkuluku hieman pienempi kuin $2^{256}$. Elliptinen käyrä $y^2 = x^3 + ax + b$ yli $\mathbb{Z}_p$ määritellään:$

a = 0, \quad b = 7

 $Generaattoripiste tai alkuperäispiste $G$: ```text G = 0x0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798 ``` Tämä numero on tiivistetty muoto, joka antaa vain pisteen $G$ abskissan. Alkupääte `02` alussa määrittää, kumpaa kahdesta arvosta, joilla on tämä abskissa $x$, käytetään generaattoripisteenä. $G$:n järjestys $n$ (olemassa olevien pisteiden määrä) ja kofaktori $h$: ```text n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 ``` $n$ on erittäin suuri luku, joka on hieman pienempi kuin $p$.$

h=1

 $$h$ on kofaktori eli aliryhmien määrä. En käsittele tässä, mitä tämä tarkoittaa, koska se on melko monimutkaista, ja Bitcoinin tapauksessa meidän ei tarvitse ottaa sitä huomioon, koska se on yhtä suuri kuin $1$. Kaikki tämä tieto on julkista ja kaikkien osallistujien tiedossa. Kiitos heidän, käyttäjät pystyvät tekemään digitaalisen allekirjoituksen ja varmentamaan sen. ### Allekirjoitus ECDSA:n avulla ECDSA-algoritmi mahdollistaa käyttäjän viestin allekirjoittamisen heidän yksityisellä avaimellaan siten, että kuka tahansa, joka tietää vastaavan julkisen avaimen, voi varmistaa allekirjoituksen pätevyyden ilman, että yksityinen avain paljastuu. Bitcoinin kontekstissa allekirjoitettava viesti riippuu käyttäjän valitsemasta _sighashista_. Juuri tämä _sighash_ määrittää, mitkä transaktion osat kattaa allekirjoitus. Käsittelen tätä tarkemmin seuraavassa luvussa. Tässä ovat askeleet ECDSA-allekirjoituksen luomiseen: Ensiksi laskemme viestin, joka tarvitsee allekirjoittaa, hashin ($e$). Viesti $m$ siis kulkee kryptografisen hash-funktion läpi, yleensä SHA256 tai kaksinkertainen SHA256 Bitcoinin tapauksessa:$

e = \text{HASH}(m)

 $Seuraavaksi laskemme nonce-arvon. Kryptografiassa nonce on yksinkertaisesti satunnaisesti tai pseudo-satunnaisesti generoitu numero, jota käytetään vain kerran. Toisin sanoen, joka kerta kun uusi digitaalinen allekirjoitus tehdään tällä avainparilla, on erittäin tärkeää käyttää eri noncea, muuten se vaarantaa yksityisen avaimen turvallisuuden. Riittää siis määrittää satunnainen ja uniikki kokonaisluku $r$ siten, että $1 \leq r \leq n-1$, missä $n$ on elliptisen käyrän generoivapisteen $G$ järjestys. Sitten laskemme pisteen $R$ elliptisellä käyrällä koordinaateilla $(x_R, y_R)$ siten, että:$

R = r \cdot G

 $Poimimme pisteen $R$ abskissin arvon ($x_R$). Tämä arvo edustaa allekirjoituksen ensimmäistä osaa. Ja lopuksi laskemme allekirjoituksen toisen osan $s$ seuraavalla tavalla:$

s = r^{-1} \left( e + k \cdot x_R \right) \mod n

 $missä: - $r^{-1}$ on $r$:n modulaarinen käänteisluku modulo $n$, eli kokonaisluku siten, että $r \cdot r^{-1} \equiv 1 \mod n$; - $k$ on käyttäjän yksityinen avain; - $e$ on viestin hash; - $n$ on elliptisen käyrän generoivapisteen $G$ järjestys. Allekirjoitus on sitten yksinkertaisesti $x_R$ ja $s$ yhdistelmä:$

\text{SIG} = x_R \Vert s

 $### ECDSA-allekirjoituksen varmentaminen Allekirjoituksen $(x_R, s)$ varmentamiseksi kuka tahansa, joka tietää julkisen avaimen $K$ ja elliptisen käyrän parametrit, voi edetä seuraavasti: Ensin varmista, että $x_R$ ja $s$ ovat välillä $[1, n-1]$. Tämä varmistaa, että allekirjoitus noudattaa elliptisen ryhmän matemaattisia rajoitteita. Jos näin ei ole, tarkastaja hylkää välittömästi allekirjoituksen epäkelpoisena. Sen jälkeen laske viestin hajautusarvo:$

e = \text{HASH}(m)

 $Laske $s$:n modulaarinen käänteisluku modulo $n$:$

s^{-1} \mod n

 $Laske kaksi skalaariarvoa $u_1$ ja $u_2$ seuraavalla tavalla:$

\begin{align*} u_1 &= e \cdot s^{-1} \mod n \ u_2 &= x_R \cdot s^{-1} \mod n \end{align*}

 $Ja lopuksi laske piste $V$ elliptisellä käyrällä siten, että:$

V = u_1 \cdot G + u_2 \cdot K

 $Allekirjoitus on pätevä vain, jos $x_V \equiv x_R \mod n$, missä $x_V$ on pisteen $V$ $x$-koordinaatti. Todellakin, yhdistämällä $u_1 \cdot G$ ja $u_2 \cdot K$, saadaan piste $V$, joka, jos allekirjoitus on pätevä, täytyy vastata allekirjoituksen aikana käytettyä pistettä $R$ (modulo $n$). ### Allekirjoitus Schnorr-protokollalla Schnorrin allekirjoitusjärjestelmä on vaihtoehto ECDSA:lle, joka tarjoaa monia etuja. Sitä on voinut käyttää Bitcoinissa vuodesta 2021 lähtien ja Taprootin esittelyn myötä, P2TR-skriptimallien kanssa. Kuten ECDSA:ssa, Schnorrin järjestelmä mahdollistaa viestin allekirjoittamisen yksityisellä avaimella siten, että allekirjoituksen voi varmentaa kuka tahansa, joka tuntee vastaavan julkisen avaimen. Schnorrin tapauksessa käytetään täsmälleen samaa käyrää kuin ECDSA:ssa samoilla parametreilla. Julkiset avaimet kuitenkin esitetään hieman eri tavalla verrattuna ECDSA:han. Todellakin, ne on merkitty vain pisteen elliptisellä käyrällä $x$-koordinaatilla. Toisin kuin ECDSA:ssa, jossa tiivistetyt julkiset avaimet esitetään 33 tavulla (etuliitteen tavun osoittaessa $y$:n pariteetin), Schnorr käyttää 32 tavun julkisia avaimia, jotka vastaavat vain pisteen $K$ $x$-koordinaattia, ja oletetaan, että $y$ on oletusarvoisesti parillinen. Tämä yksinkertaistettu esitys pienentää allekirjoitusten kokoa ja helpottaa tiettyjä optimointeja varmennusalgoritmeissa. Julkinen avain on sitten pisteen $K$ $x$-koordinaatti:$

\text{pk} = K_x

 $Ensimmäinen askel allekirjoituksen luomiseksi on viestin hajauttaminen. Mutta toisin kuin ECDSA:ssa, se tehdään muiden arvojen kanssa ja käytetään merkittyä hajautusfunktiota välttääkseen törmäykset eri konteksteissa. Merkitty hajautusfunktio yksinkertaisesti sisältää satunnaisen merkinnän lisäämisen hajautusfunktion syötteisiin viestidatan ohella. ![CYP201](/courses/cyp201/assets/fr/023.webp) Viestin lisäksi hajautusfunktioon syötetään myös julkisen avaimen $K_x$ $x$-koordinaatti sekä piste $R$, joka on laskettu nousesta $r$ ($R=r \cdot G$), joka on itsessään uniikki kokonaisluku kullekin allekirjoitukselle, laskettu deterministisesti yksityisestä avaimesta ja viestistä välttääkseen haavoittuvuuksia, jotka liittyvät nouseen uudelleenkäyttöön. Kuten julkiselle avaimelle, vain nousepisteen $R_x$ $x$-koordinaatti säilytetään kuvaamaan pistettä. Tämän hajautuksen tulos, jota kutsutaan "haasteeksi":$

e = \text{HASH}(\text{``BIP0340/haaste''}, R_x \Vert K_x \Vert m) \mod n

 $Tässä $\text{HASH}$ on SHA256-tiivistefunktio, ja $\text{``BIP0340/haaste''}$ on tiivistämisen erityinen tagi. Lopuksi parametri $s$ lasketaan seuraavalla tavalla yksityisestä avaimesta $k$, nonce-arvosta $r$ ja haasteesta $e$:$

s = (r + e \cdot k) \mod n

 $Allekirjoitus on sitten yksinkertaisesti pari $Rx$ ja $s$.$

\text{SIG} = R_x \Vert s

 $### Schnorr-allekirjoituksen varmentaminen Schnorr-allekirjoituksen varmentaminen on yksinkertaisempaa kuin ECDSA-allekirjoituksen varmentaminen. Tässä ovat askeleet allekirjoituksen $(R_x, s)$ varmentamiseksi julkisella avaimella $K_x$ ja viestillä $m$: Ensiksi varmistamme, että $K_x$ on kelvollinen kokonaisluku ja pienempi kuin $p$. Jos näin on, haemme vastaavan pisteen käyrältä, jossa $K_y$ on parillinen. Erotaamme myös $R_x$ ja $s$ erilleen allekirjoituksesta $\text{SIG}$. Sitten tarkistamme, että $R_x < p$ ja $s < n$ (käyrän järjestys). Seuraavaksi laskemme haasteen $e$ samalla tavalla kuin allekirjoituksen antaja:$

e = \text{HASH}(\text{``BIP0340/haaste''}, R_x \Vert K_x \Vert m) \mod n

 $Sitten laskemme viitepisteen käyrällä tällä tavalla:$

R' = s \cdot G - e \cdot K

 $Lopuksi varmistamme, että $R'_x = R_x$. Jos kaksi x-koordinaattia täsmäävät, allekirjoitus $(R_x, s)$ on todellakin kelvollinen julkisella avaimella $K_x$. ### Miksi tämä toimii? Allekirjoittaja on laskenut $s = r + e \cdot k \mod n$, joten $R' = s \cdot G - e \cdot K$ pitäisi olla yhtä suuri kuin alkuperäinen piste $R$, koska:$

s \cdot G = (r + e \cdot k) \cdot G = r \cdot G + e \cdot k \cdot G

 $Koska $K = k \cdot G$, meillä on $e \cdot k \cdot G = e \cdot K$. Siis:$

R' = r \cdot G = R

 $Näin ollen meillä on:$

R'_x = R_x

\text{CS} = \frac{\text{ENT}}{32}

 $missä $\text{ENT}$ edustaa entropian pituutta biteissä, ja $\text{CS}$ tarkistussumman pituutta biteissä. Esimerkiksi 256-bittiselle entropialle otetaan hajautuksen ensimmäiset 8 bittiä muodostamaan tarkistussumma:$

\text{CS} = \frac{256}{32} = 8 \text{ bittiä}

 $Kun tarkistussumma on laskettu, se yhdistetään entropian kanssa saadakseen laajennetun bittijonon merkittynä $\text{ENT} \Vert \text{CS}$ ("yhdistäminen" tarkoittaa peräkkäin asettamista). ![CYP201](/courses/cyp201/assets/fr/036.webp) ### Vastaavuus Entropian ja Mnemonisen Lauseen Välillä Mnemonisen lauseen sanojen määrä riippuu alkuperäisen entropian koosta, kuten seuraavassa taulukossa on esitetty: - $\text{ENT}$: entropian koko biteissä; - $\text{CS}$: tarkistussumman koko biteissä; - $w$: lopullisen mnemonisen lauseen sanojen määrä.$

\begin{array}{|c|c|c|c|} \hline \text{ENT} & \text{CS} & \text{ENT} \Vert \text{CS} & w \ \hline 128 & 4 & 132 & 12 \ 160 & 5 & 165 & 15 \ 192 & 6 & 198 & 18 \ 224 & 7 & 231 & 21 \ 256 & 8 & 264 & 24 \ \hline \end{array}

 $Esimerkiksi 256-bittiselle entropialle tulos $\text{ENT} \Vert \text{CS}$ on 264 bittiä ja tuottaa 24 sanan mnemonisen lauseen. ### Binäärijonon Muuntaminen Mnemoniseksi Lauseeksi Bittijono $\text{ENT} \Vert \text{CS}$ jaetaan sitten 11 bitin segmentteihin. Kukin 11-bittinen segmentti, kun se muunnetaan desimaaliksi, vastaa numeroa välillä 0 ja 2047, joka osoittaa sanan sijainnin [2048 sanan standardoidussa listassa BIP39:n mukaan](https://github.com/Planb-Network/bitcoin-educational-content/blob/dev/resources/bet/bip39-wordlist//courses/cyp201/assets/BIP39-WORDLIST.pdf). ![CYP201](/courses/cyp201/assets/fr/037.webp) Esimerkiksi 128-bittiselle entropialle tarkistussumma on 4 bittiä, ja näin ollen koko sekvenssi on 132 bittiä pitkä. Se jaetaan 12 segmenttiin, joista jokainen on 11 bittiä (oranssit bitit merkitsevät tarkistussummaa): ![CYP201](/courses/cyp201/assets/fr/038.webp) Jokainen segmentti muunnetaan sitten desimaaliluvuksi, joka edustaa sanaa listalla. Esimerkiksi binäärinen segmentti `01011010001` on desimaaliluvussa `721`. Lisäämällä 1 indeksoinnin mukauttamiseksi (joka alkaa 1:stä eikä 0:sta), saadaan sanan järjestysnumero `722`, joka listalla on "*focus*". ![CYP201](/courses/cyp201/assets/fr/039.webp) Tätä vastaavuutta toistetaan jokaiselle 12 segmentille, jotta saadaan 12 sanan lause. ![CYP201](/courses/cyp201/assets/fr/040.webp) ### BIP39-sanalistan ominaisuudet BIP39-sanalistan erityispiirre on, että yksikään sana ei jaa samoja neljää ensimmäistä kirjainta samassa järjestyksessä toisen sanan kanssa. Tämä tarkoittaa, että riittää, kun merkitsee muistiin kunkin sanan ensimmäiset neljä kirjainta, jotta voi tallentaa muistilauseen. Tämä voi olla mielenkiintoista tilan säästämiseksi, erityisesti niille, jotka haluavat kaivertaa sen metallialustaan. Tämä 2048 sanan lista on olemassa useilla kielillä. Nämä eivät ole yksinkertaisia käännöksiä, vaan kullekin kielelle omat sanansa. Kuitenkin on vahvasti suositeltavaa pysyä englanninkielisessä versiossa, koska muiden kielten versiot eivät yleensä ole lompakko-ohjelmistojen tukemia. ### Mikä pituus valita muistilauseellesi? Optimaalisen muistilauseen pituuden määrittämiseksi on otettava huomioon sen tarjoama todellinen turvallisuus. 12 sanan lause takaa 128 bitin turvallisuuden, kun taas 24 sanan lause tarjoaa 256 bitin turvallisuuden. Tämä ero lauseen turvallisuustasossa ei kuitenkaan paranna Bitcoin-lompakon kokonaisturvallisuutta, koska tästä lauseesta johdetut yksityiset avaimet hyötyvät vain 128 bitin turvallisuudesta. Todellakin, kuten aiemmin näimme, Bitcoinin yksityiset avaimet luodaan satunnaisista numeroista (tai johdetaan satunnaisesta lähteestä) välillä $1$ ja $n-1$, missä $n$ edustaa secp256k1-käyrän generaattoripisteen $G$ järjestystä, lukua hieman alle $2^{256}$. Voisi siis ajatella, että nämä yksityiset avaimet tarjoavat 256 bitin turvallisuuden. Kuitenkin niiden turvallisuus perustuu yksityisen avaimen löytämisen vaikeuteen sen liitetystä julkisesta avaimesta, vaikeuteen, joka on perustettu elliptisten käyrien diskreetin logaritmin matemaattiseen ongelmaan (*ECDLP*). Tähän mennessä parhaiten tunnettu algoritmi tämän ongelman ratkaisemiseksi on Pollardin rho-algoritmi, joka vähentää tarvittavien operaatioiden määrän avaimen murtamiseksi sen koon neliöjuureen. 256-bittisille avaimille, kuten niille, joita käytetään Bitcoinissa, Pollardin rho-algoritmi vähentää siis monimutkaisuuden $2^{128}$ operaatioon:$

O(\sqrt{2^{256}}) = O(2^{128})

 $Näin ollen katsotaan, että Bitcoinissa käytetty yksityinen avain tarjoaa 128 bitin turvallisuuden. Tuloksena on, että 24 sanan lauseen valitseminen ei tarjoa lisäsuojaa lompakolle, koska 256 bitin turvallisuus lauseessa on hyödytön, jos johdetut avaimet tarjoavat vain 128 bitin turvallisuuden. Tämän periaatteen havainnollistamiseksi, se on kuin talossa olisi kaksi ovea: vanha puuovi ja vahvistettu ovi. Murron sattuessa vahvistettu ovi olisi hyödytön, koska murtovaras menisi puuoven kautta. Tässä on analoginen tilanne. 12-sanainen lause, joka tarjoaa myös 128 bitin turvallisuuden, on siis tällä hetkellä riittävä suojaamaan bitcoinsisi minkä tahansa varkausyrityksen varalta. Niin kauan kuin digitaalisen allekirjoituksen algoritmi ei muutu käyttämään suurempia avaimia tai nojaamaan johonkin muuhun matemaattiseen ongelmaan kuin ECDLP:hen, 24-sanainen lause pysyy tarpeettomana. Lisäksi pidempi lause lisää menetysriskiä varmuuskopioinnin aikana: kaksi kertaa lyhyempi varmuuskopio on aina helpompi hallita. Jatkaaksesi ja oppiaksesi konkreettisesti, miten manuaalisesti generoida testaamiseen tarkoitettu mnemoninen lause, suosittelen tutustumaan tähän tutoriaaliin: https://planb.network/tutorials/wallet/backup/generate-mnemonic-phrase-47507d90-e6af-4cac-b01b-01a14d7a8228 Ennen kuin jatkamme lompakon johdannaisten luomista tästä mnemonisesta lauseesta, esittelen sinulle seuraavassa luvussa BIP39-salasanan, koska se näyttelee roolia johdannaisprosessissa, ja se on samalla tasolla kuin mnemoninen lause. ## Salasana <chapterId>6a51b397-f3b5-5084-b151-cef94bc9b93f</chapterId> Kuten juuri näimme, HD-lompakot luodaan mnemonisesta lauseesta, joka koostuu tyypillisesti 12 tai 24 sanasta. Tämä lause on erittäin tärkeä, koska se mahdollistaa kaikkien lompakon avainten palauttamisen, jos sen fyysinen laite (kuten laitteistolompakko, esimerkiksi) katoaa. Kuitenkin, se muodostaa yksittäisen vikapisteen, koska jos se vaarantuu, hyökkääjä voisi varastaa kaikki bitcoinsit. Tässä kohtaa BIP39-salasana astuu peliin. ### Mikä on BIP39-salasana? Salasana on valinnainen salasana, jonka voit vapaasti valita, ja joka lisätään mnemoniseen lauseeseen avainten johdannaisprosessissa lompakon turvallisuuden parantamiseksi. Varo, ettei salasanaa sekoiteta laitteistolompakkosi PIN-koodiin tai salasanaan, jota käytetään pääsyn avaamiseen lompakkoosi tietokoneellasi. Toisin kuin kaikki nämä elementit, salasana näyttelee roolia lompakkosi avainten johdannaisessa. **Tämä tarkoittaa, että ilman sitä, et koskaan pysty palauttamaan bitcoinsiasi.** Salasana toimii yhdessä mnemonisen lauseen kanssa, muuttaen siemenen, josta avaimet generoidaan. Näin ollen, vaikka joku saisi 12 tai 24-sanaisen lauseesi, ilman salasanaa, he eivät pääse käsiksi varoihisi. Salasanan käyttö luo käytännössä uuden lompakon erillisillä avaimilla. Salasanan muuttaminen (jopa vähäisesti) generoi erilaisen lompakon. ![CYP201](/courses/cyp201/assets/fr/041.webp) ### Miksi sinun tulisi käyttää salasanaa? Salasana on mielivaltainen ja voi olla käyttäjän valitsema mikä tahansa merkkien yhdistelmä. Salasanan käyttö tarjoaa siis useita etuja. Ensinnäkin, se vähentää kaikki riskit, jotka liittyvät mnemonisen lauseen kompromettoitumiseen vaatimalla toisen tekijän varojen käyttöön pääsemiseksi (murtovarkaus, pääsy kotiisi jne.). Seuraavaksi, sitä voidaan käyttää strategisesti luomaan harhautuslompakko, jotta voidaan kohdata fyysisiä rajoitteita varojen varastamiseksi, kuten kuuluisa "_5 dollarin jakoavainhyökkäys_". Tässä skenaariossa idea on olla lompakko ilman salasanaa, joka sisältää vain pienen määrän bitcoineja, tarpeeksi tyydyttämään mahdollisen hyökkääjän, samalla kun on olemassa piilotettu lompakko. Tämä jälkimmäinen käyttää samaa mnemonista lausetta, mutta on suojattu lisäsalasanalla. Lopuksi, salasanan käyttö on mielenkiintoista, kun halutaan hallita HD-lompakon siemenen generoinnin satunnaisuutta. ### Miten valita hyvä salasana? Jotta salasana olisi tehokas, sen on oltava riittävän pitkä ja satunnainen. Kuten vahvan salasanan kohdalla, suosittelen valitsemaan mahdollisimman pitkän ja satunnaisen salasanan, jossa on kirjainten, numeroiden ja symbolien monimuotoisuutta, jotta mikä tahansa brute force -hyökkäys olisi mahdoton. On myös tärkeää tallentaa tämä salalause oikein, samalla tavalla kuin muistisarja. **Sen menettäminen tarkoittaa pääsyn menettämistä bitcoineihisi**. Vahva suositus on, että et luota pelkästään muistiisi, sillä se lisää kohtuuttomasti menetyksen riskiä. Ihanteellista on kirjoittaa se fyysiselle välineelle (paperille tai metallille) erillään muistisarjasta. Tämä varmuuskopio on ilmeisesti säilytettävä eri paikassa kuin missä muistisarjasi on, jotta molempia ei vaaranneta samanaikaisesti. ![CYP201](/courses/cyp201/assets/fr/042.webp) Seuraavassa osiossa tutustumme, kuinka nämä kaksi lompakkosi peruselementtiä — muistisarja ja salalause — käytetään johdattamaan avainparit, joita käytetään *scriptPubKey*ssa lukitsemaan UTXO:si. # Bitcoin-lompakoiden luominen <partId>9c25e767-7eae-50b8-8c5f-679d8fc83bab</partId> ## Siemenen ja pääavaimen luominen <chapterId>63093760-2010-5691-8d0e-9a04732ae557</chapterId> Kun muistisarja ja valinnainen salalause on luotu, voidaan aloittaa Bitcoin HD -lompakon johdannaisprosessi. Muistisarja muunnetaan ensin siemeneksi, joka muodostaa kaikkien lompakon avainten perustan. ![CYP201](/courses/cyp201/assets/fr/043.webp) ### HD-lompakon siemen BIP39-standardi määrittelee siemenen 512-bittiseksi jonoiksi, joka toimii lähtökohtana kaikkien HD-lompakon avainten johdannaiselle. Siemen johdetaan muistisarjasta ja mahdollisesta salalauseesta käyttäen **PBKDF2**-algoritmia (*Password-Based Key Derivation Function 2*), josta olemme jo keskustelleet luvussa 3.3. Tässä johdannaisfunktiossa käytämme seuraavia parametreja: - $m$ : muistisarja; - $p$ : käyttäjän valitsema valinnainen salalause siemenen turvallisuuden parantamiseksi. Jos salalausetta ei ole, tämä kenttä jätetään tyhjäksi; - $\text{PBKDF2}$ : johdannaisfunktio $\text{HMAC-SHA512}$:lla ja $2048$ iteraatiolla; - $s$: 512-bittinen lompakon siemen. Riippumatta valitusta muistisarjan pituudesta (132 bittiä tai 264 bittiä), PBKDF2-funktio tuottaa aina 512-bittisen tuloksen, ja siemen on siksi aina tämän kokoinen. ### Siemenen johdannaiskaava PBKDF2:lla Seuraava yhtälö havainnollistaa siemenen johdattamista muistisarjasta ja salalauseesta:$

s = \text{PBKDF2}_{\text{HMAC-SHA512}}(m, p, 2048)

 $![CYP201](/courses/cyp201/assets/fr/044.webp) Siemenen arvoon vaikuttavat siis muistisarjan ja salalauseen arvot. Salalauseen vaihtamisella saadaan erilainen siemen. Kuitenkin samalla muistisarjalla ja salalauseella tuotetaan aina sama siemen, koska PBKDF2 on deterministinen funktio. Tämä varmistaa, että samat avainparit voidaan palauttaa varmuuskopioistamme. **Huom:** Yleiskielessä termi "siemen" viittaa usein väärinkäytöllä muistisarjaan. Todellisuudessa, jos salalausetta ei ole, toinen on vain toisen koodaus. Kuten olemme nähneet, lompakoiden teknisessä todellisuudessa siemen ja muistisarja ovat kuitenkin kaksi erillistä elementtiä. Nyt kun meillä on siemenemme, voimme jatkaa Bitcoin-lompakkomme johdannaisen kanssa. ### Mestariavain ja Mestari Ketjukoodi Kun siemen on saatu, seuraava vaihe HD-lompakon johdannassa sisältää mestari yksityisavaimen ja mestari ketjukoodin laskemisen, jotka edustavat lompakon syvyyttä 0. Mestari yksityisavaimen ja mestari ketjukoodin saamiseksi HMAC-SHA512 -funktiota sovelletaan siemeneen, käyttäen kiinteää avainta "*Bitcoin Seed*", joka on identtinen kaikille Bitcoin-käyttäjille. Tämä vakio on valittu varmistamaan, että avainjohdannaiset ovat spesifisiä Bitcoinille. Tässä ovat elementit: - $\text{HMAC-SHA512}$: johdannaisfunktio; - $s$: 512-bittinen lompakon siemen; - $\text{"Bitcoin Seed"}$: yhteinen johdannaisvakio kaikille Bitcoin-lompakoille.$

\text{output} = \text{HMAC-SHA512}(\text{"Bitcoin Seed"}, s)

 $Tämän funktion tuloksena on siis 512 bittiä. Se jaetaan sitten kahteen osaan: - Vasemmat 256 bittiä muodostavat **mestari yksityisavaimen**; - Oikeat 256 bittiä muodostavat **mestari ketjukoodin**. Matemaattisesti nämä kaksi arvoa voidaan merkitä seuraavasti, $k_M$ ollessa mestari yksityisavain ja $C_M$ mestari ketjukoodi:$

k_M = \text{HMAC-SHA512}(\text{"Bitcoin Seed"}, s)_{[:256]}

C_M = \text{HMAC-SHA512}(\text{"Bitcoin Seed"}, s)_{[256:]}

\text{hash} = \text{HMAC-SHA512}(C_{\text{PAR}}, G \cdot k_{\text{PAR}} \Vert i)

 $Tässä laskennassa huomaamme, että HMAC-funktiomme ottaa kaksi syötettä: ensin vanhemman ketjukoodin, ja sitten indeksin yhdistämisen vanhemman yksityiseen avaimen liittyvän julkisen avaimen kanssa. Vanhempaa julkista avainta käytetään tässä, koska haluamme johtaa normaalin lapsiavaimen, ei kovennettua. Nyt meillä on 64-tavuinen $\text{hash}$, jonka jaamme kahteen 32 tavun osaan: $h_1$ ja $h_2$:$

\text{hash} = h_1 \Vert h_2

h_1 = \text{hash}{[:32]} \quad, \quad h_2 = \text{hash}{[32:]}

 $Lapsen yksityinen avain $k_{\text{CHD}}^n$ lasketaan sitten seuraavasti:$

k_{\text{CHD}}^n = \text{parse256}(h_1) + k_{\text{PAR}} \mod n

 $Tässä laskennassa toiminto $\text{parse256}(h_1)$ koostuu ensimmäisen 32 tavun tulkinnasta $\text{hash}$:sta 256-bittisenä kokonaislukuna. Tämä luku lisätään sitten vanhemman yksityisavaimen arvoon, kaikki otetaan modulo $n$ pysyäkseen elliptisen käyrän järjestyksessä, kuten näimme osiossa 3 digitaalisista allekirjoituksista. Näin ollen normaalin lapsen yksityisavaimen johdannaisessa, vaikka vanhemman julkista avainta käytetään laskennan perustana HMAC-SHA512 funktion syötteissä, on aina tarpeen olla vanhemman yksityisavain laskennan viimeistelyä varten. Tästä lapsen yksityisavaimesta on mahdollista johtaa vastaava julkinen avain soveltamalla ECDSA:ta tai Schnorr:ia. Tällä tavoin saamme täydellisen avainparin. Sitten $\text{hash}$:n toinen osa tulkitaan yksinkertaisesti lapsen avainparin ketjukoodiksi, jonka juuri johdimme:$

C_{\text{CHD}} = h_2

 $Tässä on kaavamainen esitys koko johdannaisesta: ![CYP201](/courses/cyp201/assets/fr/050.webp) **Kovennetulle lapsen avaimelle** ($i \geq 2^{31}$), $\text{hash}$:n laskenta on seuraava:$

hash = \text{HMAC-SHA512}(C_{\text{PAR}}, 0x00 \Vert k_{\text{PAR}} \Vert i)

 $Tässä laskennassa huomaamme, että HMAC-funktiomme ottaa kaksi syötettä: ensin, vanhemman ketjukoodin, ja sitten indeksin yhdistämisen vanhemman yksityisavaimen kanssa. Vanhempaa yksityisavainta käytetään tässä, koska pyrimme johtamaan kovennetun lapsen avaimen. Lisäksi avaimen alkuun lisätään tavu, joka on yhtä suuri kuin `0x00`. Tämä toimenpide tasoittaa sen pituuden vastaamaan pakatun julkisen avaimen pituutta. Joten meillä on nyt 64-tavuinen $\text{hash}$, jonka jaamme kahteen 32 tavun osaan: $h_1$ ja $h_2$:$

\text{hash} = h_1 \Vert h_2

h_1 = \text{hash}[:32] \quad, \quad h_2 = \text{hash}[32:]

 $Lapsen yksityisavain $k_{\text{CHD}}^h$ lasketaan sitten seuraavasti:$

k_{\text{CHD}}^h = \text{parse256}(h_1) + k_{\text{PAR}} \mod n

 $Seuraavaksi tulkitaan yksinkertaisesti $\text{hash}$:n toinen osa olevan juuri johdetun lapsen avainparin ketjukoodi:$

C_{\text{CHD}} = h_2

 $Tässä on kaavamainen esitys koko johdannaisesta: ![CYP201](/courses/cyp201/assets/fr/051.webp) Voimme nähdä, että normaali johdannainen ja kovennettu johdannainen toimivat samalla tavalla, tällä erolla: normaali johdannainen käyttää vanhemman julkista avainta syötteenä HMAC-funktioon, kun taas kovennettu johdannainen käyttää vanhemman yksityisavainta. #### Lapsen julkisen avaimen johtaminen vanhemman julkisesta avaimesta Jos tiedämme vain vanhemman julkisen avaimen $K_{\text{PAR}}$ ja siihen liittyvän ketjukoodin $C_{\text{PAR}}$, eli laajennetun julkisen avaimen, on mahdollista johtaa lapsen julkisia avaimia $K_{\text{CHD}}^n$, mutta vain normaaleille (ei-kovennetuille) lapsiavaimille. Tämä periaate mahdollistaa erityisesti Bitcoin-lompakon tilin liikkeiden seuraamisen `xpub` (*vain seuranta*) avulla. Tämän laskennan suorittamiseksi laskemme $\text{hash}$ indeksillä $i < 2^{31}$ (normaali johdannainen):$

\text{hash} = \text{HMAC-SHA512}(C_{\text{PAR}}, K_{\text{PAR}} \Vert i)

 $Tässä laskennassa huomaamme, että HMAC-funktiomme ottaa kaksi syötettä: ensin vanhemman ketjukoodin, sitten indeksin yhdistämisen vanhemman julkisen avaimen kanssa. Joten, meillä on nyt 64 tavun $hash$, jonka jaamme kahteen 32 tavun osaan: $h_1$ ja $h_2$:$

\text{hash} = h_1 \Vert h_2

h_1 = \text{hash}[:32] \quad, \quad h_2 = \text{hash}[32:]

 $Lapsen julkinen avain $K_{\text{CHD}}^n$ lasketaan sitten seuraavasti:$

K_{\text{CHD}}^n = G \cdot \text{parse256}(h_1) + K_{\text{PAR}}

 $Jos $\text{parse256}(h_1) \geq n$ (elliptisen käyrän järjestys) tai jos $K_{\text{CHD}}^n$ on äärettömyyden piste, johdannainen on virheellinen, ja toinen indeksi on valittava. Tässä laskennassa toiminto $\text{parse256}(h_1)$ sisältää ensimmäisen 32 tavun $\text{hash}$ tulkinnan 256-bittiseksi kokonaisluvuksi. Tätä lukua käytetään laskemaan piste elliptisellä käyrällä lisäyksen ja kaksinkertaistamisen kautta generaattoripisteestä $G$. Tämä piste lisätään sitten vanhemman julkiseen avaimen saadakseen normaalin lapsen julkisen avaimen. Näin ollen normaalin lapsen julkisen avaimen johtamiseksi tarvitaan vain vanhemman julkinen avain ja vanhemman ketjukoodi; vanhemman yksityinen avain ei koskaan tule tähän prosessiin, toisin kuin lapsen yksityisen avaimen laskenta, jonka näimme aiemmin. Seuraavaksi lapsen ketjukoodi on yksinkertaisesti:$

C_{\text{CHD}} = h_2

 $Tässä on kaavamainen esitys koko johdannaisesta: ![CYP201](/courses/cyp201/assets/fr/052.webp) ### Vastine lapsen julkisten ja yksityisten avainten välillä Kysymys, joka saattaa nousta esiin, on miten normaali lapsen julkinen avain, joka on johdettu vanhemman julkisesta avaimesta, vastaa normaalia lapsen yksityistä avainta, joka on johdettu vastaavasta vanhemman yksityisestä avaimesta. Tämä linkki varmistetaan nimenomaan elliptisten käyrien ominaisuuksien avulla. Todellakin, normaalin lapsen julkisen avaimen johtamiseksi sovelletaan HMAC-SHA512 samalla tavalla, mutta sen tulosta käytetään eri tavalla: - **Normaali lapsen yksityinen avain**: $k_{\text{CHD}}^n = \text{parse256}(h_1) + k_{\text{PAR}} \mod n$ - **Normaali lapsen julkinen avain**: $K_{\text{CHD}}^n = G \cdot \text{parse256}(h_1) + K_{\text{PAR}}$ Elliptisen käyrän lisäys- ja kaksinkertaistamistoimintojen ansiosta molemmat menetelmät tuottavat johdonmukaisia tuloksia: lapsen yksityisavaimesta johdettu julkinen avain on identtinen suoraan vanhemman julkisesta avaimesta johdetun lapsen julkisen avaimen kanssa. ### Johdannaistyypien yhteenveto Yhteenvetona, tässä ovat erilaiset mahdolliset johdannaistyypit:$

\begin{array}{|c|c|c|c|} \hline \rightarrow & \text{PAR} & \text{CHD} & \text{n/h} \ \hline k_{\text{PAR}} \rightarrow k_{\text{CHD}} & k_{\text{PAR}} & { k_{\text{CHD}}^n, k_{\text{CHD}}^h } & { n, h } \ k_{\text{PAR}} \rightarrow K_{\text{CHD}} & k_{\text{PAR}} & { K_{\text{CHD}}^n, K_{\text{CHD}}^h } & { n, h } \ K_{\text{PAR}} \rightarrow k_{\text{CHD}} & K_{\text{PAR}} & \times & \times \ K_{\text{PAR}} \rightarrow K_{\text{CHD}} & K_{\text{PAR}} & K_{\text{CHD}}^n & n \ \hline \end{array}

 $Yhteenvetona, tähän mennessä olet oppinut luomaan HD-lompakon peruselementit: muistilauseen, siemenen ja sitten pääavaimen sekä pääketjukoodin. Olet myös löytänyt, miten johdetaan lapsiavainpareja tässä luvussa. Seuraavassa luvussa tutkimme, miten nämä johdannaiset on järjestetty Bitcoin-lompakoissa ja mitä rakennetta noudattaa konkreettisesti vastaanotto-osoitteiden sekä *scriptPubKey* ja *scriptSig*:ssä käytettyjen avainparien saamiseksi. ## Lompakon Rakenne ja Johdannaispolku <chapterId>34e1bbda-67de-5493-b268-1fded8d67689</chapterId> HD-lompakoiden hierarkkinen rakenne Bitcoinissa mahdollistaa avainparien järjestämisen eri tavoin. Ajatuksena on johtaa useita syvyystasoja pääyksityisavaimesta ja pääketjukoodista. Jokainen lisätty taso vastaa lapsiavainparin johdantaa vanhemmasta avainparista. Ajan myötä erilaiset BIP:t (*Bitcoin Improvement Proposals*) ovat esitelleet standardeja näille johdannaispoluille, pyrkien standardoimaan niiden käytön eri ohjelmistoissa. Joten tässä luvussa tutustumme HD-lompakoiden kunkin johdannaispolun tason merkitykseen näiden standardien mukaisesti. ### HD-lompakon Johdannaispolkujen Syvyydet Johdannaispolut on järjestetty syvyystasojen kerroksiin, alkaen syvyydestä 0, joka edustaa pääavainta ja pääketjukoodia, aina alitasojen kerroksiin osoitteiden johdantaa varten, joita käytetään UTXO:iden lukitsemiseen. BIP:t (*Bitcoin Improvement Proposals*) määrittelevät kunkin kerroksen standardit, mikä auttaa harmonisoimaan käytäntöjä eri lompakonhallintaohjelmistojen välillä. Johdannaispolku viittaa siis indeksien sekvenssiin, jota käytetään lapsiavainten johtamiseen pääavaimesta. **Syvyys 0: Pääavain (BIP32)** Tämä syvyys vastaa lompakon pääyksityisavainta ja pääketjukoodia. Sitä edustaa notaatio $m/$. **Syvyys 1: Tarkoitus (BIP43)** Tavoite määrittää johdannaisen loogisen rakenteen. Esimerkiksi P2WPKH-osoitteella on syvyydessä 1 $/84'/$ (BIP84:n mukaan), kun taas P2TR-osoitteella on $/86'/$ (BIP86:n mukaan). Tämä kerros helpottaa lompakoiden välistä yhteensopivuutta osoittamalla indeksinumerot, jotka vastaavat BIP-numeroita. Toisin sanoen, kun sinulla on pääavain ja pääketjukoodi, ne toimivat vanhempina avainpareina johdettaessa lapsiavainparia. Tässä johdannaisessa käytettävä indeksi voi olla esimerkiksi $/84'/$, jos lompakko on tarkoitettu käyttämään SegWit v0 -tyyppisiä skriptejä. Tämä avainpari on sitten syvyydessä 1. Sen rooli ei ole lukita bittejä, vaan toimia vain välietappina johdannaisessa hierarkiassa. **Syvyys 2: Valuuttatyyppi (BIP44)** Syvyydessä 1 olevasta avainparista suoritetaan uusi johdannainen saadakseen avainparin syvyydessä 2. Tämä syvyys mahdollistaa Bitcoin-tilien erottamisen muista kryptovaluutoista samassa lompakossa. Jokaisella valuutalla on ainutlaatuinen indeksi varmistaakseen yhteensopivuuden monivaluuttalompakoiden kanssa. Esimerkiksi Bitcoinille indeksi on $/0'/$ (tai `0x80000000` heksadesimaalinotaatiossa). Valuuttaindeksit on valittu väliltä $2^{31}$ - $2^{32}-1$ varmistaakseen kovennetun johdannaisen. Antaakseni muita esimerkkejä, tässä on joitakin valuuttojen indeksejä: - $1'$ (`0x80000001`) testnet-bitteille; - $2'$ (`0x80000002`) Litecoinille; - $60'$ (`0x8000003c`) Ethereumin... **Syvyys 3: Tili (BIP32)** Jokainen lompakko voidaan jakaa useisiin tileihin, jotka on numeroitu alkaen $2^{31}$, ja esitetty syvyydessä 3 $/0'/$ ensimmäiselle tilille, $/1'/$ toiselle ja niin edelleen. Yleensä, kun viitataan laajennettuun avaimen `xpub`, se viittaa avaimiin tässä johdannaisen syvyydessä. Tämä erottelu eri tileihin on valinnainen. Sen tavoitteena on yksinkertaistaa lompakon organisointia käyttäjille. Käytännössä usein käytetään vain yhtä tiliä, yleensä oletuksena ensimmäistä. Kuitenkin joissakin tapauksissa, jos halutaan selvästi erottaa avainparit eri käyttötarkoituksiin, tämä voi olla hyödyllistä. Esimerkiksi on mahdollista luoda henkilökohtainen tili ja ammattitili samasta siemenestä, täysin erillisillä avainryhmillä tästä johdannaisen syvyydestä. **Syvyys 4: Ketju (BIP32)** Syvyydessä 3 määritelty kunkin tilin rakenne jaetaan sitten kahteen ketjuun: - **Ulkoinen ketju**: Tässä ketjussa johdetaan niin sanottuja "julkisia" osoitteita. Nämä vastaanotto-osoitteet on tarkoitettu lukitsemaan UTXO:t, jotka tulevat ulkoisista transaktioista (toisin sanoen, peräisin UTXO:ista, jotka eivät kuulu sinulle). Yksinkertaisesti sanottuna, tätä ulkoista ketjua käytetään aina, kun halutaan vastaanottaa bittejä. Kun napsautat "*vastaanota*" lompakko-ohjelmistossasi, sinulle tarjotaan aina osoitetta ulkoisesta ketjusta. Tämä ketju on esitetty avainparilla, joka on johdettu indeksillä $/0/$. - **Sisäinen ketju (vaihto)**: Tämä ketju on varattu vastaanotto-osoitteille, jotka lukitsevat bitit, jotka tulevat sinulle kuuluvien UTXO:iden kulutuksesta, toisin sanoen vaihto-osoitteille. Se tunnistetaan indeksillä $/1/$. **Syvyys 5: Osoiteindeksi (BIP32)** Lopulta syvyys 5 edustaa viimeistä vaihetta lompakon johdannaisprosessissa. Vaikka teknisesti on mahdollista jatkaa loputtomiin, nykyiset standardit päättyvät tähän. Tässä viimeisessä syvyydessä johdetaan avainpareja, joita käytetään UTXOjen lukitsemiseen ja avaamiseen. Jokainen indeksi mahdollistaa sisaravainparien erottamisen: näin ollen ensimmäinen vastaanotto-osoite käyttää indeksiä $/0/$, toinen indeksiä $/1/$, ja niin edelleen. ![CYP201](/courses/cyp201/assets/fr/053.webp) ### Johdannaispolkujen notaatio Johdannaispolku kirjoitetaan erottamalla jokainen taso kauttaviivalla ($/$). Jokainen kauttaviiva siis osoittaa vanhemman avainparin ($k_{\text{PAR}}$, $K_{\text{PAR}}$, $C_{\text{PAR}}$) johdattamisen lapsiavainpariksi ($k_{\text{CHD}}$, $K_{\text{CHD}}$, $C_{\text{CHD}}$). Jokaisessa syvyydessä mainittu numero vastaa indeksiä, jota käytetään tämän avaimen johdattamiseen vanhemmistaan. Heittomerkki ($'$) joskus indeksin oikealla puolella osoittaa kovennetun johdannaisen ($k_{\text{CHD}}^h$, $K_{\text{CHD}}^h$). Joskus tämä heittomerkki korvataan $h$:lla. Heittomerkin tai $h$:n puuttuessa kyseessä on siis normaali johdannainen ($k_{\text{CHD}}^n$, $K_{\text{CHD}}^n$). Kuten aiemmissa luvuissa olemme nähneet, kovennetut avainindeksit alkavat $2^{31}$:stä, tai `0x80000000` heksadesimaalina. Siksi, kun johdannaispolussa indeksiä seuraa heittomerkki, $2^{31}$ on lisättävä ilmoitettuun numeroon saadaksemme todellisen arvon, jota käytetään HMAC-SHA512-funktiossa. Esimerkiksi, jos johdannaispolku määrittelee $/44'/$, todellinen indeksi on:$

i = 44 + 2^{31} = 2,147,483,692

 $Heksadesimaalina tämä on `0x8000002C`. Nyt kun olemme ymmärtäneet johdannaispolkujen pääperiaatteet, otetaan esimerkki! Tässä on johdannaispolku Bitcoinin vastaanotto-osoitteelle:$

m / 84' / 0' / 1' / 0 / 7

\text{HASH160}(K) = \text{RIPEMD160}(\text{SHA256}(K))

 $Ensiksi, käymme avaimen läpi SHA256:n avulla: ```text SHA256(K) = C489EBD66E4103B3C4B5EAFF462B92F5847CA2DCE0825F4997C7CF57DF35BF3A ``` Sitten viemme tuloksen läpi RIPEMD160:n: ```text RIPEMD160(SHA256(K)) = 9F81322CC88622CA4CCB2A52A21E2888727AA535 ``` Olemme saaneet 160-bittisen julkisen avaimen tiivisteen, joka muodostaa niin kutsutun osoitteen kuorman (payload). Tämä kuorma edustaa osoitteen keskeisintä ja tärkeintä osaa. Sitä käytetään myös *scriptPubKey:ssä* lukitsemaan UTXO:t. Jotta tämä kuorma olisi ihmisille helpommin käytettävissä, siihen lisätään metadataa. Seuraava vaihe sisältää tämän tiivisteen koodaamisen 5 bitin ryhmiin desimaalimuodossa. Tämä desimaalimuunnos on hyödyllinen muunnoksessa *bech32*-muotoon, jota käytetään post-SegWit-osoitteissa. 160-bittinen binääritiiviste jaetaan siten 32 ryhmään, joissa on 5 bittiä:$

\begin{array}{|c|c|} \hline \text{5 bits} & \text{Decimal} \ \hline 10011 & 19 \ 11110 & 30 \ 00000 & 0 \ 10011 & 19 \ 00100 & 4 \ 01011 & 11 \ 00110 & 6 \ 01000 & 8 \ 10000 & 16 \ 11000 & 24 \ 10001 & 17 \ 01100 & 12 \ 10100 & 20 \ 10011 & 19 \ 00110 & 6 \ 01011 & 11 \ 00101 & 5 \ 01001 & 9 \ 01001 & 9 \ 01010 & 10 \ 00100 & 4 \ 00111 & 7 \ 10001 & 17 \ 01000 & 8 \ 10001 & 17 \ 00001 & 1 \ 11001 & 25 \ 00111 & 7 \ 10101 & 21 \ 00101 & 5 \ 00101 & 5 \ 10101 & 21 \ \hline \end{array}

\begin{array}{|c|c|c|c|c|c|c|c|c|} \hline & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 \ \hline +0 & q & p & z & r & y & 9 & x & 8 \ \hline +8 & g & f & 2 & t & v & d & w & 0 \ \hline +16 & s & 3 & j & n & 5 & 4 & k & h \ \hline +24 & c & e & 6 & m & u & a & 7 & l \ \hline \end{array}

P' = P + tG

 $Missä $G$ on käytetyn elliptisen käyrän generaattori. Tämä toimenpide tuottaa uuden julkisen avaimen, joka on johdettu alkuperäisestä avaimesta, säilyttäen samalla kryptografiset ominaisuudet, jotka mahdollistavat sen käytön. Jos sinun ei tarvitse lisätä vaihtoehtoisia skriptejä (kuluttaen yksinomaan _avainpolun_ kautta), voit luoda Taproot-osoitteen, joka perustuu yksinomaan julkiseen avaimen, joka on läsnä lompakkosi syvyydessä 5. Tässä tapauksessa on tarpeen luoda kuluttamaton skripti _skriptipolulle_, jotta rakenteen vaatimukset täyttyvät. Muunnos $t$ lasketaan soveltamalla merkittyä hajautusfunktiota, **`TapTweak`**, sisäiseen julkiseen avaimen $P$:$

t = \text{H}_{\text{TapTweak}}(P)

 $missä: - **$\text{H}_{\text{TapTweak}}$** on SHA256-hajautusfunktio, joka on merkitty tagilla `TapTweak`. Jos et ole tuttu merkittyjen hajautusfunktioiden kanssa, suosittelen tutustumaan lukuun 3.3; - $P$ on sisäinen julkinen avain, esitetty sen tiivistetyssä 256-bittisessä muodossa, käyttäen vain $x$-koordinaattia. Taproot-julkinen avain $Q$ lasketaan lisäämällä muunnos $t$, kerrottuna elliptisen käyrän generaattorilla $G$, sisäiseen julkiseen avaimen $P$:$

Q = P + t \cdot G

 $Kun Taproot-julkinen avain $Q$ on saatu, voimme luoda vastaavan vastaanotto-osoitteen. Toisin kuin muissa formaateissa, Taproot-osoitteet eivät perustu julkisen avaimen hajautukseen. Siksi avain $Q$ lisätään suoraan osoitteeseen raakamuodossa. Aloitamme poimimalla pisteen $Q$ $x$-koordinaatin saadaksemme tiivistetyn julkisen avaimen. Tähän kuormaan lasketaan tarkistussumma käyttäen BCH-koodeja, kuten SegWit v0 -osoitteissa. Taproot-osoitteiden käyttämä ohjelma eroaa kuitenkin hieman. Todellakin, _bech32_-formaatin käyttöönoton jälkeen SegWitissä löydettiin bugi: kun osoitteen viimeinen merkki on `p`, `q`:iden lisääminen tai poistaminen juuri ennen tätä `p`:tä ei tee tarkistussummasta virheellistä. Vaikka tällä bugilla ei ole seurauksia SegWit v0:ssa (kiitos kokorajoituksen), se voisi aiheuttaa ongelman tulevaisuudessa. Tämä bugi on siis korjattu Taproot-osoitteissa, ja uusi korjattu formaatti on nimeltään "_bech32m_". Taproot-osoite luodaan koodaamalla $Q$:n $x$-koordinaatti _bech32m_-formaattiin, seuraavilla elementeillä: - **HRP (_Human Readable Part_)**: `bc`, osoittamaan pääasiallista Bitcoin-verkkoa; - **Versio**: `1` osoittamaan Taproot / SegWit v1; - **Tarkistussumma**. Lopullinen osoite on siis muodossa: ``` bc1p[Qx][tarkistussumma] ``` Toisaalta, jos haluat lisätä vaihtoehtoisia skriptejä kuluttaen sisäisen julkisen avaimen (_skriptipolku_) lisäksi, vastaanotto-osoitteen laskenta on hieman erilainen. Sinun on sisällytettävä vaihtoehtoisten skriptien hajautus muunnoksen laskentaan. Taprootissa jokainen vaihtoehtoinen skripti, joka sijaitsee Merkle-puun lopussa, kutsutaan "lehdeksi". Kun eri vaihtoehtoiset skriptit on kirjoitettu, sinun on läpikäytävä ne yksitellen merkityn hajautusfunktion `TapLeaf` kautta, jonka yhteydessä on jotakin metadataa:$

\text{h}{\text{leaf}} = \text{H}{\text{TapLeaf}} (v \Vert sz \Vert S)

 $Missä: - $v$: skriptin versionumero (oletusarvo `0xC0` Taprootille); - $sz$: skriptin koko, joka on koodattu _CompactSize_-muodossa; - $S$: skripti. Eri skriptien hajautukset ($\text{h}_{\text{leaf}}$) lajitellaan ensin leksikografiseen järjestykseen. Sen jälkeen ne yhdistetään pareittain ja syötetään merkityn hajautusfunktion `TapBranch` läpi. Tätä prosessia toistetaan iteratiivisesti rakentaaksemme askel askeleelta Merkle-puun:$

\text{h}{\text{branch}} = \text{H}{\text{TapBranch}}(\text{h}{\text{leaf1}} \Vert \text{h}{\text{leaf2}})

 $Jatkamme sitten tulosten yhdistämistä kaksi kerrallaan, syöttämällä ne jokaisella askeleella merkityn hajautusfunktion `TapBranch` läpi, kunnes saamme Merkle-puun juuren: ![CYP201](/courses/cyp201/assets/fr/066.webp) Kun Merkle-juuri $h_{\text{root}}$ on laskettu, voimme laskea tweak-arvon. Tätä varten yhdistämme lompakon sisäisen julkisen avaimen $P$ juureen $h_{\text{root}}$ ja syötämme tuloksen merkittyyn hash-funktioon `TapTweak`:$

t = \text{H}{\text{TapTweak}}(P \Vert h{\text{root}})

 $Lopuksi, kuten aiemmin, Taprootin julkinen avain $Q$ saadaan lisäämällä sisäinen julkinen avain $P$ tweak-arvon $t$ ja generaattoripisteen $G$ tuloon:$

Q = P + t \cdot G

 $Osoitteen luominen jatkuu samalla prosessilla, jossa raakajulkinen avain $Q$ toimii hyötykuormana, johon lisätään joitakin lisämetatietoja. Ja siinä kaikki! Olemme saapuneet CYP201-kurssin päätökseen. Jos pidit kurssia hyödyllisenä, olisin erittäin kiitollinen, jos voisit käyttää muutaman hetken antaaksesi sille hyvän arvostelun seuraavassa arviointiluvussa. Voit myös mielellään jakaa sen läheistesi tai sosiaalisten verkostojesi kanssa. Lopuksi, jos haluat saada diplomisi tälle kurssille, voit suorittaa loppukokeen heti arviointiluvun jälkeen. # Lopullinen osio <partId>58111408-b734-54db-9ea7-0d5b67f99f99</partId> ## Arviot & Arvosanat <chapterId>0cd71541-a7fd-53db-b66a-8611b6a28b04</chapterId> <isCourseReview>true</isCourseReview> ## Loppukoe <chapterId>a53ea27d-0f84-56cd-b37c-a66210a4b31d</chapterId> <isCourseExam>true</isCourseExam> ## Yhteenveto <chapterId>d291428b-3cfa-5394-930e-4b514be82d5a</chapterId> <isCourseConclusion>true</isCourseConclusion>$