@bedrock/kms-http 13.0.0

package/test/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "bedrock-kms-http-test",
+  "version": "0.0.1-0",
+  "type": "module",
+  "description": "Bedrock KMS HTTP API test",
+  "private": true,
+  "scripts": {
+    "test": "node --preserve-symlinks test.js test",
+    "test:debug": "node --preserve-symlinks test.js test --log-level debug",
+    "test-node": "node --preserve-symlinks test.js test --framework mocha",
+    "test-karma": "node --preserve-symlinks test.js test --framework karma",
+    "coverage": "cross-env NODE_ENV=test c8 --reporter=lcov --reporter=text-summary node --preserve-symlinks test.js test --framework mocha",
+    "coverage-ci": "cross-env NODE_ENV=test c8 --reporter=lcovonly node --preserve-symlinks test.js test --framework mocha",
+    "coverage-report": "c8 report"
+  },
+  "dependencies": {
+    "@bedrock/app-identity": "^2.0.0",
+    "@bedrock/core": "^5.0.0",
+    "@bedrock/did-context": "^3.0.0",
+    "@bedrock/did-io": "^7.0.0",
+    "@bedrock/express": "^7.0.0",
+    "@bedrock/https-agent": "^3.0.0",
+    "@bedrock/jsonld-document-loader": "^2.0.0",
+    "@bedrock/karma": "^3.0.0",
+    "@bedrock/kms": "^9.0.0",
+    "@bedrock/kms-http": "file:..",
+    "@bedrock/ledger-context": "^22.0.0",
+    "@bedrock/meter": "^2.0.0",
+    "@bedrock/meter-http": "^7.0.0",
+    "@bedrock/meter-usage-reporter": "^6.0.0",
+    "@bedrock/mongodb": "^9.0.0",
+    "@bedrock/package-manager": "^2.0.0",
+    "@bedrock/security-context": "^6.0.0",
+    "@bedrock/server": "^4.0.0",
+    "@bedrock/ssm-mongodb": "^8.0.0",
+    "@bedrock/test": "^7.0.0",
+    "@bedrock/validation": "^6.0.0",
+    "@bedrock/veres-one-context": "^13.0.0",
+    "@bedrock/zcap-storage": "^6.0.0",
+    "@digitalbazaar/did-method-key": "^2.0.0",
+    "@digitalbazaar/ed25519-signature-2020": "^3.0.0",
+    "@digitalbazaar/ezcap": "^2.0.0",
+    "@digitalbazaar/http-client": "^2.0.1",
+    "@digitalbazaar/http-signature-zcap-invoke": "^5.0.1",
+    "@digitalbazaar/webkms-client": "^10.0.0",
+    "@digitalbazaar/zcap": "^7.0.0",
+    "base58-universal": "^1.0.0",
+    "c8": "^7.11.0",
+    "cross-env": "^7.0.3",
+    "jsonld-signatures": "^9.3.0",
+    "p-map": "^4.0.0",
+    "sinon": "^9.0.2",
+    "uuid-random": "^1.3.2"
+  },
+  "c8": {
+    "excludeNodeModules": false,
+    "include": [
+      "node_modules/@bedrock/kms-http/**"
+    ],
+    "exclude": [
+      "node_modules/@bedrock/kms-http/node_modules/**"
+    ]
+  }
+}

package/test/test.config.js

@@ -0,0 +1,36 @@
+/*!
+ * Copyright (c) 2019-2022 Digital Bazaar, Inc. All rights reserved.
+ */
+import {config} from '@bedrock/core';
+import {fileURLToPath} from 'url';
+import path from 'path';
+import '@bedrock/https-agent';
+import '@bedrock/kms-http';
+import '@bedrock/mongodb';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+config.mocha.tests.push(path.join(__dirname, 'mocha'));
+
+// MongoDB
+config.mongodb.name = 'bedrock_kms_http_test';
+config.mongodb.dropCollections.onInit = true;
+config.mongodb.dropCollections.collections = [];
+
+// do not require an authentication session for tests
+config['kms-http'].requireAuthentication = false;
+
+// allow self-signed certs in test framework
+config['https-agent'].rejectUnauthorized = false;
+
+// configure karma tests
+config.karma.suites['bedrock-web-kms'] = path.join('web', '**', '*.js');
+config.karma.config.proxies = {
+  '/': {
+    target: 'https://localhost:18443',
+    changeOrigin: true
+  }
+};
+config.karma.config.proxyValidateSSL = false;
+config.karma.config.browserNoActivityTimeout = 120000;
+config.karma.config.browserDisconnectTimeout = 120000;

package/test/test.js

@@ -0,0 +1,31 @@
+/*!
+ * Copyright (c) 2019-2022 Digital Bazaar, Inc. All rights reserved.
+ */
+import * as bedrock from '@bedrock/core';
+import '@bedrock/https-agent';
+import '@bedrock/kms';
+import '@bedrock/kms-http';
+import '@bedrock/meter';
+import {handlers} from '@bedrock/meter-http';
+import '@bedrock/meter-usage-reporter';
+import '@bedrock/security-context';
+import '@bedrock/ssm-mongodb';
+import '@bedrock/test';
+import '@bedrock/karma';
+
+bedrock.events.on('bedrock.init', async () => {
+  /* Handlers need to be added before `bedrock.start` is called. These are
+  no-op handlers to enable meter usage without restriction */
+  handlers.setCreateHandler({
+    handler({meter} = {}) {
+      // use configured meter usage reporter as service ID for tests
+      meter.serviceId = bedrock.config['app-identity'].seeds.services.webkms.id;
+      return {meter};
+    }
+  });
+  handlers.setUpdateHandler({handler: ({meter} = {}) => ({meter})});
+  handlers.setRemoveHandler({handler: ({meter} = {}) => ({meter})});
+  handlers.setUseHandler({handler: ({meter} = {}) => ({meter})});
+});
+
+bedrock.start();

package/test/web/.eslintrc

@@ -0,0 +1,9 @@
+{
+  "env": {
+    "mocha": true,
+    "browser": true
+  },
+  "globals": {
+    "should": true
+  }
+}

package/test/web/10-api.js

@@ -0,0 +1,108 @@
+/*!
+ * Copyright (c) 2019-2022 Digital Bazaar, Inc. All rights reserved.
+ */
+import pMap from 'p-map';
+import uuid from 'uuid-random';
+import {CapabilityAgent, KeystoreAgent, KmsClient}
+  from '@digitalbazaar/webkms-client';
+import * as helpers from './helpers.js';
+
+describe('bedrock-kms-http HMAC operations', () => {
+  describe('Sha256HmacKey2019', () => {
+    let hmac;
+    before(async () => {
+      const secret = 'b07e6b31-d910-438e-9a5f-08d945a5f676';
+      const handle = 'testKey1';
+      const capabilityAgent = await CapabilityAgent.fromSecret(
+        {secret, handle});
+
+      let err;
+      let keystore;
+      try {
+        keystore = await _createKeystore({capabilityAgent});
+      } catch(e) {
+        err = e;
+      }
+      should.not.exist(err);
+
+      // create kmsClient only required because we need to use httpsAgent
+      // that accepts self-signed certs used in test suite
+      const kmsClient = new KmsClient();
+      const keystoreAgent = new KeystoreAgent({
+        capabilityAgent,
+        keystoreId: keystore.id,
+        kmsClient
+      });
+      hmac = await keystoreAgent.generateKey({type: 'hmac'});
+    });
+    it('successfully signs', async () => {
+      const data = new TextEncoder('utf-8').encode('hello');
+      let err;
+      let result;
+      try {
+        result = await hmac.sign({data});
+      } catch(e) {
+        err = e;
+      }
+      should.not.exist(err);
+      should.exist(result);
+      result.should.be.a('Uint8Array');
+    });
+
+    describe('bulk operations', () => {
+      const operationCount = 1000;
+      const vData = [];
+      before(async () => {
+        for(let i = 0; i < operationCount; ++i) {
+          // uuids are 37 chars long, * 30 is ~1KiB
+          let v = '';
+          for(let n = 0; n < 30; ++n) {
+            v += uuid();
+          }
+          vData.push(new TextEncoder('utf-8').encode(v));
+        }
+      });
+      it(`performs ${operationCount} signatures`, async function() {
+        this.timeout(0);
+        const startTime = Date.now();
+        let result;
+        let err;
+        try {
+          result = await pMap(
+            vData, data => hmac.sign({data}), {concurrency: 30});
+        } catch(e) {
+          err = e;
+        }
+        should.not.exist(err);
+        should.exist(result);
+        result.should.be.an('array');
+        result.should.have.length(operationCount);
+        const elapsedTime = Date.now() - startTime;
+        // NOTE: reporter in karma does not report elapsed time for individual
+        // tests, this logging is intentional
+        console.log('ELAPSED TIME', elapsedTime);
+      });
+    }); // end bulk operations
+  });
+});
+
+async function _createKeystore({capabilityAgent, referenceId}) {
+  const {id: meterId} = await helpers.createMeter({capabilityAgent});
+
+  // create keystore
+  const config = {
+    sequence: 0,
+    controller: capabilityAgent.id,
+    kmsModule: 'ssm-v1',
+    meterId
+  };
+
+  if(referenceId) {
+    config.referenceId = referenceId;
+  }
+  return KmsClient.createKeystore({
+    url: 'https://localhost:18443/kms/keystores',
+    config,
+    invocationSigner: capabilityAgent.getSigner()
+  });
+}

package/test/web/helpers.js

@@ -0,0 +1,84 @@
+/*!
+ * Copyright (c) 2021-2022 Digital Bazaar, Inc. All rights reserved.
+ */
+import {decode} from 'base58-universal';
+import {driver} from '@digitalbazaar/did-method-key';
+import {Ed25519Signature2020} from '@digitalbazaar/ed25519-signature-2020';
+import {ZcapClient} from '@digitalbazaar/ezcap';
+
+// found in bedrock-app-identity
+const DEFAULT_APPLICATION_ID_SEED =
+  'z1AmMXgweztXscpTpxx19jsCLkPXUacTTBme2oxWGvuto9S';
+
+// multibase base58-btc header
+const MULTIBASE_BASE58BTC_HEADER = 'z';
+// multihash identity function cdoe
+const MULTIHASH_IDENTITY_FUNCTION_CODE = 0x00;
+// seed byte size
+const SEED_BYTE_SIZE = 32;
+
+export async function createMeter({capabilityAgent} = {}) {
+  const invocationSigner = await getInvocationSigner();
+  const zcapClient = new ZcapClient({
+    invocationSigner,
+    SuiteClass: Ed25519Signature2020
+  });
+
+  // create a meter
+  const meterService = 'https://localhost:18443/meters';
+  let meter = {
+    controller: capabilityAgent.id,
+    product: {
+      // mock ID for webkms service product
+      id: 'urn:uuid:80a82316-e8c2-11eb-9570-10bf48838a41'
+    }
+  };
+  ({data: {meter}} = await zcapClient.write({url: meterService, json: meter}));
+
+  // return full meter ID
+  const {id} = meter;
+  return {id: `${meterService}/${id}`};
+}
+
+export async function getInvocationSigner() {
+  // convert multibase seed to Uint8Array
+  const seed = _decodeMultibaseSeed({
+    seedMultibase: DEFAULT_APPLICATION_ID_SEED
+  });
+
+  const didKeyDriver = driver();
+  const didKey = await didKeyDriver.generate({seed});
+
+  const {didDocument: {capabilityInvocation}} = didKey;
+
+  const capabilityInvocationKey = didKey.keyPairs.get(capabilityInvocation[0]);
+  return capabilityInvocationKey.signer();
+}
+
+function _decodeMultibaseSeed({seedMultibase}) {
+  const prefix = seedMultibase[0];
+  if(prefix !== MULTIBASE_BASE58BTC_HEADER) {
+    throw new Error('Unsupported multibase encoding.');
+  }
+  const data = seedMultibase.substring(1);
+  // <varint hash fn code> <varint digest size in bytes> <hash fn output>
+  //  <identity function>              <32>                <seed bytes>
+  const seedMultihash = decode(data);
+  // <varint hash fn code>: identity function
+  const [hashFnCode] = seedMultihash.slice(0, 1);
+  if(hashFnCode !== MULTIHASH_IDENTITY_FUNCTION_CODE) {
+    throw new Error('Invalid multihash function code.');
+  }
+  // <varint digest size in bytes>: 32
+  const [digestSize] = seedMultihash.slice(1, 2);
+  if(digestSize !== SEED_BYTE_SIZE) {
+    throw new Error('Invalid digest size.');
+  }
+  // <hash fn output>: seed bytes
+  const seedBytes = seedMultihash.slice(2, seedMultihash.length);
+  if(seedBytes.byteLength !== SEED_BYTE_SIZE) {
+    throw new Error('Invalid digest.');
+  }
+
+  return seedBytes;
+}