Zero-Knowledge Proofs in Rust

Name: Zero-Knowledge Proofs in Rust
Rating: 4.4 (116 reviews)

A practical approch

Created byGuido Giuntoli

Last updated 8/2023

English

What you'll learn

Understand how Zero-Knowledge Proofs can be used in practice to authenticate users on a server
How to develop with Rust a full backend service based on ZKP for authentication
To fully couple the system with the gRPC protocol allowing any user to communicate with it
To create containers of the application with Docker to deploy the code on the cloud or work in different environments

Course content

4 sections • 27 lectures • 5h 9m total length

Course Description4:44
Explore the Petersen protocol as an interactive zero-knowledge proof for passwordless user authentication, implemented in Rust, with server challenges, gRPC communication, and dockerized deployment.
Introduction To Modular Arithmetics7:30
Master the basics of modular arithmetic, including remainders, mod notation, handling negatives, and the cyclic behavior that underpins later group theory applications.
Modular Arithmetics Quiz
Groups13:33
Learn about groups as sets with an operation, focusing on modular addition modulo five. Define closure, associativity, identity, inverse, and the abelian (commutative) case.
Generators9:49
Explore generators in a finite cyclic group under modular multiplication modulo 11, using powers of 2 to generate all elements and distinguish non-generators like 3.
Discrete Logarithm Problem9:58
Chaum-Pedersen ZKP Protocol19:46
Chaum-Pedersen ZKP Protocol
Toy Example12:10
Importance of Good Random Numbers Generators

Install Rust3:38
Design Schema6:18
Design the schema for zero-knowledge proofs in Rust by outlining the prover-verifier interactions, implementing exponentiation modulo p, verify logic, random number generation, and using big integers for security.
Coding Exponentiate, Solve & Verify16:06
Unit Test: Toy Example10:56
Random Number Generator (RNG)6:28
Refactoring: Add a ZKP struct9:52
Refactor the zero-knowledge proofs library in Rust by introducing a public struct for constants and generators alpha and beta, and implement protocol methods using self, including verify and generate.
1024-bit Unit Test15:35
Stress tests use 1024-bit integers to ensure a prime order group with a generator, loading 5114 constants for Diffie-Hellman, and validating random exponents in Rust.

gRPC Server Design9:57
Writting and Compiling a Protobuf File with Tonic14:16
Client/Server gRPC Protocol
Creating Server & Client Executables8:42
Run the Tonic Server11:44
Process Register Requests18:39
Implement the server register flow by parsing username, y1 and y2, and storing them in a mutex-protected hash map via a user info struct, exposed via gRPC.
Process Challenge Request15:47
Process Solution Request21:19
Implement and verify the server-side authentication flow in Rust, generating a 12-character random session id, resolving auth IDs, and validating the client's solution against the challenge.
Build the Client: Create Register Request15:38
Build the Client: Create Authentication Requests13:36
Develop a zero-knowledge proof authentication client and server, compute R1 and R2 challenges as big integers, and exchange authentication challenges via gRPC.
Possible Code Improvements as Homework4:55
Advance the zero-knowledge proof server and client with gRPC in Rust, apply code improvements as homework using cargo clippy, and implement serialize and get_pair helpers.

Introduction to Docker6:09
Writting a Dockerfile and docker-compose.yaml9:34
Write a dockerfile and docker-compose.yaml to build a rust-based zero knowledge proof server image, map local volumes, and run the container with cargo.
Running the server and client in the Docker container13:03
Learn to dockerize a zero knowledge proof Rust app by installing the protobuf compiler, building a release image, and running a server and client with Docker Compose.

Requirements

You may need some basic math knowledge like algebraic operations. Most of the concepts are covered from the ground up during the course.
The installation and Rust programming is fully covered in the course. Some previous programming experience is highly recommended.

Description

This Zero-Knowledge Proof course in Rust is designed to learn how to implement a cryptography ZKP algorithm and use it in real-world applications for user registration and authentication.

The course is divided into four main parts:

Theoretical Foundations: we will have a didactic introduction to the Chaum-Pedersen Protocol and understand how this interactive ZKP algorithm works with small toy examples. Additionally, we will cover what finite cyclic groups, generators and the discrete logarithm problem are.
Rust Implementation: we will implement in Rust what we have seen in the theory section. Here I recommend you execute the code by yourself and also create a GitHub repo to have a showcase in your portfolio. This will help future employers to know what you are talking about!
gRPC Server/Client: here, we use the previous Rust ZKP library we implemented to create a server that authenticates users through a gRPC protocol. This part is useful even if you are not interested in cryptography or ZKP protocols. Many companies and startups are interested in people with experience in gRPC.
Dockerization: in the last part of the course, we will learn how to dockerize the application using Docker. This will enable us to run it on any Windows, Linux, or MacOS system.

Who this course is for:

For those eager to learn something unique and know how to implement ZKP cryptography algorithms
For those wanting to implement backend systems using Rust
For those who desire to have a practical use case of the gRPC protocol

Zero-Knowledge Proofs in Rust

What you'll learn

Explore related topics

Course content

Course Description7 lectures • 1hr 18min

ZKP Protocol in Rust7 lectures • 1hr 9min

Building a gRPC server10 lectures • 2hr 15min

Dockerizing the Application3 lectures • 29min

Requirements

Description

Who this course is for: