recrypt 0.1.0

A pure-Rust implementation of Transform Encryption, a Proxy Re-encryption scheme
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

#![cfg_attr(feature = "unstable", feature(test))]
#![doc(html_playground_url = "https://play.rust-lang.org/")]
#![doc(html_no_source)] // use github for source browsing

//! Recrypt implements a set of cryptographic primitives that are needed for a
//! multi-hop proxy re-encryption scheme, known as Transform Encryption.
//!
//! ## Basic Encrypt/Decrypt Example
//! ```
//! use recrypt::api::*;
//! // create a new recrypt api
//! let mut api = Api::new();
//!
//! // generate a plaintext to encrypt
//! let pt = api.gen_plaintext();
//!
//! // generate a public/private keypair and some signing keys
//! let (priv_key, pub_key) = api.generate_key_pair().unwrap();
//! let (priv_signing_key, pub_signing_key) = api.generate_ed25519_key_pair();
//!
//! // encrypt!
//! let encrypted_val = api.encrypt(pt, pub_key, pub_signing_key, priv_signing_key).unwrap();
//!
//! // decrypt!
//! let decrypted_val = api.decrypt(encrypted_val, priv_key).unwrap();
//!
//! assert_eq!(pt, decrypted_val)
//! ```

//! ## Single-hop Transform Encryption Example
//! Encrypt a message to public key `initial_pub_key` and decrypt it with `target_priv_key`
//! after transforming the encrypted message.
//! ```
//! use recrypt::api::*;
//! // create a new recrypt api
//! let mut api = Api::new();
//!
//! // generate a plaintext to encrypt
//! let pt = api.gen_plaintext();
//!
//! // generate signing keys
//! let (priv_signing_key, pub_signing_key) = api.generate_ed25519_key_pair();
//!
//! // generate a public/private keypair to encrypt the data to initially.
//! let (initial_priv_key, initial_pub_key) = api.generate_key_pair().unwrap();
//!
//! // encrypt the data to `initial_pub_key`!
//! let encrypted_val = api.encrypt(pt, initial_pub_key, pub_signing_key, priv_signing_key).unwrap();
//!
//! // generate a second public/private keypair as the target of the transform.
//! // after applying the transform, `target_priv_key` will be able to decrypt the data!
//! let (target_priv_key, target_pub_key) = api.generate_key_pair().unwrap();
//!
//! // generate a transform key that will change which private key can decrypt the data
//! let initial_to_target_transform_key = api.generate_transform_key(
//!     initial_priv_key,
//!     target_pub_key,
//!     pub_signing_key,
//!     priv_signing_key).unwrap();
//!
//! // Transform the plaintext to be encrypted to the target!
//! // The data is _not_ be decrypted here. Simply transformed!
//! let transformed_val = api.transform(
//!     encrypted_val,
//!     initial_to_target_transform_key,
//!     pub_signing_key,
//!     priv_signing_key).unwrap();
//!
//! // decrypt the transformed value with the target private key and recover the plaintext
//! let decrypted_val = api.decrypt(transformed_val, target_priv_key).unwrap();
//!
//! assert_eq!(pt, decrypted_val);
//! ```
extern crate arrayvec;
extern crate core;
extern crate curve25519_dalek;
extern crate ed25519_dalek;
extern crate gridiron;
extern crate num_traits;
extern crate rand;
extern crate sha2;

#[cfg(test)]
#[macro_use]
extern crate proptest;

#[cfg(test)]
extern crate hex;

#[macro_use]
extern crate lazy_static;

#[macro_use]
mod internal; // this needs to come before `api` as api relies on macros defined in `internal`
pub mod api;
pub mod nonemptyvec;