10 releases (6 breaking)

0.7.0 Apr 14, 2022
0.6.0 Jun 21, 2021
0.5.0 Jun 18, 2021
0.4.1 Jun 18, 2021
0.1.1 Jun 13, 2021

#161 in Encoding

Download history 73/week @ 2022-06-08 20/week @ 2022-06-15 34/week @ 2022-06-22 59/week @ 2022-06-29 23/week @ 2022-07-06 30/week @ 2022-07-13 77/week @ 2022-07-20 130/week @ 2022-07-27 123/week @ 2022-08-03 42/week @ 2022-08-10 28/week @ 2022-08-17 43/week @ 2022-08-24 32/week @ 2022-08-31 43/week @ 2022-09-07 44/week @ 2022-09-14 23/week @ 2022-09-21

143 downloads per month
Used in 3 crates (2 directly)




crates.io Crates.io docs.rs MSRV ci codecov License: MIT License: Apache 2.0

serde-encrypt logo

🔐 Encrypts all the Serialize.

               Alice                                         Bob
+-----------------------------------+        +-----------------------------------+
| #[derive(Serialize, Deserialize)] |        | #[derive(Serialize, Deserialize)] |
| struct Message                    |        | struct Message                    |
+-----------------------------------+        +-----------------------------------+
                 | .encrypt()                                  ^
                 v                                             | ::decrypt()
+-----------------------------------+        +-----------------------------------+
| struct EncryptedMessage           |        | struct EncryptedMessage           |
+-----------------------------------+        +-----------------------------------+
                 | .serialize()                                ^
                 v                                             | ::deserialize()
+-----------------------------------+        +-----------------------------------+
| struct Vec<u8>                    | -----> | struct Vec<u8>                    |
+-----------------------------------+        +-----------------------------------+


serde-encrypt encrypts/decrypts any structs and enums that implements serde::{Serialize, Deserialize}.

serde-encrypt supports both shared-key encryption (XChaCha20-Poly1305) and public-key encryption (XChaCha20-Poly1305 with X25519 key-exchange), both of which are considered to be secure enough.

serde-encrypt is optionally available in no_std environments.

serde-encrypt = "(version)"  # If you use std
serde-encrypt = {version = "(version)", default-features = false}  # If you need no_std


Good first example from shared key encryption test.

If you and your peer already have shared-key, just implement SerdeEncryptSharedKey trait to your Serialize and Deserialize data types.

#[derive(Debug, Serialize, Deserialize)]
struct Message {
    content: String,
    sender: String,

impl SerdeEncryptSharedKey for Message {
    type S = BincodeSerializer<Self>;  // you can specify serializer implementation (or implement it by yourself).

Then, you can serialize the Message into Vec<u8> in encrypted form.

    // Alternative:
    // const SHARED_KEY: SharedKey = SharedKey::new_const([0u8; 32]); 
    let shared_key = SharedKey::new([0u8; 32]); // or your peer reads from elsewhere.

    let msg = Message {
        content: "I ❤️ you.".to_string(),
        sender: "Alice".to_string(),
    let encrypted_message = msg.encrypt(&shared_key)?;
    let serialized_encrypted_message: Vec<u8> = encrypted_message.serialize();

After your peer gets the binary, they can decrypt and deserialize it to Message.

    let shared_key = SharedKey::new([0u8; 32]);

    let encrypted_message = EncryptedMessage::deserialize(serialized_encrypted_message)?;
    let msg = Message::decrypt_owned(&encrypted_message, &shared_key);

Further examples...

Features and uses cases

Feature comparison

SerdeEncryptSharedKey SerdeEncryptSharedKeyDeterministic SerdeEncryptPublicKey
(a)symmetric? symmetric symmetric asymmetric
deterministic? (*1) no yes no
performance high high low

(*1) Deterministic encryptions always produce the same cipher-text from a given plain-text. More vulnerable but useful for equal-matching in cipher-text (e.g. RDBMS's encrypted index eq-search).

Encryption algorithm

SerdeEncryptSharedKey SerdeEncryptSharedKeyDeterministic SerdeEncryptPublicKey
key exchange - - X25519
encryption XChaCha20 XChaCha20 XChaCha20
message auth Poly1305 Poly1305 Poly1305
nonce (*2) XSalsa20 (random 24-byte) Fixed 24-byte XSalsa20 (random 24-byte)
Rng (*3) for nonce ChaCha20Rng - ChaCha20Rng
Implementation XChaCha20Poly1305 XChaCha20Poly1305 ChaChaBox

(*2) "Number used once": to make encryption non-deterministic. Although nonce for each encryption is not secret, nonce among different encryption must be different in order for attackers to get harder to guess plain-text.

(*3) Random number generator.


Crate users can choose and even implement by themselves serialize representations in design.

Currently, the following serializers are built-in.

  • BincodeSerializer (only std feature)
    • Best choice for std to reduce message size in most cases.
  • PostcardSerializer
    • Best choice for no_std to reduce message size in most cases.
  • CborSerializer
    • Has large message size but deals with complex serde types. See Encrypts/Decrypts complex serde types example to check kind of serde types only CborSerializer can serialize.
    • Single available choice in serde-encrypt-sgx.
      • Both bincode and postcard crates cannot compile with Rust SGX SDK

Use cases

  • SerdeEncryptSharedKey
    • Both message sender and receiver already hold shared key.
    • Needs shared-key exchange via any safe way but wants high-speed encryption/decryption (e.g. communicates large amounts of messages).
  • SerdeEncryptSharedKeyDeterministic
    • Only when you need deterministic encryption for equal-matching in cipher-text.
    • Note that this is more vulnerable than SerdeEncryptSharedKey because, for example, attackers can find repeated patterns in cipher-text and then guess repeated patterns in plain-text.
  • SerdeEncryptPublicKey
    • To exchange SharedKey.
    • Quickly sends/receive small amounts of messages without secret shared key.

Rust SGX SDK support

Use serde-encrypt-sgx crate.

Feature flags

  • std (serde-encrypt [default] ; serde-encrypt-core [default])
    • std::error::Error trait implementation to serde_encrypt::Error.
    • Random number generator is created via SeedableRng::from_entropy(), which is considered to be more secure in OS-available environments.
    • BincodeSerializer available.



serde-encrypt is a cargo workspace project and two crates are inside:

  • serde-encrypt-core
    • Encryption / Decryption implementations.
    • Traits for serialization / deserialization.
    • Traits for RNG (Random Number Generator) singleton.
  • serde-encrypt (depends on serde-encrypt-core)
    • Serialization / Deserialization impls.
    • RNG singleton impls.

serde-encrypt-sgx crate is also available in separate repository. It's in the same layer as serde-encrypt.

In order to use serde with Rust SGX SDK, people should use forked version serde-sgx. Also, Rust SGX SDK compiles with only old version of rustc (nightly-2020-10-25, currently), even simple no_std crate cannot build sometimes (e.g. spin crate cannot).

It is another choice to make serde-encrypt-sgx inside this repository using feature flags but it breaks cargo build --all-features in latest rustc.


crypto_box crate is used both for public-key encryption and shared-key encryption.

Pure Rust implementation of the crypto_box public-key authenticated encryption scheme from NaCl-family libraries (e.g. libsodium, TweetNaCl) which combines the X25519 Diffie-Hellman function and the XSalsa20Poly1305 authenticated encryption cipher into an Elliptic Curve Integrated Encryption Scheme (ECIES).


structs and enums to encrypt are serialized before encrypted. Built-in serializers are listed here.

Users can also implement TypedSerialized trait by themselves to get better serialization.




Licensed under either of Apache License, Version 2.0 or MIT license at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in serde-encrypt by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.


~89K SLoC