@icure/api 4.2.31 → 5.0.3

package/icc-x-api/icc-crypto-x-api.d.ts

@@ -1,11 +1,9 @@
-import { IccHcpartyApi, IccPatientApi } from '../icc-api';
+import { IccDeviceApi, IccHcpartyApi, IccPatientApi } from '../icc-api';
 import { AESUtils } from './crypto/AES';
 import { RSAUtils } from './crypto/RSA';
-import { UtilsClass } from './crypto/utils';
 import { ShamirClass } from './crypto/shamir';
-import * as models from '../icc-api/model/models';
-import { Device, HealthcareParty, Patient, User } from '../icc-api/model/models';
-import { IccDeviceApi } from '../icc-api';
+import { Delegation, Device, Document, EncryptedEntity, EncryptedParentEntity, HealthcareParty, Patient, User } from '../icc-api/model/models';
+import { IccMaintenanceTaskXApi } from './icc-maintenance-task-x-api';
 interface DelegatorAndKeys {
     delegatorId: string;
     key: CryptoKey;
@@ -24,7 +22,6 @@ declare type CachedDataOwner = {
 export declare class IccCryptoXApi {
     get crypto(): Crypto;
     get shamir(): ShamirClass;
-    get utils(): UtilsClass;
     get RSA(): RSAUtils;
     get AES(): AESUtils;
     hcPartyKeysCache: {
@@ -32,7 +29,11 @@ export declare class IccCryptoXApi {
     };
     hcPartyKeysRequestsCache: {
         [delegateId: string]: Promise<{
-            [delegatorId: string]: string;
+            [key: string]: {
+                [key: string]: {
+                    [key: string]: string;
+                };
+            };
         }>;
     };
     cacheLastDeletionTimestamp: number | undefined;
@@ -47,61 +48,69 @@ export declare class IccCryptoXApi {
      * @param delegateHcPartyId The Health Care Party id
      * @returns  \{delegatorId: delegateEncryptedHcPartyKey\}
      */
-    private getHcPartyKeysForDelegate;
-    private forceGetHcPartyKeysForDelegate;
+    private getEncryptedAesExchangeKeysForDelegate;
+    private forceGetEncryptedAesExchangeKeysForDelegate;
     keychainLocalStoreIdPrefix: string;
     keychainValidityDateLocalStoreIdPrefix: string;
     hcpPreferenceKeyEhealthCert: string;
     hcpPreferenceKeyEhealthCertDate: string;
+    rsaLocalStoreIdPrefix: string;
     private hcpartyBaseApi;
     private patientBaseApi;
     private deviceBaseApi;
-    private _crypto;
+    private readonly _crypto;
     private generateKeyConcurrencyMap;
-    private _AES;
-    private _RSA;
-    private _utils;
-    private _shamir;
+    private rsaKeyPairs;
+    private readonly _AES;
+    private readonly _RSA;
+    private readonly _shamir;
     constructor(host: string, headers: {
         [key: string]: string;
     }, hcpartyBaseApi: IccHcpartyApi, //Init with a hcparty x api for better performances
     patientBaseApi: IccPatientApi, deviceBaseApi: IccDeviceApi, crypto?: Crypto);
     randomUuid(): string;
     sha256(data: ArrayBuffer | Uint8Array): Promise<ArrayBuffer>;
-    encryptedShamirRSAKey(hcp: HealthcareParty, notaries: Array<HealthcareParty>, threshold?: number): Promise<HealthcareParty>;
-    decryptedShamirRSAKey(hcp: HealthcareParty, notaries: Array<HealthcareParty>): Promise<void>;
+    private getPublicKeys;
+    encryptShamirRSAKey(hcp: HealthcareParty, notaries: Array<HealthcareParty>, threshold?: number): Promise<HealthcareParty>;
+    decryptShamirRSAKey(hcp: HealthcareParty, notaries: Array<HealthcareParty>): Promise<void>;
     /**
      * Gets the decryptedHcPartyKey for the given `encryptedHcPartyKey`
      *
      * If the decrypted key exists in the cache, retrieves it from there.
      * Otherwise, decrypts it using the RSA key of the delegator or delegate (depending on the value of `encryptedForDelegator`)
-     * @param delegatorId : the id of the delegator HcP
-     * @param delegateHcPartyId : the id of the delegate HcP
-     * @param encryptedHcPartyKey : can be delegatorEncryptedHcPartyKey or delegateEncryptedHcPartyKey (depending on the value of `encryptedForDelegator`)
-     * @param encryptedForDelegator : default false - for the `encryptedHcPartyKey` RSA encrypted for delegate; true for the `encryptedHcPartyKey` RSA encrypted for delegator;
+     *
+     * @param loggedHcPartyId The logged DataOwner id or the id of his parent
+     * @param delegatorId The id of Delegator eg, the DataOwner where this AES exchange key is stored
+     * @param delegateHcPartyId The id of the delegate : the data owner for whom this aes exchange key has been created
+     * @param publicKey The public key of the delegator : A unique aes exchange key is created for each public key of the delegator. This is the public key corresponding to the encryptedHcPartyKeys
+     * @param encryptedHcPartyKeys The encryptedHcPartyKeys to be decrypted
+     * @param publicKeys The public keys for which we might have a private key
+     *
      * @returns - **delegatorId** the input param  `delegatorId`
      * - **key** the decrypted `encryptedHcPartyKey`
      */
-    decryptHcPartyKey(delegatorId: string, delegateHcPartyId: string, encryptedHcPartyKey: string, encryptedForDelegator?: boolean): Promise<DelegatorAndKeys>;
+    decryptHcPartyKey(loggedHcPartyId: string, delegatorId: string, delegateHcPartyId: string, publicKey: string, encryptedHcPartyKeys: {
+        [key: string]: string;
+    }, publicKeys: string[]): Promise<DelegatorAndKeys>;
     /**
      * Cache the RSA private/public key pair for the HcP with the given id `hcPartyKeyOwner`
      */
     cacheKeyPair(keyPairInJwk: {
-        publicKey: JsonWebKey | ArrayBuffer;
-        privateKey: JsonWebKey | ArrayBuffer;
-    }, hcPartyKeyOwner: string): Promise<{
+        publicKey: JsonWebKey;
+        privateKey: JsonWebKey;
+    }): Promise<{
         publicKey: CryptoKey;
         privateKey: CryptoKey;
     }>;
     /**
-     * Gets the secret ID (SFKs) that should be used in the prescribed context (condfidential or not) from decrypted SPKs of the given `parent`, decrypted by the HcP with the given `hcpartyId` AND by its HcP parents
-     * @param parent : the object of which delegations (SPKs) to decrypt
-     * @param hcpartyId : the id of the delegate HcP
-     * @param confidential : wether the key is going to be used for a confidential piece or data or not
+     * Gets the secret ID (SFKs) that should be used in the prescribed context (confidential or not) from decrypted SPKs of the given `parent`, decrypted by the HcP with the given `hcpartyId` AND by its HcP parents
+     * @param parent :the object of which delegations (SPKs) to decrypt
+     * @param hcpartyId :the id of the delegate HcP
+     * @param confidential :weather the key is going to be used for a confidential piece or data or not
      * @returns - **extractedKeys** array containing secret IDs (SFKs) from decrypted SPKs, from both given HcP and its parents ; can contain duplicates
      * - **hcpartyId** the given `hcpartyId` OR, if a parent exist, the HcP id of the top parent in the hierarchy  (even if that parent has no delegations)
      */
-    extractPreferredSfk(parent: models.Patient | models.Message, hcpartyId: string, confidential: boolean): Promise<string | null>;
+    extractPreferredSfk(parent: EncryptedParentEntity, hcpartyId: string, confidential: boolean): Promise<string | undefined>;
     /**
      * Gets an array of decrypted HcPartyKeys, shared between the delegate with ID `delegateHcPartyId` and the delegators in `delegatorsHcPartyIdsSet`
      *
@@ -126,25 +135,27 @@ export declare class IccCryptoXApi {
      * 3. Decrypt's delegators' keys and returns them.
      *
      * @param dataOwnerId : the id of the delegate HCP
-     * @param delegations : generic delegations (can be SPKs, CFKs, EKs) for all delegates
+     * @param delegations : delegations (can be SPKs, CFKs, EKs) for all delegates
      * @param fallbackOnParent  default true; use parent's healthCarePartyId in case there's no delegation for the `healthcarePartyId`
      * @returns  - **delegatorId** : the id of the delegator HcP that shares the **key** with the `healthcarePartyId`
      *  - **key** the decrypted HcPartyKey, shared between **delegatorId** and `healthcarePartyId`
      */
-    decryptAndImportAesHcPartyKeysInDelegations(dataOwnerId: string, delegations: {
-        [key: string]: Array<models.Delegation>;
+    getDecryptedAesExchangeKeysOfDelegateAndParentsFromGenericDelegations(dataOwnerId: string, delegations: {
+        [key: string]: Array<Delegation>;
     }, fallbackOnParent?: boolean): Promise<Array<DelegatorAndKeys>>;
     /**
-     * Retreive the owner HealthCareParty key and use it to encrypt
+     * Retrieve the owner HealthCareParty key and use it to encrypt
      * both the delegations (createdObject.id) and the cryptedForeignKeys
      * (parentObject.id), and returns them in an object.
      */
     initObjectDelegations(createdObject: any, parentObject: any, ownerId: string, secretForeignKeyOfParent: string | null): Promise<{
+        owner: HealthcareParty | Device | Patient;
         delegations: any;
         cryptedForeignKeys: any;
         secretForeignKeys: any[];
         secretId: string;
     }>;
+    private decryptAnyAesExchangeKeyForOwner;
     /**
      * Gets updated instances of SPKs and CKFs for the child object `modifiedObject`.
      * These updated SPKs and CKFs contain new SPKs/CFKs to provide delegation from delegator HcP with id `ownerId` to delegate HcP with id `delegateId`
@@ -167,16 +178,29 @@ export declare class IccCryptoXApi {
      * - **cryptedForeignKeys** existing CFKs of the `modifiedObject`, appended with results from steps 6
      * - **secretId** which is the given input parameter `secretIdOfModifiedObject`
      */
-    extendedDelegationsAndCryptedForeignKeys(modifiedObject: any | null, parentObject: any | null, ownerId: string, delegateId: string, secretIdOfModifiedObject: string | null): Promise<{
+    extendedDelegationsAndCryptedForeignKeys<T extends EncryptedEntity, P extends EncryptedParentEntity>(modifiedObject: T, parentObject: P | null, ownerId: string, delegateId: string, secretIdOfModifiedObject: string | null): Promise<{
+        modifiedObject: T;
         delegations: {
-            [key: string]: Array<models.Delegation>;
+            [key: string]: Array<Delegation>;
         };
         cryptedForeignKeys: {
-            [key: string]: Array<models.Delegation>;
+            [key: string]: Array<Delegation>;
         };
         secretId: string | null;
     }>;
-    getOrCreateHcPartyKey(owner: HealthcareParty | Patient, delegateId: string): PromiseLike<string>;
+    getEncryptedAesExchangeKeys(owner: HealthcareParty | Patient | Device, delegateId: string): Promise<{
+        [pubKeyIdentifier: string]: {
+            [pubKeyFingerprint: string]: string;
+        };
+    }>;
+    getOrCreateHcPartyKeys(owner: HealthcareParty | Patient | Device, delegateId: string): Promise<{
+        owner: HealthcareParty | Patient | Device;
+        aesExchangeKeys: {
+            [pubKeyIdentifier: string]: {
+                [pubKeyFingerprint: string]: string;
+            };
+        };
+    }>;
     /**
      * Retrieve the owners HealthCareParty key, decrypt it, and
      * use it to encrypt & initialize the "encryptionKeys" object
@@ -200,7 +224,7 @@ export declare class IccCryptoXApi {
      */
     appendEncryptionKeys(modifiedObject: any, ownerId: string, delegateId: string, secretEncryptionKeyOfObject: string): Promise<{
         encryptionKeys: {
-            [key: string]: Array<models.Delegation>;
+            [key: string]: Array<Delegation>;
         };
         secretId: string | null;
     }>;
@@ -216,7 +240,7 @@ export declare class IccCryptoXApi {
      * @param secretEncryptionKey  the secret Id used in the child object to generate the EK (Content Encryption Key)
      * @returns - an updated `child` object that will contain updated SPKs, CFKs, EKs
      *  */
-    addDelegationsAndEncryptionKeys<T extends models.AccessLog | models.Patient | models.Form | models.Contact | models.Invoice | models.Document | models.HealthElement | models.CalendarItem | models.Classification | models.Receipt>(parent: models.Patient | models.Message | null, child: T, ownerId: string, delegateId: string, secretDelegationKey: string | null, secretEncryptionKey: string | null): Promise<T>;
+    addDelegationsAndEncryptionKeys<T extends EncryptedEntity>(parent: EncryptedParentEntity | null, child: T, ownerId: string, delegateId: string, secretDelegationKey: string | null, secretEncryptionKey: string | null): Promise<T>;
     /**
      * Gets the secret IDs (SFKs) inside decrypted SPKs of the given `document`, decrypted by the HcP with the given `hcpartyId` AND by its HcP parents
      * @param document : the object of which delegations (SPKs) to decrypt
@@ -224,7 +248,7 @@ export declare class IccCryptoXApi {
      * @returns - **extractedKeys** array containing secret IDs (SFKs) from decrypted SPKs, from both given HcP and its parents ; can contain duplicates
      * - **hcpartyId** the given `hcpartyId` OR, if a parent exist, the HcP id of the top parent in the hierarchy  (even if that parent has no delegations)
      */
-    extractDelegationsSFKs(document: models.Patient | models.Message | models.Contact | models.Document | models.Invoice | models.HealthElement | models.Receipt | models.Classification | models.CalendarItem | null, hcpartyId?: string): Promise<{
+    extractDelegationsSFKs(document: EncryptedEntity | null, hcpartyId?: string): Promise<{
         extractedKeys: Array<string>;
         hcpartyId?: string;
     }>;
@@ -235,19 +259,19 @@ export declare class IccCryptoXApi {
      * @returns - **extractedKeys** array containing secret IDs (SFKs) from decrypted SPKs, from both given HcP and its parents ; can contain duplicates
      * - **hcpartyId** the given `hcpartyId` OR, if a parent exist, the HcP id of the top parent in the hierarchy  (even if that parent has no delegations)
      */
-    extractSFKsHierarchyFromDelegations(document: models.Patient | models.Message | models.Contact | models.Document | models.Invoice | models.HealthElement | models.Receipt | models.Classification | models.CalendarItem | null, hcpartyId?: string): Promise<Array<{
+    extractSFKsHierarchyFromDelegations(document: EncryptedEntity | null, hcpartyId?: string): Promise<Array<{
         hcpartyId: string;
         extractedKeys: Array<string>;
     }>>;
-    extractCryptedFKs(document: models.Patient | models.Message | models.Contact | models.Document | models.Invoice | models.HealthElement | models.Receipt | models.CalendarItem | models.Classification | null, hcpartyId: string): Promise<{
+    extractCryptedFKs(document: EncryptedEntity | null, hcpartyId: string): Promise<{
         extractedKeys: Array<string>;
         hcpartyId: string;
     }>;
-    extractEncryptionsSKs(document: models.Patient | models.Message | models.Contact | models.Document | models.Invoice | models.Receipt | models.HealthElement | models.Classification, hcpartyId: string): Promise<{
+    extractEncryptionsSKs(document: EncryptedEntity, hcpartyId: string): Promise<{
         extractedKeys: Array<string>;
         hcpartyId: string;
     }>;
-    extractDelegationsSFKsAndEncryptionSKs(ety: models.Patient | models.Contact | models.Invoice | models.Document | models.HealthElement, ownerId: string): Promise<[string[], string[]]>;
+    extractDelegationsSFKsAndEncryptionSKs(ety: EncryptedEntity, ownerId: string): Promise<[string[], string[]]>;
     /**
      * Get decrypted generic secret IDs (secretIdSPKs, parentIds, secretIdEKs) from generic delegations (SPKs, CFKs, EKs)
      * 1. Get HealthCareParty from it's Id.
@@ -261,7 +285,7 @@ export declare class IccCryptoXApi {
      * - **hcpartyId** the given `hcpartyId` OR, if a parent exist, the HCP id of the top parent in the hierarchy  (even if that parent has no delegations)
      */
     extractKeysHierarchyFromDelegationLikes(hcpartyId: string, objectId: string, delegations: {
-        [key: string]: Array<models.Delegation>;
+        [key: string]: Array<Delegation>;
     }): Promise<Array<{
         hcpartyId: string;
         extractedKeys: Array<string>;
@@ -279,7 +303,7 @@ export declare class IccCryptoXApi {
      * - **dataOwnerId** the given `dataOwnerId` OR, if a parent exist, the data owner id of the top parent in the hierarchy  (even if that parent has no delegations)
      */
     extractKeysFromDelegationsForHcpHierarchy(dataOwnerId: string, objectId: string, delegations: {
-        [key: string]: Array<models.Delegation>;
+        [key: string]: Array<Delegation>;
     }): Promise<{
         extractedKeys: Array<string>;
         hcpartyId: string;
@@ -296,14 +320,15 @@ export declare class IccCryptoXApi {
      * - even if there's no match, the secret ID is kept as a valid result (and a message logged to console)
      * @returns array of generic secret IDs (secretIdSPK, parentId, secretIdEK)
      */
-    decryptKeyInDelegationLikes(delegationsArray: Array<models.Delegation>, aesKeys: {
+    decryptKeyInDelegationLikes(delegationsArray: Array<Delegation>, aesKeysForDataOwnerId: {
         [key: string]: {
             key: CryptoKey;
             rawKey: string;
-        };
+        }[];
     }, masterId: string): Promise<Array<string>>;
+    getPublicKeyFromPrivateKey(privateKey: JsonWebKey, dataOwner: Patient | Device | HealthcareParty): string;
     loadKeyPairsAsTextInBrowserLocalStorage(healthcarePartyId: string, privateKey: Uint8Array): Promise<void>;
-    loadKeyPairsAsJwkInBrowserLocalStorage(healthcarePartyId: string, privKey: JsonWebKey): Promise<void>;
+    loadKeyPairsAsJwkInBrowserLocalStorage(healthcarePartyId: string, privateKey: JsonWebKey): Promise<void>;
     loadKeyPairsInBrowserLocalStorage(healthcarePartyId: string, file: Blob): Promise<void>;
     saveKeychainInBrowserLocalStorage(id: string, keychain: number): void;
     saveKeychainInBrowserLocalStorageAsBase64(id: string, keyChainB64: string): void;
@@ -314,7 +339,7 @@ export declare class IccCryptoXApi {
      * @param hcpId Id of the hcp to modify
      * @returns modified HCP
      */
-    saveKeyChainInHCPFromLocalStorage(hcpId: string): Promise<models.HealthcareParty>;
+    saveKeyChainInHCPFromLocalStorage(hcpId: string): Promise<HealthcareParty>;
     importKeychainInBrowserFromHCP(hcpId: string): Promise<void>;
     /**
      * Synchronizes the eHealth certificate from the database into the LocalStorage, returning information on the presence
@@ -331,11 +356,59 @@ export declare class IccCryptoXApi {
     getKeychainInBrowserLocalStorageAsBase64(id: string): string | null;
     getKeychainValidityDateInBrowserLocalStorage(id: string): string | null;
     loadKeychainFromBrowserLocalStorage(id: string): Uint8Array[] | null;
-    generateKeyForDelegate(ownerId: string, delegateId: string): PromiseLike<models.HealthcareParty | models.Patient>;
+    /**
+     *
+     * @param id
+     * @param keyPair should be JWK
+     */
+    storeKeyPair(id: string, keyPair: {
+        publicKey: any;
+        privateKey: any;
+    }): void;
+    /**
+     * loads the RSA key pair (hcparty) in JWK from local storage, not imported
+     *
+     * @param id  doc id - hcpartyId
+     * @param publicKeyFingerPrint the 32 last characters of public key this private key is associated with
+     * @returns {Object} it is in JWK - not imported
+     */
+    loadKeyPairNotImported(id: string, publicKeyFingerPrint?: string): {
+        publicKey: JsonWebKey;
+        privateKey: JsonWebKey;
+    };
+    /**
+     * Loads and imports the RSA key pair (hcparty) from local storage
+     *
+     * @param id  doc id - hcPartyId
+     * @returns {Promise} -> {CryptoKey} - imported RSA
+     */
+    loadKeyPairImported(id: string): Promise<{
+        publicKey: CryptoKey;
+        privateKey: CryptoKey;
+    }>;
+    addNewKeyPairForOwnerId(maintenanceTasksApi: IccMaintenanceTaskXApi, user: User, ownerId: string, generateTransferKey?: boolean): Promise<{
+        dataOwner: HealthcareParty | Patient | Device;
+        publicKey: string;
+        privateKey: string;
+    }>;
+    addNewKeyPairForOwner(maintenanceTasksApi: IccMaintenanceTaskXApi, user: User, cdo: CachedDataOwner, generateTransferKey?: boolean): Promise<{
+        dataOwner: HealthcareParty | Patient | Device;
+        publicKey: string;
+        privateKey: string;
+    }>;
+    private createOrUpdateAesExchangeKeysFor;
+    private createOrUpdateTransferKeysFor;
+    private encryptAesKeyFor;
+    private retrieveDataOwnerInfoAfterPotentialUpdate;
+    private sendMaintenanceTasks;
+    private createMaintenanceTask;
+    private getDataOwnerHexPublicKeys;
+    private getDataOwnerPublicKeys;
+    generateKeyForDelegate(ownerId: string, delegateId: string): PromiseLike<HealthcareParty | Patient>;
     getDataOwner(ownerId: string): Promise<CachedDataOwner>;
-    checkPrivateKeyValidity(dataOwner: models.HealthcareParty | models.Patient | models.Device): Promise<boolean>;
+    checkPrivateKeyValidity(dataOwner: HealthcareParty | Patient | Device): Promise<boolean>;
     private throwDetailedExceptionForInvalidParameter;
-    getEncryptionDecryptionKeys(dataOwnerId: string, document: models.AccessLog | models.CalendarItem | models.Classification | models.Contact | models.Document | models.Form | models.HealthElement | models.Invoice | models.Message | models.Receipt | models.Patient): Promise<Array<string> | null>;
-    encryptDecrypt(method: 'encrypt' | 'decrypt', content: Uint8Array | ArrayBuffer, edKey?: string, user?: User, documentObject?: models.Document): Promise<Uint8Array | Array<any> | any>;
+    getEncryptionDecryptionKeys(dataOwnerId: string, document: EncryptedEntity): Promise<Array<string> | undefined>;
+    encryptDecrypt(method: 'encrypt' | 'decrypt', content: Uint8Array | ArrayBuffer, edKey?: string, user?: User, documentObject?: Document): Promise<Uint8Array | Array<any> | any>;
 }
 export {};