Ar ddechrau 2017, dechreuon ni greu negesydd ar y blockchain [mae enw a dolen yn y proffil] trwy drafod y manteision dros negeswyr P2P clasurol.
Wedi pasio 2.5 flwyddyn, ac roeddem yn gallu cadarnhau ein cysyniad: mae cymwysiadau negesydd bellach ar gael ar gyfer iOS, Web PWA, Windows, GNU/Linux, Mac OS ac Android.
Heddiw, byddwn yn dweud wrthych sut mae'r negesydd blockchain yn gweithio a sut y gall cymwysiadau cleientiaid weithio gyda'i API.
Roeddem am i'r blockchain ddatrys materion diogelwch a phreifatrwydd negeswyr P2P clasurol:
- Un clic i greu cyfrif - dim ffonau neu e-byst, dim mynediad i lyfrau cyfeiriadau na geolocations.
- Nid yw'r cydgysylltwyr byth yn sefydlu cysylltiadau uniongyrchol; mae'r holl gyfathrebu yn digwydd trwy system ddosbarthedig o nodau. Nid yw cyfeiriadau IP defnyddwyr yn hygyrch i'w gilydd.
- Mae pob neges wedi'i hamgryptio o'r diwedd i'r diwedd cromlin25519xsalsa20poly1305. Mae'n ymddangos na fydd hyn yn syndod i unrhyw un, ond mae ein cod ffynhonnell ar agor.
- Mae ymosodiad MITM wedi'i eithrio - mae pob neges yn drafodiad ac wedi'i lofnodi gan Ed25519 EdDSA.
- Mae'r neges yn gorffen yn ei bloc ei hun. Cysondeb a
timestampNi allwch drwsio'r blociau, ac felly trefn y negeseuon. - Ni fydd “Wnes i ddim dweud hynny” yn gweithio gyda negeseuon ar y blockchain.
- Nid oes unrhyw strwythur canolog sy'n gwirio “dilysrwydd” neges. Gwneir hyn gan system ddosbarthedig o nodau yn seiliedig ar gonsensws, ac mae'n eiddo i'r defnyddwyr.
- Amhosibilrwydd sensoriaeth - ni ellir rhwystro cyfrifon ac ni ellir dileu negeseuon.
- Mae Blockchain 2FA yn ddewis arall i'r 2FA uffernol trwy SMS,
- Mae'r gallu i gael eich holl sgyrsiau o unrhyw ddyfais ar unrhyw adeg yn golygu nad oes rhaid i chi storio sgyrsiau yn lleol o gwbl.
- Cadarnhad o ddanfon y neges. Nid i ddyfais y defnyddiwr, ond i'r rhwydwaith. Yn y bôn, mae hyn yn gadarnhad o allu'r derbynnydd i ddarllen eich neges. Mae hon yn nodwedd ddefnyddiol ar gyfer anfon hysbysiadau beirniadol.
Mae buddion Blockchain hefyd yn cynnwys integreiddio agos â'r cryptocurrencies Ethereum, Dogecoin, Lisk, Dash, Bitcoin (mae hwn yn dal i fod ar y gweill) a'r gallu i anfon tocynnau mewn sgyrsiau. Fe wnaethon ni hyd yn oed gyfnewidydd crypto adeiledig.
Ac yna - sut mae'r cyfan yn gweithio.
Mae neges yn drafodiad
Mae pawb eisoes yn gyfarwydd â'r ffaith bod trafodion yn y blockchain yn trosglwyddo tocynnau (darnau arian) o un defnyddiwr i'r llall. Fel Bitcoin. Fe wnaethon ni greu math arbennig o drafodiad ar gyfer trosglwyddo negeseuon.
I anfon neges mewn negesydd ar y blockchain, mae angen i chi fynd trwy sawl cam:
- Amgryptio testun neges
- Rhowch ciphertext mewn trafodiad
- Llofnodwch y trafodiad
- Anfon trafodiad i unrhyw nod rhwydwaith
- Mae system ddosbarthedig o nodau yn pennu “dilysrwydd” neges
- Os yw popeth yn iawn, mae'r trafodiad gyda'r neges wedi'i gynnwys yn y bloc nesaf
- Mae'r derbynnydd yn adfer y trafodiad neges ac yn dadgryptio
Perfformir camau 1-3 a 7 yn lleol ar y cleient, a pherfformir camau 5-6 ar y gwesteiwyr.
Amgryptio neges
Mae'r neges wedi'i hamgryptio ag allwedd breifat yr anfonwr ac allwedd gyhoeddus y derbynnydd. Byddwn yn cymryd yr allwedd gyhoeddus o'r rhwydwaith, ond ar gyfer hyn, rhaid cychwyn cyfrif y derbynnydd, hynny yw, cael o leiaf un trafodiad. Gallwch ddefnyddio cais REST GET /api/accounts/getPublicKey?address={ADAMANT address}, ac wrth lwytho sgyrsiau, bydd allweddi cyhoeddus yr interlocutors eisoes ar gael.
Mae'r negesydd yn amgryptio negeseuon gan ddefnyddio'r algorithm cromlin25519xsalsa20poly1305 (). Gan fod y cyfrif yn cynnwys allweddi Ed25519, i ffurfio blwch, rhaid trosi'r allweddi yn gyntaf i Curve25519 Diffie-Hellman.
Dyma enghraifft yn 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)
}
}Ffurfio trafodiad gyda neges
Mae gan y trafodiad y strwythur cyffredinol canlynol:
{
"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": {}
}
Ar gyfer trafodiad neges, y peth pwysicaf yw asset - mae angen i chi osod neges yn y gwrthrych chat gyda strwythur:
message- arbed y neges wedi'i hamgryptioown_message- Noncetype- math o neges
Rhennir negeseuon yn fathau hefyd. Yn y bôn, y paramedr type yn dweud wrthych sut i ddeall message. Gallwch anfon testun yn unig, neu gallwch anfon gwrthrych gyda phethau diddorol y tu mewn - er enghraifft, dyma sut mae'r negesydd yn gwneud trosglwyddiadau cryptocurrency mewn sgyrsiau.
O ganlyniad, rydym yn creu trafodiad:
{
"transaction": {
"type": 8,
"amount": 0,
"senderId": "U12499126640447739963",
"senderPublicKey": "e9cafb1e7b403c4cf247c94f73ee4cada367fcc130cb3888219a0ba0633230b6",
"asset": {
"chat": {
"message": "cb682accceef92d7cddaaddb787d1184ab5428",
"own_message": "e7d8f90ddf7d70efe359c3e4ecfb5ed3802297b248eacbd6",
"type": 1
}
},
"recipientId": "U15677078342684640219",
"timestamp": 63228087,
"signature": "тут будет подпись"
}
}Llofnod trafodiad
Er mwyn sicrhau bod pawb yn hyderus yn nilysrwydd yr anfonwr a'r derbynnydd, yr amser anfon a chynnwys y neges, mae'r trafodiad wedi'i lofnodi. Mae llofnod digidol yn caniatáu ichi wirio dilysrwydd trafodiad gan ddefnyddio allwedd gyhoeddus - nid oes angen allwedd breifat ar gyfer hyn.
Ond mae'r llofnod ei hun yn cael ei berfformio gan ddefnyddio'r allwedd breifat:
Mae'r diagram yn dangos ein bod yn stwnsio'r trafodiad gyda SHA-256 yn gyntaf ac yna'n ei lofnodi a chael llofnod signature, ac mae'r ID trafodiad yn rhan o'r hash SHA-256.
Enghraifft o weithredu:
1 - Ffurfio bloc data, gan gynnwys neges
/**
* 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 - Cyfrif SHA-256 o'r bloc 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 - Arwyddwch y trafodiad
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'))
}Anfon trafodiad gyda neges i nod rhwydwaith
Gan fod y rhwydwaith wedi'i ddatganoli, bydd unrhyw un o'r nodau ag API agored yn gwneud hynny. Gwneud cais POST i'r diweddbwynt api/transactions:
curl 'api/transactions' -X POST
-d 'TX_DATA'Mewn ymateb byddwn yn derbyn ID trafodiad o'r math
{
"success": true,
"nodeTimestamp": 63228852,
"transactionId": "6146865104403680934"
}Dilysu Trafodiad
Mae system ddosbarthedig o nodau, yn seiliedig ar gonsensws, yn pennu “dilysrwydd” neges y trafodiad. Gan bwy ac i bwy, pryd, a gafodd neges ei disodli gan neges arall, ac a gafodd yr amser anfon ei nodi'n gywir. Mae hon yn fantais bwysig iawn i'r blockchain - nid oes unrhyw strwythur canolog sy'n gyfrifol am ddilysu, ac ni ellir ffugio dilyniant y negeseuon a'u cynnwys.
Yn gyntaf, mae un nod yn gwirio'r cywirdeb, ac yna'n ei anfon at eraill - os yw'r mwyafrif yn dweud bod popeth mewn trefn, bydd y trafodiad yn cael ei gynnwys yn y bloc nesaf o'r gadwyn - consensws yw hwn.
Gellir gweld y rhan o'r cod nod sy'n gyfrifol am wiriadau ar GitHub - и . Ydy, mae'r nod yn rhedeg ar Node.js.
Gan gynnwys trafodiad gyda neges mewn bloc
Os ceir consensws, bydd y trafodiad gyda'n neges yn cael ei gynnwys yn y bloc nesaf ynghyd â thrafodion dilys eraill.
Mae gan flociau ddilyniant llym, ac mae pob bloc dilynol yn cael ei ffurfio yn seiliedig ar hashes blociau blaenorol.
Y pwynt yw bod ein neges hefyd wedi'i chynnwys yn y dilyniant hwn ac ni ellir ei “aildrefnu”. Os bydd sawl neges yn syrthio i floc, bydd eu trefn yn cael ei benderfynu gan timestamp negeseuon.
Darllen negeseuon
Mae'r cymhwysiad negesydd yn adfer trafodion o'r blockchain a anfonir at y derbynnydd. Ar gyfer hyn fe wnaethom ddiweddbwynt api/chatrooms.
Mae'r holl drafodion ar gael i bawb - gallwch dderbyn negeseuon wedi'u hamgryptio. Ond dim ond y derbynnydd all ddadgryptio gan ddefnyddio ei allwedd breifat ac allwedd gyhoeddus yr anfonwr:
**
* 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 beth arall?
Gan fod negeseuon yn cael eu cyflwyno fel hyn mewn tua 5 eiliad - dyma'r amser y mae bloc rhwydwaith newydd yn ymddangos - fe wnaethom greu cysylltiad soced cleient-i-nôd a nod-i-nôd. Pan fydd nod yn derbyn trafodiad newydd, mae'n gwirio ei ddilysrwydd ac yn ei anfon ymlaen i nodau eraill. Mae'r trafodiad ar gael i gleientiaid negesydd hyd yn oed cyn i gonsensws ddigwydd a chynhwysiant yn y bloc. Fel hyn byddwn yn cyflwyno negeseuon ar unwaith, yn union fel negeswyr sydyn rheolaidd.
I storio'r llyfr cyfeiriadau, gwnaethom KVS - Storio Gwerth Allweddol - mae hwn yn fath arall o drafodiad lle asset nid NaCl-box sy'n cael ei amgryptio, ond . Dyma sut mae'r negesydd yn storio data arall.
Mae angen llawer o waith o hyd i drosglwyddo ffeiliau/delwedd a sgyrsiau grŵp. Wrth gwrs, yn y fformat blunder-and-blunder gall hyn gael ei “sgriwio i fyny” yn gyflym, ond rydym am gynnal yr un lefel o breifatrwydd.
Oes, mae gwaith i'w wneud o hyd - yn ddelfrydol, mae preifatrwydd go iawn yn tybio na fydd defnyddwyr yn cysylltu â nodau rhwydwaith cyhoeddus, ond yn codi eu rhai eu hunain. Pa ganran o ddefnyddwyr sy'n gwneud hyn yn eich barn chi? Mae hynny'n iawn, 0. Roeddem yn gallu datrys y mater hwn yn rhannol gyda fersiwn Tor o'r negesydd.
Rydym wedi profi y gall negesydd ar y blockchain fodoli. Cyn hynny, dim ond un ymgais a gafwyd yn 2012 - , a fethodd oherwydd amseroedd cyflwyno negeseuon hir, llwyth CPU, a diffyg cymwysiadau symudol.
Ac mae amheuaeth oherwydd y ffaith bod negeswyr ar y blockchain o flaen eu hamser - nid yw pobl yn barod i gymryd cyfrifoldeb am eu cyfrif, nid yw bod yn berchen ar wybodaeth bersonol yn duedd eto, ac nid yw technoleg yn caniatáu cyflymder uchel ar y blockchain. Bydd mwy o analogau technolegol o'n prosiect yn ymddangos nesaf. Byddwch yn gweld.
Ffynhonnell: hab.com