मेरे पास मॉड्यूलस और निजी एक्सपोनेंट है। आरएसए निजी कुंजी कैसे बनाएं और एक संदेश पर हस्ताक्षर कैसे करें?

Question

मैं क्रिप्टोग्राफी और पाइक्रिप्टो में नौसिखिया हूं।

मेरे पास मॉड्यूलस n और निजी एक्सपोनेंट d है। क्या मैं कुछ डॉक्स निजी कुंजीn और d के होते हैं पढ़ने के बाद समझ में से।

मैं एक संदेश हस्ताक्षर करने की आवश्यकता है और मैं pycrypto का उपयोग कर कि कैसे करना है पता नहीं कर सकते हैं। RSA.construct() विधि एक ट्यूपल स्वीकार करता है। लेकिन मुझे अतिरिक्त रूप से इस विधि के लिए सार्वजनिक एक्सपोनेंट e प्रदान करना होगा (जो मेरे पास नहीं है)।

तो यहाँ मेरे सवाल है। क्या मुझे किसी संदेश पर हस्ताक्षर करने के लिए e की गणना करना है?

ऐसा लगता है कि मुझे n और d (जो निजी कुंजी का गठन) का उपयोग कर एक संदेश पर हस्ताक्षर करने में सक्षम होना चाहिए। क्या मैं सही हूँ? क्या मैं इसे pycrypto के साथ कर सकता हूं?

अग्रिम धन्यवाद।

Answer 1

असल में सार्वजनिक कुंजी से एन्क्रिप्ट किए गए संदेश को डिक्रिप्ट करने के लिए निजी एक्सपोनेंट होना पर्याप्त है।

भी इसका मतलब है कि आप एक संदेश हस्ताक्षर कर सकते हैं, क्योंकि मूल रूप से हस्ताक्षर करने के बस है * डी * निजी कुंजी है, जो जब * एन * सार्वजनिक कुंजी प्लेन फिर से दे देंगे साथ crypted साथ प्लेन crypting। आम तौर पर आप एक हैश से पहले प्लेन पर पचाने का उपयोग करें और है कि हस्ताक्षर ...

कारण है कि आप एक संदेश uing डीक्रिप्ट नहीं कर सकते केवल n और pyrcypto साथ d है कि यह करता है संदेश डिक्रिप्शन के दौरान एक blinding step, जो involves the public exponent, लेकिन डिक्रिप्शन के लिए वास्तव में इसकी आवश्यकता नहीं है।

लेकिन निजी एपीआई को कुछ कॉल का उपयोग करके इस कदम को छोड़ दिया जा सकता है।

इसलिए इस काम करना चाहिए:

from Crypto.PublicKey import RSA 
from Crypto.Util.number import bytes_to_long, long_to_bytes 

full = RSA.generate(2048) 

# construct key using only n and d 
try: 
    # pycrypto >=2.5, only tested with _slowmath 
    impl = RSA.RSAImplementation(use_fast_math=False) 
    partial = impl.construct((full.n, 0L)) 
    partial.key.d = full.d 
except TypeError: 
    # pycrypto <=2.4.1 
    partial = RSA.construct((full.n, 0L, full.d)) 



pub = full.publickey() 

# create message with padding 
# http://en.wikipedia.org/wiki/RSA_%28algorithm%29#Padding_schemes 
cleartext = ... 

signature = partial.sign(cleartext, None) 

print "validating message: ", pub.verify(cleartext, signature) 


message = pub.encrypt(cleartext, None) 

# bypassing the blinding step on decrypt 
enc_msg=map(bytes_to_long, message) 
dec_msg = map(partial.key._decrypt, enc_msg) 

print "decrypting: " 
for m in dec_msg: 
    print long_to_bytes(m) 

Answer 2

नहीं, आप d से e की गणना नहीं कर सकते।

आरएसए d और e में सममित है: आप सार्वजनिक रूप से और निजी कुंजी की भूमिकाओं को समान रूप से अच्छी तरह से बदल सकते हैं। बेशक, हम एक विशेष रूप से निजी होने का चयन और अन्य प्रकट - लेकिन सैद्धांतिक रूप से वे एक ही बात करते हैं। स्वाभाविक रूप से, चूंकि आप जनता से निजी कुंजी को कम नहीं कर सकते हैं, इसलिए आप सार्वजनिक कुंजी को निजी से भी कम नहीं कर सकते हैं।

बेशक

, आप निजी कुंजी इसका मतलब है कि आप कुंजीयुग्म उत्पन्न, जिसका अर्थ है आप सार्वजनिक कुंजी कहीं है कि है।

Answer 3

आप सार्वजनिक प्रतिपादक नहीं है, तो आप इसे लगता है कि करने में सक्षम हो सकता है। अधिकांश समय यह एक यादृच्छिक प्रधान नहीं बल्कि एक स्थिर मूल्य है। मूल्य 65537 (हेक्स 0x010001, फर्मेट की चौथी संख्या), 3, 5, 7, 13 और 17 (उस क्रम में) का प्रयास करें।

[संपादित करें] सीधे शब्दों में निजी कुंजी के साथ प्रवेश करें और अगर सार्वजनिक कुंजी सही है या नहीं करने के लिए सार्वजनिक कुंजी के साथ की पुष्टि करें।

नोट: अगर यह यादृच्छिक प्रधानमंत्री यह निजी प्रतिपादक के रूप में लगता है के रूप में मुश्किल है, जिसका मतलब है कि आप आरएसए तोड़ने की कोशिश करेंगे - किसी भी प्रमुख आकार> 512 बिट्स की संभावना नहीं है।