ccd 0.1.4

A windows simple, fast chrome_cookie_decryptor 
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

use crate::async_writeln;
#[cfg(windows)]
use crate::encrypted_key::key::get_encryption_key;

use std::{io::ErrorKind, sync::Arc};
use tokio::io::Error;
use tokio::{fs::File, sync::Mutex};

#[cfg(windows)]
use super::cookie_decryption::decrypt_cookie;
use super::cookie_form::UserCookie;

#[cfg(windows)]
pub async fn handle_chrome_cookies(
    username: String,
    cookies: Vec<(String, String, String, i64, Vec<u8>)>,
    filepath: &str,
) -> Result<(), Error> {
    let filepath = if filepath.is_empty() { "." } else { filepath };
    let mut file = match File::create(format!("{}\\cookies.txt", filepath)).await {
        Ok(file) => file,
        Err(_e) => {
            return Err(tokio::io::Error::new(
                ErrorKind::Other,
                "Create folder failure",
            ));
        }
    };

    let cookie_iter = cookies;

    let key = tokio::task::spawn(async move {
        if let Ok(key) = get_encryption_key(username.clone()).await {
            key
        } else {
            vec![]
        }
    })
    .await
    .unwrap();

    if key.is_empty() {
        return Err(tokio::io::Error::new(
            ErrorKind::Other,
            "Key decryption error",
        ));
    }

    let shared_key = Arc::new(Mutex::new(key));

    for cookie in cookie_iter {
        let shared_key_clone = Arc::clone(&shared_key);
        let decrypt_val = tokio::task::spawn(async move {
            let decrypt_val =
                decrypt_cookie(shared_key_clone.lock().await.to_vec(), cookie.4).await;
            decrypt_val
        })
        .await
        .unwrap();

        let cookie_val = if decrypt_val.is_empty() {
            cookie.2
        } else {
            decrypt_val
        };

        let cookies = UserCookie {
            host_key: cookie.0,
            name: cookie.1,
            value: cookie_val,
            expires_utc: (cookie.3 / 1_000_000) - 11644473600,
        };

        async_writeln!(
            file,
            "{}\tTRUE\t/\tFALSE\t{}\t{}\t{}",
            cookies.host_key,
            cookies.expires_utc,
            cookies.name,
            cookies.value
        )
        .unwrap();
    }

    Ok(())
}