ബ്ലോക്ക്ചെയിനിലെ ഒരു വികേന്ദ്രീകൃത മെസഞ്ചർ എങ്ങനെയാണ് പ്രവർത്തിക്കുന്നത്?

2017-ന്റെ തുടക്കത്തിൽ, ക്ലാസിക് P2P മെസഞ്ചറുകളേക്കാൾ ഗുണങ്ങൾ ചർച്ച ചെയ്തുകൊണ്ട് ബ്ലോക്ക്ചെയിനിൽ [പേരും ലിങ്കും പ്രൊഫൈലിൽ ഉണ്ട്] ഞങ്ങൾ ഒരു മെസഞ്ചർ സൃഷ്ടിക്കാൻ തുടങ്ങി.

കടന്നുപോയി 2.5 വർഷം, ഞങ്ങളുടെ ആശയം സ്ഥിരീകരിക്കാൻ ഞങ്ങൾക്ക് കഴിഞ്ഞു: iOS, Web PWA, Windows, GNU/Linux, Mac OS, Android എന്നിവയ്‌ക്ക് ഇപ്പോൾ മെസഞ്ചർ ആപ്ലിക്കേഷനുകൾ ലഭ്യമാണ്.

ബ്ലോക്ക്‌ചെയിൻ മെസഞ്ചർ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും ക്ലയന്റ് ആപ്ലിക്കേഷനുകൾക്ക് അതിന്റെ API ഉപയോഗിച്ച് എങ്ങനെ പ്രവർത്തിക്കാമെന്നും ഇന്ന് ഞങ്ങൾ നിങ്ങളോട് പറയും.


ക്ലാസിക് P2P മെസഞ്ചറുകളുടെ സുരക്ഷാ, സ്വകാര്യത പ്രശ്‌നങ്ങൾ ബ്ലോക്ക്‌ചെയിൻ പരിഹരിക്കാൻ ഞങ്ങൾ ആഗ്രഹിച്ചു:

• ഒരു അക്കൗണ്ട് സൃഷ്‌ടിക്കാൻ ഒറ്റ ക്ലിക്ക് - ഫോണുകളോ ഇമെയിലുകളോ ഇല്ല, വിലാസ പുസ്‌തകങ്ങളിലേക്കോ ജിയോലൊക്കേഷനുകളിലേക്കോ പ്രവേശനമില്ല.
• ഇന്റർലോക്കുട്ടർമാർ ഒരിക്കലും നേരിട്ടുള്ള കണക്ഷനുകൾ സ്ഥാപിക്കുന്നില്ല; എല്ലാ ആശയവിനിമയങ്ങളും നോഡുകളുടെ വിതരണം ചെയ്ത സംവിധാനത്തിലൂടെയാണ് നടക്കുന്നത്. ഉപയോക്താക്കളുടെ IP വിലാസങ്ങൾ പരസ്പരം ആക്സസ് ചെയ്യാൻ കഴിയില്ല.
• എല്ലാ സന്ദേശങ്ങളും എൻഡ്-ടു-എൻഡ് കർവ്25519xsalsa20poly1305 എൻക്രിപ്റ്റ് ചെയ്തിരിക്കുന്നു. ഇത് ആരെയും അത്ഭുതപ്പെടുത്തില്ലെന്ന് തോന്നുന്നു, പക്ഷേ ഞങ്ങളുടെ സോഴ്സ് കോഡ് തുറന്നിരിക്കുന്നു.
• MITM ആക്രമണം ഒഴിവാക്കിയിരിക്കുന്നു - ഓരോ സന്ദേശവും ഒരു ഇടപാടാണ്, ഒപ്പിട്ടിരിക്കുന്നത് Ed25519 EdDSA ആണ്.
• സന്ദേശം അതിന്റെ സ്വന്തം ബ്ലോക്കിൽ അവസാനിക്കുന്നു. സ്ഥിരതയും timestamp നിങ്ങൾക്ക് ബ്ലോക്കുകൾ പരിഹരിക്കാൻ കഴിയില്ല, അതിനാൽ സന്ദേശങ്ങളുടെ ക്രമം.
• "ഞാൻ അത് പറഞ്ഞില്ല" എന്നത് ബ്ലോക്ക്ചെയിനിലെ സന്ദേശങ്ങളിൽ പ്രവർത്തിക്കില്ല.
• ഒരു സന്ദേശത്തിന്റെ "ആധികാരികത" പരിശോധിക്കുന്ന ഒരു കേന്ദ്ര ഘടനയും ഇല്ല. സമവായത്തെ അടിസ്ഥാനമാക്കിയുള്ള നോഡുകളുടെ വിതരണം ചെയ്ത സംവിധാനമാണ് ഇത് ചെയ്യുന്നത്, ഇത് ഉപയോക്താക്കളുടെ ഉടമസ്ഥതയിലുള്ളതാണ്.
• സെൻസർഷിപ്പിന്റെ അസാധ്യത - അക്കൗണ്ടുകൾ തടയാനും സന്ദേശങ്ങൾ ഇല്ലാതാക്കാനും കഴിയില്ല.
• എസ്എംഎസ് വഴിയുള്ള നരകതുല്യമായ 2FA യ്ക്ക് പകരമാണ് ബ്ലോക്ക്ചെയിൻ 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 ആയി പരിവർത്തനം ചെയ്യണം.

ജാവാസ്ക്രിപ്റ്റിലെ ഒരു ഉദാഹരണം ഇതാ:

/**
 * 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, ഇടപാട് ഐഡി 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'

പ്രതികരണമായി ഞങ്ങൾക്ക് ഇത്തരത്തിലുള്ള ഒരു ഇടപാട് ഐഡി ലഭിക്കും

{
    "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 സെക്കൻഡിനുള്ളിൽ സന്ദേശങ്ങൾ ഈ രീതിയിൽ ഡെലിവർ ചെയ്യുന്നതിനാൽ - ഒരു പുതിയ നെറ്റ്‌വർക്ക് ബ്ലോക്ക് ദൃശ്യമാകുന്ന സമയമാണിത് - ഞങ്ങൾ ഒരു ക്ലയന്റ്-ടു-നോഡ്, നോഡ്-ടു-നോഡ് സോക്കറ്റ് കണക്ഷനുമായി എത്തി. ഒരു നോഡിന് ഒരു പുതിയ ഇടപാട് ലഭിക്കുമ്പോൾ, അത് അതിന്റെ സാധുത പരിശോധിക്കുകയും മറ്റ് നോഡുകളിലേക്ക് കൈമാറുകയും ചെയ്യുന്നു. സമവായം ഉണ്ടാകുന്നതിനും ബ്ലോക്കിൽ ഉൾപ്പെടുത്തുന്നതിനും മുമ്പുതന്നെ ഇടപാട് മെസഞ്ചർ ക്ലയന്റുകൾക്ക് ലഭ്യമാണ്. ഇതുവഴി സാധാരണ തൽക്ഷണ സന്ദേശവാഹകരെ പോലെ ഞങ്ങൾ തൽക്ഷണം സന്ദേശങ്ങൾ കൈമാറും.

വിലാസ പുസ്തകം സംഭരിക്കുന്നതിന്, ഞങ്ങൾ കെവിഎസ് ഉണ്ടാക്കി - കീ-വാല്യൂ സ്റ്റോറേജ് - ഇത് മറ്റൊരു തരത്തിലുള്ള ഇടപാടാണ്. asset ഇത് എൻക്രിപ്റ്റ് ചെയ്തിരിക്കുന്നത് NaCl-box അല്ല, മറിച്ച് NaCl-രഹസ്യപ്പെട്ടി. ഇങ്ങനെയാണ് മെസഞ്ചർ മറ്റ് ഡാറ്റ സംഭരിക്കുന്നത്.

ഫയൽ/ചിത്ര കൈമാറ്റങ്ങൾക്കും ഗ്രൂപ്പ് ചാറ്റുകൾക്കും ഇപ്പോഴും വളരെയധികം ജോലി ആവശ്യമാണ്. തീർച്ചയായും, ബ്ലണ്ടർ ആൻഡ് ബ്ലണ്ടർ ഫോർമാറ്റിൽ ഇത് പെട്ടെന്ന് "സ്ക്രീഡ് അപ്പ്" ചെയ്യാൻ കഴിയും, എന്നാൽ അതേ നിലവാരത്തിലുള്ള സ്വകാര്യത നിലനിർത്താൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.

അതെ, ഇനിയും ചെയ്യാനുണ്ട് - യഥാർത്ഥ സ്വകാര്യത ഉപയോക്താക്കൾ പൊതു നെറ്റ്‌വർക്ക് നോഡുകളിലേക്ക് കണക്റ്റുചെയ്യില്ല, എന്നാൽ അവരുടേത് ഉയർത്തും. എത്ര ശതമാനം ഉപയോക്താക്കളാണ് ഇത് ചെയ്യുന്നതെന്ന് നിങ്ങൾ കരുതുന്നു? അത് ശരിയാണ്, 0. മെസഞ്ചറിന്റെ ടോർ പതിപ്പ് ഉപയോഗിച്ച് ഈ പ്രശ്നം ഭാഗികമായി പരിഹരിക്കാൻ ഞങ്ങൾക്ക് കഴിഞ്ഞു.

ബ്ലോക്ക്ചെയിനിൽ ഒരു മെസഞ്ചർ നിലനിൽക്കുമെന്ന് ഞങ്ങൾ തെളിയിച്ചു. മുമ്പ്, 2012 ൽ ഒരു ശ്രമം മാത്രമേ ഉണ്ടായിരുന്നുള്ളൂ - ബിറ്റ്മെസേജ്, ദൈർഘ്യമേറിയ സന്ദേശ വിതരണ സമയം, സിപിയു ലോഡ്, മൊബൈൽ ആപ്ലിക്കേഷനുകളുടെ അഭാവം എന്നിവ കാരണം ഇത് പരാജയപ്പെട്ടു.

ബ്ലോക്ക്‌ചെയിനിലെ സന്ദേശവാഹകർ അവരുടെ സമയത്തിന് മുന്നിലാണെന്ന വസ്തുതയാണ് സംശയത്തിന് കാരണം - ആളുകൾ അവരുടെ അക്കൗണ്ടിന്റെ ഉത്തരവാദിത്തം ഏറ്റെടുക്കാൻ തയ്യാറല്ല, വ്യക്തിഗത വിവരങ്ങൾ സ്വന്തമാക്കുന്നത് ഇതുവരെ ഒരു പ്രവണതയല്ല, കൂടാതെ സാങ്കേതികവിദ്യ ബ്ലോക്ക്ചെയിനിൽ ഉയർന്ന വേഗത അനുവദിക്കുന്നില്ല. ഞങ്ങളുടെ പ്രോജക്റ്റിന്റെ കൂടുതൽ സാങ്കേതിക അനലോഗുകൾ അടുത്തതായി ദൃശ്യമാകും. നിങ്ങൾ കാണും.

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