Security Utilities APIs

// Generate a hash of user input
    const userInput = document.getElementById('password').value;

    fetch(`https://mockly.me/hash/${encodeURIComponent(userInput)}?algorithm=sha256`)
    .then(response => response.json())
    .then(data => {
        console.log('Original:', data.original);
        console.log('Algorithm:', data.algorithm);
        console.log('Hashed:', data.hashed);
        
        // Store the hash for verification
        localStorage.setItem('password_hash', data.hashed);
    });

import requests

    def hash_text(text, algorithm="sha256"):
        """Generate a hash of the provided text"""
        response = requests.get(
            f"https://mockly.me/hash/{text}",
            params={"algorithm": algorithm}
        )
        data = response.json()
        return data

    # Test with different algorithms
    algorithms = ["md5", "sha1", "sha256", "sha512"]
    text = "secure_password123"

    for algo in algorithms:
        result = hash_text(text, algo)
        print(f"{algo.upper()}: {result['hashed']}")

// Create an HMAC signature for data authentication
    const data = JSON.stringify({ userId: 1234, action: "payment" });
    const secretKey = "API_SECRET_KEY_123";

    // Get HMAC to verify data integrity
    fetch(`https://mockly.me/hmac?data=${encodeURIComponent(data)}&key=${encodeURIComponent(secretKey)}`)
    .then(response => response.json())
    .then(result => {
        // Attach the signature to the request headers
        const headers = {
        'Content-Type': 'application/json',
        'X-HMAC-Signature': result.signature
        };
        
        // Send authenticated request
        fetch('https://api.example.com/process-payment', {
        method: 'POST',
        headers: headers,
        body: data
        });
    });

import requests
    import json

    def get_hmac_signature(data, key, algorithm="sha256"):
        """Generate an HMAC signature for data authentication"""
        params = {
            "data": data,
            "key": key,
            "algorithm": algorithm
        }
        
        response = requests.get("https://mockly.me/hmac", params=params)
        return response.json()

    # Data to be authenticated
    payload = json.dumps({"user_id": 123, "timestamp": 1689422587})
    api_key = "your_secret_key_here"

    # Get HMAC signature
    result = get_hmac_signature(payload, api_key)
    print(f"Signature: {result['signature']}")

    # In a real application, you would verify the signature
    print(f"Verification code: {result['verification_example']}")

// Generate a sample JWT token for UI demo
    fetch('https://mockly.me/jwt')
    .then(response => response.json())
    .then(data => {
        // Store the JWT token
        localStorage.setItem('demo_token', data.token);
        
        // Display token information
        document.getElementById('token').textContent = data.token;
        
        // Display decoded payload
        const decodedPayload = JSON.stringify(data.payload, null, 2);
        document.getElementById('decoded-token').textContent = decodedPayload;
        
        // Show expiration information
        const expiryTime = new Date(data.expires_at).toLocaleString();
        document.getElementById('token-expiry').textContent = expiryTime;
    });

import requests
    from datetime import datetime

    # Get a sample JWT token
    response = requests.get("https://mockly.me/jwt")
    data = response.json()

    print(f"JWT Token: {data['token']}")
    print(f"\nDecoded Header: {data['header']}")
    print(f"\nDecoded Payload: {data['payload']}")

    # Check if token is expired
    expires_at = datetime.fromisoformat(data['expires_at'].replace('Z', '+00:00'))
    current_time = datetime.now()

    if current_time > expires_at:
        print("\nToken has expired")
    else:
        print(f"\nToken is valid until: {expires_at}")
        print(f"Time remaining: {expires_at - current_time}")

// Basic obfuscation of data with XOR
    const data = "confidential_data_123";
    const key = "mysecretkey";

    // Encode the data
    fetch(`https://mockly.me/xor?data=${encodeURIComponent(data)}&key=${encodeURIComponent(key)}`)
    .then(response => response.json())
    .then(result => {
        console.log('Original data:', result.original);
        console.log('Encoded data:', result.encoded);
        
        // Store encoded data
        localStorage.setItem('obfuscated_data', result.encoded);
        
        // To decode, you need to use the same key and re-encode
        // (XOR is its own inverse with the same key)
    });

import requests
    import base64

    def xor_encode(data, key):
        """Encode data with XOR using a key"""
        params = {
            "data": data,
            "key": key
        }
        response = requests.get("https://mockly.me/xor", params=params)
        return response.json()

    def xor_decode(encoded_data, key):
        """Decode XOR-encoded data using the same key"""
        # Decode the base64 string
        decoded_base64 = base64.b64decode(encoded_data).decode()
        
        # XOR again with the same key (XOR is its own inverse)
        params = {
            "data": decoded_base64,
            "key": key
        }
        response = requests.get("https://mockly.me/xor", params=params)
        return response.json()["original"]

    # Test encoding and decoding
    data = "sensitive_information"
    key = "secret123"

    # Encode the data
    encoded = xor_encode(data, key)
    print(f"Encoded: {encoded['encoded']}")

    # Decode the data
    # In a real implementation, you would handle the base64 decoding
    # and XOR operation directly rather than calling the API again
    print(f"Original data: {data}")

// Get different random values for a demo
    async function populateRandomData() {
    // Get random username
    const nameResponse = await fetch('https://mockly.me/random?type=name');
    const nameData = await nameResponse.json();
    document.getElementById('username').textContent = nameData.value;
    
    // Get random number for ID
    const numResponse = await fetch('https://mockly.me/random?type=number');
    const numData = await numResponse.json();
    document.getElementById('user-id').textContent = numData.value;
    
    // Get random emoji for avatar
    const emojiResponse = await fetch('https://mockly.me/random?type=emoji');
    const emojiData = await emojiResponse.json();
    document.getElementById('avatar').textContent = emojiData.value;
    }

    // Run when page loads
    document.addEventListener('DOMContentLoaded', populateRandomData);

    // Refresh button
    document.getElementById('refresh-data').addEventListener('click', populateRandomData);

import requests

    def get_random(type_value):
        """Get a random value of the specified type"""
        response = requests.get(f"https://mockly.me/random?type={type_value}")
        return response.json()["value"]

    # Generate test user data
    def generate_test_user():
        username = get_random("name")
        user_id = get_random("number")
        password = get_random("string")
        
        return {
            "username": username,
            "user_id": user_id,
            "password": password
        }

    # Generate multiple test users
    test_users = [generate_test_user() for _ in range(5)]
    print("Generated test users:")
    for i, user in enumerate(test_users, 1):
        print(f"User {i}: {user['username']} (ID: {user['user_id']})")

// Generate a color scheme from a random color
    function generateColorScheme() {
    fetch('https://mockly.me/color')
        .then(response => response.json())
        .then(data => {
        // Update color display
        const colorBox = document.getElementById('primary-color');
        colorBox.style.backgroundColor = data.hex;
        colorBox.textContent = data.hex;
        
        // Set text color based on accessibility
        colorBox.style.color = data.accessibility.best_text_color;
        
        // Show color information
        document.getElementById('color-name').textContent = data.name;
        document.getElementById('color-rgb').textContent = data.rgb;
        
        // Set up accessibility info
        const accessMsg = data.accessibility.wcag_aa_compliant ? 
            '✓ WCAG AA Compliant' : '✗ Not WCAG AA Compliant';
        document.getElementById('accessibility').textContent = accessMsg;
        });
    }

    // Generate on page load and when button clicked
    document.addEventListener('DOMContentLoaded', generateColorScheme);
    document.getElementById('new-color').addEventListener('click', generateColorScheme);

import requests

    def generate_color_palette(num_colors=5):
        """Generate a color palette with complementary colors"""
        colors = []
        
        for _ in range(num_colors):
            response = requests.get("https://mockly.me/color")
            color_data = response.json()
            
            colors.append({
                "hex": color_data["hex"],
                "name": color_data["name"],
                "accessibility": color_data["accessibility"]
            })
        
        return colors

    # Generate a color palette for a design project
    palette = generate_color_palette()

    print("Color Palette:")
    for i, color in enumerate(palette, 1):
        print(f"{i}. {color['hex']} - {color['name']}")
        print(f"   Best text color: {color['accessibility']['best_text_color']}")
        print(f"   WCAG compliant: {color['accessibility']['wcag_aa_compliant']}")
        print()

// Generate a v4 UUID for unique identification
    fetch('https://mockly.me/uuid?version=4')
    .then(response => response.json())
    .then(data => {
        // Use for unique identifiers
        const id = data.uuid;
        console.log('Generated UUID:', id);
        
        // Example: Create a new record with this UUID
        const newRecord = {
        id: id,
        name: 'New Item',
        created: new Date().toISOString()
        };
        
        // Save to local storage
        localStorage.setItem(`item_${id}`, JSON.stringify(newRecord));
    });

import requests

    def get_uuid(version=4, namespace=None):
        """Generate a UUID of the specified version"""
        params = {"version": version}
        if namespace:
            params["namespace"] = namespace
        
        response = requests.get("https://mockly.me/uuid", params=params)
        return response.json()

    # Generate UUIDs for a database migration
    print("Generating UUIDs for database migration...")

    # Get a v1 UUID (timestamp-based) for logging
    v1_uuid = get_uuid(version=1)
    print(f"Timestamp UUID: {v1_uuid['uuid']}")
    print(f"Generated at: {v1_uuid['timestamp']}")

    # Get multiple v4 UUIDs for records
    records = []
    for i in range(3):
        v4_uuid = get_uuid(version=4)
        records.append({
            "id": v4_uuid['uuid'],
            "name": f"Record {i+1}"
        })

    print("\nGenerated records:")
    for record in records:
        print(f"- {record['id']} : {record['name']}")