Cuộc thi này đã kết thúc.

Không có câu trả lời có thể bẻ khóa trong thử thách cảnh sát.

Chủ đề đồng hành của golf băm mật mã

Xin nhắc lại, đây là các quy tắc dành cho những tên cướp khỏi thử thách chính:

Bài tập

Crack bất kỳ cảnh sát đệ trình bằng cách đăng những điều sau đây trong tên cướp chủ đề: hai thông điệp M và N trong tôi như vậy H (M) = H (N) và M ≠ N .

Chấm điểm

Bẻ khóa mỗi bài nộp cảnh sát giúp bạn đạt được một điểm. Tên cướp có nhiều điểm nhất sẽ thắng.

Trong trường hợp hòa, kẻ cướp bị trói đã bẻ khóa bài nộp dài nhất sẽ thắng.

Quy tắc bổ sung

• Mỗi cảnh sát đệ trình chỉ có thể bị bẻ khóa một lần.

• Nếu một đệ trình cảnh sát phụ thuộc vào hành vi được xác định thực hiện hoặc không xác định, bạn chỉ phải tìm một vết nứt hoạt động (có thể kiểm chứng) trên máy của bạn.

• Mỗi vết nứt thuộc về một câu trả lời riêng trong chủ đề của bọn cướp.

• Đăng một nỗ lực bẻ khóa không hợp lệ sẽ cấm bạn bẻ khóa đệ trình cụ thể đó trong 30 phút.

• Bạn không thể bẻ khóa trình của riêng bạn.

Thí dụ

Python 2.7, 22 byte bởi người dùng8675309

1

và

18

Bảng xếp hạng

1. Kinh doanh điện tử: 3 vết nứt, 393 byte
2. Martin Büttner: 3 vết nứt, 299 byte
3. jimmy23013: 3 vết nứt, 161 byte
4. Sp3000: 3 vết nứt, 44 byte
5. tucuxi: 2 vết nứt, 239 byte
6. Vi.: 2 vết nứt, 87 byte
7. feerum: 1 crack, 216 byte
8. mathmandan: 1 crack, 139 byte
9. ossifrage squeamish: 1 crack, 134 byte

C, 122 byte - bởi: Ông Llama

bmaj8PCosFLAJjeHaevvvchnJedmg2iujpePOPivI2x2asw0yKa2eA15xvFJMFe82RGIcdlvxyaAPRuDuJhFjbh78BFsnCufJkarwEyKa0azHxccw5qegpcP9yaO0FKoohanxgiAfK1Lqwba51bKtjacbvdjMmcBkiv8kd62sBd98c4twa98sgj3iPh7nkP4
rlaejTPrua1DhBdg0jrIoDBi8fc1GIJAigivIGaxs1OmfPcctNadK3HErvzPLCeDPD8fkMNPCBcIwuoGfEHegOfk9k9pwktslqaBenaati1uNthMiyk9ndpy7gdIz88iot6A09cbNeIMheyjBvbeegL7aGp7mCb91hCxnvgV5abfImrPfLbrbraAsN6loJgh

Cả hai chuỗi băm để bb66000000000000d698000000000000

Giống như "C, 128 byte - by: squeamish ossifrage", các bit bậc cao hơn không bao giờ ảnh hưởng đến các bit bậc thấp hơn, điều này có thể được khai thác.

Mã

Visual C ++, sử dụng các hoạt động chuỗi " không an toàn "

#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 bởi Sp3000

Lưu ý rằng Martin đã bẻ khóa trước, vì vậy tôi không chắc điều này có xứng đáng được không. Mặt khác, tôi đã thực hiện một cuộc tấn công tiền thân thay vì một vụ va chạm đơn giản - một kết quả mạnh mẽ hơn nhiều. Điều này có nghĩa là bạn có thể cung cấp cho nó một giá trị băm tùy ý và nó sẽ xây dựng một đầu vào tạo ra giá trị băm đó.

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

Và để cho thấy rằng nó hoạt động:

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

Và để đưa ra một bộ số cụ thể va chạm:

N: 2**128
M: 43617

Python, 109 byte bởi Sp3000

340282366920938463463374607431768211414

và

113982837842983129870077688367927159293402923522160868689804433865221255200726

cả hai năng suất

132946164914354994014709093261515948032

Thuật toán chia đầu vào thành các khối 128 bit và liên tục sửa đổi hàm băm (được gieo vào 42) với mỗi khối, trước khi thực hiện một số băm bổ sung ở cuối. Để tìm xung đột, mục tiêu của chúng tôi là tìm hai số mang lại kết quả giống nhau sau khi chạy mã giả sau đây trên mỗi đoạn:

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

Vì hàm băm được lấy mod 2 ^128, chúng tôi muốn tìm kiếm các số thay đổi tất cả những thứ thú vị bên ngoài phạm vi bit này. Nhưng hàm băm được gieo vào 42để nó có một số bit không đáng kể được đặt để bắt đầu:

000000000000000000000000 ... 000000000000000000101010

Ý tưởng của tôi là loại bỏ các bit đó khi thêm đoạn đầu tiên. Vì vậy, hãy thử 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ều đó khá đơn giản, vì vậy hãy thử sử dụng nó như một trong hai số. (Thật vậy, số lần va chạm đầu tiên tôi sử dụng là 2 ¹²⁸ -42.

Bây giờ làm thế nào để chúng ta tìm thấy một số khác có cùng kết quả? Sau một lần lặp, hàm băm không 42còn nữa, nhưng 2**122như chúng ta vừa trình bày. Bây giờ bằng cách thêm một đoạn thứ hai vào số đầu vào của chúng tôi, chúng tôi có thể chạy một lần lặp khác. Chúng ta có thể chọn đoạn thứ hai theo cùng một đối số như đối số này, tức là chúng ta muốn 2 ¹²⁸ -2 ¹²² . Sau đó, kết quả trung gian sau hash += chunksẽ giống hệt nhau và chúng tôi kết thúc với kết quả tương tự ở cuối.

Vì vậy, chúng ta có thể tính hai số va chạm:

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

Chúng ta có thể dễ dàng tạo ra nhiều va chạm như thế này.

Mathicala, 89 byte bởi LegionMammal978

0

và

16

Cả hai năng suất 0.

Nguyên tắc của cảnh sát này là phát triển một máy tự động tế bào 1-D nhị phân "ngẫu nhiên" từ điều kiện ban đầu "ngẫu nhiên" cho số bước "ngẫu nhiên", sau đó diễn giải 128 ô đầu tiên của kết quả là số nguyên.

Vấn đề là quy tắc được xác định đơn giản bởi Mod[#^2,256], sao cho bất kỳ bội số nào của 16 đưa ra quy tắc 0, đó là quy tắc tầm thường trong đó tất cả các ô luôn bằng không. Nếu đầu vào không chia hết cho 99 thì chúng ta sẽ tiến hóa ít nhất 1 bước, do đó đầu ra luôn bằng không. Vì vậy, bất kỳ hai bội số nào không phải là bội số của 99 chắc chắn va chạm. Tuy nhiên, đầu vào 0 cũng cho 0 (mặc dù không bao giờ sử dụng quy tắc), vì điều kiện ban đầu chỉ là biểu diễn nhị phân của đầu vào (đó là tất cả các số 0 trong trường hợp này).

Ở một bên, chúng ta có thể tìm thấy các va chạm khác hoàn toàn độc lập với quy tắc. Như đã lưu ý ở trên, bất kỳ bội số nào của 99 có nghĩa là thiết bị tự động di động hoàn toàn không phát triển, do đó, kết quả chỉ đơn giản là 128 bit đầu tiên (quan trọng nhất) của điều kiện ban đầu ... chính nó chỉ là số đầu vào. Vì vậy, nếu chúng ta lấy hai bội số không khác nhau trong 128 bit đầu tiên (được đệm bên phải bằng số 0), chúng ta cũng sẽ có một xung đột. Ví dụ đơn giản nhất của việc này là M = 99, N = 99*2 = 198.

J, 39 byte

Số đầu tiên là:

10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000

Đó là, 10000000lặp lại 64 lần. Số thứ hai là cộng một, tức là

10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000001

Cả hai năng suất

322124197561777885386414076216564234267

Giải trình

Hãy bắt đầu với x := H 10000000 = 146018215378200688979555343618839610915, và y := 2^128. Thay vì tìm kiếm a, bnhư vậy a == b mod y, chúng ta sẽ tìm kiếm a, bnhư vậy x^a == x^b mod y, sử dụng các tháp năng lượng trong thuật toán.

Nhưng phải có một số thứ knhư vậy x^k == 1 mod y, vì x, ylà đồng thời, và vì điều đó kchúng ta phải có a == b mod k. Vì vậy, chúng ta có thể tìm thấy logarit rời rạc của 1 mod yvà cho bước đầu tiên chúng ta nhận được

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

Vì vậy, bây giờ chúng tôi muốn tìm hai số a, bnhư vậy a == b mod k. Để làm điều này, chúng tôi thiết lập yđược kvà cố gắng tìm a, bnhư vậy x^a == x^b mod ymột lần nữa. Sử dụng cùng một logic, chúng tôi lấy lại logarit rời rạc và nhận được

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

Chúng tôi lặp lại điều này cho đến khi chúng tôi nhận được một số nhỏ y, tại thời điểm đó thật tầm thường khi tìm thấy hai số băm cho cùng một điều modulo y. Sau 63 lần lặp y = 4, tại điểm cơ bản, hai số bất kỳ đều hoạt động.

Đây là mã Mathicala để tạo chuỗi nhật ký rời rạc:

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

Điều này cho đầu ra sau .

Pyth, 8 byte bởi FryAmTheEggman

99999999999999999999999999

và

99999999999999999999999998

Độ chính xác điểm nổi không đủ lớn cho việc này.

CJam, 44 byte, người dùng jimmy23013

Các con số quá lớn để đăng, vì vậy ở đây chúng nằm trên Pastebin: num 1 , num 2 .

Số đầu tiên là số 600^2 = 360000. Số thứ hai là như nhau, ngoại trừ các thay đổi sau:

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

Cả băm để 271088937720654725553339294593617693056.

Giải trình

Chúng ta hãy xem nửa đầu của mã:

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)

Vì vậy, nếu chúng ta có thể tìm thấy hai số đầu vào sao cho tổng của S[i][j]*13^i*19^j cùng một modulo 16^20cho cả mảng rộng 600 ban đầu và mảng được nén, thì chúng ta đã hoàn thành.

Để làm cho mọi thứ dễ dàng hơn một chút, chúng tôi sẽ chỉ xem xét các 600^2 = 360000số đầu vào kỹ thuật số, sao cho mảng rộng 600 chỉ là một chữ số 600 x 600 vuông. Điều này làm cho mọi thứ dễ hình dung hơn và có giá trị vì10^360000 ~ 2^(2^20.19) < 2^(2^30) . Để đơn giản hóa mọi thứ hơn nữa, chúng ta sẽ chỉ xem xét các chuỗi đầu vào như vậy có hình vuông chữ số đối xứng dọc theo đường chéo chính, sao cho mảng ban đầu và mảng được nén là như nhau. Điều này cũng cho phép chúng ta bỏ qua việc đảo ngược chuỗi ban đầu và đánh số chỉ mục từ phải sang trái, chúng sẽ triệt tiêu lẫn nhau.

Để bắt đầu, chúng tôi có thể lấy số đầu tiên là số đầu tiên 360000. Để có được số thứ hai, chúng tôi muốn sửa đổi điều này bằng cách thay đổi một số chữ số sao cho các tổng là cùng một modulo 16^20, trong khi vẫn giữ đối xứng của hình vuông chữ số. Chúng tôi thực hiện điều này bằng cách tìm một danh sách các bộ ba (i, j, k)để

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

trong đó 1 <= k <= 8số tiền để tăng chữ số 1 bằng (tức là thay đổi thành chữ số từ 2 lên 9 - chúng tôi có thể đã bao gồm 0 nhưng chúng tôi không cần nó) và 0 <= i < j < 600là cặp chỉ số.

Một khi chúng ta có (i, j, k)ba, chúng ta thay đổi các chữ số tại (i, j)và (j, i)để 1+kđể có được số thứ hai. Các bộ ba được tìm thấy bằng thuật toán quay lui tham lam và cho số thứ hai phía trên hình vuông chữ số trông như sau:

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

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

Ví dụ, (i, j, k) = (0, 1, 7)tương ứng với việc thay đổi các chữ số (0, 1)(vị trí 600*0 + 1 = 1) và (1, 0)(vị trí 600*1 + 0 = 600) thành 1 + 7 = 8.

Đây là trình quay lại trong Python 3, mặc dù kiểm tra kỹ hơn cho thấy chúng tôi khá may mắn, vì thực tế không có quay lại nào xảy ra:

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

Đối với phần thưởng, đây là một cổng băm không hiệu quả trong Python 3. Nó vô dụng.

PHP 4.1, 66 byte bởi 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;

Tìm thấy bằng cách sử dụng băm lặp đơn giản, bắt đầu từ 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) bởi Sp3000

Tin nhắn của tôi là

5012053369354645637214643587103597313576086380250249302980438772005248488380915054746146050001036696049972235875591571028140916001206596142280971107479334216535925703480968283657357930602076844092875640359192729378384507238123245417656548512647301639542279794868512420586823155070914644206130805893968511673770843170450832829657206145931885656157628306896903719624729809643572222159364893644113710867223921580178741177106141068298067479650611992859787419779579962211254029169589775046869542029842374359998053713002047081002506346875804341770199884355810931652447801492691887376948615365487982834690942054717077615539311699691010938426302886867891090301248321702485904291177813145565144089044261424329155436660979948932491709511914065619715728353376578192548334780893602675684085757434059540582004872746967999949306946618036846307799677491651967418565531672392468089533111553281620101129322575737949904022139471688252420467041529301533363008476437812216585923822571793353317799365005036029476865
5012053369354645637214643587103103086948976188724715498910865650846170784131001427390927276355140411160919276493388206817700368694224128444524223814513348177926532982330730066315320819293979046126543806115318009892783577432467861426768883700930779409885418980853424256180864755881414774514084197887594253752179391098292488771920695965135791582218083012144604515253506370334133858904659263953147111654656123599460222236152128559750436960308887683690915261431659087040402402092795259541564130228515353133867041828417398395559815392177084002004583988047406317670433664624642858480970640416500369367395538257341309676777745698712896295462462064271676447460293684100001583256400774270688958051470568447233589146620275159126426142305307007744396679875427883384557759778766330566230012377845843842097372663092379922300568052486301863154557664156185573021849420011058607321977550938866119133331529852821217331665195832442542012455132139770813510559894254061471149750738447764616026512400623344132554752

Tôi đã sử dụng mã Python 2 này để tạo chúng:

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)

Các mô-đun lớn là một sản phẩm của hai số nguyên tố avàb . Tôi đoán hy vọng rằng chúng tôi sẽ không thể tính được yếu tố bán kết, nhưng tôi đoán 128 bit là quá nhỏ vì một số trang web đã cho tôi câu trả lời ngay lập tức.

Modulo nhóm nhân absẽ có thứ tự (a - 1) (b - 1) có nghĩa là nếu chúng ta tăng bất kỳ số nào lên công suất đó, nó sẽ phải dẫn đến 0 hoặc (thường) 1. Vì vậy, tôi đặt 1 bit vào những vị trí dẫn đến 2 ^{(a-1) (b-1)} được nhân lên thành hàm băm. Sau đó, thông báo khác về cơ bản là 0, nhưng tôi đặt một bit khác trong mỗi số để làm cho độ dài giống nhau.

Tôi nghĩ rằng sẽ khó chịu hơn khi băm bình phương trên mỗi bit, thay vì chỉ sau khi sử dụng tất cả các số nguyên tố. Sau đó, sẽ không đơn giản để xây dựng số mũ tùy ý cho chúng.

C, 128 byte - bởi: squossish ossifrage

Hai chuỗi sau cả hai băm cho tất cả các số 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

Hàm băm được xây dựng sao cho các bit bậc cao hơn không bao giờ ảnh hưởng đến các bit bậc thấp hơn, do đó tôi có thể tạo ra một tập hợp các chuỗi trong đó tất cả các xbit bậc thấp hơn bằng 0, sau đó tôi có thể thử kết hợp các chuỗi này để tìm ra một số nơi có nhiều chuỗi các bit thấp hơn bằng không, v.v ... Tôi khá chắc chắn rằng có nhiều cách để phá vỡ điều này hơn, và cũng là những cách tạo ra các chuỗi ngắn hơn đáng kể, nhưng cách này tôi đã tránh làm nhiều phép toán.

Python 3, 118 byte

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

và

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

(đó là: 9E400 và 9E4000)

Cả hai sản xuất

83909358607540647658718900164058931893

Đào sâu hơn một chút, dường như bất kỳ số nguyên nào theo sau k chữ số lặp lại sao cho k> 128 và (k% 4 == 0) sẽ trả về cùng một hàm băm. Ví dụ, H("1"+"1"*32*4)và H("1"+"1"*33*4)là cả hai 13493430891393332689861502800964084413. Hừm, 128 ...

Python 2, 161 byte, bởi Puzzled

340282366920938463463374607431768211456 (decimal)
100000000000000000000000000000000 (hexadecimal)

và

340282366920938468780317283222139437056 (decimal)
100000000000001203B66F94300000000 (hexadecimal)

Cả hai đều có đầu ra:

83F172CC3D050D131F64FD04B8181DC2

Các số là 2 ^ 128 và 2 ^ 128 + (3 * 5 * 7 * 11 * 13 * 17) ^ 2 * 19 * 2 ^ 32.

Java, 299 byte bởi SuperJedi224

Pastebin cho M. Trong nhị phân, Mcó 65535 1s, tiếp theo là 2 0s.

Pastebin cho N. Trong nhị phân, Ncó 21845 1s, tiếp theo là 1747660 s.

Cả hai năng suất 0.

Lưu ý rằng cơ sở của thuật toán là i.bitCount()*i.bitLength()+1và cuối cùng, chúng tôi lấy kết quả cho sức mạnh của ivà đưa nó vào mod 2 ¹²⁸ . Vì vậy, ý tưởng chỉ là tìm hai isố chia hết cho bốn, nhưng trong đó biểu thức đầu tiên cho 2 ³² . Điều đó đã được thực hiện dễ dàng bằng cách bao thanh toán 2 ³² -1 và chọn hai yếu tố cho số 1 và tổng chiều rộng bit của số.

Chỉnh sửa: Trên thực tế, có thêm một chút lý do tại sao Mmang lại số 0, nhưng chúng ta có thể dễ dàng tìm thấy nhiều số hơn mang lại số 0 do lời giải thích của tôi bằng cách sử dụng các yếu tố khác của 2 ³² -1 sao cho có ít nhất 64 số 0 ở cuối.

C, 134 byte (bởi Barteks2x)

10

và

20

cả băm để

0xa609779942cb9ef1

bởi vì thuật toán chỉ băm chữ số cuối cùng!

C, 87 byte

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

Tìm thấy bằng cách sử dụng bruteforcer va chạm của tôi.

Python 2, 115 byte, bởi ossifrage vuông vức

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222

và

2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222211111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

Giá trị băm không liên quan gì đến thứ tự các khối.

Python 2.x, 139 byte bởi Puzzled

H(2)

và

H(128)

cả hai trở về

16645614427504350476847004633262883518.

C ++, 239 byte bởi SpelingMistake

Sử dụng chương trình "chính" được cung cấp, hai đầu vào sau đây tạo ra cùng một hàm băm:

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

và

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

Các 8 byte đầu tiên của đầu vào không bao giờ xử lý , do lỗi này trong các mã:

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

bởi vì ước lượng --ithành false khi i==1, q[0](8 byte đầu tiên: Ilà một int64). Thay thế điều kiện vòng lặp bằng for(I i=n;i--;)sẽ sửa lỗi này.

Ruby, 90 byte, bởi MegaTom

4271974071841820164790043412339104229205409044713305539894083215644439451561281100045924173873152

và

23495857395130010906345238767865073260629749745923180469417457686044416983587046050252582956302336

đó là 2 và 11 theo sau là 40 byte. Vì vậy, cả hai đều có 41 byte. Giá trị băm được thêm vào bởi độ dài đầu vào cho mỗi byte và sau đó nó được đảo ngược theo số thập phân. Độ dài đầu vào kết thúc bằng1 có thể đảm bảo giá trị băm sẽ kết thúc bằng0 khá nhanh. Sau đó đảo ngược nó làm giảm độ dài của giá trị băm 1.

Cả hai đều có giá trị băm 259.

C # - 393 byte - bởi: Đập Logan

70776e65642062792031333337206861786f72và 70776e65642062792031333337206861786f7200cả băm để 18E1C8E645F1BBD1.