La sfida

Vi presento un'altra sfida spia contro spia che mette gli offuscatori contro i cracker. In questo caso, tuttavia, il dato da proteggere non è un input ma un output .

Le regole della sfida sono semplici. Scrivi una routine con le seguenti specifiche:

1. La routine può essere scritta in qualsiasi lingua ma non può superare i 320 byte.
2. La routine deve accettare tre numeri interi con segno a 32 bit come input. Può assumere la forma di una funzione che accetta 3 argomenti, una funzione che accetta un singolo array di 3 elementi o un programma completo che legge 3 numeri interi da qualsiasi input standard.
3. La routine deve generare un intero a 32 bit con segno.
4. Su tutti i possibili input, la routine deve produrre tra 2 e 1000 valori univoci (inclusi). Il numero di valori univoci che una routine può generare è chiamato chiave .

Ad esempio, il programma C.

int foo( int i1, int i2, int i3 ) {
    return 20 + (i1^i2^i3) %5;
}

ha una chiave di 9, dato che (si spera) può solo emettere i nove valori 16, 17, 18, 19, 20, 21, 22, 23, e 24.

Alcune limitazioni aggiuntive sono le seguenti:

5. La routine deve essere completamente deterministica e invariante nel tempo, restituendo output identici per input identici. La routine non dovrebbe effettuare chiamate a generatori di numeri pseudocasuali.
6. La routine potrebbe non basarsi su "variabili nascoste" come dati in file, variabili di sistema o funzionalità del linguaggio esoterico. Ad esempio, le routine in genere non devono fare riferimento a costanti a meno che le costanti non siano chiaramente definite nel codice stesso. Anche le routine che si basano su stranezze del compilatore, output da operazioni matematicamente indefinite, errori aritmetici, ecc. Sono fortemente scoraggiate. In caso di dubbi, si prega di chiedere.
7. Tu (il programmatore) devi sapere con precisione quanti output unici può produrre la routine e dovresti essere in grado di fornire almeno una sequenza di input che produce ogni output. (Poiché potrebbero esserci centinaia di output univoci, questo set verrà sempre e solo richiesto nel caso in cui la tua chiave venga contestata.)

Poiché questo problema mostra molto meno la somiglianza con la crittografia classica rispetto alla precedente, mi aspetto che sia accessibile a un pubblico più ampio.

Più creativo è, meglio è.

Il punteggio

Il numero più basso di invii non crackati per numero di byte verrà dichiarato vincitore.

In caso di confusione, non esitare a chiedere o commentare.

La contro-sfida

Tutti i lettori, compresi quelli che hanno presentato la propria routine, sono incoraggiati a "infrangere" le richieste. Un invio viene decifrato quando la sua chiave viene pubblicata nella sezione commenti associati. Se un invio persiste per 72 ore senza essere modificato o crackato, viene considerato "sicuro" e qualsiasi successivo successo nel cracking verrà ignorato per motivi di contest.

È consentito un solo tentativo di crack per invio per lettore. Ad esempio, se invio all'utente X: "la tua chiave è 20" e sbaglio, l'utente X declinerà la mia ipotesi come errata e non potrò più inviare ipotesi aggiuntive per tale invio.

Le comunicazioni incrinate vengono eliminate dalla contesa (a condizione che non siano "sicure"). Non dovrebbero essere modificati. Se un lettore desidera presentare una nuova routine, deve farlo in una risposta separata.

Il punteggio di un cracker è il numero di invii (conformi o meno) che cracka. Per i cracker con conteggi identici, la classifica è determinata dal conteggio totale dei byte in tutti gli invii crackati (maggiore è, migliore).

I cracker con il punteggio più alto saranno dichiarati vincitori insieme agli sviluppatori delle routine vincenti.

Si prega di non crackare la propria richiesta.

Buona fortuna. :)

Classifica

Ultimo aggiornamento 2 settembre, 10:45 EST

Barriere immobili (invii non incrinati):

1. CJam, 105 [Dennis]

Forze inarrestabili (cracker):

1. Dennis [ Java, 269 ; C, 58 ; Mathematica, 29 ]
2. Martin Büttner [ Java, 245 ]

CJam, 105 byte

1q~]4G#b2A#md"M-k^XM-WHM-n^GM-0%M-uwM-gM-^XeM-kM-^VO^Ph,M-^MM-^PM-qM-!M-8M-AM-OM-~tM-^FM-cM-h^AM-0M-0M-lM-@M-^[MF=M-^Z^SM-1M-KM-T2M-9M-UmSM-N
M-8M-^^M-n$4M-^M^SM-x M-OM-^@^?"256b@D#Y256#%2+md!A3#*)%)%

Quanto sopra usa il punto di inserimento e la notazione M, poiché contiene caratteri non stampabili. Dopo aver convertito il flusso di byte in un numero intero ( 256b), viene eseguito il seguente codice:

1q~]4G#b2A#md
12313030820310059479144347891900383683119627474072658988524821209446180284434934346766561958060381533656780340359503554566598728599799248566073353154035839
@D#Y256#%2+md!A3#*)%)%

Puoi provare questa versione online nell'interprete CJam .

Come funziona

Questa presentazione usa la teoria dei numeri invece dell'offuscamento. Il programma restituirà 0 per quasi tutti gli ingressi. Dai pochi input che producono un output diverso da zero, viene derivato un modulo segreto che viene applicato ai 10 bit meno significativi del terzo intero.

Il modo più efficiente di risolvere questa sfida (che mi viene in mente) sarebbe quello di fattorizzare l'intero a 512 bit, che spero non sia realizzabile in 72 ore.

" Prepend 1 to the numbers read from STDIN and convert the resulting array into an integer
  (“N”) by considering them digits of a base 2**32 number.                                 ";

1q~]4G#

" Compute “N / 1024” and “N % 1024”.                                                       ";

2A#md

" Push a carefully selected 512 bit semi-prime (“S”).                                      ";

12313030820310059479144347891900383683119627474072658988524821209446180284434934346766561958060381533656780340359503554566598728599799248566073353154035839

" Compute P = (N / 1024) ** 13 % 2 ** 256 + 2.                                             ";

@D#Y256#%2+

" Compute “S / P” and “S % P”.                                                             ";

md

" Compute “M = (S / P) % (1000 * !(S % P) + 1) + 1”.

  “M” is the key if P is a divisor of S; otherwise, “M == 1”.                              ";

!A3#*)%)

" Compute the final output: “N % 1024 % M”.                                                ";

%

Esempio di esecuzione

$ base64 -d > outputs.cjam <<< MXF+XTRHI2IyQSNtZCLrGNdI7gewJfV355hl65ZPEGgsjZDxobjBz/50huPoAbCw7MCbTUY9mhOxy9QyudVtU84KuJ7uJDSNE/ggz4B/IjI1NmJARCNZMjU2IyUyK21kIUEzIyopJSkl
$ wc -c outputs.cjam
105 outputs.cjam
$ LANG=en_US cjam outputs.cjam < outputs.secret; echo
1
$ LANG=en_US cjam outputs.cjam <<< '1 2 3'; echo
0

Java - 269

Grazie per la pazienza di tutti, ora questo dovrebbe essere risolto.

accorciato:

int a(int a,int b,int c){double d=180-360.0/(int)(Math.abs(Math.sin(a*60))*50+2),e=180-360.0/(int)(Math.abs(Math.cos(b*60))*50+2),f=180-360.0/(int)(Math.atan2(c*60, a*60)*51+2);if(Math.abs(d+e+f-360)<.1)return Integer.valueOf((int)d+""+(int)e+""+(int)f);else return 1;}

Non abbreviato:

int a(int a, int b, int c) {
    double d = 180 - 360.0 / (int) (Math.abs(Math.sin(a * 60)) * 50 + 2);
    double e = 180 - 360.0 / (int) (Math.abs(Math.cos(b * 60)) * 50 + 2);
    double f = 180 - 360.0 / (int) (Math.atan2(c * 60, a * 60) * 51 + 2);
    if (Math.abs(d + e + f - 360) < .1)
        return Integer.valueOf((int) d + "" + (int) e + "" + (int) f);
    else
        return 1;
}

Un campionatore

Naturalmente non si tratta di un ingresso ufficiale e il conteggio dei personaggi è troppo alto, ma immagino che se qualcuno vuole una sfida che intorpidisce la mente, può provare a determinare quanti output unici produce la seguente funzione (dati tre input come descritto nel PO) :

function z(y,_,$){M=[];N=[];O=[];C=1792814437;P=72;r=t=0;(f=function(a,k,L){if(k<a.length){for(L=a[k],a[k]=0;a[k]<L;a[k]++)f(a,k+1)}else
if(!t){f([P-1,P-1],0,++t);N=M;while(t<2*P){s=!(t&1);f([P,P,P,P],0,++t);r=r||(s?0:t);t&1&&(N=O);O=[]}}else
((t<2)&&(((d=P*a[0]+(P+1)*a[1]+P)<(P<<6))&&(M[d]=(((y^~_)>>a[0])+((_^~$)>>(a[0]-32)))&1),((a[1]<P-a[0])&&
(M[a[1]+(P+1)*a[0]]=(($^C)>>a[0]+16-a[1])&1))||1))||((t&1)&&((O[P*a[2]+a[3]]|=M[a[1]+P*a[2]]&N[P*a[0]+a[3]]&&
!(a[0]-a[1]))||1))||(s|=N[(a[0]+1)*a[1]+a[3]]);})([],0,0);return r;}

In effetti, sono così fiducioso che sia irrefrenabile, assegnerò a chiunque lo spezzerà il "Supremo inarrestabile Force of Nature Award".

Perché davvero, se lo meritano.

C, 58 byte (crackato)

Semplice:

f(a,b,c){return(long long)a*b*c-0x1d21344f8479d61dLL?0:a;}

Java - 245

Incrinato da Martin Büttner

int a(int[]_$){return $($($_(_$[0],0)))+$_(_$[1],1)*11+$($($_(_$[1+1],0)))*(1+1);}int $_(int $,int $_){int OO=0,o=1,O=1;for($=$<0?-$:$;++O*O<=$;OO+=$%O<1?O:0,o+=$%O<1?1:0,$/=$%O<1?O--:1);return $_>0?o:OO+$;}int $(int $){return(int)Math.sqrt($);}

Alimenta l'input come un array int: a(new int[]{1,2,3}) . Non mi aspetto che durerà 72 ore, ma mi diverto.

Eccolo con le interruzioni di riga, per renderlo un po 'più leggibile:

int a(int[]_$){return $($($_(_$[0],0)))+$_(_$[1],
1)*11+$($($_(_$[1+1],0)))*(1+1);}int $_(int $,int
$_){int OO=0,o=1,O=1;for($=$<0?-$:$;++O*O<=$;OO+=
$%O<1?O:0,o+=$%O<1?1:0,$/=$%O<1?O--:1);return $_>
0?o:OO+$;}int $(int $){return(int)Math.sqrt($);}

Mathematica, 29 byte, chiave: 715, incrinata da Dennis

Questa è solo una versione fissa della mia risposta iniziale, che non ha funzionato per input non positivi.

f=Plus@@Mod[NextPrime@#,240]&

Prende un elenco di numeri interi come

f[{1,2,3}]

207 caratteri, in C / C ++, non ancora offuscato:

int x(int a, int b, int c) {
    int d, e, f;
    for (int i=0; i!=1<<31; ++i) {
        d=10*(b-a);
        e=a*(28-c)-b;
        f=a*b-2.7*c;
        a += d;
        b += e;
        c += f;
    }
    return ((a%5+5)*10+(b%5+5))*10+c%5+5;
}