Questo concorso è finito.

Non ci sono ancora risposte risolvibili nella sfida della polizia.

Discussione complementare dell'hash golf crittografico

Come promemoria, ecco le regole per i ladri della sfida principale:

Compito

Crack uno qualsiasi dei poliziotti osservazioni inviando quanto segue nella briganti filo: due messaggi M e N in mi tale che H (M) = H (N) e M ≠ N .

punteggio

Infrangere ogni invio di poliziotti ti fa guadagnare un punto. Vince il ladro con il maggior numero di punti.

In caso di pareggio, vince il ladro che ha spezzato la sottomissione più lunga.

Regole aggiuntive

• Ogni invio di poliziotti può essere decifrato solo una volta.

• Se l'invio di un poliziotto si basa su un comportamento definito o non definito dall'implementazione, devi solo trovare un crack che funzioni (in modo verificabile) sul tuo computer.

• Ogni crack appartiene a una risposta separata nel thread dei ladri.

• Pubblicare un tentativo di cracking non valido ti vieta di crackare quel particolare invio per 30 minuti.

• Non puoi infrangere la tua stessa richiesta.

Esempio

Python 2.7, 22 byte dall'utente8675309

1

e

18

Classifica

1. eBusiness: 3 crepe, 393 byte
2. Martin Büttner: 3 crepe, 299 byte
3. jimmy23013: 3 crepe, 161 byte
4. Sp3000: 3 crepe, 44 byte
5. tucuxi: 2 crepe, 239 byte
6. Vi .: 2 crepe, 87 byte
7. feersum: 1 crack, 216 byte
8. Mathmandan: 1 crack, 139 byte
9. ossifrage schizzinoso: 1 crack, 134 byte

C, 122 byte - a cura di: sig. Llama

bmaj8PCosFLAJjeHaevvvchnJedmg2iujpePOPivI2x2asw0yKa2eA15xvFJMFe82RGIcdlvxyaAPRuDuJhFjbh78BFsnCufJkarwEyKa0azHxccw5qegpcP9yaO0FKoohanxgiAfK1Lqwba51bKtjacbvdjMmcBkiv8kd62sBd98c4twa98sgj3iPh7nkP4
rlaejTPrua1DhBdg0jrIoDBi8fc1GIJAigivIGaxs1OmfPcctNadK3HErvzPLCeDPD8fkMNPCBcIwuoGfEHegOfk9k9pwktslqaBenaati1uNthMiyk9ndpy7gdIz88iot6A09cbNeIMheyjBvbeegL7aGp7mCb91hCxnvgV5abfImrPfLbrbraAsN6loJgh

Hash di entrambe le stringhe bb66000000000000d698000000000000

Proprio come "C, 128 byte - by: squeamish ossifrage" i bit di ordine superiore non influenzano mai i bit di ordine inferiore, questo può essere sfruttato.

Codice

Visual C ++, utilizza operazioni di stringa " non sicure "

#include "stdafx.h"
#include <string>
#include <iostream>
#include <fstream>

long long x, y;

//Original hash function (not used for cracking).
void h(char inp[]){
    long long c;
    int index = 0;
    int len = strlen(inp);
    x = 0;
    y = 0;
    long long p = 0;
    for (c = 9; c ; c = (index<len?inp[index++]:-1) + 1) {
        for (++p; c--;) {
            x = x*'[3QQ' + p;
            y ^= c*x;
            y ^= x ^= y;
        }
    }
    printf("%016llx%016llx\n", x, y);
}

//Partial hash, takes a string and a starting point in the stream.
//The byte 0x08 must be prepended to a string in order to produce a full legal hash.
void hp(char inp[],long long p){
    long long c;
    int index = 0;
    int len = strlen(inp);
    x = 0;
    y = 0;
    for (index = 0; index<len; index++) {
        c = inp[index] + 1;
        for (++p; c--;) {
            x = x*'[3QQ' + p;
            y ^= c*x;
            y ^= x ^= y;
        }
    }
}

//Reverse partial hash, backtracks the inner state.
void hprev(char inp[], long long p){
    long long c;
    long long clim;
    int index = 0;
    int len = strlen(inp);
    p += len + 1;
    x = 0;
    y = 0;
    for (index = len-1; index>=0; index--) {
        clim = inp[index] + 1;
        c = 0;
        for (--p; c<clim;c++) {
            y ^= x;
            x ^= y;
            y ^= c*x;
            x -= p;
            x = x * 17372755581419296689;
            //The multiplicative inverse of 1530089809 mod 2^64.
        }
    }
}
const int rows = 163840;
const int maprows = 524288;

//Store for intermediate input strings, row 0 contains 64 columns with 3-char strings,
//row 1 contain 32 columns with 6-char strings and so forth, the final strings will
//contain one string from each column, in order.
char store[7][rows][512];

//Storage for a hashmap, used for matching n strings with n string in O(n) time.
char map[maprows][512];

int _tmain(int argc, _TCHAR* argv[])
{
    char alpha[] = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    int row;
    int col;
    int layer;
    int a=0, b=0, c=0;
    int colzero;
    //Produce some starting strings.
    for (row = 0; row < rows; row++){
        //All column 0 strings begin with 0x08 in order to imitate the hash.
        store[0][row][0] = 8;
        colzero = 1;
        for (col = 0; col < 64; col++){
            store[0][row][col * 8 + colzero] = alpha[a];
            store[0][row][col * 8 + colzero + 1] = alpha[b];
            store[0][row][col * 8 + colzero + 2] = alpha[c];
            store[0][row][col * 8 + colzero + 3] = 0;
            colzero = 0;
        }
        a++;
        if (a >= 52){
            b++;
            a = 0;
            if (b >= 52){
                c++;
                b = 0;
            }
        }
    }
    //Layer for layer, column for column, build strings that preserve successively
    //more zero bits. Forward calculated partial hashes are matched with backwards
    //calculated partial hashes.
    for (layer = 1; layer < 7; layer++){
        int slayer = layer - 1;
        int swidth = 1 << (slayer + 3);
        int width = 1 << (layer + 3);
        int slen = 3 << slayer;
        int len = 3 << layer;
        int colnum;
        int layershift=slayer*8;
        for (col = 0,colnum=0; col < 512; col+=width,colnum++){
            printf("Layer: %i, column: %i\n",layer,colnum);
            memset(map, 0, sizeof map);
            int col2 = col + swidth;
            for (row = 0; row < rows; row++){
                hprev(store[slayer][row] + col2, 1 + slen*(1 + colnum * 2));
                x = (x >> layershift) & 255;
                y = (y >> layershift) & 255;
                int index = (x << 3) | (y << 11);
                for (a = 0; a < 8; a++){
                    if (map[index + a][0] == 0){
                        strcpy_s(map[index + a], store[slayer][row] + col2);
                        break;
                    }
                }
            }
            int destrow = 0;
            for (row = 0; row < rows && destrow < rows; row++){
                hp(store[slayer][row] + col, !!colnum + slen*(colnum * 2));
                x = (x >> layershift) & 255;
                y = (y >> layershift) & 255;
                int index = (x << 3) | (y << 11);
                for (a = 0; a < 8 && destrow < rows; a++){
                    if (map[index + a][0]){
                        strcpy(store[layer][destrow] + col, store[slayer][row] + col);
                        strcat(store[layer][destrow] + col, map[index + a]);
                        destrow++;
                    }
                }
            }
        }
    }
    memset(map, 0, sizeof map);
    char temp[1000];
    std::ofstream myfile;
    myfile.open("hashout.txt");
    for (row = 0; row < rows; row++){
        hp(store[6][row], 0);
        sprintf(temp, "%016llx%016llx", x, y);
        myfile << store[6][row] <<" " << temp << "\n";
    }
    myfile << "\n";
    //The final hash set has 96 of 128 output bits set to 0, I could have gone all
    //the way, but this is enough to find a collision via the birthday paradox.
    for (row = 0; row < rows; row++){
        hp(store[6][row], 0);
        long long xc = x;
        long long yc = y;
        int pos = (xc >> 45 | ((yc >> 48) & 7)) & (maprows-1);
        while (map[pos][0]!=0){
            hp(map[pos], 0);
            if (x == xc && y == yc){
                myfile << store[6][row] << "\n" << map[pos] << "\n";
                sprintf(temp,"%016llx%016llx", x, y);
                myfile << temp << "\n\n";
            }
            pos = (pos + 1) % maprows;
        }
        strcpy_s(map[pos], store[6][row]);
    }
    myfile.close();
    printf("done");
    getchar();
    return 0;
}

Python, 109 byte di Sp3000

Nota che Martin si è rotto per primo, quindi non sono sicuro che questo meriti punti. D'altra parte, ho fatto un attacco preimage piuttosto che una semplice collisione - un risultato molto più forte. Questo significa che puoi dargli un valore hash arbitrario e costruirà un input che genera quel valore hash.

M = 2**128

# The hash to crack.
def jenkins(n):
    h = 42
    while n:
        h += n & (M - 1)
        n >>= 128
        h *= 1025
        h ^= h >> 6
        h %= M

    h *= 9
    h ^= h >> 11
    h *= 32769

    return h % M

def egcd(a, b):
    if a == 0:
        return (b, 0, 1)
    else:
        g, y, x = egcd(b % a, a)
        return (g, x - (b // a) * y, y)

def modinv(a, m):
    g, x, y = egcd(a, m)
    if g != 1:
        raise Exception('modular inverse does not exist')
    else:
        return x % m

def invxorshift(h, s):
    r = h >> s
    while r:
        h ^= r
        r >>= s
    return h

def moddiv(a, b):
    return (a * modinv(b, M)) % M

def jenkins_crack(h):
    h = moddiv(h, 32769)
    h = invxorshift(h, 11)
    h = moddiv(h, 9)
    h = invxorshift(h, 6)
    h = moddiv(h, 1025)
    h -= 42
    return h

E per dimostrare che funziona:

>>> from crack import *
>>> n = 2**128 + 1337
>>> h = jenkins(n)
>>> n2 = jenkins_crack(h)
>>> h2 = jenkins(n2)
>>> n != n2
True
>>> h == h2
True

E per dare una serie particolare di numeri che si scontrano:

N: 2**128
M: 43617

Python, 109 byte di Sp3000

340282366920938463463374607431768211414

e

113982837842983129870077688367927159293402923522160868689804433865221255200726

entrambi cedono

132946164914354994014709093261515948032

L'algoritmo suddivide l'input in blocchi di 128 bit e modifica ripetutamente l'hash (seeded in 42) con ogni blocco, prima di eseguire un ulteriore hash alla fine. Per trovare una collisione, il nostro obiettivo è trovare due numeri che producano lo stesso risultato dopo aver eseguito il seguente pseudo codice su ogni blocco:

hash += chunk
hash += (hash << 10)
hash ^= (hash >> 6)
hash %= 2**128

Dato che l'hash è preso mod 2 ¹²⁸ , vogliamo cercare numeri che spostino tutte le cose interessanti al di fuori di questo intervallo di bit. Ma l'hash viene seminato in 42modo che abbia alcuni bit non così significativi impostati per iniziare:

000000000000000000000000 ... 000000000000000000101010

La mia idea era di liberarmi di quei pezzi quando aggiungevo il primo pezzo. Quindi proviamo 2 ¹²⁸ -42:

           000000000000000000000000 ... 000000000000000000101010     hash = 42
           111111111111111111111111 ... 111111111111111111010110     chunk = 2**128 - 42
          1000000000000000000000000 ... 000000000000000000000000     hash += chunk
10000000001000000000000000000000000 ... 000000000000000000000000     hash += hash << 10
10000010001000001000000000000000000 ... 000000000000000000000000     hash ^= hash >> 6
           000001000000000000000000 ... 000000000000000000000000     hash %= 2**128

È abbastanza semplice, quindi proviamo a usarlo come uno dei due numeri. (In effetti, il primo numero della collisione ho usato è 2 ¹²⁸ -42.

Ora come possiamo trovare un altro numero con lo stesso risultato? Bene dopo una ripetizione l'hash non è 42più, ma 2**122come abbiamo appena mostrato. Ora aggiungendo un secondo blocco al nostro numero di input, possiamo eseguire un'altra iterazione. Possiamo scegliere il secondo pezzo con lo stesso argomento di questo, cioè vogliamo 2 ¹²⁸ -2 ¹²² . Quindi il risultato intermedio successivo hash += chunksarà identico e alla fine si otterrà lo stesso risultato.

Quindi possiamo calcolare i due numeri della collisione:

>>> 2**128-42
340282366920938463463374607431768211414L
>>> 2**128-42 + ((2**128-2**122)<<128)
113982837842983129870077688367927159293402923522160868689804433865221255200726L

Possiamo facilmente generare molte più collisioni come questa.

Mathematica, 89 byte di LegionMammal978

0

e

16

Entrambi cedono 0.

Il principio di questo poliziotto è di far evolvere un automa cellulare binario 1-D "casuale" da una condizione iniziale "casuale" per un numero "casuale" di passi, e quindi interpretare le prime 128 celle del risultato come un numero intero.

Il problema è che la regola è determinata semplicemente da Mod[#^2,256], in modo tale che qualsiasi multiplo di 16 dia la regola 0, che è la banale regola in cui tutte le celle sono sempre zero. Se l'ingresso non è divisibile per 99, evolveremo di almeno 1 passo, quindi l'uscita è sempre zero. Quindi ogni due multipli che non sono multipli di 99 si scontrano sicuramente. Tuttavia, 0 anche input dà 0 (nonostante non usi mai la regola), perché la condizione iniziale è solo la rappresentazione binaria dell'input (che in questo caso è tutto azzerato).

A parte, possiamo trovare altre collisioni che sono completamente indipendenti dalla regola. Come notato sopra, qualsiasi multiplo di 99 significa che l'automa cellulare non si è affatto evoluto, quindi il risultato è semplicemente il primo (più significativo) 128 bit della condizione iniziale ... che è esso stesso solo il numero di input. Quindi se prendiamo due multipli che non differiscono nei primi 128 bit (imbottiti a destra con zero), otteniamo anche una collisione. L'esempio più semplice di questo è M = 99, N = 99*2 = 198.

J, 39 byte

Il primo numero è:

10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000

Cioè, 10000000ripetuto 64 volte. Il secondo numero è quello più uno, cioè

10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000001

Entrambi cedono

322124197561777885386414076216564234267

Spiegazione

Cominciamo con x := H 10000000 = 146018215378200688979555343618839610915, e y := 2^128. Invece di trovare a, btale a == b mod y, cercheremo a, btale x^a == x^b mod y, facendo uso delle torri di potere dell'algoritmo.

Ma ce ne devono essere alcuni ktali x^k == 1 mod y, dal momento che x, ysono coprimi, e per questo kdobbiamo avere a == b mod k. Quindi possiamo trovare il logaritmo discreto di 1 mod ye per il primo passo otteniamo

x ^ (k = 85070591730234615865843651857942052864) == 1 mod 2^128

Quindi ora vogliamo trovare due numeri a, btali a == b mod k. Per fare questo, abbiamo impostato yper essere ke cercare di trovare a, btali che x^a == x^b mod yancora una volta. Usando la stessa logica, prendiamo di nuovo il logaritmo discreto e otteniamo

x ^ (k = 21267647932558653966460912964485513216) == 1 mod 85070591730234615865843651857942052864

Lo ripetiamo fino a quando non arriviamo a un piccolo y, a quel punto è banale trovare due numeri che hanno lo stesso modulo y. Dopo 63 iterazioni y = 4, a quel punto praticamente funzionano due numeri.

Ecco il codice Mathematica per generare la catena di registro discreta:

k = 0; x = 146018215378200688979555343618839610915; y = 2^128; While[y > 10, y = MultiplicativeOrder[x, y]; k++; Print[k, " ", y]];

Questo dà il seguente output .

Pyth, 8 byte di FryAmTheEggman

99999999999999999999999999

e

99999999999999999999999998

La precisione in virgola mobile non è abbastanza grande per questo.

CJam, 44 byte, utente jimmy23013

I numeri sono troppo grandi per essere pubblicati, quindi eccoli su Pastebin: num 1 , num 2 .

Il primo numero è 600^2 = 360000uno. Il secondo numero è lo stesso, ad eccezione delle seguenti modifiche:

Positions to change to "2": 605, 1811, 3001, 6603
Positions to change to "4": 1805, 3003, 57348, 208895
Positions to change to "5": 602, 1201, 2405, 3004
Positions to change to "6": 1203, 1802
Positions to change to "7": 12, 609, 5401, 7200
Positions to change to "8": 1, 2, 4, 6, 600, 1200, 1808, 2400, 3600, 4803

Entrambi gli hash 271088937720654725553339294593617693056.

Spiegazione

Diamo un'occhiata alla prima metà del codice:

lW%                e#  Read input number as string, and reverse
600/               e#  Split every 600 digits, forming a 2D array
_z                 e#  Duplicate and zip, swapping rows and columns
{           }%     e#  For both arrays...
 JfbDb             e#  Find sum of S[i][j]*13^i*19^j, where S are the character values
                   e#  and the indices are from right to left, starting at 0.
      GK#          e#  Take modulo 16^20

         ...  ...  e#  (Rest of code irrelevant)

Quindi, se riusciamo a trovare due numeri di input in modo che le somme di S[i][j]*13^i*19^jsiano lo stesso modulo 16^20sia per l'array iniziale da 600 che per l'array zippato, allora abbiamo finito.

Per rendere le cose un po 'più semplici, prenderemo in considerazione solo 600^2 = 360000i numeri di input -digit, in modo che l'array da 600 sia solo un 600 per 600 quadrati di cifre. Questo rende le cose più facili da visualizzare ed è valido da allora 10^360000 ~ 2^(2^20.19) < 2^(2^30). Per semplificare ulteriormente le cose, considereremo solo tali stringhe di input il cui quadrato delle cifre è simmetrico lungo la diagonale principale, in modo che l'array originale e l'array zippato siano gli stessi. Questo ci consente anche di ignorare l'inversione della stringa iniziale e la numerazione dell'indice da destra a sinistra, che si annullano a vicenda.

Per iniziare, possiamo prendere il primo numero come 360000uno. Per ottenere il secondo numero, vogliamo modificarlo cambiando alcune cifre in modo che le somme siano lo stesso modulo 16^20, preservando la simmetria del quadrato delle cifre. Lo realizziamo trovando un elenco di triple in (i, j, k)modo che

sum of k*(13^i 19^j + 19^i 13^j) == 0 mod 16^20

dov'è 1 <= k <= 8l'importo per aumentare la cifra 1 di (ovvero cambiando in una cifra da 2 a 9 - avremmo potuto includere 0 ma non ne avevamo bisogno) e 0 <= i < j < 600sono coppie di indici.

Una volta che abbiamo i (i, j, k)tre gemelli, abbiamo cambiare le cifre in (i, j)e (j, i)per 1+kottenere il secondo numero. Le terzine sono state trovate usando un avido algoritmo di backtracking e per il secondo numero sopra il quadrato delle cifre appare come:

188181811111711 ...
815112111711111 ...
851611111111111 ...
116114118112111 ...
811115111111111 ...
121451111111111 ...
811111111111111 ...
111111111111111 ...
111811111111111 ...
171111111111111 ...
111111111111111 ...
111211111111111 ...
711111111111111 ...
111111111111111 ...
111111111111111 ...

............... .
...............  .
...............   .

Ad esempio, (i, j, k) = (0, 1, 7)corrisponde alla modifica delle cifre (0, 1)(posizione 600*0 + 1 = 1) e (1, 0)(posizione 600*1 + 0 = 600) in 1 + 7 = 8.

Ecco il backtracker in Python 3, anche se un'attenta ispezione ha rivelato che siamo stati abbastanza fortunati, poiché in realtà non è accaduto alcun backtracking:

n = 16**20
L = [(k *(pow(13,i,n)*pow(19,j,n) + pow(19,i,n)*pow(13,j,n)) % n, i, j, k)
     for i in range(600) for j in range(600) for k in range(1, 9) if i < j]

L.sort(reverse=True)
stack = [(n, 0, [])]

while stack:
    k, index, result = stack.pop()

    if k == 0:
        print(result)
        break

    if index == len(L):
        continue

    stack.append((k, index+1, result)) # Don't include triplet

    if L[index][0] <= k:
        stack.append((k - L[index][0], index+1, result + [L[index][1:]])) # Include

Per un bonus, ecco una porta non molto efficiente dell'hash in Python 3. Era inutile.

PHP 4.1, 66 byte di Ismael Miguel

$ A=0111129112911291111111111111111111111111 php hash.php 2> /dev/null ; echo
0100038003800381129111111111111111111111
$ A=0111129112911291129111111111111111111111 php hash.php 2> /dev/null ; echo
0100038003800381129111111111111111111111
$ cat hash.php 
<? $a = getenv("A"); for($l=strlen($b.=$a*1);$i<40;$o.=+$b[+$i]^"$a"/$a,$i++);echo$o;

Trovato utilizzando hashing iterato semplice, a partire da 1:

$ i=1; while true; do i=$(A=$i php hash.php  2> /dev/null); echo $i; done | head -n 10
0111111111111111111111111111111111111111
0100000000000001129111111111111111111111
0111129111111111111111111111111111111111
0100038000000001129111111111111111111111
0111129112911111111111111111111111111111
0100038003800001129111111111111111111111
0111129112911291111111111111111111111111
0100038003800381129111111111111111111111
0111129112911291129111111111111111111111
0100038003800381129111111111111111111111

Python 3 (216) di Sp3000

I miei messaggi sono

5012053369354645637214643587103597313576086380250249302980438772005248488380915054746146050001036696049972235875591571028140916001206596142280971107479334216535925703480968283657357930602076844092875640359192729378384507238123245417656548512647301639542279794868512420586823155070914644206130805893968511673770843170450832829657206145931885656157628306896903719624729809643572222159364893644113710867223921580178741177106141068298067479650611992859787419779579962211254029169589775046869542029842374359998053713002047081002506346875804341770199884355810931652447801492691887376948615365487982834690942054717077615539311699691010938426302886867891090301248321702485904291177813145565144089044261424329155436660979948932491709511914065619715728353376578192548334780893602675684085757434059540582004872746967999949306946618036846307799677491651967418565531672392468089533111553281620101129322575737949904022139471688252420467041529301533363008476437812216585923822571793353317799365005036029476865
5012053369354645637214643587103103086948976188724715498910865650846170784131001427390927276355140411160919276493388206817700368694224128444524223814513348177926532982330730066315320819293979046126543806115318009892783577432467861426768883700930779409885418980853424256180864755881414774514084197887594253752179391098292488771920695965135791582218083012144604515253506370334133858904659263953147111654656123599460222236152128559750436960308887683690915261431659087040402402092795259541564130228515353133867041828417398395559815392177084002004583988047406317670433664624642858480970640416500369367395538257341309676777745698712896295462462064271676447460293684100001583256400774270688958051470568447233589146620275159126426142305307007744396679875427883384557759778766330566230012377845843842097372663092379922300568052486301863154557664156185573021849420011058607321977550938866119133331529852821217331665195832442542012455132139770813510559894254061471149750738447764616026512400623344132554752

Ho usato questo codice Python 2 per generarli:

a,b = 14460445391122031029,16815296360833931837 #http://www.numberempire.com/numberfactorizer.php
pr = ~-a * ~-b

m0 = reduce(long.__or__, [long(b) << 26*i for i,b in enumerate(bin(pr)[2:])])
m1 = 1 << 26*i-1
m0 |= m1

#print m0, m1
print f(m0), f(m1)

Il grande modulo era un prodotto di due numeri primi ae b. Immagino che la speranza fosse che NP fosse impossibile per noi fattorizzare il semiprime, ma immagino che 128 bit siano troppo piccoli in quanto alcune pagine web mi hanno dato la risposta immediatamente.

Il modulo moltiplicativo abavrà un ordine (a - 1) (b - 1), il che significa che se aumentiamo un numero a quella potenza, dovrebbe risultare in 0 o (di solito) 1. Quindi inserisco 1 bit in punti che hanno portato a 2 ^{(a-1) (b-1)} moltiplicato nell'hash. Quindi l'altro messaggio è sostanzialmente 0, ma ho impostato un altro bit in ciascun numero per rendere le lunghezze uguali.

Penso che sarebbe stato più fastidioso se l'hash quadrato su ogni bit, piuttosto che solo dopo aver usato tutti i numeri primi. Quindi non sarebbe stato così semplice costruire esponenti arbitrari per loro.

C, 128 byte - da: ossifrage schizzinoso

Le seguenti due stringhe hanno entrambi l'hash su tutti gli zero:

dddl|lddH4|@dhxdxXdh0TXPdhhdx(dTxtlpdd@4Lhd|hdDpdhDdXLdXP4(PdddL|ldXdD(lddX4|0hddp4|ddP4Lxdp0dP@dhpTxPdhXdXxdhHDxHdllLttdhPT8pd(pT8Pdd0TL8dlLLTtddPtl8dP@DPPdhhDxhd804(pdh0Txpd@DDpLdhL4xtdXXdHXdd04lXht40dlddh4|@ddPTLXdhhDXHhtPH40dh0t8pd(pt80dhPtX0dhLtXtdhLT8thlLplTdhpt80dh0txpdhHDX(hdX8txdhhdxHdp|d@tdhlTx4dlptdxdh0T8PdT@t|Hdd@tL(ht(8DhdhHD8(hpHHP8dhLtXtdX8dhxdhpt8Pd@(D@Hdd@tLhdtxTLPdd0tlxhhL8X|dd8t|0dT04|Xddxt|phxxxhhdhpt8PhhxX8hdhlTX4dd4l||dd@TLHdXlTHtdhHd8hdX0THPdh(D8(d8xdh8dhp4xPd0HDp(dhl4xTdxlthtdhlTx4d8lT(TdhhdXHdphdP(dhp4x0d0Xd0XddTl||d88DH8dhhdxhdx|tHDdhLT8Thll0lTddPTlXdxXd(xdd0Tlxdhp480dhp4x0dd|LltdhPt80dtll|dddPTlXdxXd(xdd0Tlxdhp480dhp4x0dd|LltdhPt80dtll|dddP4Lxd|ptT8dhddxldH|4xDdhp4x0dDdl|LdhtD8|hhHx88ddpTL8hhphx@dhtd8|dphDP(dh0tx0hhDHx4dhpt8Pd@(D@HddLLLDhh|xxldhl4xTdhL4x4dhPt8Pd(HDx(dh(D8Hd4PT|8ddH4|@hh4H8ddhxd8XdDP4lxdhHd8hdl04d8ddXT|phdh8Thdd@TlHdhXdxxdllL44dD@4lHdhxdxXhd8XtxddLlLddT@T|(dhxdXXd|P44Xdhpt8pdlHDT0dhL4Xtd@ldpDdddl|LdXP4h0dhltXtdX8d(Xdh|tXdhhLXX|dhxd8XdP@D0PdhXDxXhtpHtPdd84|pddtl||dh(dx(d88Dh8ddx4|PhtT0DLdd@tL(hdX8Txdhp480d08d08dlll44d4dLLldhTdX|hh8Xxhdh048pd08d08ddPtL8d4H4l@dhhdxHd|pt4Xddp4lXhp(hPxdh|48DdxhDh(ddLlldd8XdH8dddl|LdLHDT0dhpt8pdlHDT0dh(d8hdTHtl@ddptl8dt84LPdh8dxxdlptD8dd04lxhhH8XxddDl|ldP|D@4ddTl||d|ptT8dh(dXhhd8X48dhPtXpd(8DxXdh@TX@dDP4L8dhpTX0d4@4|hdhHdxHdX8DHxdhPT8PhllplTdh0TXPhlXHLXddp4lXhtHXD(dhP4X0htH8dhdhLTx4hpxHPHdhhd8(dX8DHxdhpt80hhdHxTdlll44d@Hd@(dhhDxhdh0t8Pddh4|@ddh4|@dhptx0dpPD0@ddPtlxdhPT8pdhhdX(htTpDLdd@4L(dLHDtpdhxd8xdt84lPdlpTdxdDPTLXddLLLDdxlThtdlhd4PdXLTh4ddptLxd|@44(dhhd8HdtDLLlddxt|pd|hDd0ddPtLXhl@H|pdhDD8ld8dDhLdhXDXxdDxT|PdhHD8hdp8dpxdhp480d@XD@xddpTLXdHhD8(ddllLDdD|LL4dhpt80d@LdPDdh|4xDdP8dpXddLllddl8d4@dhptXpdd(4|@dhltx4d0Dd@LdhptxphdPHdpdhl4xTdxlthtdhHD8HdTdllldhLtX4dXP4(PdhLTxTd4X4LpddlllDdlpTD8dllltTdL(dtPdhDDxLdhLTx4dhptx0d|0T4Xdhl4xTdHL4XtdhpTXpdLp4dxddHt|@dHL484dhHDXHdHLtxtdhDdXldxL4H4dh|TxDhh8xX(dhLt8td8Lt(TdhHDx(d4DlLlddXT|PdHHD8(dlll44dlP4dxdd@tL(dL@4dhdd0tLxd4X4l0dhhdxhdDlLldddLLlddD04l8ddPtlxd(hd8hdd(T|@hdDp4|ddP4Lxdp0dP@dhptXpd(p4X0dhhd8(d8pT(0dh8d8Xhd(XT(dhddxLd@XD@8dd@tlhd@ld0ddhTD8|hhPH8@ddtl||dH0Tx0ddLlLddhp480dhHdxhd4lL|DdhXD8xdhhDX(dh048pd4Ll|ddddl|LdXP4h0dlll4thhdhxtddP4LXdhXdxXdhpTX0hdXXtxddlLLddx0Th0ddTl||hlhhlHdd|Ll4dHDdXldhhDX(hpxh0HdhDDXLdXDDhLdlhDTpht8Xdxdhpt8phhHXX8dd(t|@dHl4xtddp4LXhxhXH8dhDDxldDXt|PdhTDX|d|0ttxdhdDXLdDLLLddd84|PdT84LpdlhDTphl8hlxdhXD8xdHpt8Pdlhd40ddHT|@dhxdX8dhlT84dh|T8dhlXHLxdhxDxXdT4lL|dlllttd@xd@xdhhDXHhtXXD8dh(d8(d4p4|8dd04lxdxPThpdhHD8Hhdhx4hdhl4xthl|pLDdhltX4dhP4XPdd0Tlxdl@tDhddP4lXd0xD0xdhHD8Hd@8D@xdh0T8Pd0XDpxddPtl8dP@DPPdhhDxhd804(pdd04L8hpxHphdhDdxLdppD0@dd@tl(d88dHXdh0txpdXhDhHdd@Tlhdx8DHXdh0tXPdxxdH8dhPT8Pd484LPdlhD4pdxxdHxdd|Lltdhptx0dhlTx4hp8HPhdhPt8pdt4lL|ddtl||dH0Tx0dhxd8xhl@H|pddLllDhldP||dhdD8ldXLTHTdlhDTpddllLddd04lxhhH8Xxdh|48DdP8d0XddLLldd|@44hdhhd8hd4x4L0dhltXthh4H8Ddh4DX|dD@Tlhdh0tXpd8|T(ddhtDX|dlhdTPdd@tLhdThTl@dh8D8xdT(TL@dd@Tl(d8Hd(hdhXdxxhtHXdhdd0tl8d|HDDPdd8T|PdH04xPdd@Tl(d|@4t(dd(4|@dHp4xpdhpt80dh0txpdhp48phdXxTxdhhDXHhtPH40dh0t8pd(pt80dd8T|pdlxdt@dhp48PdD0TLXdh0t8Pd|lldTdh|t8DhphHp8

ddTl||d4|L|4dhptX0d4dllLddxT|pdxXdH8dlhDtPhlpH|@dd|Lltdhptx0dhlTx4hp8HPhdhPt8pdt4lL|ddtl||dH0Tx0ddLLLDd8tdH|dhDD8LdtxtLpdhxD8Xhd8xtxdhPt8Pd(8DX8dhddxLd0xd08dd0Tlxdxdd(Lddh4|@dXpt(Pdh048pd0xd0xdhhDX(d8p4Hpdh0480d(8DX8dhL4x4d4PT|XddPTLXdPDd@Ldddl|ld(P4X0ddDL|lht88DXdhPtxpd((Dx(dh0tx0dxXd(8dhpT8Pd0xD0XdlhD4pdT0T|8dh04XPht0H40dlhDtpdpHDP(dhlTXtdPHdpHdhXDxXhpPH0pddDl|lhltp|Ldh04x0dtXTL0ddLLLDdLhdtpdhL4xtdHDdXLddxt|0d4X4l0dh(Dxhdx04h0ddllLDd0PD0@dhXDxxhdx848dhDDxldpXDpXdhPt8pdhltxTdd04lxhhH8Xxdh|48DdP8d0XddLLldd|@44hdhhd8hd4x4L0dhltXthh4H8Ddh4DX|dD@Tlhdh0tXpd8|T(ddhtDX|dlhdTPdhlTXtdTX4L0dd@Tlhhh8xXHdhPt80d|XdD@dhp4xphd4Ptldd|LL4dL|ltDdhPTx0d80T(pdhpt8pd|pTtXdhpTX0hhth8Ddhxd8xdphdP(dh8D88dp(DPhdhHD8(htxXdXdh8dXXdXpTH0ddx4|PdpXDPxdhXDXXdxxdhXdhlt8Td@xD@8dhP4XPdhltX4dd@tlHdhXDxxdhPtXPd(8Dxxdh0t8PhdpHd0dh(D8HdX(D(Hdd@tLhht|@4Tdd@4lHdttll|dd0tlXhh|xxldd@TLHdlHdTPdd|LL4dt@T|hddx4|PdlHdtPddTl||d88DH8dlhdTpd40t|xddht|@dpPDP@dhHDxHhxthHDdhddxldxtDH|dhltx4d8Dd(ldd|LLthp0H0Pdhl4x4d|0T4Xdd|ll4dt8tLPdd@4lhd|0TTXddPtLXd(8d8xdhPTxPdHxd8xdhHDX(ddLllddhp48Pd0@d0PdhptxpdX(DhHdd0TlXhtPHTPddh4|@dTDlLldhDDxLhp(hPxdhdD8ldXLTHTddPtLXdTh4L@dhLtxTdlpTd8dhPtXpdhLtX4ddPTlXdxxdhXdhhd8(d404|8dhTd8|dhL4Xtddp4l8d4X4LpdhL4Xtd@ldpDdddl|LdXP4h0dhpTX0htXxDxdhpt8pddLlLddhp4XPhp0H00dh4Dx|dlp4D8dhPtxpd((Dx(dh0tx0dxXd(8dhDDxlhlL0ltdhhDxHd@|d0TdhHdxhdL0tD8dhhD8hhl|pLdddxt|pd|hDd0ddPtLXhl@H|pdhxDXxd8DdhldlhdtphpphppdhpT8PdH8dxXdlhd40dtXtlPdhTd8|dXlthtdhTDX|dx|4HDddxT|pdHDd8ldhL4X4dhP4XpdhtDx|ddXt|Pdh|T8DdHhdxhddLLLDhlxHl8dh0tXPd|(ddPddDL|LdHhdxhdhp4x0dl8dT@ddXT|phdh8Thdh(DXhd0HDP(dddl|lhd(xT(dhXdXxdTxtl0dd|lLtd8|4hddd4l||dXLTh4dd04lxdP8DP8ddxT|0dXXdh8ddP4lxd0@DpPdh8dXxddp4lxdhLt8tdHTdx|dh4Dx|dxLTHtdhhd8hd@DDpldd04LXdXlT(tdhXdXxdhPT8pdh(DXHdP@dp0ddP4LXdXpThPdllL4td((D8(dh0tXpd|(ddpdh(DxhhdL@DDdhHDx(dxL4(tdhLtXtdl@4dHdhxd8xdTh4L@dhXDXXhhdH8Tdd8T|PdH04xPdlllT4hllpLtdhhDXHhxxXhhdhXDxXdPDd@Ldd0TlXdHLtX4ddDL|ldXLT(4dhPtXPdXXd(8dhpt8phdH8thddxT|pd(ptXpddP4LxdLXDT@dhpT80dLptDxddxt|pdP@Dp0dhptx0d|0T4XdlpTdxdxpt(PdhHD8(d4TlL|dhHDx(d@hD@(dd@tl(d88dHXdh(Dx(d4pT|xddPtl8dP@DPPdhhDxhd804(pdhHD8Hhdhx4hddP4lxhdhXt(dhxdX8dp@DppdlllT4dP0dp@dddl|ldH8DXXdllLT4dPXdp8dd@tLHdlPTd8ddtL||d8PtHpddHt|@hd|@d4dh(dX(hdhXT(dhpT80hdHX4(dlpTdxdtDlLlddxT|pd(ptXpddP4LxdLXDT@dhpT80dLptDxddxt|pdP@Dp0dhptx0d|0T4XdlpTdxdxpt(PdhHD8(d4TlL|dhHDx(d@hD@(dddL|lhtph40dhpTxPdlp4dXdhDDxldpxD08dh(dX(dHlTxTdd|ll4d40t|Xdh0480ht@hT@dhptXphdHxT(dh(D8Hd4PT|8dhpt8pd88dhXddDl|LhxdHHtddPtlXd|pt4Xdd0Tl8d0(D0hdhhd8hdppd0@ddPTlXd8P4hpdhlTx4d8dDhLdd@TLhhllplTddXT|0dH|4XDdh|4xDht8XD8ddptl8dH8d88dd|LLTdh(DXhddHt|@hpXhp(dhdDxLdDhT|@dhP4X0dXhDHhdh0T8Pd((dxhdhhDx(hdx8Txddp4LXd8xDH8dhPTXpdlPtD8dh(DxHd@8D@Xdhl48Td00Dp@dhLT8Tdp(d0(dhhd8(d404|8dhhdx(dx0T(pdd|lL4ddXt|Pdd0TlXhxdH(4ddllLDhhLXX|dhXDx8hl8hLxdhpT80dLPtDXdhptX0dPXd0XddP4lxd0@DpPdlptd8dl(dTPdhxDx8d(ptX0dhpT80htxxdXdhhDxhdXltHtddh4|@d@|dPTdhdDXLhpph0Pdhp48Pdt4lL|dh04xpdLpTD8dd@4lhdl8dt@ddhT|@dPxDp8dd04lXd40t|xdd0TLxdTdlLLddpTLXd|pTT8dd04lxhhH8XxdhddxlhddPT|dd04LXdlhd4pdh8d8xhh|8XLdhxd8xd(8d8xdhp48pd(8DX8dhhDXHd4dllLddx4|0d8PTH0ddPtlxd|P44XdlpTdxd(XDXXddpTlxdHltX4dhLTxtd|HDD0

La funzione hash è costruita in modo tale che i bit di ordine superiore non influenzino mai i bit di ordine inferiore, quindi posso generare una raccolta di stringhe in cui tutti i xbit di ordine inferiore sono zero, quindi posso provare combinazioni concatenate di queste stringhe per trovare alcune dove più i bit più bassi sono zero ecc. Sono abbastanza sicuro che ci siano più modi per rompere questo, e anche modi che producono stringhe significativamente più brevi, ma in questo modo ho evitato di fare molti calcoli.

Python 3, 118 byte

int(H("9"+"0"*400))

e

int(H("9"+"0"*4000))

(ovvero: 9E400 e 9E4000)

Entrambi producono

83909358607540647658718900164058931893

Scavando un po 'più in profondità, sembra che qualsiasi numero intero seguito da k cifre ripetute in modo tale che k> 128 e (k% 4 == 0) restituiscano lo stesso hash. Ad esempio, H("1"+"1"*32*4)e H("1"+"1"*33*4)sono entrambi 13493430891393332689861502800964084413. Hmmm, 128 ...

Python 2, 161 byte, perplesso

340282366920938463463374607431768211456 (decimal)
100000000000000000000000000000000 (hexadecimal)

e

340282366920938468780317283222139437056 (decimal)
100000000000001203B66F94300000000 (hexadecimal)

Entrambi hanno l'output:

83F172CC3D050D131F64FD04B8181DC2

I numeri sono 2 ^ 128 e 2 ^ 128 + (3 * 5 * 7 * 11 * 13 * 17) ^ 2 * 19 * 2 ^ 32.

Java, 299 byte di SuperJedi224

Pastebin per M. In binario, Mha 65535 1s, seguito da 2 0s.

Pastebin per N. In binario, Nha 21845 1s, seguito da 174766 0s.

Entrambi cedono 0.

Si noti che la base dell'algoritmo è i.bitCount()*i.bitLength()+1e alla fine, prendiamo il risultato alla potenza di ie prendiamo mod 2 ¹²⁸ . Quindi l'idea era solo di trovare due iche sono divisibili per quattro, ma in cui la prima espressione dà 2 ³² . Ciò è stato fatto facilmente considerando 2 ³² -1 e selezionando due fattori per il conteggio di 1 secondi e la larghezza totale dei bit del numero.

Modifica: In realtà, c'è un po 'di più sul perché Mproduce zero, ma possiamo facilmente trovare più numeri che producono zero a causa della mia spiegazione usando altri fattori di 2 ³² -1 in modo tale che alla fine ci siano almeno 64 zero.

C, 134 byte (di Barteks2x)

10

e

20

entrambi gli hash

0xa609779942cb9ef1

perché l'algoritmo esegue l'hashing solo dell'ultima cifra!

C, 87 byte

$ echo B075343F9832CD60 | ./hash6_ ; echo
fc2e9f02bd284bd1
$ echo 5914BD1B71164C77 | ./hash6_ ; echo
fc2e9f02bd284bd1

Trovato usando la mia collisione bruteforcer.

Python 2, 115 byte, con ossifrage schizzinoso

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222

e

2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222211111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

Il valore hash non ha nulla a che fare con l'ordine dei blocchi.

Python 2.x, 139 byte perplesso

H(2)

e

H(128)

entrambi ritornano

16645614427504350476847004633262883518.

C ++, 239 byte di SpelingMistake

Utilizzando il programma "principale" fornito, i seguenti due ingressi producono lo stesso hash:

echo -n "dog" | ./h
481c27f26cba06cf

e

echo -n "fog" | ./h
481c27f26cba06cf

I primi 8 byte di input non vengono mai elaborati , a causa di questo errore nel codice:

 for(I i=n;--i;) // and then we use q[i] for this iteration

perché --irestituisce false quando i==1, q[0](i primi 8 byte: Iè un int64). Sostituire la condizione del loop con for(I i=n;i--;)avrebbe risolto questo problema.

Ruby, 90 byte, di MegaTom

4271974071841820164790043412339104229205409044713305539894083215644439451561281100045924173873152

e

23495857395130010906345238767865073260629749745923180469417457686044416983587046050252582956302336

che sono 2 e 11 seguiti da 40 byte zero. Quindi entrambi hanno 41 byte. Il valore di hash viene aggiunto dalla lunghezza di input per ciascun byte, quindi viene invertito in decimale. Una lunghezza di input che termina con 1può assicurarsi che il valore di hash finisca con un tempo 0piuttosto rapido. Quindi invertendolo riduce la lunghezza del valore di hash di 1.

Entrambi hanno il valore hash 259.

C # - 393 byte - da: Logan Dam

70776e65642062792031333337206861786f72ed 70776e65642062792031333337206861786f7200entrambi gli hash 18E1C8E645F1BBD1.