Lo scopo di questa sfida è trovare un'implementazione incredibilmente breve della seguente funzione p, nella lingua che hai scelto. Ecco il codice C che lo implementa (vedi questo link TIO che stampa anche i suoi output) e una pagina di Wikipedia che lo contiene.

unsigned char pi[] = {
    252,238,221,17,207,110,49,22,251,196,250,218,35,197,4,77,
    233,119,240,219,147,46,153,186,23,54,241,187,20,205,95,193,
    249,24,101,90,226,92,239,33,129,28,60,66,139,1,142,79,
    5,132,2,174,227,106,143,160,6,11,237,152,127,212,211,31,
    235,52,44,81,234,200,72,171,242,42,104,162,253,58,206,204,
    181,112,14,86,8,12,118,18,191,114,19,71,156,183,93,135,
    21,161,150,41,16,123,154,199,243,145,120,111,157,158,178,177,
    50,117,25,61,255,53,138,126,109,84,198,128,195,189,13,87,
    223,245,36,169,62,168,67,201,215,121,214,246,124,34,185,3,
    224,15,236,222,122,148,176,188,220,232,40,80,78,51,10,74,
    167,151,96,115,30,0,98,68,26,184,56,130,100,159,38,65,
    173,69,70,146,39,94,85,47,140,163,165,125,105,213,149,59,
    7,88,179,64,134,172,29,247,48,55,107,228,136,217,231,137,
    225,27,131,73,76,63,248,254,141,83,170,144,202,216,133,97,
    32,113,103,164,45,43,9,91,203,155,37,208,190,229,108,82,
    89,166,116,210,230,244,180,192,209,102,175,194,57,75,99,182,
};

unsigned char p(unsigned char x) {
     return pi[x];
}

Cosa è `p`

pè un componente di due standard crittografici russi, vale a dire la funzione hash Streebog e la cifra di blocchi Kuznyechik . In questo articolo (e durante le riunioni ISO), i progettisti di questi algoritmi hanno affermato di aver generato l'arraypi selezionando permutazioni casuali a 8 bit.

Implementazioni "impossibili"

Ce ne sono $256! \approx 2^{1684}$ permutazioni su 8 bit. Pertanto, per una determinata permutazione casuale, non è previsto che un programma che lo implementa abbia bisogno di meno di 1683 bit.

Tuttavia, abbiamo trovato più implementazioni anormalmente piccole (che elenchiamo qui ), ad esempio il seguente programma C:

p(x){unsigned char*k="@`rFTDVbpPBvdtfR@\xacp?\xe2>4\xa6\xe9{z\xe3q5\xa7\xe8",l=0,b=17;while(--l&&x^1)x=2*x^x/128*285;return l%b?k[l%b]^k[b+l/b]^b:k[l/b]^188;}

che contiene solo 158 caratteri e si adatta quindi a 1264 bit. Clicca qui per vedere che funziona.

Parliamo di un'implementazione breve "impossibile" perché, se la permutazione fosse l'output di un processo casuale (come affermato dai suoi progettisti), allora un programma così corto non esisterebbe (vedi questa pagina per maggiori dettagli).

Implementazione di riferimento

Una versione più leggibile del precedente codice C è:

unsigned char p(unsigned char x){
     unsigned char
         s[]={1,221,146,79,147,153,11,68,214,215,78,220,152,10,69},
         k[]={0,32,50,6,20,4,22,34,48,16,2,54,36,52,38,18,0};
     if(x != 0) {
         unsigned char l=1, a=2;
         while(a!=x) {
             a=(a<<1)^(a>>7)*29;
             l++;
         }
         unsigned char i = l % 17, j = l / 17;
         if (i != 0) return 252^k[i]^s[j];
         else return 252^k[j];
     }
     else return 252;
}

La tabella kè tale che k[x] = L(16-x), dove Lè lineare nel senso che L(x^y)==L(x)^L(y), e dove, come in C, ^indica lo XOR. Tuttavia, non siamo riusciti a sfruttare questa proprietà per abbreviare la nostra implementazione. Non siamo a conoscenza di alcuna struttura in sgrado di consentire un'implementazione più semplice --- il suo output è sempre nel sottocampo, cioè $s[x]^{16}=s[x]$ dove l'espiazione è fatta nel campo finito. Certo, sei assolutamente libero di usare un'espressione più semplice dis dovessi trovarne una!

Il ciclo while corrisponde alla valutazione di un logaritmo discreto nel campo finito con 256 elementi. Funziona tramite una semplice ricerca della forza bruta: la variabile fittizia aè impostata per essere un generatore del campo finito, e viene moltiplicata per questo generatore fino a quando il risultato è uguale x. Quando è il caso, abbiamo quello lè il registro discreto di x. Questa funzione non è definita in 0, quindi il caso speciale corrispondente ifall'istruzione.

La moltiplicazione per il generatore può essere vista come una moltiplicazione per $X$ in che viene quindi ridotta nel modulo polinomiale . Il ruolo di è assicurarsi che la variabile rimanga su 8 bit. In alternativa, potremmo usare , nel qual caso potrebbe essere un (o qualsiasi altro tipo intero). D'altra parte, è necessario iniziare come abbiamo bisogno quando è uguale a 1. $\mathbb{F}_2[X]$ $X^8+X^4+X^3+X^2+1$ unsigned charaa=(a<<1)^(a>>7)*(256^29)aintl=1,a=2l=255x

Maggiori dettagli sulle proprietà di psono presentati nel nostro documento , con un riepilogo della maggior parte delle nostre ottimizzazioni per ottenere la precedente implementazione breve.

Regole

Propone un programma che implementa la funzione pin meno di 1683 bit. Poiché più breve è il programma, più è anormale, per una determinata lingua, più breve è meglio. Se la tua lingua sembra avere Kuznyechik, Streebog op come incorporato, non puoi usarli.

La metrica che utilizziamo per determinare la migliore implementazione è la lunghezza del programma in byte. Usiamo la lunghezza in bit nel nostro documento accademico ma ci atteniamo ai byte qui per motivi di semplicità.

Se la tua lingua non ha una chiara nozione di funzione, argomento o output, la codifica dipende da te definire, ma trucchi come codificare il valore pi[x]comex sono ovviamente proibito.

Abbiamo già presentato un documento di ricerca con i nostri risultati su questo argomento. È disponibile qui . Tuttavia, qualora fosse pubblicato in una sede scientifica, saremo lieti di riconoscere gli autori delle migliori implementazioni.

A proposito, grazie a xnor per il suo aiuto durante la stesura di questa domanda!

— picarresursix
fonte

12

Spero che qualcuno invii una risposta in Seed.

— Robin Ryder,

6

Allo stesso modo, ad esempio, è possibile ottenere un codice di Brainfuck a 3 bit per carattere se non ha nops? Ed è 1683 bits at mostuna stretta restrizione [sic?] O l'obiettivo?

— qualcuno il

31

" Se la permutazione fosse l'output di un processo casuale (come affermato dai suoi progettisti), allora un programma così corto non esisterebbe " Non sono d'accordo (anche se non importa per la sfida). Se fosse l'output di un processo casuale, sarebbe improbabile che esistesse tale programma; o sarebbe difficile da trovare

— Luis Mendo il

8

@Grimy L'affermazione quindi che un programma così breve non esisterebbe è concettuale (non programmatica). Usando i termini, appartiene al mondo della matematica pura, non al mondo della programmazione

— Luis Mendo,

7

Potrebbe essere già stato notato, ma per ogni evenienza:

produce solo 8 valori distinti:

(a partire da

e assumendo

).

s_{i} XOR s_{i - 1}

$s_i \text{ XOR } s_{i-1}$

1, 10, 68, 79, 146, 153, 220, 221

$1,10,68,79,146,153,220,221$

i = 1

$i=1$

s_{0} = 0

$s_0=0$

— Arnauld

35

Assemblaggio AMD64 (78 byte o 624 bit di codice macchina)

uint8_t SubByte (uint8_t x) {
    uint8_t y, z;
    uint8_t s [] =
      {} 1,221,146,79,147,153,11,68,214,215,78,220,152,10,69;

    uint8_t k [] =
      {} 0,32,50,6,20,4,22,34,48,16,2,54,36,52,38,18,0;

    se (x) {
      per (y = z = 1; (y = (y << 1) ^ ((y >> 7) * 29))! = x; z ++);
      x = (z% 17);
      z = (z / 17);
      x = (x)? k [x] ^ s [z]: k [z];
    }
    ritorna x ^ 252;
}

Assembly x86 a 64 bit

    ; 78 byte di assembly AMD64
    ; odzhan
    bit 64

    % ifndef BIN
      SubBytex globale
    %finisci se

SubBytex:
    mov al, 252
    jecxz L2; se (x) {
    chiama L0
K:
    db 0xfc, 0xdc, 0xce, 0xfa, 0xe8, 0xf8, 0xea, 0xde, 
    db 0xcc, 0xec, 0xfe, 0xca, 0xd8, 0xc8, 0xda, 0xee, 0xfc
S:
    db 0x01, 0xdd, 0x92, 0x4f, 0x93, 0x99, 0x0b, 0x44, 
    db 0xd6, 0xd7, 0x4e, 0xdc, 0x98, 0x0a, 0x45
L0:
    pop rbx
    mov al, 1; y = 1
    cdq; z = 0
L1:
    inc dl; z ++
    aggiungi al, al; y = y + y
    jnc $ + 4; salta XOR se non lo porti
    xor al, 29;
    cmp al, cl; se (y! = x) vai a L1
    jne L1    

    xchg eax, edx; eax = z
    cdq; edx = 0
    mov cl, 17; al = z / 17, dl = z% 17
    div ecx

    mov cl, [rbx + rax + 17]; cl = s [z]
    xlatb; al = k [z]
    test dl, dl; se (x == 0) vai a L2
    jz L2
    xchg eax, edx; al = x
    xlatb; al = k [x]
    xor al, cl; al ^ = s [z]
L2:
    macerare

Codice a 64 bit smontato

00000000 B0FC mov al, 0xfc
00000002 67E348 jecxz 0x4d
00000005 E820000000 chiama qword 0x2a
; k [] = 0xfc, 0xdc, 0xce, 0xfa, 0xe8, 0xf8, 0xea, 0xde,
; 0xcc, 0xec, 0xfe, 0xca, 0xd8, 0xc8, 0xda, 0xee, 0xfc
; s [] = 0x01, 0xdd, 0x92, 0x4f, 0x93, 0x99, 0x0b, 0x44,
; 0xd6, 0xd7, 0x4e, 0xdc, 0x98, 0x0a, 0x45
0000002A 5B pop rbx
0000002B B001 mov al, 0x1
0000002D 99 cdq
0000002E FEC2 inc dl
00000030 00C0 aggiungi al, al
00000032 7302 jnc 0x36
00000034 341D xor al, 0x1d
00000036 38C8 cmp al, cl
00000038 75F4 jnz 0x2e
0000003A 92 xchg eax, edx
0000003B 99 cdq
0000003C B111 mov cl, 0x11
0000003E F7F1 div ecx
00000040 8A4C0311 mov cl, [rbx + rax + 0x11]
00000044 D7 xlatb
00000045 84D2 test dl, dl
00000047 7404 jz 0x4d
00000049 92 xchg eax, edx
0000004A D7 xlatb
0000004B 30C8 xo al, cl
0000004D C3 ret

Assembly x86 a 32 bit

    ; 72 byte di assembly x86
    ; odzhan
    bit 32

    % ifndef BIN
      SubBytex globale
      globale _SubBytex
    %finisci se

SubBytex:
_SubBytex:
    mov al, 252
    jecxz L2; se (x) {
    chiama L0
K:
    db 0xfc, 0xdc, 0xce, 0xfa, 0xe8, 0xf8, 0xea, 0xde, 
    db 0xcc, 0xec, 0xfe, 0xca, 0xd8, 0xc8, 0xda, 0xee, 0xfc
S:
    db 0x01, 0xdd, 0x92, 0x4f, 0x93, 0x99, 0x0b, 0x44, 
    db 0xd6, 0xd7, 0x4e, 0xdc, 0x98, 0x0a, 0x45
L0:
    pop ebx
    mov al, 1; y = 1
    cdq; z = 0
L1:
    inc edx; z ++
    aggiungi al, al; y = y + y
    jnc $ + 4; salta XOR se non lo porti
    xor al, 29;
    cmp al, cl; se (y! = x) vai a L1
    jne L1    
    xchg eax, edx; al = z
    aam 17; al | x = z% 17, ah | z = z / 17
    mov cl, ah; cl = z
    cmove eax, ecx; if (x == 0) al = z else al = x
    xlatb; al = k [z] o k [x]
    jz L2; se (x == 0) vai a L2
    xor al, [ebx + ecx + 17]; k [x] ^ = k [z]
L2:
    macerare

Codice a 32 bit smontato

00000000 B0FC mov al, 0xfc
00000002 E345 jecxz 0x49
00000004 E820000000 call dword 0x29
; k [] = 0xfc, 0xdc, 0xce, 0xfa, 0xe8, 0xf8, 0xea, 0xde,
; 0xcc, 0xec, 0xfe, 0xca, 0xd8, 0xc8, 0xda, 0xee, 0xfc
; s [] = 0x01, 0xdd, 0x92, 0x4f, 0x93, 0x99, 0x0b, 0x44,
; 0xd6, 0xd7, 0x4e, 0xdc, 0x98, 0x0a, 0x45
00000029 5B pop ebx
0000002A B001 mov al, 0x1
0000002C 99 cdq
0000002D 42 inc edx
0000002E 00C0 aggiungi al, al
00000030 7302 jnc 0x34
00000032 341D xor al, 0x1d
00000034 38C8 cmp al, cl
00000036 75F5 jnz 0x2d
00000038 92 xchg eax, edx
00000039 D411 aam 0x11
0000003B 88E1 mov cl, ah
0000003D 0F44C1 cmovz eax, ecx
00000040 D7 xlatb
00000041 7404 jz 0x47
00000043 32440B11 xor al, [ebx + ecx + 0x11]
00000047 C3 ret

— odzhan
fonte

1

Bella risposta! Dato che l'OP stava cercando il conteggio dei bit, questo (85 byte) risulta a 680 bit , usando 8 bit per byte o 595 bit usando 7 bit per byte (possibile poiché tutti i caratteri sono ASCII). Probabilmente potresti andare più breve se compresso in un set di caratteri ancora più restrittivo.

— Cullub

1

Benvenuti in PPCG; bella prima soluzione.

— Shaggy

9

@Cullub Il mio punto era che il codice in questa risposta è solo C / Assembler che viene compilato, quindi il conteggio dei byte non è quello del codice dato, ma del codice compilato. E questo non è ASCII.

— ArBo

7

Solo per chiarimento, gli 84 byte è la dimensione del codice macchina dopo che questo è stato assemblato? In tal caso, il titolo deve essere aggiornato per riflettere che si tratta di una risposta del codice macchina piuttosto che di una risposta dell'assieme.

— Potato44

1

E a proposito, non è necessario utilizzare una convenzione di chiamata standard; puoi usare una convenzione personalizzata in cui RBX è chiamato clobber, salvando 2 byte per push / pop. (E dove gli uint8_targ sono estesi da zero a 64 bit per JRCXZ). Inoltre, se si scrive un codice dipendente dalla posizione, è possibile inserire l'indirizzo della tabella in un registro con un 5 byte mov ebx, imm32anziché un 6 byte call/ pop. Oppure usalo come disp32in mov al, [table + rax], ma ciò potrebbe perdere poiché ne hai già due xlatbe uno mov. Tuttavia, il trucco call + pop shellcode vince contro LEA relativo a RIP a 7 byte con i dati dopo il ret, però.

— Peter Cordes,

23

CJam ,72 67 66 63 byte

ri{_2md142*^}es*]2#~Hmd{5\}e|Fm2b"Ý0$&Ü™ÖD�’
˜×EO“N".*Lts:^i

es* ripete qualcosa in base al timestamp corrente, che è un numero elevato, e impiegherebbe troppo tempo per terminare.

Versione attualmente testabile, 64 byte:

ri{_2md142*^}256*]2#~Hmd{5\}e|Fm2b"Ý0$&Ü™ÖD�’
˜×EO“N".*Lts:^i

00000000: 7269 7b5f 326d 6431 3432 2a5e 7d32 3536  ri{_2md142*^}256
00000010: 2a5d 3223 7e48 6d64 7b35 5c7d 657c 466d  *]2#~Hmd{5\}e|Fm
00000020: 3262 22dd 3024 2612 dc99 d644 0092 0b0a  2b".0$&....D....
00000030: 98d7 454f 934e 0122 2e2a 4c74 733a 5e69  ..EO.N.".*Lts:^i

Dimostrando che uno standard crittografico russo è troppo strutturato

Cosa è p

Implementazioni "impossibili"

Implementazione di riferimento

Regole

Assemblaggio AMD64 (78 byte o 624 bit di codice macchina)

Assembly x86 a 64 bit

Codice a 64 bit smontato

Assembly x86 a 32 bit

Codice a 32 bit smontato

CJam ,72 67 66 63 byte

Spiegazione

Gelatina 71 59 byte

Spiegazione

Approccio originale

Gelatina , 71 66 byte

Spiegazione

C (gcc) , 157 148 140 139 byte

C (gcc) , 150 142 127 126 byte

05AB1E , 101 100 98 97 95 94 byte

Stax , 65 64 62 59 58 byte

Python 3 , 151 byte

JavaScript (ES6), 139 byte

JavaScript (Node.js) , 149 148 byte

Codifica

SSs

C # (compilatore interattivo Visual C #) , 141 byte

Python 3 , 182 byte

Python 3 , 176 byte

Python 3 , 173 byte

Ruggine , 170 163 byte

05AB1E , 74 byte

Cosa è `p`

$s$