როგორ მუშაობს დეცენტრალიზებული მესინჯერი ბლოკჩეინზე?

2017 წლის დასაწყისში დავიწყეთ მესინჯერის შექმნა ბლოკჩეინზე [სახელი და ბმული მოცემულია პროფილში] კლასიკურ P2P მესინჯერებთან შედარებით უპირატესობების განხილვით.

გავიდა 2.5 წელს, და ჩვენ შევძელით ჩვენი კონცეფციის დადასტურება: მესინჯერის აპლიკაციები ახლა ხელმისაწვდომია iOS, Web PWA, Windows, GNU/Linux, Mac OS და Android-ისთვის.

დღეს ჩვენ გეტყვით, თუ როგორ მუშაობს ბლოკჩეინის მესინჯერი და როგორ შეუძლიათ კლიენტის აპლიკაციებს მუშაობა მისი API-ით.


ჩვენ გვინდოდა, რომ ბლოკჩეინმა გადაჭრა კლასიკური P2P მესინჯერების უსაფრთხოებისა და კონფიდენციალურობის საკითხები:

• ერთი დაწკაპუნებით ანგარიშის შესაქმნელად - არ არის ტელეფონები ან ელ.წერილები, არ არის წვდომა მისამართების წიგნებზე ან გეოლოკაციებზე.
• თანამოსაუბრეები არასოდეს ამყარებენ პირდაპირ კავშირებს; ყველა კომუნიკაცია ხდება კვანძების განაწილებული სისტემის მეშვეობით. მომხმარებლების IP მისამართები ერთმანეთთან მიუწვდომელია.
• ყველა შეტყობინება დაშიფრულია End-to-End curve25519xsalsa20poly1305. როგორც ჩანს, ეს არავის გააკვირვებს, მაგრამ ჩვენი საწყისი კოდი ღიაა.
• MITM შეტევა გამორიცხულია - თითოეული შეტყობინება არის ტრანზაქცია და ხელს აწერს Ed25519 EdDSA.
• შეტყობინება მთავრდება საკუთარ ბლოკში. თანმიმდევრულობა და timestamp თქვენ არ შეგიძლიათ შეასწოროთ ბლოკები და, შესაბამისად, შეტყობინებების თანმიმდევრობა.
• „ეს არ მითქვამს“ არ იმუშავებს ბლოკჩეინზე შეტყობინებებით.
• არ არსებობს ცენტრალური სტრუქტურა, რომელიც ამოწმებს შეტყობინების „ნამდვილობას“. ეს კეთდება კონსენსუსის საფუძველზე დაფუძნებული კვანძების განაწილებული სისტემით და მას ეკუთვნის მომხმარებლები.
• ცენზურის შეუძლებლობა - ანგარიშების დაბლოკვა და შეტყობინებების წაშლა შეუძლებელია.
• Blockchain 2FA არის ჯოჯოხეთური 2FA-ს ალტერნატივა SMS-ით, ბევრი ჯანმრთელობა დაანგრია.
• თქვენი ყველა საუბრის ნებისმიერ დროს ნებისმიერი მოწყობილობიდან მიღების შესაძლებლობა ნიშნავს, რომ საერთოდ არ გჭირდებათ საუბრების ადგილობრივად შენახვა.
• შეტყობინების მიწოდების დადასტურება. არა მომხმარებლის მოწყობილობაზე, არამედ ქსელში. არსებითად, ეს არის დადასტურება მიმღების უნარის წაკითხვის თქვენი შეტყობინების. ეს არის სასარგებლო ფუნქცია კრიტიკული შეტყობინებების გაგზავნისთვის.

ბლოკჩეინის უპირატესობებში ასევე შედის მჭიდრო ინტეგრაცია კრიპტოვალუტებთან 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-ზე - ვალიდიატორი.js и გადაამოწმეთ.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 - Key-Value Storage - ეს არის სხვა ტიპის ტრანზაქცია, რომელშიც asset ეს არ არის NaCl-ბოქსი, რომელიც დაშიფრულია, მაგრამ NaCl-საიდუმლო ყუთი. ასე ინახავს მესინჯერი სხვა მონაცემებს.

ფაილების/სურათების გადატანა და ჯგუფური ჩეთები ჯერ კიდევ დიდ შრომას მოითხოვს. რა თქმა უნდა, ბუნდოვანი და ბუნდოვანი ფორმატში ეს შეიძლება სწრაფად „გაფუჭდეს“, მაგრამ ჩვენ გვინდა შევინარჩუნოთ კონფიდენციალურობის იგივე დონე.

დიახ, ჯერ კიდევ არის გასაკეთებელი - იდეალურ შემთხვევაში, რეალური კონფიდენციალურობა ვარაუდობს, რომ მომხმარებლები არ დაუკავშირდებიან საჯარო ქსელის კვანძებს, არამედ აამაღლებენ საკუთარ კვანძებს. როგორ ფიქრობთ, მომხმარებელთა რამდენი პროცენტი აკეთებს ამას? ასეა, 0. ჩვენ შევძელით ნაწილობრივ ამ პრობლემის მოგვარება მესენჯერის Tor ვერსიით.

ჩვენ დავამტკიცეთ, რომ მესინჯერი ბლოკჩეინზე შეიძლება არსებობდეს. ადრე 2012 წელს მხოლოდ ერთი მცდელობა იყო - ბიტმესიჯი, რომელიც ვერ მოხერხდა შეტყობინებების მიწოდების ხანგრძლივი დროის, CPU დატვირთვისა და მობილური აპლიკაციების ნაკლებობის გამო.

და სკეპტიციზმი განპირობებულია იმით, რომ ბლოკჩეინზე მესინჯერები დროზე უსწრებენ - ადამიანები არ არიან მზად აიღონ პასუხისმგებლობა საკუთარ ანგარიშზე, პერსონალური ინფორმაციის ფლობა ჯერ არ არის ტენდენცია და ტექნოლოგია არ იძლევა ბლოკჩეინზე მაღალ სიჩქარეს. ჩვენი პროექტის მეტი ტექნოლოგიური ანალოგები გამოჩნდება შემდეგში. Დაინახავთ.

წყარო: www.habr.com