@icure/api 5.0.25 → 5.0.27

package/icc-x-api/icc-crypto-x-api.js

@@ -415,8 +415,9 @@ class IccCryptoXApi {
                 const { owner: modifiedOwner, aesExchangeKeys } = yield this.getOrCreateHcPartyKeys(owner, ownerId);
                 const importedAESHcPartyKey = yield this.decryptAnyAesExchangeKeyForOwner(aesExchangeKeys, ownerId, ownerId, ownerId, publicKeys);
                 const encryptedDelegation = yield this._AES.encrypt(importedAESHcPartyKey.key, (0, binary_utils_1.string2ua)(createdObject.id + ':' + secretId).buffer, importedAESHcPartyKey.rawKey);
-                const encryptedSecretForeignKey = parentObject &&
-                    this._AES.encrypt(importedAESHcPartyKey.key, (0, binary_utils_1.string2ua)(createdObject.id + ':' + parentObject.id).buffer, importedAESHcPartyKey.rawKey);
+                const encryptedSecretForeignKey = parentObject
+                    ? yield this._AES.encrypt(importedAESHcPartyKey.key, (0, binary_utils_1.string2ua)(createdObject.id + ':' + parentObject.id).buffer, importedAESHcPartyKey.rawKey)
+                    : undefined;
                 return {
                     owner: modifiedOwner,
                     delegations: _.fromPairs([
@@ -431,8 +432,8 @@ class IccCryptoXApi {
                             ],
                         ],
                     ]),
-                    cryptedForeignKeys: (encryptedSecretForeignKey &&
-                        _.fromPairs([
+                    cryptedForeignKeys: (encryptedSecretForeignKey
+                        ? _.fromPairs([
                             [
                                 ownerId,
                                 [
@@ -443,8 +444,8 @@ class IccCryptoXApi {
                                     },
                                 ],
                             ],
-                        ])) ||
-                        {},
+                        ])
+                        : _) || {},
                     secretForeignKeys: (secretForeignKeyOfParent && [secretForeignKeyOfParent]) || [],
                     secretId: secretId,
                 };
@@ -670,50 +671,46 @@ class IccCryptoXApi {
         return __awaiter(this, arguments, void 0, function* () {
             this.throwDetailedExceptionForInvalidParameter('modifiedObject.id', modifiedObject.id, 'appendEncryptionKeys', arguments); //modifiedObject should never be null
             this.throwDetailedExceptionForInvalidParameter('secretEncryptionKeyOfObject', secretEncryptionKeyOfObject, 'appendEncryptionKeys', arguments);
-            return this.getDataOwner(ownerId)
-                .then(({ dataOwner: owner }) => __awaiter(this, void 0, void 0, function* () {
-                const publicKeys = yield this.getPublicKeys();
-                const { owner: modifiedOwner, aesExchangeKeys } = yield this.getOrCreateHcPartyKeys(owner, delegateId);
-                const importedAESHcPartyKey = yield this.decryptAnyAesExchangeKeyForOwner(aesExchangeKeys, ownerId, ownerId, delegateId, publicKeys);
-                return {
-                    previousDecryptedEncryptionKeys: yield Promise.all(((modifiedObject.encryptionKeys || {})[delegateId] || []).map((d) => (d.key &&
-                        d.owner === ownerId &&
-                        this._AES.decrypt(importedAESHcPartyKey.key, (0, binary_utils_1.hex2ua)(d.key), importedAESHcPartyKey.rawKey).catch(() => {
-                            console.log(`Cannot decrypt encryption key from ${d.owner} to ${d.delegatedTo} for object with id ${modifiedObject.id}:`, modifiedObject);
-                            return Promise.resolve();
-                        })) ||
-                        Promise.resolve())),
-                    encryptedEncryptionKey: yield this._AES.encrypt(importedAESHcPartyKey.key, (0, binary_utils_1.string2ua)(modifiedObject.id + ':' + secretEncryptionKeyOfObject)),
-                };
-            }))
-                .then(({ previousDecryptedEncryptionKeys, encryptedEncryptionKey }) => {
-                //try to limit the extent of the modifications to the delegations by preserving the redundant encryption keys already present and removing duplicates
-                //For delegate delegateId, we create:
-                // 1. an array of objects { d : {owner,delegatedTo,encrypted(key)}} with one object for the existing encryption keys and the new key concatenated
-                // 2. an array of objects { k : decrypted(key)} with one object for the existing delegations and the new key concatenated
-                // We merge them to get one array of objects: { d: {owner,delegatedTo,encrypted(key)}, k: decrypted(key)}
-                const encryptionKeysCryptedDecrypted = _.merge(((modifiedObject.encryptionKeys || {})[delegateId] || []).map((d) => ({
-                    d,
-                })), (previousDecryptedEncryptionKeys || []).map((dd) => (dd ? (0, binary_utils_1.ua2string)(dd) : null)).map((k) => ({ k })))
-                    .filter(({ d, k }) => !!k || d.owner !== ownerId) //Only keep the ones created by us that can still be decrypted
-                    .map(({ d, k }) => ({ d, k: k || this.randomUuid() }))
-                    .concat([
-                    {
-                        d: {
-                            owner: ownerId,
-                            delegatedTo: delegateId,
-                            key: (0, binary_utils_1.ua2hex)(encryptedEncryptionKey),
-                        },
-                        k: modifiedObject.id + ':' + secretEncryptionKeyOfObject,
+            const owner = (yield this.getDataOwner(ownerId)).dataOwner;
+            const publicKeys = yield this.getPublicKeys();
+            const { owner: modifiedOwner, aesExchangeKeys } = yield this.getOrCreateHcPartyKeys(owner, delegateId);
+            modifiedObject = (modifiedObject === null || modifiedObject === void 0 ? void 0 : modifiedObject.id) === owner.id ? modifiedOwner : modifiedObject;
+            const importedAESHcPartyKey = yield this.decryptAnyAesExchangeKeyForOwner(aesExchangeKeys, ownerId, ownerId, delegateId, publicKeys);
+            const previousDecryptedEncryptionKeys = yield Promise.all(((modifiedObject.encryptionKeys || {})[delegateId] || []).map((d) => (d.key &&
+                d.owner === ownerId &&
+                this._AES.decrypt(importedAESHcPartyKey.key, (0, binary_utils_1.hex2ua)(d.key), importedAESHcPartyKey.rawKey).catch(() => {
+                    console.log(`Cannot decrypt encryption key from ${d.owner} to ${d.delegatedTo} for object with id ${modifiedObject.id}:`, modifiedObject);
+                    return Promise.resolve();
+                })) ||
+                Promise.resolve()));
+            const encryptedEncryptionKey = yield this._AES.encrypt(importedAESHcPartyKey.key, (0, binary_utils_1.string2ua)(modifiedObject.id + ':' + secretEncryptionKeyOfObject));
+            //try to limit the extent of the modifications to the delegations by preserving the redundant encryption keys already present and removing duplicates
+            //For delegate delegateId, we create:
+            // 1. an array of objects { d : {owner,delegatedTo,encrypted(key)}} with one object for the existing encryption keys and the new key concatenated
+            // 2. an array of objects { k : decrypted(key)} with one object for the existing delegations and the new key concatenated
+            // We merge them to get one array of objects: { d: {owner,delegatedTo,encrypted(key)}, k: decrypted(key)}
+            const encryptionKeysCryptedDecrypted = _.merge(((modifiedObject.encryptionKeys || {})[delegateId] || []).map((d) => ({
+                d,
+            })), (previousDecryptedEncryptionKeys || []).map((dd) => (dd ? (0, binary_utils_1.ua2string)(dd) : null)).map((k) => ({ k })))
+                .filter(({ d, k }) => !!k || d.owner !== ownerId) //Only keep the ones created by us that can still be decrypted
+                .map(({ d, k }) => ({ d, k: k || this.randomUuid() }))
+                .concat([
+                {
+                    d: {
+                        owner: ownerId,
+                        delegatedTo: delegateId,
+                        key: (0, binary_utils_1.ua2hex)(encryptedEncryptionKey),
                     },
-                ]);
-                const allEncryptionKeys = _.cloneDeep(modifiedObject.encryptionKeys);
-                allEncryptionKeys[delegateId] = _.uniqBy(encryptionKeysCryptedDecrypted, (x) => x.k).map((x) => x.d);
-                return {
-                    encryptionKeys: allEncryptionKeys,
-                    secretId: secretEncryptionKeyOfObject,
-                };
-            });
+                    k: modifiedObject.id + ':' + secretEncryptionKeyOfObject,
+                },
+            ]);
+            const allEncryptionKeys = _.cloneDeep(modifiedObject.encryptionKeys || {});
+            allEncryptionKeys[delegateId] = _.uniqBy(encryptionKeysCryptedDecrypted, (x) => x.k).map((x) => x.d);
+            return {
+                modifiedObject: modifiedObject,
+                encryptionKeys: allEncryptionKeys,
+                secretId: secretEncryptionKeyOfObject,
+            };
         });
     }
     /**
@@ -731,25 +728,18 @@ class IccCryptoXApi {
     addDelegationsAndEncryptionKeys(
     //TODO: suggested name: updateChildGenericDelegationsFromDelegatorToDelegate
     parent, child, ownerId, delegateId, secretDelegationKey, secretEncryptionKey) {
-        if (parent)
-            this.throwDetailedExceptionForInvalidParameter('parent.id', parent.id, 'addDelegationsAndEncryptionKeys', arguments);
-        this.throwDetailedExceptionForInvalidParameter('child.id', child.id, 'addDelegationsAndEncryptionKeys', arguments);
-        return (secretDelegationKey
-            ? this.extendedDelegationsAndCryptedForeignKeys(child, parent, ownerId, delegateId, secretDelegationKey)
-            : Promise.resolve({ modifiedObject: child, delegations: {}, cryptedForeignKeys: {}, secretId: null }))
-            .then((extendedChildObjectSPKsAndCFKs) => secretEncryptionKey
-            ? this.appendEncryptionKeys(extendedChildObjectSPKsAndCFKs.modifiedObject, ownerId, delegateId, secretEncryptionKey).then(
-            //TODO: extendedDelegationsAndCryptedForeignKeys and appendEncryptionKeys can be done in parallel
-            (extendedChildObjectEKs) => ({
-                extendedSPKsAndCFKs: extendedChildObjectSPKsAndCFKs,
-                extendedEKs: extendedChildObjectEKs,
-            }))
-            : Promise.resolve({
-                extendedSPKsAndCFKs: extendedChildObjectSPKsAndCFKs,
-                extendedEKs: { encryptionKeys: {} },
-            }))
-            .then(({ extendedSPKsAndCFKs: extendedChildObjectSPKsAndCFKs, extendedEKs: extendedChildObjectEKs }) => {
-            return _.assign(extendedChildObjectSPKsAndCFKs.modifiedObject, {
+        return __awaiter(this, arguments, void 0, function* () {
+            if (parent)
+                this.throwDetailedExceptionForInvalidParameter('parent.id', parent.id, 'addDelegationsAndEncryptionKeys', arguments);
+            this.throwDetailedExceptionForInvalidParameter('child.id', child.id, 'addDelegationsAndEncryptionKeys', arguments);
+            const extendedChildObjectSPKsAndCFKs = secretDelegationKey
+                ? yield this.extendedDelegationsAndCryptedForeignKeys(child, parent, ownerId, delegateId, secretDelegationKey)
+                : { modifiedObject: child, delegations: {}, cryptedForeignKeys: {}, secretId: null };
+            const extendedChildObjectEKs = secretEncryptionKey
+                ? yield this.appendEncryptionKeys(extendedChildObjectSPKsAndCFKs.modifiedObject, ownerId, delegateId, secretEncryptionKey)
+                : { encryptionKeys: {}, modifiedObject: extendedChildObjectSPKsAndCFKs.modifiedObject };
+            const latestObject = extendedChildObjectEKs.modifiedObject;
+            return _.assign(latestObject, {
                 // Conservative version ... We might want to be more aggressive with the deduplication of keys
                 // For each delegate, we are going to concatenate to the src (the new delegations), the object in dest (the current delegations)
                 // for which we do not find an equivalent delegation (same delegator, same delegate)
@@ -1341,24 +1331,44 @@ class IccCryptoXApi {
     }
     addNewKeyPairForOwner(maintenanceTasksApi, user, cdo, generateTransferKey = true) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { publicKey, privateKey } = yield this.RSA.generateKeyPair();
-            const publicKeyHex = (0, binary_utils_1.ua2hex)(yield this.RSA.exportKey(publicKey, 'spki'));
+            const generatedKeypair = yield this.RSA.generateKeyPair();
+            return this.addKeyPairForOwner(maintenanceTasksApi, user, cdo, generatedKeypair, generateTransferKey);
+        });
+    }
+    addRawKeyPairForOwnerId(maintenanceTasksApi, user, ownerId, keypair, generateTransferKey = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.addRawKeyPairForOwner(maintenanceTasksApi, user, yield this.getDataOwner(ownerId), keypair, generateTransferKey);
+        });
+    }
+    addRawKeyPairForOwner(maintenanceTasksApi, user, cdo, keypair, generateTransferKey = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const importedPrivateKey = yield this._RSA.importKey('pkcs8', (0, binary_utils_1.hex2ua)(keypair.privateKey), ['decrypt']);
+            const importedPublicKey = yield this._RSA.importKey('spki', (0, binary_utils_1.hex2ua)(keypair.publicKey), ['encrypt']);
+            return this.addKeyPairForOwner(maintenanceTasksApi, user, cdo, { publicKey: importedPublicKey, privateKey: importedPrivateKey }, generateTransferKey);
+        });
+    }
+    addKeyPairForOwner(maintenanceTasksApi, user, cdo, keypair, generateTransferKey = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const publicKeyHex = (0, binary_utils_1.ua2hex)(yield this.RSA.exportKey(keypair.publicKey, 'spki'));
             const gen = (yield this._AES.generateCryptoKey(true));
-            yield this.cacheKeyPair({ publicKey: yield this.RSA.exportKey(publicKey, 'jwk'), privateKey: yield this.RSA.exportKey(privateKey, 'jwk') });
+            yield this.cacheKeyPair({
+                publicKey: yield this.RSA.exportKey(keypair.publicKey, 'jwk'),
+                privateKey: yield this.RSA.exportKey(keypair.privateKey, 'jwk'),
+            });
             const { type: ownerType, dataOwner: ownerToUpdate } = yield this.createOrUpdateAesExchangeKeysFor(cdo, gen, {
-                pubKey: publicKey,
-                privKey: privateKey,
+                pubKey: keypair.publicKey,
+                privKey: keypair.privateKey,
             }).then((dataOwnerWithUpdatedAesKeys) => generateTransferKey
-                ? this.createOrUpdateTransferKeysFor(dataOwnerWithUpdatedAesKeys, gen, { pubKey: publicKey, privKey: privateKey })
+                ? this.createOrUpdateTransferKeysFor(dataOwnerWithUpdatedAesKeys, gen, { pubKey: keypair.publicKey, privKey: keypair.privateKey })
                 : dataOwnerWithUpdatedAesKeys);
             const modifiedDataOwnerAndType = yield this._saveDataOwner({ type: ownerType, dataOwner: ownerToUpdate });
-            const sentMaintenanceTasks = yield this.sendMaintenanceTasks(maintenanceTasksApi, user, modifiedDataOwnerAndType.dataOwner, publicKey);
+            const sentMaintenanceTasks = yield this.sendMaintenanceTasks(maintenanceTasksApi, user, modifiedDataOwnerAndType.dataOwner, keypair.publicKey);
             return {
                 dataOwner: sentMaintenanceTasks.length
                     ? yield this.retrieveDataOwnerInfoAfterPotentialUpdate(modifiedDataOwnerAndType.dataOwner)
                     : modifiedDataOwnerAndType.dataOwner,
                 publicKey: publicKeyHex,
-                privateKey: (0, binary_utils_1.ua2hex)((yield this.RSA.exportKey(privateKey, 'pkcs8'))),
+                privateKey: (0, binary_utils_1.ua2hex)((yield this.RSA.exportKey(keypair.privateKey, 'pkcs8'))),
             };
         });
     }