Update app.py

app.py

@@ -1,66 +1,112 @@
-import streamlit as st
-from components.passbeaker import PasswordCracker
-
-def crack_password(password_hash, wordlist_file, algorithm, salt, parallel, complexity, min_length, max_length, character_set, brute_force):
-    Cracker = PasswordCracker(
-        password_hash=password_hash,
-        wordlist_file=wordlist_file,
-        algorithm=algorithm,
-        salt=salt,
-        parallel=parallel,
-        complexity_check=complexity
-    )
-    if brute_force:
-        Cracker.crack_passwords_with_brute_force(min_length, max_length, character_set)
-    else:
-        Cracker.crack_passwords_with_wordlist()
-    
-    # Получаем статистику
-    stats = Cracker.get_statistics()
-    
-    # Преобразуем статистику в строку для отображения в Streamlit
-    stats_str = f"Total Attempts: {stats.get('total_attempts', 'N/A')}\n"
-    stats_str += f"Cracked Password: {stats.get('cracked_password', 'N/A')}\n"
-    stats_str += f"Time Taken: {stats.get('time_taken', 'N/A')}\n"
-    
-    return stats_str
+import hashlib
+import argparse
+import itertools
+from multiprocessing import Pool
 
-def main():
-    st.title("GVA Password Cracker")
-
-    st.sidebar.header("Settings")
-    password_hash = st.sidebar.text_input("Password Hash")
-    wordlist_file = st.sidebar.file_uploader("Upload Wordlist File", type=['txt'])
-    algorithm = st.sidebar.selectbox("Hash Algorithm", ["md5", "sha1", "sha256", "sha512"])
-    salt = st.sidebar.text_input("Salt (optional)")
-    parallel = st.sidebar.checkbox("Use Parallel Processing")
-    complexity = st.sidebar.checkbox("Check for Password Complexity")
-    min_length = st.sidebar.number_input("Minimum Password Length", min_value=1, value=1)
-    max_length = st.sidebar.number_input("Maximum Password Length", min_value=1, value=6)
-    character_set = st.sidebar.text_input("Character Set", "abcdefghijklmnopqrstuvwxyz0123456789")
-    brute_force = st.sidebar.checkbox("Perform Brute Force Attack")
-
-    if st.sidebar.button("Crack Password"):
-        if not wordlist_file:
-            st.error("Please upload a wordlist file.")
+
+class PasswordCracker:
+    def __init__(self, password_hash, wordlist_file, algorithm, salt=None, parallel=False, complexity_check=False):
+        self.password_hash = password_hash
+        self.wordlist_file = wordlist_file
+        self.algorithm = algorithm
+        self.salt = salt
+        self.parallel = parallel
+        self.complexity_check = complexity_check
+        self.total_passwords = 0
+        self.matched_password = None
+
+    def crack_hash(self, word):
+        if self.salt:
+            word_with_salt = f'{self.salt}{word}'
+        else:
+            word_with_salt = word
+        hashed_word = hashlib.new(self.algorithm, word_with_salt.encode()).hexdigest()
+        if hashed_word == self.password_hash:
+            self.matched_password = word
+            return True
+        return False
+
+    def generate_passwords(self, min_length, max_length, character_set):
+        passwords = []
+        for length in range(min_length, max_length + 1):
+            for combination in itertools.product(character_set, repeat=length):
+                password = ''.join(combination)
+                passwords.append(password)
+        return passwords
+
+    def evaluate_complexity(self, password):
+        has_lowercase = any(char.islower() for char in password)
+        has_uppercase = any(char.isupper() for char in password)
+        has_digit = any(char.isdigit() for char in password)
+        has_special = any(not char.isalnum() for char in password)
+
+        return len(password) >= 8 and has_lowercase and has_uppercase and has_digit and has_special
+
+    def crack_passwords(self, passwords):
+        for password in passwords:
+            self.total_passwords += 1
+            if self.crack_hash(password):
+                return
+
+    def crack_passwords_parallel(self, passwords):
+        with Pool() as pool:
+            pool.map(self.crack_password, passwords)
+
+    def crack_password(self, password):
+        if self.complexity_check and not self.evaluate_complexity(password):
             return
-        
-        cracking_spinner = st.spinner("Cracking...")
-        with cracking_spinner:
-            stats = crack_password(
-                password_hash=password_hash,
-                wordlist_file=wordlist_file,
-                algorithm=algorithm,
-                salt=salt,
-                parallel=parallel,
-                complexity=complexity,
-                min_length=min_length,
-                max_length=max_length,
-                character_set=character_set,
-                brute_force=brute_force
-            )
-        st.success(f"Password Cracked! Statistics data:\n{stats}")
-        st.balloons()
-
-if __name__ == "__main__":
+        if self.matched_password is None:
+            if self.crack_hash(password):
+                return
+
+    def crack_passwords_with_wordlist(self):
+        with open(self.wordlist_file, 'r', encoding="latin-1") as wordlist:
+            passwords = wordlist.read().splitlines()
+            if self.parallel:
+                self.crack_passwords_parallel(passwords)
+            else:
+                self.crack_passwords(passwords)
+
+    def crack_passwords_with_brute_force(self, min_length, max_length, character_set):
+        passwords = self.generate_passwords(min_length, max_length, character_set)
+        if self.parallel:
+            self.crack_passwords_parallel(passwords)
+        else:
+            self.crack_passwords(passwords)
+
+    def print_statistics(self):
+        print(f"Total Number of Passwords Tried: {self.total_passwords}")
+        if self.matched_password:
+            print(f"Password Cracked! Password: {self.matched_password}")
+        else:
+            print("Password Failed.")
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Password cracking source PassBreaker')
+    parser.add_argument('password_hash', help='Password hash')
+    parser.add_argument('wordlist_file', help='Wordlist File')
+    parser.add_argument('--algorithm', choices=hashlib.algorithms_available, required=True, help='Hash algorithm')
+    parser.add_argument('-s', '--salt', help='Salt Value')
+    parser.add_argument('-p', '--parallel', action='store_true', help='Use parallel processing')
+    parser.add_argument('-c', '--complexity', action='store_true', help='Check for password complexity')
+    parser.add_argument('-b', '--brute-force', action='store_true', help='Perform a brute force attack')
+    parser.add_argument('--min-length', type=int, default=1, help='Minimum password length for brute force attack')
+    parser.add_argument('--max-length', type=int, default=6, help='Minimum password length for brute force attack')
+    parser.add_argument('--character-set', default='abcdefghijklmnopqrstuvwxyz0123456789',
+                        help='Character set for brute force attack')
+
+    args = parser.parse_args()
+
+    cracker = PasswordCracker(args.password_hash, args.wordlist_file, args.algorithm, args.salt, args.parallel, args.complexity)
+
+    if args.brute_force:
+        cracker.crack_passwords_with_brute_force(args.min_length, args.max_length, args.character_set)
+    else:
+        cracker.crack_passwords_with_wordlist()
+
+    cracker.print_statistics()
+
+
+if __name__ == '__main__':
     main()