From d14995349547fdcf275a521129cab02a80391fe6 Mon Sep 17 00:00:00 2001 From: Lucas Barrena Date: Sat, 27 Jan 2024 19:52:03 -0300 Subject: [PATCH] First commit --- .github/workflows/test-node.yml | 23 +++ .gitignore | 2 + LICENSE | 21 +++ README.md | 17 +++ index.js | 243 ++++++++++++++++++++++++++++++++ index2.js | 80 +++++++++++ lib/web-stream.js | 60 ++++++++ package.json | 36 +++++ test2.js | 40 ++++++ 9 files changed, 522 insertions(+) create mode 100644 .github/workflows/test-node.yml create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 README.md create mode 100644 index.js create mode 100644 index2.js create mode 100644 lib/web-stream.js create mode 100644 package.json create mode 100644 test2.js diff --git a/.github/workflows/test-node.yml b/.github/workflows/test-node.yml new file mode 100644 index 0000000..e12ceb1 --- /dev/null +++ b/.github/workflows/test-node.yml @@ -0,0 +1,23 @@ +name: Build Status +on: + push: + branches: + - main + pull_request: + branches: + - main +jobs: + build: + strategy: + matrix: + node-version: [lts/*] + os: [ubuntu-latest, macos-latest, windows-latest] + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@v3 + - name: Use Node.js ${{ matrix.node-version }} + uses: actions/setup-node@v3 + with: + node-version: ${{ matrix.node-version }} + - run: npm install + - run: npm test diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..504afef --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +node_modules/ +package-lock.json diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..a1dad77 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 Lucas Barrena + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..0096749 --- /dev/null +++ b/README.md @@ -0,0 +1,17 @@ +# hyperconnection + +Description + +``` +npm i hyperconnection +``` + +## Usage + +```js +const HyperConnection = require('hyperconnection') +``` + +## License + +MIT diff --git a/index.js b/index.js new file mode 100644 index 0000000..332655f --- /dev/null +++ b/index.js @@ -0,0 +1,243 @@ +const { Peer } = require('peerjs') // => STUN/TURN + RTCPeerConnection +const Protomux = require('protomux') +const c = require('compact-encoding') +const safetyCatch = require('safety-catch') +const ReadyResource = require('ready-resource') +const sodium = require('sodium-universal') +const b4a = require('b4a') +const WebStream = require('./lib/web-stream.js') + +// TODO: This could be a Duplex but don't know about that, for now emitting an event is good enough +module.exports = class WebPeer extends ReadyResource { + constructor (stream) { + super() + + const id = b4a.toString(randomBytes(8), 'hex') + + // this.peer = new Peer(id) + this.peer = new Peer() + this.stream = stream + // this.mux = new Protomux(stream) + this.channel = null + + this.handshake = null + this.token = b4a.toString(randomBytes(8), 'hex') // TODO: Think another solution for validating connections + this.remote = null + + this.ready().catch(safetyCatch) + } + + async _open () { + // TODO: Investigate about reusing the relayed handshake to create new SecretStream instances + /* const onhandshake = () => this.handshake = getHandshake(this.stream) + if (this.stream.handshakeHash) onhandshake() // Or this.stream._encrypt + else this.stream.once('handshake', onhandshake) */ + + this.peer.on('connection', rawStream => { + console.log('peerjs incoming', rawStream) + + // TODO: Check metadata.token before accepting the connection + + rawStream.on('open', () => { + console.log('rawStream open') + + // if (!this.handshake) throw new Error('No handshake') + + const duplex = new WebStream(rawStream) + + this.remote = duplex // new SecretStream(false, duplex) + // this.remote.on('data', (data) => console.log(data)) + // this.remote.on('close', () => console.log('remote closed')) + this.remote.on('error', console.error) + + // const done = () => this.mux.destroy() + // waitForRemote(this.remote).then(done, done) + + this.emit('continue', this.remote) + }) + + rawStream.on('error', function (err) { + console.log('rawStream error', err) + }) + + rawStream.on('close', function () { + console.log('rawStream close') + }) + }) + + try { + await waitForPeer(this.peer) + } catch (err) { + console.error(err) + this.stream.destroy() + throw err + } + + this.mux = new Protomux(this.stream) + + this._attachChannel() + + console.log('peer.id', this.peer.id) + + this.channel.open({ + // isInitiator: this.mux.stream.isInitiator, + id: this.peer.id, + token: this.token + }) + } + + _close () { + // this.peer.destroy() + // if (this.mux) this.mux.destroy() + this.stream.destroy() + } + + _attachChannel () { + const channel = this.mux.createChannel({ + protocol: 'hyperconnection', + id: null, + handshake: c.json, // TODO: Make strict messages + onopen: this._onmuxopen.bind(this), + onerror: this._onmuxerror.bind(this), + onclose: this._onmuxclose.bind(this), + messages: [ + // { encoding: c.json, onmessage: this._onmuxmessage } + ] + }) + + if (channel === null) return + + this.channel = channel + } + + _onmuxopen (handshake) { + console.log('_onmuxopen', handshake) + + if (this.mux.stream.isInitiator) { + console.log('Connecting to', handshake.id) + + // TODO: Investigate if metadata is kept truly private between both peers (E2E encrypted, not publicly stored in the middle server, etc) + const rawStream = this.peer.connect(handshake.id, { + reliable: true, + /* metadata: { + token: this.token + } */ + }) + + rawStream.on('open', () => { + console.log('rawStream open') + + // if (!this.handshake) throw new Error('No handshake') + + const duplex = new WebStream(rawStream) + + this.remote = duplex // new SecretStream(true, duplex) + + /* this.remote.on('connect', () => { + console.log('remote connected') + }) + + this.remote.on('open', () => { + console.log('remote opened') + }) */ + + this.remote.on('error', console.error) + + // TODO: Can destroy it right away? + // const done = () => this.mux.destroy() + // waitForRemote(this.remote).then(done, done) + + this.emit('continue', this.remote) + }) + + rawStream.on('error', function (err) { + console.log('rawStream error', err) + }) + + rawStream.on('close', function () { + console.log('rawStream close') + }) + } + } + + _onmuxerror (err) { + console.error('_onmuxerror', err) + } + + _onmuxclose (isRemote) { + console.log('_onmuxclose', { isRemote }, 'Stream created?', !!this.remote) + + // if (!this.remote) this.peer.destroy() + // this.mux.destroy() + } +} + +/* function getHandshake (stream) { + return { + publicKey: stream.publicKey, + remotePublicKey: stream.remotePublicKey, + hash: stream.handshakeHash, + tx: stream.tx || stream._encrypt?.key || null, + rx: stream.rx || stream._decrypt?.key || null + } +} */ + +function waitForRemote (remote) { + return new Promise(resolve => { + this.remote.on('open', done) + this.remote.on('open', done) + this.remote.on('error', done) + this.remote.on('close', done) + + function done () { + this.remote.off('open', done) + this.remote.off('error', done) + this.remote.off('close', done) + + resolve() + } + }) +} + +// TODO: Simplify a bit +function waitForPeer (peer) { + return new Promise((resolve, reject) => { + if (peer.disconnected === true) { + reject(new Error('Peer is disconnected')) + return + } + + if (peer.destroyed) { + reject(new Error('Peer is destroyed')) + return + } + + peer.on('open', onopen) + peer.on('error', onclose) + peer.on('close', onclose) + + function onopen (id) { + cleanup() + resolve() + } + + function onclose (err) { + cleanup() + + if (err) reject(err) + else reject(new Error('Could not create peer')) + } + + function cleanup () { + peer.off('open', onopen) + peer.off('error', onclose) + peer.off('close', onclose) + } + }) +} + +function randomBytes (n) { + const buf = b4a.allocUnsafe(n) + sodium.randombytes_buf(buf) + return buf +} diff --git a/index2.js b/index2.js new file mode 100644 index 0000000..7f63bcb --- /dev/null +++ b/index2.js @@ -0,0 +1,80 @@ +const iceServers = [ + { urls: 'stun:stun.l.google.com:19302' } +] + +let $id = 0 + +module.exports = class LikeWebRTC { + constructor () { + this._id = $id++ + + this.peer = new RTCPeerConnection({ iceServers }) + + this._setup() + } + + _setup () { + this.peer.onicecandidate = (event) => { + if (event.candidate) { + console.log(this._id, 'onicecandidate', event) + this.onice(event) + } + } + } + + addIceCandidate (candidate) { + this.peer.addIceCandidate(new RTCIceCandidate(candidate)) + } + + onice (event) {} + + // + + // connect () {} + + // + + createChannel (name) { + const channel = this.peer.createDataChannel(name) + // const channel = this.peer.createDataChannel(name, { negotiated: true, id: 0 }) // ondatachannel will not fire + + channel.onopen = () => { + console.log('Data channel opened'); + channel.send('Hello, peer!'); + }; + + channel.onclose = () => { + console.log('data channel closed') + } + + channel.onerror = (err) => console.error(err) + + channel.onmessage = (event) => { + console.log('Received message:', event.data); + }; + + return channel + } + + async createOffer () { + const offer = await this.peer.createOffer() + + await this.peer.setLocalDescription(offer) + + return this.peer.localDescription // => offer + } + + async receiveOffer (offer) { + this.peer.setRemoteDescription(new RTCSessionDescription(offer)) + + const answer = await this.peer.createAnswer() + + await this.peer.setLocalDescription(answer) + + return this.peer.localDescription // => answer + } + + async receiveAnswer (answer) { + this.peer.setRemoteDescription(new RTCSessionDescription(answer)) + } +} diff --git a/lib/web-stream.js b/lib/web-stream.js new file mode 100644 index 0000000..c68123b --- /dev/null +++ b/lib/web-stream.js @@ -0,0 +1,60 @@ +const b4a = require('b4a') +const { Duplex } = require('streamx') + +module.exports = class WebStream extends Duplex { + constructor (rtc) { + super({ mapWritable: toBuffer }) + + this.rtc = rtc + this.noiseStream = this + this.rawStream = this + + this._openedDone = null + + this.opened = new Promise(resolve => this._openedDone = resolve) + + this._setup() + + this.resume().pause() // Open immediately + } + + _setup () { + this.rtc.on('data', data => { + this.push(new Uint8Array(data)) + }) + + this.rtc.on('close', () => { + this.push(null) + this.emit('close') + }) + + this.rtc.on('error', (err) => { + this.emit('error', err) + }) + + this._openedDone(true) // TODO + } + + _open (cb) { + cb(null) + } + + _read (cb) { + cb(null) + } + + _write (chunk, cb) { + this.rtc.send(chunk) + cb(null) + } + + _destroy () { + this.rtc.close() + } + + setKeepAlive () {} // TODO +} + +function toBuffer (data) { + return typeof data === 'string' ? b4a.from(data) : data +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..2235ebe --- /dev/null +++ b/package.json @@ -0,0 +1,36 @@ +{ + "name": "hyper-webrtc", + "version": "0.0.0", + "description": "Description", + "main": "index.js", + "scripts": { + "test": "standard" + }, + "repository": { + "type": "git", + "url": "https://github.com/LuKks/hyper-webrtc.git" + }, + "author": "Lucas Barrena (LuKks)", + "license": "MIT", + "bugs": { + "url": "https://github.com/LuKks/hyper-webrtc/issues" + }, + "homepage": "https://github.com/LuKks/hyper-webrtc#readme", + "devDependencies": { + "brittle": "^3.3.2", + "standard": "^17.1.0" + }, + "dependencies": { + "@hyperswarm/dht-relay": "^0.4.3", + "b4a": "^1.6.4", + "compact-encoding": "^2.13.0", + "hypercore": "^10.32.5", + "hypercore-crypto": "^3.4.0", + "hyperswarm": "^4.7.13", + "peerjs": "^1.5.2", + "protomux": "^3.5.1", + "random-access-memory": "^6.2.0", + "sodium-universal": "^4.0.0", + "ws": "^8.16.0" + } +} diff --git a/test2.js b/test2.js new file mode 100644 index 0000000..d960702 --- /dev/null +++ b/test2.js @@ -0,0 +1,40 @@ +const test = require('brittle') +const WebRTC = require('./index2.js') + +test('basic', async function (t) { + const a = new WebRTC() + const b = new WebRTC() + + a.onice = function (e) { + b.addIceCandidate(e.candidate) + } + + b.onice = function (e) { + a.addIceCandidate(e.candidate) + } + + const channel1 = a.createChannel('rohil-is-he-knows') + b.peer.ondatachannel = function (e) { + const channel2 = e.channel + + channel2.onopen = () => { + console.log('Data channel opened'); + }; + + channel2.onclose = () => { + console.log('data channel closed') + } + + channel2.onerror = (err) => console.error(err) + + channel2.onmessage = (event) => { + console.log('Received message:', event.data); + }; + } + + const offer = await a.createOffer() + const answer = await b.receiveOffer(offer) + await a.receiveAnswer(answer) + + +})