From d4987270cf747038c82f232ec3fd40afda321290 Mon Sep 17 00:00:00 2001
From: duchm <duchm@cystack.net>
Date: Wed, 20 Sep 2023 11:31:15 +0700
Subject: [PATCH] fix: cannot view shared items in emergency access view
 grantor

---
 .../cipher/cipher-types/login/LoginInput.vue  |  12 +-
 .../cipher/cipher-types/login/PasswordOTP.vue |   7 +
 .../EmergencyAccess.vue                       |   2 +-
 .../EmergencyContact.vue                      |   4 +-
 .../ViewGrantorCipher.vue                     |  53 +-
 src/renderer/core/services/crypto.service.ts  |   9 +-
 src/renderer/core/services/user.service.ts    | 355 +++++----
 .../services/webCryptoFunction.service.ts     | 725 +++++++++++-------
 .../security/emergency-access/_id.vue         | 212 ++---
 .../pages/settings/security/index.vue         |   2 +-
 10 files changed, 774 insertions(+), 607 deletions(-)
 rename src/renderer/components/setting/{ => emergency-access}/EmergencyAccess.vue (99%)
 rename src/renderer/components/setting/{ => emergency-access}/EmergencyContact.vue (98%)
 rename src/renderer/components/setting/{ => emergency-access}/ViewGrantorCipher.vue (86%)

diff --git a/src/renderer/components/cipher/cipher-types/login/LoginInput.vue b/src/renderer/components/cipher/cipher-types/login/LoginInput.vue
index 0bf6c0b1..2d964964 100644
--- a/src/renderer/components/cipher/cipher-types/login/LoginInput.vue
+++ b/src/renderer/components/cipher/cipher-types/login/LoginInput.vue
@@ -45,15 +45,14 @@
       />
     </template>
     <!-- OTP -->
-    <div
-      class="my-5 text-black-700 text-head-6 font-semibold"
-    >
+    <div class="my-5 text-black-700 text-head-6 font-semibold">
       {{ $t('data.ciphers.otp.setup') }}
     </div>
     <!-- Input -->
     <div>
       <PasswordOTP
         :value="totp"
+        :disabled="isDeleted"
         class="w-full"
         @change="val => $emit('update:totp', val)"
         @createNewOtp="val => $emit('update:isCreateAuthenticator', val)"
@@ -70,7 +69,12 @@ import PasswordGenerator from '../../../password/PasswordGenerator'
 import PasswordOTP from './PasswordOTP.vue'
 
 export default {
-  components: { InputText, PasswordStrengthBar, PasswordGenerator, PasswordOTP },
+  components: {
+    InputText,
+    PasswordStrengthBar,
+    PasswordGenerator,
+    PasswordOTP
+  },
   props: {
     isDeleted: {
       type: Boolean,
diff --git a/src/renderer/components/cipher/cipher-types/login/PasswordOTP.vue b/src/renderer/components/cipher/cipher-types/login/PasswordOTP.vue
index 6e4f2d30..3df3995a 100644
--- a/src/renderer/components/cipher/cipher-types/login/PasswordOTP.vue
+++ b/src/renderer/components/cipher/cipher-types/login/PasswordOTP.vue
@@ -5,6 +5,7 @@
       :label="$t('data.ciphers.otp.otp_option')"
       :initial-value="option"
       :options="options"
+      :disabled="disabled"
       @change="changeOption"
     />
     <InputSelect
@@ -14,6 +15,7 @@
       :required="true"
       :options="otps"
       :filterable="true"
+      :disabled="disabled"
       @change="changeOtp"
     />
     <InputText
@@ -21,6 +23,7 @@
       v-model="notes"
       :label="$t('data.ciphers.otp.secret_key')"
       :required="true"
+      :disabled="disabled"
       @input="changeOtp"
     />
     <div class="flex items-center justify-between mt-3">
@@ -86,6 +89,10 @@ export default {
     value: {
       type: String,
       default: ''
+    },
+    disabled: {
+      type: Boolean,
+      default: false
     }
   },
   data () {
diff --git a/src/renderer/components/setting/EmergencyAccess.vue b/src/renderer/components/setting/emergency-access/EmergencyAccess.vue
similarity index 99%
rename from src/renderer/components/setting/EmergencyAccess.vue
rename to src/renderer/components/setting/emergency-access/EmergencyAccess.vue
index 7aecc04b..b0242d06 100644
--- a/src/renderer/components/setting/EmergencyAccess.vue
+++ b/src/renderer/components/setting/emergency-access/EmergencyAccess.vue
@@ -708,9 +708,9 @@
 </template>
 
 <script>
+import EmergencyContact from './EmergencyContact.vue'
 import { Utils } from '@/core/misc/utils.ts'
 import PasswordStrengthBar from '@/components/password/PasswordStrengthBar'
-import EmergencyContact from '@/components/setting/EmergencyContact.vue'
 import { SymmetricCryptoKey } from '@/core/models/domain/symmetricCryptoKey'
 import { MIN_MASTER_PW_LEN } from '@/constants'
 export default {
diff --git a/src/renderer/components/setting/EmergencyContact.vue b/src/renderer/components/setting/emergency-access/EmergencyContact.vue
similarity index 98%
rename from src/renderer/components/setting/EmergencyContact.vue
rename to src/renderer/components/setting/emergency-access/EmergencyContact.vue
index 5f9e3280..7724f3ea 100644
--- a/src/renderer/components/setting/EmergencyContact.vue
+++ b/src/renderer/components/setting/emergency-access/EmergencyContact.vue
@@ -94,8 +94,8 @@
 </template>
 
 <script>
-import InputText from '../input/InputText'
-import { Utils } from '../../core/misc/utils.ts'
+import InputText from '../../input/InputText'
+import { Utils } from '../../../core/misc/utils.ts'
 
 export default {
   components: {
diff --git a/src/renderer/components/setting/ViewGrantorCipher.vue b/src/renderer/components/setting/emergency-access/ViewGrantorCipher.vue
similarity index 86%
rename from src/renderer/components/setting/ViewGrantorCipher.vue
rename to src/renderer/components/setting/emergency-access/ViewGrantorCipher.vue
index a3c9a1a3..5f72bfab 100644
--- a/src/renderer/components/setting/ViewGrantorCipher.vue
+++ b/src/renderer/components/setting/emergency-access/ViewGrantorCipher.vue
@@ -165,12 +165,10 @@
       <!-- Body end -->
 
       <!-- Footer -->
-      <div slot="footer" class="dialog-footer flex items-center text-left">
-        <div>
-          <button class="btn btn-default" @click="closeDialog">
-            {{ $t('common.close') }}
-          </button>
-        </div>
+      <div slot="footer" class="dialog-footer flex items-center justify-end">
+        <el-button @click="closeDialog">
+          {{ $t('common.close') }}
+        </el-button>
       </div>
       <!-- Footer end -->
     </component>
@@ -180,9 +178,9 @@
 <script>
 import { Dialog } from 'element-ui'
 import { ValidationProvider, ValidationObserver } from 'vee-validate'
-import { SecureNoteType } from '../../core/enums'
-import { CipherType } from '../../core/enums/cipherType'
-import { Cipher } from '../../core/models/domain'
+import { SecureNoteType } from '../../../core/enums'
+import { CipherType } from '../../../core/enums/cipherType'
+import { Cipher } from '../../../core/models/domain'
 import {
   CipherView,
   LoginView,
@@ -190,20 +188,20 @@ import {
   IdentityView,
   CardView,
   LoginUriView
-} from '../../core/models/view'
-import InputText from '../input/InputText'
-import LoginInput from '../cipher/cipher-types/login/LoginInput.vue'
-import CardInput from '../cipher/cipher-types/card/CardInput.vue'
-import IdentityInput from '../cipher/cipher-types/identity/IdentityInput.vue'
-import CryptoBackupInput from '../cipher/cipher-types/crypto-backup/CryptoBackupInput.vue'
-import DriverLicenseInput from '../cipher/cipher-types/driver-license/DriverLicenseInput.vue'
-import CitizenIdInput from '../cipher/cipher-types/citizen-id/CitizenIdInput.vue'
-import PassportInput from '../cipher/cipher-types/passport/PassportInput.vue'
-import SsnInput from '../cipher/cipher-types/ssn/SsnInput.vue'
-import RouterInput from '../cipher/cipher-types/router/RouterInput.vue'
-import ServerInput from '../cipher/cipher-types/server/ServerInput.vue'
-import ApiInput from '../cipher/cipher-types/api/ApiInput.vue'
-import DatabaseInput from '../cipher/cipher-types/database/DatabaseInput.vue'
+} from '../../../core/models/view'
+import InputText from '../../input/InputText'
+import LoginInput from '../../cipher/cipher-types/login/LoginInput.vue'
+import CardInput from '../../cipher/cipher-types/card/CardInput.vue'
+import IdentityInput from '../../cipher/cipher-types/identity/IdentityInput.vue'
+import CryptoBackupInput from '../../cipher/cipher-types/crypto-backup/CryptoBackupInput.vue'
+import DriverLicenseInput from '../../cipher/cipher-types/driver-license/DriverLicenseInput.vue'
+import CitizenIdInput from '../../cipher/cipher-types/citizen-id/CitizenIdInput.vue'
+import PassportInput from '../../cipher/cipher-types/passport/PassportInput.vue'
+import SsnInput from '../../cipher/cipher-types/ssn/SsnInput.vue'
+import RouterInput from '../../cipher/cipher-types/router/RouterInput.vue'
+import ServerInput from '../../cipher/cipher-types/server/ServerInput.vue'
+import ApiInput from '../../cipher/cipher-types/api/ApiInput.vue'
+import DatabaseInput from '../../cipher/cipher-types/database/DatabaseInput.vue'
 
 export default {
   components: {
@@ -229,10 +227,6 @@ export default {
     type: {
       type: [String, Number],
       default: 1
-    },
-    routeName: {
-      type: String,
-      default: ''
     }
   },
 
@@ -341,11 +335,6 @@ export default {
           this.cipher.folderId = this.cipher.collectionIds[0]
         }
 
-        // Set current folder
-        setTimeout(() => {
-          this.$refs.inputSelectFolder.value = this.cipher.folderId
-        }, 0)
-
         this.cipher = cipherData
         return
       }
diff --git a/src/renderer/core/services/crypto.service.ts b/src/renderer/core/services/crypto.service.ts
index eac420b5..5e98ac81 100644
--- a/src/renderer/core/services/crypto.service.ts
+++ b/src/renderer/core/services/crypto.service.ts
@@ -548,7 +548,10 @@ export class CryptoService implements CryptoServiceAbstraction {
     )
   }
 
-  async rsaDecrypt (encValue: string): Promise<ArrayBuffer> {
+  async rsaDecrypt (
+    encValue: string,
+    privateKey?: ArrayBuffer
+  ): Promise<ArrayBuffer> {
     const headerPieces = encValue.split('.')
     let encType: EncryptionType = null
     let encPieces: string[]
@@ -579,7 +582,9 @@ export class CryptoService implements CryptoServiceAbstraction {
     }
 
     const data = Utils.fromB64ToArray(encPieces[0]).buffer
-    const privateKey = await this.getPrivateKey()
+    if (!privateKey) {
+      privateKey = await this.getPrivateKey()
+    }
     if (privateKey == null) {
       throw new Error('No private key.')
     }
diff --git a/src/renderer/core/services/user.service.ts b/src/renderer/core/services/user.service.ts
index 99a81428..a92f842d 100644
--- a/src/renderer/core/services/user.service.ts
+++ b/src/renderer/core/services/user.service.ts
@@ -1,175 +1,194 @@
-import { StorageService } from '../abstractions/storage.service';
-import { TokenService } from '../abstractions/token.service';
-import { UserService as UserServiceAbstraction } from '../abstractions/user.service';
+import { StorageService } from '../abstractions/storage.service'
+import { TokenService } from '../abstractions/token.service'
+import { UserService as UserServiceAbstraction } from '../abstractions/user.service'
 
-import { OrganizationData } from '../models/data/organizationData';
-import { Organization } from '../models/domain/organization';
+import { OrganizationData } from '../models/data/organizationData'
+import { Organization } from '../models/domain/organization'
 
-import { KdfType } from '../enums/kdfType';
+import { KdfType } from '../enums/kdfType'
 
 const Keys = {
-    userId: 'userId',
-    userEmail: 'userEmail',
-    stamp: 'securityStamp',
-    kdf: 'kdf',
-    kdfIterations: 'kdfIterations',
-    organizationsPrefix: 'organizations_',
-    emailVerified: 'emailVerified',
-};
+  userId: 'userId',
+  userEmail: 'userEmail',
+  stamp: 'securityStamp',
+  kdf: 'kdf',
+  kdfIterations: 'kdfIterations',
+  organizationsPrefix: 'organizations_',
+  emailVerified: 'emailVerified'
+}
 
 export class UserService implements UserServiceAbstraction {
-    private userId: string;
-    private email: string;
-    private stamp: string;
-    private kdf: KdfType;
-    private kdfIterations: number;
-    private emailVerified: boolean;
-
-    constructor(private tokenService: TokenService, private storageService: StorageService) { }
-
-    setInformation(userId: string, email: string, kdf: KdfType, kdfIterations: number): Promise<any> {
-        this.email = email;
-        this.userId = userId;
-        this.kdf = kdf;
-        this.kdfIterations = kdfIterations;
-
-        return Promise.all([
-            this.storageService.save(Keys.userEmail, email),
-            this.storageService.save(Keys.userId, userId),
-            this.storageService.save(Keys.kdf, kdf),
-            this.storageService.save(Keys.kdfIterations, kdfIterations),
-        ]);
-    }
-
-    setSecurityStamp(stamp: string): Promise<any> {
-        this.stamp = stamp;
-        return this.storageService.save(Keys.stamp, stamp);
-    }
-
-    setEmailVerified(emailVerified: boolean) {
-        this.emailVerified = emailVerified;
-        return this.storageService.save(Keys.emailVerified, emailVerified);
-    }
-
-    async getUserId(): Promise<string> {
-        if (this.userId == null) {
-            this.userId = await this.storageService.get<string>(Keys.userId);
-        }
-        return this.userId;
-    }
-
-    async getEmail(): Promise<string> {
-        if (this.email == null) {
-            this.email = await this.storageService.get<string>(Keys.userEmail);
-        }
-        return this.email;
-    }
-
-    async getSecurityStamp(): Promise<string> {
-        if (this.stamp == null) {
-            this.stamp = await this.storageService.get<string>(Keys.stamp);
-        }
-        return this.stamp;
-    }
-
-    async getKdf(): Promise<KdfType> {
-        if (this.kdf == null) {
-            this.kdf = await this.storageService.get<KdfType>(Keys.kdf);
-        }
-        return this.kdf;
-    }
-
-    async getKdfIterations(): Promise<number> {
-        if (this.kdfIterations == null) {
-            this.kdfIterations = await this.storageService.get<number>(Keys.kdfIterations);
-        }
-        return this.kdfIterations;
-    }
-
-    async getEmailVerified(): Promise<boolean> {
-        if (this.emailVerified == null) {
-            this.emailVerified = await this.storageService.get<boolean>(Keys.emailVerified);
-        }
-        return this.emailVerified;
-    }
-
-    async clear(): Promise<any> {
-        const userId = await this.getUserId();
-
-        await Promise.all([
-            this.storageService.remove(Keys.userId),
-            this.storageService.remove(Keys.userEmail),
-            this.storageService.remove(Keys.stamp),
-            this.storageService.remove(Keys.kdf),
-            this.storageService.remove(Keys.kdfIterations),
-            this.clearOrganizations(userId),
-        ]);
-
-        this.userId = this.email = this.stamp = null;
-        this.kdf = null;
-        this.kdfIterations = null;
-    }
-
-    async isAuthenticated(): Promise<boolean> {
-        const token = await this.tokenService.getToken();
-        if (token == null) {
-            return false;
-        }
-
-        const userId = await this.getUserId();
-        return userId != null;
-    }
-
-    async canAccessPremium(): Promise<boolean> {
-        const authed = await this.isAuthenticated();
-        if (!authed) {
-            return false;
-        }
-
-        const tokenPremium = this.tokenService.getPremium();
-        if (tokenPremium) {
-            return true;
-        }
-
-        const orgs = await this.getAllOrganizations();
-        for (let i = 0; i < orgs.length; i++) {
-            if (orgs[i].usersGetPremium && orgs[i].enabled) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    async getOrganization(id: string): Promise<Organization> {
-        const userId = await this.getUserId();
-        const organizations = await this.storageService.get<{ [id: string]: OrganizationData; }>(
-            Keys.organizationsPrefix + userId);
-        if (organizations == null || !organizations.hasOwnProperty(id)) {
-            return null;
-        }
-
-        return new Organization(organizations[id]);
-    }
-
-    async getAllOrganizations(): Promise<Organization[]> {
-        const userId = await this.getUserId();
-        const organizations = await this.storageService.get<{ [id: string]: OrganizationData; }>(
-            Keys.organizationsPrefix + userId);
-        const response: Organization[] = [];
-        for (const id in organizations) {
-            if (organizations.hasOwnProperty(id)) {
-                response.push(new Organization(organizations[id]));
-            }
-        }
-        return response;
-    }
-
-    async replaceOrganizations(organizations: { [id: string]: OrganizationData; }): Promise<any> {
-        const userId = await this.getUserId();
-        await this.storageService.save(Keys.organizationsPrefix + userId, organizations);
-    }
-
-    async clearOrganizations(userId: string): Promise<any> {
-        await this.storageService.remove(Keys.organizationsPrefix + userId);
-    }
+  private userId: string
+  private email: string
+  private stamp: string
+  private kdf: KdfType
+  private kdfIterations: number
+  private emailVerified: boolean
+
+  constructor (
+    private tokenService: TokenService,
+    private storageService: StorageService
+  ) {}
+
+  setInformation (
+    userId: string,
+    email: string,
+    kdf: KdfType,
+    kdfIterations: number
+  ): Promise<any> {
+    this.email = email
+    this.userId = userId
+    this.kdf = kdf
+    this.kdfIterations = kdfIterations
+
+    return Promise.all([
+      this.storageService.save(Keys.userEmail, email),
+      this.storageService.save(Keys.userId, userId),
+      this.storageService.save(Keys.kdf, kdf),
+      this.storageService.save(Keys.kdfIterations, kdfIterations)
+    ])
+  }
+
+  setSecurityStamp (stamp: string): Promise<any> {
+    this.stamp = stamp
+    return this.storageService.save(Keys.stamp, stamp)
+  }
+
+  setEmailVerified (emailVerified: boolean) {
+    this.emailVerified = emailVerified
+    return this.storageService.save(Keys.emailVerified, emailVerified)
+  }
+
+  async getUserId (): Promise<string> {
+    if (this.userId == null) {
+      this.userId = await this.storageService.get<string>(Keys.userId)
+    }
+    return this.userId
+  }
+
+  async getEmail (): Promise<string> {
+    if (this.email == null) {
+      this.email = await this.storageService.get<string>(Keys.userEmail)
+    }
+    return this.email
+  }
+
+  async getSecurityStamp (): Promise<string> {
+    if (this.stamp == null) {
+      this.stamp = await this.storageService.get<string>(Keys.stamp)
+    }
+    return this.stamp
+  }
+
+  async getKdf (): Promise<KdfType> {
+    if (this.kdf == null) {
+      this.kdf = await this.storageService.get<KdfType>(Keys.kdf)
+    }
+    return this.kdf
+  }
+
+  async getKdfIterations (): Promise<number> {
+    if (this.kdfIterations == null) {
+      this.kdfIterations = await this.storageService.get<number>(
+        Keys.kdfIterations
+      )
+    }
+    return this.kdfIterations
+  }
+
+  async getEmailVerified (): Promise<boolean> {
+    if (this.emailVerified == null) {
+      this.emailVerified = await this.storageService.get<boolean>(
+        Keys.emailVerified
+      )
+    }
+    return this.emailVerified
+  }
+
+  async clear (): Promise<any> {
+    const userId = await this.getUserId()
+
+    await Promise.all([
+      this.storageService.remove(Keys.userId),
+      this.storageService.remove(Keys.userEmail),
+      this.storageService.remove(Keys.stamp),
+      this.storageService.remove(Keys.kdf),
+      this.storageService.remove(Keys.kdfIterations),
+      this.clearOrganizations(userId)
+    ])
+
+    this.userId = this.email = this.stamp = null
+    this.kdf = null
+    this.kdfIterations = null
+  }
+
+  async isAuthenticated (): Promise<boolean> {
+    const token = await this.tokenService.getToken()
+    if (token == null) {
+      return false
+    }
+
+    const userId = await this.getUserId()
+    return userId != null
+  }
+
+  async canAccessPremium (): Promise<boolean> {
+    const authed = await this.isAuthenticated()
+    if (!authed) {
+      return false
+    }
+
+    const tokenPremium = this.tokenService.getPremium()
+    if (tokenPremium) {
+      return true
+    }
+
+    const orgs = await this.getAllOrganizations()
+    for (let i = 0; i < orgs.length; i++) {
+      if (orgs[i].usersGetPremium && orgs[i].enabled) {
+        return true
+      }
+    }
+    return false
+  }
+
+  async getOrganization (id: string): Promise<Organization> {
+    const userId = await this.getUserId()
+    const organizations = await this.storageService.get<{
+      [id: string]: OrganizationData
+    }>(Keys.organizationsPrefix + userId)
+    if (organizations == null || !organizations.hasOwnProperty(id)) {
+      return null
+    }
+
+    return new Organization(organizations[id])
+  }
+
+  async getAllOrganizations (): Promise<Organization[]> {
+    const userId = await this.getUserId()
+    const organizations = await this.storageService.get<{
+      [id: string]: OrganizationData
+    }>(Keys.organizationsPrefix + userId)
+    const response: Organization[] = []
+    for (const id in organizations) {
+      if (organizations.hasOwnProperty(id)) {
+        response.push(new Organization(organizations[id]))
+      }
+    }
+    return response
+  }
+
+  async replaceOrganizations (organizations: {
+    [id: string]: OrganizationData
+  }): Promise<any> {
+    const userId = await this.getUserId()
+    await this.storageService.save(
+      Keys.organizationsPrefix + userId,
+      organizations
+    )
+  }
+
+  async clearOrganizations (userId: string): Promise<any> {
+    await this.storageService.remove(Keys.organizationsPrefix + userId)
+  }
 }
diff --git a/src/renderer/core/services/webCryptoFunction.service.ts b/src/renderer/core/services/webCryptoFunction.service.ts
index 2cabb96d..14cd94e9 100644
--- a/src/renderer/core/services/webCryptoFunction.service.ts
+++ b/src/renderer/core/services/webCryptoFunction.service.ts
@@ -1,332 +1,469 @@
-import * as forge from 'node-forge';
+import * as forge from 'node-forge'
 
-import { CryptoFunctionService } from '../abstractions/cryptoFunction.service';
-import { PlatformUtilsService } from '../abstractions/platformUtils.service';
+import { CryptoFunctionService } from '../abstractions/cryptoFunction.service'
+import { PlatformUtilsService } from '../abstractions/platformUtils.service'
 
-import { Utils } from '../misc/utils';
+import { Utils } from '../misc/utils'
 
-import { DecryptParameters } from '../models/domain/decryptParameters';
-import { SymmetricCryptoKey } from '../models/domain/symmetricCryptoKey';
+import { DecryptParameters } from '../models/domain/decryptParameters'
+import { SymmetricCryptoKey } from '../models/domain/symmetricCryptoKey'
 
 export class WebCryptoFunctionService implements CryptoFunctionService {
-    private crypto: Crypto;
-    private subtle: SubtleCrypto;
-    private isIE: boolean;
-    private isOldSafari: boolean;
-
-    constructor(private win: Window, private platformUtilsService: PlatformUtilsService) {
-        this.crypto = typeof win.crypto !== 'undefined' ? win.crypto : null;
-        this.subtle = (!!this.crypto && typeof win.crypto.subtle !== 'undefined') ? win.crypto.subtle : null;
-        this.isIE = platformUtilsService.isIE();
-        const ua = win.navigator.userAgent;
-        this.isOldSafari = platformUtilsService.isSafari() &&
-            (ua.indexOf(' Version/10.') > -1 || ua.indexOf(' Version/9.') > -1);
+  private crypto: Crypto
+  private subtle: SubtleCrypto
+  private isIE: boolean
+  private isOldSafari: boolean
+
+  constructor (
+    private win: Window,
+    private platformUtilsService: PlatformUtilsService
+  ) {
+    this.crypto = typeof win.crypto !== 'undefined' ? win.crypto : null
+    this.subtle =
+      !!this.crypto && typeof win.crypto.subtle !== 'undefined'
+        ? win.crypto.subtle
+        : null
+    this.isIE = platformUtilsService.isIE()
+    const ua = win.navigator.userAgent
+    this.isOldSafari =
+      platformUtilsService.isSafari() &&
+      (ua.includes(' Version/10.') || ua.includes(' Version/9.'))
+  }
+
+  async pbkdf2 (
+    password: string | ArrayBuffer,
+    salt: string | ArrayBuffer,
+    algorithm: 'sha256' | 'sha512',
+    iterations: number
+  ): Promise<ArrayBuffer> {
+    if (this.isIE || this.isOldSafari) {
+      const forgeLen = algorithm === 'sha256' ? 32 : 64
+      const passwordBytes = this.toByteString(password)
+      const saltBytes = this.toByteString(salt)
+      const derivedKeyBytes = (forge as any).pbkdf2(
+        passwordBytes,
+        saltBytes,
+        iterations,
+        forgeLen,
+        algorithm
+      )
+      return Utils.fromByteStringToArray(derivedKeyBytes).buffer
     }
 
-    async pbkdf2(password: string | ArrayBuffer, salt: string | ArrayBuffer, algorithm: 'sha256' | 'sha512',
-        iterations: number): Promise<ArrayBuffer> {
-        if (this.isIE || this.isOldSafari) {
-            const forgeLen = algorithm === 'sha256' ? 32 : 64;
-            const passwordBytes = this.toByteString(password);
-            const saltBytes = this.toByteString(salt);
-            const derivedKeyBytes = (forge as any).pbkdf2(passwordBytes, saltBytes, iterations, forgeLen, algorithm);
-            return Utils.fromByteStringToArray(derivedKeyBytes).buffer;
-        }
-
-        const wcLen = algorithm === 'sha256' ? 256 : 512;
-        const passwordBuf = this.toBuf(password);
-        const saltBuf = this.toBuf(salt);
-
-        const pbkdf2Params: Pbkdf2Params = {
-            name: 'PBKDF2',
-            salt: saltBuf,
-            iterations: iterations,
-            hash: { name: this.toWebCryptoAlgorithm(algorithm) },
-        };
-
-        const impKey = await this.subtle.importKey('raw', passwordBuf, { name: 'PBKDF2' } as any,
-            false, ['deriveBits']);
-        return await this.subtle.deriveBits(pbkdf2Params, impKey, wcLen);
-    }
+    const wcLen = algorithm === 'sha256' ? 256 : 512
+    const passwordBuf = this.toBuf(password)
+    const saltBuf = this.toBuf(salt)
 
-    async hkdf(ikm: ArrayBuffer, salt: string | ArrayBuffer, info: string | ArrayBuffer,
-        outputByteSize: number, algorithm: 'sha256' | 'sha512'): Promise<ArrayBuffer> {
-        const saltBuf = this.toBuf(salt);
-        const infoBuf = this.toBuf(info);
-
-        const hkdfParams: HkdfParams = {
-            name: 'HKDF',
-            salt: saltBuf,
-            info: infoBuf,
-            hash: { name: this.toWebCryptoAlgorithm(algorithm) },
-        };
-
-        const impKey = await this.subtle.importKey('raw', ikm, { name: 'HKDF' } as any,
-            false, ['deriveBits']);
-        return await this.subtle.deriveBits(hkdfParams as any, impKey, outputByteSize * 8);
+    const pbkdf2Params: Pbkdf2Params = {
+      name: 'PBKDF2',
+      salt: saltBuf,
+      iterations,
+      hash: { name: this.toWebCryptoAlgorithm(algorithm) }
     }
 
-    // ref: https://tools.ietf.org/html/rfc5869
-    async hkdfExpand(prk: ArrayBuffer, info: string | ArrayBuffer, outputByteSize: number,
-        algorithm: 'sha256' | 'sha512'): Promise<ArrayBuffer> {
-        const hashLen = algorithm === 'sha256' ? 32 : 64;
-        if (outputByteSize > 255 * hashLen) {
-            throw new Error('outputByteSize is too large.');
-        }
-        const prkArr = new Uint8Array(prk);
-        if (prkArr.length < hashLen) {
-            throw new Error('prk is too small.');
-        }
-        const infoBuf = this.toBuf(info);
-        const infoArr = new Uint8Array(infoBuf);
-        let runningOkmLength = 0;
-        let previousT = new Uint8Array(0);
-        const n = Math.ceil(outputByteSize / hashLen);
-        const okm = new Uint8Array(n * hashLen);
-        for (let i = 0; i < n; i++) {
-            const t = new Uint8Array(previousT.length + infoArr.length + 1);
-            t.set(previousT);
-            t.set(infoArr, previousT.length);
-            t.set([i + 1], t.length - 1);
-            previousT = new Uint8Array(await this.hmac(t.buffer, prk, algorithm));
-            okm.set(previousT, runningOkmLength);
-            runningOkmLength += previousT.length;
-            if (runningOkmLength >= outputByteSize) {
-                break;
-            }
-        }
-        return okm.slice(0, outputByteSize).buffer;
+    const impKey = await this.subtle.importKey(
+      'raw',
+      passwordBuf,
+      { name: 'PBKDF2' } as any,
+      false,
+      ['deriveBits']
+    )
+    return await this.subtle.deriveBits(pbkdf2Params, impKey, wcLen)
+  }
+
+  async hkdf (
+    ikm: ArrayBuffer,
+    salt: string | ArrayBuffer,
+    info: string | ArrayBuffer,
+    outputByteSize: number,
+    algorithm: 'sha256' | 'sha512'
+  ): Promise<ArrayBuffer> {
+    const saltBuf = this.toBuf(salt)
+    const infoBuf = this.toBuf(info)
+
+    const hkdfParams: HkdfParams = {
+      name: 'HKDF',
+      salt: saltBuf,
+      info: infoBuf,
+      hash: { name: this.toWebCryptoAlgorithm(algorithm) }
     }
 
-    async hash(value: string | ArrayBuffer, algorithm: 'sha1' | 'sha256' | 'sha512' | 'md5'): Promise<ArrayBuffer> {
-        if ((this.isIE && algorithm === 'sha1') || algorithm === 'md5') {
-            const md = algorithm === 'md5' ? forge.md.md5.create() : forge.md.sha1.create();
-            const valueBytes = this.toByteString(value);
-            md.update(valueBytes, 'raw');
-            return Utils.fromByteStringToArray(md.digest().data).buffer;
-        }
-
-        const valueBuf = this.toBuf(value);
-        return await this.subtle.digest({ name: this.toWebCryptoAlgorithm(algorithm) }, valueBuf);
+    const impKey = await this.subtle.importKey(
+      'raw',
+      ikm,
+      { name: 'HKDF' } as any,
+      false,
+      ['deriveBits']
+    )
+    return await this.subtle.deriveBits(
+      hkdfParams as any,
+      impKey,
+      outputByteSize * 8
+    )
+  }
+
+  // ref: https://tools.ietf.org/html/rfc5869
+  async hkdfExpand (
+    prk: ArrayBuffer,
+    info: string | ArrayBuffer,
+    outputByteSize: number,
+    algorithm: 'sha256' | 'sha512'
+  ): Promise<ArrayBuffer> {
+    const hashLen = algorithm === 'sha256' ? 32 : 64
+    if (outputByteSize > 255 * hashLen) {
+      throw new Error('outputByteSize is too large.')
     }
-
-    async hmac(value: ArrayBuffer, key: ArrayBuffer, algorithm: 'sha1' | 'sha256' | 'sha512'): Promise<ArrayBuffer> {
-        if (this.isIE && algorithm === 'sha512') {
-            const hmac = (forge as any).hmac.create();
-            const keyBytes = this.toByteString(key);
-            const valueBytes = this.toByteString(value);
-            hmac.start(algorithm, keyBytes);
-            hmac.update(valueBytes, 'raw');
-            return Utils.fromByteStringToArray(hmac.digest().data).buffer;
-        }
-
-        const signingAlgorithm = {
-            name: 'HMAC',
-            hash: { name: this.toWebCryptoAlgorithm(algorithm) },
-        };
-
-        const impKey = await this.subtle.importKey('raw', key, signingAlgorithm, false, ['sign']);
-        return await this.subtle.sign(signingAlgorithm, impKey, value);
+    const prkArr = new Uint8Array(prk)
+    if (prkArr.length < hashLen) {
+      throw new Error('prk is too small.')
     }
-
-    // Safely compare two values in a way that protects against timing attacks (Double HMAC Verification).
-    // ref: https://www.nccgroup.trust/us/about-us/newsroom-and-events/blog/2011/february/double-hmac-verification/
-    // ref: https://paragonie.com/blog/2015/11/preventing-timing-attacks-on-string-comparison-with-double-hmac-strategy
-    async compare(a: ArrayBuffer, b: ArrayBuffer): Promise<boolean> {
-        const macKey = await this.randomBytes(32);
-        const signingAlgorithm = {
-            name: 'HMAC',
-            hash: { name: 'SHA-256' },
-        };
-        const impKey = await this.subtle.importKey('raw', macKey, signingAlgorithm, false, ['sign']);
-        const mac1 = await this.subtle.sign(signingAlgorithm, impKey, a);
-        const mac2 = await this.subtle.sign(signingAlgorithm, impKey, b);
-
-        if (mac1.byteLength !== mac2.byteLength) {
-            return false;
-        }
-
-        const arr1 = new Uint8Array(mac1);
-        const arr2 = new Uint8Array(mac2);
-        for (let i = 0; i < arr2.length; i++) {
-            if (arr1[i] !== arr2[i]) {
-                return false;
-            }
-        }
-
-        return true;
+    const infoBuf = this.toBuf(info)
+    const infoArr = new Uint8Array(infoBuf)
+    let runningOkmLength = 0
+    let previousT = new Uint8Array(0)
+    const n = Math.ceil(outputByteSize / hashLen)
+    const okm = new Uint8Array(n * hashLen)
+    for (let i = 0; i < n; i++) {
+      const t = new Uint8Array(previousT.length + infoArr.length + 1)
+      t.set(previousT)
+      t.set(infoArr, previousT.length)
+      t.set([i + 1], t.length - 1)
+      previousT = new Uint8Array(await this.hmac(t.buffer, prk, algorithm))
+      okm.set(previousT, runningOkmLength)
+      runningOkmLength += previousT.length
+      if (runningOkmLength >= outputByteSize) {
+        break
+      }
     }
-
-    hmacFast(value: string, key: string, algorithm: 'sha1' | 'sha256' | 'sha512'): Promise<string> {
-        const hmac = (forge as any).hmac.create();
-        hmac.start(algorithm, key);
-        hmac.update(value);
-        const bytes = hmac.digest().getBytes();
-        return Promise.resolve(bytes);
+    return okm.slice(0, outputByteSize).buffer
+  }
+
+  async hash (
+    value: string | ArrayBuffer,
+    algorithm: 'sha1' | 'sha256' | 'sha512' | 'md5'
+  ): Promise<ArrayBuffer> {
+    if ((this.isIE && algorithm === 'sha1') || algorithm === 'md5') {
+      const md =
+        algorithm === 'md5' ? forge.md.md5.create() : forge.md.sha1.create()
+      const valueBytes = this.toByteString(value)
+      md.update(valueBytes, 'raw')
+      return Utils.fromByteStringToArray(md.digest().data).buffer
     }
 
-    async compareFast(a: string, b: string): Promise<boolean> {
-        const rand = await this.randomBytes(32);
-        const bytes = new Uint32Array(rand);
-        const buffer = forge.util.createBuffer();
-        for (let i = 0; i < bytes.length; i++) {
-            buffer.putInt32(bytes[i]);
-        }
-        const macKey = buffer.getBytes();
-
-        const hmac = (forge as any).hmac.create();
-        hmac.start('sha256', macKey);
-        hmac.update(a);
-        const mac1 = hmac.digest().getBytes();
-
-        hmac.start(null, null);
-        hmac.update(b);
-        const mac2 = hmac.digest().getBytes();
-
-        const equals = mac1 === mac2;
-        return equals;
+    const valueBuf = this.toBuf(value)
+    return await this.subtle.digest(
+      { name: this.toWebCryptoAlgorithm(algorithm) },
+      valueBuf
+    )
+  }
+
+  async hmac (
+    value: ArrayBuffer,
+    key: ArrayBuffer,
+    algorithm: 'sha1' | 'sha256' | 'sha512'
+  ): Promise<ArrayBuffer> {
+    if (this.isIE && algorithm === 'sha512') {
+      const hmac = (forge as any).hmac.create()
+      const keyBytes = this.toByteString(key)
+      const valueBytes = this.toByteString(value)
+      hmac.start(algorithm, keyBytes)
+      hmac.update(valueBytes, 'raw')
+      return Utils.fromByteStringToArray(hmac.digest().data).buffer
     }
 
-    async aesEncrypt(data: ArrayBuffer, iv: ArrayBuffer, key: ArrayBuffer): Promise<ArrayBuffer> {
-        const impKey = await this.subtle.importKey('raw', key, { name: 'AES-CBC' } as any, false, ['encrypt']);
-        return await this.subtle.encrypt({ name: 'AES-CBC', iv: iv }, impKey, data);
+    const signingAlgorithm = {
+      name: 'HMAC',
+      hash: { name: this.toWebCryptoAlgorithm(algorithm) }
     }
 
-    aesDecryptFastParameters(data: string, iv: string, mac: string, key: SymmetricCryptoKey):
-        DecryptParameters<string> {
-        const p = new DecryptParameters<string>();
-        if (key.meta != null) {
-            p.encKey = key.meta.encKeyByteString;
-            p.macKey = key.meta.macKeyByteString;
-        }
-
-        if (p.encKey == null) {
-            p.encKey = forge.util.decode64(key.encKeyB64);
-        }
-        p.data = forge.util.decode64(data);
-        p.iv = forge.util.decode64(iv);
-        p.macData = p.iv + p.data;
-        if (p.macKey == null && key.macKeyB64 != null) {
-            p.macKey = forge.util.decode64(key.macKeyB64);
-        }
-        if (mac != null) {
-            p.mac = forge.util.decode64(mac);
-        }
-
-        // cache byte string keys for later
-        if (key.meta == null) {
-            key.meta = {};
-        }
-        if (key.meta.encKeyByteString == null) {
-            key.meta.encKeyByteString = p.encKey;
-        }
-        if (p.macKey != null && key.meta.macKeyByteString == null) {
-            key.meta.macKeyByteString = p.macKey;
-        }
-
-        return p;
+    const impKey = await this.subtle.importKey(
+      'raw',
+      key,
+      signingAlgorithm,
+      false,
+      ['sign']
+    )
+    return await this.subtle.sign(signingAlgorithm, impKey, value)
+  }
+
+  // Safely compare two values in a way that protects against timing attacks (Double HMAC Verification).
+  // ref: https://www.nccgroup.trust/us/about-us/newsroom-and-events/blog/2011/february/double-hmac-verification/
+  // ref: https://paragonie.com/blog/2015/11/preventing-timing-attacks-on-string-comparison-with-double-hmac-strategy
+  async compare (a: ArrayBuffer, b: ArrayBuffer): Promise<boolean> {
+    const macKey = await this.randomBytes(32)
+    const signingAlgorithm = {
+      name: 'HMAC',
+      hash: { name: 'SHA-256' }
     }
-
-    aesDecryptFast(parameters: DecryptParameters<string>): Promise<string> {
-        const dataBuffer = (forge as any).util.createBuffer(parameters.data);
-        const decipher = (forge as any).cipher.createDecipher('AES-CBC', parameters.encKey);
-        decipher.start({ iv: parameters.iv });
-        decipher.update(dataBuffer);
-        decipher.finish();
-        const val = decipher.output.toString('utf8');
-        return Promise.resolve(val);
+    const impKey = await this.subtle.importKey(
+      'raw',
+      macKey,
+      signingAlgorithm,
+      false,
+      ['sign']
+    )
+    const mac1 = await this.subtle.sign(signingAlgorithm, impKey, a)
+    const mac2 = await this.subtle.sign(signingAlgorithm, impKey, b)
+
+    if (mac1.byteLength !== mac2.byteLength) {
+      return false
     }
 
-    async aesDecrypt(data: ArrayBuffer, iv: ArrayBuffer, key: ArrayBuffer): Promise<ArrayBuffer> {
-        const impKey = await this.subtle.importKey('raw', key, { name: 'AES-CBC' } as any, false, ['decrypt']);
-        return await this.subtle.decrypt({ name: 'AES-CBC', iv: iv }, impKey, data);
+    const arr1 = new Uint8Array(mac1)
+    const arr2 = new Uint8Array(mac2)
+    for (let i = 0; i < arr2.length; i++) {
+      if (arr1[i] !== arr2[i]) {
+        return false
+      }
     }
 
-    async rsaEncrypt(data: ArrayBuffer, publicKey: ArrayBuffer, algorithm: 'sha1' | 'sha256'): Promise<ArrayBuffer> {
-        // Note: Edge browser requires that we specify name and hash for both key import and decrypt.
-        // We cannot use the proper types here.
-        const rsaParams = {
-            name: 'RSA-OAEP',
-            hash: { name: this.toWebCryptoAlgorithm(algorithm) },
-        };
-        const impKey = await this.subtle.importKey('spki', publicKey, rsaParams, false, ['encrypt']);
-        return await this.subtle.encrypt(rsaParams, impKey, data);
+    return true
+  }
+
+  hmacFast (
+    value: string,
+    key: string,
+    algorithm: 'sha1' | 'sha256' | 'sha512'
+  ): Promise<string> {
+    const hmac = (forge as any).hmac.create()
+    hmac.start(algorithm, key)
+    hmac.update(value)
+    const bytes = hmac.digest().getBytes()
+    return Promise.resolve(bytes)
+  }
+
+  async compareFast (a: string, b: string): Promise<boolean> {
+    const rand = await this.randomBytes(32)
+    const bytes = new Uint32Array(rand)
+    const buffer = forge.util.createBuffer()
+    for (let i = 0; i < bytes.length; i++) {
+      buffer.putInt32(bytes[i])
     }
-
-    async rsaDecrypt(data: ArrayBuffer, privateKey: ArrayBuffer, algorithm: 'sha1' | 'sha256'): Promise<ArrayBuffer> {
-        // Note: Edge browser requires that we specify name and hash for both key import and decrypt.
-        // We cannot use the proper types here.
-        const rsaParams = {
-            name: 'RSA-OAEP',
-            hash: { name: this.toWebCryptoAlgorithm(algorithm) },
-        };
-        const impKey = await this.subtle.importKey('pkcs8', privateKey, rsaParams, false, ['decrypt']);
-        return await this.subtle.decrypt(rsaParams, impKey, data);
+    const macKey = buffer.getBytes()
+
+    const hmac = (forge as any).hmac.create()
+    hmac.start('sha256', macKey)
+    hmac.update(a)
+    const mac1 = hmac.digest().getBytes()
+
+    hmac.start(null, null)
+    hmac.update(b)
+    const mac2 = hmac.digest().getBytes()
+
+    const equals = mac1 === mac2
+    return equals
+  }
+
+  async aesEncrypt (
+    data: ArrayBuffer,
+    iv: ArrayBuffer,
+    key: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    const impKey = await this.subtle.importKey(
+      'raw',
+      key,
+      { name: 'AES-CBC' } as any,
+      false,
+      ['encrypt']
+    )
+    return await this.subtle.encrypt({ name: 'AES-CBC', iv }, impKey, data)
+  }
+
+  aesDecryptFastParameters (
+    data: string,
+    iv: string,
+    mac: string,
+    key: SymmetricCryptoKey
+  ): DecryptParameters<string> {
+    const p = new DecryptParameters<string>()
+    if (key.meta != null) {
+      p.encKey = key.meta.encKeyByteString
+      p.macKey = key.meta.macKeyByteString
     }
 
-    async rsaExtractPublicKey(privateKey: ArrayBuffer): Promise<ArrayBuffer> {
-        const rsaParams = {
-            name: 'RSA-OAEP',
-            // Have to specify some algorithm
-            hash: { name: this.toWebCryptoAlgorithm('sha1') },
-        };
-        const impPrivateKey = await this.subtle.importKey('pkcs8', privateKey, rsaParams, true, ['decrypt']);
-        const jwkPrivateKey = await this.subtle.exportKey('jwk', impPrivateKey);
-        const jwkPublicKeyParams = {
-            kty: 'RSA',
-            e: jwkPrivateKey.e,
-            n: jwkPrivateKey.n,
-            alg: 'RSA-OAEP',
-            ext: true,
-        };
-        const impPublicKey = await this.subtle.importKey('jwk', jwkPublicKeyParams, rsaParams, true, ['encrypt']);
-        return await this.subtle.exportKey('spki', impPublicKey);
+    if (p.encKey == null) {
+      p.encKey = forge.util.decode64(key.encKeyB64)
     }
-
-    async rsaGenerateKeyPair(length: 1024 | 2048 | 4096): Promise<[ArrayBuffer, ArrayBuffer]> {
-        const rsaParams = {
-            name: 'RSA-OAEP',
-            modulusLength: length,
-            publicExponent: new Uint8Array([0x01, 0x00, 0x01]), // 65537
-            // Have to specify some algorithm
-            hash: { name: this.toWebCryptoAlgorithm('sha1') },
-        };
-        const keyPair = (await this.subtle.generateKey(rsaParams, true, ['encrypt', 'decrypt'])) as CryptoKeyPair;
-        const publicKey = await this.subtle.exportKey('spki', keyPair.publicKey);
-        const privateKey = await this.subtle.exportKey('pkcs8', keyPair.privateKey);
-        return [publicKey, privateKey];
+    p.data = forge.util.decode64(data)
+    p.iv = forge.util.decode64(iv)
+    p.macData = p.iv + p.data
+    if (p.macKey == null && key.macKeyB64 != null) {
+      p.macKey = forge.util.decode64(key.macKeyB64)
     }
-
-    randomBytes(length: number): Promise<ArrayBuffer> {
-        const arr = new Uint8Array(length);
-        this.crypto.getRandomValues(arr);
-        return Promise.resolve(arr.buffer);
+    if (mac != null) {
+      p.mac = forge.util.decode64(mac)
     }
 
-    private toBuf(value: string | ArrayBuffer): ArrayBuffer {
-        let buf: ArrayBuffer;
-        if (typeof (value) === 'string') {
-            buf = Utils.fromUtf8ToArray(value).buffer;
-        } else {
-            buf = value;
-        }
-        return buf;
+    // cache byte string keys for later
+    if (key.meta == null) {
+      key.meta = {}
     }
-
-    private toByteString(value: string | ArrayBuffer): string {
-        let bytes: string;
-        if (typeof (value) === 'string') {
-            bytes = forge.util.encodeUtf8(value);
-        } else {
-            bytes = Utils.fromBufferToByteString(value);
-        }
-        return bytes;
+    if (key.meta.encKeyByteString == null) {
+      key.meta.encKeyByteString = p.encKey
+    }
+    if (p.macKey != null && key.meta.macKeyByteString == null) {
+      key.meta.macKeyByteString = p.macKey
     }
 
-    private toWebCryptoAlgorithm(algorithm: 'sha1' | 'sha256' | 'sha512' | 'md5'): string {
-        if (algorithm === 'md5') {
-            throw new Error('MD5 is not supported in WebCrypto.');
-        }
-        return algorithm === 'sha1' ? 'SHA-1' : algorithm === 'sha256' ? 'SHA-256' : 'SHA-512';
+    return p
+  }
+
+  aesDecryptFast (parameters: DecryptParameters<string>): Promise<string> {
+    const dataBuffer = (forge as any).util.createBuffer(parameters.data)
+    const decipher = (forge as any).cipher.createDecipher(
+      'AES-CBC',
+      parameters.encKey
+    )
+    decipher.start({ iv: parameters.iv })
+    decipher.update(dataBuffer)
+    decipher.finish()
+    const val = decipher.output.toString('utf8')
+    return Promise.resolve(val)
+  }
+
+  async aesDecrypt (
+    data: ArrayBuffer,
+    iv: ArrayBuffer,
+    key: ArrayBuffer
+  ): Promise<ArrayBuffer> {
+    const impKey = await this.subtle.importKey(
+      'raw',
+      key,
+      { name: 'AES-CBC' } as any,
+      false,
+      ['decrypt']
+    )
+    return await this.subtle.decrypt({ name: 'AES-CBC', iv }, impKey, data)
+  }
+
+  async rsaEncrypt (
+    data: ArrayBuffer,
+    publicKey: ArrayBuffer,
+    algorithm: 'sha1' | 'sha256'
+  ): Promise<ArrayBuffer> {
+    // Note: Edge browser requires that we specify name and hash for both key import and decrypt.
+    // We cannot use the proper types here.
+    const rsaParams = {
+      name: 'RSA-OAEP',
+      hash: { name: this.toWebCryptoAlgorithm(algorithm) }
+    }
+    const impKey = await this.subtle.importKey(
+      'spki',
+      publicKey,
+      rsaParams,
+      false,
+      ['encrypt']
+    )
+    return await this.subtle.encrypt(rsaParams, impKey, data)
+  }
+
+  async rsaDecrypt (
+    data: ArrayBuffer,
+    privateKey: ArrayBuffer,
+    algorithm: 'sha1' | 'sha256'
+  ): Promise<ArrayBuffer> {
+    // Note: Edge browser requires that we specify name and hash for both key import and decrypt.
+    // We cannot use the proper types here.
+    const rsaParams = {
+      name: 'RSA-OAEP',
+      hash: { name: this.toWebCryptoAlgorithm(algorithm) }
+    }
+    const impKey = await this.subtle.importKey(
+      'pkcs8',
+      privateKey,
+      rsaParams,
+      false,
+      ['decrypt']
+    )
+    return await this.subtle.decrypt(rsaParams, impKey, data)
+  }
+
+  async rsaExtractPublicKey (privateKey: ArrayBuffer): Promise<ArrayBuffer> {
+    const rsaParams = {
+      name: 'RSA-OAEP',
+      // Have to specify some algorithm
+      hash: { name: this.toWebCryptoAlgorithm('sha1') }
+    }
+    const impPrivateKey = await this.subtle.importKey(
+      'pkcs8',
+      privateKey,
+      rsaParams,
+      true,
+      ['decrypt']
+    )
+    const jwkPrivateKey = await this.subtle.exportKey('jwk', impPrivateKey)
+    const jwkPublicKeyParams = {
+      kty: 'RSA',
+      e: jwkPrivateKey.e,
+      n: jwkPrivateKey.n,
+      alg: 'RSA-OAEP',
+      ext: true
+    }
+    const impPublicKey = await this.subtle.importKey(
+      'jwk',
+      jwkPublicKeyParams,
+      rsaParams,
+      true,
+      ['encrypt']
+    )
+    return await this.subtle.exportKey('spki', impPublicKey)
+  }
+
+  async rsaGenerateKeyPair (
+    length: 1024 | 2048 | 4096
+  ): Promise<[ArrayBuffer, ArrayBuffer]> {
+    const rsaParams = {
+      name: 'RSA-OAEP',
+      modulusLength: length,
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]), // 65537
+      // Have to specify some algorithm
+      hash: { name: this.toWebCryptoAlgorithm('sha1') }
+    }
+    const keyPair = (await this.subtle.generateKey(rsaParams, true, [
+      'encrypt',
+      'decrypt'
+    ])) as CryptoKeyPair
+    const publicKey = await this.subtle.exportKey('spki', keyPair.publicKey)
+    const privateKey = await this.subtle.exportKey('pkcs8', keyPair.privateKey)
+    return [publicKey, privateKey]
+  }
+
+  randomBytes (length: number): Promise<ArrayBuffer> {
+    const arr = new Uint8Array(length)
+    this.crypto.getRandomValues(arr)
+    return Promise.resolve(arr.buffer)
+  }
+
+  private toBuf (value: string | ArrayBuffer): ArrayBuffer {
+    let buf: ArrayBuffer
+    if (typeof value === 'string') {
+      buf = Utils.fromUtf8ToArray(value).buffer
+    } else {
+      buf = value
+    }
+    return buf
+  }
+
+  private toByteString (value: string | ArrayBuffer): string {
+    let bytes: string
+    if (typeof value === 'string') {
+      bytes = forge.util.encodeUtf8(value)
+    } else {
+      bytes = Utils.fromBufferToByteString(value)
+    }
+    return bytes
+  }
+
+  private toWebCryptoAlgorithm (
+    algorithm: 'sha1' | 'sha256' | 'sha512' | 'md5'
+  ): string {
+    if (algorithm === 'md5') {
+      throw new Error('MD5 is not supported in WebCrypto.')
     }
+    return algorithm === 'sha1'
+      ? 'SHA-1'
+      : algorithm === 'sha256'
+        ? 'SHA-256'
+        : 'SHA-512'
+  }
 }
diff --git a/src/renderer/pages/settings/security/emergency-access/_id.vue b/src/renderer/pages/settings/security/emergency-access/_id.vue
index e2fb5596..3d623717 100644
--- a/src/renderer/pages/settings/security/emergency-access/_id.vue
+++ b/src/renderer/pages/settings/security/emergency-access/_id.vue
@@ -2,6 +2,7 @@
   <div v-loading="loading" class="flex flex-col flex-column-fluid relative">
     <div class="flex-column-fluid py-10 mb-20">
       <client-only>
+        <!-- Breadcrumb -->
         <div class="mb-5">
           <el-breadcrumb separator-class="el-icon-arrow-right">
             <el-breadcrumb-item
@@ -14,12 +15,16 @@
             </el-breadcrumb-item>
           </el-breadcrumb>
         </div>
+        <!-- Breadcrumb end -->
+
+        <!-- Cipher table -->
         <el-table
           ref="multipleTable"
           :data="ciphers || []"
           style="width: 100%"
           row-class-name="hover-table-row"
         >
+          <!-- Icon + name -->
           <el-table-column prop="name" label="" show-overflow-tooltip>
             <template slot-scope="scope">
               <div class="flex items-center">
@@ -51,9 +56,13 @@
               </div>
             </template>
           </el-table-column>
+          <!-- Icon + name end -->
+
+          <!-- Actions -->
           <el-table-column label="" align="right" width="200">
             <template slot-scope="scope">
               <div class="col-actions">
+                <!-- Open URL in new tab -->
                 <button
                   v-if="scope.row.login.canLaunch"
                   class="btn btn-icon btn-xs hover:bg-black-400"
@@ -62,101 +71,62 @@
                 >
                   <i class="fas fa-external-link-square-alt" />
                 </button>
-                <el-dropdown trigger="click" :hide-on-click="false">
+                <!-- Open URL in new tab end -->
+
+                <!-- Copy -->
+                <el-dropdown
+                  v-if="
+                    !scope.row.isDeleted && getCopyableValues(scope.row).length
+                  "
+                  trigger="click"
+                  :hide-on-click="false"
+                >
                   <button class="btn btn-icon btn-xs hover:bg-black-400">
-                    <i class="fas fa-ellipsis-h" />
+                    <i class="far fa-clone" />
                   </button>
                   <el-dropdown-menu slot="dropdown">
-                    <template
-                      v-if="
-                        !scope.row.isDeleted &&
-                          scope.row.type === CipherType.Login
-                      "
-                    >
-                      <el-dropdown-item
-                        v-clipboard:copy="scope.row.login.username"
-                        v-clipboard:success="clipboardSuccessHandler"
-                        divided
-                      >
-                        {{ $t('common.copy') }} {{ $t('common.username') }}
-                      </el-dropdown-item>
-                      <el-dropdown-item
-                        v-clipboard:copy="scope.row.login.password"
-                        v-clipboard:success="clipboardSuccessHandler"
-                      >
-                        {{ $t('common.copy') }} {{ $t('common.password') }}
-                      </el-dropdown-item>
-                    </template>
-                    <template
-                      v-if="
-                        !scope.row.isDeleted &&
-                          scope.row.type === CipherType.SecureNote
-                      "
+                    <el-dropdown-item
+                      v-for="(copyKey, index) in getCopyableValues(scope.row)"
+                      :key="index"
+                      v-clipboard:copy="copyKey.value"
+                      v-clipboard:success="clipboardSuccessHandler"
+                      :disabled="!copyKey.value"
                     >
-                      <el-dropdown-item
-                        v-clipboard:copy="scope.row.notes"
-                        v-clipboard:success="clipboardSuccessHandler"
-                        divided
-                      >
-                        {{ $t('common.copy') }} {{ $t('common.note') }}
-                      </el-dropdown-item>
-                    </template>
-                    <template
-                      v-if="scope.row.type === 7 && scope.row.cryptoWallet"
-                    >
-                      <el-dropdown-item
-                        v-clipboard:copy="scope.row.cryptoWallet.seed"
-                        v-clipboard:success="clipboardSuccessHandler"
-                      >
-                        {{ $t('common.copy') }} {{ $t('data.ciphers.seed') }}
-                      </el-dropdown-item>
-                      <el-dropdown-item
-                        v-clipboard:copy="scope.row.cryptoWallet.address"
-                        v-clipboard:success="clipboardSuccessHandler"
-                      >
-                        {{ $t('common.copy') }}
-                        {{ $t('data.ciphers.wallet_address') }}
-                      </el-dropdown-item>
-                      <el-dropdown-item
-                        v-clipboard:copy="scope.row.cryptoWallet.privateKey"
-                        v-clipboard:success="clipboardSuccessHandler"
-                      >
-                        {{ $t('common.copy') }}
-                        {{ $t('data.ciphers.private_key') }}
-                      </el-dropdown-item>
-                      <el-dropdown-item
-                        v-clipboard:copy="scope.row.cryptoWallet.password"
-                        v-clipboard:success="clipboardSuccessHandler"
-                      >
-                        {{ $t('common.copy') }}
-                        {{ $t('data.ciphers.password_pin') }}
-                      </el-dropdown-item>
-                    </template>
+                      {{ $t('common.copy') }} {{ $t(copyKey.label) }}
+                    </el-dropdown-item>
                   </el-dropdown-menu>
                 </el-dropdown>
+                <!-- Copy end -->
               </div>
             </template>
           </el-table-column>
+          <!-- Actions end -->
         </el-table>
+        <!-- Cipher table -->
       </client-only>
     </div>
-    <ViewGrantorCipher ref="addEditCipherDialog" :type="type" />
+
+    <ViewGrantorCipher ref="addEditCipherDialog" />
   </div>
 </template>
 
 <script>
 import cloneDeep from 'lodash/cloneDeep'
+import { CipherMapper } from '../../../../constants'
 import { CipherType } from '@/core/enums'
 import Vnodes from '@/components/Vnodes'
-import ViewGrantorCipher from '@/components/setting/ViewGrantorCipher'
+import ViewGrantorCipher from '@/components/setting/emergency-access/ViewGrantorCipher'
 import { Cipher } from '@/core/models/domain/cipher'
 import { CipherData } from '@/core/models/data/cipherData'
 import { SymmetricCryptoKey } from '@/core/models/domain/symmetricCryptoKey'
+import { EncString } from '@/core/models/domain/encString'
+
 export default {
   components: {
     Vnodes,
     ViewGrantorCipher
   },
+
   data () {
     return {
       id: null,
@@ -166,6 +136,7 @@ export default {
       list_granted: []
     }
   },
+
   computed: {
     emergencyAccess () {
       return (
@@ -173,6 +144,7 @@ export default {
       )
     }
   },
+
   mounted () {
     if (this.$route.params.id === null) {
       return this.$router.push(
@@ -183,6 +155,7 @@ export default {
     this.load()
     this.getListGranted()
   },
+
   methods: {
     async load () {
       try {
@@ -196,51 +169,84 @@ export default {
         this.loading = false
       }
     },
+
     async getAllCiphers (response) {
-      let ciphers = response.ciphers
-      ciphers = ciphers.filter(cipher =>
-        [
-          CipherType.Login,
-          CipherType.SecureNote,
-          CipherType.Card,
-          CipherType.Identity,
-          7
-        ].includes(cipher.type)
-      )
-      const decCiphers = []
-      const oldKeyBuffer = await this.$cryptoService.rsaDecrypt(
-        response.key_encrypted
-      )
-      const oldEncKey = new SymmetricCryptoKey(oldKeyBuffer)
+      const allowedCipherTypes = Object.values(CipherMapper)
+        .filter(i => !i.hideFromCipherList && !i.noCreate)
+        .map(i => i.type)
 
-      const promises = []
-      ciphers.forEach(cipherResponse => {
-        const cipherData = new CipherData(cipherResponse)
-        const cipher = new Cipher(cipherData)
-        promises.push(cipher.decrypt(oldEncKey).then(c => decCiphers.push(c)))
-      })
+      // Get enc key
+      let encKey
+      try {
+        const keyBuffer = await this.$cryptoService.rsaDecrypt(
+          response.key_encrypted
+        )
+        encKey = new SymmetricCryptoKey(keyBuffer)
+      } catch (error) {
+        this.notify('Invalid key, cannot decrypt data', 'warning')
+        return
+      }
 
-      await Promise.all(promises)
-      decCiphers.map(item => {
-        if (item.type === 7) {
-          try {
-            item.cryptoWallet = JSON.parse(item.notes)
-            // item.notes = item.cryptoWallet ? item.cryptoWallet.notes : ''
-          } catch (error) {
-            console.log(error)
-          }
+      // Decrypt orgs
+      const orgMap = {}
+      try {
+        const privateKey = await this.$cryptoService.decryptToBytes(
+          new EncString(response.private_key),
+          encKey
+        )
+        const promises = []
+        const _getOrgKey = async (id, key) => {
+          const decKeyBuffer = await this.$cryptoService.rsaDecrypt(
+            key,
+            privateKey
+          )
+          orgMap[id] = new SymmetricCryptoKey(decKeyBuffer)
         }
-        return {
-          ...item
+        response.organizations.forEach(org => {
+          promises.push(_getOrgKey(org.id, org.key))
+        })
+        await Promise.allSettled(promises)
+      } catch (error) {
+        //
+      }
+
+      // Decrypt ciphers
+      const decCiphers = []
+
+      try {
+        const ciphers = response.ciphers.filter(cipher =>
+          allowedCipherTypes.includes(cipher.type)
+        )
+        const promises = []
+        const _decryptCipher = async cipherResponse => {
+          const cipherData = new CipherData(cipherResponse)
+          const cipher = new Cipher(cipherData)
+          const decCipher = await cipher.decrypt(
+            orgMap[cipherResponse.organization_id] || encKey
+          )
+          decCiphers.push(decCipher)
         }
-      })
-      decCiphers.sort(this.$cipherService.getLocaleSortingFunction())
+        ciphers.forEach(cipherResponse => {
+          promises.push(_decryptCipher(cipherResponse))
+        })
+        await Promise.allSettled(promises)
+      } catch (error) {
+        //
+      }
 
-      return decCiphers
+      // Done, process new types and sort
+      const res = decCiphers.map(item => {
+        const i = this.parseNotesOfNewTypes(item)
+        return i
+      })
+      res.sort(this.$cipherService.getLocaleSortingFunction())
+      return res
     },
+
     addEdit (cipher) {
       this.$refs.addEditCipherDialog.openDialog(cloneDeep(cipher))
     },
+
     getListGranted () {
       this.$axios
         .$get('cystack_platform/pm/emergency_access/granted')
diff --git a/src/renderer/pages/settings/security/index.vue b/src/renderer/pages/settings/security/index.vue
index e0ce26fc..288f6b07 100644
--- a/src/renderer/pages/settings/security/index.vue
+++ b/src/renderer/pages/settings/security/index.vue
@@ -18,7 +18,7 @@
 import ChangePassword from '@/components/setting/ChangePassword.vue'
 import ChangeMasterPassword from '@/components/setting/ChangeMasterPassword.vue'
 import TwoFactorAuthentication from '@/components/setting/TwoFactorAuthentication.vue'
-import EmergencyAccess from '@/components/setting/EmergencyAccess.vue'
+import EmergencyAccess from '@/components/setting/emergency-access/EmergencyAccess.vue'
 import ManageSessions from '@/components/setting/ManageSessions.vue'
 
 export default {