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

Clean up xpkey

Browse source
This commit is contained in:
Alex Page 2023-06-24 16:30:13 -04:00
parent 8510eb367d
commit 2bed0f88d1
2 changed files with 63 additions and 73 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
src/bin/xpkey/keys.rs
View file

@ -1,6 +1,35 @@
use std::collections::HashMap;
use std::{collections::HashMap, fs::File, io::BufReader, path::Path};
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> {
let keys = {
if let Some(path) = path {
if verbose {
println!("Loading keys file {}", path);
}
let file = File::open(&path)?;
let reader = BufReader::new(file);
let keys: Keys = from_reader(reader)?;
if verbose {
println!("Loaded keys from {} successfully", path);
}
keys
} else {
from_str(std::include_str!("../../../keys.json"))?
}
};
Ok(keys)
}
#[derive(Serialize, Deserialize)]
pub struct Keys {

99
src/bin/xpkey/main.rs
View file

@ -1,98 +1,56 @@
mod cli;
mod keys;
use std::{fs::File, io::BufReader, path::Path};
use anyhow::{anyhow, Result};
use anyhow::{bail, Result};
use clap::Parser;
use keys::{Bink, Keys};
use serde_json::{from_reader, from_str};
use keys::Bink;
use umskt::{
bink1998, bink2002, confid,
crypto::{EllipticCurve, PrivateKey},
};
use cli::*;
use crate::{cli::*, keys::load_keys};
fn main() -> Result<()> {
let args = Cli::parse();
let verbose = args.verbose;
match &args.command {
Commands::List(list_args) => {
let keys = load_keys(list_args.keys_path.as_ref(), args.verbose)?;
Commands::List(args) => list(args, verbose),
Commands::Generate(args) => generate(args, verbose),
Commands::Validate(args) => validate(args, verbose),
Commands::ConfirmationId(args) => confirmation_id(&args.instid),
}
}
fn list(args: &ListArgs, verbose: bool) -> Result<()> {
let keys = load_keys(args.keys_path.as_ref(), verbose)?;
for (key, value) in keys.products.iter() {
println!("{}: {:?}", key, value.bink);
}
println!("\n\n** Please note: any BINK ID other than 2E is considered experimental at this time **\n");
}
Commands::Generate(generate_args) => {
if generate_args.channel_id > 999 {
return Err(anyhow!("Channel ID must be 3 digits or fewer"));
}
let keys = load_keys(generate_args.keys_path.as_ref(), args.verbose)?;
generate(
&keys,
&generate_args.binkid,
generate_args.channel_id,
generate_args.num_keys,
args.verbose,
)?;
}
Commands::Validate(validate_args) => {
let keys = load_keys(validate_args.keys_path.as_ref(), args.verbose)?;
validate(
&keys,
&validate_args.binkid,
&validate_args.key_to_check,
args.verbose,
)?;
}
Commands::ConfirmationId(confirmation_id_args) => {
confirmation_id(&confirmation_id_args.instid)?;
}
}
Ok(())
}
fn load_keys<P: AsRef<Path> + std::fmt::Display>(path: Option<P>, verbose: bool) -> Result<Keys> {
let keys = {
if let Some(path) = path {
if verbose {
println!("Loading keys file {}", path);
fn generate(args: &GenerateArgs, verbose: bool) -> Result<()> {
if args.channel_id > 999 {
bail!("Channel ID must be 3 digits or fewer");
}
let file = File::open(&path)?;
let reader = BufReader::new(file);
let keys: Keys = from_reader(reader)?;
let keys = load_keys(args.keys_path.as_ref(), verbose)?;
if verbose {
println!("Loaded keys from {} successfully", path);
}
keys
} else {
from_str(std::include_str!("../../../keys.json"))?
}
};
Ok(keys)
}
fn generate(keys: &Keys, bink_id: &str, channel_id: u32, count: u64, verbose: bool) -> Result<()> {
let bink_id = bink_id.to_ascii_uppercase();
let bink_id = args.bink_id.to_ascii_uppercase();
let bink = &keys.bink[&bink_id];
// gen_order is the order of the generator G, a value we have to reverse -> Schoof's Algorithm.
let gen_order = &bink.n;
// We cannot produce a valid key without knowing the private key k. The reason for this is that
// we need the result of the function K(x; y) = kG(x; y).
let private_key = &bink.private;
// We can, however, validate any given key using the available public key: {p, a, b, G, K}.
// genOrder the order of the generator G, a value we have to reverse -> Schoof's Algorithm.
let gen_order = &bink.n;
let curve = initialize_curve(bink, &bink_id, verbose)?;
if verbose {
println!(" n: {gen_order}");
@ -102,23 +60,26 @@ fn generate(keys: &Keys, bink_id: &str, channel_id: u32, count: u64, verbose: bo
let private_key = PrivateKey::new(gen_order, private_key)?;
if u32::from_str_radix(&bink_id, 16)? < 0x40 {
bink1998_generate(&curve, &private_key, channel_id, count, verbose)?;
bink1998_generate(&curve, &private_key, args.channel_id, args.count, verbose)?;
} else {
bink2002_generate(&curve, &private_key, channel_id, count, verbose)?;
bink2002_generate(&curve, &private_key, args.channel_id, args.count, verbose)?;
}
Ok(())
}
fn validate(keys: &Keys, bink_id: &str, key: &str, verbose: bool) -> Result<()> {
let bink_id = bink_id.to_ascii_uppercase();
fn validate(args: &ValidateArgs, verbose: bool) -> 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 bink_id = args.bink_id.to_ascii_uppercase();
let bink = &keys.bink[&bink_id];
let curve = initialize_curve(bink, &bink_id, verbose)?;
if u32::from_str_radix(&bink_id, 16)? < 0x40 {
bink1998_validate(&curve, key, verbose)?;
bink1998_validate(&curve, &args.key_to_check, verbose)?;
} else {
bink2002_validate(&curve, key, verbose)?;
bink2002_validate(&curve, &args.key_to_check, verbose)?;
}
Ok(())