ProHoster > Blog > Administratioun > Wéi funktionnéiert en dezentraliséierte Messenger op der Blockchain?

Wéi funktionnéiert en dezentraliséierte Messenger op der Blockchain?

Am Ufank vum 2017 hu mir ugefaang e Messenger op der Blockchain ze kreéieren [Numm a Link sinn am Profil] andeems mir d'Virdeeler iwwer klassesch P2P Messenger diskutéieren.

Passéiert 2.5 Joer, a mir konnten eist Konzept bestätegen: Messenger Uwendungen sinn elo fir iOS, Web PWA, Windows, GNU/Linux, Mac OS an Android verfügbar.

Haut wäerte mir Iech soen wéi de Blockchain Messenger funktionnéiert a wéi Client Uwendungen mat senger API funktionnéiere kënnen.
Wéi funktionnéiert en dezentraliséierte Messenger op der Blockchain?

Mir wollten de Blockchain d'Sécherheets- a Privatsphärprobleemer vu klassesche P2P Messenger léisen:

  • Ee Klick fir e Kont ze kreéieren - keng Telefonen oder E-Mailen, keen Zougang zu Adressbicher oder Geolocatiounen.
  • D'Interlocuteuren etabléieren ni direkt Verbindungen; All Kommunikatioun fënnt duerch e verdeelt System vu Wirbelen statt. D'IP Adresse vun de Benotzer sinn net zougänglech fir all aner.
  • All Messagen sinn verschlësselte End-to-End curve25519xsalsa20poly1305. Et schéngt, datt dëst kee wäert iwwerraschen, awer eise Quellcode ass op.
  • MITM Attack ass ausgeschloss - all Message ass eng Transaktioun a gëtt vum Ed25519 EdDSA ënnerschriwwen.
  • De Message endet a sengem eegene Block. Konsistenz an timestamp Dir kënnt d'Blöcke net fixéieren, an dofir d'Uerdnung vun de Messagen.
  • "Ech hunn dat net gesot" funktionnéiert net mat Messagen op der Blockchain.
  • Et gëtt keng zentral Struktur déi d'"Authentizitéit" vun engem Message kontrolléiert. Dëst gëtt gemaach vun engem verdeelt System vun Noden baséiert op Konsens, an et ass am Besëtz vun de Benotzer.
  • Onméiglechkeet vun Zensur - Konte kënnen net blockéiert ginn a Messagen kënnen net geläscht ginn.
  • Blockchain 2FA ass eng Alternativ zum helleschen 2FA iwwer SMS, vill Gesondheet ruinéiert.
  • D'Kapazitéit fir all Är Gespréicher vun all Apparat zu all Moment ze kréien heescht datt Dir guer keng Gespréicher lokal muss späicheren.
  • Bestätegung vun Message Liwwerung. Net op den Apparat vum Benotzer, mee zum Netz. Wesentlech ass dëst Bestätegung vum Empfänger seng Fäegkeet fir Äre Message ze liesen. Dëst ass eng nëtzlech Feature fir kritesch Notifikatiounen ze schécken.

Blockchain Virdeeler enthalen och eng enk Integratioun mat de Krypto-Währungen Ethereum, Dogecoin, Lisk, Dash, Bitcoin (dëst ass nach ëmmer amgaang) an d'Fäegkeet Tokens an Chats ze schécken. Mir hunn souguer en agebaute Krypto-Austausch gemaach.

An dann - wéi et alles funktionnéiert.

E Message ass eng Transaktioun

Jiddereen ass scho gewinnt mat der Tatsaach, datt Transaktiounen an der Blockchain Tokens (Mënzen) vun engem Benotzer op en aneren transferéieren. Wéi Bitcoin. Mir hunn eng speziell Aart vun Transaktioun erstallt fir Messagen ze vermëttelen.

Fir e Message an engem Messenger op der Blockchain ze schécken, musst Dir duerch e puer Schrëtt goen:

  1. Verschlëssele Message Text
  2. Setzt Chiffertext an eng Transaktioun
  3. Ënnerschreift d'Transaktioun
  4. Schéckt eng Transaktioun op all Netzwierk Node
  5. E verdeelt System vun Noden bestëmmt d'"Authentizitéit" vun engem Message
  6. Wann alles OK ass, ass d'Transaktioun mat der Noriicht am nächste Block abegraff
  7. Den Empfänger recuperéiert d'Botschaftstransaktioun an entschlësselt

D'Schrëtt 1-3 a 7 ginn lokal op de Client gemaach, an d'Schrëtt 5-6 ginn op den Hosten ausgefouert.

Message Verschlësselung

De Message ass verschlësselt mat dem private Schlëssel vum Sender an dem ëffentleche Schlëssel vum Empfänger. Mir huelen den ëffentleche Schlëssel aus dem Netz, awer dofir muss de Kont vum Empfänger initialiséiert ginn, dat heescht, op d'mannst eng Transaktioun hunn. Dir kënnt eng REST Ufro benotzen GET /api/accounts/getPublicKey?address={ADAMANT address}, a beim Luede vun Chats sinn déi ëffentlech Schlëssele vun de Gespréichspartner scho verfügbar.

Wéi funktionnéiert en dezentraliséierte Messenger op der Blockchain?

De Messenger verschlësselt Messagen mam Curve25519xsalsa20poly1305 Algorithmus (NaCl Box). Well de Kont enthält Ed25519 Schlësselen, fir eng Këscht ze bilden, mussen d'Schlësselen als éischt op Curve25519 Diffie-Hellman ëmgewandelt ginn.

Hei ass e Beispill am 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)
  }
}

Formen eng Transaktioun mat engem Message

D'Transaktioun huet déi folgend allgemeng Struktur:

{
  "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": {}
}

Fir eng Message Transaktioun ass déi wichtegst Saach asset - Dir musst e Message am Objet setzen chat mat Struktur:

  • message - späichert de verschlësselte Message
  • own_message - net
  • type - Message Typ

Messagen sinn och an Typen ënnerdeelt. Weesentlechen, de Parameter type seet Iech wéi ze verstoen message. Dir kënnt just en Text schécken, oder Dir kënnt en Objet mat interessanten Saachen dobannen schécken - zum Beispill, dëst ass wéi de Messenger cryptocurrency Transferen an Chats mécht.

Als Resultat kreéiere mir eng Transaktioun:

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

Transaktioun Ënnerschrëft

Fir sécherzestellen datt jiddereen zouversiichtlech ass an d'Authentizitéit vum Sender an Empfänger, d'Zäit vum Schécken an den Inhalt vun der Noriicht, gëtt d'Transaktioun ënnerschriwwen. Eng digital Ënnerschrëft erlaabt Iech d'Authentizitéit vun enger Transaktioun mat engem ëffentleche Schlëssel z'iwwerpréiwen - e private Schlëssel ass net néideg fir dëst.

Awer d'Ënnerschrëft selwer gëtt mam private Schlëssel gemaach:

Wéi funktionnéiert en dezentraliséierte Messenger op der Blockchain?

D'Diagramm weist datt mir als éischt d'Transaktioun mat SHA-256 hashéieren an se dann ënnerschreiwen Ed25519 EdDSA a kritt eng Ënnerschrëft signature, an d'Transaktiouns-ID ass Deel vum SHA-256 Hash.

Beispill Implementatioun:

1 - Form en Dateblock, inklusiv e Message

/**
 * 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 - Grof SHA-256 aus dem Dateblock

/**
 * 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 - Ënnerschreift d'Transaktioun

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'))
}

Schécken vun enger Transaktioun mat engem Message un en Netzwierk Node

Zënter dem Netz dezentraliséiert ass, wäert iergendeen vun den Noden mat enger oppener API maachen. Eng POST Ufro un den Endpunkt maachen api/transactions:

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

Als Äntwert wäerte mir eng Transaktiouns-ID vum Typ kréien

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

Transaktioun Validatioun

E verdeelt System vun Noden, baséiert op Konsens, bestëmmt d'"Authentizitéit" vun der Transaktiounsmeldung. Vu wiem a wiem, wéini, ob de Message duerch en aneren ersat gouf, an ob d'Zäit vum Verschécken richteg uginn ass. Dëst ass e ganz wichtege Virdeel vun der Blockchain - et gëtt keng zentral Struktur déi fir d'Verifizéierung verantwortlech ass, an d'Sequenz vun de Messagen an hiren Inhalt kann net gefälscht ginn.

Als éischt kontrolléiert een Node d'Genauegkeet, a schéckt se dann un anerer - wann d'Majoritéit seet datt alles an der Rei ass, gëtt d'Transaktioun am nächste Block vun der Kette abegraff - dat ass Konsens.

Wéi funktionnéiert en dezentraliséierte Messenger op der Blockchain?

Den Deel vum Node Code dee verantwortlech ass fir Kontrollen kann op GitHub gekuckt ginn - validator.js и verifizéieren.js. Yep, den Node leeft op Node.js.

Inklusiv enger Transaktioun mat engem Message an engem Block

Wann de Konsens erreecht gëtt, gëtt d'Transaktioun mat eisem Message am nächste Block zesumme mat anere gültege Transaktiounen abegraff.

Blocks hunn eng strikt Sequenz, an all spéider Block gëtt op Basis vun den Hashes vu fréiere Blocks geformt.

Wéi funktionnéiert en dezentraliséierte Messenger op der Blockchain?

De Punkt ass datt eise Message och an dëser Sequenz abegraff ass a kann net "neiarrangéiert" ginn. Wann e puer Messagen an engem Block falen, gëtt hir Uerdnung bestëmmt duerch timestamp Messagen.

Liesen Messagen

D'Messenger Applikatioun recuperéiert Transaktiounen aus der Blockchain déi un den Empfänger geschéckt ginn. Dofir hu mir en Endpunkt gemaach api/chatrooms.

All Transaktioune si fir jiddereen verfügbar - Dir kënnt verschlësselte Messagen kréien. Awer nëmmen den Empfänger kann mat sengem private Schlëssel an dem ëffentleche Schlëssel vum Sender entschlësselen:

**
 * 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) : ''
}

A wat soss?

Zënter datt Messagen op dës Manéier an ongeféier 5 Sekonnen geliwwert ginn - dat ass d'Zäit wou en neien Netzwierkblock erschéngt - hu mir e Client-zu-Node an Node-to-Node Socketverbindung ukomm. Wann en Node eng nei Transaktioun kritt, iwwerpréift se seng Validitéit a schéckt se an aner Noden weider. D'Transaktioun ass verfügbar fir Messenger Clienten och ier de Konsens geschitt an d'Inklusioun am Block. Op dës Manéier liwwere mir Messagen direkt, sou wéi normal Instant Messenger.

Fir d'Adressbuch ze späicheren, hu mir KVS gemaach - Key-Value Storage - dëst ass eng aner Zort Transaktioun an där asset et ass net NaCl-Box déi verschlësselt ass, awer NaCl-Secretbox. Dëst ass wéi de Messenger aner Daten späichert.

D'Iwwerdroung vun Dateien / Biller a Gruppechats erfuerdert nach ëmmer vill Aarbecht. Natierlech, an engem blunder-and-blunder Format kann dëst séier "opgeschrauft" ginn, mä mir wëllen de selwechten Niveau vun Privatsphär erhalen.

Jo, et ass nach ëmmer Aarbecht ze maachen - am Idealfall, real Privatsphär iwwerhëlt datt d'Benotzer net mat ëffentlechen Netzwierkknäppchen verbannen, awer hir eege erhéijen. Wéi ee Prozentsaz vun de Benotzer mengt Dir mécht dat? Dat stëmmt, 0. Mir konnten dëst Thema deelweis léisen mat der Tor Versioun vum Messenger.

Mir hunn bewisen datt e Messenger op der Blockchain existéiere kann. Virdrun war et nëmmen ee Versuch am Joer 2012 - bitmessage, wat gescheitert ass wéinst laange Message Liwwerzäiten, CPU Belaaschtung a Mangel u mobilen Applikatiounen.

A Skepsis ass wéinst der Tatsaach datt Messenger op der Blockchain hir Zäit viraus sinn - d'Leit sinn net prett fir Verantwortung fir hire Kont ze huelen, perséinlech Informatioun ze besëtzen ass nach net en Trend, an d'Technologie erlaabt net héich Geschwindegkeet op der Blockchain. Méi technologesch Analoga vun eisem Projet erschéngen nächst. Dir wäert gesinn.

Source: will.com

Setzt e Commentaire