double-ratchet-rs

Implementation of the double ratchet system/encryption as specified by Signal.

The implementation follows the cryptographic recommendations provided by Signal. The AEAD Algorithm uses a constant Nonce. This might be changed in the future.

Fork of double-ratchet-2.

Example Usage

Standard

```rust use doubleratchetrs::ratchet::Ratchet;

let sk = [1; 32]; // Initial Key created by a symmetric key agreement protocol

let (mut bobratchet, publickey) = Ratchet::initbob(sk); // Creating Bobs Ratchet (returns Bobs PublicKey) let mut aliceratchet = Ratchet::initalice(sk, publickey); // Creating Alice Ratchet with Bobs PublicKey

let data = b"Hello World".to_vec(); // Data to be encrypted let ad = b"Associated Data"; // Associated Data

let (header, encrypted, nonce) = aliceratchet.ratchetencrypt(&data, ad); // Encrypting message with Alice Ratchet (Alice always needs to send the first message) let decrypted = bobratchet.ratchetdecrypt(&header, &encrypted, &nonce, ad); // Decrypt message with Bobs Ratchet

assert_eq!(data, decrypted) ```

Lost message

```rust use doubleratchetrs::ratchet::Ratchet;

let sk = [1; 32]; // Initial Key created by a symmetric key agreement protocol

let (mut bobratchet, publickey) = Ratchet::initbob(sk); // Creating Bobs Ratchet (returns Bobs PublicKey) let mut aliceratchet = Ratchet::initalice(sk, publickey); // Creating Alice Ratchet with Bobs PublicKey

let data = b"Hello World".to_vec(); // Data to be encrypted let ad = b"Associated Data"; // Associated Data

let (header1, encrypted1, nonce1) = aliceratchet.ratchetencrypt(&data, ad); // Lost message let (header2, encrypted2, nonce2) = aliceratchet.ratchetencrypt(&data, ad); // Successful message

let decrypted2 = bobratchet.ratchetdecrypt(&header2, &encrypted2, &nonce2, ad); // Decrypting second message first let decrypted1 = bobratchet.ratchetdecrypt(&header1, &encrypted1, &nonce1, ad); // Decrypting latter message

asserteq!(data, decrypted1); asserteq!(data, decrypted2); ```

Encryption before recieving inital message

```rust use doubleratchetrs::ratchet::Ratchet;

let sk = [1; 32];

let (mut bobratchet, _) = Ratchet::initbob(sk);

let data = b"Hello World".to_vec(); let ad = b"Associated Data";

let (, _, _) = bobratchet.ratchet_encrypt(&data, ad); ```

Encryption after recieving initial messages

However bob can (of course) also encrypt messages. This is possible, after decrypting the first message from alice.

```rust use doubleratchetrs::ratchet::Ratchet; let sk = [1; 32];

let (mut bobratchet, publickey) = Ratchet::initbob(sk); let mut aliceratchet = Ratchet::initalice(sk, publickey);

let data = b"Hello World".to_vec(); let ad = b"Associated Data";

let (header1, encrypted1, nonce1) = aliceratchet.ratchetencrypt(&data, ad); let decrypted1 = bobratchet.ratchet_decrypt(&header1, &encrypted1, &nonce1, ad);

let (header2, encrypted2, nonce2) = bobratchet.ratchetencrypt(&data, ad); let decrypted2 = aliceratchet.ratchetdecrypt(&header2, &encrypted2, &nonce2, ad);

assert_eq!(data, decrypted2); ```

Constructing and deconstructing headers

```rust use doubleratchetrs::ratchet::Ratchet; use doubleratchetrs::header::Header;

let sk = [1; 32];

let (mut bobratchet, publickey) = Ratchet::initbob(sk); let mut aliceratchet = Ratchet::initalice(sk, publickey);

let data = b"hello World".to_vec(); let ad = b"Associated Data";

let (header, , _) = aliceratchet.ratchetencrypt(&data, ad); let headerbytes: Vec = header.clone().into(); let headerconst = Header::from(headerbytes);

asserteq!(header, headerconst); ```

Encrypted headers

```rust use doubleratchetrs::ratchet::RatchetEncHeader;

let sk = [0; 32]; let sharedhka = [1; 32]; let sharednhkb = [2; 32];

let (mut bobratchet, publickey) = RatchetEncHeader::initbob(sk, sharedhka, sharednhkb); let mut aliceratchet = RatchetEncHeader::initalice(sk, publickey, sharedhka, sharednhkb);

let data = b"Hello World".to_vec(); let ad = b"Associated Data";

let (header, encrypted, nonce) = aliceratchet.ratchetencrypt(&data, ad); let decrypted = bobratchet.ratchetdecrypt(&header, &encrypted, &nonce, ad);

assert_eq!(data, decrypted) ```

Export / Import Ratchet with encrypted headers

This ratchet implements import and export functionality. This works over a postcard backend and maybe useful for saving Ratchets to and loading from a file.

```rust use doubleratchetrs::ratchet::RatchetEncHeader;

let sk = [0; 32]; let sharedhka = [1; 32]; let sharednhkb = [2; 32];

let (bobratchet, publickey) = RatchetEncHeader::initbob(sk, sharedhka, sharednhkb); let exratchet = bobratchet.export(); let imratchet = RatchetEncHeader::import(&ex_ratchet).unwrap();

asserteq!(imratchet, bob_ratchet) ```

Minimum Supported Rust Version (MSRV)

The current MSRV is 1.61.0.

License

This project is licensed under the MIT license.