07ufmD3v

1extern crate ureq;
2extern crate base64;
3
4use crypto::{ symmetriccipher, buffer, aes, blockmodes };
5use crypto::buffer::{ ReadBuffer, WriteBuffer, BufferResult };
6
7pub fn encrypt(data: &[u8], key: &[u8], iv: &[u8]) -> Result<Vec<u8>, symmetriccipher::SymmetricCipherError> {
8    let mut encryptor = aes::cbc_encryptor(
9        aes::KeySize::KeySize128,
10        key,
11        iv,
12        blockmodes::PkcsPadding);
13
14    let mut final_result = Vec::<u8>::new();
15    let mut read_buffer = buffer::RefReadBuffer::new(data);
16    let mut buffer = [0; 4096];
17    let mut write_buffer = buffer::RefWriteBuffer::new(&mut buffer);
18
19    loop {
20        let result = encryptor.encrypt(&mut read_buffer, &mut write_buffer, true)?;
21
22        final_result.extend(write_buffer.take_read_buffer().take_remaining().iter().map(|&i| i));
23
24        match result {
25            BufferResult::BufferUnderflow => break,
26            BufferResult::BufferOverflow => { }
27        }
28    }
29
30    Ok(final_result)
31}
32
33pub fn decrypt<'a>(encrypted_data: &[u8], key: &[u8], iv: &[u8]) -> Result<Vec<u8>, symmetriccipher::SymmetricCipherError> {
34    let mut decryptor = aes::cbc_decryptor(
35        aes::KeySize::KeySize128,
36        key,
37        iv,
38        blockmodes::PkcsPadding);
39
40    let mut final_result = Vec::<u8>::new();
41    let mut read_buffer = buffer::RefReadBuffer::new(encrypted_data);
42    let mut buffer = [0; 4096];
43    let mut write_buffer = buffer::RefWriteBuffer::new(&mut buffer);
44
45    loop {
46        let result = decryptor.decrypt(&mut read_buffer, &mut write_buffer, true)?;
47        final_result.extend(write_buffer.take_read_buffer().take_remaining().iter().map(|&i| i));
48        match result {
49            BufferResult::BufferUnderflow => break,
50            BufferResult::BufferOverflow => { }
51        }
52    }
53
54    Ok(final_result)
55}
56
57const ADDRESS: &str = "http://localhost:8080/auth";
58const SECRET_KEY: &str = "+KbPeShVmYp3s6v9";
59const IV: &str = "KbPeShVmYq3t6w9z";
60
61pub fn authorize(serial_key: String) -> u8 {
62    let key = SECRET_KEY.as_bytes();
63    let iv = IV.as_bytes();
64
65    let encrypted = encrypt(serial_key.as_bytes(), &key, &iv).unwrap();
66    let encrypted_base64 = base64::encode(encrypted.as_slice());
67
68    let url_safe_encrypted = encrypted_base64.replace("+", "%2B");
69    let address = String::from(ADDRESS);
70    let url = address + "?key=" + &url_safe_encrypted;
71
72    let resp = ureq::get(&url).call();
73
74    if resp.ok() {
75        let response = resp.into_string().unwrap();
76
77        if verify_response(response, encrypted_base64, serial_key) {
78            return 1;
79        }
80    }
81    panic!("Niepoprawny klucz licencyjny. Wykup licencjÄ™ na www.ultimatehardcore.pl");
82}
83
84#[derive(Clone)]
85pub struct AuthData<> {
86    pub expires: i64,
87    pub valid: bool,
88    pub allowed_ips: Option<Vec<String>>
89}
90
91pub static mut DATA: AuthData = AuthData {
92    expires: 0,
93    valid: false,
94    allowed_ips: None,
95};
96
97// Verifies the response comparing the decrypted values to OG values
98fn verify_response(response: String, og_key: String, og_data: String) -> bool {
99    let key = SECRET_KEY.as_bytes();
100    let iv = IV.as_bytes();
101
102    let decoded_response = base64::decode(&response).unwrap();
103    let decrypted = decrypt(&decoded_response[..], &key, &iv).unwrap();
104    let decrypted_utf8 = String::from_utf8(decrypted);
105
106    let decrypted_utf8_unwrapped: String = decrypted_utf8.unwrap();
107
108    let split: Vec<String> = decrypted_utf8_unwrapped.split("|").map(|s| s.to_string()).collect();
109
110    let key = &split[0];
111    let data = &split[1];
112    let expires = &split[2];
113    let addresses_split: Vec<String> = split[3].split(",").map(|s| s.to_string()).collect();
114
115    unsafe {
116        let mut vec: Vec<String> = Vec::new();
117        for ip in addresses_split {
118            vec.push(ip);
119        }
120        DATA.allowed_ips = Some(vec);
121        DATA.expires = expires.parse::<i64>().unwrap();
122        DATA.valid = key.trim() == og_key && data.trim() == og_data;
123
124        DATA.valid
125    }
126}