crypto-ext 9.0.0

Set of cryptographic functions to encrypt, decrypt, sign, verify data
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211

use crate::{get_path_relative_to_working_directory, get_static_filepath, read_file, read_or_create_and_write};
use p256::{ecdsa::{SigningKey, Signature, signature::Signer, VerifyingKey, signature::Verifier}, EncodedPoint};
use aes_gcm::aead::rand_core::OsRng;

#[cfg(test)]
mod tests;

/// SignatureParameters is basically the .der encoded ECDSA private key
pub struct SignatureParameters {
    pub ecdsa_private_key: Vec<u8>,
}

/// VerificationParameters is basically the .der encoded ECDSA public key
pub struct VerificationParameters {
    pub ecdsa_public_key: Vec<u8>,
}

/// Will read or create SignatureParameters and VerificationParameters at the given location which is relative to the working directory
pub fn setup(path_to_encryption_parameters: Option<&str>) -> Result<(SignatureParameters, VerificationParameters), String> {
    let signing_key = SigningKey::random(&mut OsRng);
    let verifying_key = VerifyingKey::from(&signing_key);

    let signing_key_as_bytes = Vec::from(signing_key.to_bytes().as_slice());
    let verifying_key_as_bytes = Vec::from(verifying_key.to_encoded_point(false).as_bytes());

    let ecdsa_private_key = setup_private_key(signing_key_as_bytes.as_slice(), path_to_encryption_parameters).unwrap();
    let ecdsa_public_key = setup_public_key(verifying_key_as_bytes.as_slice(), path_to_encryption_parameters).unwrap();

    let signature_parameters = SignatureParameters {
        ecdsa_private_key
    };

    let verification_parameters = VerificationParameters {
        ecdsa_public_key
    };

    Ok((signature_parameters, verification_parameters))
}

/// Returns SignatureParameters stored at the given location which is relative to the working directory
pub fn get_signature_params(path_to_encryption_parameters: Option<&str>) -> Result<SignatureParameters, String> {
    let ecdsa_private_key = get_private_key(path_to_encryption_parameters).unwrap();
        let params = SignatureParameters {
        ecdsa_private_key,
    };

    Ok(params)
}

/// Returns VerificationParameters stored at the given location which is relative to the working directory
pub fn get_verification_params(path_to_encryption_parameters: Option<&str>) -> Result<VerificationParameters, String> {
    let ecdsa_public_key = get_public_key(path_to_encryption_parameters).unwrap();
    let params = VerificationParameters {
        ecdsa_public_key
    };

    Ok(params)
}

/// Signs given byte array
///
/// # Examples
///
/// ```
///     use crypto_ext::asymmetric::signing::{get_signature_params, get_verification_params, setup, sign, verify};
///     #[test]
///     fn signing() {
///         let data = "some data to sign".as_bytes();
///         // path needs to be accessible by user with write permission for initial setup
///         let path_to_params = "/test/signature_parameters/";
///
///         // setup will read, or populate required parameters for signing and verification
///         // in this example setup is used to populate the required parameters
///         let (signature_params, verification_params) = setup(Some(path_to_params)).unwrap();
///
///         let signature = sign(signature_params, data).unwrap();
///
///         let verified = verify(verification_params, data, signature.as_slice());
///
///         assert!(verified.is_ok());
///     }
/// ```
pub fn sign(params: SignatureParameters, data: &[u8]) -> Result<Vec<u8>, String> {
    let signing_key = SigningKey::from_bytes(params.ecdsa_private_key.as_slice()).unwrap();
    let signature = signing_key.sign(data);
    Ok(signature.to_der().as_bytes().to_vec())
}


/// Verifies given byte array
///
/// # Examples
///
///
/// ```
///     use crypto_ext::asymmetric::signing::{get_signature_params, get_verification_params, setup, sign, verify};
///     #[test]
///     fn verification() {
///         let data = "some data to sign".as_bytes();
///         let path_to_params = "/test/signature_parameters/";
///
///         // to verify signature, we need to sign first
///         // setup will read, or populate required parameters for signing and verification
///         // in this example setup is used to populate the required parameters
///         let _ = setup(Some(path_to_params)).unwrap();
///
///         let signature_params = get_signature_params(Some(path_to_params)).unwrap();
///         let signature = sign(signature_params, data).unwrap();
///
///         let verification_params = get_verification_params(Some(path_to_params)).unwrap();
///         let verified = verify(verification_params, data, signature.as_slice());
///
///         assert!(verified.is_ok());
///     }
/// ```
pub fn verify(params: VerificationParameters, data: &[u8], signature: &[u8]) -> Result<(), String> {
    let point = EncodedPoint::from_bytes(params.ecdsa_public_key.as_slice()).unwrap();
    let verifying_key = VerifyingKey::from_encoded_point(&point).unwrap();

    let signature = Signature::from_der(signature).unwrap();
    let verified = verifying_key.verify(data, &signature);

    return if verified.is_ok() {
        Ok(())
    } else {
        let message = verified.err().unwrap().to_string();
        Err(message)
    }
}

// below are functions not exposed as an api, used for inner implementation

fn setup_private_key(private_key: &[u8], path_to_encryption_parameters: Option<&str>) -> Result<Vec<u8>, String> {
    let relative_path = get_path_relative_to_working_directory(path_to_encryption_parameters, ".ecdsa_private_key.der");
    let boxed_private_key_path = get_static_filepath(relative_path.as_str());
    if boxed_private_key_path.is_err() {
        return Err(boxed_private_key_path.err().unwrap());
    }

    let dsa_private_key_path = boxed_private_key_path.unwrap();
    let boxed_private_key = get_or_create_value_at_path(dsa_private_key_path.as_str(), private_key);
    if boxed_private_key.is_err() {
        return Err(boxed_private_key.err().unwrap());
    }
    let private_key = boxed_private_key.unwrap();
    Ok(private_key)
}

fn get_private_key(path_to_encryption_parameters: Option<&str>) -> Result<Vec<u8>, String> {
    let relative_path = get_path_relative_to_working_directory(path_to_encryption_parameters, ".ecdsa_private_key.der");
    let boxed_private_key_path = get_static_filepath(relative_path.as_str());
    if boxed_private_key_path.is_err() {
        return Err(boxed_private_key_path.err().unwrap());
    }

    let ecdsa_private_key_path = boxed_private_key_path.unwrap();
    let boxed_private_key = read_file(ecdsa_private_key_path.as_str());
    if boxed_private_key.is_err() {
        return Err(boxed_private_key.err().unwrap());
    }
    let private_key = boxed_private_key.unwrap();
    Ok(private_key)
}

fn setup_public_key(public_key: &[u8], path_to_encryption_parameters: Option<&str>) -> Result<Vec<u8>, String> {
    let relative_path = get_path_relative_to_working_directory(path_to_encryption_parameters, ".ecdsa_public_key.der");
    let boxed_public_key_path = get_static_filepath(relative_path.as_str());
    if boxed_public_key_path.is_err() {
        return Err(boxed_public_key_path.err().unwrap());
    }

    let ecdsa_public_key_path = boxed_public_key_path.unwrap();
    let boxed_public_key = get_or_create_value_at_path(ecdsa_public_key_path.as_str(), public_key);
    if boxed_public_key.is_err() {
        return Err(boxed_public_key.err().unwrap());
    }

    let public_key = boxed_public_key.unwrap();

    Ok(public_key)
}

fn get_public_key(path_to_encryption_parameters: Option<&str>) -> Result<Vec<u8>, String> {
    let relative_path = get_path_relative_to_working_directory(path_to_encryption_parameters, ".ecdsa_public_key.der");
    let boxed_public_key_path = get_static_filepath(relative_path.as_str());
    if boxed_public_key_path.is_err() {
        return Err(boxed_public_key_path.err().unwrap());
    }

    let ecdsa_public_key_path = boxed_public_key_path.unwrap();
    let boxed_public_key = read_file(ecdsa_public_key_path.as_str());
    if boxed_public_key.is_err() {
        return Err(boxed_public_key.err().unwrap());
    }

    let public_key = boxed_public_key.unwrap();

    Ok(public_key)
}

fn get_or_create_value_at_path(path: &str, value: &[u8]) -> Result<Vec<u8>, String> {

    let boxed_passphrase = read_or_create_and_write(path, value);
    if boxed_passphrase.is_err() {
        let message = boxed_passphrase.err().unwrap();
        return Err(message)
    }

    let passphrase = boxed_passphrase.unwrap();
    Ok(passphrase)
}