Mwanzoni mwa 2017, tulianza kuunda mjumbe kwenye blockchain [jina na kiungo viko kwenye wasifu] kwa kujadili faida dhidi ya wajumbe wa kawaida wa P2P.
Imepitishwa 2.5 mwaka, na tuliweza kuthibitisha dhana yetu: maombi ya messenger sasa yanapatikana kwa iOS, Web PWA, Windows, GNU/Linux, Mac OS na Android.
Leo tutakuambia jinsi mjumbe wa blockchain anavyofanya kazi na jinsi maombi ya mteja yanaweza kufanya kazi na API yake.
Tulitaka blockchain kutatua maswala ya usalama na faragha ya wajumbe wa kawaida wa P2P:
- Mbofyo mmoja ili kuunda akaunti - hakuna simu au barua pepe, hakuna ufikiaji wa vitabu vya anwani au eneo.
- Waingiliaji kamwe hawaanzishi miunganisho ya moja kwa moja; mawasiliano yote hufanyika kupitia mfumo uliosambazwa wa nodi. Anwani za IP za watumiaji hazipatikani kwa kila mmoja.
- Barua pepe zote zimesimbwa kwa njia fiche End-to-End curve25519xsalsa20poly1305. Inaonekana kwamba hii haitashangaza mtu yeyote, lakini msimbo wetu wa chanzo umefunguliwa.
- Shambulio la MITM halijajumuishwa - kila ujumbe ni muamala na umetiwa saini na Ed25519 EdDSA.
- Ujumbe unaishia kwenye kizuizi chake. Uthabiti na
timestampHuwezi kurekebisha vizuizi, na kwa hivyo mpangilio wa ujumbe. - "Sikusema hivyo" haitafanya kazi na ujumbe kwenye blockchain.
- Hakuna muundo mkuu ambao hukagua "uhalisi" wa ujumbe. Hii inafanywa na mfumo wa kusambazwa wa nodes kulingana na makubaliano, na inamilikiwa na watumiaji.
- Kutowezekana kwa udhibiti - akaunti haziwezi kuzuiwa na ujumbe hauwezi kufutwa.
- Blockchain 2FA ni mbadala wa 2FA ya kuzimu kupitia SMS,
- Uwezo wa kupata mazungumzo yako yote kutoka kwa kifaa chochote wakati wowote ni uwezo wa kutohifadhi mazungumzo ndani ya nchi hata kidogo.
- Uthibitishaji wa uwasilishaji wa ujumbe. Sio kwa kifaa cha mtumiaji, lakini kwa mtandao. Kimsingi, huu ni uthibitisho wa uwezo wa mpokeaji kusoma ujumbe wako. Hiki ni kipengele muhimu kwa kutuma arifa muhimu.
Faida za Blockchain pia ni pamoja na ushirikiano wa karibu na sarafu za siri za Ethereum, Dogecoin, Lisk, Dash, Bitcoin (hii bado inaendelea) na uwezo wa kutuma tokeni kwenye gumzo. Tulifanya hata kibadilishaji cha crypto kilichojengwa ndani.
Na kisha - jinsi yote inavyofanya kazi.
Ujumbe ni shughuli
Kila mtu tayari amezoea ukweli kwamba shughuli katika ishara za uhamisho wa blockchain (sarafu) kutoka kwa mtumiaji mmoja hadi mwingine. Kama Bitcoin. Tuliunda aina maalum ya ununuzi wa kutuma ujumbe.
Ili kutuma ujumbe kwa mjumbe kwenye blockchain, unahitaji kupitia hatua kadhaa:
- Simba maandishi ya ujumbe kwa njia fiche
- Weka maandishi ya siri katika shughuli
- Saini muamala
- Tuma muamala kwa nodi yoyote ya mtandao
- Mfumo uliosambazwa wa nodi huamua "ukweli" wa ujumbe
- Ikiwa kila kitu kiko sawa, shughuli iliyo na ujumbe imejumuishwa kwenye kizuizi kinachofuata
- Mpokeaji hurejesha muamala wa ujumbe na kusimbua
Hatua ya 1-3 na 7 inafanywa ndani ya nchi kwa mteja, na hatua ya 5-6 inafanywa kwa waandaji.
Usimbaji fiche wa ujumbe
Ujumbe umesimbwa kwa njia fiche kwa ufunguo wa faragha wa mtumaji na ufunguo wa umma wa mpokeaji. Tutachukua ufunguo wa umma kutoka kwa mtandao, lakini kwa hili, akaunti ya mpokeaji lazima ianzishwe, yaani, iwe na angalau shughuli moja. Unaweza kutumia ombi la REST GET /api/accounts/getPublicKey?address={ADAMANT address}, na wakati wa kupakia mazungumzo, funguo za umma za interlocutors tayari zitapatikana.
Mjumbe husimba ujumbe kwa njia fiche kwa kutumia algoriti ya curve25519xsalsa20poly1305 () Kwa kuwa akaunti ina funguo za Ed25519, ili kuunda kisanduku, funguo lazima kwanza zibadilishwe hadi Curve25519 Diffie-Hellman.
Hapa kuna mfano katika 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)
}
}Kuunda muamala kwa ujumbe
Muamala una muundo wa jumla ufuatao:
{
"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": {}
}
Kwa shughuli ya ujumbe, jambo muhimu zaidi ni asset - unahitaji kuweka ujumbe katika kitu chat na muundo:
message- Hifadhi ujumbe uliosimbwaown_message- mara mojatype- aina ya ujumbe
Ujumbe pia umegawanywa katika aina. Kimsingi, parameter type inakuambia jinsi ya kuelewa message. Unaweza kutuma maandishi tu, au unaweza kutuma kitu kilicho na vitu vya kupendeza ndani - kwa mfano, hivi ndivyo mjumbe hufanya uhamishaji wa sarafu ya crypto kwenye mazungumzo.
Kama matokeo, tunaunda shughuli:
{
"transaction": {
"type": 8,
"amount": 0,
"senderId": "U12499126640447739963",
"senderPublicKey": "e9cafb1e7b403c4cf247c94f73ee4cada367fcc130cb3888219a0ba0633230b6",
"asset": {
"chat": {
"message": "cb682accceef92d7cddaaddb787d1184ab5428",
"own_message": "e7d8f90ddf7d70efe359c3e4ecfb5ed3802297b248eacbd6",
"type": 1
}
},
"recipientId": "U15677078342684640219",
"timestamp": 63228087,
"signature": "ΡΡΡ Π±ΡΠ΄Π΅Ρ ΠΏΠΎΠ΄ΠΏΠΈΡΡ"
}
}Sahihi ya muamala
Ili kuhakikisha kwamba kila mtu anajiamini katika uhalisi wa mtumaji na mpokeaji, wakati wa kutuma na maudhui ya ujumbe, shughuli hiyo imesainiwa. Sahihi ya dijiti hukuruhusu kuthibitisha uhalisi wa muamala kwa kutumia ufunguo wa umma - ufunguo wa faragha hauhitajiki kwa hili.
Lakini saini yenyewe inafanywa kwa kutumia ufunguo wa kibinafsi:
Mchoro unaonyesha kwamba kwanza tunaharakisha muamala na SHA-256 na kisha kuutia saini na kupata saini signature, na kitambulisho cha muamala ni sehemu ya heshi ya SHA-256.
Utekelezaji wa mfano:
1 β Unda kizuizi cha data, pamoja na ujumbe
/**
* 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 - Hesabu SHA-256 kutoka kwa kizuizi cha data
/**
* 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 - Saini muamala
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'))
}Kutuma shughuli na ujumbe kwa nodi ya mtandao
Kwa kuwa mtandao umegatuliwa, nodi zozote zilizo na API wazi zitafanya. Kufanya ombi la POST hadi mwisho api/transactions:
curl 'api/transactions' -X POST
-d 'TX_DATA'Kwa kujibu tutapokea kitambulisho cha muamala cha aina hiyo
{
"success": true,
"nodeTimestamp": 63228852,
"transactionId": "6146865104403680934"
}Uthibitishaji wa Muamala
Mfumo uliosambazwa wa nodi, kulingana na makubaliano, huamua "ukweli" wa ujumbe wa shughuli. Kutoka kwa nani na kwa nani, lini, ikiwa ujumbe ulibadilishwa na mwingine, na ikiwa wakati wa kutuma ulionyeshwa kwa usahihi. Hii ni faida muhimu sana ya blockchain - hakuna muundo wa kati unaohusika na uthibitishaji, na mlolongo wa ujumbe na maudhui yao hayawezi kuingizwa.
Kwanza, nodi moja inakagua usahihi, na kisha kuituma kwa wengine - ikiwa wengi wanasema kuwa kila kitu kiko sawa, shughuli hiyo itajumuishwa kwenye kizuizi kifuatacho cha mnyororo - hii ni makubaliano.
Sehemu ya nambari ya nodi ambayo inawajibika kwa ukaguzi inaweza kutazamwa kwenye GitHub - ΠΈ . Ndiyo, nodi inaendesha Node.js.
Ikiwa ni pamoja na shughuli na ujumbe katika block
Makubaliano yakifikiwa, muamala na ujumbe wetu utajumuishwa kwenye kizuizi kifuatacho pamoja na miamala mingine halali.
Vitalu vina mlolongo mkali, na kila kizuizi kinachofuata kinaundwa kulingana na heshi za vitalu vya awali.
Jambo ni kwamba ujumbe wetu pia umejumuishwa katika mlolongo huu na hauwezi "kupangwa upya". Ikiwa ujumbe kadhaa utaanguka kwenye kizuizi, utaratibu wao utatambuliwa na timestamp ujumbe.
Kusoma ujumbe
Programu ya mjumbe hurejesha miamala kutoka kwa blockchain ambayo hutumwa kwa mpokeaji. Kwa hili tulifanya mwisho api/chatrooms.
Shughuli zote zinapatikana kwa kila mtu - unaweza kupokea ujumbe uliosimbwa kwa njia fiche. Lakini ni mpokeaji pekee anayeweza kusimbua kwa kutumia ufunguo wake wa faragha na ufunguo wa umma wa mtumaji:
**
* 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) : ''
}Na nini kingine?
Kwa kuwa ujumbe unawasilishwa kwa njia hii katika sekunde 5 - huu ndio wakati kizuizi kipya cha mtandao kinaonekana - tulikuja na muunganisho wa tundu la mteja hadi nodi na nodi hadi nodi. Wakati nodi inapokea shughuli mpya, inakagua uhalali wake na kuipeleka kwa nodi zingine. Muamala unapatikana kwa wateja wa messenger hata kabla ya makubaliano kutokea na kujumuishwa kwenye kizuizi. Kwa njia hii tutawasilisha ujumbe papo hapo, kama vile wajumbe wa kawaida wa papo hapo.
Ili kuhifadhi kitabu cha anwani, tulifanya KVS - Uhifadhi wa Thamani ya Ufunguo - hii ni aina nyingine ya shughuli ambayo asset sio sanduku la NaCl ambalo limesimbwa, lakini . Hivi ndivyo mjumbe huhifadhi data zingine.
Uhamisho wa faili/picha na gumzo za kikundi bado zinahitaji kazi nyingi. Bila shaka, katika umbizo la blunder-and-blunder hii inaweza "kurushwa" haraka, lakini tunataka kudumisha kiwango sawa cha faragha.
Ndiyo, bado kuna kazi ya kufanywa - kwa hakika, faragha halisi inadhania kuwa watumiaji hawataunganishwa na nodi za mtandao wa umma, lakini watainua zao. Unadhani ni asilimia ngapi ya watumiaji hufanya hivi? Hiyo ni kweli, 0. Tuliweza kutatua suala hili kwa kiasi na toleo la Tor la mjumbe.
Tumethibitisha kuwa mjumbe kwenye blockchain anaweza kuwepo. Hapo awali, kulikuwa na jaribio moja tu mnamo 2012 - , ambayo ilishindikana kwa sababu ya muda mrefu wa kutuma ujumbe, upakiaji wa CPU na ukosefu wa programu za simu.
Na mashaka ni kutokana na ukweli kwamba wajumbe kwenye blockchain ni kabla ya wakati wao - watu hawako tayari kuchukua jukumu kwa akaunti yao, kumiliki habari za kibinafsi bado sio mwenendo, na teknolojia hairuhusu kasi ya juu kwenye blockchain. Analogues zaidi za kiteknolojia za mradi wetu zitaonekana ijayo. Utaona.
Chanzo: mapenzi.com