rustdesk/rustdesk-server
1
0
Fork 0
mirror of https://github.com/rustdesk/rustdesk-server.git synced 2025-07-01 23:35:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

better error management

Browse Source
This commit is contained in:
Paolo Asperti 2022-07-21 11:07:16 +02:00
parent 913de8515e
commit 26549d7e7e
No known key found for this signature in database
GPG Key ID: 06D46905D19D5182
1 changed files with 29 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
src/utils.rs
View File

@ -1,14 +1,17 @@
use hbb_common::{bail, ResultType};
use sodiumoxide::crypto::sign; use sodiumoxide::crypto::sign;
use std::env; use std::env;
use std::process; use std::process;
use std::str; use std::str;
fn print_help() { fn print_help() {
println!("Usage:"); println!(
println!(" rustdesk-util [command]\n"); "Usage:
println!("Available Commands:"); rustdesk-util [command]\n
println!(" genkeypair Generate a new keypair"); Available Commands:
println!(" validatekeypair [public key] [secret key] Validate an existing keypair"); genkeypair Generate a new keypair
validatekeypair [public key] [secret key] Validate an existing keypair"
);
process::exit(0x0001); process::exit(0x0001);
} }
@ -25,65 +28,44 @@ fn gen_keypair() {
println!("Secret Key: {secret_key}"); println!("Secret Key: {secret_key}");
} }
fn validate_keypair(pk: &str, sk: &str) { fn validate_keypair(pk: &str, sk: &str) -> ResultType<()> {
let sk1 = base64::decode(&sk); let sk1 = base64::decode(&sk);
match sk1 { if sk1.is_err() {
Ok(_) => {} bail!("Invalid secret key");
Err(_) => {
println!("Invalid secret key");
process::exit(0x0001);
}
} }
let sk1 = sk1.unwrap(); let sk1 = sk1.unwrap();
let secret_key = sign::SecretKey::from_slice(sk1.as_slice()); let secret_key = sign::SecretKey::from_slice(sk1.as_slice());
match secret_key { if secret_key.is_none() {
Some(_) => {} bail!("Invalid Secret key");
None => {
println!("Invalid Secret key");
process::exit(0x0001);
}
} }
let secret_key = secret_key.unwrap(); let secret_key = secret_key.unwrap();
let pk1 = base64::decode(&pk); let pk1 = base64::decode(&pk);
match pk1 { if pk1.is_err() {
Ok(_) => {} bail!("Invalid public key");
Err(_) => {
println!("Invalid public key");
process::exit(0x0001);
}
} }
let pk1 = pk1.unwrap(); let pk1 = pk1.unwrap();
let public_key = sign::PublicKey::from_slice(pk1.as_slice()); let public_key = sign::PublicKey::from_slice(pk1.as_slice());
match public_key { if public_key.is_none() {
Some(_) => {} bail!("Invalid Public key");
None => {
println!("Invalid Public key");
process::exit(0x0001);
}
} }
let public_key = public_key.unwrap(); let public_key = public_key.unwrap();
let random_data_to_test = b"This is meh."; let random_data_to_test = b"This is meh.";
let signed_data = sign::sign(random_data_to_test, &secret_key); let signed_data = sign::sign(random_data_to_test, &secret_key);
let verified_data = sign::verify(&signed_data, &public_key); let verified_data = sign::verify(&signed_data, &public_key);
match verified_data { if verified_data.is_err() {
Ok(_) => {} bail!("Key pair is INVALID");
Err(_) => {
println!("Key pair is INVALID");
process::exit(0x0001);
}
} }
let verified_data = verified_data.unwrap(); let verified_data = verified_data.unwrap();
if random_data_to_test == &verified_data[..] { if random_data_to_test != &verified_data[..] {
println!("Key pair is VALID"); bail!("Key pair is INVALID");
} else {
println!("Key pair is INVALID");
process::exit(0x0001);
} }
Ok(())
} }
fn main() { fn main() {
@ -99,7 +81,12 @@ fn main() {
if args.len() <= 3 { if args.len() <= 3 {
error_then_help("You must supply both the public and the secret key"); error_then_help("You must supply both the public and the secret key");
} }
validate_keypair(args[2].as_str(), args[3].as_str()); let res = validate_keypair(args[2].as_str(), args[3].as_str());
if let Err(e) = res {
println!("{}", e);
process::exit(0x0001);
}
println!("Key pair is VALID");
} }
_ => print_help(), _ => print_help(),
} }