@blueid/access-cli 0.3.0

package/.eslintrc

@@ -0,0 +1,10 @@
+{
+  "extends": ["airbnb", "prettier"],
+  "plugins": ["prettier"],
+  "rules": {
+    "prettier/prettier": ["error"],
+    "no-console": "off",
+    "no-bitwise": "off",
+    "import/extensions": "off"
+  }
+}

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "singleQuote": true,
+  "printWidth": 120,
+  "semi": false,
+  "tabWidth": 4,
+  "useTabs": false
+}

package/index.js

@@ -0,0 +1,22 @@
+#! /usr/bin/env node
+
+import { program } from 'commander'
+import chalk from 'chalk'
+import os from 'os'
+
+import printCliHeader from './lib/shared/printCliHeader.js'
+
+// Just import all commands they'll register themselves
+import './lib/createKeyPair/index.js'
+import './lib/createProvisioningData/index.js'
+import './lib/registerVendor/index.js'
+import './lib/uuidToBytes/index.js'
+
+printCliHeader()
+
+if (os.endianness() !== 'LE') {
+    console.log(chalk.red('Your system is not little endian.'))
+    process.exit(-1)
+}
+
+program.parse()

package/lib/createKeyPair/action.js

@@ -0,0 +1,35 @@
+import chalk from 'chalk'
+import crypto from 'crypto'
+
+import outputBuffer from '../shared/outputBuffer.js'
+
+export default async ({ format, privateFile, publicFile }) => {
+    try {
+        const isPEM = format === 'PEM'
+
+        const { publicKey, privateKey } = crypto.generateKeyPairSync('ec', {
+            namedCurve: 'prime256v1',
+            publicKeyEncoding: {
+                type: 'spki',
+                format: isPEM ? 'pem' : 'der',
+            },
+            privateKeyEncoding: {
+                type: 'pkcs8',
+                format: isPEM ? 'pem' : 'der',
+            },
+        })
+
+        if (isPEM) {
+            console.log(privateKey)
+            console.log(publicKey)
+            return
+        }
+
+        console.log('-- PRIVATE KEY --')
+        outputBuffer(privateKey, format, privateFile)
+        console.log('-- PUBLIC KEY --')
+        outputBuffer(publicKey, format, publicFile)
+    } catch (e) {
+        console.error(chalk.red(e.message))
+    }
+}

package/lib/createKeyPair/index.js

@@ -0,0 +1,27 @@
+import { program, Option } from 'commander'
+
+import { outputFormats } from '../shared/outputBuffer.js'
+
+import action from './action.js'
+
+program
+    .command('createKeyPair')
+    .description('Create a private and public key pair used for signing')
+    .addOption(
+        new Option('--format [format]', 'The output format to be used, if not PEM then generates DER format')
+            .choices(['PEM', 'file'].concat(outputFormats))
+            .makeOptionMandatory()
+    )
+    .addOption(
+        new Option(
+            '--privateFile [privateFile]',
+            'If output format is file must define the private file name to write into'
+        )
+    )
+    .addOption(
+        new Option(
+            '--publicFile [publicFile]',
+            'If output format is file must define the public file name to write into'
+        )
+    )
+    .action(action)

package/lib/createProvisioningData/action.js

@@ -0,0 +1,34 @@
+import { protoDelimited } from '@bufbuild/protobuf'
+
+import registerDevice from './registerDevice.js'
+
+import outputBuffer from '../shared/outputBuffer.js'
+
+import { BlueHardwareType } from '../proto/BlueCore_pb.js'
+import { BlueSystemProvisioning } from '../proto/BlueSystem_pb.js'
+
+export default async (
+    provisioningFile,
+    { vendorIdentity, hardwareType, hardwareSerialNumber, hardwareVersion, hardwareName, meta, format }
+) => {
+    const { deviceId, terminalPrivateKey, signaturePublicKey } = await registerDevice({
+        vendorIdentity,
+        hardwareSerialNumber,
+        hardwareType,
+        hardwareName,
+        hardwareVersion,
+        meta,
+    })
+
+    const provisionData = new BlueSystemProvisioning({
+        hardwareType: BlueHardwareType[hardwareType],
+        deviceId,
+        serialNumber: hardwareSerialNumber,
+        terminalPrivateKey,
+        signaturePublicKey,
+    })
+
+    const buffer = protoDelimited.enc(provisionData)
+
+    outputBuffer(buffer, format, provisioningFile)
+}

package/lib/createProvisioningData/index.js

@@ -0,0 +1,48 @@
+import { program, Option } from 'commander'
+
+import { outputFormats } from '../shared/outputBuffer.js'
+
+import { BlueHardwareType } from '../proto/BlueCore_pb.js'
+
+import action from './action.js'
+
+program
+    .command('createProvisioningData')
+    .description('Create a binary provisioning data package for provisioning a blueid device.')
+    .argument('[provisioningFile]', 'If output format is file must define the provisioning file name to write into')
+    .addOption(
+        new Option(
+            '--vendorIdentity [vendorIdentity]',
+            'The vendor identity to be used for authentication or "test" for test-data'
+        ).makeOptionMandatory(true)
+    )
+    .addOption(
+        new Option('--hardwareType [hardwareType]', 'The type of the device')
+            .choices(Object.values(BlueHardwareType).filter((x) => typeof x === 'string'))
+            .makeOptionMandatory(true)
+    )
+    .addOption(
+        new Option(
+            '--hardwareVersion [hardwareVersion]',
+            'The actual hardware version of the device which is vendor specific'
+        )
+    )
+    .addOption(
+        new Option(
+            '--hardwareSerialNumber [hardwareSerialNumber]',
+            'The vendor serial number for the device which is vendor specific'
+        ).makeOptionMandatory(true)
+    )
+    .addOption(
+        new Option(
+            '--hardwareName [hardwareName]',
+            'The human readable identifier of the device which is vendor specific'
+        ).makeOptionMandatory(true)
+    )
+    .addOption(new Option('--meta [meta]', 'Optional meta data in JSON format for the device'))
+    .addOption(
+        new Option('--format [format]', 'The output format to be used')
+            .choices(['file'].concat(outputFormats))
+            .makeOptionMandatory()
+    )
+    .action(action)

package/lib/createProvisioningData/registerDevice.js

@@ -0,0 +1,101 @@
+import { createPrivateKey, createPublicKey } from 'crypto'
+
+import loadPrivateKey from '../shared/loadPrivateKey.js'
+import createSignature from '../shared/createSignature.js'
+import { getConfigValue } from '../shared/config.js'
+import { apiPost } from '../shared/api.js'
+
+import { BlueSharedDemoData } from '../proto/BlueCore_pb.js'
+
+export default async ({ vendorIdentity, hardwareType, hardwareVersion, hardwareSerialNumber, hardwareName, meta }) => {
+    if (vendorIdentity === 'test') {
+        return {
+            deviceId: BlueSharedDemoData.fields.findJsonName('deviceId').default,
+            terminalPrivateKey: BlueSharedDemoData.fields.findJsonName('terminalPrivateKey').default,
+            signaturePublicKey: BlueSharedDemoData.fields.findJsonName('signaturePublicKey').default,
+        }
+    }
+
+    if (meta) {
+        try {
+            // eslint-disable-next-line no-param-reassign
+            meta = JSON.parse(meta)
+        } catch (e) {
+            throw new Error(`Invalid meta JSON format, failed with: ${e.message}`)
+        }
+    } else {
+        meta = {}
+    }
+
+    let hardwareVersionNumber = 0
+    if (hardwareVersion) {
+        hardwareVersionNumber = Number.parseInt(hardwareVersion, 10)
+        if (Number.isNaN(hardwareVersionNumber)) {
+            throw new Error('Invalid number for hardwareVersion')
+        }
+    }
+
+    const vendorConfig = getConfigValue(`vendors.${vendorIdentity}`, undefined)
+    if (!vendorConfig) {
+        throw new Error(`No registered vendor for ${vendorIdentity} found, please call registerVendor command, first`)
+    }
+
+    const vendorPrivateKey = loadPrivateKey(vendorConfig.privateKey)
+
+    const payload = {
+        vendorIdentity,
+        hardwareType,
+        hardwareVersion: hardwareVersionNumber,
+        hardwareSerialNumber,
+        hardwareName,
+        meta,
+    }
+
+    try {
+        payload.signature = createSignature(JSON.stringify(payload), vendorPrivateKey, 'base64')
+    } catch (e) {
+        throw new Error(`Failed to create signature with: ${e.message}`)
+    }
+
+    const response = await apiPost('/access/devices/register', payload)
+
+    const {
+        deviceId,
+        terminalPrivateKey: terminalPrivateKeyData,
+        signaturePublicKey: signaturePublicKeyData,
+    } = response.data
+
+    const terminalPrivateKey = Buffer.from(terminalPrivateKeyData, 'base64')
+    const signaturePublicKey = Buffer.from(signaturePublicKeyData, 'base64')
+
+    if (!deviceId || deviceId.length !== 8) {
+        throw new Error('Received invalid device id')
+    }
+
+    // Try to validate basics to ensure we got valid data
+    try {
+        createPrivateKey({
+            key: terminalPrivateKey,
+            format: 'der',
+            type: 'pkcs8',
+        })
+    } catch (e) {
+        throw new Error('Received invalid private terminal key')
+    }
+
+    try {
+        createPublicKey({
+            key: signaturePublicKey,
+            format: 'der',
+            type: 'spki',
+        })
+    } catch (e) {
+        throw new Error('Received invalid public signature key')
+    }
+
+    return {
+        deviceId: BlueSharedDemoData.fields.findJsonName('deviceId').default,
+        terminalPrivateKey,
+        signaturePublicKey,
+    }
+}