p2plex-gossip

Create a secure (ish) swarm of peers to gossip over P2Plex

Work in progress

How it works

• Get a p2plex instance
• Get a set of peers you wish to gossip with
• Set of peers should contain their p2plex public keys as well as their public keys used for signing messages
• Generate a key to find peers based on the set
• Optionally provide a nonce to mix into the key and into messages (useful to avoid replay attacks)
• Find peers for the key
• Find connections from peers and open streams for the key for them
• Use abstract-gossip to send and recieve messages from peers

API

const Gossip = require('p2plex-gossip')

const swarm = p2plex()

const peers = new Map()

peers.set(remotePublicKey.toString('hex'), signingPublicKey)

const gossip = await Gossip.create({
    // P2Plex instance to use, the public key will be used for swarming
    swarm,

    // List of peers to gossip with
    // Map of `remotePublicKey` to `signingPublicKey`
    peers,

    // Your ID in the list
    // If not provided `keyPair.publicKey` will be used
    id,

    // Pass a nonce to prevent replay attacks
    // Must be a buffer with unique bytes
    nonce,

    // Keypair used for signing
    // Should be compatible with [libsodium_crypto_sign_*](https://doc.libsodium.org/public-key_cryptography/public-key_signatures)
    keyPair,

    // Alternately you can specify custom signing and verifying functions
    // Sign a message for your ID
    async sign(message) { return signature},
    // Given a peer's publicKey, a message and a signature, verify that it's valid
    // The `id` will be the value part of the pair inside the `peers` map
    async verify(id, message, signature) { return isValid},
    // Pass a custom hash function for generating keys
    async hashBytes(bytes) { return hash}
})

// Listen on messages being gossiped in the swarm
gossip.on('message', (data, from) => {
    // Saw a message that got broadcasted by `from`
    // This was cryptographically verified to come from them
    // Data is the data that the original peer sent out
})

// Broadcast some data to the swarm
// `data` must be a Buffer
// Signed with nonce to avoid replay attacks
gossip.broadcast(data)

// Sign some data to send out
const signedData = await gossip.sign(data)
const {from, signature, nonce, data} = signedData

// Verify that some data you got was signed
// The `from` ID is the remotePublic key of the peer
const isValid = await gossip.verify(from, data, nonce, signature)