Documentation API

import json, base64, secrets
from urllib.parse import urlencode
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.backends import default_backend

# RSA Public Key for encryption
PEM_KEY = """-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsJdFWbKk6MY03IjsAtv3
hf8QqvFiQko6weaCtde5HkrAdXXt/N64mOAzhh8jhptWMjFLqFt6zzexB02n0qbb
cxP7uWMHZU4gcqI2dwP09DFX8iVpHhj3z35EVKtd94uSsbn/A2E54cjfgfit4VhP
m9NswEnXZmHhEey50n8VSZn1h8sDvY6vSLmO/Mio1CgqJ6+Pbf8gagnxprNr1xs+
i2yWh/CUfA+q3WoA/NmECLqJ4POPPWskjqzUfxjw+Ujs75owipY2csbPUjp1gRQn
2zi2Oay0NVjtnZGITW7ElvVuXVfVPp2Z7sa/t/bvMAQu7OHsgLF/PiHi3Rk0zasf
LwIDAQAB
-----END PUBLIC KEY-----"""

def earnguardian(url: str, user_id: int) -> str:
    # Validate input parameters
    if not isinstance(url, str):
        raise ValueError(f"Invalid 'url' parameter - expected: str, received: {type(url).__name__} ({url})")
    if not isinstance(user_id, int):
        raise ValueError(f"Invalid 'user_id' parameter - expected: int, received: {type(user_id).__name__} ({user_id})")
    
    def generate_aes_key():
        return secrets.token_bytes(16)  # 128-bit AES key
    
    def encrypt_with_aes(data: str, key: bytes):
        iv = secrets.token_bytes(16)
        cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
        encryptor = cipher.encryptor()
        
        # Convert to bytes and apply PKCS7 padding
        data_bytes = data.encode('utf-8')
        pad_length = 16 - (len(data_bytes) % 16)
        padded_data = data_bytes + bytes([pad_length] * pad_length)
        
        encrypted = encryptor.update(padded_data) + encryptor.finalize()
        return {
            'iv': base64.b64encode(iv).decode('utf-8'),
            'data': base64.b64encode(encrypted).decode('utf-8')
        }
    
    def encrypt_aes_key_with_rsa(aes_key: bytes):
        # Load RSA public key and encrypt AES key with RSA-OAEP
        rsa_key = serialization.load_pem_public_key(PEM_KEY.encode('utf-8'), backend=default_backend())
        encrypted = rsa_key.encrypt(aes_key, padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(), label=None))
        return base64.b64encode(encrypted).decode('utf-8')
    
    def process_url(input_url: str):
        url_string = str(input_url)
        
        # Validate URL format
        if not url_string or not (url_string.startswith('http://') or url_string.startswith('https://')):
            raise ValueError(f'Invalid URL - received: "{url_string}". Must start with http:// or https://')
        
        # Generate encryption keys and encrypt data
        aes_key = generate_aes_key()
        json_data = json.dumps({'url': url_string, 'userId': user_id}, separators=(',', ':'))
        encrypted_data = encrypt_with_aes(json_data, aes_key)
        encrypted_aes_key = encrypt_aes_key_with_rsa(aes_key)
        
        # Build secure URL with encrypted parameters
        params = [('data', encrypted_data['data']), ('iv', encrypted_data['iv']), ('key', encrypted_aes_key)]
        return f"https://votredomaine.com/verify?{urlencode(params)}"

    try:
        return process_url(url)
    except Exception as e:
        print(f"EarnGuardian - Error processing URL: {e}")
        raise

# Example usage
if __name__ == "__main__":
    url_to_secure = "https://google.com/"
    try:
        secured_url = earnguardian(url_to_secure, 1)
        print(f'Original URL: {url_to_secure}')
        print(f'Secured URL: {secured_url}')
    except Exception as error:
        print(f'Error during securing: {error}')