लिटिल एंडियन डेटा और शा 256

Question

मुझे डेटा के sha256 हैंश उत्पन्न करना है जो कि छोटे एंडियन रूप में है। शिया 256 एल्गोरिदम का उपयोग करने से पहले, मुझे यह जानना है कि मुझे इसे पहले बड़े एंडियन में परिवर्तित करना है या नहीं। या यदि, एल्गोरिदम "एंडियन-अज्ञेयवादी" है।

संपादित करें: क्षमा करें, मुझे लगता है कि मैं स्पष्ट नहीं था। मैं जो जानना चाहता हूं वह निम्न है: sha256 एल्गोरिदम को कुछ बिट्स के साथ एक संदेश के अंत तक पैड करना आवश्यक है। पहला कदम संदेश के अंत में 1 जोड़ना है। फिर, अंत तक शून्य के साथ पैड करने के लिए। अंत में, आपको बिट्स में संदेश की लंबाई जोड़नी होगी। मैं क्या जानना चाहता हूं कि यह पैडिंग थोड़ा एंडियन में किया जा सकता है। उदाहरण के लिए, 640 बिट संदेश के लिए, मैं अंतिम शब्द 0x280 (बड़े एंडियन में), या 0x8002000 (थोड़ा एंडियन में) लिख सकता था। क्या यह पैडिंग थोड़ा एंडियन में किया जा सकता है?

Answer 1

SHA-256 कार्यान्वयन स्वयं को पैडिंग का ख्याल रखना चाहिए - आपको तब तक इसका सामना नहीं करना चाहिए जब तक कि आप अपना खुद का विशेष SHA-256 कोड लागू नहीं कर लेते। यदि आप हैं, तो ध्यान दें कि "प्री-प्रोसेसिंग चरण" में निर्दिष्ट पैडिंग नियम कहते हैं कि लंबाई 64-बिट बड़े-एंडियन पूर्णांक है। देखें SHA-2 - Wikipedia

यह भी समझना मुश्किल है कि "एंडियन-अज्ञेयवादी" का अर्थ क्या होगा, लेकिन हैश एल्गोरिदम के लिए सभी बिट्स, बाइट्स और शब्दों का क्रम बहुत मायने रखता है, इसलिए मुझे यकीन है कि उस शब्द का उपयोग नहीं करेगा ।

Answer 2

SHA256 एंडियन-अज्ञेयवादी है यदि आप चाहते हैं कि एक अच्छा हैश है। लेकिन अगर आप SHA256 लिख रहे हैं और एक ही कार्यान्वयन के साथ एक ही परिणाम चाहते हैं तो आपको छोटे एंडियन हार्डवेयर पर गेम खेलना होगा। SHA256 अंकगणितीय जोड़ (मॉड 2 * 32) को जोड़ती है और बूलियन ऑपरेशन आंतरिक रूप से एंडियन-अज्ञेयवादी नहीं है।

Answer 3

मुझे sha 256 के साथ-साथ शा 512 के बारे में उत्तर दें। संक्षेप में: एल्गोरिदम स्वयं एंडियन अज्ञेयवादी है। एंडियन संवेदनशील भाग तब होते हैं जब डेटा बाइट बफर से एल्गोरिदम कार्यशील चर में आयात किया जाता है और जब इसे पाचन परिणाम पर वापस निर्यात किया जाता है - एक बाइट बफर भी। अगर आयात/निर्यात में कास्टिंग शामिल है, तो एंडियन मामलों।

कहां कास्टिंग हो सकता है: शा 512 में 128 बाइट्स का एक कार्य बफर है। मेरी कोड में इस तरह अपने परिभाषित:

union 
    { 
     U64 w [80]; (see U64 example below) 
     byte buffer [128]; 
    }; 

इनपुट डेटा इस बाइट बफर में कॉपी किया जाता है और फिर काम डब्ल्यू पर किया जाता है इसका मतलब यह है डेटा कुछ 64 बिट प्रकार के casted था। इस डेटा को स्वैप करना होगा। मेरे मामले में यह छोटी एंडियन मशीनों के लिए बदल गया।

एक बेहतर तरीका एक मैक्रो तैयार करने के लिए होगा जो प्रत्येक बाइट लेता है और इसे u64 प्रकार में सही जगह पर रखता है।

जब एल्गोरिदम किया जाता है तो पाचन परिणाम कुछ बाइट बफर में काम करने वाले चर से आउटपुट होता है, अगर यह memcpy द्वारा किया जाता है तो इसे भी बदलना होगा।

शाही 512 को लागू करते समय एक और कास्टिंग हो सकता है - जिसे 32 बिट मशीनों पर 64 बिट मशीनों के लिए डिज़ाइन किया गया है।इस प्रकार,

typedef struct { 
     uint high; 
     uint low; 
    } U64; 

मान लें मैं भी थोड़ा endian के लिए इसे परिभाषित:

typedef struct { 
     uint low; 
     uint high; 
    } U64; 

और फिर कश्मीर एल्गोरिथ्म init इस तरह से किया जाता है मेरे मामले में मैं एक 64 बिट प्रकार है कि परिभाषित किया गया है है :

static const SHA_U64 k[80] = 
    { 
     {0xD728AE22, 0x428A2F98}, {0x23EF65CD, 0x71374491}, ... 
     ... 
     ... 
    } 

लेकिन मुझे किसी भी मशीन में समान होने के लिए [0] के तर्क मूल्य की आवश्यकता है। तो इस उदाहरण में मुझे उच्च और निम्न मानों के साथ एक और के सरणी की आवश्यकता होगी।

डेटा पैरामीटर पैरामीटर में संग्रहीत करने के बाद किसी भी बिटवाई मैनिपुलेशन के परिणामस्वरूप बड़ी/छोटी एंडियन मशीनों पर एक ही परिणाम होगा।

किसी भी कास्टिंग से बचने के लिए अच्छी विधि होगी: मैक्रो का उपयोग करके इनपुट बफर से इनपुट बफर में बाइट आयात करें। स्मृति मैपिंग के बारे में सोचने के बिना तार्किक मूल्यों के साथ काम करें। एक मैक्रो के साथ परिणाम पचाने के लिए निर्यात आउटपुट।

एक बाइट बफर से 32 बिट लेने int32 करने के लिए मैक्रो (बीई = बड़ा endian):

#define GET_BE_BYTES_FROM32(a) 
    ((((NQ_UINT32) (a)[0]) << 24) | 
    (((NQ_UINT32) (a)[1]) << 16) | 
    (((NQ_UINT32) (a)[2]) << 8) | 
    ((NQ_UINT32) (a)[3])) 

    #define GET_LE_BYTES_FROM32(a) 
    ((((NQ_UINT32) (a)[3]) << 24) | 
    (((NQ_UINT32) (a)[2]) << 16) | 
    (((NQ_UINT32) (a)[1]) << 8) | 
    ((NQ_UINT32) (a)[0]))