@lifeready/core 1.0.0 → 1.0.1

package/src/lib/api/key-exchange.service.spec.ts

@@ -0,0 +1,470 @@
+// import { TestBed } from '@angular/core/testing';
+// import { environment } from 'projects/lr-auth-app/src/environments/environment';
+// import { TrustedPartyService, UserService } from '../../public-api';
+// import {
+//   loginTestUser,
+//   logoutUser,
+// } from '../auth/life-ready-auth.service.spec';
+// import { ProfileService } from '../users/profile.service';
+// import {
+//   lrConfigureTestingModule,
+//   lrExpectAsyncThrow,
+//   lrit,
+// } from '../_common/tests';
+// import { KeyExchangeService } from './key-exchange.service';
+// import {
+//   DecryptedKeyExchange,
+//   KeyExchangeContactCardInput,
+//   KeyExchangeState,
+//   OtkState,
+// } from './key-exchange.types';
+// import { MessageService } from './message.service';
+// import { SharedContactCardService } from './shared-contact-card.service';
+// import { deleteAllTps } from '../trusted-parties/trusted-party.service.spec';
+
+// const TIMEOUT = 1000 * 60 * 10;
+
+// describe('KeyExchangeService', () => {
+//   let service: KeyExchangeService;
+//   let messageService: MessageService;
+//   let profileService: ProfileService;
+//   let userService: UserService;
+//   let trustedPartyService: TrustedPartyService;
+//   let sccService: SharedContactCardService;
+
+//   beforeEach(async () => {
+//     lrConfigureTestingModule();
+//     service = TestBed.inject(KeyExchangeService);
+//     messageService = TestBed.inject(MessageService);
+//     profileService = TestBed.inject(ProfileService);
+//     userService = TestBed.inject(UserService);
+//     trustedPartyService = TestBed.inject(TrustedPartyService);
+//     sccService = TestBed.inject(SharedContactCardService);
+//   }, TIMEOUT);
+
+//   lrit(
+//     'should exchange keys and send messages',
+//     async () => {
+//       if (!environment.test) {
+//         return;
+//       }
+
+//       const {
+//         username: username1,
+//         password: password1,
+//       } = environment.test.users[0];
+//       const {
+//         username: username2,
+//         password: password2,
+//       } = environment.test.users[1];
+
+//       let ke: DecryptedKeyExchange;
+
+//       // ------------------------------------------------------
+//       // Test User 1
+//       // ------------------------------------------------------
+//       await loginTestUser(username1, password1);
+//       const user1 = await profileService.getCurrentUser();
+
+//       const msg1 = 'from initiator';
+//       const {
+//         keyExchange: initiated,
+//         otKeyK: initiatedOtKeyK,
+//       } = await service.initiateOtk({ message: { message: msg1 } });
+//       expect(initiated.id).toBeTruthy();
+//       expect(initiated.token).toBeTruthy();
+//       expect(initiated.initiatorActionRequired).toBe(false);
+//       expect(initiated.responderActionRequired).toBe(true);
+//       expect(initiated.state).toEqual(KeyExchangeState.IN_PROGRESS);
+//       expect(initiated.otk.state).toEqual(OtkState.OTK_INITIATED);
+
+//       const { keyExchange: cancelled } = await service.initiateOtk({
+//         message: { message: 'to be cancelled by initiator' },
+//       });
+//       const {
+//         keyExchange: declined,
+//         otKeyK: declinedOtKeyK,
+//       } = await service.initiateOtk({
+//         message: { message: 'to be declined by responder' },
+//       });
+//       const {
+//         keyExchange: declinedAfterAccept,
+//         otKeyK: declinedAfterOtKeyK,
+//       } = await service.initiateOtk({
+//         message: { message: 'to be declined by responder after accepting' },
+//       });
+
+//       // Initiator cancels
+//       await trustedPartyService.cancelInvitation(cancelled.id);
+//       ke = await service.getKeyExchange(cancelled.id);
+//       expect(ke.state).toEqual(KeyExchangeState.CANCELLED);
+//       // ------------------------------------------------------
+//       // Logout
+//       // ------------------------------------------------------
+//       await logoutUser();
+
+//       // Responder declines
+//       await trustedPartyService.declineInvitation(declined.id, declined.token);
+//       ke = await service.getKeyExchange(declined.id, {
+//         token: declined.token,
+//         otKeyK: declinedOtKeyK,
+//       });
+//       expect(ke.state).toEqual(KeyExchangeState.DECLINED);
+
+//       // Responder declines again should fail
+//       (
+//         await lrExpectAsyncThrow(
+//           trustedPartyService.declineInvitation(declined.id, declined.token)
+//         )
+//       ).toBeTruthy();
+
+//       ke = await service.getKeyExchange(initiated.id, {
+//         token: initiated.token,
+//         otKeyK: initiatedOtKeyK,
+//       });
+//       expect(
+//         ke.decryptedOtk.plainOtKeyCipher.initiator.message.message
+//       ).toEqual(msg1);
+
+//       // ------------------------------------------------------
+//       // Test User 2
+//       // ------------------------------------------------------
+//       await loginTestUser(username2, password2);
+//       const { currentUser: user2 } = await profileService.getCurrentUser();
+
+//       // Responder accepts then declines
+//       // Note that declining a key exchange will always invalidate the current shared key. So make
+//       // sure to do this first before the next test that accepts the exchange.
+//       ke = await service.getKeyExchange(declinedAfterAccept.id, {
+//         token: declinedAfterAccept.token,
+//         otKeyK: declinedAfterOtKeyK,
+//       });
+//       await service.respondOtk({
+//         id: ke.id,
+//         token: ke.token,
+//         decryptedOtk: ke.decryptedOtk,
+//         message: { message: 'will be declined after accepting' },
+//       });
+
+//       await trustedPartyService.declineInvitation(
+//         declinedAfterAccept.id,
+//         declinedAfterAccept.token
+//       );
+
+//       ke = await service.getKeyExchange(declinedAfterAccept.id);
+//       expect(ke.state).toEqual(KeyExchangeState.DECLINED);
+//       // Accept
+//       ke = await service.getKeyExchange(initiated.id, {
+//         token: initiated.token,
+//         otKeyK: initiatedOtKeyK,
+//       });
+//       const msg2 = 'from responder';
+//       const accepted = await service.respondOtk({
+//         id: ke.id,
+//         token: ke.token,
+//         decryptedOtk: ke.decryptedOtk,
+//         message: { message: msg2 },
+//       });
+//       expect(accepted.userSharedKey).toBeTruthy();
+//       expect(accepted.keyExchange.initiatorActionRequired).toBe(true);
+//       expect(accepted.keyExchange.responderActionRequired).toBe(false);
+//       expect(accepted.keyExchange.state).toEqual(KeyExchangeState.IN_PROGRESS);
+//       expect(accepted.keyExchange.otk.state).toEqual(OtkState.OTK_ACCEPTED);
+
+//       // Send message from User 2 to User 1 using username
+//       const plainMessageJson2to1 = {
+//         plain: 'plain message from test user 2 to test user 1',
+//       };
+//       const plainCipherMessageJson2to1 =
+//         'cipher message from test user 2 to test user 1';
+//       const message2to1 = await messageService.sendMessage({
+//         username: username1,
+//         plainMessageJson: plainMessageJson2to1,
+//         plainCipherMessageJson: plainCipherMessageJson2to1,
+//       });
+
+//       // ------------------------------------------------------
+//       // Test User 1
+//       // ------------------------------------------------------
+//       await loginTestUser(username1, password1);
+
+//       ke = await service.getKeyExchange(initiated.id);
+
+//       const completed = await service.completeOtk(
+//         ke.id,
+//         ke.initiatorRootKeyCipher,
+//         ke.otk.initiatorOneTimePbkCipher
+//       );
+//       expect(completed.userSharedKey).toBeTruthy();
+//       expect(completed.keyExchange.initiatorActionRequired).toBe(false);
+//       expect(completed.keyExchange.responderActionRequired).toBe(false);
+//       expect(completed.keyExchange.state).toEqual(KeyExchangeState.COMPLETED);
+//       expect(completed.keyExchange.otk.state).toEqual(OtkState.OTK_COMPLETED);
+
+//       const userSharedKey = await service.currentUserSharedKey({
+//         username: username2,
+//       });
+//       expect(userSharedKey.sharedKey.id).toEqual(
+//         completed.userSharedKey.sharedKey.id,
+//         'Current user shared key not set to the new one just shared.'
+//       );
+
+//       // Get message from user 2
+//       const message2to1Copy = await messageService.getMessage(
+//         message2to1.message.id
+//       );
+//       expect(JSON.stringify(message2to1Copy.plainMessageJson)).toEqual(
+//         JSON.stringify(plainMessageJson2to1)
+//       );
+//       expect(
+//         JSON.stringify(message2to1Copy.plainSignedCipherMessageJson)
+//       ).toEqual(JSON.stringify(plainCipherMessageJson2to1));
+
+//       // Send message from User 1 to User 2 using userId
+//       const plainMessageJson1to2 = {
+//         plain: 'plain message from test user 1 to test user 2',
+//       };
+//       const plainCipherMessageJson1to2 =
+//         'cipher message from test user 1 to test user 2';
+//       const message1to2 = await messageService.sendMessage({
+//         userId: user2.id,
+//         plainMessageJson: plainMessageJson1to2,
+//         plainCipherMessageJson: plainCipherMessageJson1to2,
+//       });
+
+//       // ------------------------------------------------------
+//       // Test User 2
+//       // ------------------------------------------------------
+//       await loginTestUser(username2, password2);
+//       const message1to2Copy = await messageService.getMessage(
+//         message1to2.message.id
+//       );
+//       expect(JSON.stringify(message1to2Copy.plainMessageJson)).toEqual(
+//         JSON.stringify(plainMessageJson1to2)
+//       );
+//       expect(
+//         JSON.stringify(message1to2Copy.plainSignedCipherMessageJson)
+//       ).toEqual(JSON.stringify(plainCipherMessageJson1to2));
+//     },
+//     TIMEOUT
+//   );
+
+//   lrit(
+//     'should exchange keys with specific user',
+//     async () => {
+//       if (!environment.test) {
+//         return;
+//       }
+
+//       const {
+//         username: username1,
+//         password: password1,
+//         email: email1,
+//       } = environment.test.users[0];
+//       const {
+//         username: username2,
+//         password: password2,
+//         email: email2,
+//       } = environment.test.users[1];
+//       const {
+//         username: username3,
+//         password: password3,
+//         email: email3,
+//       } = environment.test.users[2];
+
+//       // ------------------------------------------------------
+//       // Prepare
+//       // ------------------------------------------------------
+//       await deleteAllTps(username1, password1);
+
+//       // ------------------------------------------------------
+//       // Test User 1
+//       // ------------------------------------------------------
+//       const msg1 = 'from initiator';
+//       let ke: DecryptedKeyExchange;
+//       let res;
+
+//       await loginTestUser(username1, password1);
+//       const user2 = await userService.getUserByEmail(email2);
+//       const { keyExchange: initiated, otKeyK } = await service.initiateOtk({
+//         message: { message: msg1 },
+//         email: email2,
+//         upgrade: true,
+//       });
+
+//       // ------------------------------------------------------
+//       // Not signed in
+//       // ------------------------------------------------------
+//       await logoutUser();
+//       (
+//         await lrExpectAsyncThrow(service.getKeyExchange(initiated.id))
+//       ).toBeTruthy();
+
+//       // ------------------------------------------------------
+//       // Test User 3
+//       // ------------------------------------------------------
+//       await loginTestUser(username3, password3);
+//       // No access since not targeted at User3
+//       (
+//         await lrExpectAsyncThrow(service.getKeyExchange(initiated.id))
+//       ).toBeTruthy();
+//       // But can still access via the direct link
+//       ke = await service.getKeyExchange(initiated.id, {
+//         token: initiated.token,
+//         otKeyK,
+//       });
+//       // Can not accept because it's sent to user2.
+//       res = service.respondOtk({
+//         id: ke.id,
+//         token: ke.token,
+//         decryptedOtk: ke.decryptedOtk,
+//         message: { message: 'can not accept because it is targeted to user2' },
+//       });
+//       (await lrExpectAsyncThrow(res)).toBeTruthy();
+
+//       // ------------------------------------------------------
+//       // Test User 2
+//       // ------------------------------------------------------
+//       await loginTestUser(username2, password2);
+//       ke = await service.getKeyExchange(initiated.id);
+//       const accepted = await service.respondOtk({
+//         id: ke.id,
+//         token: ke.token,
+//         decryptedOtk: ke.decryptedOtk,
+//         message: { message: 'user2 can accept' },
+//       });
+//       expect(accepted.userSharedKey).toBeTruthy();
+//       expect(accepted.keyExchange.initiatorActionRequired).toBe(true);
+//       expect(accepted.keyExchange.responderActionRequired).toBe(false);
+//       expect(accepted.keyExchange.state).toEqual(KeyExchangeState.IN_PROGRESS);
+//       expect(accepted.keyExchange.otk.state).toEqual(OtkState.OTK_ACCEPTED);
+
+//       // ------------------------------------------------------
+//       // Test User 1
+//       // ------------------------------------------------------
+//       await loginTestUser(username1, password1);
+//       ke = await service.getKeyExchange(initiated.id);
+
+//       const completed = await service.completeOtk(
+//         ke.id,
+//         ke.initiatorRootKeyCipher,
+//         ke.otk.initiatorOneTimePbkCipher
+//       );
+//       expect(completed.userSharedKey).toBeTruthy();
+//       expect(completed.keyExchange.initiatorActionRequired).toBe(false);
+//       expect(completed.keyExchange.responderActionRequired).toBe(false);
+//       expect(completed.keyExchange.state).toEqual(KeyExchangeState.COMPLETED);
+//       expect(completed.keyExchange.otk.state).toEqual(OtkState.OTK_COMPLETED);
+//     },
+//     TIMEOUT
+//   );
+
+//   lrit(
+//     'should create shared contact cards',
+//     async () => {
+//       const {
+//         username: username1,
+//         password: password1,
+//       } = environment.test.users[0];
+//       const {
+//         username: username2,
+//         password: password2,
+//       } = environment.test.users[1];
+
+//       let ke: DecryptedKeyExchange;
+
+//       const msg1 = 'from initiator';
+//       const scc1 = {
+//         plainOwnerCipherDataJson: {
+//           data: 'User 1 private data', // use this to store the references to the fields in the master CC
+//         },
+//         plainSharedCipherDataJson: {
+//           name: { name: 'User 1 CC info to be shared with user 2' },
+//           phones: [{ label: 'null', value: '0432 123 456' }],
+//         },
+//         ownerPlainData: {
+//           name: {
+//             name: '1 First Last',
+//             firstName: '1 First',
+//             lastName: '1 Last ',
+//             title: '1 Dr',
+//           },
+//         },
+//       };
+//       const scc2: KeyExchangeContactCardInput = {
+//         plainOwnerCipherDataJson: {
+//           data: 'User 2 private data', // use this to store the references to the fields in the master CC
+//         },
+//         plainSharedCipherDataJson: {
+//           name: { name: 'User 2 CC info to be shared with user 1' },
+//           phones: [{ label: 'null', value: '+61 1111 222 333' }],
+//         },
+//         ownerPlainData: {
+//           name: {
+//             name: '2 First Last',
+//             firstName: '2 First',
+//             lastName: '2 Last ',
+//             title: '2 Dr',
+//           },
+//         },
+//       };
+
+//       // ------------------------------------------------------
+//       // Test User 1
+//       // ------------------------------------------------------
+//       await loginTestUser(username1, password1);
+//       const { currentUser: user1 } = await profileService.getCurrentUser();
+
+//       const initiated = await service.initiateOtk({
+//         message: { message: msg1 },
+//         contactCard: scc1,
+//       });
+
+//       // ------------------------------------------------------
+//       // Test User 2
+//       // ------------------------------------------------------
+//       await loginTestUser(username2, password2);
+//       const { currentUser: user2 } = await profileService.getCurrentUser();
+
+//       ke = await service.getKeyExchange(initiated.keyExchange.id, {
+//         token: initiated.keyExchange.token,
+//         otKeyK: initiated.otKeyK,
+//       });
+
+//       const scc1Receiver: any = {
+//         name:
+//           ke.decryptedOtk.plainOtKeyCipher.initiator.contactCard
+//             .plainSharedCipherDataJson.name,
+//       };
+
+//       const accepted = await service.respondOtk({
+//         id: ke.id,
+//         token: ke.token,
+//         decryptedOtk: ke.decryptedOtk,
+//         message: { message: 'user2 can accept' },
+//         responderContactCard: scc2,
+//         initiatorContactCard: {
+//           plainReceiverCipherDataJson: scc1Receiver,
+//         },
+//       });
+
+//       // ------------------------------------------------------
+//       // Test User 1
+//       // ------------------------------------------------------
+//       await loginTestUser(username1, password1);
+
+//       ke = await service.getKeyExchange(initiated.keyExchange.id);
+
+//       expect(ke.myContactCard).toEqual(scc1.plainSharedCipherDataJson);
+//       expect(ke.contactCard).toEqual(scc2.plainSharedCipherDataJson);
+
+//       const completed = await service.completeOtk(
+//         ke.id,
+//         ke.initiatorRootKeyCipher,
+//         ke.otk.initiatorOneTimePbkCipher,
+//         ''
+//       );
+//     },
+//     TIMEOUT
+//   );
+// });