name: Die inneren Mechanismen von Bitcoin-Wallets goal: Tauchen Sie ein in die kryptografischen Prinzipien, die Bitcoin-Wallets antreiben. objectives:

Definieren Sie die theoretischen Konzepte, die für das Verständnis der in Bitcoin verwendeten kryptografischen Algorithmen notwendig sind.
Verstehen Sie vollständig den Aufbau einer deterministischen und hierarchischen Wallet.
Wissen, wie man die mit der Verwaltung einer Wallet verbundenen Risiken identifiziert und reduziert.
Verstehen Sie die Prinzipien von Hash-Funktionen, kryptografischen Schlüsseln und digitalen Signaturen.

Eine Reise ins Herz der Bitcoin-Wallets

Entdecken Sie die Geheimnisse deterministischer und hierarchischer Bitcoin-Wallets mit unserem CYP201-Kurs! Egal, ob Sie ein regelmäßiger Nutzer sind oder ein Enthusiast, der sein Wissen vertiefen möchte, dieser Kurs bietet eine vollständige Eintauchung in die Funktionsweise dieser Werkzeuge, die wir alle täglich nutzen.

Lernen Sie die Mechanismen von Hash-Funktionen, digitalen Signaturen (ECDSA und Schnorr), mnemonischen Phrasen, kryptografischen Schlüsseln und die Erstellung von Empfangsadressen kennen, während Sie fortgeschrittene Sicherheitsstrategien erkunden.

Dieses Training wird Sie nicht nur mit dem Wissen ausstatten, um die Struktur einer Bitcoin-Wallet zu verstehen, sondern wird Sie auch darauf vorbereiten, tiefer in die aufregende Welt der Kryptografie einzutauchen.

Mit klarer Pädagogik, über 60 erläuternden Diagrammen und konkreten Beispielen wird CYP201 es Ihnen ermöglichen, von A bis Z zu verstehen, wie Ihre Wallet funktioniert, sodass Sie das Bitcoin-Universum mit Vertrauen navigieren können. Nehmen Sie heute die Kontrolle über Ihre UTXOs, indem Sie verstehen, wie HD-Wallets funktionieren!

Einführung

Kurseinführung

Willkommen zum CYP201-Kurs, in dem wir die Funktionsweise von HD Bitcoin-Wallets ausführlich erkunden werden. Dieser Kurs ist für jeden gedacht, der die technischen Grundlagen der Nutzung von Bitcoin verstehen möchte, egal ob es sich um Gelegenheitsnutzer, aufgeklärte Enthusiasten oder zukünftige Experten handelt.

Das Ziel dieses Trainings ist es, Ihnen die Schlüssel zu geben, um die Werkzeuge, die Sie täglich verwenden, zu beherrschen. HD Bitcoin-Wallets, die im Mittelpunkt Ihrer Benutzererfahrung stehen, basieren auf manchmal komplexen Konzepten, die wir zugänglich machen werden. Gemeinsam werden wir sie entmystifizieren!

Bevor wir in die Details des Aufbaus und der Funktionsweise von Bitcoin-Wallets eintauchen, beginnen wir mit einigen Kapiteln über die kryptografischen Grundlagen, die für das Folgende zu wissen sind. Wir beginnen mit kryptografischen Hash-Funktionen, die sowohl für Wallets als auch für das Bitcoin-Protokoll selbst grundlegend sind. Sie werden ihre Hauptmerkmale entdecken, die spezifischen Funktionen, die in Bitcoin verwendet werden, und in einem technischeren Kapitel werden Sie im Detail über die Funktionsweise der Königin der Hash-Funktionen lernen: SHA256. CYP201

Als Nächstes werden wir die Funktionsweise von digitalen Signaturalgorithmen besprechen, die Sie jeden Tag verwenden, um Ihre UTXOs zu sichern. Bitcoin verwendet zwei: ECDSA und das Schnorr-Protokoll. Sie werden erfahren, welche mathematischen Grundlagen diesen Algorithmen zugrunde liegen und wie sie die Sicherheit von Transaktionen gewährleisten.

Sobald wir ein gutes Verständnis dieser Elemente der Kryptografie haben, werden wir schließlich zum Kern des Trainings übergehen: deterministische und hierarchische Wallets! Zuerst gibt es einen Abschnitt, der den mnemonischen Phrasen gewidmet ist, diesen Sequenzen von 12 oder 24 Wörtern, die es Ihnen ermöglichen, Ihre Wallets zu erstellen und wiederherzustellen. Sie werden entdecken, wie diese Wörter aus einer Quelle der Entropie generiert werden und wie sie die Nutzung von Bitcoin erleichtern.

CYP201 Das Training wird mit dem Studium des BIP39-Passphrases, des Seeds (nicht zu verwechseln mit der mnemonischen Phrase), des Master Chain Codes und des Master-Schlüssels fortgesetzt. Wir werden im Detail sehen, was diese Elemente sind, ihre jeweiligen Rollen und wie sie berechnet werden. CYP201

Schließlich werden wir vom Master-Schlüssel aus entdecken, wie kryptografische Schlüsselpaare auf eine deterministische und hierarchische Weise bis zu den Empfangsadressen abgeleitet werden.

Dieses Training wird es Ihnen ermöglichen, Ihre Wallet-Software mit Vertrauen zu nutzen, während Sie Ihre Fähigkeiten verbessern, Risiken zu identifizieren und zu mindern. Bereiten Sie sich darauf vor, ein wahrer Experte für Bitcoin-Wallets zu werden!

Hash-Funktionen

Einführung in Hash-Funktionen

Die erste Art von kryptografischen Algorithmen, die bei Bitcoin verwendet werden, umfasst Hash-Funktionen. Sie spielen eine wesentliche Rolle auf verschiedenen Ebenen des Protokolls, aber auch innerhalb von Bitcoin-Wallets. Lassen Sie uns gemeinsam entdecken, was eine Hash-Funktion ist und wofür sie bei Bitcoin verwendet wird.

Definition und Prinzip des Hashings

Hashing ist ein Prozess, der Informationen beliebiger Länge in ein anderes Stück Information fester Länge durch eine kryptografische Hash-Funktion transformiert. Mit anderen Worten, eine Hash-Funktion nimmt eine Eingabe beliebiger Größe und wandelt sie in einen Fingerabdruck fester Größe um, der als "Hash" bezeichnet wird. Der Hash kann manchmal auch als "Digest", "Kondensat", "verdichtet" oder "gehasht" bezeichnet werden.

Zum Beispiel erzeugt die SHA256-Hash-Funktion einen Hash fester Länge von 256 Bit. Wenn wir also die Eingabe "PlanB", eine Nachricht beliebiger Länge, verwenden, wird der erzeugte Hash der folgende 256-Bit-Fingerabdruck sein:

24f1b93b68026bfc24f5c8265f287b4c940fb1664b0d75053589d7a4f821b688

Eigenschaften von Hash-Funktionen

Diese kryptografischen Hash-Funktionen haben mehrere wesentliche Eigenschaften, die sie besonders nützlich im Kontext von Bitcoin und anderen Computersystemen machen:

Unumkehrbarkeit (oder Preimage-Resistenz)
Manipulationssicherheit (Lawineneffekt)
Kollisionsresistenz
Zweite Preimage-Resistenz

1. Unumkehrbarkeit (Preimage-Resistenz):

Unumkehrbarkeit bedeutet, dass es einfach ist, den Hash aus der Eingabeinformation zu berechnen, aber die umgekehrte Berechnung, also das Auffinden der Eingabe aus dem Hash, praktisch unmöglich ist. Diese Eigenschaft macht Hash-Funktionen perfekt für die Erstellung einzigartiger digitaler Fingerabdrücke, ohne die ursprünglichen Informationen zu gefährden.

Im gegebenen Beispiel ist es einfach und schnell, den Hash 24f1b9… zu erhalten, wenn man die Eingabe "PlanB" kennt. Jedoch ist es unmöglich, die Nachricht "PlanB" zu finden, wenn man nur 24f1b9… kennt.

Daher ist es unmöglich, ein Preimage $m$ für einen Hash $h$ zu finden, so dass $h = \text{HASH}(m)$ , wobei $\text{HASH}$ eine kryptografische Hash-Funktion ist.

2. Manipulationssicherheit (Lawineneffekt)

Das zweite Merkmal ist die Manipulationssicherheit, auch bekannt als der Lawineneffekt. Dieses Merkmal wird bei einer Hash-Funktion beobachtet, wenn eine kleine Änderung in der Eingangsnachricht eine radikale Änderung im Ausgabe-Hash bewirkt. Wenn wir zu unserem Beispiel mit der Eingabe "PlanB" und der SHA256-Funktion zurückkehren, haben wir gesehen, dass der generierte Hash wie folgt ist:

24f1b93b68026bfc24f5c8265f287b4c940fb1664b0d75053589d7a4f821b688

Wenn wir eine sehr geringfügige Änderung an der Eingabe vornehmen, indem wir dieses Mal "Planb" verwenden, dann ändert das einfache Wechseln von einem Großbuchstaben "B" zu einem Kleinbuchstaben "b" den SHA256-Ausgabe-Hash komplett:

bb038b4503ac5d90e1205788b00f8f314583c5e22f72bec84b8735ba5a36df3f

Diese Eigenschaft stellt sicher, dass selbst eine geringfügige Änderung der ursprünglichen Nachricht sofort erkennbar ist, da sich nicht nur ein kleiner Teil des Hashs ändert, sondern der gesamte Hash. Dies kann in verschiedenen Bereichen von Interesse sein, um die Integrität von Nachrichten, Software oder sogar Bitcoin-Transaktionen zu überprüfen.

3. Kollisionsresistenz

Das dritte Merkmal ist die Kollisionsresistenz. Eine Hash-Funktion ist kollisionsresistent, wenn es rechnerisch unmöglich ist, 2 verschiedene Nachrichten zu finden, die denselben Hash-Ausgang von der Funktion produzieren. Formal ist es schwierig, zwei unterschiedliche Nachrichten $m_1$ und $m_2$ zu finden, so dass:

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

In der Realität ist es mathematisch unvermeidlich, dass Kollisionen für Hash-Funktionen existieren, da die Größe der Eingaben größer sein kann als die Größe der Ausgaben. Dies ist bekannt als das Dirichlet-Schubladenprinzip: Wenn $n$ Objekte in $m$ Schubladen verteilt werden, mit $m < n$ , dann wird mindestens eine Schublade notwendigerweise zwei oder mehr Objekte enthalten. Für eine Hash-Funktion gilt dieses Prinzip, weil die Anzahl der möglichen Nachrichten (fast) unendlich ist, während die Anzahl der möglichen Hashes endlich ist ( $2^{256}$ im Fall von SHA256).

Daher bedeutet dieses Merkmal nicht, dass es keine Kollisionen für Hash-Funktionen gibt, sondern dass eine gute Hash-Funktion die Wahrscheinlichkeit, eine Kollision zu finden, vernachlässigbar macht. Dieses Merkmal wird beispielsweise bei den SHA-0 und SHA-1 Algorithmen, den Vorgängern von SHA-2, nicht mehr verifiziert, da für diese Kollisionen gefunden wurden. Diese Funktionen werden daher nun abgeraten und oft als veraltet betrachtet. Für eine Hash-Funktion von $n$ Bits ist die Kollisionsresistenz in der Größenordnung von $2^{\frac{n}{2}}$ , in Übereinstimmung mit dem Geburtstagsangriff. Zum Beispiel, für SHA256 ( $n = 256$ ), ist die Komplexität, eine Kollision zu finden, in der Größenordnung von $2^{128}$ Versuchen. Praktisch bedeutet dies, dass wenn man $2^{128}$ verschiedene Nachrichten durch die Funktion laufen lässt, man wahrscheinlich eine Kollision finden wird.

4. Resistenz gegen Second Preimage

Die Resistenz gegen Second Preimage ist ein weiteres wichtiges Merkmal von Hash-Funktionen. Es besagt, dass es rechnerisch unpraktikabel ist, gegeben eine Nachricht $m_1$ und ihren Hash $h$ , eine andere Nachricht $m_2 \neq m_1$ zu finden, so dass:

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

Daher ist die Resistenz gegen Second Preimage in gewisser Weise ähnlich zur Kollisionsresistenz, außer hier ist der Angriff schwieriger, weil der Angreifer $m_1$ nicht frei wählen kann.

Anwendungen von Hash-Funktionen in Bitcoin

Die am häufigsten verwendete Hash-Funktion in Bitcoin ist SHA256 ("Secure Hash Algorithm 256 bits"). Entwickelt Anfang der 2000er Jahre vom NSA und standardisiert durch das NIST, erzeugt sie einen 256-Bit-Hash-Ausgang.

Diese Funktion wird in vielen Aspekten von Bitcoin verwendet. Auf Protokollebene ist sie am Proof-of-Work-Mechanismus beteiligt, wo sie in einer doppelten Hashing-Prozedur angewendet wird, um eine partielle Kollision zwischen dem Header eines Kandidatenblocks, der von einem Miner erstellt wurde, und dem Schwierigkeitsziel zu suchen. Wenn diese partielle Kollision gefunden wird, wird der Kandidatenblock gültig und kann zur Blockchain hinzugefügt werden.

SHA256 wird auch beim Aufbau eines Merkle-Baums verwendet, der insbesondere der Akkumulator ist, der für die Aufzeichnung von Transaktionen in Blöcken verwendet wird. Diese Struktur findet sich auch im Utreexo-Protokoll, das die Größe des UTXO-Sets reduziert. Zusätzlich wird mit der Einführung von Taproot im Jahr 2021 SHA256 im MAST (Merkelised Alternative Script Tree) ausgenutzt, der es ermöglicht, nur die tatsächlich in einem Skript verwendeten Ausgabebedingungen zu offenbaren, ohne die anderen möglichen Optionen offenzulegen. Es wird auch bei der Berechnung von Transaktionsidentifikatoren, bei der Übertragung von Paketen über das P2P-Netzwerk, bei elektronischen Signaturen... verwendet. Schließlich, und das ist in dieser Schulung von besonderem Interesse, wird SHA256 auf Anwendungsebene für den Aufbau von Bitcoin-Wallets und die Ableitung von Adressen verwendet.

Meistens, wenn man in Bitcoin auf die Verwendung von SHA256 stößt, wird es tatsächlich ein doppelter Hash SHA256 sein, notiert als "HASH256", der einfach darin besteht, SHA256 zweimal hintereinander anzuwenden:

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

Diese Praxis des doppelten Hashings fügt eine zusätzliche Sicherheitsebene gegen bestimmte potenzielle Angriffe hinzu, obwohl ein einzelnes SHA256 heute als kryptografisch sicher gilt.

Eine weitere in der Script-Sprache verfügbare Hash-Funktion, die für die Ableitung von Empfangsadressen verwendet wird, ist die RIPEMD160-Funktion. Diese Funktion erzeugt einen 160-Bit-Hash (also kürzer als SHA256). Sie wird in der Regel mit SHA256 kombiniert, um die HASH160-Funktion zu bilden:

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

Diese Kombination wird verwendet, um kürzere Hashes zu erzeugen, insbesondere bei der Erstellung bestimmter Bitcoin-Adressen, die Hashes von Schlüsseln oder Skript-Hashes darstellen, sowie zur Erzeugung von Schlüsselfingerabdrücken.

Schließlich wird auf Anwendungsebene manchmal auch die SHA512-Funktion verwendet, die indirekt eine Rolle bei der Schlüsselableitung für Wallets spielt. Diese Funktion ist in ihrer Arbeitsweise SHA256 sehr ähnlich; beide gehören zur gleichen SHA2-Familie, aber SHA512 erzeugt, wie der Name schon sagt, einen 512-Bit-Hash, verglichen mit 256 Bits für SHA256. Wir werden ihre Verwendung in den folgenden Kapiteln detailliert beschreiben.

Sie kennen nun die wesentlichen Grundlagen über Hash-Funktionen für das Folgende. Im nächsten Kapitel schlage ich vor, die Funktionsweise der Funktion, die im Herzen von Bitcoin steht: SHA256, detaillierter zu entdecken. Wir werden sie analysieren, um zu verstehen, wie sie die hier beschriebenen Eigenschaften erreicht. Das nächste Kapitel ist ziemlich lang und technisch, aber es ist nicht wesentlich, um dem Rest der Schulung zu folgen. Wenn Sie also Schwierigkeiten haben, es zu verstehen, machen Sie sich keine Sorgen und gehen Sie direkt zum folgenden Kapitel über, das viel zugänglicher sein wird.

Die Funktionsweise von SHA256

905eb320-f15b-5fb6-8d2d-5bb447337deb Wir haben zuvor gesehen, dass Hashing-Funktionen wichtige Eigenschaften besitzen, die ihren Einsatz bei Bitcoin rechtfertigen. Lassen Sie uns nun die internen Mechanismen dieser Hashing-Funktionen untersuchen, die ihnen diese Eigenschaften verleihen, und dazu schlage ich vor, die Funktionsweise von SHA256 zu analysieren.

Die Funktionen SHA256 und SHA512 gehören zur gleichen SHA2-Familie. Ihr Mechanismus basiert auf einer spezifischen Konstruktion, der Merkle-Damgård-Konstruktion. RIPEMD160 verwendet ebenfalls diesen Typ von Konstruktion.

Zur Erinnerung: Wir haben eine Nachricht beliebiger Größe als Eingabe für SHA256, und wir werden sie durch die Funktion leiten, um einen 256-Bit-Hash als Ausgabe zu erhalten.

Vorverarbeitung der Eingabe

Zu Beginn müssen wir unsere Eingabenachricht $m$ so vorbereiten, dass sie eine standardisierte Länge hat, die ein Vielfaches von 512 Bits ist. Dieser Schritt ist entscheidend für das ordnungsgemäße Funktionieren des Algorithmus im weiteren Verlauf. Dazu beginnen wir mit dem Schritt der Padding-Bits. Wir fügen zuerst ein Trennbit 1 zur Nachricht hinzu, gefolgt von einer bestimmten Anzahl von 0 Bits. Die Anzahl der hinzugefügten 0 Bits wird so berechnet, dass die Gesamtlänge der Nachricht nach dieser Ergänzung kongruent zu 448 modulo 512 ist. Somit ist die Länge $L$ der Nachricht mit den Padding-Bits gleich:

 $L \equiv 448 \mod 512$

$\text{mod}$ , für modulo, ist eine mathematische Operation, die zwischen zwei Ganzzahlen den Rest der euklidischen Division des Ersten durch den Zweiten zurückgibt. Zum Beispiel: $16 \mod 5 = 1$ . Es ist eine Operation, die in der Kryptographie weit verbreitet ist.

Hier stellt der Padding-Schritt sicher, dass nach dem Hinzufügen der 64 Bits im nächsten Schritt die Gesamtlänge der angeglichenen Nachricht ein Vielfaches von 512 Bits sein wird. Wenn die ursprüngliche Nachricht eine Länge von $M$ Bits hat, ist die Anzahl ( $N$ ) der hinzuzufügenden 0 Bits also:

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

Zum Beispiel, wenn die ursprüngliche Nachricht 950 Bits lang ist, wäre die Berechnung wie folgt:

 $\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*}$

Somit hätten wir 9 0en zusätzlich zum Trennbit 1. Unsere direkt nach unserer Nachricht $M$ hinzuzufügenden Padding-Bits wären also:

1000 0000 00

Nachdem wir die Padding-Bits zu unserer Nachricht $M$ hinzugefügt haben, fügen wir auch eine 64-Bit-Darstellung der ursprünglichen Länge der Nachricht $M$ hinzu, ausgedrückt in Binär. Dies ermöglicht es der Hash-Funktion, empfindlich auf die Bitreihenfolge und die Länge der Nachricht zu reagieren. Wenn wir zu unserem Beispiel mit einer anfänglichen Nachricht von 950 Bits zurückkehren, konvertieren wir die Dezimalzahl 950 in Binär, was uns 1110 1101 10 ergibt. Wir ergänzen diese Zahl an der Basis mit Nullen, um insgesamt 64 Bits zu erhalten. In unserem Beispiel ergibt das:

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

Diese Padding-Größe wird nach dem Bit-Padding hinzugefügt. Daher besteht die Nachricht nach unserer Vorverarbeitung aus drei Teilen:

Die ursprüngliche Nachricht $M$ ;
Ein Bit 1 gefolgt von mehreren Bits 0, um das Bit-Padding zu bilden;
Eine 64-Bit-Darstellung der Länge von $M$ , um das Padding mit der Größe zu bilden.

Initialisierung der Variablen

SHA256 verwendet acht Anfangszustandsvariablen, bezeichnet mit $A$ bis $H$ , jede mit 32 Bits. Diese Variablen werden mit spezifischen Konstanten initialisiert, die die Bruchteile der Quadratwurzeln der ersten acht Primzahlen sind. Wir werden diese Werte im Laufe des Hashing-Prozesses verwenden:

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

SHA256 verwendet auch 64 andere Konstanten, bezeichnet mit $K_0$ bis $K_{63}$ , die die Bruchteile der Kubikwurzeln der ersten 64 Primzahlen sind:

 $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}$

Aufteilung der Eingabe

Nachdem wir nun eine ausgeglichene Eingabe haben, werden wir nun zur Hauptverarbeitungsphase des SHA256-Algorithmus übergehen: die Kompressionsfunktion. Dieser Schritt ist sehr wichtig, da er hauptsächlich die kryptografischen Eigenschaften der Hash-Funktion verleiht, die wir im vorherigen Kapitel untersucht haben.

Zuerst beginnen wir damit, unsere ausgeglichene Nachricht (Ergebnis der Vorverarbeitungsschritte) in mehrere Blöcke $P$ von jeweils 512 Bits aufzuteilen. Wenn unsere ausgeglichene Nachricht eine Gesamtgröße von $n \times 512$ Bits hat, werden wir daher $n$ Blöcke haben, jeder davon mit 512 Bits. Jeder 512-Bit-Block wird einzeln von der Kompressionsfunktion verarbeitet, die aus 64 Runden aufeinanderfolgender Operationen besteht. Nennen wir diese Blöcke $P_1$ , $P_2$ , $P_3$ ...

Logische Operationen

Bevor wir die Kompressionsfunktion im Detail erkunden, ist es wichtig, die grundlegenden logischen Operationen zu verstehen, die darin verwendet werden. Diese Operationen, basierend auf der Booleschen Algebra, arbeiten auf Bit-Ebene. Die grundlegenden logischen Operationen, die verwendet werden, sind:

Konjunktion (UND): bezeichnet mit $\land$ , entspricht einem logischen "UND".
Disjunktion (ODER): bezeichnet mit $\lor$ , entspricht einem logischen "ODER".
Negation (NICHT): bezeichnet mit $\lnot$ , entspricht einem logischen "NICHT".

Aus diesen grundlegenden Operationen können wir komplexere Operationen definieren, wie das "Exklusive ODER" (XOR) bezeichnet mit $\oplus$ , das in der Kryptografie weit verbreitet ist. Jede logische Operation kann durch eine Wahrheitstabelle dargestellt werden, die das Ergebnis für alle möglichen Kombinationen von binären Eingabewerten (zwei Operanden $p$ und $q$ ) angibt.

Für XOR ( $\oplus$ ):

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

Für AND ( $\land$ ):

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

Für NOT ( $\lnot p$ ):

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

Nehmen wir ein Beispiel, um die Operation von XOR auf Bit-Ebene zu verstehen. Wenn wir zwei Binärzahlen mit 6 Bits haben:

$a = 101100$
$b = 001000$

Dann:

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

Durch Anwendung von XOR Bit für Bit:

Bit Position	$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

Das Ergebnis ist daher $100100$ .

Zusätzlich zu logischen Operationen verwendet die Kompressionsfunktion Bit-Schiebeoperationen, die eine wesentliche Rolle bei der Diffusion von Bits im Algorithmus spielen werden.

Zuerst gibt es die logische Rechtsverschiebung, bezeichnet mit $ShR_n(x)$ , die alle Bits von $x$ um $n$ Positionen nach rechts verschiebt und die freien Bits links mit Nullen füllt.

Zum Beispiel, für $x = 101100001$ (auf 9 Bits) und $n = 4$ :

 $ShR_4(101100001) = 000010110$

Schematisch könnte die Rechtsverschiebung so aussehen:

CYP201 Eine weitere in SHA256 für die Bitmanipulation verwendete Operation ist die rechte zirkuläre Rotation, bezeichnet mit $RotR_n(x)$ , die die Bits von $x$ um $n$ Positionen nach rechts verschiebt und die verschobenen Bits am Anfang der Zeichenkette wieder einfügt. Zum Beispiel, für $x = 101100001$ (über 9 Bits) und $n = 4$ :

 $RotR_4(101100001) = 000110110$

Schematisch könnte die rechte zirkuläre Verschiebung so aussehen:

Kompressionsfunktion

Jetzt, da wir die grundlegenden Operationen verstanden haben, betrachten wir die SHA256-Kompressionsfunktion im Detail.

Im vorherigen Schritt haben wir unsere Eingabe in mehrere 512-Bit-Teile $P$ unterteilt. Für jeden 512-Bit-Block $P$ haben wir:

Die Nachrichtenwörter $W_i$ : für $i$ von 0 bis 63.
Die Konstanten $K_i$ : für $i$ von 0 bis 63, definiert im vorherigen Schritt.
Die Zustandsvariablen $A, B, C, D, E, F, G, H$ : initialisiert mit den Werten aus dem vorherigen Schritt.

Die ersten 16 Wörter, $W_0$ bis $W_{15}$ , werden direkt aus dem verarbeiteten 512-Bit-Block $P$ extrahiert. Jedes Wort $W_i$ besteht aus 32 aufeinanderfolgenden Bits des Blocks. So nehmen wir zum Beispiel unser erstes Stück Eingabe $P_1$ und teilen es weiter in kleinere 32-Bit-Stücke auf, die wir Wörter nennen. Die nächsten 48 Wörter ( $W_{16}$ bis $W_{63}$ ) werden mit der folgenden Formel generiert:

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

Mit:

$\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)$

In diesem Fall entspricht $x$ $W_{i-15}$ für $\sigma_0(x)$ und $W_{i-2}$ für $\sigma_1(x)$ .

Sobald wir alle Wörter $W_i$ für unser 512-Bit-Stück bestimmt haben, können wir zur Kompressionsfunktion übergehen, die aus 64 Runden besteht.

CYP201 Für jede Runde $i$ von 0 bis 63 haben wir drei verschiedene Arten von Eingaben. Zuerst die $W_i$ , die wir gerade bestimmt haben, teilweise bestehend aus unserem Nachrichtenstück $P_n$ . Als Nächstes die 64 Konstanten $K_i$ . Schließlich verwenden wir die Zustandsvariablen $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ und $H$ , die sich im Laufe des Hashing-Prozesses entwickeln und mit jeder Kompressionsfunktion modifiziert werden. Jedoch verwenden wir für das erste Stück $P_1$ die zuvor gegebenen Anfangskonstanten. Wir führen dann die folgenden Operationen mit unseren Eingaben durch:

Funktion $\Sigma_0$ :

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

Funktion $\Sigma_1$ :

 $\Sigma_1(E) = RotR_6(E) \oplus RotR_{11}(E) \oplus RotR_{25}(E)$$ - **Funktion $Ch$ ("*Wählen*"):**$

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

 $- **Funktion $Maj$ ("*Mehrheit*"):**$

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

 $Dann berechnen wir 2 temporäre Variablen: - $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}

 $Anschließend aktualisieren wir die Zustandsvariablen wie folgt:$

\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}

 $Das folgende Diagramm stellt eine Runde der SHA256-Kompressionsfunktion dar, wie wir sie gerade beschrieben haben: ![CYP201](/courses/cyp201/assets/fr/010.webp) - Die Pfeile zeigen den Datenfluss an; - Die Kästen repräsentieren die durchgeführten Operationen; - Das $+$ in einem Kreis repräsentiert die Addition modulo $2^{32}$. Wir können bereits beobachten, dass diese Runde neue Zustandsvariablen $A$, $B$, $C$, $D$, $E$, $F$, $G$ und $H$ ausgibt. Diese neuen Variablen dienen als Eingabe für die nächste Runde, die wiederum neue Variablen $A$, $B$, $C$, $D$, $E$, $F$, $G$ und $H$ produziert, die für die folgende Runde verwendet werden. Dieser Prozess setzt sich bis zur 64. Runde fort. Nach den 64 Runden aktualisieren wir die Anfangswerte der Zustandsvariablen, indem wir sie zu den Endwerten am Ende der 64. Runde addieren:$

\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}

 $Diese neuen Werte von $A$, $B$, $C$, $D$, $E$, $F$, $G$ und $H$ dienen als die Anfangswerte für den nächsten Block, $P_2$. Für diesen Block $P_2$ replizieren wir denselben Kompressionsprozess mit 64 Runden, dann aktualisieren wir die Variablen für Block $P_3$ und so weiter bis zum letzten Block unseres ausgeglichenen Inputs. Nach der Verarbeitung aller Nachrichtenblöcke fügen wir die Endwerte der Variablen $A$, $B$, $C$, $D$, $E$, $F$, $G$ und $H$ zusammen, um den endgültigen 256-Bit-Hash unserer Hashing-Funktion zu bilden:$

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

 $Jede Variable ist ein 32-Bit-Integer, daher ergibt ihre Verkettung immer ein 256-Bit-Ergebnis, unabhängig von der Größe unserer Nachrichteneingabe in die Hashing-Funktion. ### Begründung der kryptografischen Eigenschaften Aber wie ist diese Funktion irreversibel, kollisionsresistent und manipulationssicher? Die Manipulationssicherheit ist recht einfach zu verstehen. Es werden so viele Berechnungen in Kaskade durchgeführt, die sowohl von der Eingabe als auch von den Konstanten abhängen, dass die geringste Modifikation der Anfangsnachricht den genommenen Pfad vollständig ändert und somit den Ausgabe-Hash komplett verändert. Dies wird als Lawineneffekt bezeichnet. Diese Eigenschaft wird teilweise durch das Mischen der Zwischenzustände mit den Anfangszuständen für jedes Stück sichergestellt. Als Nächstes, wenn wir über eine kryptographische Hashfunktion sprechen, wird der Begriff "Irreversibilität" normalerweise nicht verwendet. Stattdessen sprechen wir über "Preimage-Resistenz", was spezifiziert, dass es für ein gegebenes $y$ schwierig ist, ein $x$ zu finden, so dass $h(x) = y$. Diese Preimage-Resistenz wird durch die algebraische Komplexität und die starke Nichtlinearität der Operationen, die in der Kompressionsfunktion durchgeführt werden, sowie durch den Verlust bestimmter Informationen im Prozess garantiert. Zum Beispiel gibt es für ein gegebenes Ergebnis einer Addition modulo mehrere mögliche Operanden:$

3+2 \mod 10 = 5 \ 7+8 \mod 10 = 5 \ 5+10 \mod 10 = 5

 $In diesem Beispiel kann man, wenn nur das verwendete Modulo (10) und das Ergebnis (5) bekannt sind, nicht mit Sicherheit bestimmen, welche die korrekten Operanden bei der Addition waren. Es wird gesagt, dass es mehrere Kongruenzen modulo 10 gibt. Beim XOR-Betrieb stehen wir vor demselben Problem. Erinnern wir uns an die Wahrheitstabelle für diese Operation: Jedes 1-Bit-Ergebnis kann durch zwei verschiedene Eingangskonfigurationen bestimmt werden, die genau die gleiche Wahrscheinlichkeit haben, die richtigen Werte zu sein. Daher kann man die Operanden eines XOR nicht mit Sicherheit bestimmen, wenn nur sein Ergebnis bekannt ist. Wenn wir die Größe der XOR-Operanden erhöhen, steigt die Anzahl der möglichen Eingaben, die nur das Ergebnis kennen, exponentiell. Darüber hinaus wird XOR oft zusammen mit anderen bitweisen Operationen verwendet, wie der $\text{RotR}$-Operation, die noch mehr mögliche Interpretationen zum Ergebnis hinzufügen. Die Kompressionsfunktion verwendet auch die $\text{ShR}$-Operation. Diese Operation entfernt einen Teil der grundlegenden Informationen, die später unmöglich wiederhergestellt werden können. Auch hier gibt es kein algebraisches Mittel, um diese Operation umzukehren. Alle diese Einweg- und Informationsverlustoperationen werden sehr häufig in Kompressionsfunktionen verwendet. Die Anzahl der möglichen Eingaben für ein gegebenes Ausgabe ist somit fast unendlich, und jeder Versuch einer Rückberechnung würde zu Gleichungen mit einer sehr hohen Anzahl von Unbekannten führen, die bei jedem Schritt exponentiell ansteigen würden. Schließlich, für das Merkmal der Kollisionsresistenz, kommen mehrere Parameter ins Spiel. Die Vorverarbeitung der ursprünglichen Nachricht spielt eine wesentliche Rolle. Ohne diese Vorverarbeitung könnte es einfacher sein, Kollisionen in der Funktion zu finden. Obwohl theoretisch Kollisionen existieren (aufgrund des Schubfachprinzips), macht die Struktur der Hashfunktion, kombiniert mit den zuvor genannten Eigenschaften, die Wahrscheinlichkeit, eine Kollision zu finden, extrem niedrig. Damit eine Hashfunktion kollisionsresistent ist, ist es wesentlich, dass: - Das Ergebnis unvorhersehbar ist: Jede Vorhersehbarkeit kann ausgenutzt werden, um Kollisionen schneller als mit einem Brute-Force-Angriff zu finden. Die Funktion stellt sicher, dass jedes Bit des Ausgangs auf eine nicht-triviale Weise vom Eingang abhängt. Mit anderen Worten, die Funktion ist so konzipiert, dass jedes Bit des Endergebnisses eine unabhängige Wahrscheinlichkeit hat, 0 oder 1 zu sein, auch wenn diese Unabhängigkeit in der Praxis nicht absolut ist. - Die Verteilung der Hashes ist pseudo-zufällig: Dies stellt sicher, dass die Hashes gleichmäßig verteilt sind. - Die Größe des Hashs ist erheblich: je größer der mögliche Raum für Ergebnisse, desto schwieriger ist es, eine Kollision zu finden. Kryptographen entwerfen diese Funktionen, indem sie die bestmöglichen Angriffe zur Findung von Kollisionen bewerten und dann die Parameter anpassen, um diese Angriffe unwirksam zu machen. ### Merkle-Damgård-Konstruktion Die Struktur von SHA256 basiert auf der Merkle-Damgård-Konstruktion, die es ermöglicht, eine Kompressionsfunktion in eine Hashfunktion umzuwandeln, die Nachrichten beliebiger Länge verarbeiten kann. Genau das haben wir in diesem Kapitel gesehen. Allerdings sind einige alte Hash-Funktionen wie SHA1 oder MD5, die diese spezifische Konstruktion verwenden, anfällig für Length-Extension-Angriffe. Dies ist eine Technik, die es einem Angreifer, der den Hash eines Nachricht $M$ und die Länge von $M$ kennt (ohne die Nachricht selbst zu kennen), ermöglicht, den Hash einer Nachricht $M'$ zu berechnen, die durch das Anhängen von zusätzlichem Inhalt an $M$ gebildet wird. SHA256, obwohl es denselben Typ von Konstruktion verwendet, ist theoretisch resistent gegen diesen Typ von Angriff, im Gegensatz zu SHA1 und MD5. Dies könnte das Geheimnis des doppelten Hashings erklären, das in Bitcoin von Satoshi Nakamoto implementiert wurde. Um diesen Typ von Angriff zu vermeiden, könnte Satoshi es bevorzugt haben, ein doppeltes SHA256 zu verwenden:$

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

 $Dies erhöht die Sicherheit gegen potenzielle Angriffe, die mit der Merkle-Damgård-Konstruktion zusammenhängen, erhöht jedoch nicht die Sicherheit des Hashing-Prozesses in Bezug auf Kollisionsresistenz. Darüber hinaus hätte selbst wenn SHA256 für diesen Typ von Angriff anfällig gewesen wäre, dies keinen ernsthaften Einfluss gehabt, da alle Anwendungsfälle von Hash-Funktionen in Bitcoin öffentliche Daten betreffen. Der Length-Extension-Angriff könnte jedoch nur für einen Angreifer nützlich sein, wenn die gehashten Daten privat sind und der Benutzer die Hash-Funktion als Authentifizierungsmechanismus für diese Daten verwendet hat, ähnlich einem MAC. Daher bleibt die Implementierung des doppelten Hashings ein Geheimnis im Design von Bitcoin. Jetzt, da wir uns im Detail mit der Funktionsweise von Hash-Funktionen, insbesondere SHA256, das in Bitcoin umfangreich verwendet wird, beschäftigt haben, werden wir uns spezifischer auf die kryptografischen Ableitungsalgorithmen konzentrieren, die auf Anwendungsebene verwendet werden, insbesondere für die Ableitung der Schlüssel für Ihre Wallet. ## Die für die Ableitung verwendeten Algorithmen <chapterId>cc668121-7789-5e99-bf5e-1ba085f4f5f2</chapterId> In Bitcoin auf Anwendungsebene werden neben Hash-Funktionen kryptografische Ableitungsalgorithmen verwendet, um sichere Daten aus anfänglichen Eingaben zu generieren. Obwohl diese Algorithmen auf Hash-Funktionen basieren, dienen sie unterschiedlichen Zwecken, insbesondere in Bezug auf Authentifizierung und Schlüsselgenerierung. Diese Algorithmen behalten einige der Eigenschaften von Hash-Funktionen bei, wie Irreversibilität, Manipulationssicherheit und Kollisionsresistenz. In Bitcoin-Wallets werden hauptsächlich 2 Ableitungsalgorithmen verwendet: - **HMAC (*Hash-based Message Authentication Code*)** - **PBKDF2 (*Password-Based Key Derivation Function 2*)** Wir werden gemeinsam die Funktionsweise und Rolle jedes von ihnen erkunden. ### HMAC-SHA512 HMAC ist ein kryptografischer Algorithmus, der einen Authentifizierungscode basierend auf einer Kombination aus einer Hash-Funktion und einem geheimen Schlüssel berechnet. Bitcoin verwendet HMAC-SHA512, die Variante von HMAC, die die SHA512-Hash-Funktion verwendet. Wir haben bereits im vorherigen Kapitel gesehen, dass SHA512 zur gleichen Familie von Hash-Funktionen wie SHA256 gehört, aber eine 512-Bit-Ausgabe produziert. Hier ist sein allgemeines Betriebsschema mit $m$ als Eingangsnachricht und $K$ als geheimem Schlüssel: ![CYP201](/courses/cyp201/assets/fr/011.webp) Lassen Sie uns im Detail untersuchen, was in dieser HMAC-SHA512-Blackbox passiert. Die HMAC-SHA512-Funktion mit: - $m$: die beliebig große Nachricht, die vom Benutzer gewählt wird (erster Eingang); - $K$: der beliebige geheime Schlüssel, der vom Benutzer gewählt wird (zweiter Eingang); - $K'$: der Schlüssel $K$, angepasst an die Größe $B$ der Hash-Funktionsblöcke (1024 Bits für SHA512, oder 128 Bytes); - $\text{SHA512}$: die SHA512-Hash-Funktion; - $\oplus$: die XOR (exklusives Oder) Operation; - $\Vert$: der Verkettungsoperator, der Bitstrings Ende-zu-Ende verbindet; - $\text{opad}$: Konstante, bestehend aus dem Byte $0x5c$, das 128 Mal wiederholt wird - $\text{ipad}$: Konstante, bestehend aus dem Byte $0x36$, das 128 Mal wiederholt wird Bevor der HMAC berechnet wird, ist es notwendig, den Schlüssel und die Konstanten entsprechend der Blockgröße $B$ anzugleichen. Wenn zum Beispiel der Schlüssel $K$ kürzer als 128 Bytes ist, wird er mit Nullen aufgefüllt, um die Größe $B$ zu erreichen. Ist $K$ länger als 128 Bytes, wird er mit SHA512 komprimiert und dann mit Nullen aufgefüllt, bis er 128 Bytes erreicht. Auf diese Weise wird ein angeglichener Schlüssel namens $K'$ erhalten. Die Werte von $\text{opad}$ und $\text{ipad}$ werden erhalten, indem ihr Basisbyte ($0x5c$ für $\text{opad}$, $0x36$ für $\text{ipad}$) wiederholt wird, bis die Größe $B$ erreicht ist. Somit haben wir mit $B = 128$ Bytes:$

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

 $Sobald die Vorverarbeitung abgeschlossen ist, wird der HMAC-SHA512-Algorithmus durch die folgende Gleichung definiert:$

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

 $Diese Gleichung wird in die folgenden Schritte unterteilt: - XOR des angeglichenen Schlüssels $K'$ mit $\text{ipad}$, um $\text{iKpad}$ zu erhalten; - XOR des angeglichenen Schlüssels $K'$ mit $\text{opad}$, um $\text{oKpad}$ zu erhalten; - Verkettung von $\text{iKpad}$ mit der Nachricht $m$. - Hashen dieses Ergebnisses mit SHA512, um einen Zwischenhash $H_1$ zu erhalten. - Verkettung von $\text{oKpad}$ mit $H_1$. - Hashen dieses Ergebnisses mit SHA512, um das endgültige Ergebnis $H_2$ zu erhalten. Diese Schritte können schematisch wie folgt zusammengefasst werden: ![CYP201](/courses/cyp201/assets/fr/012.webp) HMAC wird insbesondere in Bitcoin für die Schlüsselableitung in HD (Hierarchisch Deterministischen) Wallets verwendet (wir werden dies in den kommenden Kapiteln genauer besprechen) und als Komponente von PBKDF2. ### PBKDF2 PBKDF2 (*Password-Based Key Derivation Function 2*) ist ein Schlüsselableitungsalgorithmus, der entwickelt wurde, um die Sicherheit von Passwörtern zu erhöhen. Der Algorithmus wendet eine Pseudozufallsfunktion (hier HMAC-SHA512) auf ein Passwort und ein kryptografisches Salt an und wiederholt diese Operation eine bestimmte Anzahl von Malen, um einen Ausgabeschlüssel zu erzeugen. In Bitcoin wird PBKDF2 verwendet, um den Seed eines HD-Wallets aus einer mnemonischen Phrase und einer Passphrase zu generieren (aber wir werden dies in den kommenden Kapiteln genauer besprechen). Der PBKDF2-Prozess ist wie folgt, mit: - $m$: die mnemonische Phrase des Benutzers; - $s$: die optionale Passphrase zur Erhöhung der Sicherheit (leeres Feld, wenn keine Passphrase); - $n$: die Anzahl der Iterationen der Funktion, in unserem Fall sind es 2048. Die PBKDF2-Funktion ist iterativ definiert. Jede Iteration nimmt das Ergebnis der vorherigen, leitet es durch HMAC-SHA512 und kombiniert die aufeinanderfolgenden Ergebnisse, um den endgültigen Schlüssel zu produzieren:$

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

y^2 = x^3 + ax + b

 $### secp256k1 Um ECDSA oder Schnorr zu verwenden, muss man die Parameter der elliptischen Kurve wählen, das heißt, die Werte von $a$ und $b$ in der Kurvengleichung. Es gibt verschiedene Standards elliptischer Kurven, die als kryptografisch sicher gelten. Der bekannteste ist die *secp256r1*-Kurve, die vom NIST (*National Institute of Standards and Technology*) definiert und empfohlen wird. Trotzdem entschied sich Satoshi Nakamoto, der Erfinder von Bitcoin, diese Kurve nicht zu verwenden. Der Grund für diese Wahl ist unbekannt, aber einige glauben, er bevorzugte eine Alternative, weil die Parameter dieser Kurve potenziell einen Hintertür enthalten könnten. Stattdessen verwendet das Bitcoin-Protokoll den Standard ***secp256k1***. Diese Kurve ist durch die Parameter $a = 0$ und $b = 7$ definiert. Ihre Gleichung ist daher:$

y^2 = x^3 + 7

 $Ihre grafische Darstellung über dem Feld der reellen Zahlen sieht folgendermaßen aus: ![CYP201](/courses/cyp201/assets/fr/015.webp) In der Kryptographie arbeiten wir jedoch mit endlichen Zahlenmengen. Genauer gesagt arbeiten wir im endlichen Feld $\mathbb{F}_p$, welches das Feld der ganzen Zahlen modulo einer Primzahl $p$ ist. **Definition**: Eine Primzahl ist eine natürliche ganze Zahl, die größer oder gleich 2 ist und nur zwei verschiedene positive ganze Zahlenteiler hat: 1 und sich selbst. Zum Beispiel ist die Zahl 7 eine Primzahl, da sie nur durch 1 und 7 geteilt werden kann. Andererseits ist die Zahl 8 keine Primzahl, weil sie durch 1, 2, 4 und 8 geteilt werden kann. Bei Bitcoin wird die Primzahl $p$, die verwendet wird, um das endliche Feld zu definieren, sehr groß gewählt. Sie wird so ausgewählt, dass die Ordnung des Feldes (d.h. die Anzahl der Elemente in $\mathbb{F}_p$) ausreichend groß ist, um kryptografische Sicherheit zu gewährleisten. Die verwendete Primzahl $p$ ist: ```text p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F ``` In Dezimalschreibweise entspricht dies:$

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

 $Daher ist die Gleichung unserer elliptischen Kurve tatsächlich:$

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

 $Da diese Kurve über das endliche Feld $\mathbb{F}_p$ definiert ist, ähnelt sie nicht mehr einer kontinuierlichen Kurve, sondern eher einer diskreten Menge von Punkten. Zum Beispiel sieht hier die in Bitcoin verwendete Kurve für ein sehr kleines $p = 17$ so aus: ![CYP201](/courses/cyp201/assets/fr/016.webp) In diesem Beispiel habe ich das endliche Feld absichtlich auf $p = 17$ beschränkt, aus pädagogischen Gründen, aber man muss sich vorstellen, dass das in Bitcoin verwendete um ein Vielfaches größer ist, fast $2^{256}$. Wir verwenden ein endliches Feld ganzer Zahlen modulo $p$, um die Genauigkeit der Operationen auf der Kurve zu gewährleisten. Tatsächlich sind elliptische Kurven über dem Feld der reellen Zahlen aufgrund von Rundungsfehlern bei Berechnungen ungenau. Werden zahlreiche Operationen auf der Kurve durchgeführt, sammeln sich diese Fehler an und das Endergebnis kann falsch oder schwer zu reproduzieren sein. Die ausschließliche Verwendung positiver ganzer Zahlen gewährleistet eine perfekte Genauigkeit der Berechnungen und somit die Reproduzierbarkeit des Ergebnisses. Die Mathematik der elliptischen Kurven über endlichen Feldern ist analog zu der über dem Feld der reellen Zahlen, mit der Anpassung, dass alle Operationen modulo $p$ durchgeführt werden. Um die Erklärungen zu vereinfachen, werden wir in den folgenden Kapiteln weiterhin Konzepte anhand einer Kurve, die über reelle Zahlen definiert ist, veranschaulichen, während wir im Hinterkopf behalten, dass die Kurve in der Praxis über ein endliches Feld definiert ist. Wenn Sie mehr über die mathematischen Grundlagen der modernen Kryptographie erfahren möchten, empfehle ich auch, diesen anderen Kurs im Plan ₿ Network zu konsultieren: https://planb.network/courses/d2fd9fc0-d9ed-4a87-9fa3-0fdbb3937e28 ## Berechnung des öffentlichen Schlüssels aus dem privaten Schlüssel <chapterId>fcb2bd58-5dda-5ecf-bb8f-ad1a0561ab4a</chapterId> Wie zuvor gesehen, basieren die digitalen Signaturalgorithmen bei Bitcoin auf einem Paar von privaten und öffentlichen Schlüsseln, die mathematisch miteinander verknüpft sind. Lassen Sie uns gemeinsam erkunden, was diese mathematische Verknüpfung ist und wie sie generiert werden. ### Der private Schlüssel Der private Schlüssel ist einfach eine zufällige oder pseudozufällige Zahl. Im Fall von Bitcoin ist diese Zahl 256 Bit groß. Die Anzahl der Möglichkeiten für einen Bitcoin-privaten Schlüssel ist daher theoretisch $2^{256}$. **Hinweis**: Eine "pseudo-zufällige Zahl" ist eine Zahl, die Eigenschaften aufweist, die denen einer wirklich zufälligen Zahl nahekommen, aber durch einen deterministischen Algorithmus erzeugt wird. In der Praxis gibt es jedoch nur $n$ unterschiedliche Punkte auf unserer elliptischen Kurve secp256k1, wobei $n$ die Ordnung des Generatorpunkts $G$ der Kurve ist. Wir werden später sehen, was diese Zahl bedeutet, aber merken Sie sich einfach, dass ein gültiger privater Schlüssel eine ganze Zahl zwischen $1$ und $n-1$ ist, wobei $n$ eine Zahl ist, die nahe, aber etwas weniger als $2^{256}$ ist. Daher gibt es einige 256-Bit-Zahlen, die nicht gültig sind, um ein privater Schlüssel in Bitcoin zu werden, speziell alle Zahlen zwischen $n$ und $2^{256}$. Wenn die Erzeugung der Zufallszahl (der private Schlüssel) einen Wert $k$ ergibt, sodass $k \geq n$ ist, wird er als ungültig betrachtet, und ein neuer Zufallswert muss generiert werden. Die Anzahl der Möglichkeiten für einen Bitcoin-privaten Schlüssel beträgt daher etwa $n$, was einer Zahl nahe $1.158 \times 10^{77}$ entspricht. Diese Zahl ist so groß, dass es statistisch fast unmöglich ist, zufällig auf den privaten Schlüssel eines anderen Benutzers zu stoßen, wenn Sie einen privaten Schlüssel zufällig wählen. Um Ihnen eine Vorstellung von der Größenordnung zu geben, die Anzahl der möglichen privaten Schlüssel bei Bitcoin liegt in einer Größenordnung nahe der geschätzten Atome im beobachtbaren Universum. Wie wir in den kommenden Kapiteln sehen werden, werden heute die meisten privaten Schlüssel bei Bitcoin nicht zufällig generiert, sondern sind das Ergebnis einer deterministischen Ableitung aus einer mnemonischen Phrase, die selbst pseudo-zufällig ist (dies ist die berühmte Phrase aus 12 oder 24 Wörtern). Diese Information ändert nichts an der Verwendung von Signaturalgorithmen wie ECDSA, hilft aber, unseren Popularisierungsansatz auf Bitcoin zu fokussieren. Für die Fortsetzung der Erklärung wird der private Schlüssel durch den Kleinbuchstaben $k$ dargestellt. ### Der öffentliche Schlüssel Der öffentliche Schlüssel ist ein Punkt auf der elliptischen Kurve, dargestellt durch den Großbuchstaben $K$, und wird aus dem privaten Schlüssel $k$ berechnet. Dieser Punkt $K$ wird durch ein Paar von Koordinaten $(x, y)$ auf der elliptischen Kurve repräsentiert, wobei jede Koordinate eine ganze Zahl modulo $p$ ist, der Primzahl, die das endliche Feld $\mathbb{F}_p$ definiert. In der Praxis wird ein unkomprimierter öffentlicher Schlüssel durch 512 Bits (oder 64 Bytes) dargestellt, die zwei 256-Bit-Zahlen ($x$ und $y$) entsprechen, die hintereinander platziert sind. Diese Zahlen sind die Abszisse ($x$) und die Ordinate ($y$) unseres Punktes auf secp256k1. Wenn wir das Präfix hinzufügen, summiert sich der öffentliche Schlüssel auf 520 Bits. Es ist jedoch auch möglich, den öffentlichen Schlüssel in einer komprimierten Form darzustellen, die nur 33 Bytes (264 Bits) verwendet, indem nur die Abszisse $x$ unseres Punktes auf der Kurve und ein Byte, das die Parität von $y$ angibt, beibehalten wird. Dies ist als komprimierter öffentlicher Schlüssel bekannt. Ich werde in den letzten Kapiteln dieses Trainings mehr darüber sprechen. Aber was Sie sich merken müssen, ist, dass ein öffentlicher Schlüssel $K$ ein Punkt ist, der durch $x$ und $y$ beschrieben wird. Um den Punkt $K$ zu berechnen, der unserem öffentlichen Schlüssel entspricht, verwenden wir die Operation der skalaren Multiplikation auf elliptischen Kurven, definiert als eine wiederholte Addition ($k$-mal) des Generatorpunkts $G$:$

K = k \cdot G

 $wo: - $k$ ist der private Schlüssel (eine zufällige ganze Zahl zwischen $1$ und $n-1$); - $G$ ist der Generatorpunkt der elliptischen Kurve, der von allen Teilnehmern des Bitcoin-Netzwerks verwendet wird; - $\cdot$ repräsentiert die skalare Multiplikation auf der elliptischen Kurve, was dem Hinzufügen des Punktes $G$ zu sich selbst $k$ Mal entspricht. Die Tatsache, dass dieser Punkt $G$ allen öffentlichen Schlüsseln auf Bitcoin gemeinsam ist, ermöglicht es uns sicherzustellen, dass der gleiche private Schlüssel $k$ uns immer den gleichen öffentlichen Schlüssel $K$ geben wird: ![CYP201](/courses/cyp201/assets/fr/017.webp) Die Hauptcharakteristik dieser Operation ist, dass sie eine Einwegfunktion ist. Es ist einfach, den öffentlichen Schlüssel $K$ zu berechnen, wenn man den privaten Schlüssel $k$ und den Generatorpunkt $G$ kennt, aber es ist praktisch unmöglich, den privaten Schlüssel $k$ zu berechnen, wenn man nur den öffentlichen Schlüssel $K$ und den Generatorpunkt $G$ kennt. $k$ aus $K$ und $G$ zu finden, entspricht der Lösung des diskreten Logarithmusproblems auf elliptischen Kurven, ein mathematisch schwieriges Problem, für das kein effizienter Algorithmus bekannt ist. Selbst die leistungsfähigsten aktuellen Rechner sind nicht in der Lage, dieses Problem in einer vernünftigen Zeit zu lösen. ![CYP201](/courses/cyp201/assets/fr/018.webp) ### Addition und Verdopplung von Punkten auf elliptischen Kurven Das Konzept der Addition auf elliptischen Kurven ist geometrisch definiert. Wenn wir zwei Punkte $P$ und $Q$ auf der Kurve haben, wird die Operation $P + Q$ berechnet, indem eine Linie gezeichnet wird, die durch $P$ und $Q$ verläuft. Diese Linie wird die Kurve notwendigerweise an einem dritten Punkt $R'$ schneiden. Wir nehmen dann das Spiegelbild dieses Punktes bezüglich der x-Achse, um den Punkt $R$ zu erhalten, der das Ergebnis der Addition ist:$

P + Q = R

 $Grafisch kann dies wie folgt dargestellt werden: ![CYP201](/courses/cyp201/assets/fr/019.webp) Für die Verdopplung eines Punktes, also die Operation $P + P$, zeichnen wir die Tangente an die Kurve am Punkt $P$. Diese Tangente schneidet die Kurve an einem anderen Punkt $S'$. Wir nehmen dann das Spiegelbild dieses Punktes bezüglich der x-Achse, um den Punkt $S$ zu erhalten, der das Ergebnis der Verdopplung ist:$

2P = S

 $Grafisch wird dies gezeigt als: ![CYP201](/courses/cyp201/assets/fr/020.webp) Durch die Verwendung dieser Operationen der Addition und Verdopplung können wir die skalare Multiplikation eines Punktes mit einer ganzen Zahl $k$, bezeichnet als $kP$, durchführen, indem wiederholte Verdopplungen und Additionen durchgeführt werden. Nehmen wir zum Beispiel an, wir haben einen privaten Schlüssel $k = 4$ gewählt. Um den zugehörigen öffentlichen Schlüssel zu berechnen, führen wir aus:$

K = k \cdot G = 4G

 $Grafisch entspricht dies der Durchführung einer Reihe von Additionen und Verdopplungen: - Berechne $2G$ durch Verdopplung von $G$. - Berechne $4G$ durch Verdopplung von $2G$. ![CYP201](/courses/cyp201/assets/fr/021.webp) Wenn wir zum Beispiel den Punkt $3G$ berechnen möchten, müssen wir zuerst den Punkt $2G$ durch Verdopplung des Punktes $G$ berechnen, dann $G$ und $2G$ addieren. Um $G$ und $2G$ zu addieren, zeichnen wir einfach die Linie, die diese beiden Punkte verbindet, holen den einzigartigen Punkt $-3G$ am Schnittpunkt zwischen dieser Linie und der elliptischen Kurve und bestimmen dann $3G$ als das Gegenteil von $-3G$. Wir werden haben:$

G + G = 2G

2G + G = 3G

 $Grafisch würde dies wie folgt dargestellt: ![CYP201](/courses/cyp201/assets/fr/022.webp) ### Einwegfunktion Dank dieser Operationen können wir verstehen, warum es einfach ist, einen öffentlichen Schlüssel aus einem privaten Schlüssel abzuleiten, aber das Umgekehrte praktisch unmöglich ist. Kehren wir zu unserem vereinfachten Beispiel zurück. Mit einem privaten Schlüssel $k = 4$. Um den zugehörigen öffentlichen Schlüssel zu berechnen, führen wir aus:$

K = k \cdot G = 4G

 $Wir haben somit den öffentlichen Schlüssel $K$ leicht berechnen können, indem wir $k$ und $G$ kannten. Wenn jemand jedoch nur den öffentlichen Schlüssel $K$ kennt, steht er vor dem Problem des diskreten Logarithmus: das Finden von $k$ so, dass $K = k \cdot G$. Dieses Problem gilt als schwierig, weil es keinen effizienten Algorithmus gibt, um es auf elliptischen Kurven zu lösen. Dies gewährleistet die Sicherheit der ECDSA- und Schnorr-Algorithmen. Natürlich wäre es in diesem vereinfachten Beispiel mit $k = 4$ möglich, $k$ durch Ausprobieren zu finden, da die Anzahl der Möglichkeiten gering ist. In der Praxis bei Bitcoin ist $k$ jedoch eine 256-Bit-Ganzzahl, was die Anzahl der Möglichkeiten astronomisch groß macht (ungefähr $1.158 \times 10^{77}$). Daher ist es undurchführbar, $k$ durch Brute-Force zu finden. ## Signieren mit dem privaten Schlüssel <chapterId>bb07826f-826e-5905-b307-3d82001fb778</chapterId> Jetzt, da Sie wissen, wie man einen öffentlichen Schlüssel aus einem privaten Schlüssel ableitet, können Sie bereits Bitcoins empfangen, indem Sie dieses Schlüsselpaar als Ausgabebedingung verwenden. Aber wie gibt man sie aus? Um Bitcoins auszugeben, müssen Sie das _scriptPubKey_ entsperren, das an Ihr UTXO angehängt ist, um zu beweisen, dass Sie tatsächlich dessen legitimer Besitzer sind. Dazu müssen Sie eine Signatur $s$ erzeugen, die zum öffentlichen Schlüssel $K$ passt, der im _scriptPubKey_ vorhanden ist, indem Sie den privaten Schlüssel $k$ verwenden, der ursprünglich verwendet wurde, um $K$ zu berechnen. Die digitale Signatur ist somit ein unwiderlegbarer Beweis dafür, dass Sie im Besitz des privaten Schlüssels sind, der mit dem öffentlichen Schlüssel verbunden ist, den Sie beanspruchen. ### Elliptische Kurvenparameter Um eine digitale Signatur durchzuführen, müssen alle Teilnehmer zunächst die Parameter der verwendeten elliptischen Kurve vereinbaren. Im Fall von Bitcoin sind die Parameter von **secp256k1** wie folgt: Das endliche Feld $\mathbb{Z}_p$ definiert durch:$

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

 $```text p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F ``` $p$ ist eine sehr große Primzahl, die etwas kleiner als $2^{256}$ ist. Die elliptische Kurve $y^2 = x^3 + ax + b$ über $\mathbb{Z}_p$ definiert durch:$

a = 0, \quad b = 7

 $Der Generatorpunkt oder Ursprungspunkt $G$: ```text G = 0x0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798 ``` Diese Zahl ist die komprimierte Form, die nur die Abszisse des Punktes $G$ angibt. Das Präfix `02` am Anfang bestimmt, welche der beiden Werte mit dieser Abszisse $x$ als Erzeugungspunkt verwendet werden soll. Die Ordnung $n$ von $G$ (die Anzahl der existierenden Punkte) und der Kofaktor $h$: ```text n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 ``` $n$ ist eine sehr große Zahl, die etwas kleiner als $p$ ist.$

h=1

 $$h$ ist der Kofaktor oder die Anzahl der Untergruppen. Ich werde hier nicht näher darauf eingehen, was dies repräsentiert, da es ziemlich komplex ist, und im Fall von Bitcoin müssen wir dies nicht berücksichtigen, da es gleich $1$ ist. Alle diese Informationen sind öffentlich und allen Teilnehmern bekannt. Dank ihnen können Benutzer eine digitale Signatur erstellen und verifizieren. ### Signatur mit ECDSA Der ECDSA-Algorithmus ermöglicht es einem Benutzer, eine Nachricht mit seinem privaten Schlüssel zu signieren, sodass jeder, der den entsprechenden öffentlichen Schlüssel kennt, die Gültigkeit der Signatur überprüfen kann, ohne dass der private Schlüssel jemals offenbart wird. Im Kontext von Bitcoin hängt die zu signierende Nachricht vom _sighash_ ab, den der Benutzer wählt. Dieser _sighash_ bestimmt, welche Teile der Transaktion von der Signatur abgedeckt werden. Ich werde im nächsten Kapitel näher darauf eingehen. Hier sind die Schritte zur Erzeugung einer ECDSA-Signatur: Zuerst berechnen wir den Hash ($e$) der zu signierenden Nachricht. Die Nachricht $m$ wird also durch eine kryptografische Hash-Funktion geleitet, im Allgemeinen SHA256 oder doppeltes SHA256 im Fall von Bitcoin:$

e = \text{HASH}(m)

 $Als Nächstes berechnen wir einen Nonce. In der Kryptografie ist ein Nonce einfach eine Zahl, die auf zufällige oder pseudozufällige Weise generiert wird und nur einmal verwendet wird. Das heißt, jedes Mal, wenn eine neue digitale Signatur mit diesem Schlüsselpaar erstellt wird, ist es sehr wichtig, einen anderen Nonce zu verwenden, da sonst die Sicherheit des privaten Schlüssels gefährdet wird. Es reicht daher aus, eine zufällige und einzigartige ganze Zahl $r$ zu bestimmen, sodass $1 \leq r \leq n-1$, wobei $n$ die Ordnung des erzeugenden Punkts $G$ der elliptischen Kurve ist. Dann berechnen wir den Punkt $R$ auf der elliptischen Kurve mit den Koordinaten $(x_R, y_R)$, sodass:$

R = r \cdot G

 $Wir extrahieren den Wert der Abszisse des Punkts $R$ ($x_R$). Dieser Wert stellt den ersten Teil der Signatur dar. Und schließlich berechnen wir den zweiten Teil der Signatur $s$ auf folgende Weise:$

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

 $wobei: - $r^{-1}$ das modulare Inverse von $r$ modulo $n$ ist, das heißt, eine ganze Zahl, sodass $r \cdot r^{-1} \equiv 1 \mod n$; - $k$ ist der private Schlüssel des Benutzers; - $e$ ist der Hash der Nachricht; - $n$ ist die Ordnung des Generatorpunkts $G$ der elliptischen Kurve. Die Signatur ist dann einfach die Verkettung von $x_R$ und $s$:$

\text{SIG} = x_R \Vert s

 $### Überprüfung der ECDSA-Signatur Um eine Signatur $(x_R, s)$ zu überprüfen, kann jeder, der den öffentlichen Schlüssel $K$ und die Parameter der elliptischen Kurve kennt, auf folgende Weise vorgehen: Zuerst überprüfen Sie, ob $x_R$ und $s$ im Intervall $[1, n-1]$ liegen. Dies stellt sicher, dass die Signatur die mathematischen Einschränkungen der elliptischen Gruppe respektiert. Ist dies nicht der Fall, lehnt der Verifizierer die Signatur sofort als ungültig ab. Berechnen Sie dann den Hash des Nachricht:$

e = \text{HASH}(m)

 $Berechnen Sie das modulare Inverse von $s$ modulo $n$:$

s^{-1} \mod n

 $Berechnen Sie zwei Skalarwerte $u_1$ und $u_2$ auf diese Weise:$

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

 $Und schließlich berechnen Sie den Punkt $V$ auf der elliptischen Kurve, so dass:$

V = u_1 \cdot G + u_2 \cdot K

 $Die Signatur ist nur gültig, wenn $x_V \equiv x_R \mod n$, wobei $x_V$ die $x$-Koordinate des Punktes $V$ ist. Tatsächlich erhält man durch die Kombination von $u_1 \cdot G$ und $u_2 \cdot K$ einen Punkt $V$, der, wenn die Signatur gültig ist, dem Punkt $R$ entsprechen muss, der während der Signatur verwendet wurde (modulo $n$). ### Signatur mit dem Schnorr-Protokoll Das Schnorr-Signaturschema ist eine Alternative zu ECDSA, die viele Vorteile bietet. Seit 2021 und der Einführung von Taproot mit den P2TR-Skriptmustern ist es möglich, es bei Bitcoin zu verwenden. Wie ECDSA ermöglicht das Schnorr-Schema das Signieren einer Nachricht mit einem privaten Schlüssel, sodass die Signatur von jedem überprüft werden kann, der den entsprechenden öffentlichen Schlüssel kennt. Im Fall von Schnorr wird genau dieselbe Kurve wie bei ECDSA mit denselben Parametern verwendet. Öffentliche Schlüssel werden jedoch im Vergleich zu ECDSA etwas anders dargestellt. Tatsächlich werden sie nur durch die $x$-Koordinate des Punktes auf der elliptischen Kurve bezeichnet. Im Gegensatz zu ECDSA, wo komprimierte öffentliche Schlüssel durch 33 Bytes dargestellt werden (mit dem Präfixbyte, das die Parität von $y$ angibt), verwendet Schnorr 32-Byte öffentliche Schlüssel, die nur der $x$-Koordinate des Punktes $K$ entsprechen, und es wird standardmäßig angenommen, dass $y$ gerade ist. Diese vereinfachte Darstellung reduziert die Größe der Signaturen und erleichtert bestimmte Optimierungen in den Verifizierungsalgorithmen. Der öffentliche Schlüssel ist dann die $x$-Koordinate des Punktes $K$:$

\text{pk} = K_x

 $Der erste Schritt zur Generierung einer Signatur besteht darin, die Nachricht zu hashen. Aber im Gegensatz zu ECDSA wird dies mit anderen Werten gemacht und eine beschriftete Hash-Funktion wird verwendet, um Kollisionen in verschiedenen Kontexten zu vermeiden. Eine beschriftete Hash-Funktion beinhaltet einfach das Hinzufügen eines willkürlichen Labels zu den Eingaben der Hash-Funktion neben den Nachrichtendaten. ![CYP201](/courses/cyp201/assets/fr/023.webp) Zusätzlich zur Nachricht werden die $x$-Koordinate des öffentlichen Schlüssels $K_x$ sowie ein Punkt $R$, der aus dem Nonce $r$ ($R=r \cdot G$) berechnet wird, der selbst eine einzigartige Ganzzahl für jede Signatur ist, berechnet deterministisch aus dem privaten Schlüssel und der Nachricht, um Schwachstellen im Zusammenhang mit der Wiederverwendung von Nonces zu vermeiden, ebenfalls in die beschriftete Funktion eingegeben. Wie beim öffentlichen Schlüssel wird nur die $x$-Koordinate des Nonce-Punktes $R_x$ beibehalten, um den Punkt zu beschreiben. Das Ergebnis dieses Hashings, notiert $e$, wird als "Herausforderung" bezeichnet:$

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

 $Hierbei ist $\text{HASH}$ die SHA256-Hashfunktion, und $\text{``BIP0340/challenge''}$ ist das spezifische Tag für das Hashing. Schließlich wird der Parameter $s$ auf diese Weise aus dem privaten Schlüssel $k$, dem Nonce $r$ und der Herausforderung $e$ berechnet:$

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

 $Die Signatur ist dann einfach das Paar $Rx$ und $s$.$

\text{SIG} = R_x \Vert s

 $### Verifizierung der Schnorr-Signatur Die Verifizierung einer Schnorr-Signatur ist einfacher als die einer ECDSA-Signatur. Hier sind die Schritte zur Verifizierung der Signatur $(R_x, s)$ mit dem öffentlichen Schlüssel $K_x$ und der Nachricht $m$: Zuerst überprüfen wir, ob $K_x$ eine gültige Ganzzahl und kleiner als $p$ ist. Wenn dies der Fall ist, holen wir den entsprechenden Punkt auf der Kurve mit $K_y$ als gerade. Wir extrahieren auch $R_x$ und $s$, indem wir die Signatur $\text{SIG}$ trennen. Dann prüfen wir, ob $R_x < p$ und $s < n$ (die Ordnung der Kurve) ist. Als Nächstes berechnen wir die Herausforderung $e$ auf die gleiche Weise wie der Aussteller der Signatur:$

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

 $Dann berechnen wir einen Referenzpunkt auf der Kurve auf diese Weise:$

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

 $Schließlich überprüfen wir, ob $R'_x = R_x$. Wenn die beiden x-Koordinaten übereinstimmen, dann ist die Signatur $(R_x, s)$ tatsächlich gültig mit dem öffentlichen Schlüssel $K_x$. ### Warum funktioniert das? Der Unterzeichner hat $s = r + e \cdot k \mod n$ berechnet, also sollte $R' = s \cdot G - e \cdot K$ gleich dem ursprünglichen Punkt $R$ sein, weil:$

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

 $Da $K = k \cdot G$ ist, haben wir $e \cdot k \cdot G = e \cdot K$. Somit:$

R' = r \cdot G = R

 $Daher haben wir:$

R'_x = R_x

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

 $wobei $\text{ENT}$ die Länge der Entropie in Bits und $\text{CS}$ die Länge der Prüfsumme in Bits darstellt. Beispielsweise wird für eine Entropie von 256 Bits die ersten 8 Bits des Hashs genommen, um die Prüfsumme zu bilden:$

\text{CS} = \frac{256}{32} = 8 \text{ bits}

 $Sobald die Prüfsumme berechnet ist, wird sie mit der Entropie verkettet, um eine erweiterte Bitsequenz zu erhalten, notiert als $\text{ENT} \Vert \text{CS}$ ("verketten" bedeutet, Ende an Ende zu setzen). ![CYP201](/courses/cyp201/assets/fr/036.webp) ### Entsprechung zwischen der Entropie und der mnemonischen Phrase Die Anzahl der Wörter in der mnemonischen Phrase hängt von der Größe der anfänglichen Entropie ab, wie in der folgenden Tabelle dargestellt mit: - $\text{ENT}$: die Größe in Bits der Entropie; - $\text{CS}$: die Größe in Bits der Prüfsumme; - $w$: die Anzahl der Wörter in der endgültigen mnemonischen Phrase.$

\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}

 $Beispielsweise ergibt eine 256-Bit-Entropie das Ergebnis $\text{ENT} \Vert \text{CS}$ von 264 Bits und führt zu einer mnemonischen Phrase von 24 Wörtern. ### Umwandlung der Binärsequenz in eine mnemonische Phrase Die Bitsequenz $\text{ENT} \Vert \text{CS}$ wird dann in Segmente von 11 Bits unterteilt. Jedes 11-Bit-Segment, einmal in Dezimal umgewandelt, entspricht einer Zahl zwischen 0 und 2047, die die Position eines Wortes [in einer Liste von 2048 durch BIP39 standardisierten Wörtern](https://github.com/Planb-Network/bitcoin-educational-content/blob/dev/resources/bet/bip39-wordlist//courses/cyp201/assets/BIP39-WORDLIST.pdf) bezeichnet. ![CYP201](/courses/cyp201/assets/fr/037.webp) Zum Beispiel beträgt bei einer 128-Bit-Entropie die Prüfsumme 4 Bits, und somit misst die gesamte Sequenz 132 Bits. Sie wird in 12 Segmente zu je 11 Bits unterteilt (die orangefarbenen Bits bezeichnen die Prüfsumme): ![CYP201](/courses/cyp201/assets/fr/038.webp) Jedes Segment wird dann in eine Dezimalzahl umgewandelt, die ein Wort in der Liste repräsentiert. Zum Beispiel ist das binäre Segment `01011010001` in Dezimalzahl `721` äquivalent. Indem man 1 hinzufügt, um sich an die Indexierung der Liste anzupassen (die bei 1 und nicht bei 0 beginnt), ergibt dies den Wortrang `722`, welcher "*focus*" in der Liste ist. ![CYP201](/courses/cyp201/assets/fr/039.webp) Diese Entsprechung wird für jedes der 12 Segmente wiederholt, um eine 12-Wort-Phrase zu erhalten. ![CYP201](/courses/cyp201/assets/fr/040.webp) ### Merkmale der BIP39-Wortliste Eine Besonderheit der BIP39-Wortliste ist, dass kein Wort die gleichen ersten vier Buchstaben in derselben Reihenfolge wie ein anderes Wort teilt. Das bedeutet, dass es ausreicht, nur die ersten vier Buchstaben jedes Wortes zu notieren, um die mnemonische Phrase zu speichern. Dies kann interessant sein, um Platz zu sparen, insbesondere für diejenigen, die sie auf einem Metallträger eingravieren möchten. Diese Liste von 2048 Wörtern existiert in mehreren Sprachen. Es handelt sich dabei nicht um einfache Übersetzungen, sondern um unterschiedliche Wörter für jede Sprache. Es wird jedoch dringend empfohlen, bei der englischen Version zu bleiben, da Versionen in anderen Sprachen im Allgemeinen nicht von Wallet-Software unterstützt werden. ### Welche Länge sollte man für seine mnemonische Phrase wählen? Um die optimale Länge Ihrer mnemonischen Phrase zu bestimmen, muss man die tatsächliche Sicherheit berücksichtigen, die sie bietet. Eine 12-Wort-Phrase gewährleistet 128 Bits an Sicherheit, während eine 24-Wort-Phrase 256 Bits bietet. Allerdings verbessert dieser Unterschied in der Phrasen-Sicherheit nicht die Gesamtsicherheit eines Bitcoin-Wallets, da die daraus abgeleiteten privaten Schlüssel nur von 128 Bits an Sicherheit profitieren. Tatsächlich, wie wir zuvor gesehen haben, werden Bitcoin-Private-Keys aus Zufallszahlen (oder von einer zufälligen Quelle abgeleitet) generiert, die zwischen $1$ und $n-1$ liegen, wobei $n$ die Ordnung des Generatorpunkts $G$ der secp256k1-Kurve darstellt, eine Zahl, die etwas weniger als $2^{256}$ beträgt. Man könnte daher denken, dass diese privaten Schlüssel 256 Bits an Sicherheit bieten. Ihre Sicherheit liegt jedoch in der Schwierigkeit, einen privaten Schlüssel aus seinem zugehörigen öffentlichen Schlüssel zu finden, eine Schwierigkeit, die durch das mathematische Problem des diskreten Logarithmus auf elliptischen Kurven (*ECDLP*) festgelegt ist. Bis heute ist der bekannteste Algorithmus zur Lösung dieses Problems Pollards Rho-Algorithmus, der die Anzahl der Operationen, die benötigt werden, um einen Schlüssel zu brechen, auf die Quadratwurzel seiner Größe reduziert. Für 256-Bit-Schlüssel, wie sie bei Bitcoin verwendet werden, reduziert Pollards Rho-Algorithmus die Komplexität somit auf $2^{128}$ Operationen:$

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

 $Daher wird angenommen, dass ein privater Schlüssel, der bei Bitcoin verwendet wird, 128 Bits an Sicherheit bietet. Folglich bietet die Wahl einer 24-Wort-Phrase keinen zusätzlichen Schutz für das Wallet, da 256 Bits an Sicherheit bei der Phrase sinnlos sind, wenn die daraus abgeleiteten Schlüssel nur 128 Bits an Sicherheit bieten. Um dieses Prinzip zu veranschaulichen, ist es, als hätte man ein Haus mit zwei Türen: eine alte Holztür und eine verstärkte Tür. Im Falle eines Einbruchs wäre die verstärkte Tür nutzlos, da der Eindringling durch die Holztür gehen würde. Hier liegt eine analoge Situation vor. Ein 12-Wort-Phrase, die auch 128 Bit an Sicherheit bietet, ist daher derzeit ausreichend, um Ihre Bitcoins gegen jeden Diebstahlversuch zu schützen. Solange der digitale Signaturalgorithmus nicht geändert wird, um größere Schlüssel zu verwenden oder sich auf ein anderes mathematisches Problem als das ECDLP zu stützen, bleibt eine 24-Wort-Phrase überflüssig. Darüber hinaus erhöht eine längere Phrase das Risiko eines Verlusts während der Sicherung: Eine Sicherung, die halb so lang ist, ist immer einfacher zu verwalten. Um weiter zu gehen und konkret zu lernen, wie man manuell eine Test-Mnemonic-Phrase generiert, rate ich Ihnen, dieses Tutorial zu entdecken: https://planb.network/tutorials/wallet/backup/generate-mnemonic-phrase-47507d90-e6af-4cac-b01b-01a14d7a8228 Bevor wir mit der Ableitung des Wallets aus dieser Mnemonic-Phrase fortfahren, werde ich Ihnen im folgenden Kapitel die BIP39-Passphrase vorstellen, da sie eine Rolle im Ableitungsprozess spielt und sie sich auf derselben Ebene wie die Mnemonic-Phrase befindet. ## Die Passphrase <chapterId>6a51b397-f3b5-5084-b151-cef94bc9b93f</chapterId> Wie wir gerade gesehen haben, werden HD-Wallets aus einer Mnemonic-Phrase generiert, die typischerweise aus 12 oder 24 Wörtern besteht. Diese Phrase ist sehr wichtig, da sie die Wiederherstellung aller Schlüssel eines Wallets ermöglicht, falls dessen physisches Gerät (wie zum Beispiel ein Hardware-Wallet) verloren geht. Allerdings stellt sie einen einzigen Ausfallpunkt dar, denn wenn sie kompromittiert wird, könnte ein Angreifer alle Bitcoins stehlen. Hier kommt die BIP39-Passphrase ins Spiel. ### Was ist eine BIP39-Passphrase? Die Passphrase ist ein optionales Passwort, das Sie frei wählen können, das zur Mnemonic-Phrase im Schlüsselableitungsprozess hinzugefügt wird, um die Sicherheit des Wallets zu erhöhen. Achten Sie darauf, die Passphrase nicht mit dem PIN-Code Ihres Hardware-Wallets oder dem Passwort zu verwechseln, das verwendet wird, um den Zugang zu Ihrem Wallet auf Ihrem Computer freizuschalten. Im Gegensatz zu all diesen Elementen spielt die Passphrase eine Rolle in der Ableitung der Schlüssel Ihres Wallets. **Das bedeutet, dass Sie ohne sie niemals in der Lage sein werden, Ihre Bitcoins wiederherzustellen.** Die Passphrase arbeitet zusammen mit der Mnemonic-Phrase und modifiziert den Seed, aus dem die Schlüssel generiert werden. So kann selbst, wenn jemand Ihre 12- oder 24-Wort-Phrase erhält, ohne die Passphrase nicht auf Ihre Gelder zugreifen. Die Verwendung einer Passphrase erstellt im Wesentlichen ein neues Wallet mit unterschiedlichen Schlüsseln. Eine Modifikation (selbst eine geringfügige) der Passphrase wird ein anderes Wallet generieren. ![CYP202](/courses/cyp201/assets/fr/041.webp) ### Warum sollten Sie eine Passphrase verwenden? Die Passphrase ist willkürlich und kann jede vom Benutzer gewählte Zeichenkombination sein. Die Verwendung einer Passphrase bietet somit mehrere Vorteile. Zunächst reduziert sie alle Risiken, die mit dem Kompromittieren der Mnemonic-Phrase verbunden sind, indem sie einen zweiten Faktor zum Zugriff auf die Gelder erfordert (Einbruch, Zugang zu Ihrem Zuhause usw.). Weiterhin kann sie strategisch verwendet werden, um ein Köder-Wallet zu erstellen, um physischen Zwängen zum Stehlen Ihrer Gelder wie dem berüchtigten "_$5 Schraubenschlüssel-Angriff_" zu begegnen. In diesem Szenario besteht die Idee darin, ein Wallet ohne Passphrase zu haben, das nur eine kleine Menge an Bitcoins enthält, genug, um einen potenziellen Aggressor zufriedenzustellen, während man ein verstecktes Wallet hat. Dieses letztere verwendet dieselbe Mnemonic-Phrase, ist aber mit einer zusätzlichen Passphrase gesichert. Schließlich ist die Verwendung einer Passphrase interessant, wenn man die Zufälligkeit der Generierung des Seeds des HD-Wallets kontrollieren möchte. ### Wie wählt man eine gute Passphrase? Damit die Passphrase wirksam ist, muss sie ausreichend lang und zufällig sein. Wie bei einem starken Passwort empfehle ich, eine Passphrase zu wählen, die so lang und zufällig wie möglich ist, mit einer Vielfalt an Buchstaben, Zahlen und Symbolen, um jeden Brute-Force-Angriff unmöglich zu machen. Es ist ebenfalls wichtig, diese Passphrase ordnungsgemäß zu speichern, genauso wie die mnemonische Phrase. **Der Verlust bedeutet den Verlust des Zugangs zu Ihren Bitcoins**. Ich rate dringend davon ab, sie sich nur zu merken, da dies das Risiko eines Verlusts unangemessen erhöht. Das Ideal ist, sie auf einem physischen Medium (Papier oder Metall) getrennt von der mnemonischen Phrase niederzuschreiben. Diese Sicherungskopie muss offensichtlich an einem anderen Ort als Ihre mnemonische Phrase aufbewahrt werden, um zu verhindern, dass beide gleichzeitig kompromittiert werden. ![CYP201](/courses/cyp201/assets/fr/042.webp) Im folgenden Abschnitt werden wir entdecken, wie diese beiden Elemente an der Basis Ihrer Wallet – die mnemonische Phrase und die Passphrase – verwendet werden, um die Schlüsselpaare abzuleiten, die in dem *scriptPubKey* verwendet werden, um Ihre UTXOs zu sperren. # Erstellung von Bitcoin-Wallets <partId>9c25e767-7eae-50b8-8c5f-679d8fc83bab</partId> ## Erstellung des Seeds und des Master-Schlüssels <chapterId>63093760-2010-5691-8d0e-9a04732ae557</chapterId> Sobald die mnemonische Phrase und die optionale Passphrase generiert sind, kann der Prozess der Ableitung einer Bitcoin-HD-Wallet beginnen. Die mnemonische Phrase wird zunächst in einen Seed umgewandelt, der die Basis aller Schlüssel der Wallet bildet. ![CYP201](/courses/cyp201/assets/fr/043.webp) ### Der Seed einer HD-Wallet Der BIP39-Standard definiert den Seed als eine 512-Bit-Sequenz, die als Ausgangspunkt für die Ableitung aller Schlüssel einer HD-Wallet dient. Der Seed wird aus der mnemonischen Phrase und der möglichen Passphrase unter Verwendung des **PBKDF2**-Algorithmus (*Password-Based Key Derivation Function 2*) abgeleitet, den wir bereits in Kapitel 3.3 besprochen haben. In dieser Ableitungsfunktion werden wir die folgenden Parameter verwenden: - $m$ : die mnemonische Phrase; - $p$ : eine optionale Passphrase, die vom Benutzer gewählt wird, um die Sicherheit des Seeds zu erhöhen. Wenn keine Passphrase vorhanden ist, bleibt dieses Feld leer; - $\text{PBKDF2}$ : die Ableitungsfunktion mit $\text{HMAC-SHA512}$ und $2048$ Iterationen; - $s$: der 512-Bit-Wallet-Seed. Unabhängig von der gewählten Länge der mnemonischen Phrase (132 Bits oder 264 Bits) wird die PBKDF2-Funktion immer ein 512-Bit-Ergebnis produzieren, und der Seed wird daher immer diese Größe haben. ### Seed-Ableitungsschema mit PBKDF2 Die folgende Gleichung veranschaulicht die Ableitung des Seeds aus der mnemonischen Phrase und der Passphrase:$

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

 $![CYP201](/courses/cyp201/assets/fr/044.webp) Der Wert des Seeds wird also durch den Wert der mnemonischen Phrase und der Passphrase beeinflusst. Durch Ändern der Passphrase wird ein anderer Seed erhalten. Jedoch wird mit derselben mnemonischen Phrase und Passphrase immer derselbe Seed generiert, da PBKDF2 eine deterministische Funktion ist. Dies stellt sicher, dass dieselben Schlüsselpaare über unsere Sicherungen abgerufen werden können. **Hinweis:** Im allgemeinen Sprachgebrauch bezieht sich der Begriff "Seed" oft, durch Sprachmissbrauch, auf die mnemonische Phrase. Tatsächlich ist in Abwesenheit einer Passphrase das eine einfach die Kodierung des anderen. Wie wir jedoch gesehen haben, sind in der technischen Realität von Wallets der Seed und die mnemonische Phrase tatsächlich zwei unterschiedliche Elemente. Jetzt, da wir unseren Seed haben, können wir mit der Ableitung unserer Bitcoin-Wallet fortfahren. ### Der Master-Schlüssel und der Master-Chain-Code Sobald der Seed erhalten wurde, besteht der nächste Schritt bei der Ableitung eines HD-Wallets darin, den Master-Privatschlüssel und den Master-Chain-Code zu berechnen, die die Tiefe 0 unseres Wallets darstellen werden. Um den Master-Privatschlüssel und den Master-Chain-Code zu erhalten, wird die HMAC-SHA512-Funktion auf den Seed angewendet, unter Verwendung eines festen Schlüssels "*Bitcoin Seed*", der für alle Bitcoin-Nutzer identisch ist. Diese Konstante wird gewählt, um sicherzustellen, dass die Schlüsselableitungen spezifisch für Bitcoin sind. Hier sind die Elemente: - $\text{HMAC-SHA512}$: die Ableitungsfunktion; - $s$: der 512-Bit-Wallet-Seed; - $\text{"Bitcoin Seed"}$: die gemeinsame Ableitungskonstante für alle Bitcoin-Wallets.$

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

 $Der Output dieser Funktion ist daher 512 Bit lang. Er wird dann in 2 Teile geteilt: - Die linken 256 Bit bilden den **Master-Privatschlüssel**; - Die rechten 256 Bit bilden den **Master-Chain-Code**. Mathematisch können diese beiden Werte wie folgt mit $k_M$ als dem Master-Privatschlüssel und $C_M$ als dem Master-Chain-Code notiert werden:$

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)

 $In dieser Berechnung beobachten wir, dass unsere HMAC-Funktion zwei Eingaben nimmt: zuerst den Eltern-Chain-Code und dann die Verkettung des Index mit dem öffentlichen Schlüssel, der mit dem Eltern-Privatschlüssel assoziiert ist. Der Eltern-Öffentliche-Schlüssel wird hier verwendet, weil wir einen normalen Kind-Schlüssel ableiten möchten, keinen gehärteten. Wir haben jetzt einen 64-Byte $\text{hash}$, den wir in 2 Teile zu je 32 Bytes aufteilen: $h_1$ und $h_2$:$

\text{hash} = h_1 \Vert h_2

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

 $Der Kind-Privatschlüssel $k_{\text{CHD}}^n$ wird dann wie folgt berechnet:$

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

 $Bei dieser Berechnung besteht die Operation $\text{parse256}(h_1)$ darin, die ersten 32 Bytes des $\text{hash}$ als eine 256-Bit-Ganzzahl zu interpretieren. Diese Zahl wird dann zum übergeordneten privaten Schlüssel hinzugefügt, alles modulo $n$ genommen, um innerhalb der Ordnung der elliptischen Kurve zu bleiben, wie wir in Abschnitt 3 über digitale Signaturen gesehen haben. Um also einen normalen Kind-Privatschlüssel abzuleiten, obwohl der öffentliche Schlüssel des Elternteils als Basis für die Berechnung in den Eingaben der HMAC-SHA512-Funktion verwendet wird, ist es immer notwendig, den privaten Schlüssel des Elternteils zu haben, um die Berechnung abzuschließen. Von diesem Kind-Privatschlüssel aus ist es möglich, den entsprechenden öffentlichen Schlüssel abzuleiten, indem ECDSA oder Schnorr angewendet wird. Auf diese Weise erhalten wir ein vollständiges Schlüsselpaar. Dann wird der zweite Teil des $\text{hash}$ einfach als der Kettenkode für das Kind-Schlüsselpaar interpretiert, das wir gerade abgeleitet haben:$

C_{\text{CHD}} = h_2

 $Hier ist eine schematische Darstellung der gesamten Ableitung: ![CYP201](/courses/cyp201/assets/fr/050.webp) Für einen **verstärkten Kind-Schlüssel** ($i \geq 2^{31}$) erfolgt die Berechnung des $\text{hash}$ wie folgt:$

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

 $In dieser Berechnung beobachten wir, dass unsere HMAC-Funktion zwei Eingaben nimmt: zuerst den Eltern-Kettenkode und dann die Verkettung des Index mit dem privaten Schlüssel des Elternteils. Der private Schlüssel des Elternteils wird hier verwendet, weil wir darauf abzielen, einen verstärkten Kind-Schlüssel abzuleiten. Außerdem wird am Anfang des Schlüssels ein Byte gleich `0x00` hinzugefügt. Diese Operation gleicht seine Länge an, um der eines komprimierten öffentlichen Schlüssels zu entsprechen. So haben wir jetzt einen 64-Byte $\text{hash}$, den wir in 2 Teile von je 32 Bytes aufteilen werden: $h_1$ und $h_2$:$

\text{hash} = h_1 \Vert h_2

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

 $Der Kind-Privatschlüssel $k_{\text{CHD}}^h$ wird dann wie folgt berechnet:$

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

 $Als Nächstes interpretieren wir einfach den zweiten Teil des $\text{hash}$ als den Kettenkode für das Paar von Kind-Schlüsseln, das wir gerade abgeleitet haben:$

C_{\text{CHD}} = h_2

 $Hier ist eine schematische Darstellung der gesamten Ableitung: ![CYP201](/courses/cyp201/assets/fr/051.webp) Wir können sehen, dass die normale Ableitung und die verstärkte Ableitung auf die gleiche Weise funktionieren, mit diesem Unterschied: Die normale Ableitung verwendet den öffentlichen Schlüssel des Elternteils als Eingabe für die HMAC-Funktion, während die verstärkte Ableitung den privaten Schlüssel des Elternteils verwendet. #### Ableitung eines Kind-öffentlichen Schlüssels aus einem Eltern-öffentlichen Schlüssel Wenn wir nur den öffentlichen Schlüssel des Elternteils $K_{\text{PAR}}$ und den zugehörigen Ketten-Code $C_{\text{PAR}}$ kennen, also einen erweiterten öffentlichen Schlüssel, ist es möglich, Kind-öffentliche Schlüssel $K_{\text{CHD}}^n$ abzuleiten, aber nur für normale (nicht verstärkte) Kind-Schlüssel. Dieses Prinzip ermöglicht es insbesondere, die Bewegungen eines Kontos in einer Bitcoin-Wallet vom `xpub` (*nur-beobachten*) zu überwachen. Um diese Berechnung durchzuführen, werden wir den $\text{hash}$ mit einem Index $i < 2^{31}$ (normale Ableitung) berechnen:$

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

 $In dieser Berechnung beobachten wir, dass unsere HMAC-Funktion zwei Eingaben nimmt: zuerst den Ketten-Code des Elternteils, dann die Verkettung des Indexes mit dem öffentlichen Schlüssel des Elternteils. So haben wir jetzt einen $hash$ von 64 Bytes, den wir in 2 Teile von je 32 Bytes aufteilen werden: $h_1$ und $h_2$:$

\text{hash} = h_1 \Vert h_2

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

 $Der Kind-öffentliche Schlüssel $K_{\text{CHD}}^n$ wird dann wie folgt berechnet:$

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

 $Wenn $\text{parse256}(h_1) \geq n$ (Ordnung der elliptischen Kurve) ist oder wenn $K_{\text{CHD}}^n$ der Punkt im Unendlichen ist, ist die Ableitung ungültig, und ein anderer Index muss gewählt werden. In dieser Berechnung beinhaltet die Operation $\text{parse256}(h_1)$, die ersten 32 Bytes des $\text{hash}$ als eine 256-Bit-Ganzzahl zu interpretieren. Diese Zahl wird verwendet, um einen Punkt auf der elliptischen Kurve durch Addition und Verdopplung vom Generatorpunkt $G$ zu berechnen. Dieser Punkt wird dann zum öffentlichen Schlüssel des Elternteils addiert, um den normalen Kind-öffentlichen Schlüssel zu erhalten. Somit ist zur Ableitung eines normalen Kind-öffentlichen Schlüssels nur der öffentliche Schlüssel des Elternteils und der Ketten-Code des Elternteils notwendig; der private Schlüssel des Elternteils kommt in diesem Prozess im Gegensatz zur Berechnung des Kind-privaten Schlüssels, die wir zuvor gesehen haben, nie ins Spiel. Als Nächstes ist der Ketten-Code des Kindes einfach:$

C_{\text{CHD}} = h_2

 $Hier ist eine schematische Darstellung der gesamten Ableitung: ![CYP201](/courses/cyp201/assets/fr/052.webp) ### Entsprechung zwischen Kind-öffentlichen und privaten Schlüsseln Eine Frage, die aufkommen könnte, ist, wie ein normaler Kind-öffentlicher Schlüssel, der von einem Eltern-öffentlichen Schlüssel abgeleitet wurde, einem normalen Kind-privaten Schlüssel entsprechen kann, der vom entsprechenden Eltern-privaten Schlüssel abgeleitet wurde. Diese Verbindung wird genau durch die Eigenschaften elliptischer Kurven sichergestellt. Tatsächlich wird zur Ableitung eines normalen Kind-öffentlichen Schlüssels HMAC-SHA512 auf die gleiche Weise angewendet, aber sein Ausgang wird anders verwendet: - **Normaler Kind-privater Schlüssel**: $k_{\text{CHD}}^n = \text{parse256}(h_1) + k_{\text{PAR}} \mod n$ - **Normaler Kind-öffentlicher Schlüssel**: $K_{\text{CHD}}^n = G \cdot \text{parse256}(h_1) + K_{\text{PAR}}$ Dank der Addition und Verdopplungsoperationen auf der elliptischen Kurve liefern beide Methoden konsistente Ergebnisse: Der vom Kind-Privatschlüssel abgeleitete öffentliche Schlüssel ist identisch mit dem Kind-Öffentlichen Schlüssel, der direkt vom Eltern-Öffentlichen Schlüssel abgeleitet wurde. ### Zusammenfassung der Ableitungstypen Zusammengefasst gibt es hier die verschiedenen möglichen Typen von Ableitungen:$

\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}

 $Zusammengefasst haben Sie bisher gelernt, die grundlegenden Elemente des HD-Wallets zu erstellen: die mnemonische Phrase, den Seed und dann den Master-Schlüssel und den Master-Chain-Code. Sie haben auch entdeckt, wie man in diesem Kapitel Kind-Schlüsselpaare ableitet. Im nächsten Kapitel werden wir erforschen, wie diese Ableitungen in Bitcoin-Wallets organisiert sind und welche Struktur zu befolgen ist, um konkret die Empfangsadressen sowie die Schlüsselpaare, die im *scriptPubKey* und *scriptSig* verwendet werden, zu erhalten. ## Wallet-Struktur und Ableitungspfade <chapterId>34e1bbda-67de-5493-b268-1fded8d67689</chapterId> Die hierarchische Struktur von HD-Wallets bei Bitcoin ermöglicht die Organisation von Schlüsselpaaren auf verschiedene Weisen. Die Idee besteht darin, von dem Master-Privatschlüssel und dem Master-Chain-Code aus mehrere Tiefenebenen abzuleiten. Jede hinzugefügte Ebene entspricht der Ableitung eines Kind-Schlüsselpaares von einem Eltern-Schlüsselpaar. Im Laufe der Zeit haben verschiedene BIPs (*Bitcoin Improvement Proposals*) Standards für diese Ableitungspfade eingeführt, um deren Nutzung über verschiedene Software hinweg zu standardisieren. In diesem Kapitel werden wir also die Bedeutung jeder Ableitungsebene in HD-Wallets gemäß diesen Standards entdecken. ### Die Tiefen der Ableitung eines HD-Wallets Ableitungspfade sind in Tiefenebenen organisiert, die von Tiefe 0, die den Master-Schlüssel und den Master-Chain-Code repräsentiert, bis zu Unter-Ebenen für die Ableitung von Adressen reichen, die verwendet werden, um UTXOs zu sperren. Die BIPs definieren die Standards für jede Ebene, was hilft, Praktiken über verschiedene Wallet-Management-Software hinweg zu harmonisieren. Ein Ableitungspfad bezieht sich daher auf die Sequenz von Indizes, die verwendet werden, um Kind-Schlüssel von einem Master-Schlüssel abzuleiten. **Tiefe 0: Master-Schlüssel (BIP32)** Diese Tiefe entspricht dem Master-Privatschlüssel und dem Master-Chain-Code des Wallets. Sie wird durch die Notation $m/$ dargestellt. **Tiefe 1: Zweck (BIP43)** Das Ziel bestimmt die logische Struktur der Ableitung. Zum Beispiel wird eine P2WPKH-Adresse auf der Tiefe 1 den Index $/84'/$ haben (gemäß BIP84), während eine P2TR-Adresse den Index $/86'/$ haben wird (gemäß BIP86). Diese Schicht erleichtert die Kompatibilität zwischen Wallets, indem sie Indexnummern angibt, die den BIP-Nummern entsprechen. Anders gesagt, sobald Sie den Master-Schlüssel und den Master-Chain-Code haben, dienen diese als Elternschlüsselpaar, um ein Kind-Schlüsselpaar abzuleiten. Der in dieser Ableitung verwendete Index kann zum Beispiel $/84'/$ sein, wenn das Wallet vorgesehen ist, SegWit v0 Typ-Skripte zu verwenden. Dieses Schlüsselpaar befindet sich dann auf Tiefe 1. Seine Rolle ist es nicht, Bitcoins zu sperren, sondern einfach als Wegpunkt in der Ableitungshierarchie zu dienen. **Tiefe 2: Währungstyp (BIP44)** Vom Schlüsselpaar auf Tiefe 1 wird eine neue Ableitung durchgeführt, um das Schlüsselpaar auf Tiefe 2 zu erhalten. Diese Tiefe ermöglicht es, Bitcoin-Konten von anderen Kryptowährungen innerhalb derselben Wallet zu unterscheiden. Jede Währung hat einen einzigartigen Index, um Kompatibilität über Multi-Währungs-Wallets hinweg zu gewährleisten. Zum Beispiel ist für Bitcoin der Index $/0'/$ (oder `0x80000000` in hexadezimaler Notation). Währungsindizes werden im Bereich von $2^{31}$ bis $2^{32}-1$ gewählt, um eine gehärtete Ableitung zu gewährleisten. Um Ihnen andere Beispiele zu geben, hier sind die Indizes einiger Währungen: - $1'$ (`0x80000001`) für Testnet-Bitcoins; - $2'$ (`0x80000002`) für Litecoin; - $60'$ (`0x8000003c`) für Ethereum... **Tiefe 3: Konto (BIP32)** Jede Wallet kann in mehrere Konten unterteilt werden, nummeriert ab $2^{31}$, und auf Tiefe 3 durch $/0'/$ für das erste Konto, $/1'/$ für das zweite usw. dargestellt. Allgemein, wenn auf einen erweiterten Schlüssel `xpub` Bezug genommen wird, bezieht es sich auf Schlüssel auf dieser Ableitungstiefe. Diese Unterteilung in verschiedene Konten ist optional. Sie zielt darauf ab, die Organisation der Wallet für Benutzer zu vereinfachen. In der Praxis wird oft nur ein Konto verwendet, üblicherweise das erste standardmäßig. Jedoch kann es in einigen Fällen, wenn man Schlüsselpaare für unterschiedliche Verwendungen klar unterscheiden möchte, nützlich sein. Zum Beispiel ist es möglich, aus demselben Seed ein persönliches und ein berufliches Konto zu erstellen, mit völlig unterschiedlichen Schlüsselgruppen ab dieser Ableitungstiefe. **Tiefe 4: Kette (BIP32)** Jedes auf Tiefe 3 definierte Konto wird dann in zwei Ketten strukturiert: - **Die externe Kette**: In dieser Kette werden sogenannte "öffentliche" Adressen abgeleitet. Diese Empfangsadressen sind dazu bestimmt, UTXOs zu sperren, die von externen Transaktionen kommen (das heißt, von der Verwendung von UTXOs, die nicht Ihnen gehören). Einfach ausgedrückt, wird diese externe Kette immer dann verwendet, wenn man Bitcoins erhalten möchte. Wenn Sie in Ihrer Wallet-Software auf "*empfangen*" klicken, wird Ihnen immer eine Adresse aus der externen Kette angeboten. Diese Kette wird durch ein Paar von Schlüsseln dargestellt, die mit dem Index $/0/$ abgeleitet werden. - **Die interne Kette (Wechsel)**: Diese Kette ist für Empfangsadressen reserviert, die Bitcoins sperren, die von der Verwendung von UTXOs kommen, die Ihnen gehören, mit anderen Worten, Wechseladressen. Sie wird durch den Index $/1/$ identifiziert. **Tiefe 5: Adressindex (BIP32)** Schließlich stellt Tiefe 5 den letzten Schritt der Ableitung im Wallet dar. Obwohl es technisch möglich ist, unendlich fortzufahren, stoppen die aktuellen Standards hier. Auf dieser letzten Tiefe werden die Paare von Schlüsseln abgeleitet, die tatsächlich verwendet werden, um die UTXOs zu sperren und zu entsperren. Jeder Index ermöglicht die Unterscheidung zwischen Geschwisterschlüsselpaaren: so wird die erste Empfangsadresse den Index $/0/$ verwenden, die zweite den Index $/1/$ und so weiter. ![CYP201](/courses/cyp201/assets/fr/053.webp) ### Notation von Ableitungspfaden Der Ableitungspfad wird geschrieben, indem jede Ebene mit einem Schrägstrich ($/$) getrennt wird. Jeder Schrägstrich zeigt somit eine Ableitung eines Elternschlüsselpaares ($k_{\text{PAR}}$, $K_{\text{PAR}}$, $C_{\text{PAR}}$) zu einem Kinderschlüsselpaar ($k_{\text{CHD}}$, $K_{\text{CHD}}$, $C_{\text{CHD}}$) an. Die bei jeder Tiefe notierte Zahl entspricht dem Index, der verwendet wird, um diesen Schlüssel von seinen Eltern abzuleiten. Das Apostroph ($'$), das manchmal rechts vom Index platziert wird, zeigt eine gehärtete Ableitung ($k_{\text{CHD}}^h$, $K_{\text{CHD}}^h$) an. Manchmal wird dieses Apostroph durch ein $h$ ersetzt. In Abwesenheit eines Apostrophs oder $h$ handelt es sich daher um eine normale Ableitung ($k_{\text{CHD}}^n$, $K_{\text{CHD}}^n$). Wie wir in den vorherigen Kapiteln gesehen haben, beginnen gehärtete Schlüsselindizes bei $2^{31}$ oder `0x80000000` in Hexadezimal. Daher muss, wenn ein Index in einem Ableitungspfad von einem Apostroph gefolgt wird, $2^{31}$ zu der angegebenen Zahl addiert werden, um den tatsächlichen Wert zu erhalten, der in der HMAC-SHA512-Funktion verwendet wird. Zum Beispiel, wenn der Ableitungspfad $/44'/$ angibt, wird der tatsächliche Index sein:$

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

 $In Hexadezimal ist dies `0x8000002C`. Jetzt, da wir die Hauptprinzipien der Ableitungspfade verstanden haben, nehmen wir ein Beispiel! Hier ist der Ableitungspfad für eine Bitcoin-Empfangsadresse:$

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

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

 $Zuerst führen wir den Schlüssel durch SHA256: ```text SHA256(K) = C489EBD66E4103B3C4B5EAFF462B92F5847CA2DCE0825F4997C7CF57DF35BF3A ``` Dann führen wir das Ergebnis durch RIPEMD160: ```text RIPEMD160(SHA256(K)) = 9F81322CC88622CA4CCB2A52A21E2888727AA535 ``` Wir haben einen 160-Bit-Hash des öffentlichen Schlüssels erhalten, der das darstellt, was als Payload der Adresse bezeichnet wird. Dieser Payload repräsentiert den zentralen und wichtigsten Teil der Adresse. Er wird auch im *scriptPubKey* verwendet, um die UTXOs zu sperren. Um diesen Payload jedoch für Menschen leichter nutzbar zu machen, werden ihm Metadaten hinzugefügt. Der nächste Schritt beinhaltet die Kodierung dieses Hashs in Gruppen von 5 Bits in Dezimalzahlen. Diese dezimale Transformation wird für die Umwandlung in *bech32* nützlich sein, das von Post-SegWit-Adressen verwendet wird. Der 160-Bit-Binärhash wird somit in 32 Gruppen von 5 Bits aufgeteilt:$

\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

 $Wobei $G$ der Generator der verwendeten elliptischen Kurve ist. Diese Operation erzeugt einen neuen öffentlichen Schlüssel, der vom ursprünglichen Schlüssel abgeleitet ist, während sie kryptografische Eigenschaften beibehält, die seine Verwendung ermöglichen. Wenn Sie keine alternativen Skripte hinzufügen müssen (ausschließlich über den _key path_ ausgeben), können Sie eine Taproot-Adresse generieren, die ausschließlich auf dem öffentlichen Schlüssel basiert, der in der Tiefe 5 Ihrer Wallet vorhanden ist. In diesem Fall ist es notwendig, ein nicht-ausgabefähiges Skript für den _script path_ zu erstellen, um die Anforderungen der Struktur zu erfüllen. Die Anpassung $t$ wird dann berechnet, indem eine getaggte Hash-Funktion, **`TapTweak`**, auf den internen öffentlichen Schlüssel $P$ angewendet wird:$

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

 $wo: - **$\text{H}_{\text{TapTweak}}$** ist eine SHA256-Hash-Funktion, getaggt mit dem Tag `TapTweak`. Wenn Sie nicht vertraut sind, was eine getaggte Hash-Funktion ist, lade ich Sie ein, Kapitel 3.3 zu konsultieren; - $P$ ist der interne öffentliche Schlüssel, dargestellt in seinem komprimierten 256-Bit-Format, unter Verwendung nur der $x$-Koordinate. Der Taproot-öffentliche Schlüssel $Q$ wird dann berechnet, indem die Anpassung $t$, multipliziert mit dem Generator der elliptischen Kurve $G$, zum internen öffentlichen Schlüssel $P$ hinzugefügt wird:$

Q = P + t \cdot G

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

 $Mit: - $v$: die Skriptversionsnummer (Standard `0xC0` für Taproot); - $sz$: die Größe des Skripts kodiert im _CompactSize_-Format; - $S$: das Skript. Die verschiedenen Skripthashes ($\text{h}_{\text{leaf}}$) werden zunächst in lexikographischer Reihenfolge sortiert. Dann werden sie paarweise zusammengefügt und durch die getaggte Hashfunktion `TapBranch` geleitet. Dieser Prozess wird iterativ wiederholt, um Schritt für Schritt den Merkle-Baum aufzubauen:$

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

 $Wir fahren dann fort, indem wir die Ergebnisse zwei zu zwei zusammenfügen und sie in jedem Schritt durch die getaggte Hashfunktion `TapBranch` leiten, bis wir die Wurzel des Merkle-Baums erhalten: ![CYP201](/courses/cyp201/assets/fr/066.webp) Sobald die Merkle-Wurzel $h_{\text{root}}$ berechnet ist, kann der Tweak berechnet werden. Dazu wird der interne öffentliche Schlüssel der Wallet $P$ mit der Wurzel $h_{\text{root}}$ verkettet und dann durch die markierte Hash-Funktion `TapTweak` geführt:$

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

 $Schließlich wird, wie zuvor, der Taproot-öffentliche Schlüssel $Q$ durch Hinzufügen des internen öffentlichen Schlüssels $P$ zum Produkt des Tweaks $t$ und des Generatorpunkts $G$ erhalten:$

Q = P + t \cdot G

 $Die Adressgenerierung folgt dann demselben Prozess, wobei der rohe öffentliche Schlüssel $Q$ als Nutzlast zusammen mit einigen zusätzlichen Metadaten verwendet wird. Und damit haben wir das Ende dieses CYP201-Kurses erreicht. Wenn Sie diesen Kurs hilfreich fanden, wäre ich Ihnen sehr dankbar, wenn Sie sich ein paar Momente Zeit nehmen könnten, um ihm in dem folgenden Bewertungskapitel eine gute Bewertung zu geben. Fühlen Sie sich auch frei, ihn mit Ihren Liebsten oder in Ihren sozialen Netzwerken zu teilen. Schließlich, wenn Sie Ihr Diplom für diesen Kurs erhalten möchten, können Sie direkt nach dem Bewertungskapitel die Abschlussprüfung ablegen. # Abschluss <partId>58111408-b734-54db-9ea7-0d5b67f99f99</partId> ## Bewertungen & Noten <chapterId>0cd71541-a7fd-53db-b66a-8611b6a28b04</chapterId> <isCourseReview>true</isCourseReview> ## Abschlussprüfung <chapterId>a53ea27d-0f84-56cd-b37c-a66210a4b31d</chapterId> <isCourseExam>true</isCourseExam> ## Fazit <chapterId>d291428b-3cfa-5394-930e-4b514be82d5a</chapterId> <isCourseConclusion>true</isCourseConclusion>$