valter/umskt-rs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Use log crate to filter verbose messages

Browse source
This commit is contained in:
Alex Page 2023-06-24 17:42:09 -04:00
parent 860c0ebcac
commit c3102882a9
5 changed files with 122 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

3
xpkey/Cargo.toml
View file

@ -15,3 +15,6 @@ anyhow = "1.0.71"
clap = { version = "4.3.4", features = ["derive"] }
serde = { version = "1.0.164", features = ["derive"] }
serde_json = "1.0"
log = "0.4.19"
simple_logger = { version = "4.2.0", default-features = false }

9
xpkey/src/keys.rs
View file

@ -4,19 +4,14 @@ use anyhow::Result;
use serde::{Deserialize, Serialize};
use serde_json::{from_reader, from_str};
pub fn load_keys<P: AsRef<Path> + std::fmt::Display>(
path: Option<P>,
verbose: bool,
) -> Result<Keys> {
pub fn load_keys<P: AsRef<Path> + std::fmt::Display>(path: Option<P>) -> Result<Keys> {
let keys = {
if let Some(path) = path {
let file = File::open(&path)?;
let reader = BufReader::new(file);
let keys: Keys = from_reader(reader)?;
if verbose {
println!("Loaded keys from {}", path);
}
log::info!("Loaded keys from {}", path);
keys
} else {

68
xpkey/src/main.rs
View file

@ -13,18 +13,23 @@ use crate::{cli::*, keys::load_keys};
fn main() -> Result<()> {
let args = Cli::parse();
let verbose = args.verbose;
if args.verbose {
simple_logger::init_with_level(log::Level::Info)?;
} else {
simple_logger::init_with_level(log::Level::Warn)?;
}
match &args.command {
Commands::List(args) => list(args, verbose),
Commands::Generate(args) => generate(args, verbose),
Commands::Validate(args) => validate(args, verbose),
Commands::List(args) => list(args),
Commands::Generate(args) => generate(args),
Commands::Validate(args) => validate(args),
Commands::ConfirmationId(args) => confirmation_id(&args.instid),
}
}
fn list(args: &ListArgs, verbose: bool) -> Result<()> {
let keys = load_keys(args.keys_path.as_ref(), verbose)?;
fn list(args: &ListArgs) -> Result<()> {
let keys = load_keys(args.keys_path.as_ref())?;
for (key, value) in keys.products.iter() {
println!("{}: {:?}", key, value.bink);
}
@ -33,12 +38,12 @@ fn list(args: &ListArgs, verbose: bool) -> Result<()> {
Ok(())
}
fn generate(args: &GenerateArgs, verbose: bool) -> Result<()> {
fn generate(args: &GenerateArgs) -> Result<()> {
if args.channel_id > 999 {
bail!("Channel ID must be 3 digits or fewer");
}
let keys = load_keys(args.keys_path.as_ref(), verbose)?;
let keys = load_keys(args.keys_path.as_ref())?;
let bink_id = args.bink_id.to_ascii_uppercase();
let bink = &keys.bink[&bink_id];
@ -50,36 +55,36 @@ fn generate(args: &GenerateArgs, verbose: bool) -> Result<()> {
// we need the result of the function K(x; y) = kG(x; y).
let private_key = &bink.private;
let curve = initialize_curve(bink, &bink_id, verbose)?;
let curve = initialize_curve(bink, &bink_id)?;
let private_key = PrivateKey::new(gen_order, private_key)?;
if u32::from_str_radix(&bink_id, 16)? < 0x40 {
bink1998_generate(&curve, &private_key, args.channel_id, args.count, verbose)?;
bink1998_generate(&curve, &private_key, args.channel_id, args.count)?;
} else {
bink2002_generate(&curve, &private_key, args.channel_id, args.count, verbose)?;
bink2002_generate(&curve, &private_key, args.channel_id, args.count)?;
}
Ok(())
}
fn validate(args: &ValidateArgs, verbose: bool) -> Result<()> {
fn validate(args: &ValidateArgs) -> Result<()> {
// We can validate any given key using the available public key: {p, a, b, G, K}.
// No private key or gen_order is required.
let keys = load_keys(args.keys_path.as_ref(), verbose)?;
let keys = load_keys(args.keys_path.as_ref())?;
let bink_id = args.bink_id.to_ascii_uppercase();
let bink = &keys.bink[&bink_id];
let curve = initialize_curve(bink, &bink_id, verbose)?;
let curve = initialize_curve(bink, &bink_id)?;
if u32::from_str_radix(&bink_id, 16)? < 0x40 {
bink1998_validate(&curve, &args.key_to_check, verbose)?;
bink1998_validate(&curve, &args.key_to_check)?;
} else {
bink2002_validate(&curve, &args.key_to_check, verbose)?;
bink2002_validate(&curve, &args.key_to_check)?;
}
Ok(())
}
fn initialize_curve(bink: &Bink, bink_id: &str, verbose: bool) -> Result<EllipticCurve> {
fn initialize_curve(bink: &Bink, bink_id: &str) -> Result<EllipticCurve> {
let p = &bink.p;
let a = &bink.a;
let b = &bink.b;
@ -88,12 +93,7 @@ fn initialize_curve(bink: &Bink, bink_id: &str, verbose: bool) -> Result<Ellipti
let kx = &bink.public.x;
let ky = &bink.public.y;
if verbose {
println!("-----------------------------------------------------------");
println!("Elliptic curve parameters for BINK ID {bink_id}:");
println!("-----------------------------------------------------------");
println!("{bink}");
}
log::info!("Elliptic curve parameters for BINK ID {bink_id}:\n{bink}");
EllipticCurve::new(p, a, b, gx, gy, kx, ky)
}
@ -103,13 +103,10 @@ fn bink1998_generate(
private_key: &PrivateKey,
channel_id: u32,
count: u64,
verbose: bool,
) -> Result<()> {
for _ in 0..count {
let product_key = bink1998::ProductKey::new(curve, private_key, channel_id, None, None)?;
if verbose {
println!("{:?}", product_key);
}
log::info!("{:?}", product_key);
println!("{product_key}");
}
Ok(())
@ -120,33 +117,26 @@ fn bink2002_generate(
private_key: &PrivateKey,
channel_id: u32,
count: u64,
verbose: bool,
) -> Result<()> {
for _ in 0..count {
let product_key = bink2002::ProductKey::new(curve, private_key, channel_id, None, None)?;
if verbose {
println!("{:?}", product_key);
}
log::info!("{:?}", product_key);
println!("{product_key}");
}
Ok(())
}
fn bink1998_validate(curve: &EllipticCurve, key: &str, verbose: bool) -> Result<()> {
fn bink1998_validate(curve: &EllipticCurve, key: &str) -> Result<()> {
let product_key = bink1998::ProductKey::from_key(curve, key)?;
if verbose {
println!("{:?}", product_key);
}
log::info!("{:?}", product_key);
println!("{product_key}");
println!("Key validated successfully!");
Ok(())
}
fn bink2002_validate(curve: &EllipticCurve, key: &str, verbose: bool) -> Result<()> {
fn bink2002_validate(curve: &EllipticCurve, key: &str) -> Result<()> {
let product_key = bink2002::ProductKey::from_key(curve, key)?;
if verbose {
println!("{:?}", product_key);
}
log::info!("{:?}", product_key);
println!("{product_key}");
println!("Key validated successfully!");
Ok(())