બ્લોકચેન પર RSA રેન્ડમ

એક સમસ્યા છે - વિકેન્દ્રિત નેટવર્કમાં રેન્ડમ નંબર જનરેટ કરવું મુશ્કેલ છે. લગભગ તમામ બ્લોકચેન આનો સામનો કરી ચૂક્યા છે. ખરેખર, નેટવર્ક્સમાં જ્યાં વપરાશકર્તાઓ વચ્ચે કોઈ વિશ્વાસ નથી, નિર્વિવાદ રેન્ડમ નંબર બનાવવાથી ઘણી સમસ્યાઓ હલ થાય છે.

આ લેખમાં અમે તમને કહીએ છીએ કે અમે ઉદાહરણ તરીકે રમતોનો ઉપયોગ કરીને સમસ્યાનું નિરાકરણ કેવી રીતે કર્યું. તેમાંથી પ્રથમ હતો વેવ્ઝ ક્રિસમસ ટ્રી. વિકાસ માટે, અમને રેન્ડમ નંબર જનરેટરની જરૂર હતી.

શરૂઆતમાં, અમે બ્લોકચેનની માહિતીના આધારે નંબર જનરેટ કરવાની યોજના બનાવી હતી. જો કે, તે પછી તે સ્પષ્ટ થઈ ગયું: સંખ્યાની હેરફેર થઈ શકે છે, જેનો અર્થ છે કે ઉકેલ યોગ્ય નથી.

અમે એક ઉપાય લઈને આવ્યા છીએ: કમિટ-વિસ્તૃત યોજનાનો ઉપયોગ કરો. સર્વરે 1 થી 5 સુધીની સંખ્યાનું અનુમાન લગાવ્યું, તેમાં મીઠું ઉમેર્યું અને પછી પરિણામને હેશ કર્યું Keccak કાર્યો. સર્વરે અગાઉથી સાચવેલા નંબર સાથે સ્માર્ટ કોન્ટ્રાક્ટ જમાવ્યો. તે તારણ આપે છે કે હેશ દ્વારા છુપાયેલા નંબરનો અનુમાન લગાવતા વપરાશકર્તાને રમત ઉકળે છે.

ખેલાડીએ શરત લગાવી, અને સર્વરે છુપાયેલ નંબર અને "મીઠું" સ્માર્ટ કોન્ટ્રાક્ટ પર મોકલ્યું. સરળ શબ્દોમાં, તેણે કાર્ડ્સ જાહેર કર્યા. તે પછી, સર્વરે નંબરો તપાસ્યા અને નક્કી કર્યું કે વપરાશકર્તા જીત્યો કે હારી ગયો.

જો સર્વરે ચકાસણી માટે નંબર અથવા "મીઠું" મોકલ્યું ન હતું, તો વપરાશકર્તા જીત્યો. આ કિસ્સામાં, દરેક રમત માટે અગાઉથી સ્માર્ટ કોન્ટ્રાક્ટ ગોઠવવો અને તેમાં સંભવિત જીતનો સમાવેશ કરવો જરૂરી હતો. તે અસુવિધાજનક, સમય માંગી લેતું અને ખર્ચાળ હોવાનું બહાર આવ્યું. તે સમયે બીજો કોઈ સલામત ઉપાય નહોતો.

તાજેતરમાં, Tradisys ટીમે વેવ્સ પ્રોટોકોલમાં ફંક્શન ઉમેરવાનો પ્રસ્તાવ મૂક્યો હતો rsaVerify(). તે જાહેર અને ખાનગી કીના આધારે આરએસએ હસ્તાક્ષરની માન્યતા તપાસે છે. પરિણામે, સુવિધા ઉમેરવામાં આવી હતી.

અમે ત્રણ રમતો વિકસાવી છે: ડાઇસ રોલર, Coin Flip и મોજા પર સવારી. દરેક રેન્ડમ નંબર ટેકનોલોજીનો અમલ કરે છે. ચાલો આકૃતિ કરીએ કે તે કેવી રીતે કાર્ય કરે છે.

ચાલો ઉદાહરણ તરીકે રાઈડ ઓન વેવ્સનો ઉપયોગ કરીને રેન્ડમ નંબર જનરેટ કરવા જોઈએ. સ્માર્ટ કોન્ટ્રાક્ટ મળી શકે છે અહીં.

ટેબ પર જાઓ સ્ક્રિપ્ટ અને પસંદ કરો ડીકમ્પાઇલ. તમે સ્માર્ટ કોન્ટ્રાક્ટ કોડ (ઉર્ફ સ્ક્રિપ્ટ) જોશો.

સ્માર્ટ કોન્ટ્રાક્ટ કોડમાં કાર્યોનો સમૂહ હોય છે. જે @Callable તરીકે ચિહ્નિત થયેલ છે તેનો ઉપયોગ કરીને લોન્ચ કરી શકાય છે આહવાન વ્યવહારો. અમને બે કાર્યોમાં રસ છે: બીઇટી и પાછો ખેંચો:

• ફંક શરત (ખેલાડીની પસંદગી)
• ફંક ઉપાડ (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. સર્વર ઉપાડ કાર્ય (gameId, rsaSign) જનરેટ કરે છે. ઉદાહરણ તરીકે, આની જેમ:

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

7. સર્વર સ્માર્ટ કોન્ટ્રાક્ટ (પ્રસારણ InvocationTx) પર એક ઇન્વોકેશન ટ્રાન્ઝેક્શન મોકલે છે. ટ્રાન્ઝેક્શનમાં રચાયેલા ઉપાડ ફંક્શન (gameId, rsaSign) માટે કૉલનો સમાવેશ થાય છે:

કાર્ય સમાવે છે રમત આઈડી નવી રમત અને ખાનગી કી સાથે અનન્ય ઓળખકર્તા પર RSA હસ્તાક્ષરનું પરિણામ. સહી પરિણામ અપરિવર્તિત છે.

આનો અર્થ શું છે?

અમે સમાન મૂલ્ય (ગેમ આઈડી) લઈએ છીએ અને તેના પર RSA સહી પદ્ધતિ લાગુ કરીએ છીએ. આપણને હંમેશા એ જ પરિણામ મળશે. આ રીતે RSA અલ્ગોરિધમ કામ કરે છે. અંતિમ નંબરની હેરફેર કરી શકાતી નથી, કારણ કે ગેમ આઈડી અને RSA લાગુ કરવાનું પરિણામ જાણીતું નથી. નંબર પસંદ કરવો પણ અર્થહીન છે.

8. બ્લોકચેન વ્યવહાર સ્વીકારે છે. તે ઉપાડ કાર્ય ચલાવે છે (gameId, rsaSign)

9. ઉપાડના કાર્યની અંદર, ઉપાડ થાય છે રેન્ડઇન્ટ ફંક્શન્સ જનરેટ કરો (gameId, rsaSign). આ રેન્ડમ નંબર જનરેટર છે

# @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 હસ્તાક્ષરનું પરિણામ છે રમત આઈડી ખાનગી કી (rsaસાઇન). પછી 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