Lockers vs Crackers: The Five-Element Sequence


31

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.


6
Comment allez-vous vérifier que les programmes satisfont au point 4? Vous attendez-vous à ce que les gens modifient leurs réponses sûres pour ajouter une preuve? Les soumissions probabilistes sont-elles autorisées sur la base de l'hypothèse que les fonctions de hachage sont idéales et que le risque de collision avec un autre élément de l'espace de 48 bits (selon votre estimation ci-dessus) est négligeable?
Peter Taylor

2
Le système de notation semble encourager les crackers à ignorer les verrous les plus courts car ils obtiennent de meilleurs résultats en cassant deux longs verrous que deux petits.
Peter Taylor

3
@COTO Je pense que le problème est que vous pouvez seulement obtenir 2 scores de fissuration, et seulement les plus brefs. Alors pourquoi ne pas attendre et espérer et plus on se montre? Par exemple, Martin n'est plus incité à casser mon (plus) verrou, car il en a déjà cassé deux plus courts. Quiconque craque le mien va maintenant le battre sans même avoir à en faire un deuxième.
Geobits

1
Je pense qu'un meilleur système de notation pourrait être la somme des temps totaux entre la question et le crack. De cette façon, casser un tas de simples peut être battu, et la vraie récompense vient de casser les vraiment difficiles.
isaacg

1
Je suis novice dans le golf, alors c'est peut-être une question stupide, désolé pour ça. Pourquoi la longueur du code est-elle mesurée en caractères et non en octets? Ce dernier est littéralement l'espace mémoire qu'un programme occupe, donc cela me semble plus logique. Par exemple. la réponse CJam est la plus courte en caractères, mais quand on regarde sa taille (326 à cause de l'unicode), elle n'est même pas dans le top 5. Alors je me demande, est-il courant de jouer au golf pour compter les caractères au lieu des octets?
freddieknets

Réponses:


3

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

6

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

J'ai posté une nouvelle version depuis que j'ai oublié de supprimer un caractère inutile de la première. La séquence secrète est toujours la même, vous pouvez donc essayer de casser l'un ou l'autre.
Dennis

Pour info, j'abandonne ma tentative d'affacturage. msieve s'est fixé un délai de 276 heures, mais c'était uniquement pour construire la base de facteurs. En ce temps-là found 1740001 rational and 1739328 algebraic entries; il a depuis eu près de 100 heures pour les traiter, et les rapports sieving in progress b = 46583, 0 complete / 0 batched relations (need 44970493).
Peter Taylor

@PeterTaylor: On dirait que 512 bits étaient exagérés. Avez-vous essayé de factoriser l'entier dans mon autre réponse ou dans celle-ci?
Dennis

Oh, oups. Oui, l'autre.
Peter Taylor

4

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


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

Wow, c'était rapide! Tu as raison! Et je suis sorti.
Falko

3
Btw, ce n'est pas réellement valide, car vos cinq entiers ne tiennent pas dans un entier 32 bits.
Martin Ender

4

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

1
Votre code se bloque si la séquence arithmétique d'entrée est décroissante. Ou du moins, cela prend beaucoup de temps. Ce qui me fait penser que le code secret est croissant ...
Keith Randall

3
@KeithRandall Oups. Ajoutons quatre octets pour que les séquences descendantes prennent un temps inhabituellement court , renforçant encore votre croyance.
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;}

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

2
8675309? 90210?
Malachi

1
@Malachi Deux références exceptionnelles, sans aucun doute, mais je ne peux ni confirmer ni nier leur applicabilité à cet exercice.
Geobits

lol, je n'ai pas encore complètement compris comment ce défi fonctionne complètement, je vais peut-être essayer plus tard quand je serai à la maison.
Malachi

1
Le terme initial est -8675309, delta est 5551212.
Peter Taylor

@PeterTaylor Bien joué :)
Geobits

4

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.


Les logarithmes discrets sont beaucoup plus difficiles que je pensais. Mon cracker est là depuis 26 heures. J'abandonne.
Dennis

Vous pouvez résoudre le problème des signes en initialisant c=1, en calculant c=(c<<32)+det en modifiant la constante en conséquence.
Dennis

3

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

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

oui vous l'avez compris :)
rdans

3

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.


Oui, j'ai oublié qu'ils étaient signés.
histocrat

2
622238809,1397646693,2173054577,2948462461,3723870345(ma supposition précédente avait une erreur, mais celle-ci est testée). Je ne pense pas que cela soit valable, car le dernier nombre ne tient pas dans un entier 32 bits signé.
Martin Ender

3

GolfScript (116 caractères)

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

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

2
-51469355 -37912886 -24356417 -10799948 2756521
Dennis

Bon travail. Avez-vous exploité le petit exposant?
Peter Taylor

2
Non, j'ai factorisé le module. Cela n'a pris que 13 secondes en utilisant le tamis quadratique polynomial multiple et le PyPy de primo .
Dennis

Dans ce cas, je ferais aussi bien d'abandonner mon golf actuel en utilisant un module exprimé de manière compacte. Si le résultat doit être de l'ordre de 1024 bits pour être sûr de la factorisation, même en utilisant une représentation en base 256, cela va être trop long.
Peter Taylor

J'espère que non. Ma réponse utilise la même idée que la vôtre, mais avec un module de 512 bits et un exposant encore plus petit (13). Compte tenu du délai de 72 heures, cela pourrait être suffisant ...
Dennis

3

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.


6
Solution: 6174, 48216, 90258, 132300, 174342.
Tyilo

Wow, c'était rapide. Joli. Bruteforced, ou avez-vous trouvé quelque chose d'intelligent que j'ai manqué?
BrainSteel

J'ai utilisé l'évaluation symbolique de Mathematica comme ceci: ghostbin.com/paste/jkjpf capture d'écran: i.imgur.com/2JRo7LE.png
Tyilo

Concernant le montage: j'ai fait essentiellement la même chose, mais j'ai truqué le haut à 500k. J'ai obtenu la réponse et j'ai vu que Tyilo l'avait déjà postée :(
Geobits

@Geobits C'est une supposition étonnamment précise. J'aurais dû mettre plus de 0 à la fin de ces chiffres.
BrainSteel

3

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


@ MartinBüttner Amélioration des réponses pour obtenir un score plus élevé lorsque vous les crackez. Smart; P
Tyilo

Huh, il s'avère que j'ai sauté le paragraphe sur la notation pour le contre-défi. Je pensais que c'était juste pour le plaisir sans aucun score. Bien que je ne pense pas que cela aurait du sens pour moi de raccourcir les solutions que je veux craquer car cela réduirait mon score.
Martin Ender

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

@freddieknets Ce n'est pas la solution que j'ai utilisée lors de sa création. Je ne savais pas que cela NextPrimepourrait retourner des valeurs négatives. Comment avez-vous trouvé?
Tyilo

Alors votre clé n'est pas unique: p. Je viens de faire quelques tests - il n'y a vraiment pas beaucoup de nombres où NextPrime [#] - # est évalué à 31, c'est donc un moyen facile de le casser.
freddieknets

2

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.


5
Ceci est invariant lors de la réorganisation des arguments, donc ce n'est pas un casier valide.
Peter Taylor

D'ailleurs, je soupçonne que le code tel qu'il est affiché est bogué: la clé 121174841 121174871 121174901 121174931 121174961fonctionne, mais seulement si la liste [1,3,5,7]de la ligne 7 est remplacée par [1,3,5,7,11].
Ilmari Karonen

Bon sang, oui je venais de corriger ma faute de frappe, au cours de laquelle j'ai fait une erreur cruciale dans mon algorithme, le laissant très facile à craquer: |
stokastic

En fait, trouver et corriger le bogue était la partie difficile; étant donné votre algorithme, factoriser la constante était une chose évidente à essayer.
Ilmari Karonen

2

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

1
Terme initial 256208, delta -5.
Peter Taylor

Dang, alors ce n'est pas unique, car ce n'est pas ma clé d'origine. Avez-vous brutalisé?
freddieknets

Testez-le, j'ai peut-être fait une erreur car je n'ai pas accès à Mathematica pour le tester. Chaque étape utilise la force brute, mais ce n'est pas beaucoup de temps d'ordinateur. L'approche consiste à revenir en arrière jusqu'à la sortie de IntegerDigits, puis à factoriser pour obtenir des candidats pour le mandat initial et le delta.
Peter Taylor

Mais il est impossible que cette approche soit unique de toute façon. La seconde des cinq entrées n'est utilisée que dans une somme qui est transmise à NextPrime; si nous la modifions de plus ou moins un, au moins l'un d'eux donnera le même nombre premier suivant.
Peter Taylor

oui mais pour une séquence arithmétique - comme c'est l'entrée requise - elle était supposée être unique.
freddieknets

1

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.


7
Vous venez de révéler que 1,2,3,4,5c'est la clé?
Peter Taylor

1
Chaque entrée que j'ai essayée renvoyait 1, avez-vous changé 1 et 0 en sortie?
Tyilo

Désolé, je n'ai pas compris la distinction Sortie / Retour - le programme devrait fonctionner maintenant. Même algorithme sous-jacent.
isaacg

3
97,96,95,94,93(Je viens de tuer mon score de cracking.)
Dennis

@Dennis Bien joué. Le système de score de cracking doit être changé - cela crée des incitations vraiment étranges.
isaacg

1

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)


3, 7, 11, 15, 19ou6, 14, 22, 30, 38
Dennis

@Dennis: malheureusement ce n'est ni l'un ni l'autre. Je devrai y travailler un peu plus tard pour garantir la non-unicité.
Kyle Kanos

t1==0quand Saugmente. De plus, les deux conditions sont homogènes; si Sest une solution, il en est de même 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}}

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

1

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

3
Valeur initiale 781783, incrément 17982811
Peter Taylor

@PeterTaylor Argh ... =)
Vectorisé

1

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?


2
309, 77347, 154385, 231423, 308461mais je ne pense pas que ce soit unique.
Martin Ender

Ouais, ça ne l'est pas. Pour le même regex (ie produit des deux premiers nombres), je trouve aussi 103, 232041, 463979, 695917, 927855et 3, 7966741, 15933479, 23900217, 31866955. Et je suis presque sûr qu'il existe d'autres expressions rationnelles valides en utilisant des +s supplémentaires .
Martin Ender

Désolé, je suppose que j'ai foiré la chaîne de test. Il ne devait y avoir qu'une seule expression rationnelle avec une factorisation unique.
histocrate

Si vous voulez essayer de le réparer, assurez-vous de prendre en compte les quantificateurs possessifs. Je peux également créer un regex équivalent plus grand en insérant ()ou similaire.
Martin Ender

1

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

J'ai fait fonctionner msieve dessus pendant plus de 24 heures, mais comme sa limite de temps auto-imposée est de 276,51 heures CPU et que je ne lui ai donné qu'un processeur, je ne suis pas optimiste.
Peter Taylor

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

5
Brute forcée:320689, 444121, 567553, 690985, 814417
Tyilo

@Tyilo Si vous vous arrêtez maintenant, je pense qu'aucun cracker ne peut battre votre score. ;)
Martin Ender

2
@ MartinBüttner À moins que cela puisse être joué à moins de 512 par OP, je ne pense pas que cela compte.
Geobits

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

1
Alors 0 0 0 0 0?
Dennis

Soupir c'était un bug, mais oui ça marche.
Orby

J'ai mis à jour avec une version corrigée qui devrait être un peu plus intéressante;)
Orby

Voir la version corrigée ici .
Orby

0

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.


0

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.


1
Cette approche est interdite dans les commentaires. Si ce n'est pas mentionné dans la question, proposez une modification. Désolé.
Peter Taylor

@PeterTaylor Je suppose que je suis sorti alors, je vais le laisser ici sans score car je suis curieux de savoir si quelqu'un peut trouver une faiblesse.
Dennis Jaheruddin

0

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.


0

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!


0

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

En supposant que j'ai bien compris ce que fait votre code, j'obtiens plusieurs solutions dont la plus petite est le terme initial 9244115, delta 25.
Peter Taylor

@PeterTaylor Je peux confirmer que celui-ci est valide.
Martin Ender

@PeterTaylor correct, une autre clé est1073743739, 1073886396, 1074029053, 1074171710, 1074314367
Tyilo

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

Ce n'est pas une soumission valide; il accepte l'entrée 1,0,1,63021563418517255630720,0.
Dennis

@Dennis Fixed. J'espère que c'est valable maintenant.
Snack

1
19960211, 31167202, 42374193, 53581184, 64788175
Dennis

@Dennis Correct et génial. Je pense que je suis très pauvre en mathématiques.
Snack

2
@Dennis, 63021563418517255630720n'est pas un nombre 32 bits.
Peter Taylor


0

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

1
737262825 208413108 3974530688 3445680972 2916831257fonctionne mais n'est pas une progression arithmétique. Facturée en 3 heures 20 minutes. Les numéros 512 bits étaient apparemment faisables en 72 heures pour 75 $ sur EC2 il y a deux ans, donc je pense que cela aurait été sûr.
Peter Taylor

@PeterTaylor: Cela renvoie 1, mais les trois derniers entiers sont supérieurs à MAX_INT, donc ce n'est pas une clé valide. Cela dit, 3 h 20 m est assez impressionnant. L'algorithme que j'utilisais a pris 16 heures pour un semi-prime 256 bits ...
Dennis

Je pensais qu'il devait y avoir des chiffres négatifs quelque part parce que les deltas étaient presque corrects mais pas tout à fait. J'y vais.
Peter Taylor

1
737262825 208413109 -320436607 -849286323 -1378136039
Peter Taylor

@PeterTaylor: C'est celui-là. J'espère que la version 512 bits dure plus longtemps.
Dennis

-2

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

Toute séquence (arithmétique ou non) de nombres premiers négatifs fonctionnera. Deux exemples: -7 -37 -67 -97 -127,-157 -127 -97 -67 -37
Dennis

Ouais, mon code est juste criblé de bugs. La réponse que nitreux a donnée va dans le sens de ce que je cherchais. Mais bon travail en soulignant les réponses les plus évidentes.
Orby
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.