Public Key से Ethereum Address जनरेट करें
एक Ethereum address, public key के keccak256 के अंतिम 20 bytes होते हैं। इसमें इस्तेमाल होने वाला public key एल्गोरिथ्म secp256k1 है, जिसका उपयोग Bitcoin में भी किया जाता है।
चूँकि यह एक elliptic curve एल्गोरिथ्म है, public key एक (x, y) पेयर (pair) होता है जो elliptic curve पर एक बिंदु (point) को दर्शाता है।
Elliptic Curve Public Key जनरेट करें
Public key, x और y का concatenation (संयोजन) होता है, और हम इसी का hash निकालते हैं।
इसके लिए कोड नीचे दिया गया है।
from ecpy.curves import Curve
from ecpy.keys import ECPublicKey, ECPrivateKey
from sha3 import keccak_256
private_key = 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
cv = Curve.get_curve('secp256k1')
pv_key = ECPrivateKey(private_key, cv)
pu_key = pv_key.get_public_key()
# equivalent alternative for illustration:
# concat_x_y = bytes.fromhex(hex(pu_key.W.x)[2:] + hex(pu_key.W.y)[2:])
concat_x_y = pu_key.W.x.to_bytes(32, byteorder='big') + pu_key.W.y.to_bytes(32, byteorder='big')
eth_addr = '0x' + keccak_256(concat_x_y).digest()[-20:].hex()
print('private key: ', hex(private_key))
print('eth_address: ', eth_addr)
ecpy लाइब्रेरी यहाँ उपलब्ध है: https://github.com/cslashm/ECPy। यह लाइब्रेरी Python में elliptic curve के गणित (math) को लागू (implement) करती है, इसलिए यह Bitcoin C इम्प्लीमेंटेशन के रैपर (wrapper) जितनी तेज़ नहीं होगी, जिसका उपयोग coincurve लाइब्रेरी द्वारा किया जाता है।
हालाँकि, Python इम्प्लीमेंटेशन आपको public key प्राप्त करने के लिए इस्तेमाल किए जाने वाले elliptic curve गणित को स्टेप-बाय-स्टेप (step by step) देखने की अनुमति देता है।
आप इस कोड का उपयोग ब्रूट फोर्स (brute force) के साथ एक Ethereum vanity address जनरेट करने के लिए कर सकते हैं, लेकिन इस बात का ध्यान रखें कि यदि आपका source of randomness सुरक्षित नहीं है या उसमें बहुत कम बिट्स (bits) की रैंडमनेस है, तो आप इस जैसे किसी हैक का शिकार हो सकते हैं।
Python और coin flips (सिक्का उछालने) या dice (पासे) के साथ private key जनरेट करें
आप एक सिक्के को 256 बार उछालकर और चित (heads) आने पर एक स्ट्रिंग में 1 लिखकर और पट (tails) आने पर 0 लिखकर, स्वयं एक private key से एक Ethereum address जनरेट कर सकते हैं।
मान लीजिए कि आपको निम्नलिखित परिणाम (outcome) मिलता है:
result = b'1100001011001101010001001100101000001111101101111011001000110001101100011101101011010001011000101111100110010101001001101110111011001000100001010101111100001100100110010010111110110100000010011111100000110101001110000101100101011111001101010001100001000'
आप निम्नलिखित Python कोड का उपयोग करके इसे private key में बदल सकते हैं:
# 2 means base 2 for binary
private_key = hex(int(result, 2))
# private key is 0x1859a89941f6f646363b5a2c5f32a4ddd910abe19325f6813f06a70b2be6a308
फिर, उस private key को ऊपर दिए गए सेक्शन के कोड में डालें और आपने अपनी खुद की रैंडमनेस के साथ अपना address जनरेट कर लिया है।
यही काम 16-साइड वाले पासे (16-sided dice) को 64 बार रोल करके और कैरेक्टर दर कैरेक्टर (character by character) उत्पन्न होने वाली hex स्ट्रिंग को लिखकर और भी तेज़ी से किया जा सकता है। ध्यान रखें कि अधिकांश पासों में शून्य (zero) संख्या का प्रतिनिधित्व नहीं होता है, इसलिए आपको प्रत्येक परिणाम से 1 घटाना होगा।
यदि आपके पास केवल पारंपरिक 6-साइड वाले पासे (traditional six-sided dice) हैं, तो आप base 6 में एक स्ट्रिंग लिख सकते हैं (प्रत्येक रोल से 1 घटाना न भूलें) और बाइनरी में base conversion कर सकते हैं। आपको तब तक पासा रोल करते रहना होगा जब तक कि आपकी private key के लिए कम से कम 256 bits न हो जाएं। यदि आप रैंडमनेस को लेकर विशेष रूप से चिंतित (paranoid) हैं, तो आप कैसीनो-ग्रेड (casino grade) पासों का उपयोग कर सकते हैं।
Python की बिल्ट-इन (built-in) रैंडम नंबर लाइब्रेरी का उपयोग करते समय सावधान रहें। यह क्रिप्टोग्राफिक रूप से सुरक्षित (cryptographically secure) होने के इरादे से नहीं बनाई गई है। यदि आप इस विषय में नए हैं, तो हम अनुशंसा करते हैं कि आप cryptographically secure randomness से खुद को परिचित कर लें।
आमतौर पर, आप इस तरीके का उपयोग करके hardware wallet को इनिशियलाइज़ (initialize) नहीं कर सकते हैं क्योंकि वे जिस 24-वर्ड रिकवरी फ्रेज़ (24 word recovery phrase) का उपयोग करते हैं, वह ट्रांज़ैक्शन साइन (sign) करने के लिए उपयोग की जाने वाली private key के समान नहीं है। 24-वर्ड रिकवरी फ्रेज़ का उपयोग वॉलेट में मौजूद विभिन्न प्रकार के क्रिप्टो के लिए कई private keys प्राप्त (derive) करने के लिए किया जाता है।
Math: secp256k1 के बारे में: Private Key से Public Key
Curve का आकार (Shape)
Secp256k1, elliptic curve (mod p) के आकार को परिभाषित करता है, जहाँ p अभाज्य संख्या (prime number) 115792089237316195423570985008687907853269984665640564039457584007908834671663 है।
या
अभाज्य संख्या p को curve के order समझने की भूल नहीं करनी चाहिए। का हर मान उपरोक्त समीकरण को संतुष्ट (satisfy) नहीं करता है। हालाँकि, curve पर ऑपरेशन्स के closed होने की गारंटी होती है। अर्थात्, यदि दो वैध (valid) बिंदुओं को जोड़ा या गुणा किया जाता है, तो परिणाम curve पर एक वैध संख्या (valid number) होगा।
शुरुआती बिंदु (The starting point)
secp256k1 में एक और महत्वपूर्ण पैरामीटर शुरुआती बिंदु G (starting point G) है। चूँकि G, elliptic curve पर एक बिंदु है, यह 2-आयामी (2-dimensional) है और इसके पैरामीटर्स हैं:
x = 55066263022277343669578718895168534326250603453777594175500187360389116729240
y = 32670510020758816978083085130507043184471273380659243275938904335757337482424
यह देखने के लिए कि G एक वैध (valid) बिंदु है, हम इन नंबरों को Python में डाल सकते हैं:
x = 55066263022277343669578718895168534326250603453777594175500187360389116729240
y = 32670510020758816978083085130507043184471273380659243275938904335757337482424
p = 115792089237316195423570985008687907853269984665640564039457584007908834671663
assert pow(y, 2, p) == (pow(x, 3) + 7) % p
एक public / private key पेयर बनाने के लिए, एक रैंडम नंबर s बनाया जाता है (यह secret key है)। बिंदु G को स्वयं में s बार जोड़ा जाता है और नया बिंदु (x, y) public key होता है। यदि s काफी बड़ा है, तो G और (x, y) से s प्राप्त करना संभव नहीं है।
इस स्कीम (scheme) में मैसेजेस को साइन (signing messages) करने का मतलब मूल रूप से यह प्रदर्शित करना है कि आप s को बिना उजागर (reveal) किए जानते हैं।
G को स्वयं में s बार जोड़ना, s * G से गुणा करने के समान है। वास्तव में, हम लाइब्रेरी द्वारा प्रदान किए जा रहे कुछ एब्सट्रैक्शन्स (abstractions) को हटाकर इस ऑपरेशन को निचले स्तर (lower level) पर देख सकते हैं।
from ecpy.curves import Curve
from sha3 import keccak_256
private_key = 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
cv = Curve.get_curve('secp256k1')
pu_key = private_key * cv.generator # just multiplying the private key by generator point (EC multiplication)
concat_x_y = pu_key.x.to_bytes(32, byteorder='big') + pu_key.y.to_bytes(32, byteorder='big')
eth_addr = '0x' + keccak_256(concat_x_y).digest()[-20:].hex()
print('private key: ', hex(private_key))
print('eth_address: ', eth_addr)
Public key, secp256k1 elliptic curve पर मौजूद बिंदु G से गुणा की गई private key होती है। बस इतना ही।
और जानें
आज ही हमारा एडवांस blockchain bootcamp देखें और एक ऐसे ब्लॉकचेन डेवलपर बनें जो उन कठिन चीज़ों को जानता है जो अन्य कोडर्स नहीं जानते।
मूल रूप से 30 जनवरी, 2023 को प्रकाशित