update examples

crates/crypto/examples/single_file.rs

@@ -1,4 +1,4 @@
-use std::fs::File;
+use tokio::fs::File;
 
 use sd_crypto::{
 	crypto::stream::{Algorithm, StreamDecryption, StreamEncryption},
@@ -11,12 +11,12 @@ use sd_crypto::{
 const ALGORITHM: Algorithm = Algorithm::XChaCha20Poly1305;
 const HASHING_ALGORITHM: HashingAlgorithm = HashingAlgorithm::Argon2id(Params::Standard);
 
-pub fn encrypt() {
+async fn encrypt() {
 	let password = Protected::new(b"password".to_vec());
 
 	// Open both the source and the output file
-	let mut reader = File::open("test").unwrap();
-	let mut writer = File::create("test.encrypted").unwrap();
+	let mut reader = File::open("test").await.unwrap();
+	let mut writer = File::create("test.encrypted").await.unwrap();
 
 	// This needs to be generated here, otherwise we won't have access to it for encryption
 	let master_key = generate_master_key();
@@ -36,13 +36,14 @@ pub fn encrypt() {
 		hashed_password,
 		master_key.clone(),
 	)
+	.await
 	.unwrap()];
 
 	// Create the header for the encrypted file
 	let header = FileHeader::new(LATEST_FILE_HEADER, ALGORITHM, keyslots);
 
 	// Write the header to the file
-	header.write(&mut writer).unwrap();
+	header.write(&mut writer).await.unwrap();
 
 	// Use the nonce created by the header to initialize a stream encryption object
 	let encryptor = StreamEncryption::new(master_key, &header.nonce, header.algorithm).unwrap();
@@ -51,21 +52,22 @@ pub fn encrypt() {
 	// Use AAD so the header can be authenticated against every block of data
 	encryptor
 		.encrypt_streams(&mut reader, &mut writer, &header.generate_aad())
+		.await
 		.unwrap();
 }
 
-pub fn decrypt() {
+async fn decrypt() {
 	let password = Protected::new(b"password".to_vec());
 
 	// Open both the encrypted file and the output file
-	let mut reader = File::open("test.encrypted").unwrap();
-	let mut writer = File::create("test.original").unwrap();
+	let mut reader = File::open("test.encrypted").await.unwrap();
+	let mut writer = File::create("test.original").await.unwrap();
 
 	// Deserialize the header, keyslots, etc from the encrypted file
-	let (header, aad) = FileHeader::from_reader(&mut reader).unwrap();
+	let (header, aad) = FileHeader::from_reader(&mut reader).await.unwrap();
 
 	// Decrypt the master key with the user's password
-	let master_key = header.decrypt_master_key(password).unwrap();
+	let master_key = header.decrypt_master_key(password).await.unwrap();
 
 	// Initialize a stream decryption object using data provided by the header
 	let decryptor = StreamDecryption::new(master_key, &header.nonce, header.algorithm).unwrap();
@@ -73,11 +75,13 @@ pub fn decrypt() {
 	// Decrypt data the from the writer, and write it to the writer
 	decryptor
 		.decrypt_streams(&mut reader, &mut writer, &aad)
+		.await
 		.unwrap();
 }
 
-fn main() {
-	encrypt();
+#[tokio::main]
+async fn main() {
+	encrypt().await;
 
-	decrypt();
+	decrypt().await;
 }

crates/crypto/examples/single_file_with_metadata.rs

@@ -7,7 +7,7 @@ use sd_crypto::{
 	primitives::{generate_master_key, generate_salt, LATEST_FILE_HEADER, LATEST_KEYSLOT},
 	Protected,
 };
-use std::fs::File;
+use tokio::fs::File;
 const ALGORITHM: Algorithm = Algorithm::XChaCha20Poly1305;
 const HASHING_ALGORITHM: HashingAlgorithm = HashingAlgorithm::Argon2id(Params::Standard);
 
@@ -16,7 +16,7 @@ pub struct FileInformation {
 	pub file_name: String,
 }
 
-fn encrypt() {
+async fn encrypt() {
 	let password = Protected::new(b"password".to_vec());
 
 	let embedded_metadata = FileInformation {
@@ -24,8 +24,8 @@ fn encrypt() {
 	};
 
 	// Open both the source and the output file
-	let mut reader = File::open("test").unwrap();
-	let mut writer = File::create("test.encrypted").unwrap();
+	let mut reader = File::open("test").await.unwrap();
+	let mut writer = File::create("test.encrypted").await.unwrap();
 
 	// This needs to be generated here, otherwise we won't have access to it for encryption
 	let master_key = generate_master_key();
@@ -45,6 +45,7 @@ fn encrypt() {
 		hashed_password,
 		master_key.clone(),
 	)
+	.await
 	.unwrap()];
 
 	// Create the header for the encrypted file (and include our metadata)
@@ -57,10 +58,11 @@ fn encrypt() {
 			master_key.clone(),
 			&embedded_metadata,
 		)
+		.await
 		.unwrap();
 
 	// Write the header to the file
-	header.write(&mut writer).unwrap();
+	header.write(&mut writer).await.unwrap();
 
 	// Use the nonce created by the header to initialise a stream encryption object
 	let encryptor = StreamEncryption::new(master_key, &header.nonce, header.algorithm).unwrap();
@@ -69,26 +71,28 @@ fn encrypt() {
 	// Use AAD so the header can be authenticated against every block of data
 	encryptor
 		.encrypt_streams(&mut reader, &mut writer, &header.generate_aad())
+		.await
 		.unwrap();
 }
 
-pub fn decrypt_metadata() {
+async fn decrypt_metadata() {
 	let password = Protected::new(b"password".to_vec());
 
 	// Open the encrypted file
-	let mut reader = File::open("test.encrypted").unwrap();
+	let mut reader = File::open("test.encrypted").await.unwrap();
 
 	// Deserialize the header, keyslots, etc from the encrypted file
-	let (header, _) = FileHeader::from_reader(&mut reader).unwrap();
+	let (header, _) = FileHeader::from_reader(&mut reader).await.unwrap();
 
 	// Decrypt the metadata
-	let file_info: FileInformation = header.decrypt_metadata(password).unwrap();
+	let file_info: FileInformation = header.decrypt_metadata(password).await.unwrap();
 
 	println!("file name: {}", file_info.file_name);
 }
 
-fn main() {
-	encrypt();
+#[tokio::main]
+async fn main() {
+	encrypt().await;
 
-	decrypt_metadata();
+	decrypt_metadata().await;
 }

crates/crypto/examples/single_file_with_preview_media.rs

@@ -1,4 +1,4 @@
-use std::fs::File;
+use tokio::fs::File;
 
 use sd_crypto::{
 	crypto::stream::{Algorithm, StreamEncryption},
@@ -11,12 +11,12 @@ use sd_crypto::{
 const ALGORITHM: Algorithm = Algorithm::XChaCha20Poly1305;
 const HASHING_ALGORITHM: HashingAlgorithm = HashingAlgorithm::Argon2id(Params::Standard);
 
-fn encrypt() {
+async fn encrypt() {
 	let password = Protected::new(b"password".to_vec());
 
 	// Open both the source and the output file
-	let mut reader = File::open("test").unwrap();
-	let mut writer = File::create("test.encrypted").unwrap();
+	let mut reader = File::open("test").await.unwrap();
+	let mut writer = File::create("test.encrypted").await.unwrap();
 
 	// This needs to be generated here, otherwise we won't have access to it for encryption
 	let master_key = generate_master_key();
@@ -36,6 +36,7 @@ fn encrypt() {
 		hashed_password,
 		master_key.clone(),
 	)
+	.await
 	.unwrap()];
 
 	let pvm_media = b"a nice mountain".to_vec();
@@ -50,10 +51,11 @@ fn encrypt() {
 			master_key.clone(),
 			&pvm_media,
 		)
+		.await
 		.unwrap();
 
 	// Write the header to the file
-	header.write(&mut writer).unwrap();
+	header.write(&mut writer).await.unwrap();
 
 	// Use the nonce created by the header to initialise a stream encryption object
 	let encryptor = StreamEncryption::new(master_key, &header.nonce, header.algorithm).unwrap();
@@ -62,26 +64,28 @@ fn encrypt() {
 	// Use AAD so the header can be authenticated against every block of data
 	encryptor
 		.encrypt_streams(&mut reader, &mut writer, &header.generate_aad())
+		.await
 		.unwrap();
 }
 
-pub fn decrypt_preview_media() {
+async fn decrypt_preview_media() {
 	let password = Protected::new(b"password".to_vec());
 
 	// Open the encrypted file
-	let mut reader = File::open("test.encrypted").unwrap();
+	let mut reader = File::open("test.encrypted").await.unwrap();
 
 	// Deserialize the header, keyslots, etc from the encrypted file
-	let (header, _) = FileHeader::from_reader(&mut reader).unwrap();
+	let (header, _) = FileHeader::from_reader(&mut reader).await.unwrap();
 
 	// Decrypt the preview media
-	let media = header.decrypt_preview_media(password).unwrap();
+	let media = header.decrypt_preview_media(password).await.unwrap();
 
 	println!("{:?}", media.expose());
 }
 
-fn main() {
-	encrypt();
+#[tokio::main]
+async fn main() {
+	encrypt().await;
 
-	decrypt_preview_media();
+	decrypt_preview_media().await;
 }