മെച്ചപ്പെടുത്തിയ സുരക്ഷയ്ക്കും പ്രകടനത്തിനുമായി JavaScript-ൻ്റെ നേറ്റീവ് BigInt ഉപയോഗിച്ച് ECDH, പബ്ലിക് കീ വീണ്ടെടുക്കൽ, Schnorr സിഗ്നേച്ചറുകൾ പോലുള്ള നൂതന എലിപ്റ്റിക് കർവ് ക്രിപ്‌റ്റോഗ്രഫി (ECC) പ്രവർത്തനങ്ങൾ പര്യവേക്ഷണം ചെയ്യുക.
JavaScript BigInt എലിപ്റ്റിക് കർവ് ക്രിപ്‌റ്റോഗ്രഫി: നൂതന പ്രവർത്തനങ്ങളിലേക്കുള്ള ആഴത്തിലുള്ള ഒരു പഠനം
വികേന്ദ്രീകൃത ധനകാര്യം (DeFi) മുതൽ എൻഡ്-ടു-എൻഡ് എൻക്രിപ്റ്റഡ് സന്ദേശമയയ്‌ക്കൽ വരെ ഡിജിറ്റൽ ഇടപെടൽ ആധിപത്യം സ്ഥാപിക്കുന്ന ഈ കാലഘട്ടത്തിൽ, നമ്മുടെ ക്രിപ്‌റ്റോഗ്രാഫിക് അടിത്തറയുടെ കരുത്ത് എന്നത്തേക്കാളും നിർണായകമാണ്. എലിപ്റ്റിക് കർവ് ക്രിപ്‌റ്റോഗ്രഫി (ECC) ആധുനിക പബ്ലിക്-കീ ക്രിപ്‌റ്റോഗ്രഫിയുടെ ഒരു തൂണായി നിലകൊള്ളുന്നു, RSA പോലുള്ള അതിന്റെ മുൻഗാമികളുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ ചെറിയ കീ വലുപ്പത്തിൽ ശക്തമായ സുരക്ഷ ഇത് വാഗ്ദാനം ചെയ്യുന്നു. വർഷങ്ങളായി, ഈ സങ്കീർണ്ണമായ ഗണിതശാസ്ത്ര പ്രവർത്തനങ്ങൾ JavaScript-ൽ നേരിട്ട് ചെയ്യുന്നത് ഒരു വെല്ലുവിളിയായിരുന്നു, പലപ്പോഴും JavaScript-ൻ്റെ സാധാരണ നമ്പർ തരത്തിലുള്ള പരിമിതികളോ കുറഞ്ഞ തലത്തിലുള്ള വിശദാംശങ്ങൾ ഇല്ലാത്ത പ്രത്യേക ലൈബ്രറികൾ ആവശ്യമായിരുന്നു.
JavaScript-ൽ (ES2020) നേറ്റീവ് BigInt ടൈപ്പിന്റെ ആമുഖം ഒരു വിപ്ലവകരമായ നിമിഷമായിരുന്നു. ഇത് 64-ബിറ്റ് ഫ്ലോട്ടിംഗ് പോയിന്റ് Number ടൈപ്പിന്റെ പരിമിതികളിൽ നിന്ന് ഡെവലപ്പർമാരെ മോചിപ്പിച്ചു, ഏകപക്ഷീയമായി വലിയ സംഖ്യകൾ കൈകാര്യം ചെയ്യാൻ ഒരു സംവിധാനം നൽകി. ഈ ഒരൊറ്റ ഫീച്ചർ, ബ്രൗസറുകളും Node.js പോലുള്ള JavaScript പരിതസ്ഥിതികളിൽ നേരിട്ട് കാര്യക്ഷമവും നേറ്റീവുമായ കൂടുതൽ സുതാര്യമായ ക്രിപ്‌റ്റോഗ്രാഫിക് നടപ്പാക്കാനുള്ള സാധ്യത തുറന്നു.
പല ഡെവലപ്പർമാർക്കും ECC-യുടെ അടിസ്ഥാനകാര്യങ്ങൾ പരിചിതമാണെങ്കിലും - കീ ജോഡികൾ നിർമ്മിക്കുകയും സന്ദേശങ്ങളിൽ ഒപ്പിടുകയും ചെയ്യുക - ഈ സാങ്കേതികവിദ്യയുടെ യഥാർത്ഥ ശക്തി അതിന്റെ കൂടുതൽ നൂതനമായ പ്രവർത്തനങ്ങളിലാണ്. ഈ ലേഖനം അടിസ്ഥാനകാര്യങ്ങൾക്കപ്പുറം BigInt-ന് നന്ദി നൽകി ഇപ്പോൾ ലഭ്യമായ സങ്കീർണ്ണമായ ക്രിപ്‌റ്റോഗ്രാഫിക് പ്രോട്ടോക്കോളുകളും സാങ്കേതികതകളും പര്യവേക്ഷണം ചെയ്യുന്നു. സുരക്ഷിതമായ കീ കൈമാറ്റത്തിനായി എലിപ്റ്റിക് കർവ് ഡിഫി-ഹെൽമാൻ (ECDH), സിഗ്നേച്ചറുകളിൽ നിന്ന് പബ്ലിക് കീ വീണ്ടെടുക്കൽ, ശക്തവും മൊത്തത്തിൽ ഉപയോഗിക്കാൻ എളുപ്പമുള്ളതുമായ Schnorr സിഗ്നേച്ചറുകൾ എന്നിവ ഞങ്ങൾ പരിശോധിക്കും.
JavaScript ക്രിപ്‌റ്റോഗ്രഫിയിൽ BigInt വിപ്ലവം
ഞങ്ങൾ നൂതനമായ പ്രവർത്തനങ്ങളിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, JavaScript-ലെ ക്രിപ്‌റ്റോഗ്രഫിക്ക് BigInt ഒരു ഗെയിം ചേഞ്ചറാണെന്ന് മനസിലാക്കേണ്ടത് അത്യാവശ്യമാണ്.
`Number` ടൈപ്പിനുള്ള പ്രശ്നം
JavaScript-ൻ്റെ പരമ്പരാഗത Number ടൈപ്പ് ഒരു IEEE 754 ഇരട്ട-കൃത്യതയുള്ള 64-ബിറ്റ് ഫ്ലോട്ടിംഗ്-പോയിന്റ് സംഖ്യയാണ്. ഈ ഫോർമാറ്റ് വിപുലമായ ആപ്ലിക്കേഷനുകൾക്ക് മികച്ചതാണ്, എന്നാൽ ക്രിപ്‌റ്റോഗ്രഫിക്ക് ഒരു നിർണായക പരിമിതിയുണ്ട്: ഇതിന് Number.MAX_SAFE_INTEGER വരെ പൂർണ്ണ സംഖ്യകളെ മാത്രമേ സുരക്ഷിതമായി പ്രതിനിധീകരിക്കാൻ കഴിയൂ, ഇത് 253 - 1 ആണ്.
ECC-യിലെ ക്രിപ്‌റ്റോഗ്രാഫിക് കീകൾക്കും ഇന്റർമീഡിയറ്റ് മൂല്യങ്ങൾക്കും വളരെ വലുപ്പമുണ്ട്. ഉദാഹരണത്തിന്, Bitcoin-ഉം Ethereum-ഉം ഉപയോഗിക്കുന്ന secp256k1 കർവ് 256 ബിറ്റ് വലുപ്പമുള്ള പ്രധാന സംഖ്യകളുടെ ഒരു ഫീൽഡിലാണ് പ്രവർത്തിക്കുന്നത്. സാധാരണ Number ടൈപ്പിന് കൃത്യത നഷ്ടപ്പെടാതെ കൈകാര്യം ചെയ്യാൻ കഴിയുന്നതിലും എത്രയോ വലുതാണ് ഈ സംഖ്യകൾ. അത്തരം സംഖ്യകൾ ഉപയോഗിച്ച് കണക്കുകൂട്ടലുകൾ നടത്താൻ ശ്രമിച്ചാൽ തെറ്റായതും സുരക്ഷിതമല്ലാത്തതുമായ ഫലങ്ങളിലേക്ക് നയിക്കും.
`BigInt` നൽകുന്നു: ഏകപക്ഷീയമായ കൃത്യതയുള്ള പൂർണ്ണസംഖ്യകൾ
BigInt ഈ പ്രശ്നം മനോഹരമായി പരിഹരിക്കുന്നു. ഏത് വലുപ്പത്തിലുള്ള പൂർണ്ണ സംഖ്യകളെയും പ്രതിനിധീകരിക്കാൻ കഴിയുന്ന ഒരു പ്രത്യേക സംഖ്യാ തരമാണിത്. ഒരു പൂർണ്ണ സംഖ്യാ ലിറ്ററലിന്റെ അവസാനം `n` ചേർത്ത് അല്ലെങ്കിൽ BigInt() കൺസ്ട്രക്ടർ വിളിക്കുന്നതിലൂടെ നിങ്ങൾക്ക് ഒരു BigInt ഉണ്ടാക്കാം.
ഉദാഹരണം:
const aLargeNumber = 9007199254740991n; // BigInt ഉപയോഗിച്ച് സുരക്ഷിതം
const anEvenLargerNumber = 115792089237316195423570985008687907853269984665640564039457584007908834671663n; // 256-ബിറ്റ് പ്രധാന സംഖ്യ
BigInt ഉപയോഗിച്ച്, സാധാരണ ഗണിത ഓപ്പറേറ്റർമാരെല്ലാം (+, -, *, /, %, **) ഈ വലിയ പൂർണ്ണ സംഖ്യകളിൽ പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുന്നു. ഈ ശേഷിയാണ് നേറ്റീവ് JavaScript ECC നടപ്പാക്കലിന്റെ അടിസ്ഥാനം, ബാഹ്യ WebAssembly മൊഡ്യൂളുകളെയോ വലിയ മൾട്ടി-പാർട്ട് നമ്പർ ലൈബ്രറികളെയോ ആശ്രയിക്കാതെ ക്രിപ്‌റ്റോഗ്രാഫിക് അൽഗോരിതങ്ങളുടെ നേരിട്ടുള്ളതും കൃത്യവും സുരക്ഷിതവുമായ കമ്പ്യൂട്ടിംഗ് അനുവദിക്കുന്നു.
എലിപ്റ്റിക് കർവ് ക്രിപ്‌റ്റോഗ്രഫി അടിസ്ഥാനകാര്യങ്ങളെക്കുറിച്ച് ഒരു ഓർമ്മപ്പെടുത്തൽ
നൂതന പ്രവർത്തനങ്ങളെ അഭിനന്ദിക്കാൻ, ECC-യുടെ പ്രധാന ആശയങ്ങൾ നമുക്ക് ഹ്രസ്വമായി പുനഃപരിശോധിക്കാം.
അടിസ്ഥാനപരമായി, ECC പരിമിതമായ ഫീൽഡുകളിലെ എലിപ്റ്റിക് കർവുകളുടെ ബീജഗണിത ഘടനയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. ഈ കർവുകൾ വിയർസ്‌ട്രാസ് സമവാക്യം ഉപയോഗിച്ച് നിർവചിച്ചിരിക്കുന്നു:
y2 = x3 + ax + b (mod p)
ഇവിടെ `a` ഉം `b` ഉം കർവിൻ്റെ ആകൃതി നിർവചിക്കുന്ന കോൺസ്റ്റന്റുകളാണ്, `p` എന്നത് പരിമിതമായ ഫീൽഡിനെ നിർവചിക്കുന്ന ഒരു വലിയ പ്രധാന സംഖ്യയാണ്.
പ്രധാന ആശയങ്ങൾ
- കർവിലെ പോയിന്റ്: കർവ് സമവാക്യം തൃപ്തിപ്പെടുത്തുന്ന കോർഡിനേറ്റുകളുടെ ഒരു ജോഡി (x, y). ഞങ്ങളുടെ എല്ലാ ക്രിപ്‌റ്റോഗ്രാഫിക് പ്രവർത്തനങ്ങളും പ്രധാനമായും "പോയിന്റ് അരിത്മെറ്റിക്" ആണ്.
- അടിസ്ഥാന പോയിന്റ് (G): കർവിലെ പരസ്യമായി അറിയപ്പെടുന്ന ഒരു സാധാരണ ആരംഭ പോയിന്റ്.
- സ്വകാര്യ കീ (d): വളരെ വലുതും ക്രിപ്‌റ്റോഗ്രാഫിക്കലി സുരക്ഷിതവുമായ ക്രമരഹിതമായ പൂർണ്ണസംഖ്യ. ഇതാണ് നിങ്ങളുടെ രഹസ്യം.
BigInt-ൻ്റെ പശ്ചാത്തലത്തിൽ, `d` ഒരു വലിയ `BigInt` ആണ്. - പബ്ലിക് കീ (Q): സ്കെയിലാർ ഗുണനം എന്ന് വിളിക്കപ്പെടുന്ന ഒരു പ്രവർത്തനത്തിലൂടെ സ്വകാര്യ കീയിൽ നിന്നും അടിസ്ഥാന പോയിന്റിൽ നിന്നും ഉരുത്തിരിഞ്ഞ കർവിലെ ഒരു പോയിന്റ്: Q = d * G. ഇതിനർത്ഥം G എന്ന പോയിന്റിനെ `d` തവണ സ്വയം കൂട്ടിച്ചേർക്കുന്നു.
ECC-യുടെ സുരക്ഷ എലിപ്റ്റിക് കർവ് ഡിസ്‌ക്രീറ്റ് ലോഗരിതം പ്രോബ്ലം (ECDLP) എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു. സ്വകാര്യ കീ `d` യും അടിസ്ഥാന പോയിന്റ് `G` യും നൽകിയാൽ പബ്ലിക് കീ `Q` കണക്കാക്കാൻ എളുപ്പമാണ്. എന്നിരുന്നാലും, പബ്ലിക് കീ `Q` യും അടിസ്ഥാന പോയിന്റ് `G` യും മാത്രം നൽകിയാൽ സ്വകാര്യ കീ `d` നിർണ്ണയിക്കാൻ കമ്പ്യൂട്ടിങ്പരമായി സാധ്യമല്ല.
നൂതന പ്രവർത്തനം 1: എലിപ്റ്റിക് കർവ് ഡിഫി-ഹെൽമാൻ (ECDH) കീ എക്സ്ചേഞ്ച്
ECC-യുടെ ഏറ്റവും ശക്തമായ ആപ്ലിക്കേഷനുകളിൽ ഒന്ന്, സുരക്ഷിതമല്ലാത്ത ഒരു ആശയവിനിമയ ചാനലിലൂടെ രണ്ട് കക്ഷികൾ തമ്മിൽ ഒരു പങ്കിട്ട രഹസ്യം സ്ഥാപിക്കുക എന്നതാണ്. എലിപ്റ്റിക് കർവ് ഡിഫി-ഹെൽമാൻ (ECDH) കീ എക്സ്ചേഞ്ച് പ്രോട്ടോക്കോൾ ഉപയോഗിച്ചാണ് ഇത് സാധ്യമാക്കുന്നത്.
ലക്ഷ്യം
ആലീസിനും ബോബിനും സുരക്ഷിതമായി ആശയവിനിമയം നടത്തണമെന്ന് സങ്കൽപ്പിക്കുക. അവർക്ക് മാത്രം അറിയാവുന്ന ഒരു സമമിതി എൻക്രിപ്ഷൻ കീയിൽ അവർ സമ്മതിക്കണം, എന്നാൽ അവരുടെ ആശയവിനിമയത്തിനുള്ള ഏക മാർഗ്ഗം ഒരു പൊതു ചാനലാണ്, അത് ഈവ് എന്ന കള്ളൻ നിരീക്ഷിക്കാൻ കഴിയും. ECDH ഒരുപോലെ പങ്കിട്ട ഒരു രഹസ്യം നേരിട്ട് കൈമാറാതെ തന്നെ കമ്പ്യൂട്ട് ചെയ്യാൻ അവരെ അനുവദിക്കുന്നു.
പ്രോട്ടോക്കോൾ ഘട്ടം ഘട്ടമായി
- കീ ജനറേഷൻ:
- ആലീസ് അവളുടെ സ്വകാര്യ കീ, `d_A` (വലിയ ക്രമരഹിതമായ
BigInt), കൂടാതെ അതിന് തുല്യമായ പബ്ലിക് കീ, `Q_A = d_A * G` എന്നിവ ഉണ്ടാക്കുന്നു. - ബോബ് അവന്റെ സ്വകാര്യ കീ, `d_B` (മറ്റൊരു വലിയ ക്രമരഹിതമായ
BigInt), അവന്റെ പബ്ലിക് കീ, `Q_B = d_B * G` എന്നിവ ഉണ്ടാക്കുന്നു.
- ആലീസ് അവളുടെ സ്വകാര്യ കീ, `d_A` (വലിയ ക്രമരഹിതമായ
- പബ്ലിക് കീ എക്സ്ചേഞ്ച്:
- ആലീസ് അവളുടെ പബ്ലിക് കീ, `Q_A`, ബോബിന് അയയ്ക്കുന്നു.
- ബോബ് അവന്റെ പബ്ലിക് കീ, `Q_B`, ആലീസിന് അയയ്ക്കുന്നു.
- ഈവ് എന്ന കള്ളൻ `Q_A` ഉം `Q_B` ഉം കാണുന്നു, എന്നാൽ ECDLP കാരണം സ്വകാര്യ കീകൾ `d_A` അല്ലെങ്കിൽ `d_B` കണ്ടെത്താൻ കഴിയില്ല.
- പങ്കിട്ട രഹസ്യ കണക്കുകൂട്ടൽ:
- ആലീസ് ബോബിൻ്റെ പബ്ലിക് കീ `Q_B` എടുത്ത് അവളുടെ സ്വകാര്യ കീ `d_A` ഉപയോഗിച്ച് ഗുണിക്കുന്നു, ഒരു പോയിന്റ് S ലഭിക്കാൻ: S = d_A * Q_B.
- ബോബ് ആലീസിൻ്റെ പബ്ലിക് കീ `Q_A` എടുത്ത് അവന്റെ സ്വകാര്യ കീ `d_B` ഉപയോഗിച്ച് ഗുണിക്കുന്നു, ഒരു പോയിന്റ് S ലഭിക്കാൻ: S = d_B * Q_A.
Commutativityയുടെ മാജിക്
ആലീസും ബോബും കർവിലെ ഒരേ രഹസ്യ പോയിന്റിൽ `S` എത്തുന്നു. സ്കെയിലാർ ഗുണനം സഹായകവും ക്രമീകൃതവുമാണ് എന്നതിനാലാണിത്:
ആലീസിൻ്റെ കണക്കുകൂട്ടൽ: S = d_A * Q_B = d_A * (d_B * G)
ബോബിൻ്റെ കണക്കുകൂട്ടൽ: S = d_B * Q_A = d_B * (d_A * G)
d_A * d_B * G = d_B * d_A * G ആയതിനാൽ, അവർ അവരുടെ സ്വകാര്യ കീകൾ വെളിപ്പെടുത്താതെ തന്നെ ഒരേ ഫലം കമ്പ്യൂട്ട് ചെയ്യുന്നു.
പങ്കിട്ട പോയിന്റിൽ നിന്ന് സമമിതി കീയിലേക്ക്
തത്ഫലമായുണ്ടാകുന്ന പങ്കിട്ട രഹസ്യം `S` എന്നത് കർവിലെ ഒരു പോയിന്റാണ്, AES പോലുള്ള എൻക്രിപ്ഷൻ അൽഗോരിതങ്ങൾക്ക് അനുയോജ്യമായ ഒരു സമമിതി കീയല്ല. ഒരു കീ ഉണ്ടാക്കാൻ, പോയിന്റ് `S`-ൻ്റെ x-കോർഡിനേറ്റ് എടുത്ത് കീ ഡെറിവേഷൻ ഫംഗ്ഷനിലൂടെ (KDF) കടത്തിവിടുന്നത് ഒരു സാധാരണ രീതിയാണ്, ഉദാഹരണത്തിന് HKDF (HMAC അടിസ്ഥാനമാക്കിയുള്ള കീ ഡെറിവേഷൻ ഫംഗ്ഷൻ). KDF പങ്കിട്ട രഹസ്യവും ആവശ്യമെങ്കിൽ സാൾട്ടും മറ്റ് വിവരങ്ങളും എടുത്ത് ആവശ്യമുള്ള ദൈർഘ്യമുള്ള ക്രിപ്‌റ്റോഗ്രാഫിക്കായി ശക്തമായ കീ ഉത്പാദിപ്പിക്കുന്നു.
എല്ലാ അടിസ്ഥാന കണക്കുകൂട്ടലുകളും - ക്രമരഹിതമായ `BigInt`s ആയി സ്വകാര്യ കീകൾ ഉണ്ടാക്കുന്നതും സ്കെയിലാർ ഗുണനം നടത്തുന്നതും - `BigInt` അരിത്മെറ്റിക്കിനെ വളരെയധികം ആശ്രയിക്കുന്നു.
നൂതന പ്രവർത്തനം 2: സിഗ്നേച്ചറുകളിൽ നിന്ന് പബ്ലിക് കീ വീണ്ടെടുക്കൽ
പല സിസ്റ്റങ്ങളിലും, പ്രത്യേകിച്ച് ബ്ലോക്ക്‌ചെയിനുകളിൽ, കാര്യക്ഷമതയും ഡാറ്റ ചുരുക്കലും പരമപ്രധാനമാണ്. സാധാരണയായി, ഒരു സിഗ്നേച്ചർ പരിശോധിക്കാൻ, നിങ്ങൾക്ക് സന്ദേശം, സിഗ്നേച്ചർ, സൈനറുടെ പബ്ലിക് കീ എന്നിവ ആവശ്യമാണ്. എന്നിരുന്നാലും, എലിപ്റ്റിക് കർവ് ഡിജിറ്റൽ സിഗ്നേച്ചർ അൽഗോരിതത്തിൻ്റെ (ECDSA) ഒരു സൂത്രപരമായ പ്രോപ്പർട്ടി സന്ദേശത്തിൽ നിന്നും സിഗ്നേച്ചറിൽ നിന്നും നേരിട്ട് പബ്ലിക് കീ വീണ്ടെടുക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഇതിനർത്ഥം പബ്ലിക് കീ കൈമാറേണ്ടതില്ല, ഇത് വിലയേറിയ സ്ഥലം ലാഭിക്കുന്നു.
ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു (ഉയർന്ന നിലവാരം)
ഒരു ECDSA സിഗ്നേച്ചറിൽ രണ്ട് ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു, (`r`, `s`).
- `r` എന്നത് ക്രമരഹിതമായ പോയിന്റ് `k * G`-യുടെ x-കോർഡിനേറ്റിൽ നിന്ന് ഉരുത്തിരിഞ്ഞതാണ്.
- സന്ദേശ ഹാഷ് (`z`), സ്വകാര്യ കീ (`d`), `r` എന്നിവ അടിസ്ഥാനമാക്കി `s` കണക്കാക്കുന്നു. സൂത്രവാക്യം ഇതാണ്: `s = k_inverse * (z + r * d) mod n`, ഇവിടെ `n` എന്നത് കർവിൻ്റെ ക്രമമാണ്.
സിഗ്നേച്ചർ സ്ഥിരീകരണ സമവാക്യത്തിന്റെ ബീജഗണിതപരമായ കൃത്രിമത്വത്തിലൂടെ, പബ്ലിക് കീ `Q`യുടെ ഒരു എക്സ്പ്രെഷൻ ഉണ്ടാക്കാൻ സാധിക്കും. എന്നിരുന്നാലും, ഈ പ്രക്രിയ സാധുവായ രണ്ട് പബ്ലിക് കീകൾ നൽകുന്നു. ഈ അവ്യക്തത പരിഹരിക്കാൻ, വീണ്ടെടുക്കൽ ID (പലപ്പോഴും `v` അല്ലെങ്കിൽ `recid` എന്ന് സൂചിപ്പിക്കുന്നു) എന്ന് വിളിക്കുന്ന ഒരു ചെറിയ അധിക വിവരവും സിഗ്നേച്ചറിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ഈ ID, സാധാരണയായി 0, 1, 2, അല്ലെങ്കിൽ 3, സാധ്യമായ പരിഹാരങ്ങളിൽ ഏതാണ് ശരിയായതെന്നും കീയുടെ y-കോർഡിനേറ്റ് ഒറ്റയാണോ ഇരട്ടയാണോ എന്നും വ്യക്തമാക്കുന്നു.
എന്തുകൊണ്ട് `BigInt` അത്യാവശ്യമാണ്
പബ്ലിക് കീ വീണ്ടെടുക്കാൻ ആവശ്യമായ ഗണിതശാസ്ത്രപരമായ പ്രവർത്തനങ്ങൾ തീവ്രമാണ്, കൂടാതെ മോഡുലാർ വിപരീതങ്ങൾ, ഗുണനം, 256-ബിറ്റ് സംഖ്യകളുടെ കൂട്ടിച്ചേർക്കൽ എന്നിവ ഉൾപ്പെടുന്നു. ഉദാഹരണത്തിന്, `(r_inverse * (s*k - z)) * G` കണക്കാക്കുന്നത് ഒരു പ്രധാന പടിയാണ്. ഈ പ്രവർത്തനങ്ങൾക്ക് വേണ്ടിയാണ് `BigInt` രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. ഇത് കൂടാതെ, നേറ്റീവ് JavaScript-ൽ ഈ കണക്കുകൂട്ടലുകൾ കൃത്യതയും സുരക്ഷയും ഗണ്യമായി നഷ്ടപ്പെടുത്താതെ നടത്താൻ കഴിയില്ല.
പ്രായോഗിക ആപ്ലിക്കേഷൻ: Ethereum ഇടപാടുകൾ
ഈ സാങ്കേതികത Ethereum-ൽ പ്രസിദ്ധമായി ഉപയോഗിക്കുന്നു. ഒപ്പിട്ട ഒരു ഇടപാടിൽ അയച്ചയാളുടെ പൊതു വിലാസം നേരിട്ട് അടങ്ങിയിട്ടില്ല. പകരം, വിലാസം (പബ്ലിക് കീയിൽ നിന്ന് ഉരുത്തിരിഞ്ഞത്) സിഗ്നേച്ചറിൻ്റെ `v`, `r`, `s` ഘടകങ്ങളിൽ നിന്ന് വീണ്ടെടുക്കുന്നു. ഈ രൂപകൽപ്പന ഓരോ ഇടപാടിലും 20 ബൈറ്റുകൾ ലാഭിക്കുന്നു, ഇത് ഒരു ആഗോള ബ്ലോക്ക്‌ചെയിനിൻ്റെ സ്കെയിലിൽ ഗണ്യമായ ലാഭമാണ്.
നൂതന പ്രവർത്തനം 3: Schnorr സിഗ്നേച്ചറുകളും അഗ്രഗേഷനും
ECDSA വ്യാപകമായി ഉപയോഗിക്കപ്പെടുന്നുണ്ടെങ്കിലും, സിഗ്നേച്ചർ മാലെബിലിറ്റി, അഗ്രഗേഷൻ പ്രോപ്പർട്ടികളുടെ അഭാവം എന്നിവയുൾപ്പെടെ ചില പോരായ്മകളുണ്ട്. മറ്റൊരു ECC-അടിസ്ഥാനമാക്കിയുള്ള സ്കീമായ Schnorr സിഗ്നേച്ചറുകൾ ഈ പ്രശ്നങ്ങൾക്ക് മികച്ച പരിഹാരങ്ങൾ നൽകുന്നു, കൂടാതെ പല ക്രിപ്‌റ്റോഗ്രാഫർമാരും മികച്ചതായി കണക്കാക്കുന്നു.
Schnorr സിഗ്നേച്ചറുകളുടെ പ്രധാന ഗുണങ്ങൾ
- തെളിയിക്കാവുന്ന സുരക്ഷ: ECDSA-യെ അപേക്ഷിച്ച് ഇതിന് കൂടുതൽ ലളിതവും ശക്തവുമായ സുരക്ഷാ തെളിവുണ്ട്.
- നോൺ-മാലെബിലിറ്റി: ഒരു മൂന്നാമത്തെ കക്ഷിക്ക് സാധുവായ ഒരു സിഗ്നേച്ചറിനെ അതേ സന്ദേശത്തിനും കീയ്‌ക്കുമുള്ള മറ്റൊരു സാധുവായ സിഗ്നേച്ചറാക്കി മാറ്റാൻ കഴിയില്ല.
- ലീനിയാരിറ്റി (ദി സൂപ്പർപവർ): ഇതാണ് ഏറ്റവും പ്രധാനപ്പെട്ട ഗുണം. Schnorr സിഗ്നേച്ചറുകൾ ലീനിയറാണ്, ഇത് ശക്തമായ അഗ്രഗേഷൻ ടെക്നിക്കുകൾക്ക് അനുവദിക്കുന്നു.
സിഗ്നേച്ചർ അഗ്രഗേഷൻ വിശദീകരിച്ചു
ലീനിയാരിറ്റി പ്രോപ്പർട്ടി എന്നാൽ ഒന്നിലധികം സൈനർമാരിൽ നിന്നുള്ള ഒന്നിലധികം സിഗ്നേച്ചറുകൾ ഒരുമിപ്പിച്ച് ഒരൊറ്റ കോംപാക്റ്റ് സിഗ്നേച്ചറാക്കി മാറ്റാൻ കഴിയും എന്നാണ്. ഇത് മൾട്ടി-സിഗ്നേച്ചർ (multisig) സ്കീമുകൾക്കുള്ള ഒരു ഗെയിം ചേഞ്ചറാണ്.
ഒരു ഇടപാടിന് 5 പങ്കാളികളിൽ നിന്ന് 3 പേരുടെ സിഗ്നേച്ചറുകൾ ആവശ്യമായ ഒരു സാഹചര്യം പരിഗണിക്കുക. ECDSA ഉപയോഗിച്ച്, നിങ്ങൾ മൂന്ന് വ്യക്തിഗത സിഗ്നേച്ചറുകളും ബ്ലോക്ക്‌ചെയിനിൽ ഉൾപ്പെടുത്തേണ്ടിവരും, ഇത് ഗണ്യമായ സ്ഥലം എടുക്കും.
Schnorr സിഗ്നേച്ചറുകൾ ഉപയോഗിച്ച്, പ്രക്രിയ കൂടുതൽ കാര്യക്ഷമമാണ്:
- കീ അഗ്രഗേഷൻ: 3 പങ്കാളികൾക്ക് അവരുടെ വ്യക്തിഗത പബ്ലിക് കീകൾ (`Q1`, `Q2`, `Q3`) സംയോജിപ്പിച്ച് ഒരു അഗ്രഗേറ്റ് പബ്ലിക് കീ (`Q_agg`) ഉണ്ടാക്കാം.
- സിഗ്നേച്ചർ അഗ്രഗേഷൻ: MuSig2 പോലുള്ള ഒരു സഹകരണ പ്രോട്ടോക്കോൾ വഴി, പങ്കാളികൾക്ക് അഗ്രഗേറ്റ് പബ്ലിക് കീ `Q_agg` ന് സാധുവായ ഒരു അഗ്രഗേറ്റ് സിഗ്നേച്ചർ (`S_agg`) ഉണ്ടാക്കാൻ കഴിയും.
തത്ഫലമായി ലഭിക്കുന്ന ഇടപാട് പുറത്ത് നിന്ന് നോക്കിയാൽ സാധാരണ സിംഗിൾ-സൈനർ ഇടപാട് പോലെയിരിക്കും. അതിന് ഒരു പബ്ലിക് കീയും ഒരു സിഗ്നേച്ചറും ഉണ്ട്. ഇത് കാര്യക്ഷമത, സ്കേലബിലിറ്റി, സ്വകാര്യത എന്നിവയെ ഗണ്യമായി മെച്ചപ്പെടുത്തുന്നു, കാരണം സങ്കീർണ്ണമായ മൾട്ടിസിഗ് സജ്ജീകരണങ്ങൾ ലളിതമായവയിൽ നിന്ന് വേർതിരിച്ചറിയാൻ കഴിയില്ല.
`BigInt` ൻ്റെ പങ്ക്
അഗ്രഗേഷന്റെ മാജിക് ലളിതമായ എലിപ്റ്റിക് കർവ് പോയിന്റ് കൂട്ടിച്ചേർക്കലിനെയും സ്കെയിലാർ അരിത്മെറ്റിക്കിനെയും അടിസ്ഥാനമാക്കിയുള്ളതാണ്. അഗ്രഗേറ്റ് കീ ഉണ്ടാക്കുന്നതിൽ `Q_agg = Q1 + Q2 + Q3` ഉൾപ്പെടുന്നു, കൂടാതെ അഗ്രഗേറ്റ് സിഗ്നേച്ചർ ഉണ്ടാക്കുന്നതിൽ കർവ് ഓർഡർ മോഡുലോ വ്യക്തിഗത സിഗ്നേച്ചർ ഘടകങ്ങൾ ചേർക്കുന്നു. MuSig2 പോലുള്ള പ്രോട്ടോക്കോളുകളുടെ അടിസ്ഥാനമായ ഈ പ്രവർത്തനങ്ങളെല്ലാം വലിയ പൂർണ്ണ സംഖ്യകളിലും കർവ് കോർഡിനേറ്റുകളിലുമാണ് നടത്തുന്നത്, ഇത് JavaScript-ൽ Schnorr സിഗ്നേച്ചറുകളും അഗ്രഗേഷൻ സ്കീമുകളും നടപ്പിലാക്കുന്നതിനുള്ള ഒഴിച്ചുകൂടാനാവാത്ത ഉപകരണമാക്കി BigInt-നെ മാറ്റുന്നു.
നടപ്പാക്കൽ പരിഗണനകളും സുരക്ഷാ രീതികളും
ഈ നൂതന പ്രവർത്തനങ്ങൾ മനസിലാക്കാനും നടപ്പിലാക്കാനും `BigInt` ഞങ്ങളെ സഹായിക്കുമ്പോൾ, പ്രൊഡക്ഷൻ-ഗ്രേഡ് ക്രിപ്‌റ്റോഗ്രഫി നിർമ്മിക്കുന്നത് അപകടകരമായ കാര്യമാണ്. ചില പ്രധാന പരിഗണനകൾ ഇതാ.
1. പ്രൊഡക്ഷനായി നിങ്ങളുടെ സ്വന്തം ക്രിപ്‌റ്റോ ഉണ്ടാക്കരുത്
ഈ ലേഖനം അടിസ്ഥാന മെക്കാനിക്സുകളെക്കുറിച്ച് പഠിപ്പിക്കാനും വ്യക്തമാക്കാനും ലക്ഷ്യമിട്ടുള്ളതാണ്. ഒരു പ്രൊഡക്ഷൻ ആപ്ലിക്കേഷനായി നിങ്ങൾ ഈ ക്രിപ്‌റ്റോഗ്രാഫിക് പ്രിമിറ്റീവുകൾ ആദ്യം മുതൽ നടപ്പിലാക്കരുത്. നന്നായി പരിശോധിച്ചതും ഓഡിറ്റ് ചെയ്തതും പിയർ-റിവ്യൂ ചെയ്തതുമായ `noble-curves` പോലുള്ള ലൈബ്രറികൾ ഉപയോഗിക്കുക. ഈ ലൈബ്രറികൾ വിദഗ്ധർ പ്രത്യേകമായി നിർമ്മിച്ചതാണ്, കൂടാതെ നിരവധി സൂക്ഷ്മവും എന്നാൽ നിർണായകവുമായ സുരക്ഷാ പ്രശ്നങ്ങൾ പരിഗണിക്കുന്നു.
2. കോൺസ്റ്റന്റ്-ടൈം പ്രവർത്തനങ്ങളും സൈഡ്-ചാനൽ ആക്രമണങ്ങളും
ഏറ്റവും അപകടകരമായ അപകടങ്ങളിൽ ഒന്ന് സൈഡ്-ചാനൽ ആക്രമണമാണ്. ഒരു ആക്രമണകാരിക്ക് ഒരു സിസ്റ്റത്തിൻ്റെ പ്രവർത്തനരഹിതമായ വശങ്ങൾ - വൈദ്യുതി ഉപഭോഗം അല്ലെങ്കിൽ ഒരു പ്രവർത്തനം എടുക്കുന്ന കൃത്യമായ സമയം പോലുള്ളവ - രഹസ്യ കീകൾ സംബന്ധിച്ച വിവരങ്ങൾ ചോർത്താൻ വിശകലനം ചെയ്യാൻ കഴിയും. ഉദാഹരണത്തിന്, കീയിലെ '1' ബിറ്റ് ഉപയോഗിച്ചുള്ള ഒരു ഗുണനം '0' ബിറ്റിനേക്കാൾ അല്പം കൂടുതൽ സമയമെടുക്കുകയാണെങ്കിൽ, സമയ വ്യതിയാനങ്ങൾ നിരീക്ഷിച്ച് ഒരു ആക്രമണകാരിക്ക് കീ പുനർനിർമ്മിക്കാൻ കഴിയും.
JavaScript-ലെ സാധാരണ BigInt പ്രവർത്തനങ്ങൾ സ്ഥിര സമയത്തിലുള്ളതല്ല. അവയുടെ എക്സിക്യൂഷൻ സമയം ഓപ്പറാൻഡുകളുടെ മൂല്യത്തെ ആശ്രയിച്ചിരിക്കുന്നു. പ്രൊഫഷണൽ ക്രിപ്‌റ്റോഗ്രാഫിക് ലൈബ്രറികൾ, സ്വകാര്യ കീകൾ ഉൾപ്പെടുന്ന എല്ലാ പ്രവർത്തനങ്ങളും കീയുടെ മൂല്യം പരിഗണിക്കാതെ ഒരു നിശ്ചിത സമയം എടുക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ ഉയർന്ന സ്പെഷ്യലൈസ്ഡ് അൽഗോരിതങ്ങൾ ഉപയോഗിക്കുന്നു, അതുവഴി ഈ ഭീഷണി ലഘൂകരിക്കുന്നു.
3. സുരക്ഷിതമായ ക്രമരഹിത സംഖ്യാ ഉത്പാദനം
ഏത് ക്രിപ്‌റ്റോഗ്രാഫിക് സിസ്റ്റത്തിൻ്റെയും സുരക്ഷ ആരംഭിക്കുന്നത് ക്രമരഹിതത്വത്തിൻ്റെ ഗുണനിലവാരത്തിലാണ്. ക്രിപ്‌റ്റോഗ്രാഫിക്കായി സുരക്ഷിതമായ സ്യൂഡോ-റാండം നമ്പർ ജനറേറ്റർ (CSPRNG) ഉപയോഗിച്ച് സ്വകാര്യ കീകൾ ഉണ്ടാക്കണം. JavaScript പരിതസ്ഥിതികളിൽ, എല്ലായ്പ്പോഴും ബിൽറ്റ്-ഇൻ API-കൾ ഉപയോഗിക്കുക:
- ബ്രൗസർ:
crypto.getRandomValues() - Node.js:
crypto.randomBytes()
ക്രിപ്‌റ്റോഗ്രാഫിക് ആവശ്യങ്ങൾക്കായി ഒരിക്കലും Math.random() ഉപയോഗിക്കരുത്, കാരണം ഇത് പ്രവചനാതീതമായിരിക്കാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതല്ല.
4. ഡൊമെയ്ൻ പാരാമീറ്റർ, പബ്ലിക് കീ വാലിഡേഷൻ
ബാഹ്യ ഉറവിടത്തിൽ നിന്ന് ഒരു പബ്ലിക് കീ സ്വീകരിക്കുമ്പോൾ, അത് സാധുവാണോ എന്ന് പരിശോധിക്കേണ്ടത് നിർണായകമാണ്. ഒരു ആക്രമണകാരിക്ക് വ്യക്തമാക്കിയ എലിപ്റ്റിക് കർവിൽ ഇല്ലാത്ത ക്ഷുദ്രകരമായ ഒരു പോയിന്റ് നൽകാൻ കഴിയും, ഇത് ECDH കീ എക്സ്ചേഞ്ച് സമയത്ത് നിങ്ങളുടെ സ്വകാര്യ കീ വെളിപ്പെടുത്തുന്ന ആക്രമണങ്ങളിലേക്ക് നയിച്ചേക്കാം (ഉദാഹരണത്തിന്, അസാധുവായ കർവ് ആക്രമണങ്ങൾ). പ്രശസ്തമായ ലൈബ്രറികൾ ഈ വാലിഡേഷൻ സ്വയമേവ കൈകാര്യം ചെയ്യുന്നു.
ഉപസംഹാരം
`BigInt`-ൻ്റെ വരവ് JavaScript എക്കോസിസ്റ്റത്തിലെ ക്രിപ്‌റ്റോഗ്രഫിയുടെ ലാൻഡ്‌സ്‌കേപ്പിനെ അടിസ്ഥാനപരമായി മാറ്റിമറിച്ചു. ഇത് ECC-യെ അതാര്യവും ബ്ലാക്ക്-ബോക്സ് ലൈബ്രറികളുടെ മണ്ഡലത്തിൽ നിന്ന് നടപ്പിലാക്കാനും തദ്ദേശീയമായി മനസ്സിലാക്കാനും കഴിയുന്ന ഒന്നിലേക്ക് മാറ്റി, ഇത് സുതാര്യതയുടെയും ശേഷിയുടെയും ഒരു പുതിയ തലം വളർത്തുന്നു.
ആധുനിക സുരക്ഷിത സിസ്റ്റങ്ങളുടെ കേന്ദ്രമായ നൂതനവും ശക്തവുമായ ക്രിപ്‌റ്റോഗ്രാഫിക് പ്രവർത്തനങ്ങൾ ഈ ഒരൊറ്റ ഫീച്ചർ എങ്ങനെ പ്രാപ്തമാക്കുന്നുവെന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്തു:
- ECDH കീ എക്സ്ചേഞ്ച്: സുരക്ഷിതമായ ആശയവിനിമയ ചാനലുകൾ സ്ഥാപിക്കുന്നതിനുള്ള അടിസ്ഥാനം.
- പബ്ലിക് കീ വീണ്ടെടുക്കൽ: ബ്ലോക്ക്‌ചെയിനുകൾ പോലുള്ള സ്കേലബിൾ സിസ്റ്റങ്ങൾക്ക് നിർണായകമായ കാര്യക്ഷമത വർദ്ധിപ്പിക്കുന്ന സാങ്കേതികത.
- Schnorr സിഗ്നേച്ചറുകൾ: അഗ്രഗേഷനിലൂടെ മികച്ച കാര്യക്ഷമതയും സ്വകാര്യതയും സ്കേലബിലിറ്റിയും വാഗ്ദാനം ചെയ്യുന്ന ഒരു അടുത്ത തലമുറ സിഗ്നേച്ചർ സ്കീം.
ഡെവലപ്പർമാരും ആർക്കിടെക്റ്റുകളും എന്ന നിലയിൽ, ഈ നൂതന ആശയങ്ങൾ മനസ്സിലാക്കുന്നത് ഇനി ഒരു അക്കാദമിക് വ്യായാമം മാത്രമല്ല. Bitcoin-ലെ Taproot അപ്‌ഗ്രേഡ് മുതൽ നമ്മുടെ ദൈനംദിന സംഭാഷണങ്ങളെ സംരക്ഷിക്കുന്ന സുരക്ഷിതമായ സന്ദേശമയയ്‌ക്കൽ പ്രോട്ടോക്കോളുകൾ വരെ അവ ഇന്ന് ആഗോള സിസ്റ്റങ്ങളിൽ വിന്യസിക്കപ്പെടുന്നു. നടപ്പാക്കൽ എല്ലായ്പ്പോഴും ഓഡിറ്റ് ചെയ്ത, വിദഗ്ധർ അവലോകനം ചെയ്ത ലൈബ്രറികൾക്ക് വിട്ടുകൊടുക്കുമ്പോൾ, `BigInt` പോലുള്ള ടൂളുകൾ സാധ്യമാക്കുന്ന മെക്കാനിക്സുകളെക്കുറിച്ചുള്ള ആഴത്തിലുള്ള ധാരണ, ആഗോള പ്രേക്ഷകർക്കായി കൂടുതൽ സുരക്ഷിതവും കാര്യക്ഷമവും നൂതനവുമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ ഞങ്ങളെ സഹായിക്കുന്നു.