क्रिप्टोग्राफिक हैश गोल्फ


34

यह प्रतियोगिता समाप्त हो गई है।

चुनौतियों की प्रकृति के कारण , पुलिस चुनौती बहुत आसान हो जाती है जब संबंधित लुटेरों की चुनौती में रुचि कम हो जाती है। इसलिए, जब आप अभी भी हैश फ़ंक्शन पोस्ट कर सकते हैं, तो आपका उत्तर स्वीकार नहीं किया जाएगा या लीडरबोर्ड का हिस्सा नहीं होगा।

यह चुनौती एक की कम से कम कार्यान्वयन के लिए एक खोज है हैश फंक्शन वह यह है कि टक्कर प्रतिरोधी , यानी, यह एक ही हैश के साथ दो अलग-अलग संदेशों को खोजने के अव्यवहार्य होना चाहिए।

एक पुलिस वाले के रूप में, आप कोड आकार और टक्कर प्रतिरोध के बीच सबसे अच्छा समझौता खोजने के लिए एक हैश फ़ंक्शन का आविष्कार और कार्यान्वित करने का प्रयास करते हैं। बहुत सारे बाइट्स का उपयोग करें और एक अन्य पुलिस वाला आपको आउटगोल्फ करेगा!

एक डाकू के रूप में, आप उनके कार्यों को क्रैक करके पुलिस के प्रयासों को विफल करने की कोशिश करते हैं, यह साबित करते हुए कि वे अनुपयुक्त हैं। यह उन्हें अपने एल्गोरिदम को मजबूत करने के लिए अधिक बाइट्स का उपयोग करने के लिए मजबूर करेगा!

चुनौती देता है

कार्य

अपनी पसंद के क्रिप्टोग्राफ़िक हैश फ़ंक्शन एच: I -> O को लागू करें, जहां मैं 2 2 30 के नीचे सभी गैर-नकारात्मक पूर्णांक का सेट है और O 2 128 से नीचे सभी गैर-नकारात्मक पूर्णांकों का समूह है ।

आप या तो एच को एक वास्तविक फ़ंक्शन के रूप में कार्यान्वित कर सकते हैं जो एकल पूर्णांक, पूर्णांक का एक स्ट्रिंग प्रतिनिधित्व या पूर्णांक का एक सरणी या एक पूर्ण कार्यक्रम है जो STDIN से पढ़ता है और आधार 10 या 16 में STDOUT को प्रिंट करता है।

स्कोरिंग

  • एच कि इसे नीचे परिभाषित लुटेरों की चुनौती का विरोध करना है ।

    यदि कोई डाकू पोस्ट करने के बाद पहले 168 घंटों में आपके सबमिशन को हरा देता है, तो उसे क्रैक माना जाता है ।

  • H का कार्यान्वयन यथासंभव कम होना चाहिए। सबसे छोटा अनियंत्रित सबमिशन पुलिस चुनौती का विजेता होगा।

अतिरिक्त नियम

  • यदि आप H को एक फंक्शन के रूप में कार्यान्वित करते हैं, तो कृपया उस प्रोग्राम को निष्पादित करने के लिए एक आवरण प्रदान करें जो ऊपर बताए अनुसार व्यवहार करता है।

  • कृपया अपने कार्यक्रम या आवरण (उदाहरण इनपुट और उनके संबंधित आउटपुट) के लिए कम से कम तीन परीक्षण वैक्टर प्रदान करें।

  • H आपके उपन्यास का डिज़ाइन (पसंदीदा) या एक प्रसिद्ध एल्गोरिथ्म हो सकता है, जब तक कि आप इसे स्वयं कार्यान्वित नहीं करते। किसी भी तरह के इन-बिल्ट हैश फंक्शन, कम्प्रेशन फंक्शन, सिफर, PRNG, इत्यादि का उपयोग करना मना है।

    किसी भी अंतर्निहित हैशिंग कार्यों को लागू करने के लिए आमतौर पर उपयोग किया जाता है (उदाहरण के लिए, आधार रूपांतरण) उचित खेल है।

  • आपके प्रोग्राम या फ़ंक्शन का आउटपुट नियतात्मक होना चाहिए।

  • एक निशुल्क (बीयर के रूप में) संकलक / दुभाषिया होना चाहिए जो कि x86 या x64 प्लेटफ़ॉर्म पर या किसी वेब ब्राउज़र से चलाया जा सकता है।

  • आपका कार्यक्रम या कार्य यथोचित रूप से कुशल होना चाहिए और I 2 2 19 से नीचे किसी भी संदेश को सेकंड से कम में हैश करना है ।

    एज मामलों के लिए, मेरी मशीन (इंटेल कोर i7-3770, 16 GiB RAM) पर लिया गया (दीवार) समय निर्णायक होगा।

  • इस चुनौती की प्रकृति को देखते हुए, किसी भी तरह से अपने उत्तर के कोड को बदलने के लिए मना किया जाता है, चाहे वह आउटपुट को बदल दे या नहीं।

    यदि आपका सबमिशन क्रैक किया गया है (या यहां तक ​​कि अगर यह नहीं है), तो आप एक अतिरिक्त उत्तर पोस्ट कर सकते हैं।

    यदि आपका उत्तर अमान्य है (उदाहरण के लिए, यह I / O विनिर्देशन का अनुपालन नहीं करता है), तो कृपया इसे हटा दें।

उदाहरण

पायथन 2.7, 22 बाइट्स

def H(M):
 return M%17

आवरण

print H(int(input()))

लुटेरे चुनौती देते हैं

कार्य

'में निम्नलिखित पोस्ट करके प्रस्तुतियाँ पुलिस के किसी भी क्रैक धागा लुटेरों' दो संदेश: एम और एन में मैं ऐसा है कि एच (एम) = एच (एन) और एम ≠ एन

स्कोरिंग

  • प्रत्येक पुलिस सबमिशन को क्रैक करने से आपको एक अंक मिलता है। सबसे अधिक अंक के साथ डाकू जीतता है।

    एक टाई के मामले में, सबसे लंबे समय तक सबमिशन जीत को क्रैक करने वाला बंधे हुए डाकू।

अतिरिक्त नियम

  • प्रत्येक पुलिस सबमिशन केवल एक बार क्रैक किया जा सकता है।

  • यदि एक पुलिस सबमिशन कार्यान्वयन-परिभाषित या अपरिभाषित व्यवहार पर निर्भर करता है, तो आपको केवल एक दरार ढूंढनी होगी जो आपकी मशीन पर काम करती है (वास्तव में)।

  • प्रत्येक दरार लुटेरों के धागे में एक अलग उत्तर से संबंधित है।

  • अमान्य क्रैकिंग प्रयास पोस्ट करने से आप उस विशेष सबमिट को 30 मिनट के लिए क्रैक कर सकते हैं।

  • आप अपनी खुद की सबमिशन क्रैक नहीं कर सकते हैं।

उदाहरण

Python 2.7, 22 बाइट्स user8675309 द्वारा

1

तथा

18

लीडरबोर्ड

सुरक्षित प्रस्तुतियाँ

  1. सीजाम, ईबिजनेस द्वारा 21 बाइट्स
  2. सी ++, 148 बाइट्स टुक्सी द्वारा
  3. सी ++, 233 (?) वी द्वारा बाइट्स।

निर्विवाद प्रस्तुतियाँ

आप इस स्टैक स्निपेट का उपयोग कर सकते हैं ताकि अभी तक फटे हुए उत्तरों की सूची प्राप्त न हो सके।

function g(p){$.getJSON('//api.stackexchange.com/2.2/questions/51068/answers?page='+p+'&pagesize=100&order=desc&sort=creation&site=codegolf&filter=!.Fjs-H6J36w0DtV5A_ZMzR7bRqt1e',function(s){s.items.map(function(a){var h=$('<div/>').html(a.body).children().first().text();if(!/cracked/i.test(h)&&(typeof a.comments=='undefined'||a.comments.filter(function(b){var c=$('<div/>').html(b.body);return /^cracked/i.test(c.text())||c.find('a').filter(function(){return /cracked/i.test($(this).text())}).length>0}).length==0)){var m=/^\s*((?:[^,(\s]|\s+[^-,(\s])+)\s*(?:[,(]|\s-).*?([0-9]+)/.exec(h);$('<tr/>').append($('<td/>').append($('<a/>').text(m?m[1]:h).attr('href',a.link)),$('<td class="score"/>').text(m?m[2]:'?'),$('<td/>').append($('<a/>').text(a.owner.display_name).attr('href',a.owner.link))).appendTo('#listcontent');}});if(s.length==100)g(p+1);});}g(1);
table th, table td {padding: 5px} th {text-align: left} .score {text-align: right} table a {display:block}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><table><tr><th>Language</th><th class="score">Length</th><th>User</th></tr><tbody id="listcontent"></tbody></table>


यदि कोई हैश फ़ंक्शन त्रुटिपूर्ण रूप से 2 ^ 128-1 से अधिक संख्या देता है, तो क्या यह सबमिशन को अमान्य करता है, या हम केवल परिणाम modulo 2 ^ 128 लेंगे?
मार्टिन एंडर

@ मार्टिनबटनर: हां, आपको रिजल्ट मोडुलो 2 ^ 128 लेना होगा।
डेनिस

1
@Scimonster आवश्यकताओं को पूरा नहीं करता (2 ^ तक 30 बिट इनपुट, आउटपुट के 128 बिट्स)
कोडइन्कॉउंस

1
क्या पुलिस और लुटेरे आमतौर पर दूसरे रास्ते नहीं जाते?
haneefmubarak

2
शायद हमारे पास एक नियम हो सकता है कि सबमिशन में उदाहरण हैश शामिल होना चाहिए, सबमर्स चुने गए प्रोग्रामिंग भाषा को चलाने के लिए काफी कष्टप्रद है ताकि लोगों के खिलाफ क्रैकिंग कार्यान्वयन की तुलना करने के लिए एक परिणाम हो।
आआआआआआआआआआ आआआआआ

जवाबों:


6

सीजेएम, 21 बाइट्स

1q3*{i+_E_#*^26_#)%}/

इनपुट के रूप में बाइट्स की एक स्ट्रिंग लेता है।

छद्मकोश में:

hash = 1
3 times:
    for i in input:
        hash = hash + i
        hash = hash xor hash * 14^14
        hash = hash mod (26^26 + 1)
output hash

उदाहरण हैश:

"" (खाली स्ट्रिंग) -> 1
"टेस्ट" -> 2607833638733409808360080023081587841
"परीक्षण" -> 363640467424586895504738713637444413

यह साधारण पक्ष पर थोड़ा सा हो सकता है, आउटपुट रेंज केवल 122 बिट्स से थोड़ा अधिक है, ट्रिपल पुनरावृत्ति सुदृढ़ीकरण पहले से ही थोड़ा टूट गया है क्योंकि यह हर बार बिल्कुल वैसा ही करता है, इसलिए इनपुट हैश में 1 से 1 है पुनरावृति पूर्ण विराम होगा। लेकिन यह कम है, और बहुत सुरक्षित होने में कोई मज़ा नहीं है।


वहाँ अन्य CJam पोस्ट की तरह एक साथ सी संस्करण है?
वि।

@Vi। नहीं, अभी कम से कम नहीं। मैंने कभी सी में बिगिन के साथ डब नहीं किया, क्या इसके लिए एक मानक पुस्तकालय है?
आआआआआआआआआआ आआआआ



1
@ Agawa001 आप अपनी शब्दावली को मिला रहे हैं। यह एक ट्रिपल-पास स्पंज फ़ंक्शन हैश एल्गोरिथम है। सीज़र सिफर एक विशिष्ट एन्क्रिप्शन एल्गोरिथ्म है जिसमें कोई आंतरिक स्थिति नहीं है।
आआआआआआआआआआआ आआआआ

7

अजगर, 109 बाइट्स [ फटा , और फिर ]

def f(n,h=42,m=2**128):
 while n:h+=n&~-m;n>>=128;h+=h<<10;h^=h>>6;h%=m
 h+=h<<3;h^=h>>11;h+=h<<15;return h%m

मैंने जेन्किन्स के एक-एक-समय के कार्य को लागू करने की कोशिश की , जैसा कि एकमात्र अंतर है, बीज और बिट्स की संख्या।

मजेदार तथ्य: स्पष्ट रूप से पर्ल ने कुछ बिंदुओं पर जेनकींस के हैश का इस्तेमाल किया

आवरण

print(f(int(input())))

उदाहरण

>>> f(0)
12386682
>>> f(1)
13184902071
>>> f(2**128-1)
132946164914354994014709093274101144634
>>> f(2**128)
13002544814292
>>> f(2**128+1)
13337372262951
>>> f(2**(2**20))
290510273231835581372700072767153076167



6

सी ++, 148 बाइट्स

typedef __uint128_t U;U h(char*b,U n,U&o){U a=0x243f6a8885a308d,p=0x100000001b3;for(o=a;n--;)for(U i=27;--i;){o=(o<<i)|(o>>(128-i));o*=p;o^=b[n];}}

__uint128_t एक GCC एक्सटेंशन है, और उम्मीद के मुताबिक काम करता है। हैश FNV हैश को पुनरावृत्त करने पर आधारित है (मैंने उनके प्राइम को उधार लिया है, हालांकि प्रत्येक पुनरावृत्ति की शुरुआत में aएक sha1 की तरह रोटेशन के साथ hex में Pi का पहला अंक है) । के साथ संकलित -O3, हैशिंग 10MB फ़ाइल में 2 सेकंड लगते हैं, इसलिए आंतरिक लूप में पुनरावृत्तियों को ऊपर उठाने के लिए अभी भी मार्जिन है - लेकिन मैं आज उदार महसूस कर रहा हूं।

अपने खुर आनंद के लिए डी-क्रॉलिफ़ाइड (परिवर्तित चर नाम, टिप्पणी, व्हाट्सएप और ब्रेसिज़ की एक जोड़ी):

typedef __uint128_t U;
U h(char* input, U inputLength, U &output){
    U a=0x243f6a8885a308d,p=0x100000001b3;    
    for(output=a;inputLength--;) {   // initialize output, consume input
        for(U i=27;--i;) {                          // evil inner loop
            output = (output<<i)|(output>>(128-i)); // variable roll 
            output *= p;                            // FNV hash steps
            output ^= input[inputLength];        
        }
    }
    // computed hash now available in output
}

गोल्फ सुझावों का स्वागत है (भले ही मुझे उनके आधार पर कोड में सुधार करने के लिए नहीं मिलता है)।

संपादित करें: de-uglified कोड में निश्चित टाइपोस (गोल्फ संस्करण अपरिवर्तित रहता है)।


oअसिंचित प्रतीत होता है। कहां outputघोषित किया गया? या हो सकता oहै output?
वि।

उसी के लिए n। क्या आपने वास्तव में चलाने के लिए "de-uglified" कोड की जाँच की है?
वि।

ब्रूटफ़ॉर्मर शुरू किया ...
वीआई।

यहां तक ​​कि 3-राउंड संस्करण भी आसान नहीं है।
वि।

@Vi। फिक्स्ड डी-क्रॉसीफाइड संस्करण - इसे बेहतर तरीके से जांच नहीं करने के लिए क्षमा करें। मुझे उस आंतरिक पाश पर गर्व है; U i=81;i-=3महत्वपूर्ण रनटाइम लागत के बिना और भी अधिक शून्य हो सकता था।
16 नवंबर को tucuxi

5

CJam, 44 बाइट्स [ फटा ]

lW%600/_z]{JfbDbGK#%GC#[md\]}%z~Bb4G#%\+GC#b

इनपुट बेस 10 में है।

CJam धीमा है। मुझे आशा है कि यह कुछ कंप्यूटर में 1 सेकंड में चलता है ...

स्पष्टीकरण

lW%600/            e# Reverse, and split into chunks with size 600.
_z                 e# Duplicate and swap the two dimensions.
]{                 e# For both versions or the array:
    JfbDb          e# Sum of S[i][j]*13^i*19^j, where S is the character values,
                   e# and the indices are from right to left, starting at 0.
    GK#%GC#[md\]   e# Get the last 32+48 bits.
}%
z~                 e# Say the results are A, B, C, D, where A and C are 32 bits.
Bb4G#%             e# E = the last 32 bits of A * 11 + C.
\+GC#b             e# Output E, B, D concatenated in binary.

खैर, दो आयामी चीजें एक कमजोरी लग रही थीं ... इसका मकसद शुरुआत में कुछ धीमी गणना करना था। लेकिन यह एक दूसरे से कोई फर्क नहीं पड़ता कि मैं क्या करता हूं, इसलिए मैंने धीमे कोड को हटा दिया।

यह भी बेहतर होना चाहिए अगर मैंने बाइनरी बिट्स और उच्चतर अड्डों का उपयोग किया है।

सी संस्करण

__uint128_t hash(unsigned char* s){
    __uint128_t a=0,b=0;
    __uint128_t ar=0;
    __uint128_t v[600];
    int l=0,j=strlen(s);
    memset(v,0,sizeof v);
    for(int i=0;i<j;i++){
        if(i%600)
            ar*=19;
        else{
            a=(a+ar)*13;
            ar=0;
        }
        if(i%600>l)
            l=i%600;
        v[i%600]=v[i%600]*19+s[j-i-1];
        ar+=s[j-i-1];
    }
    for(int i=0;i<=l;i++)
        b=b*13+v[i];
    a+=ar;
    return (((a>>48)*11+(b>>48))<<96)
        +((a&0xffffffffffffull)<<48)
        +(b&0xffffffffffffull);
}

क्या आप कृपया विवरण जोड़ सकते हैं? CJam को हर कोई नहीं जानता।
orlp

@orlp संपादित ...
jimmy23013

यह मेरे कंप्यूटर पर 0.4 s लेता है, इसलिए यह अनुमत सीमा के भीतर अच्छी तरह से है।
डेनिस

ए, बी, सी और इतने पर क्या है? कुछ मैट्रिसेस? कौन से आयाम? क्या इसे C में आसानी से लागू किया जा सकता है?
वि।

1
फटा , मुझे विश्वास है।
Sp3000

5

C ++, 182 वर्ण (+ बॉयलरप्लेट के 51 वर्ण)

h=0xC0CC3051F486B191;j=0x9A318B5A176B8125;char q=0;for(int i=0;i<l;++i){char w=buf[i];h+=((w<<27)*257);j^=(h+0x5233);h+=0xAA02129953CC12C3*(j>>32);j^=(w+0x134)*(q-0x16C552F34);q=w;}

बॉयलरप्लेट:

void hash(const unsigned char* buf, size_t len, unsigned long long *hash1, unsigned long long *hash2)
{
    unsigned long long &h=*hash1;
    unsigned long long &j=*hash2;
    size_t l = len;
    const unsigned char* b = buf;

    // code here
}

एक गोल्फ समारोह के साथ चलने योग्य कार्यक्रम

#include <stdio.h>

// The next line is 227 characters long
int hash(char*b,int l,long long&h,long long&j){h=0xC0CC3051F486B191;j=0x9A318B5A176B8125;char q=0;for(int i=0;i<l;++i){char w=b[i];h+=((w<<27)*257);j^=(h+0x5233);h+=0xAA02129953CC12C3*(j>>32);j^=(w+0x134)*(q-0x16C552F34);q=w;}}

int main() {
    char buf[1024];
    int l  = fread(buf, 1, 1024, stdin);
    long long q, w;
    hash(buf, l, q, w);
    printf("%016llX%016llX\n", q, w);
}

2
मुझे लगता है कि फ़ंक्शन की घोषणा आदि चरित्र संख्या की ओर गिना जाता है।
यपनीपं जू

@Ypnypn, गिने हुए फंक्शन डिक्लेरेशन में गिने गए कैरेक्टर।
वि।

आउटपुट हैश क्या है? मैं मान रहा हूँ कि यह ((h << 64) | j) है।
tucuxi

हाँ। या सिर्फ 64-बिट संख्याओं की एक जोड़ी। मुझे यह पता लगाने के __uint128_tबाद ही पता चला ।
वि।

1
@Dennis, Done.󠀠
Vi।

4

अजगर, 8 फटा

sv_`.lhQ

इसे ऑनलाइन आज़माएं

थोड़ा सा मूर्खतापूर्ण जवाब, मैं समझाता हूं कि यह कैसे काम करता है क्योंकि अधिकांश लोग पायथ नहीं पढ़ सकते हैं। यह एक से अधिक इनपुट के प्राकृतिक लॉग लेता है, और फिर इसे एक स्ट्रिंग में परिवर्तित करता है। वह स्ट्रिंग उलट है, और फिर मूल्यांकन किया गया और फिर एक पूर्णांक में बदल दिया गया।

एक अजगर अनुवाद की तरह दिखेगा:

import math
n = eval(input()) + 1
rev = str(math.log(n))[::-1]
print(int(eval(rev)))


4

अजगर 3, 216 बाइट्स [ फटा ]

def f(m):
 h=1;p=[2]+[n for n in range(2,102)if 2**n%n==2];l=len(bin(m))-2;*b,=map(int,bin((l<<(l+25)//26*26)+m)[2:])
 while b:
  h*=h
  for P in p:
   if b:h=h*P**b.pop()%0xb6ee45a9012d1718f626305a971e6a21
 return h

कल्पना के साथ एक असंगति के कारण मैं कम से कम एक मामूली भेद्यता के बारे में सोच सकता हूं , लेकिन इसके अलावा मुझे लगता है कि यह कम से कम क्रूरता का सबूत है। मैंने पहले 10 मिलियन हैश की जाँच की है, अन्य चीजों के बीच।

गोल्फ के संदर्भ में यह पायथन 2 में छोटा होगा, लेकिन मैंने दक्षता के लिए कुछ बाइट्स का त्याग किया है (क्योंकि यह शायद वैसे भी जीतने वाला नहीं है)।

संपादित करें: यह बहुत स्मूथ हैश को लागू करने का मेरा प्रयास था , लेकिन दुर्भाग्य से 128-बिट्स बहुत छोटा था।

आवरण

print(f(int(input())))

उदाहरण

>>> f(0)
2
>>> f(123456789)
228513724611896947508835241717884330242
>>> f(2**(2**19)-1)
186113086034861070379984115740337348649
>>> f(2**(2**19))
1336078

कोड स्पष्टीकरण

def f(m):
 h=1                                             # Start hash at 1
 p=[2]+[n for n in range(2,102)if 2**n%n==2]     # p = primes from 2 to 101
 l=len(bin(m))-2                                 # l = bit-length of m (input)
 *b,=map(int,bin((l<<(l+25)//26*26)+m)[2:])      # Convert bits to list, padding to
                                                 # a multiple of 26 then adding the
                                                 # bit-length at the front

 while b:                                        # For each round
  h*=h                                           # Square the hash
  for P in p:                                    # For each prime in 2 ... 101
   if b:h=(h*P**b.pop()                          # Multiply by prime^bit, popping
                                                 # the bit from the back of the list
           %0xb6ee45a9012d1718f626305a971e6a21)  # Take mod large number

 return h                                        # Return hash

के लिए पैडिंग का एक उदाहरण f(6):

[1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0]

(len 3)(------------------ 23 zeroes for padding -------------------------)(input 6)
       (---------------------------- length 26 total ------------------------------)


4

सी, 87 बाइट्स [ फटा ]

यह पूरा कार्यक्रम है; कोई आवरण आवश्यक नहीं है। स्टड के माध्यम से बाइनरी इनपुट को स्वीकार करता है, और स्टैडआउट के लिए एक हेक्साडेसिमल हैश आउटपुट करता है।

c;p;q;main(){while((c=getchar())+1)p=p*'foo+'+q+c,q=q*'bar/'+p;printf("%08x%08x",p,q);}

यह केवल 64-बिट हैश की गणना करता है, इसलिए मैं यहां थोड़ा जुआ खेल रहा हूं।

मामले में किसी को भी सोच रहा है, दो स्थिरांक 'foo+'और 'bar/'रूढ़ अंक 1718578987 और 1650553391 हैं।


उदाहरण:

अग्रणी शून्य की उपेक्षा करता है:

echo -ne '\x00\x00\x00\x00' |./hash
0000000000000000

एकल-बाइट इनपुट:

echo -ne '\x01' |./hash
0000000100000001
echo -ne '\xff' |./hash
000000ff000000ff

मल्टी-बाइट इनपुट:

echo -ne '\x01\x01' |./hash
666f6f2dc8d0e15c
echo -ne 'Hello, World' |./hash
04f1a7412b17b86c

Aa आ आ आ आ आ आ आ आ आ आ आ आ आ रहास्स्स्स्स्स्स्स्स्स्स्स्स्स्स्स् अहों में से उसके साथ कैसे बर्ताव करोगी?
इस्माइल मिगुएल

1
foo|(d5c9bef71d4f5d1b) और foo\(d5c9bef71d4f5d1b) बहुत समान हैश पैदा करते हैं ।
इस्माइल मिगुएल

1
उसे तोड़ दिया!!! \x00और \x00\x00!
इस्माइल मिगुएल

1
चैट टिप्पणियों के आधार पर, मेरा मानना ​​है कि यह अभी भी फटा नहीं है? सिर्फ दोहरी जाँच, क्योंकि उखाड़ी गई टिप्पणी उन लोगों को भ्रमित कर सकती है जो अनियोजित हैश के लिए स्किमिंग कर रहे हैं।
Sp3000


3

जे - 39 बाइट्स - फटा

इनपुट के रूप में एक स्ट्रिंग ले रहा है और एक पूर्णांक लौटाता है <2 128 । मैं मान रहा हूं कि हमें अपने कार्य को मान्य बनाने के लिए नाम देना है, इसलिए यदि हम अनाम फ़ंक्शन सबमिट कर सकते हैं, तो गिनती से अन्य 3 वर्णों को छोड़ दें।

H=:_8(".p:@+5,9:)a\(a=.(2^128x)&|@^/@)]

आप में से उन लोगों के लिए जो चित्रलिपि नहीं पढ़ते हैं, यहाँ मैं क्या कर रहा हूँ, इसका एक हिस्सा है।

  • a=.(2^128x)&|@^/@यह एक सबरूटीन * है जो संख्याओं की एक सरणी लेता है, और फिर इसे एक पावर टॉवर के रूप में मानता है, जहां प्रतिपादक मॉड 2 128 लिया जाता है । "पावर टॉवर" से, मेरा मतलब है कि अगर आपने इसे इनपुट दिया 3 4 5 6, तो यह गणना करेगा 3 ^ (4 ^ (5 ^ 6))
  • (".p:@+5,9:)aयह फ़ंक्शन एक स्ट्रिंग लेता है, इसे संख्या N में परिवर्तित करता है , और फिर ( n +5) -th और ( n +9) -थ अभाज्य संख्याओं की गणना करता है, और फिर उस aपर पहले से फेंकता है। यही है, हम p(n+5) ^ p(n+9)मॉड 2 128 पाते हैं, जहां p(k)यह kप्रधानमंत्री है।
  • H=:_8...\(a...)]इनपुट के 8-चरित्र सबब्लॉक पर उपरोक्त फ़ंक्शन करें, और फिर aसभी परिणाम एक साथ और परिणामी हैश फ़ंक्शन को कॉल करें H। मैं 8 वर्णों का उपयोग करता हूं क्योंकि J " k-th Prime" फ़ंक्शन विफल रहता है जब p(k)> 2 31 , अर्थात k=105097564सबसे बड़ा सुरक्षित है k

कुछ सैंपल आउटपुट हैं। आप इसे स्वयं tryj.tk पर ऑनलाइन आज़मा सकते हैं , लेकिन मैं वास्तव में Jsoftware से दुभाषिए को डाउनलोड करके घर पर ऐसा करने की सलाह देता हूं

   H=:_8(".p:@+5,9:)a\(a=.(2^128x)&|@^/@)]
   H '88'
278718804776827770823441490977679256075
   H '0'
201538126434611150798503956371773
   H '1'
139288917338851014461418017489467720433
   H '2'
286827977638262502014244740270529967555
   H '3'
295470173585320512295453937212042446551
   30$'0123456789'  NB. a 30 character string
012345678901234567890123456789
   H 30$'0123456789'
75387099856019963684383893584499026337
   H 80$'0123456789'
268423413606061336240992836334135810465

* तकनीकी रूप से, यह अपने आप में एक फ़ंक्शन नहीं है, यह अन्य कार्यों और उनके आउटपुट पर कार्य करता है। लेकिन यह जम्मू का एक अर्थपूर्ण मुद्दा है, न कि वैचारिक अंतर: कार्यक्रम प्रवाह जैसा कि मैंने ऊपर वर्णित किया है।



2

अजगर 3, 118 बाइट्स [ फटा ]

def H(I):
    o=0;n=3;M=1<<128
    for c in I:i=ord(c);o=(o<<i^o^i^n^0x9bb90058bcf52d3276a7bf07bcb279b7)%M;n=n*n%M
    return o

इंडेंटेशन एक एकल टैब है। सरल हैश, वास्तव में अभी तक पूरी तरह से इसका परीक्षण नहीं किया है।

कॉल इस प्रकार है:

print(H("123456789"))

परिणाम: 73117705077050518159191803746489514685


अपने एल्गोरिथ्म में उपयोग करने के लिए इनपुट पूर्णांक को एक स्ट्रिंग में कैसे परिवर्तित किया जाना चाहिए?
feersum

@ फैर्सम बेस -10 स्ट्रिंग वह है जो मैंने परीक्षण किया था। यह किसी भी चीज़ का उपयोग नहीं करता है ord(c), हालांकि, वास्तव में, कोई भी स्ट्रिंग करेगा :) (nul chars जैसी चीजों को छोड़कर, मुझे लगता है कि उन हैश टक्करों को वास्तव में आसान बनाते हैं। इसलिए 0-9 स्ट्रिंग के साथ छड़ी करें)
tomsmeding

1
इसे तोड़ दिया: codegolf.stackexchange.com/a/51160/41288 । "10000" और "20000" जैसे स्ट्रिंग्स को देखकर शुरू किया गया यह बहुत ही करीब हैश का उत्पादन करता है। अधिक से अधिक शून्य के साथ खेलने के लिए शुरू किया, और 128 या तो के बाद, किसी भी अंक + के * 4 शून्य दोहराता है कि कश्मीर की परवाह किए बिना एक ही हैश देता है।
tucuxi

@tucuxi पहले से ही सोचा था कि यह बहुत मुश्किल नहीं होना चाहिए ; खुशी है कि तुच्छ नहीं था, लेकिन किसी ने इसे वैसे भी तोड़ दिया। अच्छा कार्य।

2

सी ++, 239 बाइट्स

मेरा पहला कोड गोल्फ! [ कृपया कोमल रहें ]

#define r(a,b) ((a<<b)|(a>>(64-b)))
typedef uint64_t I;I f(I*q, I n, I&h){h=0;for(I i=n;--i;)h=r(h^(r(q[i]*0x87c37b91114253d5,31)*0x4cf5ad432745937f),31)*5+0x52dce729;h^=(h>>33)*0xff51afd7ed558ccd;h^=(h>>33)*0xc4ceb9fe1a85ec53;h^=(h>>33);}

Ungolfed संस्करण:

I f(I* q, I n, I& h) // input, length and output
{
    h = 0; // initialize hashes
    for (I i=n;--i;)
    {
        q[i] *= 0x87c37b91114253d5;
        q[i]  = rotl(q[i], 31);
        q[i] *= 0x4cf5ad432745937f;

        h ^= q[i]; // merge the block with hash

        h *= rotl(h, 31);
        h = h * 5 + 0x52dce729;
    }
    h ^= h>>33;
    h *= 0xff51afd7ed558ccd;
    h ^= h>>33;
    h *= 0xc4ceb9fe1a85ec53; // avalanche!
    h ^= h>>33;
}

सबसे अच्छा हैश नहीं है, और निश्चित रूप से अस्तित्व में सबसे छोटा कोड नहीं है। गोल्फ युक्तियाँ स्वीकार करने और सुधारने की उम्मीद!

आवरण

शायद दुनिया में सबसे अच्छा नहीं है, लेकिन फिर भी एक आवरण

I input[500];

int main()
{
    string s;
    getline(cin, s);
    memcpy(input, s.c_str(), s.length());
    I output;
    f(input, 500, output);
    cout << hex << output << endl;
}

2
ठोस दिखता है, लेकिन 64 बिट्स के साथ, यह ब्रूट-फोर्सिंग के अधीन हो सकता है। ~ Sqrt (n) परीक्षण (n कुल आउटपुट के बीच) से टकराव में लगभग 50% संभावना है; 2 ^ 32 कोशिशें आधुनिक पीसी के लिए उतनी नहीं हैं।
16 नवंबर को tucuxi

रैपर में हेडर इंक्लूज़न का अभाव होता है और सामान्य तौर पर कई समान हैश की ओर जाता है।
वि।

कुछ हैश नमूने प्रदान करें। मेरे लिए "3" और "33" लीड 481c27f26cba06cf (इस रैपर का उपयोग करके) है।
वि।

क्रैक: कोडगॉल्फ.स्टैकएक्सचेंज . com / a / 51215 / 41288 । मुझे @Vi से ठीक पहले शक है। पता चला कि इतने सारे हैश बराबर क्यों थे।
तुकसी

1
उचित टक्कर (बग का उपयोग किए बिना): printf '33333333\x40\xF3\x32\xD6\x56\x91\xCA\x66' | ./hash7_-> a4baea17243177fd; printf '33333333\x77\x39\xF3\x82\x93\xDE\xA7\x2F' | ./hash7_-> a4baea17243177fd। Bruteforcer यहाँ अन्य 64-बिट हैश की तुलना में बहुत तेज़ी से टकराव पाता है।
वि।

2

जावा, 299 291 282 बाइट्स, फटा।

import java.math.*;class H{public static void main(String[]a){BigInteger i=new java.util.Scanner(System.in).nextBigInteger();System.out.print(BigInteger.valueOf(i.bitCount()*i.bitLength()+1).add(i.mod(BigInteger.valueOf(Long.MAX_VALUE))).modPow(i,BigInteger.valueOf(2).pow(128)));}}

BigIntegers पर कुछ संचालन करता है, तो परिणाम modulo 2 128 लेता है ।


मैं इसे कैसे चलाऊं? Ideone इसे संकलित करने से इनकार करता है।
मार्टिन एंडर

1
आप इसे "मुख्य" वर्ग में बदलकर या पहले "सार्वजनिक" कीवर्ड को हटाकर (लेकिन दूसरा नहीं) Ideone पर चला सकते हैं। या तो कोई काम करेगा।
सुपरजेडी २२४४


1
@ SuperJedi224 public7 चरों को बचाते हुए पहले खुद को क्यों नहीं हटाया ?
user253751

@immibis क्योंकि तब मुझे नहीं लगता कि यह ग्रहण पर सही काम करेगा। मैं हालांकि यह कोशिश करेंगे। संपादित करें: मुझे लगता है कि यह करता है। यह आश्चर्य की बात है।
SuperJedi224

2

सी, 128 बाइट्स [ फटा ]

p;q;r;s;main(c){while((c=getchar())+1)p=p*'foo+'+s^c,q=q*'bar/'+p,r=r*'qux3'^q,s=s*'zipO'+p;printf("%08x%08x%08x%08x",p,q,r,s);}

यह कमोबेश एक ही एल्गोरिथ्म है, जैसा कि मेरा आखिरी प्रयास (वीआई द्वारा क्रैक) , लेकिन अब उचित 128-बिट हैश उत्पन्न करने के लिए पर्याप्त हम्सटर पहिए हैं।

कोड में चार प्रमुख स्थिरांक इस प्रकार हैं:

'foo+' = 1718578987
'bar/' = 1650553391
'qux3' = 1903523891
'zipO' = 2053730383

पहले की तरह, यह एक पूरा कार्यक्रम है जिसमें एक आवरण की आवश्यकता नहीं है। पूर्णांक I कच्चे बाइनरी डेटा (बिग-एंडियन) के रूप में स्टड के माध्यम से इनपुट होता है, और हैश को स्टैकआउट करने के लिए हेक्स में मुद्रित किया जाता है। I में अग्रणी शून्य को अनदेखा किया जाता है।

उदाहरण:

echo -ne '\x00' |./hash
00000000000000000000000000000000
echo -ne '\x00\x00' |./hash
00000000000000000000000000000000
echo -ne '\x01' |./hash
00000001000000010000000100000001
echo -ne 'A' |./hash
00000041000000410000004100000041
echo -ne '\x01\x01' |./hash
666f6f2dc8d0e15cb9a5996fe0d8df7c
echo -ne 'Hello, World' |./hash
da0ba2857116440a9bee5bb70d58cd6a


क्या आपके उदाहरण में टक्कर नहीं थी (पहले दो)?
mbomb007

@ mbomb007 नंबर इनपुट 0 और 2 ^ (2 ^ 30) के बीच की संख्या है। 0x00 और 0x0000 दोनों शून्य के बराबर हैं, इसलिए वे एक ही आउटपुट का उत्पादन करते हैं।
स्क्वीश ossifrage

2

सी, 122 बाइट्स [ फटा ]

long long x,y,p;main(c){for(c=9;c|p%97;c=getchar()+1)for(++p;c--;)x=x*'[3QQ'+p,y^=x^=y^=c*x;printf("%016llx%016llx",x,y);}

नेस्टेड लूप्स, अर्ध-assed LCGs और वैरिएबल स्वैपिंग। क्या प्यार करने लायक नहीं?

यहाँ के साथ खेलने के लिए एक ungolf'd संस्करण है:

long long x,y,p;

int main(int c){
    // Start with a small number of iterations to
    //   get the state hashes good and mixed because initializing takes space
    // Then, until we reach the end of input (EOF+1 == 0)
    //   and a position that's a multiple of 97
    for (c=9;c|p%97;c=getchar()+1) {

        // For each input c(haracter) ASCII value, iterate down to zero
        for (++p;c--;) {

            // x will act like a LCG with a prime multiple
            //   partially affected by the current input position
            // The string '[3QQ' is the prime number 0x5B335151
            x=x*'[3QQ'+p;

            // Mix the result of x with the decrementing character
            y^=c*x;

            // Swap the x and y buffers
            y^=x^=y;
        }
    }

    // Full 128-bit output
    printf("%016llx%016llx",x,y);
    return 0;
}

यह एक पूरी तरह से स्व-युक्त कार्यक्रम है जो STDIN से पढ़ता है और STDOUT को प्रिंट करता है।

उदाहरण:

> echo -n "Hello world" | ./golfhash
b3faef341f70c5ad6eed4c33e1b55ca7

> echo -n "" | ./golfhash
69c761806803f70154a7f816eb3835fb

> echo -n "a" | ./golfhash
5f0e7e5303cfcc5ecb644cddc90547ed

> echo -n "c" | ./golfhash
e64e173ed4415f7dae81aae0137c47e5

कुछ सरल बेंचमार्क में, यह लगभग 3MB / s टेक्स्ट डेटा को हैश करता है। हैश गति इनपुट डेटा पर ही निर्भर करती है, इसलिए इसे संभवतः ध्यान में रखा जाना चाहिए।



1

PHP 4.1, 66 बाइट्स [ फटा ]

मैं अभी गर्म हो रहा हूं।

मुझे आशा है कि आपको यह सहज ज्ञान मिलेगा।

<?for($l=strlen($b.=$a*1);$i<40;$o.=+$b[+$i]^"$a"/$a,$i++);echo$o;

मैंने इसकी संख्या 99999999999999999999999999999 बताई है
। आउटपुट 2 128 सीमा के भीतर लगता है ।


register_globalsनिर्देश के कारण PHP 4.1 की आवश्यकता है ।

यह स्वचालित रूप से सत्र, POST, GET, REQUEST और कुकीज़ से स्थानीय चर बनाकर काम करता है।

यह कुंजी का उपयोग करता है a। (ईजी: एक्सेस ओवर http://localhost/file.php?a=<number>)।

यदि आप PHP 4.2 और नए के साथ इसका परीक्षण करना चाहते हैं, तो यह प्रयास करें:

<?for($l=strlen($b.=$a=$_REQUEST['a']*1);$i<40;$o.=+$b[+$i]^"$a"/$a,$i++);echo$o;

यह संस्करण केवल POST और GET के साथ काम करता है।


उदाहरण आउटपुट:

0 -> 0000000000000000000000000000000000000000
9 -> 8111111111111111111111111111111111111111
9999 -> 8888111111111111111111111111111111111111
1234567890 -> 0325476981111111111111111111111111111111
99999999999999999999999999999999999999999999999999999999999999999999999999999999 -> 0111191111111111111111111111111111111111

(मैं आपको विश्वास दिलाता हूं कि ऐसे नंबर हैं जो समान हैश का उत्पादन करते हैं)।



1

सी, 134 बाइट्स, क्रैक

यह पूरा सी प्रोग्राम है।

long long i=0,a=0,e=1,v,r;main(){for(;i++<323228500;r=(e?(scanf("%c",&v),e=v>'/'&&v<':',v):(a=(a+1)*7)*(7+r)));printf("0x%llx\n", r);}

यह क्या करता है: विचार बाइट सरणी के रूप में इनपुट लेना है और छद्म यादृच्छिक (लेकिन नियतात्मक) बाइट्स को लगभग 2 2 30 (थोड़ा अधिक) के बराबर लंबाई बनाने के लिए बाइट्स को जोड़ना है । कार्यान्वयन इनपुट बाइट को बाइट द्वारा पढ़ता है और छद्म यादृच्छिक डेटा का उपयोग करना शुरू करता है जब यह पहला वर्ण पाता है जो एक अंक नहीं है।

जैसा कि अंतर्निहित PRNG की अनुमति नहीं है, मैंने इसे स्वयं कार्यान्वित किया।

अपरिभाषित / कार्यान्वयन परिभाषित व्यवहार है जो कोड को कम करता है (अंतिम मूल्य को अहस्ताक्षरित किया जाना चाहिए, और मुझे विभिन्न मूल्यों के लिए विभिन्न प्रकारों का उपयोग करना चाहिए)। और मैं सी। में 128 बिट मानों का उपयोग नहीं कर सका। कम मोटे संस्करण:

long long i = 0, prand = 0, notEndOfInput = 1, in, hash;

main() {
    for (; i++ < 323228500;) {
        if (notEndOfInput) {
            scanf("%c", &in);
            notEndOfInput = in >= '0' && in <= '9';
            hash = in;
        } else {
            prand = (prand + 1)*7;
            hash = prand*(7 + hash);
        }
    }
    printf("0x%llx\n", hash);
}


1

अजगर 2.X - 139 बाइट्स [[ क्रैक ]]

यह अन्य सभी (LOOP, XOR, SHIFT, ADD) के समान है। आओ अपने अंक लुटेरों;) मैं इसे हल करने के बाद एक कठिन बना दूँगा।

M=2**128
def H(I):
 A=[1337,8917,14491,71917];O=M-I%M
 for z in range(73):
  O^=A[z%4]**(9+I%9);O>>=3;O+=9+I**(A[z%4]%A[O%4]);O%=M
 return O

रैपर (बेस -16 में एक तर्क को हेक्साडेसिमल के नाम से भी जाना जाता है):

import sys
if __name__ == '__main__':
 print hex(H(long(sys.argv[1], 16)))[2:][:-1].upper()


1
इसके अलावा, मुझे यकीन नहीं है कि यह प्रविष्टि ओपी के नमूने से मिलती है, क्योंकि मेरी मशीन पर फ़ंक्शन को बड़े इनपुट पर कई सेकंड लगते हैं। उदाहरण के लिए, H(2**(2**10))लगभग 8 या 9 सेकंड लगे, जबकि H(2**(2**12))लगभग 29 सेकंड लगे और H(2**(2**14))दो मिनट से अधिक समय लगा ।
मैथमेटन

आप बिल्कुल सही हैं, मुझे स्पष्ट रूप से बड़े इनपुट के लिए समय का परीक्षण करना चाहिए था। इसके अलावा, मुझे लगता है कि शिफ्ट के जुड़ने के बाद मैं अपना टेस्ट चलाना भूल गया। मूल संस्करण शिफ्ट के बिना था (पोस्टिंग से पहले) और यह मेरे "पहले 100000 पूर्णांक में कोई टक्कर नहीं" टेस्ट पास कर रहा था: /
उलझा हुआ

1

पायथन 2.7 - 161 बाइट्स [[ क्रैक ]]

खैर जब से मैं अपने पहले हैश फ़ंक्शन को पोस्ट करने से पहले एक बेकार संस्करण में बदलने में कामयाब रहा, मुझे लगता है कि मैं एक समान संरचना का दूसरा संस्करण पोस्ट करूंगा। इस बार मैंने इसे तुच्छ टकराव के खिलाफ परीक्षण किया और मैंने गति के लिए संभावित इनपुट परिमाणों का अधिकांश परीक्षण किया।

A=2**128;B=[3,5,7,11,13,17,19]
def H(i):
 o=i/A
 for r in range(9+B[i%7]):
  v=B[i%7];i=(i+o)/2;o=o>>v|o<<128-v;o+=(9+o%6)**B[r%6];o^=i%(B[r%6]*v);o%=A
 return o

आवरण (बाइटकाउंट में नहीं गिना जाता है)

import sys
if __name__ == '__main__':
 arg = long(sys.argv[1].strip(), 16)
 print hex(H(arg))[2:][:-1].upper()

रन उदाहरण (इनपुट हमेशा एक हेक्साडेसिमल संख्या है):

$ python crypt2.py 1
3984F42BC8371703DB8614A78581A167
$ python crypt2.py 10
589F1156882C1EA197597C9BF95B9D78
$ python crypt2.py 100
335920C70837FAF2905657F85CBC6FEA
$ python crypt2.py 1000
B2686CA7CAD9FC323ABF9BD695E8B013
$ python crypt2.py 1000AAAA
8B8959B3DB0906CE440CD44CC62B52DB


अच्छी तरह से किया जिम्मी :)
हैरान

1

रूबी, 90 बाइट्स

def H(s);i=823542;s.each_byte{|x|i=(i*(x+1)+s.length).to_s.reverse.to_i%(2**128)};i;end

एक उच्च यादृच्छिक हैश एल्गोरिथ्म मैं किसी भी वास्तविक हैश को देखे बिना बनाया गया है ... कोई भी विचार अच्छा नहीं है। यह इनपुट के रूप में एक स्ट्रिंग लेता है।

आवरण:

def buildString(i)
  if(i>255)
    buildString(i/256)+(i%256).chr
  else
    i.chr
  end
end 
puts H buildString gets

क्या आप कृपया उस रैपर को प्रदान कर सकते हैं जो प्रश्न की आवश्यकता है?
डेनिस

इनपुट प्रारूप क्या है? मैंने एक संख्या के साथ कोशिश की लेकिन यह कहता है comparison of String with 255 failed (ArgumentError)
jimmy23013

एच एक स्ट्रिंग लेता है, बिल्ड स्ट्रिंग ओपी द्वारा आवश्यक संख्या लेता है और इसे एक स्ट्रिंग में बदल देता है।
मेगाटॉम

मुझे लगता है कि आपको gets.to_iरैपर में एक की जरूरत है ।
jimmy23013


0

मैथेमेटिका, 89 बाइट्स, फटा

Last@CellularAutomaton[(a=Mod)[#^2,256],{#~IntegerDigits~2,0},{#~a~99,128}]~FromDigits~2&

सबसे छोटा नहीं।


3
आप इसे बिना गणित के कैसे चलाते हैं? "एक निशुल्क (बीयर में) संकलक / दुभाषिया होना चाहिए जो कि x86 या x64 प्लेटफ़ॉर्म पर या किसी वेब ब्राउज़र से चलाया जा सकता है।"
मार्टिन एंडर

2
@ मार्टिनबॉटनर wolfram.com/mathematica/trial
लीजनमैमल 978


0

PHP, 79 बाइट्स (फटा हुआ। एक टिप्पणी के साथ):

echo (('.'.str_replace('.',M_E*$i,$i/pi()))*substr(pi(),2,$i%20))+deg2rad($i);

यह php में टाइप-रूपांतरणों के माध्यम से डरावनी चीजों का एक बहुत कुछ करता है, जो कि भविष्यवाणी करना कठिन बनाता है;) (या कम से कम मुझे आशा है कि)। हालांकि, यह सबसे छोटा या सबसे अपठनीय उत्तर नहीं है।

इसे चलाने के लिए आप PHP4 का उपयोग कर सकते हैं और ग्लोबल्स (i? 123) के साथ रजिस्टर कर सकते हैं या कमांडलाइन का उपयोग कर सकते हैं)

php -r "$i = 123.45; echo (('.'.str_replace('.',M_E*$i,$i/pi()))*substr(pi(),2,$i%20))+deg2rad($i);"

5
हैश का आउटपुट मान फ़्लोटिंग-पॉइंट दिखता है। और यह 300000000000000000000000000000000000000001 और 3000000000000000000000000000000000000000000000
vi

0

C # - 393 बाइट्स फटा

using System;class P{static void Main(string[]a){int l=a[0].Length;l=l%8==0?l/8:l/8+1;var b=new byte[l][];for(int i=0;i<l;i++){b[i]=new byte[8];};int j=l-1,k=7;for(int i=0;i<a[0].Length;i++){b[j][k]=Convert.ToByte(""+a[0][i],16);k--;if((i+1)%8==0){j--;k=7;}}var c=0xcbf29ce484222325;for(int i=0;i<l;i++){for(int o=0;o<8;o++){c^=b[i][o];c*=0x100000001b3;}}Console.WriteLine(c.ToString("X"));}}

Ungolfed:

using System;
class P
{
    static void Main(string[]a)
    {
      int l = a[0].Length;
      l = l % 8 == 0 ? l / 8 : l / 8 + 1;
      var b = new byte[l][];
      for (int i = 0; i < l; i++) { b[i] = new byte[8]; };
      int j = l-1, k = 7;
      for (int i = 0; i < a[0].Length; i++)
      {
        b[j][k] = Convert.ToByte(""+a[0][i], 16);
        k--;
        if((i+1) % 8 == 0)
        {
          j--;
          k = 7;
        }
      }
      var c = 0xcbf29ce484222325;
      for (int i = 0; i < l; i++)
      {
        for (int o = 0; o < 8; o++)
        {
          c ^= b[i][o];
          c *= 0x100000001b3;
        }
      }
      Console.WriteLine(c.ToString("X"));
    }
}

मैंने अपने जीवन में कभी भी क्रिप्टोग्राफी या हैशिंग को नहीं छुआ है, इसलिए कोमल बनो :)

यह FNV-1a हैश का एक सरल कार्यान्वयन है, जिसमें इनपुट पर कुछ धुरी होती है। मुझे यकीन है कि ऐसा करने का एक बेहतर तरीका है लेकिन यह सबसे अच्छा मैं कर सकता हूं।

यह लंबे इनपुट पर थोड़ी मेमोरी का उपयोग कर सकता है।


क्रैक किया गया: codegolf.stackexchange.com/a/51277/101 दोषपूर्ण गद्दी के शीर्ष पर, यह एक क्रिप्टोग्राफिक हैश नहीं है, इसे तोड़ने के कई तरीके हैं।
आआआआआआआआ आआआआआ

0

अजगर 2, 115 बाइट्स [ पहले से ही फटा! ]

ठीक है, यहाँ मेरा आखिरी प्रयास है। केवल 115 बाइट्स क्योंकि अंतिम न्यूलाइन की आवश्यकता नहीं है।

h,m,s=1,0,raw_input()
for c in[9+int(s[x:x+197])for x in range(0,len(s),197)]:h+=pow(c,257,99**99+52)
print h%4**64

यह एक पूर्ण कार्यक्रम है जो स्टड पर एक दशमलव पूर्णांक इनपुट करता है और स्टडआउट पर एक दशमलव हैश मान प्रिंट करता है। अतिरिक्त अग्रणी शून्य का परिणाम भिन्न हैश मूल्यों में होगा, इसलिए मैं सिर्फ यह मानूंगा कि इनपुट में कोई भी नहीं है।

यह एक मॉड्यूलर एक्सपेंनेरेशन के माध्यम से इनपुट संख्या के 197-अंक वाले विखंडू को भरकर काम करता है। कुछ भाषाओं के विपरीत, int()फ़ंक्शन हमेशा आधार 10 में चूकता है, इसलिए int('077')77 है, न कि 63।

नमूना आउटपुट:

$ python hash.py <<<"0"
340076608891873865874583117084537586383

$ python hash.py <<<"1"
113151740989667135385395820806955292270

$ python hash.py <<<"2"
306634563913148482696255393435459032089

$ python hash.py <<<"42"
321865481646913829448911631298776772679

$ time python hash.py <<<`python <<<"print 2**(2**19)"`
233526113491758434358093601138224122227

real    0m0.890s   <-- (Close, but fast enough)
user    0m0.860s
sys     0m0.027s

1
यह ब्लॉक के आदेश का उपयोग नहीं किया ... टूट गया
jimmy23013

ओह। में देता हूँ :-(
स्क्वीश ossifrage
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.