actually made code functional

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

Cargo.toml

@@ -7,7 +7,19 @@ edition = "2021"
 
 [dependencies]
 anyhow = "1.0.75"
+chrono = { version = "0.4.31", features = ["serde"] }
+clap = "4.5.11"
+console = "0.15.7"
+crossterm = "0.27.0"
 getset = "0.1.2"
-headless_chrome = {git = "https://github.com/atroche/rust-headless-chrome", features = ["fetch"]}
+json = "0.12.4"
+log = "0.4.20"
+rand = "0.8.5"
+random-string = "1.0.1"
+ratatui = "0.24.0"
+reqwest = { version = "0.11.22", features = ["blocking"] }
+serde = { version = "1.0.193", features = ["derive"] }
+serde_derive = "1.0.193"
+serde_json = "1.0.108"
 strum = { version = "0.25.0", features = ["strum_macros", "derive"] }
 strum_macros = "0.25.3"

README.md

@@ -0,0 +1 @@
+Just a quick rust project to bruteforce discord invite codes. Nothing fancy, probably against TOS and really not useful cuz of rate limiting.

src/brute_forcer.rs

@@ -0,0 +1,64 @@
+use std::{time::{Duration, Instant}, sync::{Arc, RwLock}};
+
+use crate::discord_invite::{DiscordInvite, DiscordInviteError};
+use console::Term;
+use getset::{Getters, MutGetters, Setters};
+use rand::seq::IteratorRandom;
+use reqwest::blocking::get;
+
+#[derive(Clone, Debug, Getters, Setters)]
+pub struct Bruter {
+    #[getset(get = "pub")]
+    found_codes: Vec<DiscordInvite>,
+    #[getset(get = "pub", set = "pub")]
+    codes: Vec<String>,
+    iterations: usize,
+}
+
+impl Bruter {
+    pub fn new(iterations: usize) -> Self {
+        Self {
+            found_codes: vec![],
+            codes: vec![],
+            iterations,
+        }
+    }
+
+    pub fn start(mut self) -> anyhow::Result<()> {
+        let mut rng = rand::thread_rng();
+        for i in 0..self.iterations {
+            let string: String = random_string::generate(
+                (5..12).choose(&mut rng).unwrap(),
+                random_string::charsets::ALPHANUMERIC,
+            );
+            self.codes.push(string);
+        }
+
+        for code in self.codes.clone() {
+            let start = Instant::now();
+            let res = DiscordInvite::resolve(code.clone());
+            match res {
+                Err(e) => {
+                    println!("{e} | took {}ms", start.elapsed().as_millis());
+                    match e {
+                        DiscordInviteError::RateLimit(t) => {
+                            std::thread::sleep(t + Duration::from_secs(1))
+                        }
+                        _ => (),
+                    }
+                }
+                Ok(inv) => {
+                    println!(
+                        "Valid invite found for {}: https://discord.gg/{} | took {}ms",
+                        &inv.guild.clone().unwrap().name.unwrap(),
+                        &inv.code,
+                        start.elapsed().as_millis()
+                    );
+                    self.found_codes.push(inv);
+                }
+            }
+        }
+
+        Ok(())
+    }
+}

src/discord_invite.rs

@@ -0,0 +1,137 @@
+use json::JsonValue;
+use serde_derive::Deserialize;
+use serde_derive::Serialize;
+use serde_json::Value;
+use strum_macros::Display;
+use std::{time::{Duration, Instant}, path::Display, sync::Arc};
+use getset::{Getters, Setters};
+use reqwest::{blocking::get, StatusCode};
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DiscordInvite {
+    #[serde(rename = "type")]
+    pub type_field: i64,
+    pub code: String,
+    pub inviter: Option<Inviter>,
+    #[serde(rename = "expires_at")]
+    pub expires_at: Option<chrono::NaiveDateTime>,
+    pub flags: Option<i64>,
+    pub guild: Option<Guild>,
+    #[serde(rename = "guild_id")]
+    pub guild_id: String,
+    pub channel: Option<Channel>,
+    #[serde(rename = "approximate_member_count")]
+    pub approximate_member_count: i64,
+    #[serde(rename = "approximate_presence_count")]
+    pub approximate_presence_count: i64,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Inviter {
+    pub id: Option<String>,
+    pub username: Option<String>,
+    pub avatar: Option<String>,
+    pub discriminator: Option<String>,
+    #[serde(rename = "public_flags")]
+    pub public_flags: Option<i64>,
+    #[serde(rename = "premium_type")]
+    pub premium_type: Option<i64>,
+    pub flags: Option<i64>,
+    pub banner: Option<String>,
+    #[serde(rename = "accent_color")]
+    pub accent_color: Option<i64>,
+    #[serde(rename = "global_name")]
+    pub global_name: Option<String>,
+    #[serde(rename = "avatar_decoration_data")]
+    pub avatar_decoration_data: Option<Value>,
+    #[serde(rename = "banner_color")]
+    pub banner_color: Option<String>,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Guild {
+    pub id: Option<String>,
+    pub name: Option<String>,
+    pub splash: Option<String>,
+    pub banner: Option<String>,
+    pub description: Option<Value>,
+    pub icon: Option<String>,
+    pub features: Option<Vec<String>>,
+    #[serde(rename = "verification_level")]
+    pub verification_level: Option<i64>,
+    #[serde(rename = "vanity_url_code")]
+    pub vanity_url_code: Option<String>,
+    #[serde(rename = "nsfw_level")]
+    pub nsfw_level: Option<i64>,
+    pub nsfw: Option<bool>,
+    #[serde(rename = "premium_subscription_count")]
+    pub premium_subscription_count: Option<i64>,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Channel {
+    pub id: Option<String>,
+    #[serde(rename = "type")]
+    pub type_field: Option<i64>,
+    pub name: Option<String>,
+}
+
+impl DiscordInvite {
+    pub fn resolve(code: String) -> Result<Self, DiscordInviteError>{
+        let response = match get(format!("https://discord.com/api/v9/invites/{}?with_counts=true&with_expiration=true", code)){
+            Ok(r) => r,
+            Err(e) => return Err(DiscordInviteError::Unknown(format!("Unknown Error!: {}", e))),
+        };
+        let result = match response.text(){
+            Ok(r) => r,
+            Err(e) => return Err(DiscordInviteError::Unknown(format!("Unknown Error!: {}", e))),
+        };
+        if result.contains("Unknown Invite"){
+            return Err(DiscordInviteError::InvalidInvite);
+        }
+        if result.contains("You are being rate limited."){
+            let time: Value = match serde_json::from_str(&result){
+                Ok(v) => v,
+                Err(_) => return Err(DiscordInviteError::RateLimit(Duration::ZERO)),
+            };
+            let time = match time.get("retry_after"){
+                Some(v) => v,
+                None => return Err(DiscordInviteError::RateLimit(Duration::ZERO)),
+            }.as_f64().unwrap_or(0.0);
+            return Err(DiscordInviteError::RateLimit(Duration::from_secs_f64(time)));
+        }
+        if result.contains("Error 1015"){
+            return Err(DiscordInviteError::RateLimit(Duration::ZERO));
+        }
+        let parsed_result = match serde_json::from_str::<DiscordInvite>(&result){
+            Ok(r) => r,
+            Err(e) => {
+                return Err(DiscordInviteError::Unknown(e.to_string()));
+            }
+        };
+        Ok(parsed_result)
+    }
+}
+
+#[derive(Debug)]
+pub enum DiscordInviteError {
+    InvalidInvite,
+    RateLimit(Duration),
+    Timeout,
+    Unknown(String),
+}
+
+impl std::fmt::Display for DiscordInviteError{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", match self {
+            Self::Unknown(s) => format!("Unknown Error!: {}", s),
+            Self::InvalidInvite => "Invalid Invite".to_string(),
+            Self::RateLimit(t) => format!("Youve been rate limited for {}s", t.as_secs_f64()),
+            _ => "Not yet implemented".to_string()
+        })
+    }
+}

src/invite.rs

@@ -1,54 +0,0 @@
-use getset::{Getters, Setters};
-use headless_chrome::Browser;
-use strum::Display;
-
-#[derive(Getters, Setters, Debug)]
-#[getset(get = "pub")]
-pub struct DiscordInvite {
-    code: String,
-}
-
-impl DiscordInvite {
-    pub fn new(code: String) -> Self {
-        Self { code }
-    }
-
-    pub fn resolve(&self, browser: &Browser) -> Result<(), DiscordInviteError> {
-        let mut tab = browser
-            .new_tab()
-            .map_err(|e| DiscordInviteError::Unknown(format!("Failed to create new tab: {}", e)))?;
-        tab.navigate_to(&format!("https://discord.com/invite/{}", self.code))
-            .map_err(|e| {
-                DiscordInviteError::Unknown(format!("Failed to navigate to url: {}", e))
-            })?;
-        //std::thread::sleep(std::time::Duration::from_secs(4));
-        tab.wait_until_navigated().map_err(|e| {
-            DiscordInviteError::Unknown(format!("Failed to wait until navigated: {}", e))
-        })?;
-        let content = tab.get_content().unwrap();
-        return match content.contains("Invite Invalid") {
-            true => Err(DiscordInviteError::InvalidInvite),
-            false => Ok(()),
-        };
-    }
-}
-
-impl From<String> for DiscordInvite {
-    fn from(code: String) -> Self {
-        Self::new(code)
-    }
-}
-
-impl From<&str> for DiscordInvite {
-    fn from(code: &str) -> Self {
-        Self::new(code.to_string())
-    }
-}
-
-#[derive(Debug, Display)]
-pub enum DiscordInviteError {
-    InvalidInvite,
-    RateLimit,
-    Timeout,
-    Unknown(String),
-}

src/main.rs

@@ -1,19 +1,16 @@
-use headless_chrome::protocol::cdp::Page;
+use std::{sync::{Arc, RwLock}, ops::Deref, time::Duration};
-use headless_chrome::Browser;
-use invite::DiscordInvite;
-use std::time::Duration;
 
-pub mod invite;
+use brute_forcer::Bruter;
 
-fn main() -> anyhow::Result<()> {
+use crate::discord_invite::DiscordInviteError;
-    let mut browser = Browser::default()?;
+pub mod discord_invite;
-
+pub mod brute_forcer;
-    let mut invite = DiscordInvite::from("incestcentral");
+pub mod tui;
-    let result = invite.resolve(&mut browser);
-    match result {
-        Ok(_) => println!("Invite is valid!"),
-        Err(e) => println!("Invite is invalid: {:?}", e),
-    }
 
+fn main() -> anyhow::Result<()>{
+    let mut bruter = Bruter::new(10);
+    let b_ref = bruter.clone();
+    bruter.set_codes(vec!["incestcentral".to_string(), "penis".to_string(), "peter".to_string()]);
+    Bruter::start(bruter).unwrap();
     Ok(())
-}
+}

src/tui.rs

@@ -0,0 +1,7 @@
+pub struct Tui{
+
+}
+
+impl Tui{
+    
+}