이 콘테스트는 끝났습니다.

경찰의 도전에는 남아있는 깨지기 쉬운 대답이 없습니다.

암호화 해시 골프 의 컴패니언 스레드

다시 말해, 주요 도전 과제의 강도에 대한 규칙은 다음과 같습니다.

직무

두 개의 메시지 : 스레드 '도적으로 다음 게시하여 제출'경찰 어떠한 균열 M 과 N을 의 I 되도록 H (M) = H (N) 및 M ≠ N .

채점

각 경찰 제출물을 크래킹하면 1 ​​포인트를 얻습니다. 가장 많은 점수를 얻은 강도가 승리합니다.

동점 인 경우, 가장 긴 제출을 금한 묶인 강도가 승리합니다.

추가 규칙

• 모든 경찰 제출은 한 번만 해킹 할 수 있습니다.

• 경찰 제출이 구현 정의 또는 정의되지 않은 동작에 의존하는 경우 시스템에서 (확인 가능) 작동하는 균열 만 찾으면됩니다.

• 각 균열은 강도 실에서 별도의 답변에 속합니다.

• 잘못된 크래킹 시도를 게시하면 30 분 동안 해당 특정 크래킹이 크래킹되지 않습니다.

• 당신은 당신 자신의 제출물을 해독 할 수 없습니다.

예

Python 2.7, 사용자 별 22 바이트

1

과

18

리더 보드

1. e 비즈니스 : 3 개의 크랙, 393 바이트
2. 마틴 부트 너 : 3 개의 균열, 299 바이트
3. jimmy23013 : 3 개의 균열, 161 바이트
4. Sp3000 : 균열 3 개, 44 바이트
5. tucuxi : 2 개의 균열, 239 바이트
6. Vi .: 2 개의 균열, 87 바이트
7. feersum : 균열 1 개, 216 바이트
8. mathmandan : 1 개의 균열, 139 바이트
9. 으스스한 ossifrage : 1 균열, 134 바이트

C, 122 바이트-작성자 : Mr. Llama

bmaj8PCosFLAJjeHaevvvchnJedmg2iujpePOPivI2x2asw0yKa2eA15xvFJMFe82RGIcdlvxyaAPRuDuJhFjbh78BFsnCufJkarwEyKa0azHxccw5qegpcP9yaO0FKoohanxgiAfK1Lqwba51bKtjacbvdjMmcBkiv8kd62sBd98c4twa98sgj3iPh7nkP4
rlaejTPrua1DhBdg0jrIoDBi8fc1GIJAigivIGaxs1OmfPcctNadK3HErvzPLCeDPD8fkMNPCBcIwuoGfEHegOfk9k9pwktslqaBenaati1uNthMiyk9ndpy7gdIz88iot6A09cbNeIMheyjBvbeegL7aGp7mCb91hCxnvgV5abfImrPfLbrbraAsN6loJgh

두 문자열은 bb66000000000000d698000000000000

"C, 128 바이트-by : squeamish ossifrage"와 같이 상위 비트는 하위 비트에 영향을 미치지 않으며, 이는 악용 될 수 있습니다.

암호

Visual C ++, " 안전하지 않은 "문자열 연산 사용

#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, Sp3000 별 109 바이트

Martin은 먼저 금이 갔으므로 이것이 가치가 있는지 확실하지 않습니다. 다른 한편으로, 나는 단순한 충돌보다는 사전 이미지 공격을했다 – 훨씬 더 강한 결과. 즉, 임의의 해시 값을 제공 할 수 있으며 해당 해시 값을 생성하는 입력을 구성합니다.

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

그리고 그것이 작동한다는 것을 보여주기 위해 :

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

충돌하는 특정 숫자 집합을 제공하려면 다음을 수행하십시오.

N: 2**128
M: 43617

Python, Sp3000 별 109 바이트

340282366920938463463374607431768211414

과

113982837842983129870077688367927159293402923522160868689804433865221255200726

둘 다 수확량

132946164914354994014709093261515948032

이 알고리즘은 입력을 128 비트 청크로 분할 42하고 끝에 추가 해싱을 수행하기 전에 각 청크 로 해시 (에 시드 됨 )를 반복적으로 수정합니다 . 충돌을 찾으려면 각 청크에서 다음 의사 코드를 실행 한 후 동일한 결과를 생성하는 두 개의 숫자를 찾는 것이 목표입니다.

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

해시는 mod 2 ¹²⁸ 로 취해 지므로이 비트 범위 밖의 모든 흥미로운 것들을 이동시키는 숫자를 찾고 싶습니다. 그러나 해시는 시드되어 42있으므로 중요하지 않은 비트로 시작합니다.

000000000000000000000000 ... 000000000000000000101010

내 생각은 첫 번째 청크를 추가 할 때 해당 비트를 제거하는 것이 었습니다. 그럼 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

그것은 매우 간단합니다. 두 숫자 중 하나로 사용하십시오. (실제로, I 사용한 충돌 제 번호 2 ¹²⁸ -42.

이제 같은 결과를 가진 다른 숫자를 어떻게 찾습니까? 한 번의 반복 후에 해시는 42더 이상 아니지만, 2**122방금 보여 드린 것처럼. 이제 입력 번호에 두 번째 청크를 추가하여 다른 반복을 실행할 수 있습니다. 이 인수와 같은 인수로 두 번째 청크를 선택할 수 있습니다. 즉, ²¹²⁸ -2 ^{122가 필요} 합니다. 그런 다음 중간 결과 hash += chunk는 동일하며 결국 동일한 결과로 끝납니다.

따라서 충돌의 두 숫자를 계산할 수 있습니다.

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

이와 같이 더 많은 충돌을 쉽게 생성 할 수 있습니다.

Mathematica, LegionMammal978에 의해 89 바이트

0

과

16

둘 다 수율 0.

이 경찰의 원칙은 "임의"단계 수에 대한 "임의"초기 조건에서 "임의"이진 1 차원 세포 오토 마톤을 발전시킨 다음 결과의 첫 128 개 셀을 정수로 해석하는 것입니다.

문제는 규칙에 의해 간단하게 결정되므로 Mod[#^2,256]16의 배수는 규칙을 제공 0하는데, 이는 모든 셀이 항상 0 인 사소한 규칙입니다. 입력을 99로 나눌 수 없으면 적어도 1 단계 씩 진화하므로 출력은 항상 0입니다. 따라서 99의 배수가 아닌 두 개의 배수는 반드시 충돌합니다. 그러나 초기 조건은 입력의 이진 표현 (이 경우 모두 0 임)이기 때문에 입력 은 0 0 도 제공합니다 (규칙을 사용하지 않더라도).

옆으로, 우리는 규칙과 완전히 독립적 인 다른 충돌을 찾을 수 있습니다. 위에서 언급했듯이 99의 배수는 셀룰러 오토 마톤이 전혀 진화되지 않았기 때문에 결과는 단순히 초기 조건의 첫 번째 (가장 중요한) 128 비트입니다. 따라서 처음 128 비트에서 다르지 않은 두 개의 배수 (0으로 오른쪽에 채워짐)를 취하면 충돌이 발생합니다. 이것의 간단한 예입니다 M = 99, N = 99*2 = 198.

J, 39 바이트

첫 번째 숫자는 다음과 같습니다

10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000

즉, 1000000064 번 반복됩니다. 두 번째 숫자는 더하기 1입니다. 즉

10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000001

두 수확량

322124197561777885386414076216564234267

설명

이제 시작하자 x := H 10000000 = 146018215378200688979555343618839610915,하고 y := 2^128. a, b그러한 것을 찾는 대신 알고리즘에서 파워 타워를 사용 하는 것을 a == b mod y찾을 것입니다 .a, bx^a == x^b mod y

그러나 일부이 있어야 k하도록 x^k == 1 mod y하기 때문에, x, y서로 소이며, 그것을 위해 k우리가해야합니다 a == b mod k. 따라서 1 mod 의 이산 대수 를 찾을 수 y있으며 첫 번째 단계에서는

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

이제 우리는 a, b그런 두 숫자를 찾고 싶습니다 a == b mod k. 이를 위해, 우리는 설정 y으로 k찾아 시도 a, b하는 등 x^a == x^b mod y다시. 동일한 논리를 사용하여 불연속 로그를 다시 가져 와서

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

우리는 작은 것에 도달 할 때까지 이것을 반복한다.이 y시점에서 같은 것을 모듈로 해시하는 두 개의 숫자를 찾는 것은 사소한 일이다 y. 63 번의 반복 후에는 y = 4기본적으로 두 숫자가 작동합니다.

이산 로그 체인을 생성하는 Mathematica 코드는 다음과 같습니다.

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

이것은 다음과 같은 출력을 제공합니다 .

FyAmTheEggman에 의해 8 바이트 Pyth

99999999999999999999999999

과

99999999999999999999999998

부동 소수점 정밀도는 이것으로 충분하지 않습니다.

CJam, 44 바이트, 사용자 jimmy23013

숫자가 게시하기에 너무 커서 여기에 Pastebin에 있습니다 : num 1 , num 2 .

첫 번째 숫자는 숫자 600^2 = 360000입니다. 두 번째 숫자는 다음 변경을 제외하고 동일합니다.

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

둘 다 해시합니다 271088937720654725553339294593617693056.

설명

코드의 전반부를 살펴 보자.

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)

따라서 두 개의 입력 번호를 찾을 수 있으므로 합이 초기 600 너비 배열과 압축 배열 모두에 대해 S[i][j]*13^i*19^j동일한 모듈로가되면 16^20완료됩니다.

좀 더 쉽게하기 위해 600^2 = 360000600 자릿수 배열은 600 x 600 제곱의 자릿수 만되도록 숫자 입력 만 고려할 것 입니다. 이를 통해 상황을보다 쉽게 ​​시각화 할 수 있으며 이후부터 유효합니다 10^360000 ~ 2^(2^20.19) < 2^(2^30). 더 단순화하기 위해 우리는 숫자 배열이 기본 대각선을 따라 대칭 인 입력 문자열 만 고려하여 원래 배열과 압축 배열을 동일하게 고려합니다. 이를 통해 초기 문자열 반전과 오른쪽에서 왼쪽으로의 색인 번호 매기기를 무시할 수 있습니다.

우리를 시작하기 위해 첫 번째 숫자를 숫자로 사용할 수 360000있습니다. 두 번째 숫자를 얻으려면 숫자의 일부를 변경하여 합계가 동일한 모듈러스가 16^20되도록 숫자 사각형의 대칭을 유지하면서 이를 수정하려고합니다 . 우리는 트리플 목록을 찾아서 이것을 달성 (i, j, k)합니다.

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

어디 1 <= k <= 8에서 숫자 1을 증가시키는 양 (즉, 숫자를 2에서 9로 변경) – 0을 포함 할 수 있었지만 필요하지 않았습니다)과 0 <= i < j < 600인덱스 쌍입니다.

우리는 일단 (i, j, k)세 쌍둥이를, 우리는에서 숫자를 변경 (i, j)하고 (j, i)로 1+k두 번째 숫자를 얻을 수 있습니다. 삼중 항은 탐욕스러운 역 추적 알고리즘을 사용하여 발견되었으며 숫자 위의 두 번째 숫자는 다음과 같습니다.

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

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

예를 들어 (i, j, k) = (0, 1, 7)숫자 (0, 1)(position 600*0 + 1 = 1) 및 (1, 0)(position 600*1 + 0 = 600)을 로 변경하는 것에 해당 합니다 1 + 7 = 8.

파이썬 3의 역 추적기는 다음과 같습니다. 비록 역 추적이 실제로 일어나지 않았으므로 우리가 운이 좋았다는 것이 밝혀졌습니다.

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

보너스를 들어, 여기 그것은 쓸모가 없었습니다 파이썬 3에 해시의 그리 효율적 포트.

PHP 4.1, 66 바이트 로 이스마엘 미겔

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

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

Sp3000의 Python 3 (216)

내 메시지는

5012053369354645637214643587103597313576086380250249302980438772005248488380915054746146050001036696049972235875591571028140916001206596142280971107479334216535925703480968283657357930602076844092875640359192729378384507238123245417656548512647301639542279794868512420586823155070914644206130805893968511673770843170450832829657206145931885656157628306896903719624729809643572222159364893644113710867223921580178741177106141068298067479650611992859787419779579962211254029169589775046869542029842374359998053713002047081002506346875804341770199884355810931652447801492691887376948615365487982834690942054717077615539311699691010938426302886867891090301248321702485904291177813145565144089044261424329155436660979948932491709511914065619715728353376578192548334780893602675684085757434059540582004872746967999949306946618036846307799677491651967418565531672392468089533111553281620101129322575737949904022139471688252420467041529301533363008476437812216585923822571793353317799365005036029476865
5012053369354645637214643587103103086948976188724715498910865650846170784131001427390927276355140411160919276493388206817700368694224128444524223814513348177926532982330730066315320819293979046126543806115318009892783577432467861426768883700930779409885418980853424256180864755881414774514084197887594253752179391098292488771920695965135791582218083012144604515253506370334133858904659263953147111654656123599460222236152128559750436960308887683690915261431659087040402402092795259541564130228515353133867041828417398395559815392177084002004583988047406317670433664624642858480970640416500369367395538257341309676777745698712896295462462064271676447460293684100001583256400774270688958051470568447233589146620275159126426142305307007744396679875427883384557759778766330566230012377845843842097372663092379922300568052486301863154557664156185573021849420011058607321977550938866119133331529852821217331665195832442542012455132139770813510559894254061471149750738447764616026512400623344132554752

이 Python 2 코드를 사용하여 생성했습니다.

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)

큰 계수는 두 개의 소수 a와 의 곱이었습니다 b. 나는 우리가 semiprime을 인수하는 것이 불가능할 것이라는 희망이 있었지만 일부 웹 페이지가 바로 대답을 주었기 때문에 128 비트가 너무 작을 것이라고 생각합니다.

곱하기 그룹 모듈로 ab는 순서 (a-1) (b-1) 을 갖습니다. 즉, 우리가 그 거듭 제곱으로 숫자를 올리면 0 또는 (보통) 1이되어야합니다. 2 ^{(a-1) (b-1)} 은 해시에 곱해집니다. 그런 다음 다른 메시지는 기본적으로 0이지만 길이를 동일하게 만들기 위해 각 숫자에 다른 비트 하나를 설정했습니다.

나는 모든 소수를 사용한 후에가 아니라 모든 비트에서 해시가 제곱되는 것이 더 성가신 것이라고 생각합니다. 그렇다면 임의의 지수를 만드는 것이 그렇게 간단하지 않았을 것입니다.

C, 128 바이트-기준 : squeamish ossifrage

다음 두 문자열은 모두 0으로 해시됩니다.

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

해시 함수는 상위 비트가 하위 비트에 영향을 미치지 않도록 만들어 졌으므로 모든 x하위 비트가 0 인 문자열 컬렉션을 생성 할 수 있습니다 . 그런 다음 이러한 문자열의 조합을 시도하여 낮은 비트는 제로 등입니다. 나는 이것을 깨는 더 많은 방법과 상당히 짧은 문자열을 생성하는 방법이 있다고 확신하지만, 이런 식으로 나는 많은 수학을 피했습니다.

파이썬 3, 118 바이트

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

과

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

(즉 : 9E400 및 9E4000)

둘 다 생산

83909358607540647658718900164058931893

좀 더 깊게 파면 k> 128 및 (k % 4 == 0)과 같은 정수와 k 반복 숫자가 동일한 해시를 반환하는 것처럼 보입니다. 예를 들어, H("1"+"1"*32*4)및 H("1"+"1"*33*4)둘 다 13493430891393332689861502800964084413입니다. 흠, 128 ...

Pythond, 161 바이트, Puzzled

340282366920938463463374607431768211456 (decimal)
100000000000000000000000000000000 (hexadecimal)

과

340282366920938468780317283222139437056 (decimal)
100000000000001203B66F94300000000 (hexadecimal)

둘 다 출력이 있습니다.

83F172CC3D050D131F64FD04B8181DC2

숫자는 2 ^ 128 및 2 ^ 128 + (3 * 5 * 7 * 11 * 13 * 17) ^ 2 * 19 * 2 ^ 32입니다.

Java, SuperJedi224에 의한 299 바이트

에 대한 Pastebin M. 이진수로 M65535 초가 1있고 2 0초가 있습니다.

에 대한 Pastebin N. 이진수로 N21845 1s 뒤에 174766 0s가 있습니다.

둘 다 수율 0.

알고리즘의 기초는 i.bitCount()*i.bitLength()+1궁극적으로 결과를 거듭 제곱 i하고 mod 2 ^128을 취합니다 . 따라서 아이디어는 i4로 나눌 수 있는 2 개를 찾는 것이었지만 첫 번째 표현은 2 ³² 입니다. 이는 2 ³² -1 을 인수 분해 하여 1의 수와 숫자의 총 비트 폭에 대해 두 가지 요소를 선택 함으로써 쉽게 수행되었습니다 .

편집 : 실제로, 왜 M0을 산출 하는가에 대해 조금 더 많은 것이 있지만, 우리는 설명에 따라 2 ³² -1 의 다른 요소를 사용 하여 끝에 64 개의 0이 있도록 더 많은 숫자를 쉽게 찾을 수 있습니다 .

C, 134 바이트 (Barteks2x 제공)

10

과

20

해시 둘 다

0xa609779942cb9ef1

알고리즘은 마지막 숫자 만 해시하기 때문입니다!

C, 87 바이트

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

내 충돌 bruteforcer를 사용하여 발견되었습니다.

파이썬 2, 115 바이트, squeamish ossifrage

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222

과

2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222211111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

해시 값은 블록 순서와 관련이 없습니다.

Python 2.x, Puzzled의 139 바이트

H(2)

과

H(128)

둘 다 반환

16645614427504350476847004633262883518.

C ++, SpelingMistake에 의한 239 바이트

제공된 "메인"프로그램을 사용하여 다음 두 입력은 동일한 해시를 생성합니다.

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

과

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

입력의 처음 8 바이트는 처리되지 않습니다 때문에이 코드 버그 :

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

, (처음 8 바이트 : 가 a ) 인 --i경우 false로 평가 되기 때문 입니다. 루프 조건을 교체하면 이 문제가 해결되었습니다.i==1q[0]Iint64for(I i=n;i--;)

Ruby, 90 바이트, MegaTom

4271974071841820164790043412339104229205409044713305539894083215644439451561281100045924173873152

과

23495857395130010906345238767865073260629749745923180469417457686044416983587046050252582956302336

이는 2와 11이고 40 바이트는 0입니다. 그래서 그들은 모두 41 바이트를 가지고 있습니다. 해시 값은 각 바이트의 입력 길이로 추가 된 다음 10 진수로 반전됩니다. 로 끝나는 입력 길이 1는 해시 값이 0꽤 빨리 끝나도록 할 수 있습니다. 그런 다음 반전하면 해시 값의 길이가 1만큼 줄어 듭니다.

둘 다 해시 값을가집니다 259.

C #-393 바이트-작성자 : Logan Dam

70776e65642062792031333337206861786f72그리고 70776e65642062792031333337206861786f7200둘 다 해시합니다 18E1C8E645F1BBD1.