Decryption failed: 'utf-8' codec can't decode byte 0x95 in position 6: invalid start byte

[finnstacey]

Hi,

I am able to follow all the steps, but with the correct backup password I have the error for each password:

"Decryption failed: 'utf-8' codec can't decode byte 0x95 in position 6: invalid start byte"

[ksverdlov]

I have the same error for ~1/3 of all my entries. And some entries have the other error:
"Decryption failed: 'utf-8' codec can't decode byte 0xf4 in position 0: invalid continuation byte"

[lynnewu]

same problem here, using a known-good password. Windows 10, Python 3.12.6

I threw your code into Claude4 and after some iterations, got successful decryption for at least some (but haven't tested all). Apologies for the bulk and debug code, but while I'm a coder, I'm not a Python coder and wanted to see everything that was going on.

from us.anthropic.claude-sonnet-4-20250514-v1:0

I notice there's a unique_iv field in the data that wasn't being used! This is likely the actual IV for the AES decryption, not a zero IV. Let me rewrite the decryption function to use the correct IV:

...code shown below...

The key change is that I'm now using the unique_iv field from each token instead of assuming a zero IV. This should give you the correct decrypted TOTP secrets. The IV (0ac44b5f3be72210eb8a46548740e984) is crucial for proper AES-CBC decryption.

This should now properly decrypt the seeds to readable Base32 strings that can be used with TOTP authenticator applications.

import json
import base64
import binascii
import re
from getpass import getpass
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend

def decrypt_token(kdf_rounds, encrypted_seed_b64, salt, passphrase, unique_iv):
    try:
        print(f"DEBUG: Starting token decryption")
        print(f"DEBUG: KDF rounds: {kdf_rounds}")
        print(f"DEBUG: Salt: {salt}")
        print(f"DEBUG: Unique IV: {unique_iv}")
        print(f"DEBUG: Passphrase length: {len(passphrase)} characters")
        print(f"DEBUG: Encrypted seed (base64): {encrypted_seed_b64}")
        
        encrypted_seed = base64.b64decode(encrypted_seed_b64)
        print(f"DEBUG: Encrypted seed size after base64 decode: {len(encrypted_seed)} bytes")
        print(f"DEBUG: Encrypted seed (hex): {encrypted_seed.hex()}")
        
        iv = bytes.fromhex(unique_iv)
        print(f"DEBUG: IV size: {len(iv)} bytes")
        print(f"DEBUG: IV (hex): {iv.hex()}")
        
        if len(iv) != 16:
            raise ValueError(f"Invalid IV length: {len(iv)}")
        
        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA1(),
            length=32,
            salt=salt.encode(),
            iterations=kdf_rounds,
            backend=default_backend()
        )
        
        key = kdf.derive(passphrase.encode())
        print(f"DEBUG: Derived key (hex): {key.hex()}")
        print(f"DEBUG: Key length: {len(key)} bytes")
        
        cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
        decryptor = cipher.decryptor()
        
        decrypted_data = decryptor.update(encrypted_seed) + decryptor.finalize()
        print(f"DEBUG: Decrypted data size: {len(decrypted_data)} bytes")
        print(f"DEBUG: Decrypted data (hex): {decrypted_data.hex()}")
        
        padding_len = decrypted_data[-1]
        padding_start = len(decrypted_data) - padding_len
        print(f"DEBUG: Padding length: {padding_len}")
        
        if padding_len > 16 or padding_start < 0:
            raise ValueError("Invalid padding length")
        
        padding_bytes = decrypted_data[padding_start:]
        if not all(pad == padding_len for pad in padding_bytes):
            raise ValueError("Invalid padding bytes")
        
        decrypted_seed_without_padding = decrypted_data[:padding_start]
        print(f"DEBUG: Data without padding: {decrypted_seed_without_padding.hex()}")
        
        try:
            utf8_result = decrypted_seed_without_padding.decode('utf-8')
            print(f"DEBUG: Successfully decoded as UTF-8: '{utf8_result}'")
            if re.match(r'^[A-Z2-7=]+$', utf8_result.upper().replace(' ', '')):
                return utf8_result.upper().replace(' ', '')
            return utf8_result
        except UnicodeDecodeError as e:
            print(f"DEBUG: UTF-8 decode failed: {e}")
        
        ascii_chars = [chr(b) for b in decrypted_seed_without_padding if 32 <= b <= 126]
        ascii_string = ''.join(ascii_chars)
        print(f"DEBUG: Extracted ASCII string: '{ascii_string}'")
        
        base32_match = re.search(r'[A-Z2-7=]{10,}', ascii_string.upper())
        if base32_match:
            return base32_match.group()
        
        if len(ascii_string) >= 8:
            return ascii_string
        
        return decrypted_seed_without_padding.hex().upper()
        
    except Exception as e:
        import traceback
        print(f"ERROR: Decryption failed with exception: {type(e).__name__}: {str(e)}")
        traceback.print_exc()
        return f"Decryption failed: {str(e)}"

def process_authenticator_data(input_file, output_file, backup_password):
    print(f"DEBUG: Input file: {input_file}")
    print(f"DEBUG: Output file: {output_file}")
    
    try:
        with open(input_file, "r") as json_file:
            data = json.load(json_file)
        if 'authenticator_tokens' not in data:
            print("ERROR: 'authenticator_tokens' not found")
            return
    except Exception as e:
        print(f"ERROR: Failed to load input: {str(e)}")
        return
    
    decrypted_tokens = []
    
    for i, token in enumerate(data['authenticator_tokens']):
        print(f"\nDEBUG: Processing token {i+1}")
        unique_iv = token.get('unique_iv', '00000000000000000000000000000000')
        decrypted_seed = decrypt_token(
            kdf_rounds=token['key_derivation_iterations'],
            encrypted_seed_b64=token['encrypted_seed'],
            salt=token['salt'],
            passphrase=backup_password,
            unique_iv=unique_iv
        )
        
        decrypted_tokens.append({
            "account_type": token["account_type"],
            "name": token["name"],
            "issuer": token["issuer"],
            "decrypted_seed": decrypted_seed,
            "digits": token["digits"],
            "logo": token["logo"],
            "unique_id": token["unique_id"]
        })
    
    output_data = {
        "message": "success",
        "decrypted_authenticator_tokens": decrypted_tokens,
        "success": True
    }
    
    try:
        with open(output_file, "w") as output_json_file:
            json.dump(output_data, output_json_file, indent=4)
        print(f"SUCCESS: Decrypted data saved to '{output_file}'")
    except Exception as e:
        print(f"ERROR: Failed to write output: {str(e)}")

# Entry point
input_file = "authenticator_tokens.json"
output_file = "decrypted_tokens.json"

backup_password = getpass("Enter the backup password: ").strip()
process_authenticator_data(input_file, output_file, backup_password)