forex-scalping.com

Code: Select all

import os
import secrets
import numpy as np

def generate_secure_bytes(size_in_bytes):
    """
    Fills a mutable bytearray in operating memory with highly secure, 
    OS-generated random bytes.
    """
    # os.urandom pulls from the OS hardware entropy pool
    # bytearray ensures it stays in a mutable, efficient memory array
    return bytearray(os.urandom(size_in_bytes))

def generate_secure_integers(count, max_value):
    """
    Generates an array of secure random integers using the secrets module.
    Slower than os.urandom, but easier to use for specific integer ranges.
    """
    return [secrets.randbelow(max_value) for _ in range(count)]

# --- Example Usage ---

# 1. Generate 1 Megabyte of purely random data into memory
megabyte_array = generate_secure_bytes(1024 * 1024)
print(f"Generated {len(megabyte_array)} bytes of secure entropy.")

# 2. If you need a mathematical array (like NumPy) of random floats (0.0 to 1.0)
# We can securely convert random bytes into NumPy floats
def generate_secure_numpy_floats(count):
    # Get random bytes (8 bytes per 64-bit float)
    random_bytes = os.urandom(count * 8)
    # Convert bytes to 64-bit unsigned integers
    random_ints = np.frombuffer(random_bytes, dtype=np.uint64)
    # Divide by the maximum 64-bit integer value to get a float between 0 and 1
    return random_ints / (2**64 - 1)

secure_floats = generate_secure_numpy_floats(100)
print(f"First 3 secure floats: {secure_floats[:3]}")

Code: Select all

import requests
import numpy as np

def get_quantum_random_numbers(count):
    """
    Fetches strictly True Random Numbers generated by quantum vacuum 
    fluctuations from the ANU Quantum Random Number Generator.
    """
    if count > 1024:
        raise ValueError("ANU API allows a maximum of 1024 numbers per request.")
        
    url = f"https://qrng.anu.edu.au/API/jsonI.php?length={count}&type=uint16"
    
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        data = response.json()
        
        if data.get('success'):
            # Load directly into a numpy operating memory array
            return np.array(data['data'], dtype=np.uint16)
        else:
            raise Exception("API returned an unsuccessful response.")
            
    except requests.RequestException as e:
        print(f"Failed to fetch quantum numbers: {e}")
        return None

# --- Example Usage ---

# Fetch 10 true quantum random integers
quantum_array = get_quantum_random_numbers(10)

if quantum_array is not None:
    print(f"Quantum Random Array: {quantum_array}")
    print(f"Data type in memory: {type(quantum_array)} ({quantum_array.dtype})")

Code: Select all

#include <iostream>
#include <vector>
#include <random>
#include <algorithm>
#include <chrono>

// Fills an operating memory array with true random unsigned 32-bit integers
std::vector<uint32_t> generate_secure_array(size_t num_elements) {
    // std::random_device requests non-deterministic entropy from the OS
    std::random_device hardware_entropy;
    
    // Allocate the memory array
    std::vector<uint32_t> memory_array(num_elements);
    
    // Fill the array directly using the hardware entropy generator
    std::generate(memory_array.begin(), memory_array.end(), std::ref(hardware_entropy));
    
    return memory_array;
}

int main() {
    size_t array_size = 1000000; // 1 million elements (~4 Megabytes)
    
    std::cout << "Allocating and filling memory array..." << std::endl;
    
    auto start = std::chrono::high_resolution_clock::now();
    std::vector<uint32_t> true_random_array = generate_secure_array(array_size);
    auto end = std::chrono::high_resolution_clock::now();
    
    std::chrono::duration<double> duration = end - start;
    
    std::cout << "Filled " << true_random_array.size() << " integers in " 
              << duration.count() << " seconds." << std::endl;
              
    std::cout << "First 3 true random numbers: " << '\n'
              << true_random_array[0] << '\n'
              << true_random_array[1] << '\n'
              << true_random_array[2] << std::endl;

    return 0;
}

Code: Select all

#include <iostream>
#include <vector>
#include <immintrin.h> // Required for hardware intrinsics (RDRAND)

std::vector<uint64_t> generate_cpu_hardware_entropy(size_t num_elements) {
    std::vector<uint64_t> memory_array;
    memory_array.reserve(num_elements);

    for (size_t i = 0; i < num_elements; ++i) {
        unsigned long long random_value;
        
        // _rdrand64_step directly queries the CPU's hardware random number generator.
        // It returns 1 if successful, and 0 if the hardware entropy pool is temporarily exhausted.
        int success = 0;
        int retries = 10; // Prevent infinite loop if hardware fails
        
        while (success == 0 && retries > 0) {
            success = _rdrand64_step(&random_value);
            retries--;
        }
        
        if (success == 1) {
            memory_array.push_back(random_value);
        } else {
            std::cerr << "CRITICAL: CPU Hardware entropy pool exhausted!" << std::endl;
            break;
        }
    }
    
    return memory_array;
}

int main() {
    size_t array_size = 10;
    
    std::vector<uint64_t> bare_metal_array = generate_cpu_hardware_entropy(array_size);
    
    std::cout << "Direct CPU Silicon Random Numbers (64-bit):" << std::endl;
    for (size_t i = 0; i < bare_metal_array.size(); ++i) {
        std::cout << bare_metal_array[i] << std::endl;
    }

    return 0;
}

Code: Select all

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

// Platform-specific headers
#ifdef _WIN32
    #include <windows.h>
    #include <bcrypt.h>
    #pragma comment(lib, "bcrypt.lib") // Required for MSVC linker
#else
    #include <fcntl.h>
    #include <unistd.h>
#endif

/*
 * Allocates and fills a memory array with cryptographically secure random integers.
 * Returns 0 on success, -1 on failure.
 */
int fill_secure_random_array(uint32_t *array, size_t num_elements) {
    size_t bytes_to_read = num_elements * sizeof(uint32_t);

#ifdef _WIN32
    // Windows: Use the modern CNG API (System Preferred RNG)
    NTSTATUS status = BCryptGenRandom(NULL, (PUCHAR)array, (ULONG)bytes_to_read, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
    if (status < 0) {
        return -1;
    }
#else
    // POSIX (Linux/macOS): Read directly from the OS hardware entropy pool
    int fd = open("/dev/urandom", O_RDONLY);
    if (fd < 0) {
        return -1;
    }
    
    size_t total_read = 0;
    while (total_read < bytes_to_read) {
        ssize_t result = read(fd, ((char*)array) + total_read, bytes_to_read - total_read);
        if (result < 0) {
            close(fd);
            return -1;
        }
        total_read += result;
    }
    close(fd);
#endif

    return 0;
}

int main() {
    size_t array_size = 1000000; // 1 million elements
    
    // Allocate the operating memory array on the heap
    uint32_t *secure_array = (uint32_t *)malloc(array_size * sizeof(uint32_t));
    if (secure_array == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    printf("Filling memory array with OS-level entropy...\n");
    
    if (fill_secure_random_array(secure_array, array_size) == 0) {
        printf("Successfully generated %zu secure random integers.\n", array_size);
        printf("First 3 numbers:\n%u\n%u\n%u\n", 
               secure_array[0], secure_array[1], secure_array[2]);
    } else {
        printf("Failed to generate random numbers.\n");
    }

    // Always free heap memory in C
    free(secure_array);
    return 0;
}

Code: Select all

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <immintrin.h> // Header for x86 hardware intrinsics

/*
 * Fills an array using direct CPU silicon quantum/thermal fluctuations.
 * Returns 0 on success, -1 on hardware exhaustion.
 */
int fill_hardware_random_array(uint64_t *array, size_t num_elements) {
    for (size_t i = 0; i < num_elements; i++) {
        unsigned long long rand_val;
        int success = 0;
        int retries = 10; // The hardware pool can temporarily empty out
        
        // Query the CPU directly
        while (success == 0 && retries > 0) {
            success = _rdrand64_step(&rand_val);
            retries--;
        }
        
        if (success == 1) {
            array[i] = (uint64_t)rand_val;
        } else {
            // If the hardware entropy pool is exhausted and doesn't recover
            return -1; 
        }
    }
    return 0;
}

int main() {
    size_t array_size = 5;
    
    // Allocate memory array
    uint64_t *hardware_array = (uint64_t *)malloc(array_size * sizeof(uint64_t));
    if (hardware_array == NULL) return 1;

    printf("Querying CPU hardware for pure entropy...\n");
    
    if (fill_hardware_random_array(hardware_array, array_size) == 0) {
        for (size_t i = 0; i < array_size; i++) {
            printf("Hardware TRNG [%zu]: %llu\n", i, (unsigned long long)hardware_array[i]);
        }
    } else {
        printf("CRITICAL: CPU hardware entropy generator failed.\n");
    }

    free(hardware_array);
    return 0;
}