Crypt Format Specifications

[Header: 0-50]     - Magic bytes and metadata
[IV/Nonce: 51-66]  - 16-byte initialization vector
[Data: 67-EOF-20]  - Encrypted and compressed data
[Tag: EOF-20-EOF]  - Authentication tag

if is_crypt12:
    iv = data[51:67]              # Extract IV
    ciphertext = data[67:-20]      # Extract ciphertext
    cipher = AES.new(raw_key, AES.MODE_GCM, nonce=iv)
    # Last 16 bytes are GCM tag
    decrypted_data = cipher.decrypt_and_verify(
        ciphertext[:-16], 
        ciphertext[-16:]
    )
    decrypted_data = zlib.decompress(decrypted_data)  # Decompress

[Header: Variable]     - Contains metadata, version info
[IV/Nonce: Variable]   - 16-byte IV at offset determined by header
[Data: Variable]       - Encrypted and compressed SQLite database
[Tag: Variable]        - 16-byte or 32-byte GCM authentication tag

COMMON_OFFSETS = [
    (8, 24, 135),    # (IV start, IV end, Data start)
    (67, 83, 190),
    (191, 207, 224),
    (67, 83, 83)
]

def _derive_key(self, key_stream: bytes) -> bytes:
    intermediate = hmac.new(b'\x00' * 32, key_stream, hashlib.sha256).digest()
    return hmac.new(intermediate, b"backup encryption\x01", hashlib.sha256).digest()

keys_to_try = [
    ("Derived", self._derive_key(raw_key)),  # Try derived key first
    ("Raw", raw_key)                          # Fallback to raw key
]

for name, key in keys_to_try:
    # 1. Try known offsets
    for iv_s, iv_e, db_s in self.COMMON_OFFSETS:
        if len(data) < db_s: continue
        iv = data[iv_s:iv_e]
        cipher = AES.new(key, AES.MODE_GCM, nonce=iv)
        ct = data[db_s:]
        
        # Try two tag positions (32-byte footer or 16-byte end)
        tag = ct[-32:-16] if len(ct) > 32 else ct[-16:]
        actual = ct[:-32] if len(ct) > 32 else ct[:-16]
        
        res = cipher.decrypt_and_verify(actual, tag)
        decrypted_data = zlib.decompress(res)

for iv_s in range(0, 190):  # Scan first 190 bytes for IV
    iv = data[iv_s:iv_s+16]
    for db_s in range(iv_s+16, iv_s+300):  # Scan next 300 bytes for data
        try:
            cipher = AES.new(key, AES.MODE_GCM, nonce=iv)
            ct = data[db_s:]
            res = cipher.decrypt_and_verify(ct[:-16], ct[-16:])
            decrypted_data = zlib.decompress(res)
            # Success! Found correct offsets
            break
        except:
            pass  # Wrong offset, continue

cipher = AES.new(key, AES.MODE_GCM, nonce=iv)
plaintext = cipher.decrypt_and_verify(ciphertext, tag)

from core.crypto_manager import CryptoManager

cm = CryptoManager()
key_hex = "a1b2c3..." # 64 hex chars
cm.decrypt_file(
    input_path="msgstore.db.crypt14",
    key_hex=key_hex,
    output_path="msgstore.db"
)

Decrypting msgstore.db.crypt14...
Decrypted with Derived Key (Offset 67)
Saved to: msgstore.db

cm.decrypt_file(
    input_path="msgstore.db.crypt12",
    key_hex=key_hex,
    output_path="msgstore.db"
)

Decrypting msgstore.db.crypt12...
Decrypted .crypt12 successfully.
Saved to: msgstore.db

Decrypting msgstore.db.crypt14...
Scanning offsets for Derived Key...
Decrypted at IV:82, DB:156
Saved to: msgstore.db

try:
    iv = data[iv_s:iv_e]
    cipher = AES.new(key, AES.MODE_GCM, nonce=iv)
    ct = data[db_s:]
    res = cipher.decrypt_and_verify(actual, tag)
    decrypted_data = zlib.decompress(res)
except:
    pass  # Wrong offset/key, continue trying

try:
    res = cipher.decrypt_and_verify(actual, tag)
    print(f"DEBUG: Successful at IV:{iv_s}, DB:{db_s}, Key:{name}")
except Exception as e:
    print(f"DEBUG: Failed at IV:{iv_s}, DB:{db_s}: {e}")

with open('msgstore.db.crypt14', 'rb') as f:
    header = f.read(200)
    print(header.hex())  # Examine first 200 bytes

from core.utils import validate_hex_key

key = "a1b2c3..."
if validate_hex_key(key):
    print("Valid key format")
else:
    print("Invalid: must be 64 hex chars")

is_crypt12 = input_path.endswith('.crypt12')