Le défi

Un simple défi "espion contre espion".

Écrivez un programme avec les spécifications suivantes:

1. Le programme peut être écrit dans n'importe quelle langue mais ne doit pas dépasser 512 caractères (comme représenté dans un bloc de code sur ce site).
2. Le programme doit accepter 5 entiers 32 bits signés comme entrées. Il peut prendre la forme d'une fonction qui accepte 5 arguments, une fonction qui accepte un seul tableau à 5 éléments ou un programme complet qui lit 5 entiers à partir de n'importe quelle entrée standard.
3. Le programme doit générer un entier 32 bits signé.
4. Le programme doit retourner 1 si et seulement si les cinq entrées, interprétées comme une séquence, correspondent à une séquence arithmétique spécifique du choix du programmeur, appelée "clé". La fonction doit retourner 0 pour toutes les autres entrées.

Une séquence arithmétique a la propriété que chaque élément successif de la séquence est égal à son prédécesseur plus une constante fixe a.

Par exemple, 25 30 35 40 45est une séquence arithmétique puisque chaque élément de la séquence est égal à son prédécesseur plus 5. De même, 17 10 3 -4 -11est une séquence arithmétique puisque chaque élément est égal à son prédécesseur plus -7.

Les séquences 1 2 4 8 16et 3 9 15 6 12ne sont pas des séquences arithmétiques.

Une clé peut être n'importe quelle séquence arithmétique de votre choix, avec la seule restriction que les séquences impliquant un débordement d'entier ne sont pas autorisées. C'est-à-dire que la séquence doit être strictement croissante, strictement décroissante ou avoir tous les éléments égaux.

Par exemple, supposons que vous choisissiez la clé 98021 93880 89739 85598 81457. Votre programme doit renvoyer 1 si les entrées (dans l'ordre) correspondent à ces cinq nombres et 0 sinon.

Veuillez noter que les moyens de protéger la clé doivent être de votre propre conception. De plus, les solutions probabilistes qui peuvent renvoyer des faux positifs avec une probabilité non nulle ne sont pas autorisées. En particulier, veuillez ne pas utiliser de hachages cryptographiques standard, y compris les fonctions de bibliothèque pour les hachages cryptographiques standard.

La notation

La ou les soumissions non fissurées les plus courtes par nombre de caractères seront déclarées gagnantes.

En cas de confusion, n'hésitez pas à demander ou à commenter.

Le contre-défi

Tous les lecteurs, y compris ceux qui ont soumis leurs propres programmes, sont encouragés à "cracker" les soumissions. Une soumission est craquée lorsque sa clé est publiée dans la section des commentaires associés. Si une soumission persiste pendant 72 heures sans être modifiée ou fêlée, elle est considérée comme «sûre» et tout succès ultérieur dans la fêlure sera ignoré pour les besoins du concours.

Voir "Clause de non-responsabilité" ci-dessous pour plus de détails sur la politique de score de craquage mise à jour.

Les soumissions fissurées sont éliminées de la contention (à condition qu'elles ne soient pas «sécuritaires»). Ils ne doivent pas être modifiés. Si un lecteur souhaite soumettre un nouveau programme, il doit le faire dans une réponse séparée.

Le ou les crackers ayant obtenu le ou les scores les plus élevés seront déclarés gagnants avec les développeurs des programmes gagnants.

Veuillez ne pas casser votre propre soumission.

Bonne chance. :)

Classement

Avant-dernier classement (en attendant la sécurité de la communication de Dennis CJam 49).

Casiers sécurisés

1. CJam 49, Dennis
2. CJam 62, Dennis en sécurité
3. CJam 91, Dennis en sécurité
4. Python 156, coffre-fort Maarten Baert
5. Perl 256, chilemagic safe
6. Java 468, géobits sûrs

Craquelins imparables

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. nitreux [C 212 *]

* soumission non conforme

Avis de non-responsabilité (mis à jour à 23 h 15 HNE le 26 août)

Avec les problèmes de notation atteignant enfin la masse critique (étant donné que les deux tiers des soumissions fissurées sont jusqu'à présent non conformes), j'ai classé les meilleurs crackers en termes de nombre de soumissions fissurées (primaire) et de nombre total de caractères dans les soumissions fissurées conformes (secondaire).

Comme précédemment, les soumissions exactes fissurées, la longueur des soumissions et leur statut conforme / non conforme sont toutes marquées afin que les lecteurs puissent déduire leur propre classement s'ils pensent que le nouveau classement officiel est injuste.

Mes excuses pour avoir modifié les règles si tard dans la partie.

CJam, 62 caractères

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

Stack Exchange a tendance à mutiler des caractères non imprimables, mais copier le code de cette pâte et le coller dans l' interpréteur CJam fonctionne très bien pour moi.

Comment ça marche

Après avoir remplacé la chaîne Unicode par une chaîne ASCII, le code suivant est exécuté:

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

Cette approche utilise le Bivium-B (voir l' analyse algébrique des chiffres de type Trivium ), une version affaiblie du chiffrement de flux Trivium .

Le programme utilise la séquence d'entiers comme état initial, met à jour l'état 434 fois (354 tours atteignent une diffusion complète) et génère 177 bits de sortie, qu'il compare à ceux de la séquence correcte.

Étant donné que la taille de l'état est précisément de 177 bits, cela devrait suffire pour identifier de manière unique l'état initial.

Exemple d'exécution

$ 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 caractères

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

Stack Exchange a tendance à mutiler des caractères non imprimables, mais copier le code de cette pâte et le coller dans l' interpréteur CJam fonctionne très bien pour moi.

Comment ça marche

Après avoir remplacé la chaîne Unicode par des entiers (en considérant les chiffres des caractères des nombres de base 65533), le code suivant est exécuté:

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

Étant donné que 13 est coprime au totient du module (le totient est secret, vous n'aurez donc qu'à me faire confiance), différentes bases généreront des résultats différents, c'est-à-dire que la solution est unique.

A moins que quelqu'un ne puisse exploiter le petit exposant (13), le moyen le plus efficace de briser ce verrou est de factoriser le module (voir problème RSA ). J'ai choisi un entier de 512 bits pour le module, qui devrait résister à 72 heures de tentatives de factorisation.

Exemple d'exécution

$ 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

Essayons celui-ci:

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

(Attend de l'utilisateur qu'il saisisse 5 nombres séparés par des virgules, par exemple 1,2,3,4,5.)

Java: 468

L'entrée est donnée sous la forme k(int[5]). Balles tôt si elles ne sont pas également espacées. Sinon, il faut un peu déterminer si les dix hachages sont corrects. Pour les grands nombres, "un peu" peut signifier dix secondes ou plus, donc cela peut dissuader les crackers.

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

Voici un casier basé sur des chaînes qui dépend à la fois du nombre de caractères saisis et de l'entrée spécifique. La séquence peut être basée sur des références obscures à la culture pop. S'amuser!

Un peu non golfé:

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: version plus courte basée sur le commentaire de Dennis. J'ai également mis à jour la séquence pour éviter de divulguer des informations.

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

Sur la base du problème de logarithme discret qui est considéré comme non craquable, cependant le premier que j'utilise est probablement trop petit pour être sécurisé (et il peut avoir d'autres problèmes, je ne sais pas). Et vous pouvez le forcer brutalement, car les seules inconnues sont deux entiers 32 bits.

Javascript 125

Celui-ci devrait être craqué assez rapidement. Je vais enchaîner avec quelque chose de plus fort.

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

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

Contrairement à l'utilisation d'un hachage cryptographique ou srand, cela est prouvablement unique (ce qui est un léger indice). Prend cinq chiffres via STDIN, délimités par un ou plusieurs caractères non numériques et non de nouvelle ligne. Sorties vers STDOUT.

GolfScript (116 caractères)

Prend les entrées sous forme d'entiers séparés par des espaces.

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

C 459 octets

RESOLU PAR Tyilo - LIRE MODIFIER CI-DESSOUS

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

Nous avons besoin de quelqu'un pour écrire une solution C, n'est-ce pas? Je n'impressionne personne avec sa longueur, je ne suis pas un golfeur. J'espère que c'est un défi intéressant!

Je ne pense pas qu'il y ait un moyen évident de le casser, et j'attends avec impatience toutes les tentatives! Je sais que cette solution est unique. Obscurcissement très minime, principalement pour répondre aux exigences de longueur. Cela peut être testé simplement:

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

PS Il y a une signification en a[0]tant que nombre à part entière, et j'aimerais voir quelqu'un le souligner dans les commentaires!

MODIFIER:

Solution: 6174, 48216, 90258, 132300, 174342

Une note sur le cracking:

Bien que ce ne soit pas la méthode utilisée (voir les commentaires), il m'est arrivé de casser mon propre chiffre avec une force brute très simple. Je comprends maintenant qu'il est d'une importance vitale de rendre les chiffres importants. Le code suivant peut déchiffrer n'importe quel chiffre où se upper_boundtrouve une limite supérieure connue a[0] + a[1] + a[2] + a[3] + a[4]. La borne supérieure du chiffre ci-dessus est 457464, qui peut être dérivée du système d'équations b[]et de certains traitements de l'algorithme. On peut le montrer 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]);
}

Avec a[0] = 6174, cette boucle a cassé mon travail en un peu moins d'une minute.

Mathematica 80 67

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

Fonctionnement:

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

Probablement assez facile à casser, pourrait également avoir plusieurs solutions.

Mise à jour: Amélioration du golf en faisant ce que Martin Büttner a suggéré. La fonctionnalité de la fonction et de la touche n'a pas changé.

Python27, 283 182

D'accord, je suis très confiant dans mon casier, mais cela fait assez longtemps que j'ai ajouté des calculs `` difficiles à inverser '' à l'entrée, pour le rendre bien - difficile à inverser.

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: Merci à colevk pour le golf. J'ai réalisé lors de l'édition qu'il y avait un bug ainsi qu'une faille dans mon algorithme, peut-être que j'aurai plus de chance la prochaine fois.

Mathematica 142 146

EDIT : la clé n'était pas unique, a ajouté 4 caractères, elle l'est maintenant.

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

(Espaces et nouvelles lignes ajoutés pour plus de lisibilité, non comptés et non nécessaires).

Usage:

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

Craqué par @Dennis en 2 heures

Juste un simple pour démarrer les choses - je m'attends à ce que cela soit rapidement craqué.

Pyth , 13

h_^ZqU5m-CGdQ

Prend une entrée séparée par des virgules sur STDIN.

Exécutez-le comme ceci (-c signifie prendre le programme comme argument de ligne de commande):

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

Correction du programme - je n'avais pas compris la spécification.

Ce langage pourrait être trop ésotérique pour ce concours - Si OP le pense, je le supprimerai.

Lua 105

Je soupçonne qu'il ne faudra pas longtemps avant qu'il ne soit fissuré, mais c'est parti:

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

(des espaces ont été ajoutés pour plus de clarté, mais ne font pas partie du décompte)

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

J'ai dû mettre dans beaucoup de logique de gestion des erreurs et cela peut certainement être beaucoup plus bas. Il imprimera un 1lorsque vous obtenez les cinq bons chiffres. Il nous l' espérons imprimer un 0pour tout le reste (peut - être des erreurs ou rien, je ne sais pas). Si quelqu'un veut aider à améliorer le code ou le jouer davantage, n'hésitez pas à aider!

Appeler avec:

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

Rubis - 130

Basé sur le registre à décalage à rétroaction linéaire. Entrées par arguments de ligne de commande.
Doit être unique en fonction de la nature des LFSR. Indice: ascendant et tout positif.

Donnera plus d'indices si personne ne le résout bientôt.

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

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

Devrait être amusant. Qui a besoin de mathématiques?

CJam, 49 caractères

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

Essayez-le en ligne.

Comment ça marche

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

%!

Le résultat sera 1 si et seulement si le deuxième entier est un facteur du premier, qui est un produit de deux nombres premiers: celui correspondant à la séquence secrète et l'autre qui ne correspond à aucune séquence valide. Par conséquent, la solution est unique.

Factoriser un entier de 512 bits n'est pas si difficile, mais j'espère que personne ne pourra le faire en 72 heures. Ma version précédente utilisant un entier de 320 bits a été cassée .

Exemple d'exécution

$ 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

Convertit les entrées en un certain nombre de types de données et effectue des manipulations pertinentes pour chaque type de données en cours de route. Devrait être assez facilement inversé pour quiconque prend le temps.

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 (fissuré par Dennis)

Allez ici pour ma soumission mise à jour.

Pourrait probablement être joué un peu plus à fond. Certes, je n'ai pas pris le temps de prouver que la clé est unique (ce n'est probablement pas le cas) mais elle est définitivement de l'ordre d'une collision de hachage. Si vous le craquez, partagez votre méthode :)

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

https://codegolf.stackexchange.com/a/36810/31064 par Orby a au moins deux clés:

13 103 193 283 373
113 173 233 293 353

Orby a demandé la méthode que j'ai utilisée pour le casser. La fonction p vérifie si x est premier en vérifiant x%i==0tout i entre 2 et x (bien qu'en utilisant (x/i)*i==xau lieu dex%i==0 ), et renvoie vrai si x est un nombre premier. La fonction f vérifie que tous a, b, c, d et e sont premiers. Il vérifie également si le nombre m, une concaténation des représentations décimales de e, d, c, b et a (dans cet ordre), est premier. La clé est telle que a, b, c, d, e et m sont tous premiers.

Green et Tao (2004) montrent qu'il existe une infinité de séquences arithmétiques de nombres premiers pour toute longueur k, il nous suffit donc de rechercher ces séquences qui satisfont également m étant premier. En prenant longtemps comme étant limité par -9.223372037e + 18 et 9.223372037e + 18, nous savons que pour que la chaîne concaténée tienne en long long, les nombres ont une limite supérieure de 9999. Donc, en utilisant un script python pour générer tous des séquences arithmétiques dans tous les nombres premiers <10000, puis en vérifiant si leur concaténation inverse est un nombre premier, nous pouvons trouver de nombreuses solutions possibles.

Pour une raison quelconque, j'ai trouvé des faux positifs, mais les deux ci-dessus sont valides selon le programme. De plus, il peut y avoir des solutions où e est négatif et les autres sont positives (p utilise le module de x), mais je ne les ai pas recherchées.

Les clés que j'ai données sont toutes des séquences arithmétiques, mais le script d'Orby ne semble pas exiger que les entrées soient une séquence arithmétique, donc il peut également y avoir des clés invalides.

MATLAB: Apparemment invalide

Très simple, il vous suffit de générer le bon nombre aléatoire.

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

Il peut toujours y avoir une erreur, mais cela ne devrait pas être un problème.

MATLAB (avec Symbolic Toolbox), 173 caractères

Ce n'est pas une entrée officielle et ne comptera pas pour le score de crack de quiconque, mais cela vous rapportera des droits de vantardise fous. ;)

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

La boîte à outils symbolique n'est nécessaire que pour gérer la soustraction de grands nombres entiers.

Brute le forçant devrait être un chien, mais si vous connaissez la série qu'elle implique, la solution est triviale.

Python 2 (91)

Edit: Ceci n'est pas autorisé car l'argument de l'unicité est probabiliste. J'abandonne.

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

Prend des listes d'entiers en entrée, comme [1,2,3,4,5].

La boucle est destinée à opérer sur les entrées de manière gênante, laissant une tour de sommes et d'exposants. L'idée est comme un journal discret, mais avec des complications compliquées au lieu de la simplicité mathématique. Peut-être que la composition du module est une vulnérabilité, auquel cas je pourrais en faire quelque chose 7**58+8.

Je ne sais pas vraiment comment je prouverais que ma clé est la seule, mais la plage de sorties est au moins 10 fois plus grande que la plage d'entrées, alors probablement? Bien que seule une petite fraction des sorties potentielles soit réalisable. Je pourrais toujours augmenter le nombre de chiffres au détriment des caractères. Je vous laisse le soin de décider ce qui est juste.

Bonne fissuration!

Mathematica - 72

Version 2 de mon script, avec la même clé que celle destinée à ma version 1.

Cela supprime essentiellement les nombres premiers négatifs pour NextPrime.

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

Fonctionnement:

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

Python, 86 caractères

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

Entrez les chiffres comme 1,2,3,4,5.

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

Python, 78

(Cracké par Tyilo en 14 minutes)

Amusement!

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

D'accord, il ne s'affiche pas correctement ici :(

Attend une liste de cinq nombres, par exemple. [1,2,3,4,5]

CJam, 37 caractères (cassé)

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

Essayez-le en ligne.

Comment ça marche

Voir ma nouvelle réponse.

Exemple d'exécution

$ 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 (fissuré)

C'est la même idée que ma soumission précédente , golfée plus en profondeur, avec un bug corrigé qui passait 0,0,0,0,0 (Merci à Dennis d'avoir signalé le bug). Compilez avec -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);}