क्रिप्टोग्राफिक पहेली: एक क्रिप्टो सेवा प्रदाता में एक WebMoney कुंजी आयात करना

एक विंडोज सिस्टम पर निजी कुंजी आमतौर पर एक विशेष कीस्टोर में संग्रहीत होती है। इन कुंजियों के साथ काम क्रिप्टोग्राफिक प्रदाता (बाद में सीएसपी) के कार्यों को कॉल करके होता है। मानक CSP (Microsoft Base क्रिप्टोग्राफ़िक प्रदाता) का उपयोग करते समय, उपयोगकर्ता कुंजियाँ फ़ोल्डर C: \ Users \ [Vasia] \ AppData \ Roaming \ Microsoft \ Crypto में संग्रहीत की जाती हैं। विशेष उपकरणों का उपयोग करते समय, चाबियाँ डिवाइस की स्मृति में ही संग्रहीत होती हैं।



सुरक्षा में सुधार के लिए, वेबमनी कुंजी (बहुत ही .kwm कि इंटरफ़ेस अनुरोधों के साथ हस्ताक्षर किए गए) को CSP में आयात करने का निर्णय लिया गया। आमतौर पर, जो लोग WM इंटरफेस के अनुरोधों पर हस्ताक्षर करने के लिए कुंजी का उपयोग करते हैं, वे इसे फ़ाइल सिस्टम में एक .kwm फ़ाइल के रूप में या xml प्रतिनिधित्व के रूप में संग्रहीत करते हैं - दोनों विकल्प बहुत सुरक्षित नहीं हैं।



यह इतना आसान नहीं निकला।



अपनी भुगतान सेवा की सुरक्षा बढ़ाते समय आने वाली समस्याओं के बारे में और पढ़ें, कट के तहत पढ़ें।







So. चलिए kwm फाइल फॉर्मेट से शुरू करते हैं। फ़ाइल में एक जटिल प्रारूप है (छोटी चीजें गायब हैं):



1. अखंडता की जाँच के लिए एक हैश।

2. एन्क्रिप्टेड निजी आरएसए-प्रदर्शक (डी)।

एच। एनक्रिप्टेड RSA मॉड्यूल (मॉड्यूलस)।



समस्या नंबर 1: कुंजी फ़ाइल को डिक्रिप्ट करने के बाद, हमें 8 में से केवल 2 मापदंडों की आवश्यकता होती है।



हमारे पास है: डी और मॉडुलस, हमें चाहिए: एक्सपोनेंट, मोडुलस, पी, क्यू, डीपी, डीक्यू, इनवर्सक्यू, डी (उस संरचना पर विवरण के लिए जिसे आपको सीएसपी के लिए आयात करने के लिए कुंजी लाने की आवश्यकता है, MSDN msdn.microsoft.com/en- देखें us / पुस्तकालय / Aa387401 )।



यदि हम ई (ओपन एक्सपोनेंट) जानते थे, तो इन सभी मापदंडों को खोजना मुश्किल नहीं होगा। आमतौर पर E, Fermat में से एक नंबर लेता है: १ the, २५ 6, ६५५३ 4 या ४२ ९ ४ ९ ६7२ ९।



1. हम अपने मापदंडों डी और मापुलस के साथ एक मनमाना संदेश संदेश एन्क्रिप्ट करते हैं:



encrypted = message^D % Modulus









2. घातांक (माना) और मापांक का उपयोग कर डिक्रिप्ट करने की कोशिश करना:



message = encrypted^Exponent % Modulus









यदि डिक्रिप्शन के बाद प्राप्त संदेश मूल के साथ मेल खाता है, तो घातांक को सही ढंग से चुना गया था।



नोट: इसके बाद, ऑपरेटर "^" घातांक है, और ऑपरेटर "%" विभाजन का शेष है ।



समस्या संख्या 2: हम खुले प्रदर्शक को नहीं जानते हैं, और यह काफी बड़ा है।



दुर्भाग्यवश, इनमें से एक भी Fermat संख्या एक खुले प्रतिपादक के रूप में सामने नहीं आई। यह थोड़ा परेशान करने वाला है। इसके अलावा, उम्मीद है कि यह संख्या अभी भी बहुत बड़ी नहीं है - 4 बाइट्स से कम की सभी संख्याओं की कोशिश की गई है (क्रूर बल)। उनमें से कोई भी नहीं आया। यह एक मरा हुआ अंत प्रतीत होता है और कोई इस विचार को भूल सकता है ...



यह समाप्त हो सकता था। एक खुला प्रदर्शक प्राप्त करना संभव नहीं था: वर्षों के कई दसियों (या यहां तक ​​कि सैकड़ों) के लिए इसे बाध्य करें।



हालांकि, कहानी जारी है। माइकल जे। वीनर जैसा एक व्यक्ति रहता था, जो एक छोटे से मूल्य के मामले में आरएसए प्रणाली को हैक करने का एक तरीका लेकर आया था। हमारे पास थोड़ा विपरीत है: खुले घातांक का छोटा मूल्य, जिसे हम नहीं जानते हैं।



दरअसल, आरएसए पर वीनर के हमले का उपयोग करते हुए, आप किसी भी कुंजी के खुले घातांक को तुरंत पा सकते हैं (यदि यह बहुत लंबा नहीं है)।



यहाँ क्या हुआ:



मूल D और मापांक मान (kwm फ़ाइल से प्राप्त):



D: 19715AB67A97257C5C80C8CD8F97448199F6F3FF8A3724DEA911C32CB5E64395D3175D6112A51DC14911FBA4E8FD107C1C65BE062A3491B1131168DF423408E2593



Modulus: 789BE5F2D0C90430EAEFC640B752FE707D75EB12C9C76F776C981014C1825C48989F15F5F53AFBF9B9C11D5C9AF184CC4F3938A48045414F814636C1275321F3AB9









RSA पर वीनर के हमले का उपयोग कर एक खुला प्रदर्शक को तुरंत बहाल किया गया था:



Exponent: 21EA463DEB0B









यह एक छोटी सी बात की तरह लग रहा था: प्राप्त मापदंडों को निजी कुंजी BLOB की संरचना में लाएं और किसी भी क्रिप्टो प्रदाता में आयात करें। लेकिन इतना सरल नहीं ...



समस्या 3: एक सार्वजनिक घातांक 4 बाइट्स से अधिक लंबा होता है, और निजी कुंजी BLOBs प्रारूप केवल 4 बाइट्स तक लम्बी (4 बाइट्स सम्मिलित) की अनुमति देता है।



क्या तकलीफ है! ऐसा लगता है कि समस्या का कोई हल नहीं है और आप इसके बारे में (दूसरी बार) भूल सकते हैं।



हालांकि ... आखिरकार, हमारे पास क्रिप्टोसिस्टम के पैरामीटर हैं (विशेष रूप से, प्रिम्स पी और क्यू)। इसलिए, आप यह कर सकते हैं:



1. हम मूल पैरामीटर P और Q लेते हैं।



2. उपयुक्त सार्वजनिक प्रतिपादक घातांक 2 चुनें (4 से अधिक बाइट्स नहीं)। फरमेट नंबर 65537 पर लें।



3. बंद घातांक D2 की गणना करें (संख्या ई मोडुलो (P-1) के विपरीत गुणा) *

(क्यू 1))। D2 kwm फ़ाइल से मूल D से अलग होगा।



4. मापदंडों की गणना करें: DP2, DQ2, InverseQ2। चीनी शेष प्रमेय का उपयोग करके, उन्हें जल्दी से एक हस्ताक्षर प्राप्त करने की आवश्यकता है ।



5. सबसे महत्वपूर्ण बात! हम मूल डी (जो मूल कुंजी kwm में है) और हमारे संशोधित क्रिप्टोकरेंसी के डी 2 (यानी डी 2 - डी) के बीच अंतर की गणना करते हैं।



अब संशोधित कुंजी को CSP स्टोरेज में (उदाहरण के लिए, eToken PRO) निजी RSA कुंजी के रूप में सहेजा जा सकता है, और विचलन को PKCS # 11 ऑब्जेक्ट के रूप में सहेजा जा सकता है। Microsoft CSP का उपयोग करते समय, विचलन उपयोगकर्ता के भंडार में संग्रहीत किया जा सकता है।



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



यहाँ C # में एक उदाहरण दिया गया है जो CSP में संशोधित कुंजी आयात करने के लिए जिम्मेदार है:

public void ImportPrivateKey( byte [] modulusBytes, byte [] privateExponentBytes)

{

//



var modulus = new BigInteger(modulusBytes);

var d = new BigInteger(privateExponentBytes);



var p = Wiener.Calculate(d, modulus); // RSA P ( )

var q = modulus/p;

var f = (p - 1)*(q - 1); //

var e = new BigInteger( new byte [] {1, 0, 1}); // 65537



var d2 = e.modInverse(f); // d2 --



var dp2 = d2%(p - 1);

var dq2 = d2%(q - 1);

var iq = q.modInverse(p);



var rsaParameters = new RSAParameters

{

D = toByteArray(d2),

DP = toByteArray(dp2),

DQ = toByteArray(dq2),

Exponent = toByteArray(e),

InverseQ = toByteArray(iq),

Modulus = toByteArray(modulus),

P = toByteArray(p),

Q = toByteArray(q)

};



BigInteger deviation;

byte flag; // d > d2,



if (d > d2)

{

deviation = d - d2;

flag = 0;

}

else

{

deviation = d2 - d;

flag = 1;

}



// CSP ( eToken, CSP "eToken Base Cryptographic Provider")

var cspParameters = new CspParameters

{

Flags =

CspProviderFlags.UseNonExportableKey | CspProviderFlags.UseUserProtectedKey,

KeyNumber = ( int )KeyNumber.Exchange,

KeyContainerName = _containerName

};



//

RSACryptoServiceProvider.UseMachineKeyStore = false ;



using ( var cryptoServiceProvider = new RSACryptoServiceProvider(cspParameters))

{

//

cryptoServiceProvider.ImportParameters(rsaParameters);

}



// deviation ( )

Storage.SaveDataInStorage(_containerName, toByteArray(deviation));

Storage.SaveDataInStorage(_containerName + "_flag" , new [] {flag});

}



* This source code was highlighted with Source Code Highlighter .

अब संदेश संदेश का हस्ताक्षर कैसे प्राप्त करें?



मूल हस्ताक्षर निम्नानुसार प्राप्त किया जाता है:



signature = hash ^ D % Modulus









अब हमारे पास डी नहीं है, लेकिन डी 2 और विचलन हैं, और डी 2 + विचलन = डी। डी 2 तक कोई सीधी पहुंच नहीं है, क्योंकि यह CSP द्वारा प्रबंधित किया जाता है: आप केवल मानक कार्यों को कॉल करके इस D2 के लिए एक हस्ताक्षर प्राप्त कर सकते हैं। बीजगणित याद करें:



a^(b+c) = a^b * a^c









यह कानून मॉड्यूलर बीजगणित पर भी लागू होता है। तो, हमारा मूल हस्ताक्षर (डी के ज्ञान के बिना) इस तरह है:



part1 = hash ^ D2 % Modulus



part2 = hash ^ deviation % Modulus



signature = part1 * part2 % Modulus









लाभ! अब हमारी कुंजी CSP द्वारा प्रबंधित की गई है (हार्डवेयर डिवाइस के मामले में, यह बहुत विश्वसनीय है)। थोड़ा उपद्रव - पूरे "फिट नहीं हुआ", विचलन के रूप में अभी भी "टुकड़ा" था। लेकिन यह विचलन एक रहस्य नहीं है, डी 2 के ज्ञान के बिना यह व्यावहारिक रूप से मूल डी के बारे में कोई सुराग नहीं लाता है।



लेकिन आराम करने के लिए जल्दी मत करो।



समस्या संख्या 4: हस्ताक्षर किए जा रहे डेटा की संरचना आम तौर पर स्वीकृत एक से अलग है।



यदि हम Win CAPI द्वारा प्राप्त हस्ताक्षर को डिक्रिप्ट करते हैं (आप इसे सार्वजनिक घातांक और मॉड्यूल के साथ डिक्रिप्ट कर सकते हैं), तो हम इस संरचना की तरह कुछ देखेंगे:



1FFFFFFFFFFFFFFFFFFFFFFFF003031300D0609608648016503040201050004209F64A747E1B97F131FABB6B447296C9B6F0201E79FB3C5356E6C77E89B6A806









शुरुआत में मानक हेडर है, और अंत में हस्ताक्षरित संदेश के हैश का 32 बाइट्स (SHA-256 के लिए उद्धृत) है।



WebMoney Signer के हस्ताक्षर अलग हैं: पहले बाइट्स यादृच्छिक संख्याओं से भरे होते हैं, फिर MD4 हैश के 16 बाइट्स, फिर 2 बाइट्स के हेडर।



समस्या यह है कि सीएसपी मॉड्यूलर निजी-कुंजी प्रतिपादक के प्रत्यक्ष कार्य का समर्थन नहीं करता है (यदि यह संभव था, तो यह काम किया होगा)। केवल अनुमति है:



1. संदेश पर हस्ताक्षर करें। स्पष्ट रूप से हमें किसी भी तरह से सूट नहीं करता है, क्योंकि वेबमनी हमारे हस्ताक्षर को मान्यता नहीं देगी - संरचना अलग है।



2. संदेश एन्क्रिप्ट करें। फिर से - एक प्रकार का एन्क्रिप्शन (मूल संदेश संशोधित, यादृच्छिक संख्याओं द्वारा पूरक) - यह हमारे प्रारूप से सहमत नहीं है।



फिर से गतिरोध। हालांकि ... और क्या होगा अगर हम अपने सीएसपी को एक असली हैश नहीं, बल्कि एक छद्म-हैश में डाल दें, जिसमें हम उस डेटा को डाल देंगे जो हमें चाहिए? हैश फ़ंक्शन प्रतिवर्ती नहीं है, इसलिए यह जांचने का कोई तरीका नहीं है कि हैश असली है या नहीं।



ऐसा करने के लिए, हमें एक एल्गोरिथ्म चुनने की ज़रूरत है जिसमें काफी लंबा हैश हो: ताकि हमारा 16-बाइट एमडी 4 फिट बैठता है, और एक 2-बाइट हेडर, और यह सुरक्षा के लिए, यादृच्छिक संख्याओं के साथ डेटा को पूरक करने के लिए अच्छा होगा।



SHA-512 बहुत बड़ा निकला, लेकिन SHA-256 सही था।



यहाँ हस्ताक्षर बनाने के लिए कार्य है:

public string Sign( string value )

{

if ( string .IsNullOrEmpty( value ))

throw new ArgumentNullException( "value" );



var toSign = new byte [32]; // - SHA256



var random = new byte [14]; //

var hash = getHash( value ); // MD4

var prefix = new byte [] {0, 56}; // WebMoney



var rngCryptoServiceProvider = new RNGCryptoServiceProvider();

rngCryptoServiceProvider.GetBytes(random);



Buffer.BlockCopy(random, 0, toSign, 0, random.Length);

Buffer.BlockCopy(hash, 0, toSign, random.Length, hash.Length);

Buffer.BlockCopy(prefix, 0, toSign, random.Length + hash.Length, prefix.Length);



var cspParameters = new CspParameters

{

Flags =

CspProviderFlags.UseNonExportableKey | CspProviderFlags.UseUserProtectedKey,

KeyNumber = ( int ) KeyNumber.Exchange,

KeyContainerName = _containerName

};



byte [] signature1;

BigInteger modulus;



using ( var rsaCryptoServiceProvider = new RSACryptoServiceProvider(528, cspParameters))

{

signature1 = rsaCryptoServiceProvider.SignHash(toSign, CryptoConfig.MapNameToOID( "SHA256" ));

modulus = new BigInteger(rsaCryptoServiceProvider.ExportParameters( false ).Modulus);

}



var deviation = new BigInteger(Storage.LoadDataFromStorage(_containerName));



// SHA-256

var header = new byte []

{

0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,

0x30,

0x31, 0x30, 0x0D, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01,

0x05,

0x00, 0x04, 0x20

};



var toEncrypt = new byte [65];



Buffer.BlockCopy(header, 0, toEncrypt, 0, header.Length);

Buffer.BlockCopy(random, 0, toEncrypt, header.Length, random.Length);

Buffer.BlockCopy(hash, 0, toEncrypt, header.Length + random.Length, hash.Length);

Buffer.BlockCopy(prefix, 0, toEncrypt, header.Length + random.Length + hash.Length, prefix.Length);



byte flag = Storage.LoadDataFromStorage(_containerName + "_flag" )[0];



var part1 = new BigInteger(signature1);

BigInteger part2;



if (1 == flag)

{

// -- --

part2 = new BigInteger(toEncrypt).modInverse(modulus).modPow(deviation, modulus);

}

else

part2 = new BigInteger(toEncrypt).modPow(deviation, modulus);



var signature = toByteArray((part1*part2)%modulus);



// little-endian

Array.Reverse(signature);



//

var uResult = new ushort [KeyBytesLength/2];



Buffer.BlockCopy(signature, 0, uResult, 0, signature.Length);



var stringBuilder = new StringBuilder ();



for ( int pos = 0; pos < uResult.Length; pos++)

stringBuilder.Append( string .Format(CultureInfo.InvariantCulture, "{0:x4}" , uResult[pos]));



return stringBuilder.ToString();

}



* This source code was highlighted with Source Code Highlighter .

अब सब कुछ एक घड़ी की तरह काम करता है: कुंजी विंडोज सिस्टम पर चलने वाले किसी भी क्रिप्टोग्राफिक डिवाइस (उर्फ ईटोकन, रुबोटेन - जो भी हो) के साथ संगत है, हस्ताक्षर वैध है।



पुनश्च

लेखक से।



शायद किसी के लिए यह समझना मुश्किल होगा कि मैंने "आसान तरीका" क्यों नहीं चुना। मैं समझाता हूं: मुझे क्रिप्टोग्राफिक पहेलियाँ पसंद हैं। कोई व्यक्ति पहेली हल करता है, लेकिन मुझे इस रूप में पहेलियाँ अधिक पसंद हैं।