ബ്ലോക്ക്ചെയിനിൽ RSA റാൻഡം

ഒരു പ്രശ്നമുണ്ട് - ഒരു വികേന്ദ്രീകൃത നെറ്റ്‌വർക്കിൽ ഒരു ക്രമരഹിത നമ്പർ സൃഷ്ടിക്കുന്നത് ബുദ്ധിമുട്ടാണ്. മിക്കവാറും എല്ലാ ബ്ലോക്ക്ചെയിനുകളും ഇതിനകം ഇത് നേരിട്ടിട്ടുണ്ട്. തീർച്ചയായും, ഉപയോക്താക്കൾക്കിടയിൽ വിശ്വാസമില്ലാത്ത നെറ്റ്‌വർക്കുകളിൽ, നിഷേധിക്കാനാവാത്ത റാൻഡം നമ്പർ സൃഷ്ടിക്കുന്നത് നിരവധി പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നു.

ഒരു ഉദാഹരണമായി ഗെയിമുകൾ ഉപയോഗിച്ച് പ്രശ്നം എങ്ങനെ പരിഹരിക്കാമെന്ന് ഈ ലേഖനത്തിൽ ഞങ്ങൾ നിങ്ങളോട് പറയുന്നു. അവയിൽ ആദ്യത്തേത് വേവ്സ് ക്രിസ്മസ് ട്രീ. വികസനത്തിന്, ഞങ്ങൾക്ക് ഒരു റാൻഡം നമ്പർ ജനറേറ്റർ ആവശ്യമാണ്.

തുടക്കത്തിൽ, ബ്ലോക്ക്ചെയിനിൽ നിന്നുള്ള വിവരങ്ങളെ അടിസ്ഥാനമാക്കി ഒരു നമ്പർ ജനറേറ്റ് ചെയ്യാൻ ഞങ്ങൾ പദ്ധതിയിട്ടിരുന്നു. എന്നിരുന്നാലും, പിന്നീട് അത് വ്യക്തമായി: നമ്പർ കൃത്രിമമാക്കാം, അതിനർത്ഥം പരിഹാരം അനുയോജ്യമല്ല എന്നാണ്.

ഞങ്ങൾ ഒരു പരിഹാരവുമായി എത്തി: പ്രതിബദ്ധത-വികസനം സ്കീം ഉപയോഗിക്കുക. സെർവർ 1 മുതൽ 5 വരെയുള്ള ഒരു നമ്പർ ഊഹിച്ചു, അതിൽ ഒരു ഉപ്പ് ചേർത്തു, തുടർന്ന് ഫലം ഹാഷ് ചെയ്തു കെക്കാക്ക് പ്രവർത്തനങ്ങൾ. സെർവർ ഇതിനകം സംരക്ഷിച്ച നമ്പറുള്ള സ്മാർട്ട് കരാർ മുൻകൂട്ടി വിന്യസിച്ചു. ഹാഷ് മറച്ച നമ്പർ ഊഹിക്കുന്ന ഉപയോക്താവിലേക്ക് ഗെയിം തിളച്ചുമറിയുന്നു.

കളിക്കാരൻ ഒരു പന്തയം വെച്ചു, സെർവർ മറഞ്ഞിരിക്കുന്ന നമ്പറും "ഉപ്പ്" സ്മാർട്ട് കരാറിലേക്ക് അയച്ചു. ലളിതമായി പറഞ്ഞാൽ, അവൻ കാർഡുകൾ വെളിപ്പെടുത്തി. അതിനുശേഷം, സെർവർ നമ്പറുകൾ പരിശോധിച്ച് ഉപയോക്താവ് വിജയിച്ചോ തോറ്റതോ എന്ന് തീരുമാനിച്ചു.

സ്ഥിരീകരണത്തിനായി സെർവർ ഒരു നമ്പറോ "ഉപ്പ്" അയച്ചിട്ടില്ലെങ്കിൽ, ഉപയോക്താവ് വിജയിച്ചു. ഈ സാഹചര്യത്തിൽ, ഓരോ ഗെയിമിനും ഒരു സ്മാർട്ട് കരാർ മുൻകൂട്ടി വിന്യസിക്കുകയും അതിൽ സാധ്യതയുള്ള വിജയങ്ങൾ ഉൾപ്പെടുത്തുകയും ചെയ്യേണ്ടത് ആവശ്യമാണ്. ഇത് അസൗകര്യവും സമയമെടുക്കുന്നതും ചെലവേറിയതുമായി മാറി. അക്കാലത്ത് സുരക്ഷിതമായ മറ്റൊരു പരിഹാരവും ഇല്ലായിരുന്നു.

അടുത്തിടെ, ട്രേഡിസിസ് ടീം വേവ്സ് പ്രോട്ടോക്കോളിലേക്ക് ഒരു ഫംഗ്ഷൻ ചേർക്കാൻ നിർദ്ദേശിച്ചു rsaVerify(). ഇത് പൊതു, സ്വകാര്യ കീ അടിസ്ഥാനമാക്കി RSA ഒപ്പിന്റെ സാധുത പരിശോധിക്കുന്നു. തൽഫലമായി, സവിശേഷത ചേർത്തു.

ഞങ്ങൾ മൂന്ന് ഗെയിമുകൾ വികസിപ്പിച്ചെടുത്തു: ഡൈസ് റോളർ, കോയിൻ ഫ്ലിപ്പ് и തിരമാലകളിൽ സവാരി ചെയ്യുക. ഓരോന്നും റാൻഡം നമ്പർ സാങ്കേതികവിദ്യ നടപ്പിലാക്കുന്നു. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നമുക്ക് കണ്ടെത്താം.

ഒരു ഉദാഹരണമായി റൈഡ് ഓൺ വേവ്സ് ഉപയോഗിച്ച് ഒരു റാൻഡം നമ്പർ സൃഷ്ടിക്കുന്നത് നോക്കാം. സ്മാർട്ട് കരാർ കണ്ടെത്താനാകും ഇവിടെ.

ടാബിലേക്ക് പോകുക സ്ക്രിപ്റ്റ് കൂടാതെ തിരഞ്ഞെടുക്കുക വിഘടിപ്പിച്ചു. നിങ്ങൾ സ്മാർട്ട് കരാർ കോഡ് (അതായത് സ്ക്രിപ്റ്റ്) കാണും.

സ്മാർട്ട് കരാർ കോഡിൽ ഒരു കൂട്ടം ഫംഗ്ഷനുകൾ അടങ്ങിയിരിക്കുന്നു. @Callable എന്ന് അടയാളപ്പെടുത്തിയവ ഉപയോഗിച്ച് ലോഞ്ച് ചെയ്യാം അഭ്യർത്ഥന ഇടപാടുകൾ. ഞങ്ങൾക്ക് രണ്ട് പ്രവർത്തനങ്ങളിൽ താൽപ്പര്യമുണ്ട്: പന്തയം и പിൻവലിക്കൂ:

• ഫങ്ക് ബെറ്റ് (പ്ലെയർ ചോയ്സ്)
• func withdraw(gameId,rsaSign)

1. ഉപയോക്താവ് സെഗ്‌മെന്റിന്റെ നീളവും പന്തയത്തിന്റെ വലുപ്പവും തിരഞ്ഞെടുക്കുന്നു.

2. ക്ലയന്റ് ഒരു പന്തയ പ്രവർത്തനം സൃഷ്ടിക്കുന്നു. മുകളിലുള്ള ചിത്രത്തിന് അത് ആയിരിക്കും പന്തയം ("50").

3. സ്‌മാർട്ട് കോൺട്രാക്‌റ്റ് വിലാസത്തിലേക്ക് ക്ലയന്റ് ഒരു ഇൻവോക്കേഷൻ ഇടപാട് അയയ്‌ക്കുന്നു (ബ്രോഡ്‌കാസ്‌റ്റ് InvocationTx). ഇടപാടിൽ ഒരു കോൾ പാരാമീറ്ററായി ബെറ്റ് ഫംഗ്ഷൻ അടങ്ങിയിരിക്കുന്നു. ഇതിനർത്ഥം, ഇൻവോക്കേഷൻ ഇടപാട്, സ്‌മാർട്ട് കരാറിലെ ബെറ്റ് ഫംഗ്‌ഷൻ (ചോയ്‌സ്: സ്ട്രിംഗ്) നടപ്പിലാക്കാൻ പ്രേരിപ്പിക്കുന്നു എന്നാണ്.

4. പന്തയത്തിന്റെ പ്രവർത്തനം പരിഗണിക്കുക:

@Callable(i)
func bet (playerChoice) = {
    let newGameNum = IncrementGameNum()
    let gameId = toBase58String(i.transactionId)
    let pmt = extract(i.payment)
    let betNotInWaves = isDefined(pmt.assetId)
    let feeNotInWaves = isDefined(pmt.assetId)
    let winAmt = ValidateBetAndDefineWinAmt(pmt.amount, playerChoice)
    let txIdUsed = isDefined(getString(this, gameId))
    if (betNotInWaves)
        then throw ("Bet amount must be in Waves")
        else if (feeNotInWaves)
            then throw ("Transaction's fee must be in Waves")
            else if (txIdUsed)
                then throw ("Passed txId had been used before. Game aborted.")
                else {
                    let playerPubKey58 = toBase58String(i.callerPublicKey)
                    let gameDataStr = FormatGameDataStr(STATESUBMITTED, playerChoice, playerPubKey58, height, winAmt, "")
                    ScriptResult(WriteSet(cons(DataEntry(RESERVATIONKEY, ValidateAndIncreaseReservedAmt(winAmt)), cons(DataEntry(GAMESCOUNTERKEY, newGameNum), cons(DataEntry(gameId, gameDataStr), nil)))), TransferSet(cons(ScriptTransfer(SERVER, COMMISSION, unit), nil)))
                    }
    }

സ്മാർട്ട് കരാറിന്റെ അവസ്ഥയിലേക്ക് ഫംഗ്ഷൻ ഒരു പുതിയ ഗെയിം എഴുതുന്നു. അതായത്:

• ഒരു പുതിയ ഗെയിമിനുള്ള അദ്വിതീയ ഐഡന്റിഫയർ (ഗെയിം ഐഡി)
• ഗെയിം നില = സമർപ്പിച്ചു
• കളിക്കാരന്റെ തിരഞ്ഞെടുപ്പ് (സെഗ്‌മെന്റ് ദൈർഘ്യം 50)
• പൊതു കീ
• സാധ്യതയുള്ള വിജയങ്ങൾ (കളിക്കാരന്റെ പന്തയത്തെ ആശ്രയിച്ച്)

ബ്ലോക്ക്‌ചെയിനിലെ ഒരു ഡാറ്റ റെക്കോർഡ് ഇങ്ങനെയാണ് (കീ മൂല്യം):

{
    "type": "string",
    "value": "03WON_0283_448t8Jn9P3717UnXFEVD5VWjfeGE5gBNeWg58H2aJeQEgJ_06574069_09116020000_0229",
    "key": "2GKTX6NLTgUrE4iy9HtpSSHpZ3G8W4cMfdjyvvnc21dx"
  }

"കീ" (കീ) - ഗെയിം ഐഡി പുതിയ ഗെയിം. ശേഷിക്കുന്ന ഡാറ്റ "മൂല്യം" ഫീൽഡിന്റെ വരിയിൽ അടങ്ങിയിരിക്കുന്നു. ഈ എൻട്രികൾ ടാബിൽ സംഭരിച്ചിരിക്കുന്നു ഡാറ്റ മികച്ച കരാർ:

5. സെർവർ സ്‌മാർട്ട് കോൺട്രാക്‌റ്റിലേക്ക് നോക്കുകയും ബ്ലോക്ക്ചെയിൻ Api ഉപയോഗിച്ച് അയച്ച ഇടപാട് (പുതിയ ഗെയിം) കണ്ടെത്തുകയും ചെയ്യുന്നു. പുതിയ ഗെയിമിന്റെ ഗെയിം ഐഡി ബ്ലോക്ക്‌ചെയിനിൽ ഇതിനകം രേഖപ്പെടുത്തിയിട്ടുണ്ട്, അതിനർത്ഥം അത് ഇനി മാറ്റാനോ സ്വാധീനിക്കാനോ കഴിയില്ല എന്നാണ്.

6. സെർവർ ഒരു പിൻവലിക്കൽ പ്രവർത്തനം (ഗെയിംഐഡി, ആർഎസ്എസൈൻ) സൃഷ്ടിക്കുന്നു. ഉദാഹരണത്തിന്, ഇതുപോലെ:

withdraw ("FwsuaaShC6DMWdSWQ5osGWtYkVbTEZrsnxqDbVx5oUpq", "base64:Gy69dKdmXUEsAmUrpoWxDLTQOGj5/qO8COA+QjyPVYTAjxXYvEESJbSiCSBRRCOAliqCWwaS161nWqoTL/TltiIvw3nKyd4RJIBNSIgEWGM1tEtNwwnRwSVHs7ToNfZ2Dvk/GgPUqLFDSjnRQpTHdHUPj9mQ8erWw0r6cJXrzfcagKg3yY/0wJ6AyIrflR35mUCK4cO7KumdvC9Mx0hr/ojlHhN732nuG8ps4CUlRw3CkNjNIajBUlyKQwpBKmmiy3yJa/QM5PLxqdppmfFS9y0sxgSlfLOgZ51xRDYuS8NViOA7c1JssH48ZtDbBT5yqzRJXs3RnmZcMDr/q0x6Bg==")

7. സ്‌മാർട്ട് കരാറിലേക്ക് സെർവർ ഒരു ഇൻവോക്കേഷൻ ഇടപാട് അയയ്‌ക്കുന്നു (ബ്രോഡ്‌കാസ്റ്റ് InvocationTx). ഇടപാടിൽ രൂപീകരിച്ച പിൻവലിക്കൽ ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു കോൾ അടങ്ങിയിരിക്കുന്നു (ഗെയിംഐഡി, rsaSign):

ചടങ്ങിൽ അടങ്ങിയിരിക്കുന്നു ഗെയിം ഐഡി പുതിയ ഗെയിമും ഒരു സ്വകാര്യ കീ ഉപയോഗിച്ച് ഒരു അദ്വിതീയ ഐഡന്റിഫയറിന്റെ RSA ഒപ്പിട്ടതിന്റെ ഫലവും. ഒപ്പ് ഫലം മാറ്റമില്ല.

ഇത് എന്താണ് അർത്ഥമാക്കുന്നത്?

ഞങ്ങൾ അതേ മൂല്യം (ഗെയിം ഐഡി) എടുക്കുകയും അതിൽ RSA സിഗ്നേച്ചർ രീതി പ്രയോഗിക്കുകയും ചെയ്യുന്നു. ഞങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഒരേ ഫലം ലഭിക്കും. RSA അൽഗോരിതം പ്രവർത്തിക്കുന്നത് ഇങ്ങനെയാണ്. ഗെയിം ഐഡിയും RSA പ്രയോഗിച്ചതിന്റെ ഫലവും അറിയാത്തതിനാൽ, അവസാന നമ്പർ കൃത്രിമമാക്കാൻ കഴിയില്ല. ഒരു നമ്പർ തിരഞ്ഞെടുക്കുന്നതും അർത്ഥശൂന്യമാണ്.

8. ബ്ലോക്ക്ചെയിൻ ഇടപാട് സ്വീകരിക്കുന്നു. ഇത് പിൻവലിക്കൽ ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കുന്നു (ഗെയിംഐഡി, ആർഎസ്എസൈൻ)

9. പിൻവലിക്കൽ പ്രവർത്തനത്തിനുള്ളിൽ, പിൻവലിക്കൽ സംഭവിക്കുന്നു RandInt ഫംഗ്‌ഷനുകൾ ജനറേറ്റ് ചെയ്യുക (ഗെയിംഐഡി, ആർഎസ്എസൈൻ). ഇതൊരു റാൻഡം നമ്പർ ജനറേറ്ററാണ്

# @return 1 ... 100
func GenerateRandInt (gameId,rsaSign) = {
   	# verify RSA signature to proof random
    let rsaSigValid = rsaVerify (SHA256, toBytes(gameId), rsaSign, RSAPUBLIC)
    if (rsaSigValid)
        then {
            let rand = (toInt(sha256(rsaSign)) % 100)
            if ((0 > rand))
                then ((-1 * rand) + 1)
                else (rand + 1)
            }
        else throw ("Invalid RSA signature")
    }

റാൻഡ് - കൂടാതെ ഒരു റാൻഡം നമ്പർ ഉണ്ട്.

ആദ്യം, സ്ട്രിംഗ് എടുക്കുന്നു, ഇത് RSA ഒപ്പിന്റെ ഫലമാണ് ഗെയിം ഐഡി സ്വകാര്യ കീ (rsaSign). തുടർന്ന് SHA-256 ഉപയോഗിച്ച് ഹാഷ് ചെയ്തു (sha256(rsaSign)).

ഒപ്പിന്റെയും തുടർന്നുള്ള ഹാഷിംഗിന്റെയും ഫലം പ്രവചിക്കാൻ ഞങ്ങൾക്ക് കഴിയില്ല. അതിനാൽ, ഒരു ക്രമരഹിത സംഖ്യയുടെ ജനറേഷനെ സ്വാധീനിക്കുക അസാധ്യമാണ്. ഒരു നിശ്ചിത ശ്രേണിയിൽ ഒരു നമ്പർ ലഭിക്കുന്നതിന് (ഉദാഹരണത്തിന്, 1 മുതൽ 100 ​​വരെ), toInt കൺവേർഷൻ ഫംഗ്‌ഷനും % 100 (ഇതിന് സമാനമായത് എതിരായി).

ലേഖനത്തിന്റെ തുടക്കത്തിൽ ഞങ്ങൾ പ്രവർത്തനത്തെക്കുറിച്ച് പരാമർശിച്ചു rsaVerify(), ഇത് ഒരു പൊതു കീ ഉപയോഗിച്ച് ഒരു RSA ഒപ്പിന്റെ സാധുത പരിശോധിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. GenerateRandInt(gameId,rsaSign) ഭാഗം ഇതാ:

rsaVerify (SHA256, toBytes(gameId), rsaSign, RSAPUBLIC)

RSAPUBLIC എന്ന പൊതു കീയും rsaSign സ്ട്രിംഗും ഇൻപുട്ടിലേക്ക് കൈമാറുന്നു. ഒപ്പ് സാധുത പരിശോധിക്കുന്നു. പരിശോധന വിജയിച്ചാൽ നമ്പർ ജനറേറ്റ് ചെയ്യപ്പെടും. അല്ലെങ്കിൽ, സിഗ്നേച്ചർ സാധുവല്ലെന്ന് സിസ്റ്റം കരുതുന്നു (അസാധുവായ RSA ഒപ്പ്).

സെർവർ ഗെയിം ഐഡിയിൽ ഒരു സ്വകാര്യ കീ ഉപയോഗിച്ച് ഒപ്പിടുകയും 2880 ബ്ലോക്കുകൾക്കുള്ളിൽ സാധുവായ ഒരു Rsa ഒപ്പ് അയയ്ക്കുകയും വേണം. സ്‌മാർട്ട് കരാർ വിന്യസിക്കുമ്പോൾ പരാമീറ്റർ കോൺഫിഗർ ചെയ്‌തിരിക്കുന്നു. അനുവദിച്ച സമയത്തിനുള്ളിൽ ഒന്നും സംഭവിച്ചില്ലെങ്കിൽ, ഉപയോക്താവ് വിജയിക്കും. ഈ സാഹചര്യത്തിൽ, സമ്മാനം നിങ്ങളുടെ വിലാസത്തിലേക്ക് അയയ്ക്കണം. "സെർവറിന് വഞ്ചിക്കുന്നത് ലാഭകരമല്ല" എന്ന് ഇത് മാറുന്നു, കാരണം ഇത് നഷ്ടത്തിലേക്ക് നയിക്കുന്നു. താഴെ ഒരു ഉദാഹരണം.

ഉപയോക്താവ് കളിക്കുന്നു ഡൈസ് റോളർ. ഞാൻ ക്യൂബിന്റെ 2 വശങ്ങളിൽ 6 എണ്ണം തിരഞ്ഞെടുത്തു, പന്തയം 14 തരംഗങ്ങളാണ്. നിശ്ചിത സമയത്തിനുള്ളിൽ (2880 ബ്ലോക്കുകൾ) സ്മാർട്ട് കരാറിലേക്ക് സെർവർ സാധുവായ RSA ഒപ്പ് അയച്ചില്ലെങ്കിൽ, ഉപയോക്താവ് 34.44 തരംഗങ്ങൾ എടുക്കും.

ഗെയിമുകളിൽ നമ്പറുകൾ സൃഷ്ടിക്കുന്നതിന്, ഞങ്ങൾ ഒരു ഒറാക്കിൾ ഉപയോഗിക്കുന്നു - ഒരു ബാഹ്യ, നോൺ-ബ്ലോക്ക്ചെയിൻ സിസ്റ്റം. ഗെയിം ഐഡിയുടെ RSA ഒപ്പ് സെർവർ നിർവഹിക്കുന്നു. സ്മാർട്ട് കരാർ ഒപ്പിന്റെ സാധുത പരിശോധിച്ച് വിജയിയെ നിർണ്ണയിക്കുന്നു. സെർവർ ഒന്നും അയച്ചില്ലെങ്കിൽ, ഉപയോക്താവ് യാന്ത്രികമായി വിജയിക്കും.

ഇത് ഒരു സത്യസന്ധമായ ജനറേഷൻ രീതിയാണ്, കാരണം കൃത്രിമം സാങ്കേതികമായി അസാധ്യമാണ്. എല്ലാ Tradisys ഗെയിമുകളും വിവരിച്ച അൽഗോരിതം അടിസ്ഥാനമാക്കി പ്രവർത്തിക്കുന്നു. ബ്ലോക്ക്ചെയിൻ ഗെയിമുകൾ ഇങ്ങനെയാണ് പ്രവർത്തിക്കുന്നത്. എല്ലാം സുതാര്യവും പരിശോധിക്കാവുന്നതുമാണ്. മറ്റേതെങ്കിലും ബ്ലോക്ക്ചെയിനിൽ അത്തരമൊരു സിസ്റ്റത്തിന്റെ അനലോഗ് ഇല്ല. ഇതൊരു ന്യായമായ യാദൃശ്ചികതയാണ്.

അവലംബം: www.habr.com