packages/shared/test/keys/publicKeys.spec.ts

   1 import type { PublicKeyReference } from '@proton/crypto';
   2 import { CryptoProxy } from '@proton/crypto';
   3
   4 import { API_KEY_SOURCE, RECIPIENT_TYPES } from '../../lib/constants';
   5 import { getContactPublicKeyModel, sortApiKeys, sortPinnedKeys } from '../../lib/keys/publicKeys';
   6 import { ExpiredPublicKey, SignOnlyPublicKey, ValidPublicKey } from './keys.data';
   7
   8 describe('get contact public key model', () => {
   9     const publicKeyConfig = {
  10         emailAddress: '',
  11         apiKeysConfig: {
  12             Keys: [],
  13             publicKeys: [],
  14             SignedKeyList: null,
  15         },
  16     };
  17
  18     it('should mark valid key as capable of encryption', async () => {
  19         const publicKey = await CryptoProxy.importPublicKey({ armoredKey: ValidPublicKey });
  20         const contactModel = await getContactPublicKeyModel({
  21             ...publicKeyConfig,
  22             pinnedKeysConfig: {
  23                 pinnedKeys: [publicKey],
  24                 isContact: true,
  25             },
  26         });
  27         const fingerprint = publicKey.getFingerprint();
  28         expect(contactModel.encryptionCapableFingerprints.has(fingerprint)).toBeTrue();
  29     });
  30
  31     it('should mark expired key as incapable of encryption', async () => {
  32         const publicKey = await CryptoProxy.importPublicKey({ armoredKey: ExpiredPublicKey });
  33         const contactModel = await getContactPublicKeyModel({
  34             ...publicKeyConfig,
  35             pinnedKeysConfig: {
  36                 pinnedKeys: [publicKey],
  37                 isContact: true,
  38             },
  39         });
  40         const fingerprint = publicKey.getFingerprint();
  41         expect(contactModel.encryptionCapableFingerprints.has(fingerprint)).toBeFalse();
  42     });
  43
  44     it('should mark sign-only as incapable of encryption', async () => {
  45         const publicKey = await CryptoProxy.importPublicKey({ armoredKey: SignOnlyPublicKey });
  46         const contactModel = await getContactPublicKeyModel({
  47             ...publicKeyConfig,
  48             pinnedKeysConfig: {
  49                 pinnedKeys: [publicKey],
  50                 isContact: true,
  51             },
  52         });
  53         const fingerprint = publicKey.getFingerprint();
  54         expect(contactModel.encryptionCapableFingerprints.has(fingerprint)).toBeFalse();
  55     });
  56
  57     it('should determine encryption flag based on `encryptToPinned` when pinned keys are present', async () => {
  58         const publicKey = await CryptoProxy.importPublicKey({ armoredKey: ValidPublicKey });
  59         const contactModel = await getContactPublicKeyModel({
  60             ...publicKeyConfig,
  61             apiKeysConfig: {
  62                 publicKeys: [{ publicKey, armoredKey: '', flags: 1, source: API_KEY_SOURCE.WKD }],
  63             },
  64             pinnedKeysConfig: {
  65                 pinnedKeys: [publicKey],
  66                 encryptToPinned: false,
  67                 encryptToUntrusted: true,
  68                 isContact: true,
  69             },
  70         });
  71         expect(contactModel.encrypt).toBeFalse();
  72     });
  73
  74     it('should determine encryption flag based on `encryptToUntrusted` when only API keys are present', async () => {
  75         const publicKey = await CryptoProxy.importPublicKey({ armoredKey: ValidPublicKey });
  76         const contactModel = await getContactPublicKeyModel({
  77             ...publicKeyConfig,
  78             apiKeysConfig: {
  79                 publicKeys: [{ publicKey, armoredKey: '', flags: 1, source: API_KEY_SOURCE.WKD }],
  80             },
  81             pinnedKeysConfig: {
  82                 pinnedKeys: [],
  83                 encryptToPinned: false,
  84                 encryptToUntrusted: true,
  85                 isContact: true,
  86             },
  87         });
  88         expect(contactModel.encrypt).toBeTrue();
  89     });
  90
  91     it('should set the encryption flag when pinned keys are present and `encryptToPinned` is missing', async () => {
  92         const publicKey = await CryptoProxy.importPublicKey({ armoredKey: ValidPublicKey });
  93         const contactModel = await getContactPublicKeyModel({
  94             ...publicKeyConfig,
  95             apiKeysConfig: {
  96                 publicKeys: [{ publicKey, armoredKey: '', flags: 1, source: API_KEY_SOURCE.WKD }],
  97             },
  98             pinnedKeysConfig: {
  99                 pinnedKeys: [publicKey],
 100                 // encryptToPinned: undefined,
 101                 encryptToUntrusted: false,
 102                 isContact: true,
 103             },
 104         });
 105         expect(contactModel.encrypt).toBeTrue();
 106     });
 107
 108     it('should not determine encryption flag based on `encryptToUntrusted` if API keys are missing', async () => {
 109         const contactModel = await getContactPublicKeyModel({
 110             ...publicKeyConfig,
 111             apiKeysConfig: {
 112                 publicKeys: [],
 113             },
 114             pinnedKeysConfig: {
 115                 pinnedKeys: [],
 116                 // encryptToPinned: undefined,
 117                 encryptToUntrusted: true,
 118                 isContact: true,
 119             },
 120         });
 121         expect(contactModel.encrypt).toBeUndefined();
 122     });
 123
 124     it('should not determine encryption flag based on `encryptToUntrusted` for internal users', async () => {
 125         const publicKey = await CryptoProxy.importPublicKey({ armoredKey: ValidPublicKey });
 126         const contactModel = await getContactPublicKeyModel({
 127             ...publicKeyConfig,
 128             apiKeysConfig: {
 129                 ...publicKeyConfig,
 130                 RecipientType: RECIPIENT_TYPES.TYPE_INTERNAL,
 131                 publicKeys: [{ publicKey, armoredKey: '', flags: 1, source: API_KEY_SOURCE.PROTON }],
 132             },
 133             pinnedKeysConfig: {
 134                 pinnedKeys: [publicKey],
 135                 // encryptToPinned: undefined,
 136                 encryptToUntrusted: false,
 137                 isContact: true,
 138             },
 139         });
 140         expect(contactModel.encrypt).toBeTrue();
 141     });
 142 });
 143
 144 describe('sortApiKeys', () => {
 145     const generateFakeKey = (fingerprint: string) =>
 146         ({
 147             getFingerprint() {
 148                 return fingerprint;
 149             },
 150         }) as PublicKeyReference;
 151     it('sort keys as expected', () => {
 152         const fingerprints = [
 153             'trustedObsoleteNotCompromised',
 154             'notTrustedObsoleteCompromised',
 155             'trustedNotObsoleteNotCompromised',
 156             'notTrustedNotObsoleteCompromised',
 157             'trustedNotObsoleteCompromised',
 158             'trustedObsoleteCompromised',
 159             'notTrustedNotObsoleteNotCompromised',
 160             'notTrustedObsoleteNotCompromised',
 161         ];
 162         const sortedKeys = sortApiKeys({
 163             keys: fingerprints.map(generateFakeKey),
 164             obsoleteFingerprints: new Set([
 165                 'trustedObsoleteNotCompromised',
 166                 'trustedObsoleteCompromised',
 167                 'notTrustedObsoleteNotCompromised',
 168                 'notTrustedObsoleteCompromised',
 169             ]),
 170             compromisedFingerprints: new Set([
 171                 'trustedObsoleteCompromised',
 172                 'trustedNotObsoleteCompromised',
 173                 'notTrustedObsoleteCompromised',
 174                 'notTrustedNotObsoleteCompromised',
 175             ]),
 176             trustedFingerprints: new Set([
 177                 'trustedObsoleteCompromised',
 178                 'trustedNotObsoleteCompromised',
 179                 'trustedObsoleteNotCompromised',
 180                 'trustedNotObsoleteNotCompromised',
 181             ]),
 182         });
 183         expect(sortedKeys.map((key) => key.getFingerprint())).toEqual([
 184             'trustedNotObsoleteNotCompromised',
 185             'trustedObsoleteNotCompromised',
 186             'trustedNotObsoleteCompromised',
 187             'trustedObsoleteCompromised',
 188             'notTrustedNotObsoleteNotCompromised',
 189             'notTrustedObsoleteNotCompromised',
 190             'notTrustedNotObsoleteCompromised',
 191             'notTrustedObsoleteCompromised',
 192         ]);
 193     });
 194 });
 195
 196 describe('sortPinnedKeys', () => {
 197     const generateFakeKey = (fingerprint: string) =>
 198         ({
 199             getFingerprint() {
 200                 return fingerprint;
 201             },
 202         }) as PublicKeyReference;
 203     it('sort keys as expected', () => {
 204         const fingerprints = [
 205             'cannotEncryptObsoleteNotCompromised',
 206             'canEncryptObsoleteCompromised',
 207             'cannotEncryptNotObsoleteNotCompromised',
 208             'canEncryptNotObsoleteCompromised',
 209             'cannotEncryptNotObsoleteCompromised',
 210             'cannotEncryptObsoleteCompromised',
 211             'canEncryptNotObsoleteNotCompromised',
 212             'canEncryptObsoleteNotCompromised',
 213         ];
 214         const sortedKeys = sortPinnedKeys({
 215             keys: fingerprints.map(generateFakeKey),
 216             obsoleteFingerprints: new Set([
 217                 'canEncryptObsoleteNotCompromised',
 218                 'canEncryptObsoleteCompromised',
 219                 'cannotEncryptObsoleteNotCompromised',
 220                 'cannotEncryptObsoleteCompromised',
 221             ]),
 222             compromisedFingerprints: new Set([
 223                 'canEncryptObsoleteCompromised',
 224                 'canEncryptNotObsoleteCompromised',
 225                 'cannotEncryptObsoleteCompromised',
 226                 'cannotEncryptNotObsoleteCompromised',
 227             ]),
 228             encryptionCapableFingerprints: new Set([
 229                 'canEncryptObsoleteCompromised',
 230                 'canEncryptNotObsoleteCompromised',
 231                 'canEncryptObsoleteNotCompromised',
 232                 'canEncryptNotObsoleteNotCompromised',
 233             ]),
 234         });
 235         expect(sortedKeys.map((key) => key.getFingerprint())).toEqual([
 236             'canEncryptNotObsoleteNotCompromised',
 237             'canEncryptObsoleteNotCompromised',
 238             'canEncryptNotObsoleteCompromised',
 239             'canEncryptObsoleteCompromised',
 240             'cannotEncryptNotObsoleteNotCompromised',
 241             'cannotEncryptObsoleteNotCompromised',
 242             'cannotEncryptNotObsoleteCompromised',
 243             'cannotEncryptObsoleteCompromised',
 244         ]);
 245     });
 246 });