Pastry pudding cookie toffee bonbon jujubes jujubes powder topping. Jelly beans gummi bears sweet roll bonbon muffin liquorice. Wafer lollipop sesame snaps. Brownie macaroon cookie muffin cupcake candy caramels tiramisu. Oat cake chocolate cake sweet jelly-o brownie biscuit marzipan. Jujubes donut marzipan chocolate bar. Jujubes sugar plum jelly beans tiramisu icing cheesecake.

Sweet pie candy jelly. Sesame snaps biscuit sugar plum. Sweet roll topping fruitcake. Caramels liquorice biscuit ice cream fruitcake cotton candy tart. Donut caramels gingerbread jelly-o gingerbread pudding. Gummi bears pastry marshmallow candy canes pie. Pie apple pie carrot cake.

Pastry pudding cookie toffee bonbon jujubes jujubes powder topping. Jelly beans gummi bears sweet roll bonbon muffin liquorice. Wafer lollipop sesame snaps. Brownie macaroon cookie muffin cupcake candy caramels tiramisu. Oat cake chocolate cake sweet jelly-o brownie biscuit marzipan. Jujubes donut marzipan chocolate bar. Jujubes sugar plum jelly beans tiramisu icing cheesecake.

Sweet pie candy jelly. Sesame snaps biscuit sugar plum. Sweet roll topping fruitcake. Caramels liquorice biscuit ice cream fruitcake cotton candy tart. Donut caramels gingerbread jelly-o gingerbread pudding. Gummi bears pastry marshmallow candy canes pie. Pie apple pie carrot cake.

Pastry pudding cookie toffee bonbon jujubes jujubes powder topping. Jelly beans gummi bears sweet roll bonbon muffin liquorice. Wafer lollipop sesame snaps. Brownie macaroon cookie muffin cupcake candy caramels tiramisu. Oat cake chocolate cake sweet jelly-o brownie biscuit marzipan. Jujubes donut marzipan chocolate bar. Jujubes sugar plum jelly beans tiramisu icing cheesecake.

Sweet pie candy jelly. Sesame snaps biscuit sugar plum. Sweet roll topping fruitcake. Caramels liquorice biscuit ice cream fruitcake cotton candy tart. Donut caramels gingerbread jelly-o gingerbread pudding. Gummi bears pastry marshmallow candy canes pie. Pie apple pie carrot cake.

Geração dos números aleatórios

A função dos números nesse serviço é de extrema importância. São utilizados em vários lugares, como na geração de chaves de segurança (tokens), em procedimentos criptográficos, na geração dos números das cartelas e a sequência vencedora do Bingo. Dada sua importância, é necessário que os números sejam gerados de maneira aleatória e não determinística.

O sistema utiliza um serviço TRNG (implementado em C e Assembly X86) para geração dos números das cartelas e da sequência final. O serviço está em conformidade com as especificações SP800-90A, SP800-90B e SP800-90C do NIST.

Uma breve explicação sobre os termos

Coisas que fazem números aleatórios são genericamente chamadas de Geradores de Números Aleatórios (RNGs). Eles se enquadram em dois tipos principais:

• Geradores de Números Pseudo-aleatórios (PRNGs)
• Geradores de Números Aleatórios Verdadeiros (TRNGs)

Infelizmente, TRNG é um termo que não está bem definido. É interpretado de maneiras diferentes por pessoas diferentes na indústria e no meio acadêmico.

PRNGs são algoritmos determinísticos que geram uma sequência de números de "aparência aleatória". No entanto, dadas as mesmas condições iniciais, um PRNG sempre dará a mesma sequência. Daí o nome "Pseudo-Random" Number Generator (PRNG).

TRNGs são sistemas não determinísticos. Eles inevitavelmente requerem um componente de hardware para detectar "ruído" ou "entropia" no ambiente que pode ser transformado em números não determinísticos. Como um algoritmo de computador segue um conjunto fixo de instruções, é impossível escrever um algoritmo gerador de número aleatório não determinístico que funcione isoladamente. Você deve ter um componente de hardware físico para passar uma fonte não determinística de dados para o sistema para formar o que costuma ser chamado de TRNG (True Random Number Generator).

Algumas CPUs oferecem RNGs integrados. Algumas plataformas incluem RNGs que são acessíveis pela CPU. Algumas linguagens oferecem maneiras de acessar RNGs e alguns sistemas operacionais oferecem interfaces de API ou interfaces de sistema de arquivos para acessar os RNGs.

Por motivos de segurança esse serviço utiliza 4 meios distintos para geração de números aleatórios. São eles:

• Syscall getrandom() do Linux;
• Serviços /dev/random e /dev/urandom dos sistemas Unix e Linux;
• Instruções RDRAND e RDSEED do CPU;
• Python Random Library;

Lógica aplicada ao sistema do Bingo

O sistema utiliza como fonte principal na geração de números aleatórios um serviço TRNG que interage diretamente com a API e com o Core.

Como meio de geração principal são utilizados as instruções RDRAND e RDSEED providas pelo processador para geração dos números. Caso haja alguma falha durante a execução das instruções pelo processador então os números passam a ser gerados pela syscall getrandom() do Linux.

Caso o serviço de geração de números do Bingo falhe por completo, então o sistema passa a gerar os números por meio das bibliotecas Random presente no Python até que o serviço seja restaurado.

Um pequeno aprofundamento

RDRAND e RDSEED

Esse é o meio principal de geração de números (TRNG) do sistema. Esse método também está em conformidade com as específicações NIST SP800-90.

As instruções RDRAND e RDSEED estão disponíveis em CPUs Intel X86 e CPUs AMD recentes. Os RNGs físicos subjacentes nas CPUs Intel e AMD não são os mesmos, mas ambos afirmam estar em conformidade com o SP800-90.

As três especificações SP800-90 (SP800-90A, SP800-90B e SP800-90C) são as especificações do NIST (Instituto Nacional de Padrões e Tecnologia dos Estados Unidos).

O exemplo C abaixo, primeiro verifica o suporte de RDRAND e, em seguida, busca 32 números aleatórios de 64 bits. Ele usa um limite de 10 tentativas, consistente com as diretrizes do Intel® Digital Random Number Generator (DRNG) Software Implementation Guide.

/* Gera SIZE números aleatórios (0-90) utilizando a instrução RDRAND */
#include <stdio.h>
#include <stdint.>
#include "rdrand.h"

#define SIZE 32

int main(void) {
    
    uint64_t buffer[SIZE];
    int i = 0;
    int m, v;
    
    if(rdrand_check_support() == 1) {
        for(i = 0; i < SIZE; i++) {
            
            /* a função "rdrand_get_uint64_retry" executa a instrução RDRAND com um
             * destino de 64 bits dentro de um loop de repetição para iterações 
             * de até 10 tentativas (seguindo recomendação do tópico 5.2.1 do
             * Intel® Digital Random Number Generator (DRNG) Software Implementation Guide).
             *
             * Os dados resultantes são gravados no local apontado pelo segundo parâmetro.
             */
            rdrand_get_uint64_retry(10, &buffer[i]);
        }

        for(i = 0; i < SIZE; i++) {
            v = (int) buffer[i] % (90 + 1);
            m = v >> sizeof(int) * __CHAR_BIT__ - 1;
            printf("%d ", (v  + m) ^ m);
        }
    } else {
        printf("RDRAND instruction not supported.\n");
        return 1;
    }

    puts("");
    return 0;
}

A função rdrand_get_uint64_retry funciona como um wrapper para rdrand64_step. A rotina utilizada para invocar a RDRAND pode ser encontrada à seguir (trecho extraído do código original):

/****************************************************/
/* Reúne 64 bits de entropia por meio da RDRAND     */
/*  Grava essa entropia em *therand.                   */
/*   Retorna 1 em caso de sucesso ou 0 em underflow */
/****************************************************/

int rdrand64_step(uint64_t *therand) {
        
    uint64_t foo;
    int cf_error_status;

    asm("\n\
            rdrand %%rax;\n\
            mov $1,%%edx;\n\
            cmovae %%rax,%%rdx;\n\
            mov %%edx,%1;\n\
            mov %%rax, %0;":"=r"(foo),"=r"(cf_error_status)::"%rax","%rdx");
            *therand = foo;

    return cf_error_status;
}

Linux getrandom() Syscall

Essa é uma solução alternativa caso as funções RDRAND/RDSEED falhem.

O kernel do sistema operacional Linux possuí suporte a syscall getrandom() desde as versões de kernel 3.17. A glibc também oferece suporte à interface de funções desde a versão 2.25.

O exemplo a baixo demonstra o funcionamento e o uso da syscall por meio da linguagem C.

/* Compilado com GCC */
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <syscall.h>
#include <errno.h>
#include <linux/random.h>

int main(void) {
    
    unsigned char buffer[64];
    int i;
    int result;

    result = syscall(SYS_getrandom, buffer, 64, 0);
    
    if(result > 0) {
        printf ("%d bytes retornados\n" , result);
        for (i =0; i < result ; i ++) {
            printf("%02x", buffer[i]);
            if((i > 0) && (((i +1) % 4) == 0)) printf("\n");
        }
        if((i % 4) != 0) printf("\n");
    } else {
        printf("Error: getrandom() retornou %d\n" , errno);
        return -1;
    }

    return 0;
}

/dev/random e /dev/urandom

Esse é um método alternativo ao da Syscall demonstrado acima.

Sistemas operacionais baseados em Unix, como SysV Unix, Linux e MacOSX, todos fornecem acesso a um software RNG baseado em sistema operacional. Esse acesso é feito por meio de dois arquivos sintéticos em /dev/random e /dev/urandom e uma interface IOCTL API.

O código abaixo usa as chamadas padrão open() e read() dos sistemas unix para acessar /dev/urandom.

/* Compilado com GCC */
#include <stdio.h>
#include <stdint.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(void) {

    uint32_t buffer[64];
    int f;
    int result;
    int i;

    f = open("/dev/urandom", O_RDONLY);
    if(f < 0) {
        fprintf(stderr, "Error: Falha ao abrir /dev/urandom.\n");
        return -1;
    }

    result = read(f, buffer, 64 * sizeof(uint32_t));

    if(result < 0) {
        fprintf(stderr, "Error: Falha ao ler %lu bytes\n", 64 * sizeof(uint32_t));
        return -1;
    }

    for(i = 0; i < 64; i++) {
        printf("%08x\n", buffer[i]);
    }

    return 0;
}

Python Random Library

Esse é um método alternativo ao da Syscall demonstrado acima.

O Python fornece uma classe Random, que fornece uma ampla variedade de métodos para semear e executar PRNGs e retornar dados em várias formas, incluindo ponto flutuante, inteiros limitados e strings de bits.

Além da classe Random básica, há uma subclasse SystemRandom, que fornece os mesmos métodos, mas fornece dados do serviço de números aleatórios do sistema operacional. Fornecendo uma solução adequada para acessar os serviçoes de números aleatórios do sistema operacional (Windows ou Linux).

import random

r = random.SystemRandom()

for i in range(5):
    key = r.getrandbits(256)
    print(f'{key:064x}')