inspect-message

#!/usr/bin/env node
'use strict';
// This is a proof of concept. The code below is ugly, inefficient and has no tests.

const assert = require('assert').strict;
const fs = require('fs');
const yargs = require('yargs');
const {CARGO_SERIALIZER, PARCEL_SERIALIZER} = require('../core/serialization');
const {Cargo} = require('../core/messages');
const {derCertToPem} = require('../_asn1_utils');
const {deserializeCargoPayload, deserializeServiceMessage} = require('../core/serialization');
const {getAddressFromCert} = require('../core/pki');

const SERIALIZER_BY_TAG = {
    C: CARGO_SERIALIZER,
    P: PARCEL_SERIALIZER,
};

async function main(argv) {
    const messageRaw = fs.readFileSync(fs.openSync('/dev/stdin', 'rs'));

    const fileSignature = messageRaw.slice(0, 9).toString();
    assert(fileSignature.startsWith('Relaynet'), 'Message must be a Relaynet message');
    const fileTag = fileSignature[8];
    const serializer = SERIALIZER_BY_TAG[fileTag];
    assert(serializer, `Message tag must be either parcel or cargo, not "${fileTag}"`);

    const message = await serializer.deserialize(messageRaw);

    console.log(`Message type: ${message.constructor.name}`);
    console.log(formatMessageInfo(message));

    if (argv.recipientKey) {
        const payloadDecrypted = await message.decryptPayload(argv.recipientKey);

        if (message instanceof Cargo) {
            console.log('  Decrypted:');
            const parcelsSerialized = deserializeCargoPayload(payloadDecrypted);
            for (let parcelSerialized of parcelsSerialized) {
                console.log(`    Parcel:`);
                const parcel = await PARCEL_SERIALIZER.deserialize(parcelSerialized);
                console.log(formatMessageInfo(parcel, true))
            }
        } else {
            // It's a parcel
            const serviceMessage = deserializeServiceMessage(payloadDecrypted);
            console.log('  Service message:');
            console.log(`    Type: ${serviceMessage.type}`);
            if (argv.decodePayload) {
                console.log('    Content:', serviceMessage.messageSerialized.toString('utf-8'));
            }
        }
    }
}

function formatMessageInfo(message, indent = false) {
    let messageInfo = `Recipient: ${message.recipient}
Sender certificate:
  Address: ${getAddressFromCert(derCertToPem(message.senderCert))}
  Size: ${message.senderCert.length} octets
Id: ${message.id}
Date: ${message.date}
TTL: ${message.ttl} seconds
Payload:
  Size: ${message.payload.length} octets`;

    if (indent) {
        messageInfo = messageInfo.split('\n').map(line => `      ${line}`).join('\n');
    }

    return messageInfo;
}

const argv = yargs
    .option('recipient-key', {
        requiresArg: true,
        description: "The path to the recipient's private key, to decrypt payload",
        normalize: true,
    })
    .option('decode-payload', {
        description: "Whether to UTF-8 decode the payload after decryption",
        boolean: true,
        default: false,
    })
    .help()
    .strict()
    .argv;

(async () => await main(argv))();