क्या एन्क्रिप्शन का एक तरीका है जो किसी भी लम्बाई की स्ट्रिंग ले सकता है और उप-10-चरित्र हैश का उत्पादन कर सकता है? मैं यथोचित रूप से नहीं बल्कि मैसेज कंटेंट के आधार पर यथोचित यूनिक आईडी का उत्पादन करना चाहता हूं।
मैं पूर्णांक मानों को संदेश देने के लिए विवश रह सकता हूं, हालांकि, अगर मनमाने ढंग से लंबाई के तार असंभव हैं। हालाँकि, हैश उस स्थिति में लगातार दो पूर्णांकों के समान नहीं होना चाहिए।
जवाबों:
आप किसी भी उपलब्ध हैश एल्गोरिथ्म (उदाहरण के लिए SHA-1) का उपयोग कर सकते हैं, जो आपको आपकी आवश्यकता के मुकाबले थोड़ा अधिक समय देगा। बस वांछित लंबाई के परिणाम को छोटा करें, जो काफी अच्छा हो सकता है।
उदाहरण के लिए, पायथन में:
>>> import hashlib
>>> hash = hashlib.sha1("my message".encode("UTF-8")).hexdigest()
>>> hash
'104ab42f1193c336aa2cf08a2c946d5c6fd0fcdb'
>>> hash[:10]
'104ab42f11'hash(a)साथ टकराता है hash(b)तो base64(hash(a))भी टकराता है base64(hash(b))।
sha1टकराता है लेकिन यह एक और कहानी है)। यदि आपके पास 10 वर्ण हैश है तो आप उच्च एन्ट्रापी प्राप्त करते हैं यदि यह base64बनाम base16(या हेक्स) के साथ एन्कोडेड है । कितना ऊंचा है? आपके साथ base16प्रति चरित्र में 4 बिट्स की जानकारी मिलती है, base64इस आंकड़े के साथ 6 बिट्स / चार है। टोटल ए 10 चार "हेक्स" हैश में एंट्रॉपी के 40 बिट्स होंगे जबकि बेस 64 60बिट्स। इसलिए यह थोड़ा अधिक प्रतिरोधी है, अगर मैं सुपर स्पष्ट नहीं था तो क्षमा करें।
यदि आपको किसी ऐसे एल्गोरिथ्म की आवश्यकता नहीं है जो जानबूझकर संशोधन के खिलाफ मजबूत हो, तो मैंने एडलर 32 नामक एक एल्गोरिथ्म पाया है जो बहुत कम (~ 8 वर्ण) परिणाम पैदा करता है। इसे आज़माने के लिए इसे ड्रॉपडाउन में से चुनें:
आपको एक पाचन के साथ आने वाली सामग्री को हैश करने की आवश्यकता है। कई हैश उपलब्ध हैं, लेकिन 10-वर्ण परिणाम सेट के लिए बहुत छोटा है। जिस तरह से, लोगों ने सीआरसी -32 का उपयोग किया, जो 33-बिट हैश (मूल रूप से 4 अक्षर प्लस एक बिट) का उत्पादन करता है। CRC-64 भी है जो 65-बिट हैश का उत्पादन करता है। MD5, जो 128-बिट हैश (16 बाइट्स / वर्ण) का उत्पादन करता है क्रिप्टोग्राफ़िक उद्देश्यों के लिए टूटा हुआ माना जाता है क्योंकि दो संदेश मिल सकते हैं जिनमें एक ही हैश है। यह कहे बिना जाना चाहिए कि किसी भी समय आप एक 16-बाइट को पचाने के लिए एक मनमाना लंबाई संदेश से बाहर निकलते हैं जिसे आप डुप्लिकेट के साथ समाप्त करने जा रहे हैं। पाचन जितना छोटा होगा, टकरावों का खतरा उतना ही अधिक होगा।
हालांकि, आपकी चिंता यह है कि हैश लगातार दो संदेशों (चाहे पूर्णांक या नहीं) सभी हैश के साथ समान होना चाहिए। यहां तक कि मूल संदेश में एक भी परिवर्तन थोड़ा बहुत अलग परिणामी पाचन का उत्पादन करना चाहिए।
इसलिए, CRC-64 (और आधार -64 'परिणाम) जैसी किसी चीज़ का उपयोग करके आपको उस पड़ोस में प्राप्त करना चाहिए जिसे आप खोज रहे हैं।
बस एक जवाब का सारांश है जो मेरे लिए उपयोगी था (आधार -64 एन्कोडिंग का उपयोग करने के बारे में @ erasmospunk की टिप्पणी को देखते हुए)। मेरा लक्ष्य एक छोटी स्ट्रिंग थी जो ज्यादातर अनोखी थी ...
मैं कोई विशेषज्ञ नहीं हूं, इसलिए कृपया इसे ठीक करें अगर इसमें कोई चमकता हुआ त्रुटि है (स्वीकार किए गए उत्तर की तरह फिर से पायथन में):
import base64
import hashlib
import uuid
unique_id = uuid.uuid4()
# unique_id = UUID('8da617a7-0bd6-4cce-ae49-5d31f2a5a35f')
hash = hashlib.sha1(str(unique_id).encode("UTF-8"))
# hash.hexdigest() = '882efb0f24a03938e5898aa6b69df2038a2c3f0e'
result = base64.b64encode(hash.digest())
# result = b'iC77DySgOTjliYqmtp3yA4osPw4='resultयहाँ सिर्फ हेक्स वर्णों से अधिक उपयोग कर रहा है (यदि आप का इस्तेमाल किया है कि तुम क्या मिल चाहते हैं hash.hexdigest()) तो यह संभावना कम है एक टक्कर (है कि, एक हेक्स पचाने से काटना सुरक्षित होना चाहिए) है।
नोट: UUID4 (यादृच्छिक) का उपयोग करना। अन्य प्रकारों के लिए http://en.wikipedia.org/wiki/Universally_unique_identifier देखें ।
आप एक मौजूदा हैश एल्गोरिथ्म का उपयोग कर सकते हैं जो एमडी 5 (128 बिट्स) या एसएचए 1 (160) की तरह कुछ छोटा पैदा करता है। फिर आप अन्य वर्गों के साथ पाचन के XORing वर्गों द्वारा इसे और छोटा कर सकते हैं। यह टकराव की संभावना को बढ़ाएगा, लेकिन उतना ही बुरा नहीं होगा जितना कि पाचन को कमजोर कर देगा।
इसके अलावा, आप इसे और अधिक विशिष्ट बनाने के लिए परिणाम के हिस्से के रूप में मूल डेटा की लंबाई शामिल कर सकते हैं। उदाहरण के लिए, MD5 की पहली छमाही को दूसरी छमाही के साथ पचाने के परिणामस्वरूप 64 बिट्स हो जाएंगे। डेटा की लंबाई के लिए 32 बिट्स जोड़ें (या यदि आपको पता है कि लंबाई हमेशा कम बिट्स में फिट होगी)। इसका परिणाम 96-बिट (12-बाइट) के रूप में होगा, जिसके परिणामस्वरूप आप 24-वर्ण हेक्स स्ट्रिंग में बदल सकते हैं। वैकल्पिक रूप से, आप इसे छोटा करने के लिए बेस 64 एन्कोडिंग का उपयोग कर सकते हैं।
यदि आपको आवश्यकता "sub-10-character hash"
हो तो आप फ्लेचर -32 एल्गोरिथ्म का उपयोग कर सकते हैं जो 8 वर्ण हैश (32 बिट्स), सीआरसी -32 या एडलर -32 का उत्पादन करता है ।
CRC-32 20% - 100% के कारक Adler32 से धीमा है।
फ्लेचर -32 एडलर -32 की तुलना में थोड़ा अधिक विश्वसनीय है। एडलर चेकसम की तुलना में इसकी कम कम्प्यूटेशनल लागत है: फ्लेचर बनाम एडलर तुलना ।
कुछ फ्लेचर कार्यान्वयन के साथ एक नमूना कार्यक्रम नीचे दिया गया है:
#include <stdio.h>
#include <string.h>
#include <stdint.h> // for uint32_t
uint32_t fletcher32_1(const uint16_t *data, size_t len)
{
uint32_t c0, c1;
unsigned int i;
for (c0 = c1 = 0; len >= 360; len -= 360) {
for (i = 0; i < 360; ++i) {
c0 = c0 + *data++;
c1 = c1 + c0;
}
c0 = c0 % 65535;
c1 = c1 % 65535;
}
for (i = 0; i < len; ++i) {
c0 = c0 + *data++;
c1 = c1 + c0;
}
c0 = c0 % 65535;
c1 = c1 % 65535;
return (c1 << 16 | c0);
}
uint32_t fletcher32_2(const uint16_t *data, size_t l)
{
uint32_t sum1 = 0xffff, sum2 = 0xffff;
while (l) {
unsigned tlen = l > 359 ? 359 : l;
l -= tlen;
do {
sum2 += sum1 += *data++;
} while (--tlen);
sum1 = (sum1 & 0xffff) + (sum1 >> 16);
sum2 = (sum2 & 0xffff) + (sum2 >> 16);
}
/* Second reduction step to reduce sums to 16 bits */
sum1 = (sum1 & 0xffff) + (sum1 >> 16);
sum2 = (sum2 & 0xffff) + (sum2 >> 16);
return (sum2 << 16) | sum1;
}
int main()
{
char *str1 = "abcde";
char *str2 = "abcdef";
size_t len1 = (strlen(str1)+1) / 2; // '\0' will be used for padding
size_t len2 = (strlen(str2)+1) / 2; //
uint32_t f1 = fletcher32_1(str1, len1);
uint32_t f2 = fletcher32_2(str1, len1);
printf("%u %X \n", f1,f1);
printf("%u %X \n\n", f2,f2);
f1 = fletcher32_1(str2, len2);
f2 = fletcher32_2(str2, len2);
printf("%u %X \n",f1,f1);
printf("%u %X \n",f2,f2);
return 0;
}आउटपुट:
4031760169 F04FC729
4031760169 F04FC729
1448095018 56502D2A
1448095018 56502D2A
टेस्ट वैक्टर के साथ सहमत हैं :
"abcde" -> 4031760169 (0xF04FC729)
"abcdef" -> 1448095018 (0x56502D2A)
एडलर -32 में कुछ सौ बाइट के साथ छोटे संदेशों के लिए कमजोरी है, क्योंकि इन संदेशों के चेकसम में 32 उपलब्ध बिट्स की खराब कवरेज है। इसे देखो:
एडलर 32 एल्गोरिदम तुलनात्मक चेकसमों के साथ प्रतिस्पर्धा करने के लिए पर्याप्त जटिल नहीं है ।
आप पायथन के लिए हैशलीब लाइब्रेरी का उपयोग कर सकते हैं । Shake_128 और shake_256 एल्गोरिदम चर लंबाई हैश प्रदान करते हैं। यहाँ कुछ काम कोड (Python3) है:
import hashlib
>>> my_string = 'hello shake'
>>> hashlib.shake_256(my_string.encode()).hexdigest(5)
'34177f6a0a'ध्यान दें कि एक लंबाई पैरामीटर x (उदाहरण में 5) फ़ंक्शन की लंबाई 2x का हैश मान है ।
मुझे हाल ही में एक साधारण स्ट्रिंग कमी फ़ंक्शन की तर्ज पर कुछ की आवश्यकता थी। मूल रूप से, कोड कुछ इस तरह दिखता था (C / C ++ कोड आगे):
size_t ReduceString(char *Dest, size_t DestSize, const char *Src, size_t SrcSize, bool Normalize)
{
size_t x, x2 = 0, z = 0;
memset(Dest, 0, DestSize);
for (x = 0; x < SrcSize; x++)
{
Dest[x2] = (char)(((unsigned int)(unsigned char)Dest[x2]) * 37 + ((unsigned int)(unsigned char)Src[x]));
x2++;
if (x2 == DestSize - 1)
{
x2 = 0;
z++;
}
}
// Normalize the alphabet if it looped.
if (z && Normalize)
{
unsigned char TempChr;
y = (z > 1 ? DestSize - 1 : x2);
for (x = 1; x < y; x++)
{
TempChr = ((unsigned char)Dest[x]) & 0x3F;
if (TempChr < 10) TempChr += '0';
else if (TempChr < 36) TempChr = TempChr - 10 + 'A';
else if (TempChr < 62) TempChr = TempChr - 36 + 'a';
else if (TempChr == 62) TempChr = '_';
else TempChr = '-';
Dest[x] = (char)TempChr;
}
}
return (SrcSize < DestSize ? SrcSize : DestSize);
}यह संभवतः वांछित होने की तुलना में अधिक टकराव है, लेकिन यह क्रिप्टोग्राफिक हैश फ़ंक्शन के रूप में उपयोग करने के लिए अभिप्रेत नहीं है। यदि आप बहुत से टकराव प्राप्त करते हैं, तो आप विभिन्न गुणक (यानी 37 को दूसरे अभाज्य संख्या में बदल सकते हैं) आज़मा सकते हैं। इस स्निपेट की एक दिलचस्प विशेषता यह है कि जब Src गंतव्य से छोटा होता है, तो गंतव्य इनपुट स्ट्रिंग के साथ समाप्त होता है (-* * 37 + मान = मान)। यदि आप प्रक्रिया के अंत में कुछ "पठनीय" चाहते हैं, तो सामान्यीकरण बढ़ती टकराव की कीमत पर परिवर्तित बाइट्स को समायोजित करेगा।
स्रोत:
https://github.com/cubiclesoft/cross-platform-cpp/blob/master/sync/sync_util.cpp
DestSize? यदि आप किसी आउटपुट से दिए गए टकराव प्रतिरोध को इंट से अधिक चाहते हैं, तो आप SHA का उपयोग करेंगे।