XMPP - authentication¶

import hashlib
import hmac
import base64
import itertools

def generate_from_pattern(pattern):
    """Generate password candidates based on pattern with wildcards"""
    if pattern == "koma*":
        for i in itertools.product('abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*', repeat=3):
            yield f"koma{''.join(i)}"
    elif pattern == "*koma*":
        for pre in ['', 'a', 'x', '1']:
            for post in ['', '1', '!', 'test']:
                yield f"{pre}koma{post}"
    elif pattern == "koma*test":
        for mid in ['', '_', '123', 'x']:
            yield f"koma{mid}test"
    elif pattern == "koma*123":
        for mid in ['', '_', 'test', 'x']:
            yield f"koma{mid}123"
    elif pattern == "test*koma":
        for mid in ['', '_', '123']:
            yield f"test{mid}koma"

def calculate_scram_proof(password, salt_b64, iterations, auth_message):
    """Calculate SCRAM-SHA-1 proof for given parameters"""
    salt = base64.b64decode(salt_b64)
    
    # Calculate SaltedPassword
    salted_password = hashlib.pbkdf2_hmac(
        'sha1',
        password.encode('utf-8'),
        salt,
        iterations
    )
    
    # Calculate ClientKey
    client_key = hmac.new(salted_password, b"Client Key", 'sha1').digest()
    
    # Calculate StoredKey
    stored_key = hashlib.sha1(client_key).digest()
    
    # Calculate ClientSignature
    client_signature = hmac.new(stored_key, auth_message.encode('utf-8'), 'sha1').digest()
    
    # Calculate ClientProof
    client_proof = bytes([ck ^ cs for ck, cs in zip(client_key, client_signature)])
    return base64.b64encode(client_proof).decode('utf-8')

def main():
    salt_b64 = "qgiJIJQsQPhvAotJWNHNPQ=="
    iterations = 4096
    target_proof = "anvxRRv7SVKIwsJ3Y6/0hKC0YU="
    
    # The auth_message would normally be built from the full protocol exchange
    # This is a simplified version for demonstration
    auth_message = "n=koma_test,r=hydra,r=hydra4OjoFBGFJyzTaBWKiGfuqNM+v9rDA0wn,s=qgiJIJQsQPhvAotJWNHNPQ==,i=4096,c=biws,r=hydra4OjoFBGFJyzTaBWKiGfuqNM+v9rDA0wn"

    patterns = [
        "koma*", 
        "*koma*",
        "koma*test",
        "koma*123",
        "test*koma"
    ]

    for pattern in patterns:
        print(f"\nTesting pattern: {pattern}")
        for pwd in generate_from_pattern(pattern):
            proof = calculate_scram_proof(pwd, salt_b64, iterations, auth_message)
            if proof == target_proof:
                print(f"Valid alternative found: {pwd}")
                # Don't break to find all possible matches

if __name__ == "__main__":
    main()

import hashlib
import hmac
import base64

# Parameters from packet capture
salt_b64 = "qgiJIJQsQPhvAotJWNHNPQ=="
iterations = 4096
client_nonce = "hydra"
server_nonce = "4OjoFBGFJyzTaBWKiGfuqNM+v9rDA0wn"
username = "koma_test"
target_proof = "anvxRRv7SVKIwsJ3Y6/0hKC0YU="

# Build auth message (simplified from full protocol flow)
auth_message = f"n={username},r={client_nonce},r={client_nonce}{server_nonce},s={salt_b64},i={iterations},c=biws,r={client_nonce}{server_nonce}"

def verify_password(password):
    salt = base64.b64decode(salt_b64)
    
    # 1. Compute SaltedPassword
    salted_password = hashlib.pbkdf2_hmac(
        'sha1',
        password.encode('utf-8'),
        salt,
        iterations
    )
    
    # 2. Compute ClientKey
    client_key = hmac.new(salted_password, b"Client Key", 'sha1').digest()
    
    # 3. Compute StoredKey
    stored_key = hashlib.sha1(client_key).digest()
    
    # 4. Compute ClientSignature
    client_signature = hmac.new(stored_key, auth_message.encode('utf-8'), 'sha1').digest()
    
    # 5. Compute ClientProof
    client_proof = bytes([ck ^ cs for ck, cs in zip(client_key, client_signature)])
    return base64.b64encode(client_proof).decode('utf-8')

# Test all candidate passwords
candidates = [
    "koma_test",      # The simplest candidate
    "koma_test123",
    "koma_test!",
    "k0ma_test",
    "komatest",
    "koma_password",
    "koma_secure",
    "koma123test"
]

print("Password Verification Results:")
print("="*50)
for pwd in candidates:
    proof = verify_password(pwd)
    match = "MATCH!" if proof == target_proof else ""
    print(f"{pwd.ljust(15)}: {proof} {match}")