Einführung :

Wissensfreie Beweise ermöglichen private, sichere Transaktionen. Mit zkSNARKs und zkSTARKs kann ein Prüfer einem Prüfer den Besitz einiger Informationen nachweisen, ohne die tatsächlichen Daten preiszugeben.

Dies birgt ein enormes Potenzial für Anonymität und Vertraulichkeit. Aber zkSTARKs und zkSNARKs sind komplex. Risc0 macht sie zugänglicher. Sehen wir uns die sehr einfache Implementierung an:

In diesem Tutorial wird Folgendes behandelt:

• Installation von Risc0

• Schreiben Sie Ihr erstes wissensfreies Programm mit Rust

  
  

Voraussetzungen:

• Kopieren und Einfügen von Verknüpfungen

• Erforderliche Installationen:

  • Rust-Sprache
  • Frachtkiste

• Einige grundlegende Programmierkenntnisse in Rust

• Code-Editor (VSCODE, wenn möglich)

  
  

Am Ende verfügen Sie über praktische Erfahrung mit wissensfreien Beweisen in Risc0. Es sind keine fortgeschrittenen mathematischen oder kryptografischen Kenntnisse erforderlich.

Wir konzentrieren uns auf die Grundlagen der Codierung, um mit der Entwicklung realer Lösungen zu beginnen. Diese praktische Einführung soll leistungsstarke Datenschutztechnologien für jeden Entwickler verständlich machen.

Installation :

• (Für MacOS) Um Rust und Cargo zu installieren, können Sie den folgenden Befehl im Terminal ausführen:

  curl [https://sh.rustup.rs](https://sh.rustup.rs/) -sSf | sh

• Um Risc0 zu installieren, führen Sie nach der Installation von Rust den folgenden Befehl aus und starten das Terminal neu:

  cargo install cargo-risczero

• Damit die oben genannten Befehle erfolgreich erstellt werden können, müssen Sie die erforderlichen Abhängigkeiten installiert haben. brew install openssl brew install pkgconf

• Als nächstes müssen wir die risc0 Toolchain mit „ cargo risczero install installieren

Das ist alles was wir brauchen. Gehen wir also zum Code-Editor.

Einige magische Zeilen schreiben:

Nachdem wir nun mit der Installation fertig sind, können Sie diese Abra-Kadabra-🪄-Schritte lesen und befolgen:

1. Öffnen Sie den Code-Editor und gehen Sie im Editor-Terminal zu dem Ort, an dem Sie Ihr Projekt erstellen möchten.

   
   

2. Erstellen Sie eine neue Instanz des Projekts mit dem folgenden Befehl im Terminal: cargo risczero new multiply .

   
   

   

3. Es sollte ein Ordner mit dem Namen „multiply“ erstellt werden. CD hinein. cd multiply

   
   

4. Die Ordnerstruktur ist sehr einfach.

   
   

   1. Wir haben einen Host-Ordner und einen Methodenordner.

      
      

   2. Der Host-Ordner enthält das Host-Programm, das wir Gastprogramm nennen. Es besteht auch die Möglichkeit, dies zu überprüfen, wenn Sie möchten.

      
      

   3. Der Ordner „Methoden“ enthält das Gastprogramm, das den Teil der zkvm-Anwendung enthält, der geprüft wird. Es empfängt die Eingabeparameter vom Host, generiert dann basierend auf der Logik Ergebnisse, schreibt sie in das Journal und sendet sie als Empfangsbestätigung an den Host.

      
      

   4. Die restlichen Dateien werden bei Bedarf unterwegs erklärt.

   

5. Beginnen wir mit dem Gästeprogramm.

   
   

   1. Ändern wir den Namen der Dateien main.rs —> multiply.rs .

      

      

   2. Erstellen Sie einen Ordner mit dem Namen bin im Ordner src und verschieben Sie mutiply.rs dorthin. Ihre Ordnerstruktur sollte etwa so aussehen:

      

   3. Öffnen Sie Cargo.toml und ändern Sie das Update in name = "method_name” —> name = "multiply” .

      

   4. Fügen Sie den folgenden Code in Cargo.toml hinzu.

       [[bin]] name = "multiply" path = "src/bin/multiply.rs"

   5. Ihr endgültiges Cargo.toml sieht also folgendermaßen aus:

      

   6. Öffnen Sie nun multiply.rs . Hier bearbeiten wir die Hauptfunktion. Dies ist die Funktion, die in zkvm ausgeführt wird.

      
      

      1. Im folgenden Code übernehmen wir die Eingabe vom Host-Programm. Dann stellen wir sicher, dass es sich bei der Eingabe nicht um triviale Faktoren handelt, die 1 sind. Dann berechnen wir das Produkt und übergeben es schließlich wieder an den Host des Programms.

          // We will get the values for these variables from host program let a:u64 = env::read(); let b:u64 = env::read(); // To avoid trivial factors like multiplication by 1 if a == 1 || b == 1 { panic!("Trivial factors !!") // The panic! macro in Rust is used to intentionally crash a program when an unrecoverable error occurs } // Caculate the product of the two numbers let product = a.checked_mul(b).expect("Integer Overflow"); // Commit back the output to the host to save it as receipt env::commit(&product);

      2. Nach den oben genannten Änderungen sollte Ihr multiply.rs so aussehen.

         

   7. Es gibt noch eine letzte Änderung im methods Cargo.toml .

      

   8. Öffnen und aktualisieren Sie den Wert von name = "multiply-methods” .

      
      

   9. Ihr endgültiges Cargo.toml sieht wie folgt aus.

      

   10. Unsere Arbeit hier ist getan.

   11. Kommen wir nun zum Host-Programm.

       1. Ihr Host-Ordner muss jetzt so aussehen.

          

       2. Wir möchten main.rs in zwei Dateien aufteilen: prover.rs und verify.rs .

          
          

       3. Erstellen Sie unter src einen neuen Ordner und benennen Sie ihn als bin .

          
          

       4. Entfernen Sie main.rs . Erstellen Sie Dateien und benennen Sie sie verify.rs und prove.rs .

          
          

       5. Ihre Ordnerstruktur sollte jetzt etwa so aussehen.

          

       6. Öffnen Sie prove.rs und beginnen Sie mit dem Codieren:

          
          

       7. Fügen Sie den folgenden Code hinzu. Dies sind die Importe, die wir benötigen werden.

           use multiply_methods::MULTIPLY_ELF; // It is a binary file of multiply_method use risc0_zkvm::{ default_prover, serde::{from_slice, to_vec}, ExecutorEnv, };

          
          

       8. Nehmen wir Änderungen an der Hauptfunktion vor.

           fn main() { // Declaring our secret input params let a: u64 = 17; let b: u64 = 23; // First, we construct an executor environment let env = ExecutorEnv::builder() .add_input(&to_vec(&a).unwrap()) // Passing the input params to environment so it can be used by gues proggram .add_input(&to_vec(&b).unwrap()) .build() .unwrap(); // Obtain the default prover. let prover = default_prover(); // Produce a receipt by proving the specified ELF binary. let receipt = prover.prove_elf(env, MULTIPLY_ELF).unwrap(); // Extract journal of receipt (ie output c, where c = a * b) let c: u64 = from_slice(&receipt.journal).unwrap(); // Print an assertion println!("Hello, world! I know the factors of {}, and I can prove it!", c); // Let's serialize the receipt so we can save it to an file for verifier program to verify. let serialized = bincode::serialize(&receipt).unwrap(); // Writing the serialized contect to receipt.bin file let _saved_file = match std::fs::write("./receipt.bin", serialized){ Ok(()) => println!("Receipt saved and serialized as receipt.bin"), Err(_) => println!("Something went wrong !!"), }; }

          
          

       9. Ihr endgültiger prove.rs sollte so aussehen.

          

       10. Lassen Sie uns unsere verify.rs öffnen und Code hinzufügen.

           
           

       11. Hier importieren wir die Image-ID des Gastprogramms und einige grundlegende Importe.

            use multiply_methods::MULTIPLY_ID; use risc0_zkvm::Receipt;

           
           

       12. Nehmen wir Änderungen an der Hauptfunktion vor.

            fn main(){ // Let's impor the receipt that was generated by prove let receipt_path ="./receipt.bin".to_string(); let receipt_file = std::fs::read(receipt_path).unwrap(); // As we has serialized the receipt we need to desrialize it let receipt = bincode::deserialize::<Receipt>(&receipt_file).unwrap(); // Let's verify if the receipt that was generated was not created tampered with let _verification = match receipt.verify(MULTIPLY_ID){ Ok(()) => println!("Proof is Valid"), Err(_) => println!("Something went wrong !!"), }; }

           
           

       13. Ihr endgültiges verify.rs sollte in etwa so aussehen.

           

       14. Ich verspreche, dass dies die letzten Änderungen sind. Jetzt sind wir fast fertig.

           
           

       15. Öffnen Sie Cargo.toml im host Ordner und nehmen Sie unter Abhängigkeiten die folgenden Änderungen vor.

           

            multiply-methods = { path = "../methods" }

       16. Ihr Cargo.toml wird so aussehen.

           

   12. Es ist endlich Zeit zu sehen, ob unser Code funktioniert.

       
       

   13. Starten Sie Ihre Konsole im Stammverzeichnis des Projekts und führen Sie den folgenden Befehl in console cargo run --release --bin prove aus

       
       

   14. Dieser Befehl generiert den Nachweis und die Quittung für den Prüfer.

       
       

       Beim ersten Start wird es viel Zeit in Anspruch nehmen. Machen Sie sich also keine Sorgen und holen Sie sich einen Kaffee, bis der Vorgang abgeschlossen ist.

       
       

       

   15. Sobald dies erledigt ist, können Sie bei Bedarf die von Ihnen erstellte Quittung überprüfen. Führen Sie dazu den Befehl cargo run --release --bin verify aus

       
       

       Beim ersten Start wird es viel Zeit in Anspruch nehmen. Machen Sie sich also keine Sorgen und holen Sie sich einen Kaffee, bis der Vorgang abgeschlossen ist.

       
       

       

   Glückwunsch !!! beim Schreiben Ihrer ersten ZK-App mit Risc0. Wenn Sie Hilfe benötigen, schreiben Sie mir bitte einen Kommentar und ich werde mich bei Ihnen melden.