what is version control?

Signed-off-by: spv <spv0x04@proton.me>

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rsa_implementation"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0.80"
+arboard = "3.3.1"
+clap = { version = "4.5.1", features = ["derive"] }
+colored = { version = "2.1.0", features = ["no-color"] }
+eframe = "0.26.2"
+fern = { version = "0.6.2", features = ["chrono", "colored"] }
+humantime = "2.1.0"
+log = "0.4.21"
+num-bigint-dig = { version = "0.8.4", features = ["rand", "prime"] }
+rand = "0.8.5"

message.enc

@@ -0,0 +1 @@
+200541381588390557501069626192487602246153967846934782878271832944400998537605615633898449879402523525329546819274398356372235706692153959789939660279818353296059731977274168062664057611510599197163582981216328122409043223933730603045394626199409228432575897347306880376570594081216909871044449211637911686590087054073136904598441266438584717502859846435544182134298308517440694013047589814974186194001120765768500745691272180301851520015360900802644198733707320574925539863324644951961336003220444125950942920078330598660637129190779825560681545499527437649671965188389803889710286827540218758855604454812811717815278861949462303268263414713228886250524145411327467058880440855099365125692094608627068422546298217516614295809390403507748331780644053503147173917861342141333091132187964280919943947950744957893803032216699601180435708106581639535126413300381030458971389657997415863487158899731268440024858686764500436838206981645009661076890169425513082333515225069131464153226661009851456068680420038190609983694845663637940588530977480744126753816492638640958631956256538926158792097670667549026082719914204337022608584546083373070673370457854420168213358705901125664452103270327154681703685571342471505339380927628592453665867711167822637385542809091884287372933106039679284155386541106973827568260189597232773624357201092770507771681419064397415445239472734247548791532329604770664791693582390785922538010927203207476267613847573723583644691030550700263015582037046979490531194690902424699518609041714791436209500388116145813145251571040369532471514318185597542853257834286062751058097409613518498722638862095371258965131879801394603686286993269973140177857719789743705584771753976125162651986550702961759711337799597267332106899135652517529059293487733920707558072131449432321557453942031605048804513992731720022948822511990985523872657461394586643592499717124874608868285212819556398033793248655367798174350392523382658573989934739572583218132542910072639859648502981633303730806327046330013885360251981597585939308484413828891552729876539777073295825677569452385462020401558632767330055783864319543041586643323102902512162657350850720693843898617067812423247182424494492723321324796698285099644649523141161706568800148088054865335776883291179430323522972768360931093416740961611352214727723225309283387182609545326034814694032402323353690640309231821379076370513626754055652266062367722317751620082871364689153477346643499171618821447762252845466342746701

private_key

@@ -0,0 +1 @@
+12326230423318164716577468604522171631270969132972038946527081564099372250397638425209106864702526320174509988214934875277501813209387819406794511344174110568035240635461974782031704087829238743107762852412020817025178432246151173948147870063568040854932536841959804069249178377890548516476689502265449461890913624600438618901184031122440688106605850222794075697028979639565756189585643867159194955811387328847068202268789695632960650103366957287814296999241411532758023285337379620377754545739206434573130971631244226714283112933402352439235731080008121925212675636780079494992443080791105217065724131287657334356915748415754289479511401904044509885052774401384983852297548129224017659304139427228286315591487193829255612637849119854890531009667089484077579362911548719871735934878539693704690842990763859730975946568388438599974276442849203931205410643813981563190111980368234738120896712385415997560941815313565857241691587774774073559808090895219474093231646491722818475765406892653423376301232532846893482643291439286335800075355311161190175783735535720217456591100598305006443584062920074011036771672866319854120169060016541804543881569699695944183438879023104819825007899644520603211124688531354380725523210687439754057766382053390541617559903369484876152419628439811690113508636568970812091802163740274262551493533074240624422322460828790823211087383462075423832239207994428037341594271371130022935019558231042716611816418349449063895582522482036463044060378196549253009598927023610924099858699031302676971338766309512564602472609690370410328622672170196135328399452480398921190997270140843224118706130980868601712201912014255458772337933876566537180316732513253143393323906773746262260981510867648098677715527224224926082917628214733354778945328315391150264095965434778182529787888740480506383859957674363696161520247716771706722858249857796805983576859435684049241092997384613638492227119989447945333157466375622217600447508250426221317499201724493487072269429187513026521261447887320321493629076107888529500872898332853959074405705197156397564747379955125785535953593117956851022393885749550732706782664206799668472186461889144641357017553752008024937621144417310440099042852599961230978118745777602897561159772810672197660072929553565244860847538579660344384914673600033760470594890447670942318683517500847286544699225983999126536863079890525405465199560912540868150031690099940059700743850154829618633266708484658590230514894930690893844792103575301099:5459899112563229513526935932931192080867654596652031846591635806641436969785109076074592656578957010510651159830215103008135659315047302486629116659634984928743589943682301031652976153228762230790302165376927156030859568811642316224211462759681591699128631159657162995688549873039012010449694656896516652817871730993110844957467316629874675977948629717580685497240735877516238779792352622281260032125773487104227517192756011817509350728801910177385709303957417836118847137008942365455059061286725806204151438031700814970419841542225443180099191074088234159588813706259165658850734790458091372129941502999364707193481726087088785200884231970636439443205456904865328435226029766695188858769093568079967262146422780710191362944588276586796471334766518398450520382358365097388818126571063753190494959391992400111652401020602143045435693646955453206355842188063823185611008223747732261748414116061894646756302109065414934293614226149216699066664333706640569749533865198401394583696442454179081455705056743046200822438024072139834314038135811132733769402570179147006777399738642122867082218920023193421724448517076078932178451062662652785144692600855450034659709605562552492852169308712763834662402633598024820131405059719052917397597822372366052412461673428774818917436454480629737928118047052909798010137196623661755780794166577486405759181763222216809323709408972981266870959947818692959129933345134413818391461167601133242668220343296858284550651514512663869799957343668705221798237013990540984918952232412909923072680824935269372368726656465063243602533262894609285983059583321153219231968035260872009173315838529922637535641717830252720842893884315151597034862344350462250264468275161169914041787613842980507795777082086816421913492980626889664786149663939523541032240657471243823121747499386660132255157189713408873153748356708241657119643954348600684448625182366309066209511708353841800674537075226312583816180309181327101802426521664799326995259395178274438572016582834975469179537926007911692493664276257486087497958044888510625370061588193790254885103611614866353802295373237163548450856796237673156591913626096605014481040082342060789332720471514082626936881830799906451687910068778244801651638428066078540253347509966062283441881492438363696347954738348691686946585535911836751826507443872620568868667306803732149536902531545625952392643638603392811102658069404733762869263140550927826694343097010859634385011133699817494033288533602881219999913396377857737

public_key

@@ -0,0 +1 @@
+12326230423318164716577468604522171631270969132972038946527081564099372250397638425209106864702526320174509988214934875277501813209387819406794511344174110568035240635461974782031704087829238743107762852412020817025178432246151173948147870063568040854932536841959804069249178377890548516476689502265449461890913624600438618901184031122440688106605850222794075697028979639565756189585643867159194955811387328847068202268789695632960650103366957287814296999241411532758023285337379620377754545739206434573130971631244226714283112933402352439235731080008121925212675636780079494992443080791105217065724131287657334356915748415754289479511401904044509885052774401384983852297548129224017659304139427228286315591487193829255612637849119854890531009667089484077579362911548719871735934878539693704690842990763859730975946568388438599974276442849203931205410643813981563190111980368234738120896712385415997560941815313565857241691587774774073559808090895219474093231646491722818475765406892653423376301232532846893482643291439286335800075355311161190175783735535720217456591100598305006443584062920074011036771672866319854120169060016541804543881569699695944183438879023104819825007899644520603211124688531354380725523210687439754057766382053390541617559903369484876152419628439811690113508636568970812091802163740274262551493533074240624422322460828790823211087383462075423832239207994428037341594271371130022935019558231042716611816418349449063895582522482036463044060378196549253009598927023610924099858699031302676971338766309512564602472609690370410328622672170196135328399452480398921190997270140843224118706130980868601712201912014255458772337933876566537180316732513253143393323906773746262260981510867648098677715527224224926082917628214733354778945328315391150264095965434778182529787888740480506383859957674363696161520247716771706722858249857796805983576859435684049241092997384613638492227119989447945333157466375622217600447508250426221317499201724493487072269429187513026521261447887320321493629076107888529500872898332853959074405705197156397564747379955125785535953593117956851022393885749550732706782664206799668472186461889144641357017553752008024937621144417310440099042852599961230978118745777602897561159772810672197660072929553565244860847538579660344384914673600033760470594890447670942318683517500847286544699225983999126536863079890525405465199560912540868150031690099940059700743850154829618633266708484658590230514894930690893844792103575301099:6011713441757205448408687346938476419995093228638159660188919795080775011142432423194741476908150713290603474786148982946439676479825017553586862914041939940333683983220839088974453104349975337867428992031232512797891290570544566625422752440512892303690870333574240939611113442458251283470016560306527405846284719602651216685874474874329595289690997975863985470648457311938836366349999167357479704547732061578605395642706608336684932192975887814509582171418963472871092952388153402014986462798745315835506267554314900416378737011745057788157370503066929354124570572809358418069532801125943818179198787849489603352580269798509357063450800469354290405166598524537778649860523489402171087800623920398782772214192340162843698245269186238181434393546744907553934674934363231813342657188242573924879370677091703285143641314720120308374012428632856483076461667286075633014477905427323810852864002647618665530438525946197432196774481805138310919792890027148360665160013324328549190550693400153005171950839575553950156551638087470683964144143246779347510261996467266836506722714822203909402349091084811277137305656913284025741170097387163036820771725201042258229365968442991725685059004171926375192648253951319796495928821987045058680832306224682385492464908193946098872119409476445010716435689990531469909451011636741457691800294472579006872446159116987318642911842911798996490773664647978814332846588129813562575420316759228291419425266974621667016429834450205903734783881313339633406633247719264470222960780366134252331554725289351803578121246983996626782295850757498743527577252367007501542351015847451901980115656348342808933637322883768074104493730186458452735923200143264174151620102164165097612920073804540509736201377459867127831377754109814944563840351144971126573989523250041682156525846559732902476499670716511164997916902061350409763158789382839820254648129123811448909138229186349479805965540254754079647840243546713164254633908621553221850575982327646235865448221765243891914994820267375228312518912426566147945672067348096420542951613718464182228265793694076254424678074606293287655147143376547407488588749203612741826219825180455975101943603429482871668515033052870018358528264114042582028449962037727470477305791564483967696128610003983717657147444228147707779091419465073507675998992521805212686812275456726560091695083999735033559931682533267119730553818954608646520845735332538282522807392092512323209529487208460732666129580738151419359352945814151745

src/gui.rs

@@ -0,0 +1,67 @@
+use std::{process::ExitCode, str::FromStr};
+
+use eframe::{self, egui::{self, Slider, TextEdit}};
+use num_bigint_dig::BigUint;
+mod rsa;
+
+fn main() {
+    let native_options = eframe::NativeOptions::default();
+    eframe::run_native("Yeah", native_options, Box::new(|cc| Box::new(MyEguiApp::new(cc))));
+}
+
+#[derive(Default)]
+struct MyEguiApp {
+    pub_key: String,
+    priv_key: String,
+    n: BigUint,
+    my_n: String,
+    decrypted: String,
+    encrypted: String,
+}
+
+impl MyEguiApp {
+    fn new(cc: &eframe::CreationContext<'_>) -> Self {
+        Self::default()
+    }
+}
+
+impl eframe::App for MyEguiApp {
+   fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        egui::containers::Window::new("Controls").show(&ctx, |ui| {
+            if ui.button("Generate Keypair").clicked(){
+                let (n, e, d) = rsa::generate_magics();
+                self.n = n.clone();
+                self.my_n = n.to_string().clone();
+                self.pub_key = e.to_string();
+                self.priv_key = d.to_string();
+            }
+
+            ui.text_edit_multiline(&mut self.my_n);
+                if ui.button("Set N").clicked(){
+                    self.n = BigUint::from_str(&self.my_n).unwrap();
+                }
+
+            if ui.button("Encrypt Message").clicked(){
+                self.encrypted = rsa::encrypt(self.decrypted.clone(), BigUint::from_str(&self.pub_key).unwrap().clone(), self.n.clone());
+            }
+
+            if ui.button("Decrypt Message").clicked(){
+                self.decrypted = rsa::decrypt(self.encrypted.clone(), &BigUint::from_str(&self.priv_key).unwrap(), &self.n);
+            }
+        });
+
+        egui::containers::Window::new("Messages").show(&ctx, |ui|{
+            ui.label("Encrypted");
+            ui.text_edit_singleline(&mut self.encrypted);
+            ui.label("Decrypted");
+            ui.text_edit_singleline(&mut self.decrypted)
+        });
+
+        egui::containers::Window::new("Keys").show(&ctx, |ui|{
+            ui.label("Public Key");
+            ui.text_edit_multiline(&mut self.pub_key);
+            ui.label("Private key");
+            ui.text_edit_multiline(&mut self.priv_key);
+        });
+   }
+}

src/main.rs

@@ -0,0 +1,158 @@
+use std::{fs, path::PathBuf, process::exit, str::FromStr};
+mod rsa;
+use log::{*};
+use fern::colors::Color;
+use fern::colors::ColoredLevelConfig;
+use log;
+use clap::{self, Parser, Subcommand, ValueEnum};
+use log::info;
+use num_bigint_dig::BigUint;
+
+#[derive(Parser)]
+#[command(about = r#"
+ ____  ____    _    
+|  _ \/ ___|  / \   
+| |_) \___ \ / _ \  
+|  _ < ___) / ___ \ 
+|_| \_\____/_/   \_\
+
+A nice RSA implementation thats definetly not vulnerable to a lot of crypto magic"#)]
+pub struct Args{
+    #[command(subcommand)]
+    mode: Mode,
+    #[arg(short, long, help = "How many log messages do you want to see?")]
+    log_level: Option<log::LevelFilter>,
+}
+
+#[derive(Clone, Subcommand)]
+pub enum Mode{
+    #[command(about = "generate a new keypair")]
+    Generate{
+        #[arg(short, long, value_name = "Key Size", help = "The size of the RSA key in bits. Must be a power of 2")]
+        bitsize: Option<usize>,
+    },
+    #[command(about = "Encrypt a string using a public key")]
+    Encrypt{
+        #[arg(value_name = "Public Key", help = "The path to the public key file")]
+        pub_key: PathBuf,
+        #[arg(value_name = "Message")]
+        message: String,
+    },
+    #[command(about = "Decrypt a string using a private key")]
+    Decrypt{
+        #[arg[value_name = "Private Key", help = "The path to the private key file"]]
+        priv_key: PathBuf,
+        #[arg(value_name = "Message File", help = "The path to the message file")]
+        message: PathBuf,
+    },
+}
+
+/// Key file format
+/// <value of n>:<rest of key (public or private)>
+fn parse_key_from_string(key: String) -> (BigUint, BigUint){
+    info!("Splitting input message into blocks");
+    let parts = key.split(":").map(|s| s.to_string()).collect::<Vec<String>>();
+    info!("{} Blocks", parts.len());
+
+    if parts.len() != 2{
+        error!("Failed to parse key file. More than 2 segments provided");
+        exit(-1);
+    };
+
+    let n = BigUint::from_str(&parts[0]);
+    let k = BigUint::from_str(&parts[1]);
+
+    if k.is_err() || n.is_err(){
+        error!("Failed to parse keys. Format doesnt appear to be in integer format");
+        exit(-1);
+    };
+
+    info!("Keyfile parsed successfully");
+
+    (n.unwrap(), k.unwrap())
+}
+
+fn main() {
+    let args = Args::parse();
+    match setup_logger(&args){
+        Ok(_) => (),
+        Err(e) => println!("Faiiled to setup logger {e}. Proceeding without"),
+    };
+
+    match args.mode{
+        Mode::Generate {bitsize} => generate_cli(bitsize),
+        Mode::Decrypt { priv_key, message } => decrypt_cli(priv_key, message),
+        Mode::Encrypt { pub_key, message } => encrypt_cli(pub_key, message),
+    }
+}
+
+fn generate_cli(bitsize: Option<usize>){
+    info!("Generating keypair");
+    let (n, e, d) = rsa::generate_magics(bitsize);
+
+    let public_keypair = format!("{n}:{e}");
+    let private_keypair = format!("{n}:{d}");
+    let pub_res = fs::write("public_key", public_keypair);
+    let priv_res = fs::write("private_key", private_keypair);
+
+    if pub_res.is_err() || priv_res.is_err(){
+        error!("Failed to write keys to file");
+        exit(-1);
+    }
+    info!("Saved private key to \"private_key\"");
+    info!("Saved public key to \"public_key\"");
+}
+
+fn encrypt_cli(pub_key_file: PathBuf, message: String){
+    let key_file = match fs::read_to_string(pub_key_file){
+        Ok(s) => s,
+        Err(e) => {error!("Error: {e}"); exit(-1);}
+    };
+
+    let (n, e) = parse_key_from_string(key_file);
+
+    if fs::write("message.enc", rsa::encrypt(message, &e, &n)).is_err(){
+        error!("Failed to write message to file");
+        exit(-1);
+    };
+}
+
+fn decrypt_cli(priv_key_file: PathBuf, message: PathBuf){
+    let key_file = match fs::read_to_string(priv_key_file){
+        Ok(s) => s,
+        Err(e) => {error!("Error: {e}"); exit(-1);}
+    };
+    let message_content = match fs::read_to_string(message){
+        Ok(s) => s,
+        Err(e) => {error!("Error: {e}"); exit(-1);}
+    };
+
+    let (n, d) = parse_key_from_string(key_file);
+    println!("{}", rsa::decrypt(message_content, &d, &n));
+}
+
+fn setup_logger(args: &Args) -> anyhow::Result<()>{
+    let colors = ColoredLevelConfig::new()
+    .trace(Color::Blue).info(Color::Green).warn(Color::Magenta).error(Color::Red);
+    fern::Dispatch::new()
+    // Perform allocation-free log formatting
+    .format(move |out, message, record| {
+        out.finish(format_args!(
+            "[{} {} {}] {}",
+            humantime::format_rfc3339(std::time::SystemTime::now()),
+            colors.color(record.level()),
+            record.target(),
+            message
+        ))
+    })
+    // Add blanket level filter -
+    .level(args.log_level.unwrap_or(log::LevelFilter::Warn))
+    // - and per-module overrides
+    .level_for("hyper", log::LevelFilter::Info)
+    // Output to stdout, files, and other Dispatch configurations
+    .chain(std::io::stdout())
+    // Apply globally
+    .apply()?;
+
+    Ok(())
+}

src/rsa.rs

@@ -0,0 +1,147 @@
+use std::{borrow::Cow, char::DecodeUtf16, fs::read_link, str::FromStr};
+use num_bigint_dig::{self, BigUint, IntoBigUint, UniformBigUint};
+use rand::{self, distributions::uniform::UniformSampler, thread_rng};
+use log::*;
+
+fn gcd(mut b1: BigUint, mut b2: BigUint) -> BigUint {
+    let mut tmp: BigUint;
+    loop {
+        // see if 5 is cleanly divisible by 24 (no)
+        // tmp = 5
+        tmp = b1 % b2.clone();
+        if tmp == 0_u8.into() {
+            break;
+        }
+        // b1 = 4
+        b1 = b2;
+        // b2 = 1
+        b2 = tmp;
+    }
+    return b2;
+}
+
+fn generate_bitarray(length: usize) -> Vec<u8>{
+    let mut out = vec![];
+    for _ in 0..length{
+        out.push(rand::random::<u8>())
+    }
+    out
+}
+
+/// Returns (n, e, d)
+pub fn generate_magics(bitsize: Option<usize>) -> (BigUint, BigUint, BigUint){
+    let bitsize = bitsize.unwrap_or(2048);
+    assert!(bitsize.is_power_of_two(), "Bizsize is not a power of 2 (this is your fault)");
+    let p;
+    let q;
+
+    log::warn!("These implementations of random number generation are NOT cryptographically safe.");
+    let bitarray = generate_bitarray(bitsize/8);
+    let start = BigUint::from_bytes_le(&bitarray);
+    p = num_bigint_dig::prime::next_prime(&start);
+    let bitarray = generate_bitarray(bitsize/8);
+    let start = BigUint::from_bytes_le(&bitarray);
+    q = num_bigint_dig::prime::next_prime(&start);
+
+    let n = p.clone()*q.clone();
+    let f = (p.clone()-1_u8)*(q.clone()-1_u8);
+    
+    let e = {
+        let haha = UniformBigUint::new::<BigUint, BigUint>(2_u8.into(), f.clone());
+        let mut rng = thread_rng();
+        let mut sample = haha.sample(&mut rng);
+        while sample < f && gcd(f.clone(), sample.clone()) != 1_u8.into(){
+            sample = haha.sample(&mut rng);
+        }
+
+        sample
+    };
+
+    //let lcm = f.clone()/gcd(p.clone()-1_u8, q.clone()-1_u8);
+    let d = num_bigint_dig::algorithms::mod_inverse(Cow::Owned(e.clone()), Cow::Owned(f.clone())).unwrap().into_biguint().unwrap();
+    info!("Generated keypair of {} bits", bitsize);
+    (n, e, d)
+}
+
+pub fn encrypt(message: String, e: &BigUint, n: &BigUint) -> String{
+    let mut blocks = vec![];
+    let message = message.as_bytes();
+    let max_len = n.to_bytes_le().len()-1;
+    for i in 0..(&message.len()/max_len){
+        blocks.push(&message[i*max_len..(i+1)*max_len]);
+    }
+    if message.len() % max_len != 0 {
+        blocks.push(&message[((message.len() / max_len) * max_len)..])
+    }
+
+    let mut out = String::new();
+    for block in blocks{
+        let bytes = block;
+        let mut tmp_out = BigUint::from_bytes_le(bytes);
+        tmp_out = tmp_out.modpow(&e, &n);
+        out += &format!("{}-", tmp_out);
+    }
+
+    
+    out[..out.len()-1].to_string()
+}
+
+pub fn decrypt(message: String, d: &BigUint, n: &BigUint) -> String{
+    let blocks = message.split("-").into_iter();
+    let mut bytes = vec![];
+    for block in blocks{
+        let numba = BigUint::from_str(block).unwrap();
+        bytes.extend_from_slice(&numba.modpow(&d, &n).to_bytes_le());
+    }
+    String::from_utf8_lossy(&bytes).into_owned()
+}
+
+pub fn stupid_decrypt(mut input: String, d: BigUint, n: BigUint) -> String{
+    let mut out = vec![];
+    for i in input.split("-"){
+        if i.len() == 0{
+            continue;
+        }
+        let encrypted_bruh = BigUint::from_str(i).unwrap();
+        let decrypted = encrypted_bruh.modpow(&d, &n);
+
+        let decrypted = decrypted.to_string();
+        let mut blocks = vec![];
+        for i in 0..(&decrypted.len()/3){
+            blocks.push(u8::from_str(&decrypted[i*3..(i+1)*3]).unwrap());
+        }
+        out.push(String::from_utf8_lossy(&blocks[..]).into_owned());
+    }
+
+    out.join("")
+}
+
+pub fn stupid_encrypt(mut message: String, e: BigUint, n: BigUint) -> String{
+    let mut message = message.to_lowercase();
+    message += &" ".repeat(4 - (message.len() % 4));
+
+    let mut blocks = vec![];
+    for i in 0..(&message.len()/4){
+        blocks.push(&message[i*4..(i+1)*4]);
+    }
+
+    let mut hahas = vec![];
+
+    for block in blocks{
+        let mut haha = String::new();
+        for b in block.bytes(){
+            haha += &format!("{:0>3}", u8::from(b));
+        }
+        hahas.push(haha);
+    }
+
+    let mut out = String::new();
+    for haha in hahas{
+        let message = BigUint::from_str(&haha).unwrap();
+        let encrypted = message.modpow(&e, &n);
+        out += "-";
+        out += &encrypted.to_string();
+    }
+
+    out
+}