Introduction :

Les preuves sans connaissance permettent des transactions privées et sécurisées. Avec les zkSNARK et les zkSTARK, un prouveur peut prouver la possession de certaines informations à un vérificateur sans révéler les données réelles.

Cela présente un énorme potentiel d’anonymat et de confidentialité. Mais les zkSTARK et les zkSNARK sont complexes. Risc0 les rend plus accessibles. Voyons sa mise en œuvre très basique :

Ce tutoriel couvrira :

• Installation de Risc0

• Écrire votre premier programme sans connaissance en utilisant Rust

  
  

Conditions préalables:

• Raccourcis copier-coller

• Installations requises :

  • Langue rouille
  • Caisse de chargement

• Quelques connaissances de base en codage dans Rust

• Éditeur de code (VSCODE si possible)

  
  

À la fin, vous aurez une expérience pratique avec des preuves sans connaissance dans Risc0. Aucune formation avancée en mathématiques ou en cryptographie n’est requise.

Nous nous concentrerons sur les éléments essentiels du codage pour commencer à créer des solutions concrètes. Cette introduction pratique vise à rendre la puissante technologie de confidentialité compréhensible pour tout développeur.

Installation :

• (Pour MacOS) Pour installer rust et cargo, vous pouvez exécuter la commande ci-dessous dans le terminal :

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

• Pour installer Risc0, vous exécutez la commande ci-dessous après l'installation de rust et redémarrez le terminal :

  cargo install cargo-risczero

• Pour que les commandes ci-dessus soient créées avec succès, vous devrez avoir installé les dépendances requises. brew install openssl brew install pkgconf

• Ensuite, nous devrons installer la chaîne d'outils risc0 avec : cargo risczero install

C'est tout ce dont nous avons besoin. Passons donc à l'éditeur de code.

Écrire quelques lignes magiques :

Maintenant que nous avons terminé l'installation, vous pouvez lire et suivre ces étapes abra kadabra 🪄 :

1. Ouvrez l'éditeur de code et dirigez-vous vers l'emplacement où vous souhaitez créer votre projet dans le terminal de l'éditeur.

   
   

2. Créez une nouvelle instance du projet à l'aide de la commande ci-dessous dans le terminal : cargo risczero new multiply .

   
   

   

3. Vous devriez voir un dossier créé appelé multiplier. cd dedans. cd multiply

   
   

4. La structure des dossiers est très simple.

   
   

   1. Nous avons un dossier hôte et un dossier méthodes.

      
      

   2. Le dossier hôte contient le programme hôte que nous appelons le programme invité. Il a également la capacité de vérifier si vous le souhaitez.

      
      

   3. Le dossier méthodes contient le programme invité qui contient la partie de l'application zkvm qui est éprouvée. Il reçoit les paramètres d'entrée de l'hôte, puis, en fonction de la logique, il génère des résultats, les valide dans le journal et les envoie à l'hôte sous forme de reçu.

      
      

   4. Le reste des fichiers sera expliqué au fur et à mesure selon les besoins.

   

5. Commençons par le programme invité.

   
   

   1. Changeons le nom des fichiers main.rs —> multiply.rs .

      

      

   2. Créez un dossier nommé bin dans le dossier src et déplacez-y mutiply.rs . La structure de vos dossiers devrait ressembler à ceci :

      

   3. Ouvrez Cargo.toml et modifiez la mise à jour en name = "method_name” —> name = "multiply” .

      

   4. Ajoutez le code ci-dessous dans Cargo.toml .

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

   5. Votre Cargo.toml final ressemblera donc à ceci :

      

   6. Maintenant, ouvrez multiply.rs . Ici, nous allons éditer la fonction principale. C'est la fonction qui sera exécutée dans zkvm.

      
      

      1. Dans le code ci-dessous, nous prenons l'entrée du programme hôte. Ensuite, nous nous assurons que l'entrée n'est pas un facteur trivial qui vaut 1. Ensuite, nous calculons le produit et finalement le restituons à l'hôte du programme.

          // 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. Après les modifications ci-dessus, votre multiply.rs devrait ressembler à ceci.

         

   7. Il y a encore un dernier changement dans le dossier Cargo.toml des methods .

      

   8. Ouvrez et mettez à jour la valeur de name = "multiply-methods” .

      
      

   9. Votre Cargo.toml final ressemblera à ci-dessous.

      

   10. Notre travail ici est terminé.

   11. Passons maintenant au programme hôte.

       1. Votre dossier hôte doit ressembler à ceci maintenant.

          

       2. Nous voulons diviser le main.rs en deux fichiers qui sont prover.rs et verify.rs .

          
          

       3. Créez un nouveau dossier sous src et nommez-le bin .

          
          

       4. Supprimez main.rs . Créez des fichiers et nommez-les verify.rs & prove.rs .

          
          

       5. La structure de vos dossiers devrait maintenant ressembler à ceci.

          

       6. Ouvrez prove.rs et commençons à coder :

          
          

       7. Ajoutez le code ci-dessous. Ce sont les importations dont nous aurons besoin.

           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. Apportons des modifications à la fonction principale.

           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. Vos prove.rs finales devraient ressembler à ceci.

          

       10. Ouvrons et ajoutons du code à notre verify.rs .

           
           

       11. Ici, nous importerons l'ID de l'image du programme invité et quelques importations de base.

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

           
           

       12. Apportons des modifications à la fonction principale.

            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. Votre verify.rs finale devrait ressembler à ceci.

           

       14. Je promets que ce sont les derniers changements. Maintenant, nous avons presque terminé.

           
           

       15. Ouvrez le Cargo.toml dans le dossier host et apportez les modifications ci-dessous sous les dépendances.

           

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

       16. Votre Cargo.toml ressemblera à ceci.

           

   12. Il est enfin temps de voir si notre code fonctionne.

       
       

   13. Lancez votre console dans le répertoire racine du projet et exécutez la commande ci-dessous dans console cargo run --release --bin prove

       
       

   14. Cette commande générera la preuve et le reçu pour le vérificateur.

       
       

       Lors de la première exécution, cela prendra beaucoup de temps. Alors ne vous inquiétez pas, prenez un café en attendant la fin.

       
       

       

   15. Une fois cela fait, si vous le souhaitez, vous pouvez vérifier le reçu que vous avez généré. Pour cela, exécutez cette commande cargo run --release --bin verify

       
       

       Lors de la première exécution, cela prendra beaucoup de temps. Alors ne vous inquiétez pas, prenez un café en attendant la fin.

       
       

       

   Toutes nos félicitations !!! sur l'écriture de votre première application ZK à l'aide de Risc0. Si vous avez besoin d'aide, envoyez-moi un commentaire et je vous répondrai.