@opentdf/sdk 0.1.0-beta.1701

package/dist/web/src/errors.js

@@ -0,0 +1,123 @@
+function scrubCause(error, d) {
+    if (!error || (d && d > 4)) {
+        return {};
+    }
+    if (!error.name) {
+        return {};
+    }
+    const cause = new Error(error.name, scrubCause(error.cause, (d || 0) + 1));
+    if (error.message) {
+        cause.message = error.message;
+    }
+    if (error.stack) {
+        cause.stack = error.stack;
+    }
+    return { cause };
+}
+/**
+ * Root class for all errors thrown by this library.
+ * This should not be thrown directly, but rather one of its subclasses.
+ */
+export class TdfError extends Error {
+    constructor(message, cause) {
+        super(message, scrubCause(cause));
+        this.name = 'TdfError';
+        // Error is funny (only on ES5? So  guess just IE11 we have to worry about?)
+        // https://github.com/Microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+        // https://stackoverflow.com/questions/41102060/typescript-extending-error-class#comment70895020_41102306
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/**
+ * Errors that indicate the client or method does not have valid options.
+ */
+export class ConfigurationError extends TdfError {
+    constructor() {
+        super(...arguments);
+        this.name = 'ConfigurationError';
+    }
+}
+/**
+ * The assigned data attribute is not in the correct form.
+ */
+export class AttributeValidationError extends ConfigurationError {
+    constructor(message, attribute, cause) {
+        super(message, cause);
+        this.name = 'AttributeValidationError';
+        this.attribute = attribute;
+    }
+}
+/**
+ * Errors that indicate the TDF object is corrupt, invalid, or fails validation or decrypt.
+ */
+export class InvalidFileError extends TdfError {
+}
+/**
+ * Indicates a decrypt failure, either due to an incorrect key, corrupt ciphertext, or inappropriate key parameters.
+ */
+export class DecryptError extends InvalidFileError {
+    constructor() {
+        super(...arguments);
+        this.name = 'DecryptError';
+    }
+}
+export class IntegrityError extends InvalidFileError {
+    constructor() {
+        super(...arguments);
+        this.name = 'IntegrityError';
+    }
+}
+/**
+ * Thrown when a KAS URL found in one or more required key access objects are not in the list of known and allowed KASes in the client.
+ * This may indicate a malicious file - e.g. an attempt to DDoS a server by listing it as the KAS for many files, or to siphon credentials using a lookalike URL.
+ */
+export class UnsafeUrlError extends InvalidFileError {
+    constructor(message, ...url) {
+        super(message);
+        this.name = 'UnsafeUrlError';
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.url = url;
+    }
+}
+/**
+ * A network error (no response) from rewrap or other endpoint, Possibly fixed by retrying or adjusting your network settings; could indicate network failure.
+ */
+export class NetworkError extends TdfError {
+    constructor() {
+        super(...arguments);
+        this.name = 'NetworkError';
+    }
+}
+/**
+ * The service reports an unexpected error on its behalf, or a subcomponent (5xx).
+ */
+export class ServiceError extends TdfError {
+    constructor() {
+        super(...arguments);
+        this.name = 'ServiceError';
+    }
+}
+/** Authentication failure (401) */
+export class UnauthenticatedError extends TdfError {
+    constructor() {
+        super(...arguments);
+        this.name = 'UnauthenticatedError';
+    }
+}
+/** Authorization failure (403) */
+export class PermissionDeniedError extends TdfError {
+    constructor() {
+        super(...arguments);
+        this.name = 'PermissionDeniedError';
+    }
+}
+/**
+ * Version of file is unsupported, or file uses a feature that is not supported by this version of the library.
+ */
+export class UnsupportedFeatureError extends TdfError {
+    constructor() {
+        super(...arguments);
+        this.name = 'UnsupportedFeatureError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/web/src/index.js

@@ -0,0 +1,313 @@
+import { Client, NanoTDF, encrypt, decrypt, encryptDataset, getHkdfSalt, DefaultParams, } from './nanotdf/index.js';
+import { keyAgreement } from './nanotdf-crypto/index.js';
+import { createAttribute, Policy } from './tdf/index.js';
+import { fetchECKasPubKey } from './access.js';
+import { ConfigurationError } from './errors.js';
+export { attributeFQNsAsValues } from './policy/api.js';
+// Define default options
+const defaultOptions = {
+    ecdsaBinding: false,
+};
+/**
+ * NanoTDF SDK Client
+ *
+ * @example
+ * ```
+ * import { clientSecretAuthProvider, NanoTDFClient } from '@opentdf/sdk';
+ *
+ * const OIDC_ENDPOINT = 'http://localhost:65432/auth/realms/opentdf-demo';
+ * const KAS_URL = 'http://localhost:65432/api/kas/';
+ *
+ * const ciphertext = '...';
+ * const client = new NanoTDFClient({
+ *   authProvider: await clientSecretAuthProvider({
+ *     clientId: 'tdf-client',
+ *     clientSecret: '123-456',
+ *     oidcOrigin: OIDC_ENDPOINT,
+ *   }),
+ *   kasEndpoint: KAS_URL
+ *  }
+ * );
+ * client.decrypt(ciphertext)
+ *   .then(plaintext => {
+ *     console.log('Plaintext', plaintext);
+ *   })
+ *   .catch(err => {
+ *     console.error('Some error occurred', err);
+ *   })
+ */
+export class NanoTDFClient extends Client {
+    /**
+     * Decrypt ciphertext
+     *
+     * Pass a base64 string, TypedArray, or ArrayBuffer ciphertext and get a promise which resolves plaintext
+     *
+     * @param ciphertext Ciphertext to decrypt
+     */
+    async decrypt(ciphertext) {
+        // Parse ciphertext
+        const nanotdf = NanoTDF.from(ciphertext);
+        await this.fetchOIDCToken();
+        // TODO: The version number should be fetched from the API
+        const version = '0.0.1';
+        const kasUrl = nanotdf.header.getKasRewrapUrl();
+        // Rewrap key on every request
+        const ukey = await this.rewrapKey(nanotdf.header.toBuffer(), kasUrl, nanotdf.header.magicNumberVersion, version);
+        if (!ukey) {
+            throw new Error('internal: key rewrap failure');
+        }
+        // Return decrypt promise
+        return decrypt(ukey, nanotdf);
+    }
+    /**
+     * Decrypt ciphertext of the legacy TDF, with the older, smaller i.v. calculation.
+     *
+     * Pass a base64 string, TypedArray, or ArrayBuffer ciphertext and get a promise which resolves plaintext
+     *
+     * @param ciphertext Ciphertext to decrypt
+     */
+    async decryptLegacyTDF(ciphertext) {
+        // Parse ciphertext
+        const nanotdf = NanoTDF.from(ciphertext, undefined, true);
+        await this.fetchOIDCToken();
+        const legacyVersion = '0.0.0';
+        // Rewrap key on every request
+        const key = await this.rewrapKey(nanotdf.header.toBuffer(), nanotdf.header.getKasRewrapUrl(), nanotdf.header.magicNumberVersion, legacyVersion);
+        if (!key) {
+            throw new Error('internal: failed unwrap');
+        }
+        // Return decrypt promise
+        return decrypt(key, nanotdf);
+    }
+    /**
+     * Encrypts the given data using the NanoTDF encryption scheme.
+     *
+     * @param {string | TypedArray | ArrayBuffer} data - The data to be encrypted.
+     * @param {EncryptOptions} [options=defaultOptions] - The encryption options (currently unused).
+     * @returns {Promise<ArrayBuffer>} A promise that resolves to the encrypted data as an ArrayBuffer.
+     * @throws {Error} If the initialization vector is not a number.
+     */
+    async encrypt(data, options) {
+        // For encrypt always generate the client ephemeralKeyPair
+        const ephemeralKeyPair = await this.ephemeralKeyPair;
+        const initializationVector = this.iv;
+        if (typeof initializationVector !== 'number') {
+            throw new ConfigurationError('NanoTDF clients are single use. Please generate a new client and keypair.');
+        }
+        delete this.iv;
+        if (!this.kasPubKey) {
+            this.kasPubKey = await fetchECKasPubKey(this.kasUrl);
+        }
+        // Create a policy for the tdf
+        const policy = new Policy();
+        // Add data attributes.
+        for (const dataAttribute of this.dataAttributes) {
+            const attribute = await createAttribute(dataAttribute, this.kasPubKey, this.kasUrl);
+            policy.addAttribute(attribute);
+        }
+        if (this.dissems.length == 0 && this.dataAttributes.length == 0) {
+            console.warn('This policy has an empty attributes list and an empty dissemination list. This will allow any entity with a valid Entity Object to access this TDF.');
+        }
+        // Encrypt the policy.
+        const policyObjectAsStr = policy.toJSON();
+        // IV is always '1', since the new keypair is generated on encrypt
+        // using the same key is fine.
+        const lengthAsUint32 = new Uint32Array(1);
+        lengthAsUint32[0] = initializationVector;
+        const lengthAsUint24 = new Uint8Array(lengthAsUint32.buffer);
+        // NOTE: We are only interested in only first 3 bytes.
+        const payloadIV = new Uint8Array(12).fill(0);
+        payloadIV[9] = lengthAsUint24[2];
+        payloadIV[10] = lengthAsUint24[1];
+        payloadIV[11] = lengthAsUint24[0];
+        const mergedOptions = { ...defaultOptions, ...options };
+        return encrypt(policyObjectAsStr, this.kasPubKey, ephemeralKeyPair, payloadIV, data, mergedOptions.ecdsaBinding);
+    }
+}
+/**
+ * NanoTDF Dataset SDK Client
+ *
+ *
+ * @example
+ * ```
+ * import { clientSecretAuthProvider, NanoTDFDatasetClient } from '@opentdf/sdk';
+ *
+ * const OIDC_ENDPOINT = 'http://localhost:65432/auth/realms/tdf';
+ * const KAS_URL = 'http://localhost:65432/api/kas/';
+ *
+ * const ciphertext = '...';
+ * const client = new NanoTDFDatasetClient({
+ *   authProvider: await clientSecretAuthProvider({
+ *     clientId: 'tdf-client',
+ *     clientSecret: '123-456',
+ *     exchange: 'client',
+ *     oidcOrigin: OIDC_ENDPOINT,
+ *   }),
+ *   kasEndpoint: KAS_URL,
+ * });
+ * const plaintext = client.decrypt(ciphertext);
+ * console.log('Plaintext', plaintext);
+ * ```
+ */
+export class NanoTDFDatasetClient extends Client {
+    /**
+     * Create new NanoTDF Dataset Client
+     *
+     * The Ephemeral Key Pair can either be provided or will be generate when fetching the entity object. Once set it
+     * cannot be changed. If a new ephemeral key is desired it a new client should be initialized.
+     * There is no performance impact for creating a new client IFF the ephemeral key pair is provided.
+     *
+     * @param clientConfig OIDC client credentials
+     * @param kasUrl Key access service URL
+     * @param ephemeralKeyPair (optional) ephemeral key pair to use
+     * @param maxKeyIterations Max iteration to performe without a key rotation
+     */
+    constructor(opts) {
+        if (opts.maxKeyIterations &&
+            opts.maxKeyIterations > NanoTDFDatasetClient.NTDF_MAX_KEY_ITERATIONS) {
+            throw new ConfigurationError(`key iteration exceeds max iterations(${NanoTDFDatasetClient.NTDF_MAX_KEY_ITERATIONS})`);
+        }
+        super(opts);
+        this.maxKeyIteration = opts.maxKeyIterations || NanoTDFDatasetClient.NTDF_MAX_KEY_ITERATIONS;
+        this.keyIterationCount = 0;
+    }
+    /**
+     * Encrypt data
+     *
+     * Pass a string, TypedArray, or ArrayBuffer data and get a promise which resolves ciphertext
+     *
+     * @param data to decrypt
+     */
+    async encrypt(data, options) {
+        // Intial encrypt
+        if (this.keyIterationCount == 0) {
+            const mergedOptions = { ...defaultOptions, ...options };
+            this.ecdsaBinding = mergedOptions.ecdsaBinding;
+            // For encrypt always generate the client ephemeralKeyPair
+            const ephemeralKeyPair = await this.ephemeralKeyPair;
+            if (!this.kasPubKey) {
+                this.kasPubKey = await fetchECKasPubKey(this.kasUrl);
+            }
+            // Create a policy for the tdf
+            const policy = new Policy();
+            // Add data attributes.
+            for (const dataAttribute of this.dataAttributes) {
+                const attribute = await createAttribute(dataAttribute, this.kasPubKey, this.kasUrl);
+                policy.addAttribute(attribute);
+            }
+            if (this.dissems.length == 0 || this.dataAttributes.length == 0) {
+                console.warn('This policy has an empty attributes list and an empty dissemination list. This will allow any entity with a valid Entity Object to access this TDF.');
+            }
+            // Encrypt the policy.
+            const policyObjectAsStr = policy.toJSON();
+            const ivVector = this.generateIV();
+            // Generate a symmetric key.
+            this.symmetricKey = await keyAgreement(ephemeralKeyPair.privateKey, await this.kasPubKey.key, await getHkdfSalt(DefaultParams.magicNumberVersion));
+            const nanoTDFBuffer = await encrypt(policyObjectAsStr, this.kasPubKey, ephemeralKeyPair, ivVector, data, this.ecdsaBinding);
+            // Cache the header and increment the key iteration
+            if (!this.cachedHeader) {
+                const nanoTDF = NanoTDF.from(nanoTDFBuffer);
+                this.cachedHeader = nanoTDF.header;
+            }
+            this.keyIterationCount += 1;
+            return nanoTDFBuffer;
+        }
+        this.keyIterationCount += 1;
+        if (!this.cachedHeader) {
+            throw new ConfigurationError('invalid dataset client: empty nanoTDF header');
+        }
+        if (!this.symmetricKey) {
+            throw new ConfigurationError('invalid dataset client: empty dek');
+        }
+        this.keyIterationCount += 1;
+        if (this.keyIterationCount == this.maxKeyIteration) {
+            // reset the key iteration
+            this.keyIterationCount = 0;
+        }
+        const ivVector = this.generateIV();
+        return encryptDataset(this.symmetricKey, this.cachedHeader, ivVector, data);
+    }
+    /**
+     * Decrypt ciphertext
+     *
+     * Pass a base64 string, TypedArray, or ArrayBuffer ciphertext and get a promise which resolves plaintext
+     *
+     * @param ciphertext Ciphertext to decrypt
+     */
+    async decrypt(ciphertext) {
+        // Parse ciphertext
+        const nanotdf = NanoTDF.from(ciphertext);
+        if (!this.cachedEphemeralKey) {
+            // First decrypt
+            return this.rewrapAndDecrypt(nanotdf);
+        }
+        // Other encrypts
+        if (this.cachedEphemeralKey.toString() == nanotdf.header.ephemeralPublicKey.toString()) {
+            const ukey = this.unwrappedKey;
+            if (!ukey) {
+                // These should have thrown already.
+                throw new Error('internal: key rewrap failure');
+            }
+            // Return decrypt promise
+            return decrypt(ukey, nanotdf);
+        }
+        else {
+            return this.rewrapAndDecrypt(nanotdf);
+        }
+    }
+    async rewrapAndDecrypt(nanotdf) {
+        // TODO: The version number should be fetched from the API
+        await this.fetchOIDCToken();
+        const version = '0.0.1';
+        // Rewrap key on every request
+        const ukey = await this.rewrapKey(nanotdf.header.toBuffer(), nanotdf.header.getKasRewrapUrl(), nanotdf.header.magicNumberVersion, version);
+        if (!ukey) {
+            // These should have thrown already.
+            throw new Error('internal: key rewrap failure');
+        }
+        this.cachedEphemeralKey = nanotdf.header.ephemeralPublicKey;
+        this.unwrappedKey = ukey;
+        // Return decrypt promise
+        return decrypt(ukey, nanotdf);
+    }
+    generateIV() {
+        const iv = this.iv;
+        if (iv === undefined) {
+            // iv has passed the maximum iteration count for this dek
+            throw new ConfigurationError('dataset full');
+        }
+        // assert iv ∈ ℤ ∩ (0, 2^24)
+        if (!Number.isInteger(iv) || iv <= 0 || 16777215 < iv) {
+            // Something has fiddled with the iv outside of the expected behavior
+            // could indicate a race condition, e.g. if two workers or handlers are
+            // processing the file at once, for example.
+            throw new Error('internal: invalid state');
+        }
+        const lengthAsUint32 = new Uint32Array(1);
+        lengthAsUint32[0] = iv;
+        const lengthAsUint24 = new Uint8Array(lengthAsUint32.buffer);
+        // NOTE: We are only interested in only first 3 bytes.
+        const ivVector = new Uint8Array(Client.IV_SIZE).fill(0);
+        ivVector[9] = lengthAsUint24[2];
+        ivVector[10] = lengthAsUint24[1];
+        ivVector[11] = lengthAsUint24[0];
+        // Increment the IV
+        if (iv == 16777215) {
+            delete this.iv;
+        }
+        else {
+            this.iv = iv + 1;
+        }
+        return ivVector;
+    }
+}
+// Total unique IVs(2^24 -1) used for encrypting the nano tdf payloads
+// IV starts from 1 since the 0 IV is reserved for policy encryption
+NanoTDFDatasetClient.NTDF_MAX_KEY_ITERATIONS = 8388606;
+/**
+ * Authorization for connecting authZ tokens to
+ * remote requests.
+ */
+export * as AuthProviders from './auth/providers.js';
+export { version, clientType } from './version.js';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"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"}