Die Herausforderung

Eine einfache Herausforderung "Spion gegen Spion".

Schreiben Sie ein Programm mit folgenden Spezifikationen:

1. Das Programm kann in einer beliebigen Sprache geschrieben sein, darf jedoch nicht länger als 512 Zeichen sein (wie in einem Codeblock auf dieser Site dargestellt).
2. Das Programm muss 5 vorzeichenbehaftete 32-Bit-Ganzzahlen als Eingaben akzeptieren. Es kann die Form einer Funktion annehmen, die 5 Argumente akzeptiert, einer Funktion, die ein einzelnes Array mit 5 Elementen akzeptiert, oder eines vollständigen Programms, das 5 Ganzzahlen aus einer beliebigen Standardeingabe liest.
3. Das Programm muss eine vorzeichenbehaftete 32-Bit-Ganzzahl ausgeben.
4. Das Programm muss genau dann 1 zurückgeben, wenn die fünf als Folge interpretierten Eingaben mit einer bestimmten arithmetischen Folge der Wahl des Programmierers übereinstimmen, die als "Schlüssel" bezeichnet wird. Die Funktion muss für alle anderen Eingänge 0 zurückgeben.

Eine arithmetische Folge hat die Eigenschaft, dass jedes aufeinanderfolgende Element der Folge dem Vorgänger plus einer festen Konstante entspricht a .

Dies ist beispielsweise 25 30 35 40 45eine arithmetische Folge, da jedes Element der Folge dem Vorgänger plus 5 entspricht.17 10 3 -4 -11 entspricht. Dies ist auch eine arithmetische Folge, da jedes Element dem Vorgänger plus -7 entspricht.

Die Folgen 1 2 4 8 16und 3 9 15 6 12sind keine arithmetischen Folgen.

Ein Schlüssel kann eine beliebige arithmetische Folge Ihrer Wahl sein, mit der einzigen Einschränkung, dass Folgen mit Ganzzahlüberlauf nicht zulässig sind. Das heißt, die Reihenfolge muss streng zunehmen, streng abnehmen oder alle Elemente müssen gleich sein.

Angenommen, Sie wählen den Schlüssel aus 98021 93880 89739 85598 81457. Ihr Programm muss 1 zurückgeben, wenn die Eingaben (nacheinander) mit diesen fünf Zahlen übereinstimmen, andernfalls 0.

Bitte beachten Sie, dass das Mittel zum Schutz des Schlüssels von Ihrem eigenen neuartigen Design sein sollte. Probabilistische Lösungen, die mit einer Wahrscheinlichkeit ungleich Null falsch positive Ergebnisse liefern können, sind ebenfalls nicht zulässig. Verwenden Sie insbesondere keine standardmäßigen kryptografischen Hashes, einschließlich Bibliotheksfunktionen für standardmäßige kryptografische Hashes.

Die Wertung

Die kürzeste (n) nicht geknackte (n) Einsendung (en) pro Zeichenanzahl wird (werden) zum Gewinner erklärt.

Bei Unklarheiten können Sie gerne nachfragen oder Kommentare abgeben.

Die Gegen-Herausforderung

Alle Leser, einschließlich derer, die ihre eigenen Programme eingereicht haben, werden aufgefordert, Einsendungen zu "knacken". Ein Beitrag wird geknackt, wenn sein Schlüssel im zugehörigen Kommentarbereich veröffentlicht wird. Wenn eine Einreichung 72 Stunden lang ohne Änderung oder Crack andauert, wird sie als "sicher" eingestuft und jeder nachfolgende Erfolg beim Cracken wird für den Wettbewerb ignoriert.

Unter "Haftungsausschluss" finden Sie Einzelheiten zur aktualisierten Richtlinie für Cracking-Scores.

Gebrochene Einsendungen werden von der Konkurrenz ausgeschlossen (sofern sie nicht "sicher" sind). Sie sollten nicht bearbeitet werden. Wenn ein Leser ein neues Programm einreichen möchte, sollte er dies in einer separaten Antwort tun.

Der / die Cracker mit der (den) höchsten Punktzahl (en) wird (werden) zusammen mit den Entwicklern der Gewinnerprogramme zum Gewinner erklärt.

Bitte knacken Sie nicht Ihren eigenen Beitrag.

Viel Glück. :)

Bestenliste

Vorletzte Platzierung (in Erwartung der Sicherheit von Dennis 'Einreichung von CJam 49).

Sichere Schließfächer

1. CJam 49, Dennis
2. CJam 62, Dennis sicher
3. CJam 91, Dennis sicher
4. Python 156, Maarten Baert sicher
5. Perl 256, chilemagic safe
6. Java 468, Geobits sicher

Unaufhaltsame Cracker

1. Peter Taylor [Ruby 130, Java 342, Mathematica 146 *, Mathematica 72 *, CJam 37]
2. Dennis [Python 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. salpetrig [C 212 *]

* nicht konforme Einreichung

Haftungsausschluss (Aktualisiert 23.15 Uhr EST, 26. August)

Da die Bewertungsprobleme endlich die kritische Masse erreichen (vorausgesetzt, zwei Drittel der geknackten Einreichungen sind bislang nicht konform), habe ich die besten Cracker in Bezug auf die Anzahl der geknackten Einreichungen (primär) und die Gesamtzahl der Zeichen in konformen geknackten Einreichungen eingestuft (sekundär).

Wie zuvor sind die genauen Einsendungen geknackt, die Länge der Einsendungen und ihr Konformitäts- / Nicht-Konformitätsstatus markiert, sodass die Leser ihre eigenen Rankings ableiten können, wenn sie glauben, dass die neuen offiziellen Rankings unfair sind.

Ich entschuldige mich dafür, dass ich die Regeln so spät im Spiel geändert habe.

CJam, 62 Zeichen

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

Stack Exchange ist anfällig dafür, nicht druckbare Zeichen zu verfälschen, aber das Kopieren des Codes aus dieser Paste und das Einfügen in den CJam-Interpreter funktioniert für mich einwandfrei .

Wie es funktioniert

Nach dem Ersetzen der Unicode-Zeichenfolge durch eine ASCII-Zeichenfolge wird der folgende Code ausgeführt:

" 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=

Dieser Ansatz verwendet Bivium-B (siehe Algebraische Analyse von Trivium-ähnlichen Chiffren ), eine abgeschwächte Version der Stream-Chiffre Trivium .

Das Programm verwendet die Folge von ganzen Zahlen als Anfangszustand, aktualisiert den Zustand 434-mal (354 Runden erreichen die volle Diffusion) und erzeugt 177 Bit der Ausgabe, die es mit denen der richtigen Folge vergleicht.

Da die Größe des Zustands genau 177 Bit beträgt, sollte dies ausreichen, um den Anfangszustand eindeutig zu identifizieren.

Beispiellauf

$ 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 Zeichen

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

Stack Exchange ist anfällig dafür, nicht druckbare Zeichen zu verfälschen, aber das Kopieren des Codes aus dieser Paste und das Einfügen in den CJam-Interpreter funktioniert für mich einwandfrei .

Wie es funktioniert

Nach dem Ersetzen der Unicode-Zeichenfolge durch Ganzzahlen (unter Berücksichtigung der Ziffern der Basis-65533-Zahlen) wird der folgende Code ausgeführt:

" 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=

Da 13 gleich dem Totienten des Moduls ist (der Totient ist geheim, Sie müssen mir also nur vertrauen), führen unterschiedliche Basen zu unterschiedlichen Ergebnissen, dh die Lösung ist einzigartig.

Wenn jemand den kleinen Exponenten (13) nicht ausnutzen kann, ist die effizienteste Möglichkeit, diese Sperre aufzuheben, die Faktorisierung des Moduls (siehe RSA-Problem ). Ich habe eine 512-Bit-Ganzzahl als Modul gewählt, die 72 Stunden Faktorisierungsversuchen standhalten sollte.

Beispiellauf

$ 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

Lass es uns versuchen:

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]))]

(Erwartet, dass der Benutzer 5 durch Kommas getrennte Zahlen eingibt, z 1,2,3,4,5. B. )

Java: 468

Die Eingabe erfolgt als k(int[5]). Kaution früh, wenn nicht gleichmäßig verteilt. Andernfalls muss ein bisschen herausgefunden werden, ob alle zehn Hashes korrekt sind. Bei großen Zahlen kann "ein bisschen" zehn Sekunden oder länger bedeuten, sodass Cracker möglicherweise davon abgehalten werden.

//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;}

Hier ist ein auf Zeichenfolgen basierendes Schließfach, das sowohl von der Anzahl der eingegebenen Zeichen als auch von der spezifischen Eingabe abhängt. Die Sequenz könnte auf obskuren Popkulturreferenzen basieren. Habe Spaß!

Ein bisschen ungolfed:

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

Edit: kürzere Version basierend auf Dennis 'Kommentar. Ich habe auch die Sequenz aktualisiert, um zu verhindern, dass Informationen verloren gehen.

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

Basierend auf dem diskreten Logarithmusproblem, von dem angenommen wird, dass es nicht zu knacken ist, jedoch ist die von mir verwendete Primzahl wahrscheinlich zu klein, um sicher zu sein (und es kann auch andere Probleme geben, die ich nicht kenne). Und Sie können es natürlich brachial erzwingen, da die einzigen Unbekannten zwei 32-Bit-Ganzzahlen sind.

Javascript 125

Dieser sollte ziemlich schnell geknackt werden. Ich werde etwas Stärkeres nachholen.

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

Rubin, 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

Im Gegensatz zur Verwendung eines kryptografischen Hashs oder srandist dies nachweislich einzigartig (was ein kleiner Hinweis ist). Nimmt fünf Zahlen über STDIN entgegen, die durch ein oder mehrere nicht ziffern- oder neuzeilige Zeichen begrenzt sind. Ausgänge zu STDOUT.

GolfScript (116 Zeichen)

Übernimmt Eingaben als durch Leerzeichen getrennte Ganzzahlen.

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

C 459 Bytes

Gelöst von Tyilo - LESEN SIE DIE BEARBEITUNG UNTEN

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;
}

Wir brauchen jemanden, der eine C-Lösung schreibt, nicht wahr? Ich beeindrucke niemanden mit Länge, ich bin kein Golfspieler. Ich hoffe es ist eine interessante Herausforderung!

Ich glaube nicht, dass es einen offensichtlichen Weg gibt, diesen zu knacken, und ich warte gespannt auf alle Versuche! Ich kenne diese Lösung als einzigartig. Sehr minimale Verschleierung, hauptsächlich, um die Längenanforderungen zu erfüllen. Dies kann einfach getestet werden:

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

PS: Es gibt eine Bedeutung für sich a[0]selbst, und ich würde gerne sehen, dass jemand in den Kommentaren darauf hinweist!

BEARBEITEN:

Lösung: 6174, 48216, 90258, 132300, 174342

Ein Hinweis zum Knacken:

Dies ist zwar nicht die verwendete Methode (siehe die Kommentare), aber ich habe meine eigene Chiffre mit einer sehr einfachen Bruteforce geknackt. Ich verstehe jetzt, dass es äußerst wichtig ist, die Zahlen groß zu machen. Der folgende Code kann jede Chiffre knacken, für upper_bounddie eine Obergrenze bekannt ist a[0] + a[1] + a[2] + a[3] + a[4]. Die obere Schranke in der obigen Ziffer ist 457464, die aus dem Gleichungssystem des b[]Algorithmus und einem gewissen Durcharbeiten desselben abgeleitet werden kann. Es kann gezeigt werden, dass 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]);
}

Damit a[0] = 6174hat diese Schleife meine Arbeit in weniger als einer Minute unterbrochen.

Mathematica 80 67

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

Laufen:

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

Wahrscheinlich ziemlich leicht zu knacken, könnte auch mehrere Lösungen haben.

Update: Verbessertes Golfen mit Martin Büttner. Die Funktionalität der Funktion und des Schlüssels hat sich nicht geändert.

Python27, 283 182

Okay, ich bin sehr zuversichtlich in mein Schließfach, aber es ist ziemlich lang, da ich Berechnungen, die schwierig umzukehren sind, zur Eingabe hinzugefügt habe, um es gut zu machen - schwierig umzukehren.

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]

edit: Danke an colevk für das weitere Golfen. Während der Bearbeitung wurde mir klar, dass mein Algorithmus sowohl einen Fehler als auch einen Fehler aufweist. Vielleicht habe ich beim nächsten Mal mehr Glück.

Mathematica 142 146

BEARBEITEN : Schlüssel war nicht eindeutig, hinzugefügt 4 Zeichen, jetzt ist es.

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

(Leerzeichen und Zeilenumbrüche zur besseren Lesbarkeit hinzugefügt, nicht gezählt und nicht benötigt).

Verwendung:

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

Von @Dennis in 2 Stunden geknackt

Nur eine einfache Möglichkeit, die Dinge in Gang zu bringen - ich gehe davon aus, dass dies schnell geknackt wird.

Pyth , 13

h_^ZqU5m-CGdQ

Übernimmt die kommagetrennte Eingabe für STDIN.

Führen Sie es folgendermaßen aus (-c bedeutet, dass Sie das Programm als Befehlszeilenargument verwenden):

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

Das Programm wurde behoben - ich hatte die Spezifikation nicht verstanden.

Diese Sprache könnte für diesen Wettbewerb zu esoterisch sein - Wenn OP das meint, werde ich sie entfernen.

Lua 105

I suspect it won't be long before it's cracked, but here we go:

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

(spaces added for clarity, but are not part of count)

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}}

I had to put in a lot of error handling logic and this can definitely be golfed down a lot more. It will print a 1 when you get the right five numbers. It will hopefully print a 0 for everything else (might be errors or nothing, I don't know). If anyone wants to help improve the code or golf it more, feel free to help out!

Call with:

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

Ruby - 130

Based on Linear Feedback Shift Register. Inputs by command line arguments.
Should be unique based on the nature of LFSRs. Clue: ascending and all positive.

Will give more clues if no one solves it soon.

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

Should be fun. Who needs math?

CJam, 49 characters

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

Try it online.

How it works

" 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.                          ";

%!

The result will be 1 if and only if the second integer is a factor of the first, which is a product of two primes: the one corresponding to the secret sequence and another that doesn't correspond to any valid sequence. Therefore, the solution is unique.

Factorizing a 512 bit integer isn't that difficult, but I hope nobody will be able to in 72 hours. My previous version using a 320 bit integer has been broken.

Example run

$ 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

Converts the inputs to a number of data types and performs some manipulations relevant to each data type along the way. Should be fairly easily reversed for anyone that takes the time.

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)

Go here for my updated submission.

Could probably be golfed a little more thoroughly. Admittedly, I haven't taken the time to prove the key is unique (it probably isn't) but its definitely on the order of a hash collision. If you crack it, please share your method :)

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 by Orby -- Cracked

https://codegolf.stackexchange.com/a/36810/31064 by Orby has at least two keys:

13 103 193 283 373
113 173 233 293 353

Orby asked for the method I used to crack it. Function p checks whether x is prime by checking x%i==0 for all i between 2 and x (though using (x/i)*i==x instead of x%i==0), and returns true if x is a prime number. Function f checks that all of a, b, c, d and e are prime. It also checks whether the number m, a concatenation of the decimal representations of e, d, c, b and a (in that order), is prime. The key is such that a,b,c,d,e and m are all prime.

Green and Tao (2004) show that there exist infinitely many arithmetic sequences of primes for any length k, so we just need to look for these sequences that also satisfy m being prime. By taking long long as being bounded by -9.223372037e+18 and 9.223372037e+18, we know that for the concatenated string to fit into long long, the numbers have an upper bound of 9999. So by using a python script to generate all arithmetic sequences within all primes < 10000 and then checking whether their reverse concatenation is a prime, we can find many possible solutions.

For some reason I came up with false positives, but the two above are valid according to the program. In addition there may be solutions where e is negative and the rest are positive (p uses the modulus of x), but I didn't look for those.

The keys I gave are all arithmetic sequences but Orby's script doesn't appear to actually require the inputs to be an arithmetic sequence, so there may be invalid keys too.

MATLAB: Apparently invalid

Very simple, you just have to generate the right random number.

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

It can still error out, but that shouldn't be a problem.

MATLAB (with Symbolic Toolbox), 173 characters

This isn't an official entry and won't count towards anyone's cracking score, but it will net you mad bragging rights. ;)

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))));

The symbolic toolbox is only required to handle subtraction of big integers.

Brute forcing it should be a dog, but if you're familiar with the series it involves, the solution is trivial.

Python 2 (91)

Edit: This isn't allowed because the argument for uniqueness is probabilistic. I give up.

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

Takes lists of integers as input, like [1,2,3,4,5].

The loop is meant to operate on the inputs in an annoying way, leaving a tower of sums and exponents. The idea is like discrete log, but with messy complication instead of mathematical simplicity. Maybe the compositeness of the of the modulus is a vulnerability, in which case I could make it something like 7**58+8.

I don't really know how I'd prove that my key is the only one, but the range of outputs is at least 10 times bigger than the range of inputs, so probably? Though maybe only a small fraction of potential outputs are achievable. I could always increase the number of digits at the cost of characters. I'll leave it up to you to decide what's fair.

Happy cracking!

Mathematica - 72

Version 2 of my script, with the same key as the one intended for my version 1.

This basically removes negative prime numbers for NextPrime.

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

Running:

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

Python, 86 characters

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

Enter the numbers like 1,2,3,4,5.

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

Python, 78

(Cracked by Tyilo in 14 mins)

Fun!

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

Okay, it doesn't display properly here :(

Expects a list of five numbers, eg. [1,2,3,4,5]

CJam, 37 characters (broken)

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

Try it online.

How it works

See my new answer.

Example run

$ 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 (Cracked)

This is the same idea as my previous submission, golfed more thoroughly, with a bug corrected that passed 0,0,0,0,0 (Thanks to Dennis for pointing out the bug). Compile with -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);}