બ્લોકચેન પર વિકેન્દ્રિત મેસેન્જર કેવી રીતે કાર્ય કરે છે?

2017 ની શરૂઆતમાં, અમે ક્લાસિક P2P મેસેન્જર્સ પરના ફાયદાઓની ચર્ચા કરીને બ્લોકચેન [નામ અને લિંક પ્રોફાઇલમાં છે] પર મેસેન્જર બનાવવાનું શરૂ કર્યું.

પાસ થયા 2.5 વર્ષ, અને અમે અમારા ખ્યાલની પુષ્ટિ કરવામાં સક્ષમ હતા: મેસેન્જર એપ્લિકેશન હવે iOS, Web PWA, Windows, GNU/Linux, Mac OS અને Android માટે ઉપલબ્ધ છે.

આજે અમે તમને જણાવીશું કે બ્લોકચેન મેસેન્જર કેવી રીતે કામ કરે છે અને ક્લાયંટ એપ્લીકેશન તેના API સાથે કેવી રીતે કામ કરી શકે છે.


અમે ઇચ્છીએ છીએ કે બ્લોકચેન ક્લાસિક P2P મેસેન્જર્સની સુરક્ષા અને ગોપનીયતાના મુદ્દાઓને હલ કરે:

• એકાઉન્ટ બનાવવા માટે એક ક્લિક - કોઈ ફોન અથવા ઈમેલ નહીં, સરનામાં પુસ્તકો અથવા ભૌગોલિક સ્થાનોની ઍક્સેસ નહીં.
• ઇન્ટરલોક્યુટર્સ ક્યારેય સીધા જોડાણો સ્થાપિત કરતા નથી; તમામ સંચાર ગાંઠોની વિતરિત સિસ્ટમ દ્વારા થાય છે. વપરાશકર્તાઓના IP સરનામાં એકબીજાને ઍક્સેસિબલ નથી.
• બધા સંદેશાઓ Encrypted End-to-End curve25519xsalsa20poly1305 છે. એવું લાગે છે કે આનાથી કોઈને આશ્ચર્ય થશે નહીં, પરંતુ અમારો સ્રોત કોડ ખુલ્લો છે.
• MITM હુમલાને બાકાત રાખવામાં આવ્યો છે - દરેક સંદેશ એક વ્યવહાર છે અને તે Ed25519 EdDSA દ્વારા સહી થયેલ છે.
• સંદેશ તેના પોતાના બ્લોકમાં સમાપ્ત થાય છે. સુસંગતતા અને timestamp તમે બ્લોક્સને ઠીક કરી શકતા નથી, અને તેથી સંદેશાઓનો ક્રમ.
• "મેં કહ્યું નથી કે" બ્લોકચેન પરના સંદેશાઓ સાથે કામ કરશે નહીં.
• ત્યાં કોઈ કેન્દ્રીય માળખું નથી કે જે સંદેશની "પ્રમાણિકતા" તપાસે. આ સર્વસંમતિ પર આધારિત નોડ્સની વિતરિત સિસ્ટમ દ્વારા કરવામાં આવે છે, અને તે વપરાશકર્તાઓની માલિકીની છે.
• સેન્સરશીપની અશક્યતા - એકાઉન્ટ્સ અવરોધિત કરી શકાતા નથી અને સંદેશા કાઢી શકાતા નથી.
• બ્લોકચેન 2FA એ SMS દ્વારા નરક 2FA નો વિકલ્પ છે, ઘણું સ્વાસ્થ્ય બગાડ્યું.
• કોઈપણ સમયે કોઈપણ ઉપકરણમાંથી તમારી બધી વાતચીતો મેળવવાની ક્ષમતાનો અર્થ છે કે તમારે વાર્તાલાપને સ્થાનિક રૂપે સંગ્રહિત કરવાની જરૂર નથી.
• સંદેશ વિતરણની પુષ્ટિ. વપરાશકર્તાના ઉપકરણ પર નહીં, પરંતુ નેટવર્ક પર. આવશ્યકપણે, આ તમારો સંદેશ વાંચવાની પ્રાપ્તકર્તાની ક્ષમતાની પુષ્ટિ છે. નિર્ણાયક સૂચનાઓ મોકલવા માટે આ એક ઉપયોગી સુવિધા છે.

બ્લોકચેન લાભોમાં ક્રિપ્ટોકરન્સી Ethereum, Dogecoin, Lisk, Dash, Bitcoin (આ હજુ ચાલુ છે) અને ચેટમાં ટોકન્સ મોકલવાની ક્ષમતા સાથે ગાઢ એકીકરણનો પણ સમાવેશ થાય છે. અમે બિલ્ટ-ઇન ક્રિપ્ટો એક્સ્ચેન્જર પણ બનાવ્યું છે.

અને પછી - તે બધું કેવી રીતે કાર્ય કરે છે.

સંદેશ એ એક વ્યવહાર છે

દરેક વ્યક્તિ પહેલાથી જ એ હકીકતથી ટેવાયેલું છે કે બ્લોકચેનમાં વ્યવહારો ટોકન્સ (સિક્કા) એક વપરાશકર્તાથી બીજામાં ટ્રાન્સફર કરે છે. બિટકોઈનની જેમ. અમે સંદેશાઓ ટ્રાન્સમિટ કરવા માટે એક ખાસ પ્રકારનો વ્યવહાર બનાવ્યો છે.

બ્લોકચેન પર મેસેન્જરમાં સંદેશ મોકલવા માટે, તમારે ઘણા પગલાઓમાંથી પસાર થવાની જરૂર છે:

1. સંદેશ ટેક્સ્ટ એન્ક્રિપ્ટ કરો
2. ટ્રાન્ઝેક્શનમાં સિફરટેક્સ્ટ મૂકો
3. વ્યવહાર પર સહી કરો
4. કોઈપણ નેટવર્ક નોડ પર વ્યવહાર મોકલો
5. નોડ્સની વિતરિત સિસ્ટમ સંદેશની "અધિકૃતતા" નક્કી કરે છે
6. જો બધું બરાબર છે, તો સંદેશ સાથેનો વ્યવહાર આગામી બ્લોકમાં શામેલ છે
7. પ્રાપ્તકર્તા સંદેશ વ્યવહાર પુનઃપ્રાપ્ત કરે છે અને ડિક્રિપ્ટ કરે છે

સ્ટેપ 1–3 અને 7 ક્લાઈન્ટ પર સ્થાનિક રીતે કરવામાં આવે છે, અને સ્ટેપ 5–6 હોસ્ટ પર કરવામાં આવે છે.

સંદેશ એન્ક્રિપ્શન

સંદેશ પ્રેષકની ખાનગી કી અને પ્રાપ્તકર્તાની સાર્વજનિક કી સાથે એનક્રિપ્ટ થયેલ છે. અમે નેટવર્કમાંથી સાર્વજનિક કી લઈશું, પરંતુ આ માટે, પ્રાપ્તકર્તાનું ખાતું શરૂ કરવું આવશ્યક છે, એટલે કે, ઓછામાં ઓછું એક વ્યવહાર હોવો જોઈએ. તમે REST વિનંતીનો ઉપયોગ કરી શકો છો GET /api/accounts/getPublicKey?address={ADAMANT address}, અને ચેટ્સ લોડ કરતી વખતે, ઇન્ટરલોક્યુટર્સની સાર્વજનિક કીઓ પહેલેથી જ ઉપલબ્ધ હશે.

મેસેન્જર curve25519xsalsa20poly1305 અલ્ગોરિધમનો ઉપયોગ કરીને સંદેશાઓને એન્ક્રિપ્ટ કરે છે (NaCl બોક્સ). એકાઉન્ટમાં Ed25519 કીઝ હોવાથી, બોક્સ બનાવવા માટે, કીને પહેલા Curve25519 Diffie-Hellman માં રૂપાંતરિત કરવી આવશ્યક છે.

અહીં JavaScript માં એક ઉદાહરણ છે:

/**
 * Encodes a text message for sending to ADM
 * @param {string} msg message to encode
 * @param {*} recipientPublicKey recipient's public key
 * @param {*} privateKey our private key
 * @returns {{message: string, nonce: string}}
 */
adamant.encodeMessage = function (msg, recipientPublicKey, privateKey) {
  const nonce = Buffer.allocUnsafe(24)
  sodium.randombytes(nonce)

  if (typeof recipientPublicKey === 'string') {
    recipientPublicKey = hexToBytes(recipientPublicKey)
  }

  const plainText = Buffer.from(msg)
  const DHPublicKey = ed2curve.convertPublicKey(recipientPublicKey)
  const DHSecretKey = ed2curve.convertSecretKey(privateKey)

  const encrypted = nacl.box(plainText, nonce, DHPublicKey, DHSecretKey)

  return {
    message: bytesToHex(encrypted),
    nonce: bytesToHex(nonce)
  }
}

સંદેશ સાથે વ્યવહારની રચના

વ્યવહારમાં નીચેની સામાન્ય રચના છે:

{
  "id": "15161295239237781653",
  "height": 7585271,
  "blockId": "16391508373936326027",
  "type": 8,
  "block_timestamp": 45182260,
  "timestamp": 45182254,
  "senderPublicKey": "bd39cc708499ae91b937083463fce5e0668c2b37e78df28f69d132fce51d49ed",
  "senderId": "U16023712506749300952",
  "recipientId": "U17653312780572073341",
  "recipientPublicKey": "23d27f616e304ef2046a60b762683b8dabebe0d8fc26e5ecdb1d5f3d291dbe21",
  "amount": 204921300000000,
  "fee": 50000000,
  "signature": "3c8e551f60fedb81e52835c69e8b158eb1b8b3c89a04d3df5adc0d99017ffbcb06a7b16ad76d519f80df019c930960317a67e8d18ab1e85e575c9470000cf607",
  "signatures": [],
  "confirmations": 3660548,
  "asset": {}
}

સંદેશ વ્યવહાર માટે, સૌથી મહત્વની બાબત છે asset - તમારે ઑબ્જેક્ટમાં સંદેશ મૂકવાની જરૂર છે chat બંધારણ સાથે:

• message - એન્ક્રિપ્ટેડ સંદેશ સાચવો
• own_message - નોન્સ
• type - સંદેશનો પ્રકાર

સંદેશાઓ પણ પ્રકારોમાં વહેંચાયેલા છે. આવશ્યકપણે, પરિમાણ type તમને કેવી રીતે સમજવું તે કહે છે message. તમે ફક્ત એક ટેક્સ્ટ મોકલી શકો છો, અથવા તમે અંદરની રસપ્રદ વસ્તુઓ સાથે ઑબ્જેક્ટ મોકલી શકો છો - ઉદાહરણ તરીકે, આ રીતે મેસેન્જર ચેટ્સમાં ક્રિપ્ટોકરન્સી ટ્રાન્સફર કરે છે.

પરિણામે, અમે એક વ્યવહાર બનાવીએ છીએ:

{
  "transaction": {
    "type": 8,
    "amount": 0,
    "senderId": "U12499126640447739963",
    "senderPublicKey": "e9cafb1e7b403c4cf247c94f73ee4cada367fcc130cb3888219a0ba0633230b6",
    "asset": {
      "chat": {
        "message": "cb682accceef92d7cddaaddb787d1184ab5428",
        "own_message": "e7d8f90ddf7d70efe359c3e4ecfb5ed3802297b248eacbd6",
        "type": 1
      }
    },
    "recipientId": "U15677078342684640219",
    "timestamp": 63228087,
    "signature": "тут будет подпись"
  }
}

વ્યવહાર સહી

દરેક વ્યક્તિને પ્રેષક અને પ્રાપ્તકર્તાની અધિકૃતતા, મોકલવાનો સમય અને સંદેશની સામગ્રીમાં વિશ્વાસ છે તેની ખાતરી કરવા માટે, વ્યવહાર પર હસ્તાક્ષર કરવામાં આવે છે. ડિજિટલ હસ્તાક્ષર તમને સાર્વજનિક કીનો ઉપયોગ કરીને વ્યવહારની અધિકૃતતા ચકાસવાની મંજૂરી આપે છે - આ માટે ખાનગી કીની જરૂર નથી.

પરંતુ હસ્તાક્ષર પોતે ખાનગી કીનો ઉપયોગ કરીને કરવામાં આવે છે:

ડાયાગ્રામ બતાવે છે કે આપણે સૌ પ્રથમ SHA-256 સાથે ટ્રાન્ઝેક્શન હેશ કરીએ છીએ અને પછી તેના પર સહી કરીએ છીએ Ed25519 EdDSA અને સહી મેળવો signature, અને વ્યવહાર ID SHA-256 હેશનો ભાગ છે.

ઉદાહરણ અમલીકરણ:

1 — સંદેશ સહિત ડેટા બ્લોક બનાવો

/**
 * Calls `getBytes` based on transaction type
 * @see privateTypes
 * @implements {ByteBuffer}
 * @param {transaction} trs
 * @param {boolean} skipSignature
 * @param {boolean} skipSecondSignature
 * @return {!Array} Contents as an ArrayBuffer.
 * @throws {error} If buffer fails.
 */

adamant.getBytes = function (transaction) {

  ...

  switch (transaction.type) {
    case constants.Transactions.SEND:
      break
    case constants.Transactions.CHAT_MESSAGE:
      assetBytes = this.chatGetBytes(transaction)
      assetSize = assetBytes.length
      break

…

    default:
      alert('Not supported yet')
  }

  var bb = new ByteBuffer(1 + 4 + 32 + 8 + 8 + 64 + 64 + assetSize, true)

  bb.writeByte(transaction.type)
  bb.writeInt(transaction.timestamp)

  ...

  bb.flip()
  var arrayBuffer = new Uint8Array(bb.toArrayBuffer())
  var buffer = []

  for (var i = 0; i < arrayBuffer.length; i++) {
    buffer[i] = arrayBuffer[i]
  }

  return Buffer.from(buffer)
}

2 - ડેટા બ્લોકમાંથી SHA-256 ની ગણતરી કરો

/**
 * Creates hash based on transaction bytes.
 * @implements {getBytes}
 * @implements {crypto.createHash}
 * @param {transaction} trs
 * @return {hash} sha256 crypto hash
 */
adamant.getHash = function (trs) {
  return crypto.createHash('sha256').update(this.getBytes(trs)).digest()
}

3 - વ્યવહાર પર સહી કરો

adamant.transactionSign = function (trs, keypair) {
  var hash = this.getHash(trs)
  return this.sign(hash, keypair).toString('hex')
}

/**
 * Creates a signature based on a hash and a keypair.
 * @implements {sodium}
 * @param {hash} hash
 * @param {keypair} keypair
 * @return {signature} signature
 */
adamant.sign = function (hash, keypair) {
  return sodium.crypto_sign_detached(hash, Buffer.from(keypair.privateKey, 'hex'))
}

નેટવર્ક નોડ પર સંદેશ સાથે વ્યવહાર મોકલી રહ્યું છે

નેટવર્ક વિકેન્દ્રિત હોવાથી, ઓપન API સાથેના કોઈપણ નોડ્સ કરશે. અંતિમ બિંદુ પર POST વિનંતી કરવી api/transactions:

curl 'api/transactions' -X POST 
  -d 'TX_DATA'

જવાબમાં અમને પ્રકારનું ટ્રાન્ઝેક્શન ID પ્રાપ્ત થશે

{
    "success": true,
    "nodeTimestamp": 63228852,
    "transactionId": "6146865104403680934"
}

વ્યવહાર માન્યતા

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

પ્રથમ, એક નોડ ચોકસાઈ તપાસે છે, અને પછી તેને અન્યને મોકલે છે - જો બહુમતી કહે છે કે બધું ક્રમમાં છે, તો વ્યવહાર સાંકળના આગલા બ્લોકમાં શામેલ કરવામાં આવશે - આ સર્વસંમતિ છે.

નોડ કોડનો ભાગ જે તપાસ માટે જવાબદાર છે તે GitHub પર જોઈ શકાય છે - validator.js и verify.js. હા, નોડ Node.js પર ચાલે છે.

બ્લોકમાં સંદેશ સાથેના વ્યવહાર સહિત

જો સર્વસંમતિ પહોંચી જાય, તો અમારા સંદેશ સાથેનો વ્યવહાર અન્ય માન્ય વ્યવહારો સાથે આગામી બ્લોકમાં સામેલ કરવામાં આવશે.

બ્લોક્સમાં કડક ક્રમ હોય છે, અને દરેક અનુગામી બ્લોક અગાઉના બ્લોકના હેશના આધારે રચાય છે.

મુદ્દો એ છે કે અમારો સંદેશ પણ આ ક્રમમાં સમાવિષ્ટ છે અને તેને "પુનઃવ્યવસ્થિત" કરી શકાતો નથી. જો ઘણા સંદેશાઓ બ્લોકમાં આવે છે, તો તેમનો ઓર્ડર દ્વારા નક્કી કરવામાં આવશે timestamp સંદેશાઓ

સંદેશાઓ વાંચી રહ્યા છીએ

મેસેન્જર એપ્લિકેશન બ્લોકચેનમાંથી વ્યવહારો પુનઃપ્રાપ્ત કરે છે જે પ્રાપ્તકર્તાને મોકલવામાં આવે છે. આ માટે અમે એક અંતિમ બિંદુ બનાવ્યું api/chatrooms.

બધા વ્યવહારો દરેક માટે ઉપલબ્ધ છે - તમે એન્ક્રિપ્ટેડ સંદેશા પ્રાપ્ત કરી શકો છો. પરંતુ માત્ર પ્રાપ્તકર્તા જ તેની ખાનગી કી અને પ્રેષકની સાર્વજનિક કીનો ઉપયોગ કરીને ડિક્રિપ્ટ કરી શકે છે:

**
 * Decodes the incoming message
 * @param {any} msg encoded message
 * @param {string} senderPublicKey sender public key
 * @param {string} privateKey our private key
 * @param {any} nonce nonce
 * @returns {string}
 */
adamant.decodeMessage = function (msg, senderPublicKey, privateKey, nonce) {
  if (typeof msg === 'string') {
    msg = hexToBytes(msg)
  }

  if (typeof nonce === 'string') {
    nonce = hexToBytes(nonce)
  }

  if (typeof senderPublicKey === 'string') {
    senderPublicKey = hexToBytes(senderPublicKey)
  }

  if (typeof privateKey === 'string') {
    privateKey = hexToBytes(privateKey)
  }

  const DHPublicKey = ed2curve.convertPublicKey(senderPublicKey)
  const DHSecretKey = ed2curve.convertSecretKey(privateKey)
  const decrypted = nacl.box.open(msg, nonce, DHPublicKey, DHSecretKey)

  return decrypted ? decode(decrypted) : ''
}

અને બીજું શું?

સંદેશાઓ લગભગ 5 સેકન્ડમાં આ રીતે વિતરિત થાય છે - આ તે સમય છે જ્યારે નવો નેટવર્ક બ્લોક દેખાય છે - અમે ક્લાયંટ-ટુ-નોડ અને નોડ-ટુ-નોડ સોકેટ કનેક્શન સાથે આવ્યા છીએ. જ્યારે નોડ નવો ટ્રાન્ઝેક્શન મેળવે છે, ત્યારે તે તેની માન્યતા તપાસે છે અને તેને અન્ય નોડ્સ પર ફોરવર્ડ કરે છે. સર્વસંમતિ થાય અને બ્લોકમાં સમાવેશ થાય તે પહેલાં જ મેસેન્જર ક્લાયન્ટ્સ માટે વ્યવહાર ઉપલબ્ધ છે. આ રીતે અમે નિયમિત ઇન્સ્ટન્ટ મેસેન્જરની જેમ તરત જ સંદેશા પહોંચાડીશું.

એડ્રેસ બુક સ્ટોર કરવા માટે, અમે KVS બનાવ્યું - કી-વેલ્યુ સ્ટોરેજ - આ અન્ય પ્રકારનો વ્યવહાર છે જેમાં asset તે એનક્રિપ્ટેડ NaCl-બોક્સ નથી, પરંતુ NaCl-સિક્રેટબોક્સ. આ રીતે મેસેન્જર અન્ય ડેટાને સ્ટોર કરે છે.

ફાઇલ/ઇમેજ ટ્રાન્સફર અને ગ્રૂપ ચેટ્સ માટે હજુ પણ ઘણું કામ જરૂરી છે. અલબત્ત, ભૂલ-અને-ભૂલના ફોર્મેટમાં આને ઝડપથી "સ્ક્રૂ અપ" કરી શકાય છે, પરંતુ અમે ગોપનીયતાના સમાન સ્તરને જાળવી રાખવા માંગીએ છીએ.

હા, હજી કામ કરવાનું બાકી છે - આદર્શ રીતે, વાસ્તવિક ગોપનીયતા ધારે છે કે વપરાશકર્તાઓ સાર્વજનિક નેટવર્ક નોડ્સ સાથે કનેક્ટ થશે નહીં, પરંતુ તેમના પોતાના ઉભા કરશે. તમારા મતે કેટલા ટકા વપરાશકર્તાઓ આ કરે છે? તે સાચું છે, 0. અમે મેસેન્જરના ટોર સંસ્કરણ સાથે આ સમસ્યાને આંશિક રીતે હલ કરવામાં સક્ષમ હતા.

અમે સાબિત કર્યું છે કે બ્લોકચેન પર મેસેન્જર અસ્તિત્વમાં હોઈ શકે છે. અગાઉ, 2012 માં માત્ર એક જ પ્રયાસ હતો - બીટમેસેજ, જે લાંબા મેસેજ ડિલિવરી સમય, CPU લોડ અને મોબાઇલ એપ્લિકેશનના અભાવને કારણે નિષ્ફળ ગયું.

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

સોર્સ: www.habr.com