Build Apps with Autholas

# pip install requests
import requests
import getpass
import uuid
import hashlib
import platform
import getpass as getuser

# Your API configuration
API_KEY = "YOUR_API_KEY_HERE"
API_URL = "https://autholas.nicholasdevs.xyz/api/auth"

def get_hardware_id():
    """Generate hardware ID"""
    hostname = platform.node()
    username = getpass.getuser()
    architecture = platform.machine().lower()

    # Normalize architecture like Node.js
    if architecture == "amd64":
        architecture = "x64"
    elif architecture == "x86_64":
        architecture = "x64"

    combined = f"{hostname}|{username}|{architecture}"
    return hashlib.sha256(combined.encode()).hexdigest()

def handle_auth_error(error_code, error_message):
    error_messages = {
        'INVALID_CREDENTIALS': {
            'title': 'Login Failed',
            'message': 'Username or password is incorrect.\nPlease double-check your credentials and try again.'
        },
        'USER_BANNED': {
            'title': 'Account Banned',
            'message': 'Your account has been suspended.\nPlease contact support for assistance.'
        },
        'SUBSCRIPTION_EXPIRED': {
            'title': 'Subscription Expired',
            'message': 'Your subscription has ended.\nPlease renew your subscription to continue.'
        },
        'MAX_DEVICES_REACHED': {
            'title': 'Device Limit Reached',
            'message': 'Maximum number of devices exceeded.\nPlease contact support to reset your devices.'
        },
        'HWID_BANNED': {
            'title': 'Device Banned',
            'message': 'This device has been banned.\nPlease contact support for assistance.'
        },
        'INVALID_API_KEY': {
            'title': 'Service Error',
            'message': 'Authentication service unavailable.\nPlease try again later or contact support.'
        },
        'RATE_LIMIT_EXCEEDED': {
            'title': 'Too Many Attempts',
            'message': 'Please wait before trying again.'
        },
        'DEVELOPER_SUSPENDED': {
            'title': 'Service Unavailable',
            'message': 'Authentication service is temporarily unavailable.\nPlease contact support.'
        },
        'SERVICE_ERROR': {
            'title': 'Service Error',
            'message': 'Authentication service is temporarily unavailable.\nPlease try again later.'
        }
    }
    
    if error_code in error_messages:
        error = error_messages[error_code]
        print(error['title'])
        print(error['message'])
    else:
        print(f"Error: {error_message}")

def authenticate(username, password, hwid):
    payload = {
        'api_key': API_KEY,
        'username': username,
        'password': password,
        'hwid': hwid,
        'device_name': 'User PC'
    }
    
    try:
        print("Authenticating...")
        response = requests.post(API_URL, json=payload, timeout=10)
        result = response.json()
        
        if result.get('success'):
            print("Login successful!")
            print(f"Welcome, {username}!")
            print(f"Session token: {result.get('session_token')}")
            print(f"Session expires: {result.get('expires_at')}")
            print(f"Subscription expires: {result['user']['expires_at']}")

            return {'success': True, 'session_token': result.get('session_token')}
        else:
            error_code = result.get('error_code', 'UNKNOWN')
            error_message = result.get('error', 'Unknown error')
            handle_auth_error(error_code, error_message)
            return {'success': False, 'error': error_message, 'error_code': error_code}
            
    except requests.exceptions.RequestException as e:
        print(f"Network error: {str(e)}")
        return {'success': False, 'error': str(e)}

if __name__ == "__main__":
    print("═══════════════════════════════════")
    print("       Autholas Login System       ")
    print("        Python Example Code        ")
    print("═══════════════════════════════════")
    
    username = input("Username: ")
    password = getpass.getpass("Password: ")
    hwid = get_hardware_id()
    
    print(f"Device ID: {hwid[:8]}...")
    
    result = authenticate(username, password, hwid)
    
    if result['success']:
        print("\nAuthentication successful!")
        print("Starting application...")
        # Your app logic here
    else:
        print("\nAuthentication failed.")
        input("Press Enter to exit...")

<?php
// Your API configuration
define('API_KEY', 'YOUR_API_KEY_HERE');
define('API_URL', 'https://autholas.nicholasdevs.xyz/api/auth');

function handleAuthError($errorCode, $errorMessage) {
    $errorMessages = array(
        'INVALID_CREDENTIALS' => array(
            'title' => 'Login Failed',
            'message' => 'Username or password is incorrect.\nPlease double-check your credentials and try again.'
        ),
        'USER_BANNED' => array(
            'title' => 'Account Banned',
            'message' => 'Your account has been suspended.\nPlease contact support for assistance.'
        ),
        'SUBSCRIPTION_EXPIRED' => array(
            'title' => 'Subscription Expired',
            'message' => 'Your subscription has ended.\nPlease renew your subscription to continue.'
        ),
        'MAX_DEVICES_REACHED' => array(
            'title' => 'Device Limit Reached',
            'message' => 'Maximum number of devices exceeded.\nPlease contact support to reset your devices.'
        ),
        'HWID_BANNED' => array(
            'title' => 'Device Banned',
            'message' => 'This device has been banned.\nPlease contact support for assistance.'
        ),
        'INVALID_API_KEY' => array(
            'title' => 'Service Error',
            'message' => 'Authentication service unavailable.\nPlease try again later or contact support.'
        ),
        'RATE_LIMIT_EXCEEDED' => array(
            'title' => 'Too Many Attempts',
            'message' => 'Please wait before trying again.'
        ),
        'DEVELOPER_SUSPENDED' => array(
            'title' => 'Service Unavailable',
            'message' => 'Authentication service is temporarily unavailable.\nPlease contact support.'
        ),
        'SERVICE_ERROR' => array(
            'title' => 'Service Error',
            'message' => 'Authentication service is temporarily unavailable.\nPlease try again later.'
        )
    );

    if (isset($errorMessages[$errorCode])) {
        $error = $errorMessages[$errorCode];
        echo $error['title'] . "\\n";
        echo $error['message'] . "\\n";
    } else {
        echo "Error: " . $errorMessage . "\\n";
    }
}

function authenticateUser($username, $password, $hwid) {
    $payload = array(
        'api_key' => API_KEY,
        'username' => $username,
        'password' => $password,
        'hwid' => $hwid,
        'device_name' => 'User PC'
    );
    
    $options = array(
        'http' => array(
            'header' => "Content-Type: application/json\\r\n",
            'method' => 'POST',
            'content' => json_encode($payload),
            'timeout' => 10
        )
    );
    
    echo "Authenticating...\n";
    
    $context = stream_context_create($options);
    $result = file_get_contents(API_URL, false, $context);
    
    if ($result === FALSE) {
        echo "Connection Error: Unable to reach authentication server.\n";
        echo "Please check your internet connection and try again.\n";
        return array('success' => false, 'error' => 'Connection error');
    }
    
    $response = json_decode($result, true);
    
    if ($response['success']) {
        echo "Login successful!\n";
        echo "Welcome, " . $username . "!\n";
        echo "Session token: " . $response['session_token'] . "\n";
        echo "Subscription expires: " . $response['user.expires_at'] . "\n";

        if (isset($response['expires_at'])) {
            echo "Session expires: " . $response['expires_at'] . "\n";
        }
        return array('success' => true, 'session_token' => $response['session_token']);
    } else {
        $errorCode = isset($response['error_code']) ? $response['error_code'] : 'UNKNOWN';
        $errorMessage = isset($response['error']) ? $response['error'] : 'Unknown error';
        
        handleAuthError($errorCode, $errorMessage);
        return array('success' => false, 'error' => $errorMessage, 'error_code' => $errorCode);
    }
}

function getHardwareID() {
    $hostname = gethostname();
    $username = get_current_user();
    $architecture = php_uname('m');

    $combined = "{$hostname}|{$username}|{$architecture}";
    return hash('sha256', $combined);
}

// Main application logic
echo "═══════════════════════════════════\\n";
echo "       Autholas Login System       \\n";
echo "          PHP Example Code         \\n";
echo "═══════════════════════════════════\\n";

echo "Username: ";
$username = trim(fgets(STDIN));

echo "Password: ";
$password = trim(fgets(STDIN));

$hwid = getHardwareID();
echo "Device ID: " . substr($hwid, 0, 8) . "...\n";

$result = authenticateUser($username, $password, $hwid);

if ($result['success']) {
    // User authenticated - start your application
    echo "\nAuthentication successful!\n";
    echo "Starting application...\n";
    // Your app logic here
    startApplication($result['session_token']);
} else {
    echo "\nAuthentication failed.\n";
    
    // Provide helpful tips based on error code
    if (isset($result['error_code'])) {
        switch ($result['error_code']) {
            case 'MAX_DEVICES_REACHED':
                echo "Tip: Contact support to reset your device limit or login from a previously used device.\n";
                break;
            case 'HWID_BANNED':
                echo "Tip: This specific device has been banned. Try from a different device or contact support.\n";
                break;
            case 'INVALID_CREDENTIALS':
                echo "Tip: Double-check your username and password spelling.\n";
                break;
        }
    }
    
    echo "Press Enter to exit...";
    fgets(STDIN);
    exit(1);
}
?>

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using System.Management;

namespace Autholas
{
    class AuthService
    {
        // Your API configuration
        private const string API_KEY = "YOUR_API_KEY_HERE";
        private const string API_URL = "https://autholas.nicholasdevs.xyz/api/auth";
        
        private static readonly HttpClient client = new HttpClient();

        private static void HandleAuthError(string errorCode, string errorMessage)
        {
            var errorMessages = new Dictionary<string, (string title, string message)>
            {
                ["INVALID_CREDENTIALS"] = ("Login Failed", "Username or password is incorrect.\nPlease double-check your credentials and try again."),
                ["USER_BANNED"] = ("Account Banned", "Your account has been suspended.\nPlease contact support for assistance."),
                ["SUBSCRIPTION_EXPIRED"] = ("Subscription Expired", "Your subscription has ended.\nPlease renew your subscription to continue."),
                ["MAX_DEVICES_REACHED"] = ("Device Limit Reached", "Maximum number of devices exceeded.\nPlease contact support to reset your devices."),
                ["HWID_BANNED"] = ("Device Banned", "This device has been banned.\nPlease contact support for assistance."),
                ["INVALID_API_KEY"] = ("Service Error", "Authentication service unavailable.\nPlease try again later or contact support."),
                ["RATE_LIMIT_EXCEEDED"] = ("Too Many Attempts", "Please wait before trying again."),
                ["DEVELOPER_SUSPENDED"] = ("Service Unavailable", "Authentication service is temporarily unavailable.\nPlease contact support."),
                ["SERVICE_ERROR"] = ("Service Error", "Authentication service is temporarily unavailable.\nPlease try again later.")
            };

            if (errorMessages.ContainsKey(errorCode))
            {
                var error = errorMessages[errorCode];
                Console.WriteLine(error.title);
                Console.WriteLine(error.message);
            }
            else
            {
                Console.WriteLine($"Error: {errorMessage}");
            }
        }

        public static async Task<AuthResult> AuthenticateUserAsync(string username, string password, string hwid)
        {
            var payload = new
            {
                api_key = API_KEY,
                username = username,
                password = password,
                hwid = hwid,
                device_name = "User PC"
            };

            try
            {
                Console.WriteLine("Authenticating...");
                
                var json = JsonConvert.SerializeObject(payload);
                var content = new StringContent(json, Encoding.UTF8, "application/json");
                
                var response = await client.PostAsync(API_URL, content);
                var responseString = await response.Content.ReadAsStringAsync();
                
                var result = JsonConvert.DeserializeObject<dynamic>(responseString);
                
                if (result.success == true)
                {
                    Console.WriteLine("Login successful!");
                    Console.WriteLine($"Welcome, {username}!");
                    Console.WriteLine($"Subscription expires: {result.user.expires_at}");

                    if (result.expires_at != null)
                        Console.WriteLine($"Session expires: {result.expires_at}");
                    
                    return new AuthResult 
                    { 
                        Success = true, 
                        SessionToken = result.session_token 
                    };
                }
                else
                {
                    string errorCode = result.error_code ?? "UNKNOWN";
                    string errorMessage = result.error ?? "Unknown error";
                    
                    HandleAuthError(errorCode, errorMessage);
                    return new AuthResult 
                    { 
                        Success = false, 
                        Error = errorMessage, 
                        ErrorCode = errorCode 
                    };
                }
            }
            catch (HttpRequestException ex)
            {
                Console.WriteLine("Connection Error: Unable to reach authentication server.");
                Console.WriteLine("Please check your internet connection and try again.");
                return new AuthResult { Success = false, Error = ex.Message };
            }
            catch (TaskCanceledException ex)
            {
                Console.WriteLine("Request Timeout: Server is taking too long to respond.");
                Console.WriteLine("Please try again later.");
                return new AuthResult { Success = false, Error = "Request timeout" };
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Unexpected error: {ex.Message}");
                return new AuthResult { Success = false, Error = ex.Message };
            }
        }

        public static string GetHardwareID() {
            try {
                string hostname = Environment.MachineName;
                string username = Environment.UserName;
                string architecture = Environment.Is64BitOperatingSystem ? "x64" : "x86";
                string combined = $"{hostname}|{username}|{architecture}";
                using (var sha256 = System.Security.Cryptography.SHA256.Create()) {
                    byte[] hash = sha256.ComputeHash(System.Text.Encoding.UTF8.GetBytes(combined));
                    return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
                }
            } catch {
                return "unknown";
            }
        }
    }

    public class AuthResult
    {
        public bool Success { get; set; }
        public string SessionToken { get; set; }
        public string Error { get; set; }
        public string ErrorCode { get; set; }
    }

    class Program
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine("═════════════════════════════════════");
            Console.WriteLine("        Autholas Login System        ");
            Console.WriteLine("           C# Example Code           ");
            Console.WriteLine("═════════════════════════════════════");
            
            Console.Write("Username: ");
            var username = Console.ReadLine();
            
            Console.Write("Password: ");
            var password = ReadPassword();
            
            var hwid = AuthService.GetHardwareID();
            Console.WriteLine($"Device ID: {hwid.Substring(0, Math.Min(8, hwid.Length))}...");
            
            var result = await AuthService.AuthenticateUserAsync(username, password, hwid);
            
            if (result.Success)
            {
                // User authenticated - start your application
                Console.WriteLine("\nAuthentication successful!");
                Console.WriteLine("Starting application...");
                // Your app logic here
                StartApplication(result.SessionToken);
            }
            else
            {
                Console.WriteLine("\nAuthentication failed.");
                
                // Provide helpful tips based on error code
                switch (result.ErrorCode)
                {
                    case "MAX_DEVICES_REACHED":
                        Console.WriteLine("Tip: Contact support to reset your device limit or login from a previously used device.");
                        break;
                    case "HWID_BANNED":
                        Console.WriteLine("Tip: This specific device has been banned. Try from a different device or contact support.");
                        break;
                    case "INVALID_CREDENTIALS":
                        Console.WriteLine("Tip: Double-check your username and password spelling.");
                        break;
                }
                
                Console.WriteLine("Press any key to exit...");
                Console.ReadKey();
            }
        }

        static string ReadPassword()
        {
            string password = "";
            ConsoleKeyInfo key;
            do
            {
                key = Console.ReadKey(true);
                if (key.Key != ConsoleKey.Backspace && key.Key != ConsoleKey.Enter)
                {
                    password += key.KeyChar;
                    Console.Write("*");
                }
                else if (key.Key == ConsoleKey.Backspace && password.Length > 0)
                {
                    password = password.Substring(0, (password.Length - 1));
                    Console.Write("\b \b");
                }
            } while (key.Key != ConsoleKey.Enter);
            Console.WriteLine();
            return password;
        }

        static void StartApplication(string sessionToken)
        {
            // Your application logic here
            Console.WriteLine("Application started successfully!");
            Console.WriteLine($"Session token: {sessionToken}");
        }
    }
}

// For Node.js applications
const axios = require('axios');
const readline = require('readline');
const os = require('os');
const crypto = require('crypto');

// Your API configuration
const API_KEY = 'YOUR_API_KEY_HERE';
const API_URL = 'https://autholas.nicholasdevs.xyz/api/auth';

function handleAuthError(errorCode, errorMessage) {
    const errorMessages = {
        'INVALID_CREDENTIALS': {
            title: 'Login Failed',
            message: 'Username or password is incorrect.\nPlease double-check your credentials and try again.'
        },
        'USER_BANNED': {
            title: 'Account Banned',
            message: 'Your account has been suspended.\nPlease contact support for assistance.'
        },
        'SUBSCRIPTION_EXPIRED': {
            title: 'Subscription Expired',
            message: 'Your subscription has ended.\nPlease renew your subscription to continue.'
        },
        'MAX_DEVICES_REACHED': {
            title: 'Device Limit Reached',
            message: 'Maximum number of devices exceeded.\nPlease contact support to reset your devices.'
        },
        'HWID_BANNED': {
            title: 'Device Banned',
            message: 'This device has been banned.\nPlease contact support for assistance.'
        },
        'INVALID_API_KEY': {
            title: 'Service Error',
            message: 'Authentication service unavailable.\nPlease try again later or contact support.'
        },
        'RATE_LIMIT_EXCEEDED': {
            title: 'Too Many Attempts',
            message: 'Please wait before trying again.'
        },
        'DEVELOPER_SUSPENDED': {
            title: 'Service Unavailable',
            message: 'Authentication service is temporarily unavailable.\nPlease contact support.'
        },
        'MISSING_PARAMETERS': {
            title: 'Invalid Request',
            message: 'Missing required parameters.\nPlease try again.'
        },
        'SERVICE_ERROR': {
            title: 'Service Error',
            message: 'Authentication service is temporarily unavailable.\nPlease try again later.'
        }
    };

    if (errorMessages[errorCode]) {
        const error = errorMessages[errorCode];
        console.log(error.title);
        console.log(error.message);
    } else {
        console.log(`Error: ${errorMessage}`);
    }
}

async function authenticateUser(username, password, hwid) {
    const payload = {
        api_key: API_KEY,
        username: username,
        password: password,
        hwid: hwid,
        device_name: 'User PC'
    };

    try {
        console.log('Authenticating...');
        
        const response = await axios.post(API_URL, payload, {
            timeout: 10000,
            validateStatus: function (status) {
                // Don't throw for any status code - we'll handle it manually
                return status < 500;
            }
        });

        if (response.data.success) {
            console.log('Login successful!');
            console.log(`Welcome, ${username}!`);
            
            // Display user info if available
            if (response.data.user && response.data.user.expires_at) {
                console.log(`Subscription expires: ${response.data.user.expires_at}`);
            }
            
            return {
                success: true,
                sessionToken: response.data.session_token
            };
        } else {
            // Handle specific errors with user-friendly messages
            const errorCode = response.data.error_code || 'UNKNOWN';
            const errorMessage = response.data.error || 'Unknown error';
            
            handleAuthError(errorCode, errorMessage);
            return { success: false, error: errorMessage, errorCode: errorCode };
        }
    } catch (error) {
        // Check if it's an HTTP error with response data
        if (error.response && error.response.data) {
            const errorCode = error.response.data.error_code || 'UNKNOWN';
            const errorMessage = error.response.data.error || 'Unknown error';
            
            handleAuthError(errorCode, errorMessage);
            return { success: false, error: errorMessage, errorCode: errorCode };
        }
        
        // Handle network errors
        if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND') {
            console.log('Connection Error: Unable to reach authentication server.');
            console.log('Please check your internet connection and try again.');
        } else if (error.code === 'ECONNABORTED') {
            console.log('Request Timeout: Server is taking too long to respond.');
            console.log('Please try again later.');
        } else {
            console.log(`Unexpected error: ${error.message}`);
        }
        return { success: false, error: error.message };
    }
}

function getHardwareID() {
  const hostname = os.hostname();
  const username = os.userInfo().username || 'unknown';
  const architecture = os.arch();
  const combined = `${hostname}|${username}|${architecture}`;
  return crypto.createHash('sha256').update(combined).digest('hex');
}

function question(query) {
    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout
    });

    return new Promise(resolve => rl.question(query, answer => {
        rl.close();
        resolve(answer);
    }));
}

function questionHidden(query) {
    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout
    });

    return new Promise(resolve => {
        process.stdout.write(query);
        rl.input.on('keypress', (char, key) => {
            if (key && key.name === 'return') {
                process.stdout.write('\\n');
                rl.close();
            } else if (key && key.name !== 'backspace') {
                process.stdout.write('*');
            }
        });
        
        rl.question('', password => {
            resolve(password);
        });
    });
}

async function main() {
    console.log('═════════════════════════════════');
    console.log('      Autholas Login System      ');
    console.log('       NodeJS Example Code       ');
    console.log('═════════════════════════════════');
    
    const username = await question('Username: ');
    const password = await question('Password: '); // Use questionHidden for hidden input
    const hwid = getHardwareID();
    
    console.log(`Device ID: ${hwid.substring(0, 8)}...`); // Show partial HWID for debugging
    
    const result = await authenticateUser(username, password, hwid);
    
    if (result.success) {
        // User authenticated - start your application
        console.log('\nAuthentication successful!');
        console.log('Starting application...');
        // Your app logic here
        startApplication(result.sessionToken);
    } else {
        console.log('\nAuthentication failed.');
        
        // Provide helpful information based on error code
        if (result.errorCode === 'MAX_DEVICES_REACHED') {
            console.log('Tip: Contact support to reset your device limit or login from a previously used device.');
        } else if (result.errorCode === 'HWID_BANNED') {
            console.log('Tip: This specific device has been banned. Try from a different device or contact support.');
        } else if (result.errorCode === 'INVALID_CREDENTIALS') {
            console.log('Tip: Double-check your username and password spelling.');
        }
        
        await question('Press Enter to exit...');
        process.exit(1);
    }
}

function startApplication(sessionToken) {
    // Your application logic here
    console.log('Application started successfully!');
    // Store session token for API calls
    console.log(`Session token: ${sessionToken}`);
}

// Start the application
main().catch(console.error);