Schließfächer gegen Cracker: Die Fünf-Elemente-Sequenz


31

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.


6
Wie können Sie überprüfen, ob die Programme Punkt 4 erfüllen? Erwarten Sie, dass die Benutzer ihre sicheren Antworten bearbeiten, um einen Beweis hinzuzufügen? Sind probabilistische Eingaben zulässig, wenn angenommen wird, dass Hash-Funktionen ideal sind und die Wahrscheinlichkeit einer Kollision mit einem anderen Element des 48-Bit-Raums (gemäß Ihrer obigen Schätzung) vernachlässigbar ist?
Peter Taylor

2
Das Punktesystem scheint Cracker zu ermutigen, die kürzesten Schlösser zu ignorieren, da sie besser abschneiden, wenn sie zwei lange Schlösser knacken als zwei kleine.
Peter Taylor

3
@COTO Ich denke das Problem ist, dass man nur 2 Cracking Scores bekommen kann und nur die kürzeste. Warum also nicht abwarten und hoffen und länger auftauchen? Zum Beispiel hat Martin jetzt keinen Anreiz mehr, mein (längeres) Schloss zu knacken, da er bereits zwei kürzere geknackt hat. Jeder, der meine knackt, wird ihn jetzt schlagen, ohne auch nur eine zweite machen zu müssen.
Geobits

1
Ich denke, ein besseres Bewertungssystem könnte die Summe der Gesamtzeiten zwischen Frage und Riss sein. Auf diese Weise kann man es schaffen, ein paar leichte zu knacken, und die wirkliche Belohnung kommt davon, die wirklich harten zu knacken.
Isaacg

1
Ich bin neu im Golfen, also ist es vielleicht eine blöde Frage, tut mir leid. Warum wird die Codelänge in Zeichen und nicht in Bytes gemessen? Letzteres ist buchstäblich der Speicherplatz, den ein Programm einnimmt, und erscheint mir logischer. Z.B. Die CJam-Antwort ist die kürzeste in Zeichen, aber wenn man sich die Größe ansieht (326 aufgrund von Unicode), ist sie nicht einmal in den Top 5. Ich frage mich also, ob es beim Golfen üblich ist, Zeichen anstelle von Bytes zu zählen?
Freddieknets

Antworten:


3

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

6

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

Ich habe eine neue Version gepostet, da ich vergessen habe, ein unnötiges Zeichen aus der ersten zu entfernen. Die geheime Sequenz ist immer noch dieselbe, sodass Sie versuchen können, eine der beiden zu knacken.
Dennis

Zu Ihrer Information, ich brich meinen Factoring-Versuch ab. msieve hat sich ein Zeitlimit von 276 Stunden gesetzt, aber das war nur zum Aufbau der Faktorbasis. In dieser Zeit ist es found 1740001 rational and 1739328 algebraic entries; Es hat seitdem fast 100 Stunden gedauert, um sie zu verarbeiten und zu berichten sieving in progress b = 46583, 0 complete / 0 batched relations (need 44970493).
Peter Taylor

@ PeterTaylor: Sieht aus wie 512 Bits Overkill waren. Haben Sie versucht, die ganze Zahl in meine andere Antwort oder in diese Antwort einzubeziehen?
Dennis

Oh, hoppla. Ja, andere
Peter Taylor

4

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


3
32416190039,32416190047,32416190055,32416190063,32416190071
Martin Ender

Wow, das war schnell! Du hast recht! Und ich bin raus.
Falko

3
Übrigens ist dies nicht wirklich gültig, da Ihre fünf Ganzzahlen nicht in eine 32-Bit-Ganzzahl passen.
Martin Ender

4

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

1
Ihr Code bleibt hängen, wenn die arithmetische Eingabereihenfolge absteigend ist. Zumindest dauert es sehr lange. Was mich denken lässt, dass der Geheimcode aufsteigt ...
Keith Randall

3
@KeithRandall Ups. Lassen Sie sich vier Bytes hinzufügen , um Sequenzen , die eine ungewöhnlich nehmen absteigend kurze Menge an Zeit, das weiterhin Ihren Glauben zu stärken.
Geobits

4

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

2
8675309? 90210?
Malachi

1
@Malachi Zweifellos zwei herausragende Referenzen, aber ich kann ihre Anwendbarkeit auf diese Übung weder bestätigen noch leugnen.
Geobits

lol, ich habe noch nicht vollständig herausgefunden, wie diese Herausforderung vollständig funktioniert. Vielleicht probiere ich es später, wenn ich zu Hause bin.
Malachi

1
Anfangsbedingung ist -8675309, Delta ist 5551212.
Peter Taylor

@ Peter Taylor Schön gemacht :)
Geobits

4

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.


Diskrete Logarithmen sind viel schwieriger, als ich dachte. Mein Cracker ist seit 26 Stunden dabei. Ich gebe auf.
Dennis

Sie können das Vorzeichenproblem lösen, indem Sie die Konstante initialisieren c=1, berechnen c=(c<<32)+dund entsprechend ändern.
Dennis

3

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

6
0, 3913, 7826, 11739, 15652
Martin Ender

yep du hast es :)
rdans

3

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.


Ja, ich habe vergessen, dass sie unterschrieben sind.
Histokrat

2
622238809,1397646693,2173054577,2948462461,3723870345(Meine vorherige Vermutung hatte einen Fehler, aber dieser ist getestet). Ich denke nicht, dass dies gültig ist, da die letzte Zahl nicht in eine vorzeichenbehaftete 32-Bit-Ganzzahl passt.
Martin Ender

3

GolfScript (116 Zeichen)

Übernimmt Eingaben als durch Leerzeichen getrennte Ganzzahlen.

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

2
-51469355 -37912886 -24356417 -10799948 2756521
Dennis

Gute Arbeit. Hast du den kleinen Exponenten ausgenutzt?
Peter Taylor

2
Nein, ich habe den Modul faktorisiert. Mit dem Multiple Polynomial Quadratic Sieve und PyPy von primo dauerte es nur 13 Sekunden .
Dennis

In diesem Fall könnte ich genauso gut auf mein aktuelles Golfspiel verzichten, indem ich ein kompakt ausgedrücktes Modul verwende. Wenn das Ergebnis ungefähr 1024 Bit sein muss, um vor Faktorisierung geschützt zu sein, wird es selbst bei Verwendung einer Base-256-Darstellung zu lang.
Peter Taylor

Ich hoffe nicht. Meine Antwort verwendet dieselbe Idee wie Ihre, jedoch mit einem 512-Bit-Modul und einem noch kleineren Exponenten (13). Angesichts des Zeitlimits von 72 Stunden könnte das ausreichen ...
Dennis

3

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.


6
Lösung: 6174, 48216, 90258, 132300, 174342.
Tyilo

Wow das war schnell. Schön. Bruteforced, oder haben Sie etwas Kluges gefunden, das ich verpasst habe?
BrainSteel

Ich habe Mathematics symbolische Bewertung folgendermaßen verwendet : ghostbin.com/paste/jkjpf
screenshot

Zum Edit: Ich habe im Grunde das Gleiche gemacht, aber das Upper bei 500k verfälscht. Bekam die Antwort und sah, dass Tyilo sie bereits gepostet hatte :(
Geobits

@Geobits Das ist eine überraschend genaue Schätzung. Hätte noch ein paar Nullen an die Enden dieser Zahlen setzen sollen.
BrainSteel

3

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.


@ MartinBüttner Verbessere die Antworten, um eine höhere Punktzahl zu erzielen, wenn du sie knackst. Smart; P
Tyilo

Wie sich herausstellte, habe ich den Absatz über das Punkten für die Konterherausforderung übersprungen. Ich dachte, das sei nur zum Spaß und ohne Punktzahl. Obwohl ich nicht der Meinung bin, dass es Sinn macht, Lösungen zu verkürzen, die ich knacken möchte, da dies meine Punktzahl verringern würde.
Martin Ender

4
{58871,5592,-47687,-100966,-154245}
Freddieknets

@freddieknets Nicht die Lösung, die ich beim Erstellen verwendet habe. Wusste nicht, dass NextPrimedas negative Werte zurückgeben könnte. Wie hast du das gefunden?
Tyilo

Dann ist Ihr Schlüssel nicht eindeutig: p. Ich habe nur ein paar Tests durchgeführt - es gibt wirklich nicht so viele Zahlen, bei denen NextPrime [#] - # auf 31 ausgewertet wird, also ist das ein einfacher Weg, es zu knacken.
Freddieknets

2

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.


5
Dies ist bei einer Neuordnung der Argumente unveränderlich, sodass es kein gültiges Schließfach ist.
Peter Taylor

Außerdem vermute ich, dass der Code, wie er veröffentlicht wurde, fehlerhaft ist: Der Schlüssel 121174841 121174871 121174901 121174931 121174961funktioniert, aber nur, wenn die Liste [1,3,5,7]in Zeile 7 durch ersetzt wird [1,3,5,7,11].
Ilmari Karonen

Verdammt, ja, ich habe gerade meinen Tippfehler korrigiert. Dabei habe ich einen entscheidenden Fehler in meinem Algorithmus gemacht, der das Knacken sehr einfach machte: |
Stokastic

Tatsächlich war es schwierig, den Fehler zu finden und zu beheben. Angesichts Ihres Algorithmus war es naheliegend, die Konstante zu berücksichtigen.
Ilmari Karonen

2

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

1
Anfangslaufzeit 256208Delta -5.
Peter Taylor

Dang, dann ist es immer noch nicht einzigartig, da dies nicht mein Originalschlüssel ist. Hast du bruteforce?
Freddieknets

Testen Sie es, ich könnte einen Fehler gemacht haben, weil ich keinen Zugriff auf Mathematica zum Testen habe. In jeder Phase wird rohe Gewalt angewendet, aber es ist nicht viel Computerzeit. Der Ansatz besteht darin, rückwärts auf den Output von zu arbeiten IntegerDigitsund dann Kandidaten für die Anfangslaufzeit und das Delta zu ermitteln.
Peter Taylor

Aber dieser Ansatz könnte auf keinen Fall einzigartig sein. Die zweite der fünf Eingaben wird nur in einer Summe verwendet, die an übergeben wird NextPrime. Wenn wir es um plus oder minus eins variieren, gibt mindestens einer davon die gleiche nächste Primzahl.
Peter Taylor

ja, aber für eine arithmetische Sequenz - wie die erforderliche Eingabe - sollte sie eindeutig sein.
Freddieknets

1

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.


7
Have you just given away that 1,2,3,4,5 is the key?
Peter Taylor

1
Every input I tried returned 1, did you switch 1 and 0 as output?
Tyilo

Sorry, I didn't understand the Output vs. Return distinction - the program should work now. Same underlying algorithm.
isaacg

3
97,96,95,94,93 (I just killed my cracking score.)
Dennis

@Dennis Well done. The cracking score system needs to be changed - it's creating some really weird incentives.
isaacg

1

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)


3, 7, 11, 15, 19 or 6, 14, 22, 30, 38
Dennis

@Dennis: sadly it is neither of those. I'll have to work on it a bit later to ensure the non-uniqueness.
Kyle Kanos

t1==0 whenver S is increasing. Also, both conditions are homogeneous; if S is a solution, so is kS.
Dennis

1

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

1

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

3
Initial value 781783, increment 17982811
Peter Taylor

@PeterTaylor Argh... =)
Vectorized

1

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?


2
309, 77347, 154385, 231423, 308461 but I don't think it's unique.
Martin Ender

Yeah, it's not. For the same regex (i.e. product of the first two numbers), I also find 103, 232041, 463979, 695917, 927855 and 3, 7966741, 15933479, 23900217, 31866955. And I'm pretty sure there are other valid regexes by using additional +s.
Martin Ender

Sorry, I guess I messed up the test string. There was supposed to be only one regexp with a unique factorization.
histocrat

If you want to try to fix it, make sure to take possessive quantifiers into account. I can also create a larger, equivalent regex by inserting () or similar.
Martin Ender

1

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

I've had msieve running on it for over 24 hours, but since its self-imposed time limit is 276.51 CPU-hours and I've only given it one CPU I'm not optimistic.
Peter Taylor

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

5
Brute forced: 320689, 444121, 567553, 690985, 814417
Tyilo

@Tyilo If you stop now, I think no cracker can beat your score. ;)
Martin Ender

2
@MartinBüttner Unless this can be golfed to under 512 per the OP, I don't think it counts.
Geobits

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

1
So, 0 0 0 0 0?
Dennis

Sigh that was a bug, but yes that works.
Orby

I've updated with a corrected version that should be a little more interesting ;)
Orby

See the corrected version here.
Orby

0

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.


0

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.


1
This approach is prohibited in the comments. If it's not mentioned in the question, propose an edit. Sorry.
Peter Taylor

@PeterTaylor I guess I am out then, I will just leave it here without score as I am curious whether someone can find a weakness.
Dennis Jaheruddin

0

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.


0

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!


0

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

Assuming that I've correctly understood what your code does, I get several solutions of which the smallest is initial term 9244115, delta 25.
Peter Taylor

@PeterTaylor I can confirm that that one is valid.
Martin Ender

@PeterTaylor correct, another key is 1073743739, 1073886396, 1074029053, 1074171710, 1074314367
Tyilo

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

This isn't a valid submission; it accepts the input 1,0,1,63021563418517255630720,0.
Dennis

@Dennis Fixed. I hope it's valid now.
Snack

1
19960211, 31167202, 42374193, 53581184, 64788175
Dennis

@Dennis Correct and awesome. I think I'm very poor at math.
Snack

2
@Dennis, 63021563418517255630720 isn't a 32-bit number.
Peter Taylor


0

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

1
737262825 208413108 3974530688 3445680972 2916831257 works but isn't an arithmetic progression. Factored in 3 hours 20 minutes. 512-bit numbers were apparently doable in 72 hours for $75 on EC2 two years ago, so I think that would have been safe.
Peter Taylor

@PeterTaylor: That returns 1, but the last three integers are greater than MAX_INT, so it's not a valid key. That being said, 3 h 20 m is pretty impressive. The algorithm I was using took 16 hours for a 256-bit semiprime...
Dennis

I thought there must be some negative numbers in there somewhere because the deltas were almost right but not quite. I'll get on to it.
Peter Taylor

1
737262825 208413109 -320436607 -849286323 -1378136039
Peter Taylor

@PeterTaylor: That's the one. I hope the 512 bit version lasts longer.
Dennis

-2

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

Any sequence (arithmetic or not) of negative primes will work. Two examples: -7 -37 -67 -97 -127, -157 -127 -97 -67 -37
Dennis

Yeah, my code is just riddled with bugs. The answer nitrous gave is along the lines of what I was looking for. But nice job pointing out the more obvious answers.
Orby
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.