rsacracker 0.9.1

Powerful RSA cracker for CTFs. Supports RSA, X509, OPENSSH, PKCS#12, PKCS#7, and CSR in PEM and DER formats.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

use indicatif::ProgressBar;
use rug::Integer;

use crate::{Attack, AttackKind, AttackSpeed, Error, Parameters, Solution};

/// Cube root attack (m^e < n and small e)
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CubeRootAttack;

impl Attack for CubeRootAttack {
    fn name(&self) -> &'static str {
        "cube_root"
    }

    fn speed(&self) -> AttackSpeed {
        AttackSpeed::Fast
    }

    fn kind(&self) -> AttackKind {
        AttackKind::KnownExtraInformation
    }

    fn run(&self, params: &Parameters, _pb: Option<&ProgressBar>) -> Result<Solution, Error> {
        let e = match params.e.to_u32() {
            Some(e) => e,
            None => return Err(Error::NotFound),
        };
        let c = params.c.as_ref().ok_or(Error::MissingParameters)?;

        let (root, rem) = c.root_rem_ref(e).into();
        if rem == Integer::ZERO {
            return Ok(Solution::new_m(self.name(), root));
        }
        Err(Error::NotFound)
    }
}

#[cfg(test)]
mod tests {
    use rug::ops::Pow;

    use crate::{bytes_to_integer, Attack, Parameters};

    use super::*;

    #[test]
    fn attack() {
        let m = bytes_to_integer(b"RsaCracker!");
        let e = Integer::from(19);
        let c = m.clone().pow(e.to_u32().unwrap());

        let params = Parameters {
            e,
            c: Some(c),
            ..Default::default()
        };

        let solution = CubeRootAttack.run(&params, None).unwrap();
        assert_eq!(solution.m.unwrap(), m);
    }
}