rekrypt 1.0.1

Professional proxy re-encryption library based on Curve25519 for Rust and WebAssembly
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

// SPDX-License-Identifier: AGPL-3.0-or-later
// Copyright (C) 2025 stenvenleep

use crate::crypto::{
    aes_decrypt, aes_encrypt, compute_hmac, derive_key_pbkdf2, generate_iv, generate_salt,
    verify_mac,
};
use crate::errors::{CryptoError, ErrorCode};
use crate::i18n::I18n;
use crate::types::{CipherParams, KdfParams, Keystore, KeystoreCrypto};
use crate::validation::{
    validate_iv, validate_kdf_iterations, validate_password_strength, validate_private_key,
};
use zeroize::Zeroize;

/// Creates encrypted keystore
pub fn create_keystore(
    private_key: &[u8],
    password: &str,
    i18n: &I18n,
) -> Result<Keystore, CryptoError> {
    validate_private_key(private_key, i18n)?;

    validate_password_strength(password, i18n)?;

    let salt = generate_salt();
    let iv = generate_iv();
    let iterations = 600_000u32;
    let dklen = 32;

    let mut key = derive_key_pbkdf2(password.as_bytes(), &salt, iterations, dklen);
    let ciphertext = aes_encrypt(&key, &iv, private_key, i18n)?;

    let version_bytes = [1u8];
    let iterations_bytes = iterations.to_le_bytes();
    let dklen_bytes = (dklen as u32).to_le_bytes();
    let cipher_name = b"aes-256-gcm";
    let kdf_name = b"pbkdf2-hmac-sha256";

    let mut mac_data = compute_hmac(
        &key,
        &[
            &ciphertext,
            &salt,
            &iv,
            &iterations_bytes,
            &dklen_bytes,
            &version_bytes,
            cipher_name,
            kdf_name,
        ],
    );

    key.zeroize();

    let keystore = Keystore {
        version: 1,
        crypto: KeystoreCrypto {
            cipher: "aes-256-gcm".to_string(),
            ciphertext,
            cipherparams: CipherParams { iv: iv.to_vec() },
            kdf: "pbkdf2-hmac-sha256".to_string(),
            kdfparams: KdfParams {
                dklen: dklen as u32,
                n: iterations,
                p: 1,
                r: 8,
                salt,
            },
            mac: mac_data.clone(),
        },
    };

    mac_data.zeroize();

    Ok(keystore)
}

/// Recovers private key from keystore
pub fn recover_from_keystore(
    keystore: &Keystore,
    password: &str,
    i18n: &I18n,
) -> Result<Vec<u8>, CryptoError> {
    if keystore.version != 1 {
        return Err(CryptoError::new(
            ErrorCode::UnsupportedVersion,
            i18n.format(
                "unsupported_version",
                &[("version", &keystore.version.to_string())],
            ),
        ));
    }

    validate_kdf_iterations(keystore.crypto.kdfparams.n, i18n)?;
    validate_iv(&keystore.crypto.cipherparams.iv, i18n)?;

    let mut key = derive_key_pbkdf2(
        password.as_bytes(),
        &keystore.crypto.kdfparams.salt,
        keystore.crypto.kdfparams.n,
        keystore.crypto.kdfparams.dklen as usize,
    );

    let version_bytes = [keystore.version];
    let iterations_bytes = keystore.crypto.kdfparams.n.to_le_bytes();
    let dklen_bytes = keystore.crypto.kdfparams.dklen.to_le_bytes();
    let cipher_name = keystore.crypto.cipher.as_bytes();
    let kdf_name = keystore.crypto.kdf.as_bytes();

    let computed_mac = compute_hmac(
        &key,
        &[
            &keystore.crypto.ciphertext,
            &keystore.crypto.kdfparams.salt,
            &keystore.crypto.cipherparams.iv,
            &iterations_bytes,
            &dklen_bytes,
            &version_bytes,
            cipher_name,
            kdf_name,
        ],
    );

    if let Err(e) = verify_mac(&computed_mac, &keystore.crypto.mac, i18n) {
        key.zeroize();
        return Err(e);
    }

    let private_key = aes_decrypt(
        &key,
        &keystore.crypto.cipherparams.iv,
        &keystore.crypto.ciphertext,
        i18n,
    );

    key.zeroize();

    private_key
}