SensehacK · March 6, 2025 00:08
diff --git a/0_readme.md b/0_readme.md
diff --git a/1_decrypt-encrypted-authy-resp-to b/1_decrypt-encrypted-authy-resp-to
 import json
 import base64
 import binascii  # For base16 decoding
 from getpass import getpass  # For hidden password input
 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, iv, passphrase):
    try:
        # Decode the base64-encoded encrypted seed
        encrypted_seed = base64.b64decode(encrypted_seed_b64)

        # Derive the encryption key using PBKDF2 with SHA-1
        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA1(),
            length=32,  # AES-256 requires a 32-byte key
            salt=salt.encode(),
            iterations=kdf_rounds,
            backend=default_backend()
        )
        key = kdf.derive(passphrase.encode())

        # AES with CBC mode
        # Some versions of Authy used an IV, while others used a null IV. We account for both cases here.
        if not iv:
            iv = bytes([0] * 16)
        else:
            iv = binascii.unhexlify(iv)
        cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
        decryptor = cipher.decryptor()

        # Decrypt the ciphertext
        decrypted_data = decryptor.update(encrypted_seed) + decryptor.finalize()

        # Remove PKCS7 padding
        padding_len = decrypted_data[-1]

        padding_start = len(decrypted_data) - padding_len

        # Validate padding
        if padding_len > 16 or padding_start < 0:
            raise ValueError("Invalid padding length")
        if not all(pad == padding_len for pad in decrypted_data[padding_start:]):
            raise ValueError("Invalid padding bytes")

        return decrypted_data[:padding_start].decode('utf-8')
    except Exception as e:
        return f"Decryption failed: {str(e)}"


 def process_authenticator_data(input_file, output_file, backup_password):
    with open(input_file, "r") as json_file:
        data = json.load(json_file)

    decrypted_tokens = []
    for token in data['authenticator_tokens']:
        decrypted_seed = decrypt_token(
            kdf_rounds=token['key_derivation_iterations'],
            encrypted_seed_b64=token['encrypted_seed'],
            salt=token['salt'],
            iv=token['unique_iv'],
            passphrase=backup_password
        )
        decrypted_token = {
            "account_type": token["account_type"],
            "name": token["name"],
            "issuer": token["issuer"],
            "decrypted_seed": decrypted_seed,  # Store as UTF-8 string
            "digits": token["digits"],
            "logo": token["logo"],
            "unique_id": token["unique_id"]
        }
        decrypted_tokens.append(decrypted_token)

    output_data = {
        "message": "success",
        "decrypted_authenticator_tokens": decrypted_tokens,
        "success": True
    }

    with open(output_file, "w") as output_json_file:
        json.dump(output_data, output_json_file, indent=4)

    print(f"Decryption completed. Decrypted data saved to '{output_file}'.")


 # User configuration
 input_file = "authenticator_tokens.json"  # Replace with your input file
 output_file = "decrypted_tokens.json"  # Replace with your desired output file

 # Prompt for the backup password at runtime (hidden input)
 backup_password = getpass("Enter the backup password: ").strip()

 # Process the file
 process_authenticator_data(input_file, output_file, backup_password)
diff --git a/2_convert-decrypted-values-vaultwarden.py b/2_convert-decrypted-values-vaultwarden.py
 import json
 import urllib.parse

 # Load source content from file
 with open("decrypted_tokens.json", "r") as f:
    authy_data = json.load(f)

 # Convert to Bitwarden format
 bitwarden_data = {"items": []}

 for account in authy_data["decrypted_authenticator_tokens"]:
    # Ensure all fields are strings or provide defaults
    name = str(account.get("name", ""))
    issuer = account.get("issuer")  # May be None
    secret = str(account.get("decrypted_seed", ""))
    digits = str(account.get("digits", "6"))

    # Construct TOTP URI
    totp_uri = f"otpauth://totp/{urllib.parse.quote(issuer or '')}:{urllib.parse.quote(name)}?"
    totp_uri += f"secret={urllib.parse.quote(secret)}&digits={digits}"
    if issuer:  # Only add issuer parameter if it exists
        totp_uri += f"&issuer={urllib.parse.quote(issuer)}"

    # Add to Bitwarden items
    bitwarden_data["items"].append({
        "name": name,
        "type": 1,  # Type 1 is for login items
        "login": {
            "username": name,
            "totp": totp_uri
        }
    })

 # Save to JSON file
 with open("vaultwarden_import.json", "w") as f:
    json.dump(bitwarden_data, f, indent=4)

 print("Vaultwarden import file created: vaultwarden_import.json")
diff --git a/3_dummy_vaultwarden_exported_data.json b/3_dummy_vaultwarden_exported_data.json
 {
    "items": [
        {
            "name": "Kay",
            "type": 1,
            "login": {
                "username": "KautilyaSave",
                "totp": "otpauth://totp/:Kay?secret=safa2&digits=6"
            }
        },
        {
            "name": "Kautilya",
            "type": 1,
            "login": {
                "username": "sensehack",
                "totp": "otpauth://totp/:Kautilya?secret=safa2&digits=6"
            }
        }
    ]
 }
diff --git a/4_convert-vaultwarden-ravioOTP.py b/4_convert-vaultwarden-ravioOTP.py
 import json
 import uuid
 import urllib.parse

 def extract_totp_secret(totp_uri):
    """
    Extract TOTP secret from otpauth URI
    """
    try:
        parsed_url = urllib.parse.urlparse(totp_uri)
        query_params = urllib.parse.parse_qs(parsed_url.query)
        return query_params.get('secret', [None])[0]
    except Exception:
        return None

 def convert_vaultwarden_to_raivo(input_file, output_file):
    """
    Convert Vaultwarden JSON export to Raivo OTP format.
    
    :param input_file: Path to the input Vaultwarden JSON file
    :param output_file: Path to save the converted Raivo OTP JSON file
    """
    # Read Vaultwarden JSON file
    with open(input_file, 'r', encoding='utf-8') as f:
        vaultwarden_data = json.load(f)
    
    # Prepare Raivo OTP format
    raivo_otps = []
    
    # Iterate through items
    for item in vaultwarden_data.get('items', []):
        # Check if the item has a login with TOTP
        if item.get('type') == 1 and 'login' in item:
            login = item['login']
            totp_uri = login.get('totp', '')
            
            # Extract secret from URI
            otp_secret = extract_totp_secret(totp_uri)
            
            # Skip if no OTP secret
            if not otp_secret:
                continue
            
            # Prepare Raivo OTP entry
            raivo_entry = {
                "id": str(uuid.uuid4()),  # Generate a unique ID
                "issuer": item.get('name', ''),
                "label": login.get('username', ''),
                "secret": otp_secret,
                "type": "TOTP",
                "algorithm": "SHA1",  # Default algorithm for most TOTP
                "digits": 6,  # Most OTP use 6 digits
                "period": 30  # Standard 30-second period
            }
            
            raivo_otps.append(raivo_entry)
    
    # Write Raivo OTP JSON file
    with open(output_file, 'w', encoding='utf-8') as f:
        json.dump(raivo_otps, f, indent=2, ensure_ascii=False)
    
    print(f"Converted {len(raivo_otps)} OTP entries.")

 def main():
    # Example usage
    input_file = 'vaultwarden_import.json'
    output_file = 'raivo_otps_third_try.json'
    
    convert_vaultwarden_to_raivo(input_file, output_file)

 if __name__ == '__main__':
    main()
diff --git a/5_my_prompts.md b/5_my_prompts.md
	import json
	import base64
	import binascii # For base16 decoding
	from getpass import getpass # For hidden password input
	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, iv, passphrase):
	try:
	# Decode the base64-encoded encrypted seed
	encrypted_seed = base64.b64decode(encrypted_seed_b64)

	# Derive the encryption key using PBKDF2 with SHA-1
	kdf = PBKDF2HMAC(
	algorithm=hashes.SHA1(),
	length=32, # AES-256 requires a 32-byte key
	salt=salt.encode(),
	iterations=kdf_rounds,
	backend=default_backend()
	)
	key = kdf.derive(passphrase.encode())

	# AES with CBC mode
	# Some versions of Authy used an IV, while others used a null IV. We account for both cases here.
	if not iv:
	iv = bytes([0] * 16)
	else:
	iv = binascii.unhexlify(iv)
	cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
	decryptor = cipher.decryptor()

	# Decrypt the ciphertext
	decrypted_data = decryptor.update(encrypted_seed) + decryptor.finalize()

	# Remove PKCS7 padding
	padding_len = decrypted_data[-1]

	padding_start = len(decrypted_data) - padding_len

	# Validate padding
	if padding_len > 16 or padding_start < 0:
	raise ValueError("Invalid padding length")
	if not all(pad == padding_len for pad in decrypted_data[padding_start:]):
	raise ValueError("Invalid padding bytes")

	return decrypted_data[:padding_start].decode('utf-8')
	except Exception as e:
	return f"Decryption failed: {str(e)}"


	def process_authenticator_data(input_file, output_file, backup_password):
	with open(input_file, "r") as json_file:
	data = json.load(json_file)

	decrypted_tokens = []
	for token in data['authenticator_tokens']:
	decrypted_seed = decrypt_token(
	kdf_rounds=token['key_derivation_iterations'],
	encrypted_seed_b64=token['encrypted_seed'],
	salt=token['salt'],
	iv=token['unique_iv'],
	passphrase=backup_password
	)
	decrypted_token = {
	"account_type": token["account_type"],
	"name": token["name"],
	"issuer": token["issuer"],
	"decrypted_seed": decrypted_seed, # Store as UTF-8 string
	"digits": token["digits"],
	"logo": token["logo"],
	"unique_id": token["unique_id"]
	}
	decrypted_tokens.append(decrypted_token)

	output_data = {
	"message": "success",
	"decrypted_authenticator_tokens": decrypted_tokens,
	"success": True
	}

	with open(output_file, "w") as output_json_file:
	json.dump(output_data, output_json_file, indent=4)

	print(f"Decryption completed. Decrypted data saved to '{output_file}'.")


	# User configuration
	input_file = "authenticator_tokens.json" # Replace with your input file
	output_file = "decrypted_tokens.json" # Replace with your desired output file

	# Prompt for the backup password at runtime (hidden input)
	backup_password = getpass("Enter the backup password: ").strip()

	# Process the file
	process_authenticator_data(input_file, output_file, backup_password)
	import json
	import urllib.parse

	# Load source content from file
	with open("decrypted_tokens.json", "r") as f:
	authy_data = json.load(f)

	# Convert to Bitwarden format
	bitwarden_data = {"items": []}

	for account in authy_data["decrypted_authenticator_tokens"]:
	# Ensure all fields are strings or provide defaults
	name = str(account.get("name", ""))
	issuer = account.get("issuer") # May be None
	secret = str(account.get("decrypted_seed", ""))
	digits = str(account.get("digits", "6"))

	# Construct TOTP URI
	totp_uri = f"otpauth://totp/{urllib.parse.quote(issuer or '')}:{urllib.parse.quote(name)}?"
	totp_uri += f"secret={urllib.parse.quote(secret)}&digits={digits}"
	if issuer: # Only add issuer parameter if it exists
	totp_uri += f"&issuer={urllib.parse.quote(issuer)}"

	# Add to Bitwarden items
	bitwarden_data["items"].append({
	"name": name,
	"type": 1, # Type 1 is for login items
	"login": {
	"username": name,
	"totp": totp_uri
	}
	})

	# Save to JSON file
	with open("vaultwarden_import.json", "w") as f:
	json.dump(bitwarden_data, f, indent=4)

	print("Vaultwarden import file created: vaultwarden_import.json")
	{
	"items": [
	{
	"name": "Kay",
	"type": 1,
	"login": {
	"username": "KautilyaSave",
	"totp": "otpauth://totp/:Kay?secret=safa2&digits=6"
	}
	},
	{
	"name": "Kautilya",
	"type": 1,
	"login": {
	"username": "sensehack",
	"totp": "otpauth://totp/:Kautilya?secret=safa2&digits=6"
	}
	}
	]
	}
	import json
	import uuid
	import urllib.parse

	def extract_totp_secret(totp_uri):
	"""
	Extract TOTP secret from otpauth URI
	"""
	try:
	parsed_url = urllib.parse.urlparse(totp_uri)
	query_params = urllib.parse.parse_qs(parsed_url.query)
	return query_params.get('secret', [None])[0]
	except Exception:
	return None

	def convert_vaultwarden_to_raivo(input_file, output_file):
	"""
	Convert Vaultwarden JSON export to Raivo OTP format.

	:param input_file: Path to the input Vaultwarden JSON file
	:param output_file: Path to save the converted Raivo OTP JSON file
	"""
	# Read Vaultwarden JSON file
	with open(input_file, 'r', encoding='utf-8') as f:
	vaultwarden_data = json.load(f)

	# Prepare Raivo OTP format
	raivo_otps = []

	# Iterate through items
	for item in vaultwarden_data.get('items', []):
	# Check if the item has a login with TOTP
	if item.get('type') == 1 and 'login' in item:
	login = item['login']
	totp_uri = login.get('totp', '')

	# Extract secret from URI
	otp_secret = extract_totp_secret(totp_uri)

	# Skip if no OTP secret
	if not otp_secret:
	continue

	# Prepare Raivo OTP entry
	raivo_entry = {
	"id": str(uuid.uuid4()), # Generate a unique ID
	"issuer": item.get('name', ''),
	"label": login.get('username', ''),
	"secret": otp_secret,
	"type": "TOTP",
	"algorithm": "SHA1", # Default algorithm for most TOTP
	"digits": 6, # Most OTP use 6 digits
	"period": 30 # Standard 30-second period
	}

	raivo_otps.append(raivo_entry)

	# Write Raivo OTP JSON file
	with open(output_file, 'w', encoding='utf-8') as f:
	json.dump(raivo_otps, f, indent=2, ensure_ascii=False)

	print(f"Converted {len(raivo_otps)} OTP entries.")

	def main():
	# Example usage
	input_file = 'vaultwarden_import.json'
	output_file = 'raivo_otps_third_try.json'

	convert_vaultwarden_to_raivo(input_file, output_file)

	if __name__ == '__main__':
	main()