@pamoja/audit 0.1.15 → 0.1.16

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Ergonomic facade over the generated audit binding.
+ *
+ * A log that can be edited after the fact proves nothing. Each record here is
+ * signed and carries the hash of the one before it, so altering a record,
+ * dropping one, or reordering two breaks the chain at that point and at every
+ * point after it. The index is part of what is signed, which is what makes a
+ * record removed from the end detectable too.
+ *
+ * @packageDocumentation
+ */
+import { AuditEntry } from '@pamoja/native';
+import { DeviceIdentity } from '@pamoja/security';
+export { AuditEntry, AuditVerifier } from '@pamoja/native';
+/** A log that signs what it is given and chains it onto what came before. */
+export declare class AuditLog {
+    #private;
+    /**
+     * Creates a log that signs with a device identity.
+     *
+     * @param identity - The identity whose signature each record will carry.
+     * @param last - The final record of an existing log to carry on from, or
+     *   omitted to start empty.
+     */
+    constructor(identity: DeviceIdentity, last?: AuditEntry);
+    /**
+     * Creates a log that carries on from the last record an earlier one wrote.
+     *
+     * This is what a device does after a restart: the chain continues at the next
+     * index and hashes onto the record it left off at, so a reboot leaves no gap
+     * for a record to be removed through.
+     *
+     * @param identity - The identity whose signature each record will carry.
+     * @param last - The final record of the existing log.
+     */
+    static resume(identity: DeviceIdentity, last: AuditEntry): AuditLog;
+    /**
+     * Appends a payload, signing it and chaining it onto the last record.
+     *
+     * @param payload - The record to store.
+     * @returns The new entry.
+     */
+    append(payload: Uint8Array): AuditEntry;
+}
+/**
+ * Checks a whole chain that has already arrived.
+ *
+ * @param publicKey - The 32-byte key the records were signed with.
+ * @param entries - The records, in the order they were written.
+ * @throws With the reason the chain does not hold: a record whose signature
+ *   fails, or one that does not follow the record before it.
+ */
+export declare function verifyChain(publicKey: Uint8Array, entries: AuditEntry[]): void;

package/dist/index.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Ergonomic facade over the generated audit binding.
+ *
+ * A log that can be edited after the fact proves nothing. Each record here is
+ * signed and carries the hash of the one before it, so altering a record,
+ * dropping one, or reordering two breaks the chain at that point and at every
+ * point after it. The index is part of what is signed, which is what makes a
+ * record removed from the end detectable too.
+ *
+ * @packageDocumentation
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AuditLog_inner;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditLog = exports.AuditVerifier = exports.AuditEntry = void 0;
+exports.verifyChain = verifyChain;
+const native_1 = require("@pamoja/native");
+const security_1 = require("@pamoja/security");
+var native_2 = require("@pamoja/native");
+Object.defineProperty(exports, "AuditEntry", { enumerable: true, get: function () { return native_2.AuditEntry; } });
+Object.defineProperty(exports, "AuditVerifier", { enumerable: true, get: function () { return native_2.AuditVerifier; } });
+/** A log that signs what it is given and chains it onto what came before. */
+class AuditLog {
+    /**
+     * Creates a log that signs with a device identity.
+     *
+     * @param identity - The identity whose signature each record will carry.
+     * @param last - The final record of an existing log to carry on from, or
+     *   omitted to start empty.
+     */
+    constructor(identity, last) {
+        _AuditLog_inner.set(this, void 0);
+        const signer = security_1.DeviceIdentity.native(identity);
+        __classPrivateFieldSet(this, _AuditLog_inner, last === undefined ? new native_1.AuditLog(signer) : native_1.AuditLog.resume(signer, last), "f");
+    }
+    /**
+     * Creates a log that carries on from the last record an earlier one wrote.
+     *
+     * This is what a device does after a restart: the chain continues at the next
+     * index and hashes onto the record it left off at, so a reboot leaves no gap
+     * for a record to be removed through.
+     *
+     * @param identity - The identity whose signature each record will carry.
+     * @param last - The final record of the existing log.
+     */
+    static resume(identity, last) {
+        return new AuditLog(identity, last);
+    }
+    /**
+     * Appends a payload, signing it and chaining it onto the last record.
+     *
+     * @param payload - The record to store.
+     * @returns The new entry.
+     */
+    append(payload) {
+        return __classPrivateFieldGet(this, _AuditLog_inner, "f").append(Buffer.from(payload));
+    }
+}
+exports.AuditLog = AuditLog;
+_AuditLog_inner = new WeakMap();
+/**
+ * Checks a whole chain that has already arrived.
+ *
+ * @param publicKey - The 32-byte key the records were signed with.
+ * @param entries - The records, in the order they were written.
+ * @throws With the reason the chain does not hold: a record whose signature
+ *   fails, or one that does not follow the record before it.
+ */
+function verifyChain(publicKey, entries) {
+    (0, native_1.verifyAuditChain)(Buffer.from(publicKey), entries);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pamoja/audit",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "A tamper-evident, hash-chained log; altering, reordering, or dropping a record breaks verification.",
   "license": "MIT",
   "publishConfig": {
@@ -34,7 +34,7 @@
     "node": ">= 16"
   },
   "dependencies": {
-    "@pamoja/native": "0.1.15",
-    "@pamoja/security": "0.1.15"
+    "@pamoja/native": "0.1.16",
+    "@pamoja/security": "0.1.16"
   }
 }