@opentdf/sdk 0.1.0-beta.1701

package/dist/web/tdf3/src/crypto/index.js

@@ -0,0 +1,296 @@
+/**
+ * This file is for using native crypto in the browser.
+ *
+ * @private
+ */
+import { Algorithms } from '../ciphers/index.js';
+import { Binary } from '../binary.js';
+import { MIN_ASYMMETRIC_KEY_SIZE_BITS, } from './declarations.js';
+import { ConfigurationError, DecryptError } from '../../../src/errors.js';
+import { formatAsPem, removePemFormatting } from './crypto-utils.js';
+import { encodeArrayBuffer as hexEncode } from '../../../src/encodings/hex.js';
+import { decodeArrayBuffer as base64Decode } from '../../../src/encodings/base64.js';
+// Used to pass into native crypto functions
+const METHODS = ['encrypt', 'decrypt'];
+export const isSupported = typeof globalThis?.crypto !== 'undefined';
+export const method = 'http://www.w3.org/2001/04/xmlenc#aes256-cbc';
+export const name = 'BrowserNativeCryptoService';
+/**
+ * Get a DOMString representing the algorithm to use for an
+ * asymmetric key generation.
+ */
+export function rsaOaepSha1(modulusLength = MIN_ASYMMETRIC_KEY_SIZE_BITS) {
+    if (!modulusLength || modulusLength < MIN_ASYMMETRIC_KEY_SIZE_BITS) {
+        throw new ConfigurationError('Invalid key size requested');
+    }
+    return {
+        name: 'RSA-OAEP',
+        hash: {
+            name: 'SHA-1',
+        },
+        modulusLength,
+        publicExponent: new Uint8Array([0x01, 0x00, 0x01]), // 24 bit representation of 65537
+    };
+}
+export function rsaPkcs1Sha256(modulusLength = MIN_ASYMMETRIC_KEY_SIZE_BITS) {
+    if (!modulusLength || modulusLength < MIN_ASYMMETRIC_KEY_SIZE_BITS) {
+        throw new ConfigurationError('Invalid key size requested');
+    }
+    return {
+        name: 'RSASSA-PKCS1-v1_5',
+        hash: {
+            name: 'SHA-256',
+        },
+        modulusLength,
+        publicExponent: new Uint8Array([0x01, 0x00, 0x01]), // 24 bit representation of 65537
+    };
+}
+/**
+ * Generate a random hex key
+ * @return New key as a hex string
+ */
+export async function generateKey(length) {
+    return randomBytesAsHex(length || 32);
+}
+/**
+ * Generate an RSA key pair
+ * @see    {@link https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey}
+ * @param  size in bits
+ */
+export async function generateKeyPair(size) {
+    const algoDomString = rsaOaepSha1(size || MIN_ASYMMETRIC_KEY_SIZE_BITS);
+    return crypto.subtle.generateKey(algoDomString, true, METHODS);
+}
+/**
+ * Generate an RSA key pair suitable for signatures
+ * @see    {@link https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey}
+ */
+export async function generateSigningKeyPair() {
+    return crypto.subtle.generateKey({
+        name: 'RSASSA-PKCS1-v1_5',
+        hash: 'SHA-256',
+        modulusLength: 2048,
+        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+    }, true, ['sign', 'verify']);
+}
+export async function cryptoToPemPair(keysMaybe) {
+    const keys = keysMaybe;
+    if (!keys.privateKey || !keys.publicKey) {
+        // These are only ever generated here, so this should not happen
+        throw new Error('internal: invalid keys');
+    }
+    const [exPublic, exPrivate] = await Promise.all([
+        crypto.subtle.exportKey('spki', keys.publicKey),
+        crypto.subtle.exportKey('pkcs8', keys.privateKey),
+    ]);
+    return {
+        publicKey: formatAsPem(exPublic, 'PUBLIC KEY'),
+        privateKey: formatAsPem(exPrivate, 'PRIVATE KEY'),
+    };
+}
+/**
+ * Encrypt using a public key
+ * @param payload Payload to encrypt
+ * @param publicKey PEM formatted public key
+ * @return Encrypted payload
+ */
+export async function encryptWithPublicKey(payload, publicKey) {
+    console.assert(typeof payload === 'object');
+    console.assert(typeof publicKey === 'string');
+    const algoDomString = rsaOaepSha1();
+    // Web Crypto APIs don't work with PEM formatted strings
+    publicKey = removePemFormatting(publicKey);
+    const keyBuffer = base64Decode(publicKey);
+    const cryptoKey = await crypto.subtle.importKey('spki', keyBuffer, algoDomString, false, [
+        'encrypt',
+    ]);
+    const result = await crypto.subtle.encrypt({ name: 'RSA-OAEP' }, cryptoKey, payload.asArrayBuffer());
+    return Binary.fromArrayBuffer(result);
+}
+/**
+ * Generate a 16-byte initialization vector
+ */
+export async function generateInitializationVector(length) {
+    return randomBytesAsHex(length || 16);
+}
+export async function randomBytes(byteLength) {
+    const r = new Uint8Array(byteLength);
+    crypto.getRandomValues(r);
+    return r;
+}
+/**
+ * Returns a promise to the encryption key as a binary string.
+ *
+ * Note: This function should almost never fail as it includes a fallback
+ * if for some reason the native generate key fails.
+ *
+ * @param length The key length, defaults to 256
+ *
+ * @returns The hex string.
+ */
+export async function randomBytesAsHex(length) {
+    // Create a typed array of the correct length to fill
+    const r = new Uint8Array(length);
+    crypto.getRandomValues(r);
+    return hexEncode(r.buffer);
+}
+/**
+ * Decrypt a public-key encrypted payload with a private key
+ * @param  encryptedPayload  Payload to decrypt
+ * @param  privateKey        PEM formatted private keynpmv
+ * @return Decrypted payload
+ */
+export async function decryptWithPrivateKey(encryptedPayload, privateKey) {
+    console.assert(typeof encryptedPayload === 'object', 'encryptedPayload must be object');
+    console.assert(typeof privateKey === 'string', 'privateKey must be string');
+    const algoDomString = rsaOaepSha1();
+    // Web Crypto APIs don't work with PEM formatted strings
+    const keyDataString = removePemFormatting(privateKey);
+    const keyData = base64Decode(keyDataString);
+    const key = await crypto.subtle.importKey('pkcs8', keyData, algoDomString, false, ['decrypt']);
+    const payload = await crypto.subtle.decrypt({ name: 'RSA-OAEP' }, key, encryptedPayload.asArrayBuffer());
+    const bufferView = new Uint8Array(payload);
+    return Binary.fromArrayBuffer(bufferView.buffer);
+}
+/**
+ * Decrypt content synchronously
+ * @param payload The payload to decrypt
+ * @param key     The encryption key
+ * @param iv      The initialization vector
+ * @param algorithm The algorithm to use for encryption
+ * @param authTag The authentication tag for authenticated crypto.
+ */
+export function decrypt(payload, key, iv, algorithm, authTag) {
+    return _doDecrypt(payload, key, iv, algorithm, authTag);
+}
+/**
+ * Encrypt content synchronously
+ * @param payload   The payload to encrypt
+ * @param key       The encryption key
+ * @param iv        The initialization vector
+ * @param algorithm The algorithm to use for encryption
+ */
+export function encrypt(payload, key, iv, algorithm) {
+    return _doEncrypt(payload, key, iv, algorithm);
+}
+async function _doEncrypt(payload, key, iv, algorithm) {
+    console.assert(payload != null);
+    console.assert(key != null);
+    console.assert(iv != null);
+    const payloadBuffer = payload.asArrayBuffer();
+    const algoDomString = getSymmetricAlgoDomString(iv, algorithm);
+    const importedKey = await _importKey(key, algoDomString);
+    const encrypted = await crypto.subtle.encrypt(algoDomString, importedKey, payloadBuffer);
+    if (algoDomString.name === 'AES-GCM') {
+        return {
+            payload: Binary.fromArrayBuffer(encrypted.slice(0, -16)),
+            authTag: Binary.fromArrayBuffer(encrypted.slice(-16)),
+        };
+    }
+    return {
+        payload: Binary.fromArrayBuffer(encrypted),
+    };
+}
+async function _doDecrypt(payload, key, iv, algorithm, authTag) {
+    console.assert(payload != null);
+    console.assert(key != null);
+    console.assert(iv != null);
+    let payloadBuffer = payload.asArrayBuffer();
+    // Concat the the auth tag to the payload for decryption
+    if (authTag) {
+        const authTagBuffer = authTag.asArrayBuffer();
+        const gcmPayload = new Uint8Array(payloadBuffer.byteLength + authTagBuffer.byteLength);
+        gcmPayload.set(new Uint8Array(payloadBuffer), 0);
+        gcmPayload.set(new Uint8Array(authTagBuffer), payloadBuffer.byteLength);
+        payloadBuffer = gcmPayload.buffer;
+    }
+    const algoDomString = getSymmetricAlgoDomString(iv, algorithm);
+    const importedKey = await _importKey(key, algoDomString);
+    algoDomString.iv = iv.asArrayBuffer();
+    const decrypted = await crypto.subtle
+        .decrypt(algoDomString, importedKey, payloadBuffer)
+        // Catching this error so we can specifically check for OperationError
+        .catch((err) => {
+        if (err.name === 'OperationError') {
+            throw new DecryptError(err);
+        }
+        throw err;
+    });
+    return { payload: Binary.fromArrayBuffer(decrypted) };
+}
+function _importKey(key, algorithm) {
+    return crypto.subtle.importKey('raw', key.asArrayBuffer(), algorithm, true, METHODS);
+}
+/**
+ * Get a DOMString representing the algorithm to use for a crypto
+ * operation. Defaults to AES-CBC.
+ * @param  {String|undefined} algorithm
+ * @return {DOMString} Algorithm to use
+ */
+function getSymmetricAlgoDomString(iv, algorithm) {
+    let nativeAlgorithm = 'AES-CBC';
+    if (algorithm === Algorithms.AES_256_GCM) {
+        nativeAlgorithm = 'AES-GCM';
+    }
+    return {
+        name: nativeAlgorithm,
+        iv: iv.asArrayBuffer(),
+    };
+}
+/**
+ * Create a SHA256 hash. Code refrenced from MDN:
+ * https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest
+ * @param  content  String content
+ * @return Hex hash
+ */
+export async function sha256(content) {
+    const buffer = new TextEncoder().encode(content);
+    const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
+    return hexEncode(hashBuffer);
+}
+/**
+ * Create an HMAC SHA256 hash
+ * @param  key     Key string
+ * @param  content Content string
+ * @return Hex hash
+ */
+export async function hmac(key, content) {
+    const contentBuffer = new TextEncoder().encode(content);
+    const keyBuffer = hex2Ab(key);
+    const cryptoKey = await crypto.subtle.importKey('raw', keyBuffer, {
+        name: 'HMAC',
+        hash: { name: 'SHA-256' },
+    }, true, ['sign', 'verify']);
+    const hashBuffer = await crypto.subtle.sign('HMAC', cryptoKey, contentBuffer);
+    return hexEncode(hashBuffer);
+}
+/**
+ * Create an ArrayBuffer from a hex string.
+ * https://developers.google.com/web/updates/2012/06/How-to-convert-ArrayBuffer-to-and-from-String?hl=en
+ * @param  hex - Hex string
+ */
+export function hex2Ab(hex) {
+    const buffer = new ArrayBuffer(hex.length / 2);
+    const bufferView = new Uint8Array(buffer);
+    for (let i = 0; i < hex.length; i += 2) {
+        bufferView[i / 2] = parseInt(hex.substr(i, 2), 16);
+    }
+    return buffer;
+}
+export const DefaultCryptoService = {
+    name,
+    method,
+    cryptoToPemPair,
+    decrypt,
+    decryptWithPrivateKey,
+    encrypt,
+    encryptWithPublicKey,
+    generateInitializationVector,
+    generateKey,
+    generateKeyPair,
+    generateSigningKeyPair,
+    hmac,
+    randomBytes,
+    sha256,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../tdf3/src/crypto/index.ts"],"names":[],"mappings":"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"}

package/dist/web/tdf3/src/index.js

@@ -0,0 +1,5 @@
+export * as Client from './client/index.js';
+export { Client as TDF3Client } from './client/index.js';
+export * as Errors from '../../src/errors.js';
+export { version, clientType } from './version.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90ZGYzL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssTUFBTSxNQUFNLG1CQUFtQixDQUFDO0FBQzVDLE9BQU8sRUFBRSxNQUFNLElBQUksVUFBVSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDekQsT0FBTyxLQUFLLE1BQU0sTUFBTSxxQkFBcUIsQ0FBQztBQUM5QyxPQUFPLEVBQUUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGNBQWMsQ0FBQyJ9

package/dist/web/tdf3/src/models/attribute-set.js

@@ -0,0 +1,118 @@
+import { decodeJwt } from 'jose';
+export class AttributeSet {
+    constructor() {
+        this.verbose = false;
+        this.attributes = [];
+    }
+    /**
+     * Check if attribute is in the list
+     * @param attribute URL of the attribute
+     * @return if attribute is in the set
+     */
+    has(attribute = '') {
+        // This could be much more elegant with something other than an
+        // array as the data structure. This is OK-ish only because the
+        // expected size of the data structure is small
+        // console.log(">>> ----- Has Attribute" + attribute);
+        return !!this.attributes.find((attrObj) => attrObj.attribute === attribute);
+    }
+    /**
+     * Get an attribute by URL
+     * @param  attribute URL of the attribute
+     * @return attribute in object form, if found
+     */
+    get(attribute = '') {
+        // This could be much more elegant with something other than an
+        // array as the data structure. This is OK-ish only because the
+        // expected size of the data structure is small
+        // console.log(">>> ----- Get Attribute" + attribute);
+        const result = this.attributes.filter((attrObj) => attrObj.attribute == attribute);
+        return result.length > 0 ? result[0] : null;
+    }
+    /**
+     * Get all the attributes.
+     * @return default attribute in object form or null
+     */
+    getDefault() {
+        return this.defaultAttribute || null;
+    }
+    /**
+     * Get the default attribute, if it exists.
+     * @return return all the attribute urls
+     */
+    getUrls() {
+        return this.attributes.map((attr) => attr.attribute);
+    }
+    /**
+     * Add an attribute to the set. Should be idempotent.
+     * @param attrObj AttributeObject to add, in non-JWT form
+     * @return the attribute object if successful, or null
+     */
+    addAttribute(attrObj) {
+        // Check for duplicate entries to assure idempotency.
+        if (this.has(attrObj.attribute)) {
+            // This may be a common occurance, so only un-comment this log message
+            // if you want verbose mode.
+            // console.log(`Attribute ${attrObj.attribute} is already loaded.`);
+            return null; // reject silently
+        }
+        if (attrObj.isDefault === true) {
+            if (this.defaultAttribute && this.defaultAttribute.attribute !== attrObj.attribute) {
+                // Remove the existing default attribute to make room for the new one
+                this.deleteAttribute(this.defaultAttribute.attribute);
+            }
+            this.defaultAttribute = attrObj;
+        }
+        this.attributes.push(attrObj);
+        return attrObj;
+    }
+    /**
+     * Delete an attribute from the set. Should be idempotent.
+     * @param attrUrl - URL of Attribute object to delete.
+     * @return The attribute object if successful or null if not
+     */
+    deleteAttribute(attrUrl = '') {
+        const deleted = this.get(attrUrl);
+        if (deleted) {
+            this.attributes = this.attributes.filter((attrObj) => attrObj.attribute != attrUrl);
+        }
+        return deleted;
+    }
+    /**
+     * Add a list of attributes in object form
+     * @param  attributes List of attribute objects as provided in an EntityObject
+     * @param  easPublicKey EAS public key for decrypting the JWTs
+     * @return list of attribute objects
+     */
+    addAttributes(attributes = []) {
+        return attributes
+            .map((attrObj) => {
+            return this.addAttribute(attrObj); // Returns promise
+        })
+            .filter((x) => x);
+    }
+    /**
+     * Add an attribute in JWT form = { jwt: <string jwt> }
+     * @param  {Object} jwtAttribute - Attribute object in JWT form.
+     * @return {Object} - Decrypted and added attribute object
+     */
+    addJwtAttribute(jwtAttribute) {
+        const attrJwt = jwtAttribute?.jwt;
+        // Can't verify the JWT because the client does not have the easPublicKey,
+        // but the contents of the JWT can be decoded.
+        const attrObjPayload = attrJwt && decodeJwt(attrJwt);
+        if (!attrObjPayload) {
+            return null;
+        }
+        // JWT payloads contain many things, incluing .iat and .exp. This
+        // extraneous material should be stripped away before adding the
+        // attribute to the attributeSet.
+        const { attribute, displayName, pubKey, kasUrl } = attrObjPayload;
+        const attrObj = { attribute, displayName, pubKey, kasUrl, jwt: attrJwt };
+        if (attrObjPayload.isDefault) {
+            attrObj.isDefault = !!attrObjPayload.isDefault;
+        }
+        return this.addAttribute(attrObj);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/web/tdf3/src/models/encryption-information.js

@@ -0,0 +1,86 @@
+import { keySplit } from '../utils/index.js';
+import { base64, hex } from '../../../src/encodings/index.js';
+import { Binary } from '../binary.js';
+import { ConfigurationError } from '../../../src/errors.js';
+export class SplitKey {
+    constructor(cipher) {
+        this.cipher = cipher;
+        this.cryptoService = cipher.cryptoService;
+        this.keyAccess = [];
+    }
+    async generateKey() {
+        const unwrappedKey = await this.cipher.generateKey();
+        const unwrappedKeyBinary = Binary.fromString(hex.decode(unwrappedKey));
+        const unwrappedKeyIvBinary = await this.generateIvBinary();
+        return { unwrappedKeyBinary, unwrappedKeyIvBinary };
+    }
+    async encrypt(contentBinary, keyBinary, ivBinaryOptional) {
+        const ivBinary = ivBinaryOptional || (await this.generateIvBinary());
+        return this.cipher.encrypt(contentBinary, keyBinary, ivBinary);
+    }
+    async decrypt(content, keyBinary) {
+        return this.cipher.decrypt(content, keyBinary);
+    }
+    async getKeyAccessObjects(policy, keyInfo) {
+        const splitIds = [...new Set(this.keyAccess.map(({ sid }) => sid))].sort((a, b) => a.localeCompare(b));
+        const unwrappedKeySplitBuffers = await keySplit(new Uint8Array(keyInfo.unwrappedKeyBinary.asByteArray()), splitIds.length, this.cryptoService);
+        const splitsByName = Object.fromEntries(splitIds.map((sid, index) => [sid, unwrappedKeySplitBuffers[index]]));
+        const keyAccessObjects = [];
+        for (const item of this.keyAccess) {
+            // use the key split to encrypt metadata for each key access object
+            const unwrappedKeySplitBuffer = splitsByName[item.sid];
+            const unwrappedKeySplitBinary = Binary.fromArrayBuffer(unwrappedKeySplitBuffer.buffer);
+            const metadata = item.metadata || '';
+            const metadataStr = (typeof metadata === 'object'
+                ? JSON.stringify(metadata)
+                : typeof metadata === 'string'
+                    ? metadata
+                    : () => {
+                        throw new ConfigurationError("KAO generation failure: metadata isn't a string or object");
+                    });
+            const metadataBinary = Binary.fromArrayBuffer(new TextEncoder().encode(metadataStr));
+            const encryptedMetadataResult = await this.encrypt(metadataBinary, unwrappedKeySplitBinary, keyInfo.unwrappedKeyIvBinary);
+            const encryptedMetadataOb = {
+                ciphertext: base64.encode(encryptedMetadataResult.payload.asString()),
+                iv: base64.encode(keyInfo.unwrappedKeyIvBinary.asString()),
+            };
+            const encryptedMetadataStr = JSON.stringify(encryptedMetadataOb);
+            const keyAccessObject = await item.write(policy, unwrappedKeySplitBuffer, encryptedMetadataStr);
+            keyAccessObjects.push(keyAccessObject);
+        }
+        return keyAccessObjects;
+    }
+    async generateIvBinary() {
+        const iv = await this.cipher.generateInitializationVector();
+        return Binary.fromString(hex.decode(iv));
+    }
+    async write(policy, keyInfo) {
+        const algorithm = this.cipher?.name;
+        if (!algorithm) {
+            // Hard coded as part of the cipher object. This should not be reachable.
+            throw new ConfigurationError('uninitialized cipher type');
+        }
+        const keyAccessObjects = await this.getKeyAccessObjects(policy, keyInfo);
+        // For now we're only concerned with a single (first) key access object
+        const policyForManifest = base64.encode(JSON.stringify(policy));
+        return {
+            type: 'split',
+            keyAccess: keyAccessObjects,
+            method: {
+                algorithm,
+                isStreamable: false,
+                iv: base64.encode(keyInfo.unwrappedKeyIvBinary.asString()),
+            },
+            integrityInformation: {
+                rootSignature: {
+                    alg: 'HS256',
+                    sig: '',
+                },
+                segmentHashAlg: 'GMAC',
+                segments: [],
+            },
+            policy: policyForManifest,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/web/tdf3/src/models/index.js

@@ -0,0 +1,9 @@
+export * from './attribute-set.js';
+export * from './encryption-information.js';
+export * from './key-access.js';
+export * from './manifest.js';
+export * from './payload.js';
+export * from './policy.js';
+export * from './upsert-response.js';
+export * from '../assertions.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi90ZGYzL3NyYy9tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGtCQUFrQixDQUFDIn0=

package/dist/web/tdf3/src/models/key-access.js

@@ -0,0 +1,74 @@
+import { Binary } from '../binary.js';
+import { base64, hex } from '../../../src/encodings/index.js';
+import * as cryptoService from '../crypto/index.js';
+export function isRemote(keyAccessJSON) {
+    return keyAccessJSON.type === 'remote';
+}
+export class Wrapped {
+    constructor(url, kid, publicKey, metadata, sid) {
+        this.url = url;
+        this.kid = kid;
+        this.publicKey = publicKey;
+        this.metadata = metadata;
+        this.sid = sid;
+        this.type = 'wrapped';
+    }
+    async write(policy, keyBuffer, encryptedMetadataStr) {
+        const policyStr = JSON.stringify(policy);
+        const unwrappedKeyBinary = Binary.fromArrayBuffer(keyBuffer.buffer);
+        const wrappedKeyBinary = await cryptoService.encryptWithPublicKey(unwrappedKeyBinary, this.publicKey);
+        const policyBinding = await cryptoService.hmac(hex.encodeArrayBuffer(keyBuffer), base64.encode(policyStr));
+        this.keyAccessObject = {
+            type: 'wrapped',
+            url: this.url,
+            protocol: 'kas',
+            wrappedKey: base64.encode(wrappedKeyBinary.asString()),
+            encryptedMetadata: base64.encode(encryptedMetadataStr),
+            policyBinding: {
+                alg: 'HS256',
+                hash: base64.encode(policyBinding),
+            },
+        };
+        if (this.kid) {
+            this.keyAccessObject.kid = this.kid;
+        }
+        if (this.sid?.length) {
+            this.keyAccessObject.sid = this.sid;
+        }
+        return this.keyAccessObject;
+    }
+}
+export class Remote {
+    constructor(url, kid, publicKey, metadata, sid) {
+        this.url = url;
+        this.kid = kid;
+        this.publicKey = publicKey;
+        this.metadata = metadata;
+        this.sid = sid;
+        this.type = 'remote';
+    }
+    async write(policy, keyBuffer, encryptedMetadataStr) {
+        const policyStr = JSON.stringify(policy);
+        const policyBinding = await cryptoService.hmac(hex.encodeArrayBuffer(keyBuffer), base64.encode(policyStr));
+        const unwrappedKeyBinary = Binary.fromArrayBuffer(keyBuffer.buffer);
+        const wrappedKeyBinary = await cryptoService.encryptWithPublicKey(unwrappedKeyBinary, this.publicKey);
+        // this.wrappedKey = wrappedKeyBinary.asBuffer().toString('hex');
+        this.wrappedKey = base64.encode(wrappedKeyBinary.asString());
+        this.keyAccessObject = {
+            type: 'remote',
+            url: this.url,
+            protocol: 'kas',
+            wrappedKey: this.wrappedKey,
+            encryptedMetadata: base64.encode(encryptedMetadataStr),
+            policyBinding: {
+                alg: 'HS256',
+                hash: base64.encode(policyBinding),
+            },
+        };
+        if (this.kid) {
+            this.keyAccessObject.kid = this.kid;
+        }
+        return this.keyAccessObject;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/web/tdf3/src/models/manifest.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFuaWZlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi90ZGYzL3NyYy9tb2RlbHMvbWFuaWZlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/web/tdf3/src/models/payload.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF5bG9hZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3RkZjMvc3JjL21vZGVscy9wYXlsb2FkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/web/tdf3/src/models/policy.js

@@ -0,0 +1,20 @@
+import { ConfigurationError } from '../../../src/errors.js';
+export const CURRENT_VERSION = '1.1.0';
+export function validatePolicyObject(policyMaybe) {
+    if (typeof policyMaybe !== 'object') {
+        throw new ConfigurationError(`The given policy reference must be an object, not: ${policyMaybe}`);
+    }
+    const policy = policyMaybe;
+    const missingFields = [];
+    if (!policy.uuid)
+        missingFields.push('uuid');
+    if (!policy.body)
+        missingFields.push('body', 'body.dissem');
+    if (policy.body && !policy.body.dissem)
+        missingFields.push('body.dissem');
+    if (missingFields.length) {
+        throw new ConfigurationError(`The given policy object requires the following properties: ${missingFields}`);
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9saWN5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vdGRmMy9zcmMvbW9kZWxzL3BvbGljeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUc1RCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsT0FBTyxDQUFDO0FBYXZDLE1BQU0sVUFBVSxvQkFBb0IsQ0FBQyxXQUFvQjtJQUN2RCxJQUFJLE9BQU8sV0FBVyxLQUFLLFFBQVEsRUFBRTtRQUNuQyxNQUFNLElBQUksa0JBQWtCLENBQzFCLHNEQUFzRCxXQUFXLEVBQUUsQ0FDcEUsQ0FBQztLQUNIO0lBQ0QsTUFBTSxNQUFNLEdBQUcsV0FBcUIsQ0FBQztJQUNyQyxNQUFNLGFBQWEsR0FBRyxFQUFFLENBQUM7SUFDekIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJO1FBQUUsYUFBYSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUM3QyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUk7UUFBRSxhQUFhLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxhQUFhLENBQUMsQ0FBQztJQUM1RCxJQUFJLE1BQU0sQ0FBQyxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU07UUFBRSxhQUFhLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFDO0lBRTFFLElBQUksYUFBYSxDQUFDLE1BQU0sRUFBRTtRQUN4QixNQUFNLElBQUksa0JBQWtCLENBQzFCLDhEQUE4RCxhQUFhLEVBQUUsQ0FDOUUsQ0FBQztLQUNIO0lBQ0QsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDIn0=