Wyzwanie

Proste wyzwanie „szpieg kontra szpieg”.

Napisz program o następujących specyfikacjach:

1. Program może być napisany w dowolnym języku, ale nie może przekraczać 512 znaków (przedstawionych w bloku kodu na tej stronie).
2. Program musi zaakceptować 5 podpisanych 32-bitowych liczb całkowitych jako dane wejściowe. Może mieć postać funkcji, która akceptuje 5 argumentów, funkcji, która akceptuje pojedynczą tablicę 5-elementową lub kompletnego programu, który odczytuje 5 liczb całkowitych z dowolnego standardowego wejścia.
3. Program musi wypisać jedną 32-bitową liczbę całkowitą ze znakiem.
4. Program musi zwrócić 1 wtedy i tylko wtedy, gdy pięć wejść, interpretowanych jako sekwencja, odpowiada określonej sekwencji arytmetycznej wybranej przez programistę, zwanej „kluczem”. Funkcja musi zwrócić 0 dla wszystkich innych wejść.

Sekwencja arytmetyczna ma właściwość polegającą na tym, że każdy kolejny element sekwencji jest równy swojemu poprzednikowi plus pewna stała stała a.

Na przykład 25 30 35 40 45jest sekwencją arytmetyczną, ponieważ każdy element sekwencji jest równy swojemu poprzednikowi plus 5. Podobnie 17 10 3 -4 -11jest sekwencją arytmetyczną, ponieważ każdy element jest równy jego poprzednikowi plus -7.

Sekwencje 1 2 4 8 16i 3 9 15 6 12nie są sekwencjami arytmetycznymi.

Kluczem może być dowolna wybrana przez ciebie sekwencja arytmetyczna, z jedynym ograniczeniem, że sekwencje obejmujące przepełnienie liczb całkowitych są niedozwolone. Oznacza to, że sekwencja musi być ściśle rosnąca, ściśle malejąca lub mieć wszystkie elementy równe.

Jako przykład załóżmy, że wybierasz klucz 98021 93880 89739 85598 81457. Twój program musi zwrócić 1, jeśli dane wejściowe (w sekwencji) są zgodne z tymi pięcioma liczbami, a 0 w przeciwnym razie.

Należy pamiętać, że środki ochrony klucza powinny być opracowane według własnego projektu. Również rozwiązania probabilistyczne, które mogą zwracać wyniki fałszywie dodatnie z dowolnym niezerowym prawdopodobieństwem, są niedozwolone. W szczególności nie używaj żadnych standardowych skrótów kryptograficznych, w tym funkcji bibliotecznych dla standardowych skrótów kryptograficznych.

Punktacja

Najkrótsze niezłamywane materiały na liczbę znaków zostaną ogłoszone zwycięzcami.

W przypadku jakichkolwiek nieporozumień prosimy pytać lub komentować.

Kontr-wyzwanie

Wszystkich czytelników, w tym tych, którzy przesłali własne programy, zachęca się do „łamania” zgłoszeń. Zgłoszenie jest łamane, gdy jego klucz jest publikowany w powiązanej sekcji komentarzy. Jeśli przesłanie trwa 72 godziny bez modyfikacji lub krakowania, jest uważane za „bezpieczne”, a wszelkie kolejne sukcesy w krakowaniu będą ignorowane ze względu na konkurs.

Zobacz „Zrzeczenie się odpowiedzialności” poniżej, aby uzyskać szczegółowe informacje na temat zaktualizowanych zasad oceny wyników crackingu.

Zgłoszone zgłoszenia są eliminowane ze sporów (pod warunkiem, że nie są „bezpieczne”). Nie należy ich edytować. Jeśli czytelnik chce złożyć nowy program, powinien to zrobić w osobnej odpowiedzi.

Krakersy o najwyższym wyniku zostaną ogłoszone zwycięzcami wraz z twórcami zwycięskich programów.

Proszę nie łamać własnego zgłoszenia.

Powodzenia. :)

Tabela liderów

Klasyfikacja przedostatnia (w oczekiwaniu na bezpieczeństwo zgłoszenia Dennisa CJam 49).

Bezpieczne szafki

1. CJam 49, Dennis
2. CJam 62, Dennis bezpieczny
3. CJam 91, Dennis bezpieczny
4. Python 156, Maarten Baert bezpieczny
5. Perl 256, bezpieczny dla dzieci
6. Java 468, Bezpieczne geobity

Niepowstrzymani krakersy

1. Peter Taylor [Ruby 130, Java 342, Mathematica 146 *, Mathematica 72 *, CJam 37]
2. Dennis [Pyth 13, Python 86 *, Lua 105 *, GolfScript 116, C 239 *]
3. Martin Büttner [Javascript 125, Python 128 *, Ruby 175 *, Ruby 249 *]
4. Tyilo [C 459, JavaScript 958 *]
5. freddieknets [Mathematica 67 *]
6. Ilmari Karonen [Python27 182 *]
7. azotawy [C 212 *]

* przesłanie niezgodne

Oświadczenie (zaktualizowane 23.15 EST, 26 sierpnia)

Ponieważ problemy z punktowaniem w końcu osiągnęły masę krytyczną (biorąc pod uwagę, że dwie trzecie zgłoszonych do tej pory zgłoszeń są niezgodne), umieściłem w rankingu najlepszych crackerów pod względem liczby zgłoszonych zgłoszeń (pierwotne) i całkowitej liczby znaków w zgłoszeniach zgłoszonych do złamania (wtórny).

Tak jak poprzednio, dokładnie zgłoszone pęknięcia, długość zgłoszeń oraz ich status zgodności / niezgodności są oznaczone, aby czytelnicy mogli wyciągać własne rankingi, jeśli uważają, że nowe oficjalne rankingi są niesprawiedliwe.

Przepraszam za zmianę zasad w późnej fazie gry.

CJam, 62 znaki

"ḡꬼ쏉壥떨ሤ뭦㪐ꍡ㡩折量ⶌ팭뭲䯬ꀫ郯⛅彨ꄇ벍起ឣ莨ຉᆞ涁呢鲒찜⋙韪鰴ꟓ䘦쥆疭ⶊ凃揭"2G#b129b:c~

Wymiana stosów jest podatna na fałszowanie niedrukowalnych znaków, ale kopiowanie kodu z tej pasty i wklejanie go do interpretera CJam działa dla mnie dobrze.

Jak to działa

Po zamianie ciągu Unicode na ciąg ASCII wykonywany jest następujący kod:

" Push 85, read the integers from STDIN and collect everything in an array.               ";

85l~]

" Convert the array of base 4**17 digits into and array of base 2 digits.                 ";

4H#b2b

" Split into chunks of length 93 and 84.                                                  ";

93/~

" Do the following 611 times:

    * Rotate array A (93 elements) and B one element to the left.
    * B[83] ^= B[14]
    * T = B[83]
    * B[83] ^= B[0] & B[1] ^ A[23]
    * A[92] ^= A[26]
    * Rotate T ^ A[92] below the arrays.
    * A[92] ^= A[0] & A[1] ^ B[5].                                                        ";

{(X$E=^:T1$2<:&^2$24=^+\(1$26=^_T^@@1$2<:&^3$5=^+@}611*

" Discard the arrays and collects the last 177 generated bits into an array.              ";

;;]434>

" Convert the into an integer and check if the result is 922 ... 593.                     ";

2b9229084211442676863661078230267436345695618217593=

Podejście to wykorzystuje Bivium-B (patrz analiza algebraiczna szyfrów typu trivium ), osłabioną wersję szyfru strumieniowego trivium .

Program wykorzystuje sekwencję liczb całkowitych jako stan początkowy, aktualizuje stan 434 razy (354 rundy osiągają pełną dyfuzję) i generuje 177 bitów wyjścia, które porównuje z tymi o prawidłowej sekwencji.

Ponieważ rozmiar stanu wynosi dokładnie 177 bitów, powinno to wystarczyć do jednoznacznej identyfikacji stanu początkowego.

Przykładowy przebieg

$ echo $LANG
en_US.UTF-8
$ base64 -d > block.cjam <<< IgThuKHqrLzsj4nlo6XrlqjhiKTrrabjqpDqjaHjoanmipjvpb7itozuoIDtjK3rrbLul7bkr6zqgKvvjafpg6/im4XlvajqhIfrso3uprrotbfvmL/hnqPojqjguonhhp7mtoHujLPuipzlkaLpspLssJzii5npn6rpsLTqn5PkmKbspYbnlq3itorlh4Pmj60iMkcjYjEyOWI6Y34=
$ wc -m block.cjam
62 block.cjam
$ cjam block.cjam < block.secret; echo
1
$ cjam block.cjam <<< "1 2 3 4 5"; echo
0

CJam, 91 znaków

q~]KK#bD#"᫖࿼듋ޔ唱୦廽⻎킋뎢凌Ḏ끮冕옷뿹毳슟夫΢眘藸躦䪕齃噳卤"65533:Bb%"萗縤ᤞ雑燠Ꮖ㈢ꭙ㈶タ敫䙿娲훔쓭벓脿翠❶셭剮쬭玓ୂ쁬䈆﹌⫌稟"Bb=

Wymiana stosów jest podatna na fałszowanie niedrukowalnych znaków, ale kopiowanie kodu z tej pasty i wklejanie go do interpretera CJam działa dla mnie dobrze.

Jak to działa

Po zamianie ciągu Unicode na liczby całkowite (biorąc pod uwagę cyfry znaków liczb podstawowych 65533), wykonywany jest następujący kod:

" Read the integers from STDIN and collect them in an array.                               ";

q~]

" Convert it into an integer by considering its elements digits of a base 20**20 number.   ";

KK#b

" Elevate it to the 13th power modulus 252 ... 701.                                        ";

D#
25211471039348320335042771975511542429923787152099395215402073753353303876955720415705947365696970054141596580623913538507854517012317194585728620266050701%

" Check if the result is 202 ... 866.                                                      ";

20296578126505831855363602947513398780162083699878357763732452715119575942704948999334568239084302792717120612636331880722869443591786121631020625810496866=

Ponieważ 13 jest coprime do sumy modułu (totient jest tajny, więc musisz mi tylko zaufać), różne zasady wygenerują różne wyniki, tj. Rozwiązanie jest unikalne.

Chyba że ktoś może wykorzystać mały wykładnik (13), najbardziej skutecznym sposobem na złamanie tego zamka jest rozkładanie modułu na moduł (patrz problem RSA ). Wybrałem 512-bitową liczbę całkowitą dla modułu, która powinna wytrzymać 72 godziny prób faktoryzacji.

Przykładowy przebieg

$ echo $LANG
en_US.UTF-8
$ base64 -d > lock.cjam <<< cX5dS0sjYkQjIgHuiJHhq5bgv7zrk4velOWUse6zjuCtpuW7veK7ju2Ci+uOouWHjOG4ju+Rh+uBruWGleyYt+u/ueavs+6boOyKn+Wkq86i55yY6Je46Lqm5KqV6b2D5Zmz75Wp5Y2kIjY1NTMzOkJiJSIB6JCX57ik4aSe74aS6ZuR54eg4Y+G44ii6q2Z44i244K/5pWr5Jm/5aiy7ZuU7JOt67KT7rO26IS/57+g4p2275+K7IWt5Ymu7Kyt546T4K2C7IGs5IiG77mM4quM56ifIkJiPQ==
$ wc -m lock.cjam
91 lock.cjam
$ cjam lock.cjam < lock.secret; echo
1
$ cjam lock.cjam <<< "1 2 3 4 5"; echo
0

Python - 128

Spróbujmy tego:

i=input()
k=1050809377681880902769L
print'01'[all((i>1,i[0]<i[4],k%i[0]<1,k%i[4]<1,i[4]-i[3]==i[3]-i[2]==i[2]-i[1]==i[1]-i[0]))]

(Oczekuje, że użytkownik wprowadzi 5 liczb oddzielonych przecinkami, np 1,2,3,4,5.)

Java: 468

Dane wejściowe są podane jako k(int[5]). Kaucje wcześnie, jeśli nie są równo rozmieszczone. W przeciwnym razie trzeba nieco dowiedzieć się, czy wszystkie dziesięć skrótów jest poprawne. W przypadku dużych liczb „trochę” może oznaczać dziesięć lub więcej sekund, więc może zniechęcić crackerów.

//golfed
int k(int[]q){int b=q[1]-q[0],i,x,y,j,h[]=new int[]{280256579,123883276,1771253254,1977914749,449635393,998860524,888446062,1833324980,1391496617,2075731831};for(i=0;i<4;)if(q[i+1]-q[i++]!=b||b<1)return 0;for(i=1;i<6;b=m(b,b/(i++*100),(1<<31)-1));for(i=0;i<5;i++){for(j=1,x=b,y=b/2;j<6;x=m(x,q[i]%100000000,(1<<31)-1),y=m(y,q[i]/(j++*1000),(1<<31)-1));if(x!=h[i*2]||y!=h[i*2+1])return 0;}return 1;}int m(int a,int b,int c){long d=1;for(;b-->0;d=(d*a)%c);return (int)d;}

// line breaks
int k(int[]q){
    int b=q[1]-q[0],i,x,y,j,
    h[]=new int[]{280256579,123883276,1771253254,1977914749,449635393,
                  998860524,888446062,1833324980,1391496617,2075731831};
    for(i=0;i<4;)
        if(q[i+1]-q[i++]!=b||b<1)
            return 0;
    for(i=1;i<6;b=m(b,b/(i++*100),(1<<31)-1));
    for(i=0;i<5;i++){
        for(j=1,x=b,y=b/2;j<6;x=m(x,q[i]%100000000,(1<<31)-1),y=m(y,q[i]/(j++*1000),(1<<31)-1));
        if(x!=h[i*2]||y!=h[i*2+1])
            return 0;
    }
    return 1;
}
int m(int a,int b,int c){
    long d=1;for(;b-->0;d=(d*a)%c);
    return (int)d;
}

Java: 342

int l(int[]a){String s=""+(a[1]-a[0]);for(int b:a)s+=b;char[]c=new char[11];for(char x:s.toCharArray())c[x<48?10:x-48]++;for(int i=0;i<11;c[i]+=48,c[i]=c[i]>57?57:c[i],i++,s="");for(int b:a)s+=new Long(new String(c))/(double)b;return s.equals("-3083.7767567702776-8563.34366442527211022.4345579010483353.1736981951231977.3560837512646")?1:0;}

Oto blokada łańcuchowa, która zależy zarówno od liczby znaków wejściowych, jak i od konkretnych danych wejściowych. Sekwencja może być oparta na niejasnych odniesieniach do popkultury. Baw się dobrze!

Nieco golfista:

int lock(int[]a){
    String s=""+(a[1]-a[0]);
    for(int b:a)
        s+=b;
    char[]c=new char[11];
    for(char x:s.toCharArray())
        c[x<48?10:x-48]++;
    for(int i=0;i<11;c[i]+=48,
                     c[i]=c[i]>57?57:c[i],
                     i++,
                     s="");
    for(int b:a)
        s+=new Long(new String(c))/(double)b;
    return s.equals("-3083.7767567702776-8563.34366442527211022.4345579010483353.1736981951231977.3560837512646")?1:0;
}

Python, 147

Edycja: krótsza wersja na podstawie komentarza Dennisa. Zaktualizowałem też sekwencję, aby uniknąć wycieku jakichkolwiek informacji.

def a(b):
    c=1
    for d in b:
        c=(c<<32)+d
    return pow(7,c,0xf494eca63dcab7b47ac21158799ffcabca8f2c6b3)==0xa3742a4abcb812e0c3664551dd3d6d2207aecb9be

Oparty na problemie logarytmu dyskretnego, który uważa się za niemożliwy do rozwiązania, jednak liczba podstawowa, której używam, jest prawdopodobnie zbyt mała, aby była bezpieczna (i może mieć inne problemy, nie wiem). Możesz oczywiście użyć siły, ponieważ jedynymi niewiadomymi są dwie 32-bitowe liczby całkowite.

JavaScript 125

Ten powinien zostać złamany dość szybko. Zajmę się czymś silniejszym.

function unlock(a, b, c, d, e)
{
    return (e << a == 15652) && (c >> a == 7826) && (e - b == d) && (d - c - a == b) ? 1 : 0;
}

Ruby, 175

a=gets.scan(/\d+/).map(&:to_i)
a.each_cons(2).map{|x,y|x-y}.uniq[1]&&p(0)&&exit
p a[2]*(a[1]^a[2]+3)**7==0x213a81f4518a907c85e9f1b39258723bc70f07388eec6f3274293fa03e4091e1?1:0

W przeciwieństwie do korzystania z kryptograficznego skrótu lub srand, jest to możliwe do udowodnienia, że ​​jest to wyjątkowa wskazówka. Pobiera pięć cyfr przez STDIN, oddzielonych dowolnymi nie cyfrowymi, nieliniowymi znakami lub znakami. Wyjścia do STDOUT.

GolfScript (116 znaków)

Pobiera dane wejściowe jako liczby całkowite rozdzielone spacjami.

~]{2.5??:^(&}%^base 2733?5121107535380437850547394675965451197140470531483%5207278525522834743713290685466222557399=

C 459 bajtów

ROZWIĄZANE PRZEZ TYILO - CZYTAJ PONIŻEJ EDYCJI

int c (int* a){
int d[4] = {a[1] - a[0], a[2] - a[1], a[3] - a[2], a[4] - a[3]};
if (d[0] != d[1] || d[0] != d[2] || d[0] != d[3]) return 0;
int b[5] = {a[0], a[1], a[2], a[3], a[4]};
int i, j, k;
for (i = 0; i < 5; i++) { 
for (j = 0, k = 2 * i; j < 5; j++, k++) {
k %= i + 1;
b[j] += a[k];
}
}
if (b[0] == 0xC0942 - b[1] && 
b[1] == 0x9785A - b[2] && 
b[2] == 0x6E772 - b[3] && 
b[3] == 0xC0942 - b[4] && 
b[4] == 0xB6508 - b[0]) return 1;
else return 0;
}

Potrzebujemy kogoś, kto napisze rozwiązanie C, prawda? Nie robię na nikim wrażenia długością, nie jestem golfistą. Mam nadzieję, że to ciekawe wyzwanie!

Nie sądzę, że istnieje oczywisty sposób na złamanie tego i z niecierpliwością czekam na wszystkie próby! Wiem, że to rozwiązanie jest wyjątkowe. Bardzo minimalne zaciemnienie, głównie w celu spełnienia wymagań dotyczących długości. Można to przetestować po prostu:

int main(){
    a[5] = {0, 0, 0, 0, 0} /* your guess */
    printf("%d\n", c(a));
    return 0;
}

PS Jest to a[0]samo w sobie ważne i chciałbym, aby ktoś zauważył to w komentarzach!

EDYTOWAĆ:

Rozwiązanie: 6174, 48216, 90258, 132300, 174342

Uwaga na temat łamania:

Chociaż nie jest to stosowana metoda (patrz komentarze), zdarzyło mi się złamać własny szyfr bardzo łatwą siłą. Rozumiem teraz, że niezwykle ważne jest, aby liczby były duże. Poniższy kod może złamać dowolny szyfr, dla którego upper_boundjest znana górna granica a[0] + a[1] + a[2] + a[3] + a[4]. Górną granicą powyższego szyfru jest 457464, która może być wyprowadzona z układu równań b[]i pewnego sposobu działania algorytmu. Można to pokazać b[4] = a[0] + a[1] + a[2] + a[3] + a[4].

int a[5];
for (a[0] = 0; a[0] <= upper_bound / 5; a[0]++) {
    for (a[1] = a[0] + 1; 10 * (a[1] - a[0]) + a[0] <= upper_bound; a[1]++) {
        a[2] = a[1] + (a[1] - a[0]);
        a[3] = a[2] + (a[1] - a[0]);
        a[4] = a[3] + (a[1] - a[0]);
        if (c(a)) {
            printf("PASSED FOR {%d, %d, %d, %d, %d}\n", a[0], a[1], a[2], a[3], a[4]);
        }
    }
    printf("a[0] = %d Checked\n", a[0]);
}

Z a[0] = 6174ta pętla złamał moją pracę w nieco krótszym niż minuta.

Mathematica 80 67

f=Boole[(p=NextPrime/@#)-#=={18,31,6,9,2}&&BitXor@@#~Join~p==1000]&

Bieganie:

f[{1,2,3,4,5}] (* => 0 *)

Prawdopodobnie dość łatwe do złamania, może również mieć wiele rozwiązań.

Aktualizacja: Ulepszono grę w golfa dzięki temu, co sugerował Martin Büttner. Funkcjonalność funkcji i klawisza nie uległa zmianie.

Python27, 283 182

W porządku, jestem bardzo pewny swojej szafki, jednak jest ona dość długa, ponieważ do danych wejściowych dodałem obliczenia „trudne do odwrócenia”, aby było dobrze - trudno ją odwrócić.

import sys
p=1
for m in map(int,sys.argv[1:6]):m*=3**len(str(m));p*=m<<sum([int(str(m).zfill(9)[-i])for i in[1,3,5,7]])
print'01'[p==0x4cc695e00484947a2cb7133049bfb18c21*3**45<<101]

edycja: Podziękowania dla colevk za dalszą grę w golfa. Podczas edycji zdałem sobie sprawę, że w moim algorytmie był błąd, a także wada, może następnym razem będę miał więcej szczęścia.

Mathematica 142 146

EDYCJA : klucz nie był unikalny, dodano 4 znaki, teraz jest.

n=NextPrime;
f=Boole[
    FromDigits /@ (
        PartitionsQ[n@(237/Plus@##) {1, ##} + 1] & @@@ 
            IntegerDigits@n@{Plus@##-37*Log[#3],(#1-#5)#4}
    ) == {1913001154,729783244}
]&

(Dodano spacje i znaki nowej linii dla czytelności, nie są liczone i nie są potrzebne).

Stosowanie:

f[1,2,3,4,5]   (* => 0 *)

Pęknięty przez @Dennis w 2 godziny

Po prostu prosty sposób na rozpoczęcie - w pełni oczekuję, że zostanie to szybko złamane.

Pyth , 13 lat

h_^ZqU5m-CGdQ

Pobiera wejście oddzielone przecinkami na STDIN.

Uruchom go w ten sposób (-c oznacza, że ​​weź program jako argument wiersza poleceń):

$ echo '1,2,3,4,5' | python3 pyth.py -c h_^ZqU5m-CGdQ
0

Naprawiono program - nie zrozumiałem specyfikacji.

Ten język może być zbyt ezoteryczny dla tego konkursu - jeśli OP tak uważa, usunę go.

Lua 105

Podejrzewam, że nie potrwa długo, zanim się pęknie, ale proszę bardzo:

function f(a,b,c,d,e)
   t1=a%b-(e-2*(d-b))
   t2=(a+b+c+d+e)%e
   t3=(d+e)/2
   print(t1==0 and t2==t3 and"1"or"0")
end

(spacje dodane dla przejrzystości, ale nie są częścią liczenia)

Perl - 256

sub t{($z,$j,$x,$g,$h)=@_;$t="3"x$z;@n=(7,0,split(//,$g),split(//,$h),4);@r=((2)x6,1,1,(2)x9,4,2,2,2);$u=($j+1)/2;for$n(0..$#r+1){eval{substr($t,$j,1)=$n[$n]};if($@){print 0; return}$j+=$r[$n]*$u}for(1..$x){$t=pack'H*',$t;}eval$t;if($@||$t!~/\D/){print 0}}

Musiałem wprowadzić wiele logiki obsługi błędów, a to zdecydowanie można pograć w golfa jeszcze bardziej. Wydrukuje a, 1gdy otrzymasz odpowiednie pięć liczb. Mam nadzieję , że wydrukuje 0wszystko inne (mogą to być błędy lub nic, nie wiem). Jeśli ktoś chce poprawić kod lub pograć w golfa, nie wahaj się pomóc!

Zadzwoń z:

t(1,2,3,4,5);

Rubin - 130

Na podstawie rejestru przesunięcia liniowego sprzężenia zwrotnego. Dane wejściowe według argumentów wiersza poleceń.
Powinien być unikalny w oparciu o charakter LFSR. Wskazówka: rosnąco i wszystkie pozytywne.

Daje więcej wskazówek, jeśli nikt nie rozwiąże go wkrótce.

x=($*.map{|i|i.to_i+2**35}*'').to_i
(9**8).times{x=((x/4&1^x&1)<<182)+x/2}
p x.to_s(36)=="qnsjzo1qn9o83oaw0a4av9xgnutn28x17dx"?1:0

Ruby, 249

a=gets.scan(/\d+/).map(&:to_i)
a.each_cons(2).map{|x,y|x-y}.uniq[1]&&p(0)&&exit
r=(a[0]*a[1]).to_s(5).tr'234','(+)'
v=a[0]<a[1]&&!r[20]&&(0..3).select{|i|/^#{r}$/=~'%b'%[0xaa74f54ea7aa753a9d534ea7,'101'*32,'010'*32,'100'*32][i]}==[0]?1:0rescue 0
p v

Powinno być zabawnie. Kto potrzebuje matematyki?

CJam, 49 znaków

"腕옡裃䃬꯳널֚樂律ࡆᓅ㥄뇮┎䔤嬣ꑙ䘿휺ᥰ籃僾쎧諯떆Ἣ餾腎틯"2G#b[1q~]8H#b%!

Wypróbuj online.

Jak to działa

" Push a string representing a base 65536 number and convert it to an integer.            ";

"腕옡裃䃬꯳널֚樂律ࡆᓅ㥄뇮┎䔤嬣ꑙ䘿휺ᥰ籃僾쎧諯떆Ἣ餾腎틯"2G#b

" Prepend 1 to the integers read from STDIN and collect them into an array.               ";

[1q~]

" Convert that array into an integer by considering it a base 2**51 number.               ";

8H#b

" Push the logical NOT of the modulus of both computed integers.                          ";

%!

Wynik będzie wynosił 1 wtedy i tylko wtedy, gdy druga liczba całkowita jest czynnikiem pierwszego, który jest iloczynem dwóch liczb pierwszych: jednej odpowiadającej tajnej sekwencji i drugiej, która nie odpowiada żadnej prawidłowej sekwencji. Dlatego rozwiązanie jest wyjątkowe.

Factorizing 512 bitową liczbę całkowitą nie jest to trudne, ale mam nadzieję, że nikt nie będzie w stanie w ciągu 72 godzin. Moja poprzednia wersja z 320-bitową liczbą całkowitą została zepsuta .

Przykładowy przebieg

$ echo $LANG
en_US.UTF-8
$ base64 -d > flock512.cjam <<< IuiFleyYoeijg+SDrOqvs+uEkNaa76a/5b6L4KGG4ZOF76Gi46WE64eu4pSO5JSk5ayj6pGZ5Ji/7Zy64aWw57GD5YO+7I6n6Kuv65aG7qK04byr6aS+6IWO7rSn7YuvIjJHI2JbMXF+XThII2IlIQ==
$ wc -m flock512.cjam
49 flock512.cjam
$ cjam flock512.cjam < flock512.secret; echo
1
$ cjam flock512.cjam <<< "1 2 3 4 5"; echo
0

JavaScript 958

Konwertuje dane wejściowe na wiele typów danych i wykonuje pewne manipulacje odpowiednie dla każdego typu danych po drodze. Powinien być dość łatwo odwrócony dla każdego, kto potrzebuje czasu.

function encrypt(num)
{
    var dateval = new Date(num ^ (1024-1) << 10);

    dateval.setDate(dateval.getDate() + 365);

    var dateString = (dateval.toUTCString() + dateval.getUTCMilliseconds()).split('').reverse().join('');

    var result = "";

    for(var i = 0; i < dateString.length; i++)
        result += dateString.charCodeAt(i);

    return result;
}

function unlock(int1, int2, int3, int4, int5)
{
    return encrypt(int1) == "5549508477713255485850495848483249555749321109774324948324410511470" && encrypt(int2) == "5756568477713252485848495848483249555749321109774324948324410511470" && encrypt(int3) == "5149538477713248485856485848483249555749321109774324948324410511470" && encrypt(int4) == "5356498477713256535853485848483249555749321109774324948324410511470" && encrypt(int5) == "5748568477713251535851485848483249555749321109774324948324410511470" ? 1 : 0;
}

C, 239 (Cracked by Dennis)

Przejdź tutaj, aby uzyskać zaktualizowane zgłoszenie.

Prawdopodobnie można by grać w golfa nieco dokładniej. Trzeba przyznać, że nie poświęciłem czasu, aby udowodnić, że klucz jest unikalny (prawdopodobnie nie jest), ale zdecydowanie jest to zgodne z kolizją skrótu. Jeśli go złamiesz, udostępnij swoją metodę :)

p(long long int x){long long int i;x=abs(x);
for (i=2;i<x;i++) {if ((x/i)*i==x) return 0;}return 1;}
f(a,b,c,d,e){char k[99];long long int m;sprintf(k,"%d%d%d%d%d",e,d,c,b,a);
sscanf(k,"%lld",&m);return p(a)&&p(b)&&p(c)&&p(d)&&p(e)&&p(m);}

C, 212 autorstwa Orby - Cracked

https://codegolf.stackexchange.com/a/36810/31064 firmy Orby ma co najmniej dwa klucze:

13 103 193 283 373
113 173 233 293 353

Orby poprosił o metodę, której użyłem do jej złamania. Funkcja p sprawdza, czy x jest liczbą pierwszą, sprawdzając x%i==0wszystkie i między 2 a x (chociaż używa (x/i)*i==xzamiast x%i==0) i zwraca true, jeśli x jest liczbą pierwszą. Funkcja f sprawdza, czy wszystkie a, b, c, d i e są liczbą pierwszą. Sprawdza również, czy liczba m, konkatenacja dziesiętnych reprezentacji e, d, c, b oraz a (w tej kolejności), jest liczbą pierwszą. Klucz jest taki, że a, b, c, d, e im są wszystkie pierwsze.

Green i Tao (2004) pokazują, że istnieje nieskończenie wiele ciągów arytmetycznych liczb pierwszych dla dowolnej długości k, więc musimy po prostu szukać tych sekwencji, które również spełniają m, że są pierwsze. Biorąc pod uwagę długi czas, ponieważ jest on ograniczony przez -9,223372037e + 18 i 9.223372037e + 18, wiemy, że aby skonkatenowany łańcuch pasował do długiej długości, liczby mają górną granicę 9999. Tak więc używając skryptu pythonowego do wygenerowania wszystkich sekwencje arytmetyczne we wszystkich liczbach pierwszych <10000, a następnie sprawdzając, czy ich odwrotna konkatenacja jest liczbą pierwszą, możemy znaleźć wiele możliwych rozwiązań.

Z jakiegoś powodu wymyśliłem fałszywe wyniki pozytywne, ale dwa powyższe są zgodne z programem. Ponadto mogą istnieć rozwiązania, w których e jest ujemne, a reszta jest dodatnia (p używa modułu x), ale ich nie szukałem.

Wszystkie klucze, które podałem, są ciągami arytmetycznymi, ale skrypt Orby'ego nie wymaga, aby dane wejściowe były ciągami arytmetycznymi, więc mogą być też nieprawidłowe klucze.

MATLAB: Najwyraźniej nieważny

Bardzo proste, wystarczy wygenerować odpowiednią liczbę losową.

function ans=t(a,b,c,d,e)
rng(a)
r=@(x)rng(rand*x)
r(b)
r(c)
r(d)
r(e)
rand==0.435996843156676

Nadal może występować błąd, ale nie powinno to stanowić problemu.

MATLAB (z Symbolicznym zestawem narzędzi), 173 znaków

To nie jest oficjalny wpis i nie będzie się liczył do nikogo, ale zdobędziesz szalone prawa do przechwalania się. ;)

function b=L(S),c=sprintf('%d8%d',S(1),S(2)-S(1));b=numel(unique(diff(S)))==1&&numel(c)==18&&all(c([8,9])==c([18,17]))&&isequal(c,char(sym(sort(c,'descend'))-sym(sort(c))));

Symboliczny zestaw narzędzi jest wymagany tylko do obsługi odejmowania dużych liczb całkowitych.

Brutalne zmuszanie do tego powinno być psem, ale jeśli znasz tę serię, rozwiązanie jest trywialne.

Python 2 (91)

Edycja: jest to niedozwolone, ponieważ argument za wyjątkowością jest probabilistyczny. Poddaję się.

s=3
for n in input():s+=pow(n,s,7**58)
print s==0x8b5ca8d0cea606d2b32726a79f01adf56f12aeb6e

Pobiera na wejściu listy liczb całkowitych, np [1,2,3,4,5].

Pętla ma działać w sposób denerwujący na wejściach, pozostawiając wieżę sum i wykładników. Pomysł jest jak dyskretny log, ale z nieporządną komplikacją zamiast matematycznej prostoty. Być może złożoność modułu jest podatna na atak, w którym to przypadku mogłabym to zrobić7**58+8 .

Naprawdę nie wiem, jak udowodnię, że mój klucz jest jedyny, ale zakres wyjść jest co najmniej 10 razy większy niż zakres wejść, więc prawdopodobnie? Chociaż może tylko niewielka część potencjalnych wyników jest osiągalna. Zawsze mogłem zwiększyć liczbę cyfr kosztem znaków. Sam zdecyduję, co jest sprawiedliwe.

Miłego łamania!

Mathematica - 72

Wersja 2 mojego skryptu, z takim samym kluczem jak ten przeznaczony dla mojej wersji 1.

To w zasadzie usuwa ujemne liczby pierwsze dla NextPrime.

f=Boole[(p=Abs[NextPrime/@#])-#=={18,31,6,9,2}&&BitXor@@#~Join~p==1000]&

Bieganie:

f[{1,2,3,4,5}] (* => 0 *)

Python, 86 znaków

a,b,c,d,e=input()
print 1if(a*c^b*e)*d==0xd5867e26a96897a2f80 and b^d==48891746 else 0

Wpisz liczby jak 1,2,3,4,5.

> python 36768.py <<< "1,2,3,4,5"
0
> python 36768.py <<< "[REDACTED]"
1

Python, 78

(Pęknięty przez Tyilo w 14 minut)

Zabawa!

def L(a): return 1 if a==[(i-i**6) for i in bytearray(' ','utf-8')] else 0

Okej, tutaj nie wyświetla się poprawnie :(

Oczekuje listy pięciu liczb, np. [1,2,3,4,5]

CJam, 37 znaków (zepsuty)

"煷➻捬渓类ⶥ땙ዶ꾫㞟姲̷ᐂ㵈禙鰳쥛忩蔃"2G#b[1q~]4G#b%!

Wypróbuj online.

Jak to działa

Zobacz moją nową odpowiedź.

Przykładowy przebieg

$ echo $LANG
en_US.UTF-8
$ base64 -d > flock.cjam <<< IueFt+Keu+aNrOa4k+exu+K2peuVmeGLtuq+q+Oen+Wnsu6AhMy34ZCC47WI56aZ6bCz7KWb5b+p6JSDIjJHI2JbMXF+XTRHI2IlIQ==
$ wc -m flock.cjam
37 flock.cjam
$ cjam flock.cjam < flock.secret; echo
1
$ cjam flock.cjam <<< "1 2 3 4 5"; echo
0

C, 212 (pęknięty)

Jest to ten sam pomysł, co moje poprzednie zgłoszenie , bardziej szczegółowo grał w golfa, z poprawionym błędem, który przeszedł 0,0,0,0,0 (Podziękowania dla Dennisa za wskazanie błędu). Skompiluj z -std = c99.

#define L long long
p(L x){x=abs(x);for(L i=2;i<x;i++){if((x/i)*i==x)return 0;}return(x>1);}
f(a,b,c,d,e){char k[99];L m;sprintf(k,"%d%d%d%d%d",e,d,c,b,a);sscanf(k,"%lld",&m);
return p(a)&p(b)&p(c)&p(d)&p(e)&p(m);}