ice 0.3.0

A simple CTF tool store
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use digest::Digest;
use md5::Md5;
use sha1::Sha1;
use sha2::{Sha256, Sha512};
use std::fs::File;
use std::io::Read;
use std::path::Path;

pub fn md5(input: &str) -> String {
    if Path::new(input).exists() {
        let mut file = File::open(input).unwrap();
        let mut hasher = Md5::new();
        let mut buffer = Vec::new();
        file.read_to_end(&mut buffer).unwrap();
        hasher.update(&buffer);
        format!("{:x}", hasher.finalize())
    } else {
        let mut hasher = Md5::new();
        hasher.update(input.as_bytes());
        format!("{:x}", hasher.finalize())
    }
}

pub fn sha1(input: &str) -> String {
    if Path::new(input).exists() {
        let mut file = File::open(input).unwrap();
        let mut hasher = Sha1::new();
        let mut buffer = Vec::new();
        file.read_to_end(&mut buffer).unwrap();
        hasher.update(&buffer);
        format!("{:x}", hasher.finalize())
    } else {
        let mut hasher = Sha1::new();
        hasher.update(input.as_bytes());
        format!("{:x}", hasher.finalize())
    }
}

pub fn sha256(input: &str) -> String {
    if Path::new(input).exists() {
        let mut file = File::open(input).unwrap();
        let mut hasher = Sha256::new();
        let mut buffer = Vec::new();
        file.read_to_end(&mut buffer).unwrap();
        hasher.update(&buffer);
        format!("{:x}", hasher.finalize())
    } else {
        let mut hasher = Sha256::new();
        hasher.update(input.as_bytes());
        format!("{:x}", hasher.finalize())
    }
}

pub fn sha512(input: &str) -> String {
    if Path::new(input).exists() {
        let mut file = File::open(input).unwrap();
        let mut hasher = Sha512::new();
        let mut buffer = Vec::new();
        file.read_to_end(&mut buffer).unwrap();
        hasher.update(&buffer);
        format!("{:x}", hasher.finalize())
    } else {
        let mut hasher = Sha512::new();
        hasher.update(input.as_bytes());
        format!("{:x}", hasher.finalize())
    }
}

// pub struct Cracker {
//     pub query: String,
//     pub result: String,
// }

// impl Cracker {
//     pub fn new(s: &str) -> Self {
//         Self {
//             query: s.to_string(),
//             result: String::new(),
//         }
//     }
//     pub async fn get(self: &Self) -> Result<Self> {
//         const URL: &str = "https://api.dehash.lt/api.php?search=";
//         let url = Url::parse(&*format!("{}{}", URL, self.query))?;
//         let res = reqwest::get(url).await?.text().await?;
//         let last = res.lines().last().unwrap();
//
//         Ok(Cracker {
//             query: self.query.clone(),
//             result: last.to_string(),
//         })
//     }
// }

// pub async fn start_cracker(s: &str) -> Result<String> {
//     let res = Cracker::new(s).get().await?;
//
//     let nice = if res.result.find(':') != None {
//         res.result.split(':').last().unwrap().to_string()
//     } else {
//         String::from("No Password Found!")
//     };
//
//     Ok(nice)
// }