Decrypting Messages fails when Relationship is not active anymore

packages/transport/src/modules/challenges/ChallengeController.ts

@@ -31,9 +31,9 @@ export class ChallengeController extends TransportController {
     private async validateChallengeLocally(challenge: Challenge, signedChallenge: ChallengeSigned): Promise<{ isValid: boolean; correspondingRelationship?: Relationship }> {
         if (!challenge.createdBy) return { isValid: false };
 
-        const relationship = await this.parent.relationships.getActiveRelationshipToIdentity(challenge.createdBy);
+        const relationship = await this.parent.relationships.getOnceActiveRelationshipToIdentity(challenge.createdBy);
         if (!relationship) {
-            throw TransportCoreErrors.general.recordNotFound(Relationship, challenge.createdBy.toString());
+            throw TransportCoreErrors.general.recordNotFound("Once active Relationship to Identity", challenge.createdBy.toString());
         }
         const challengeBuffer = CoreBuffer.fromUtf8(signedChallenge.challenge);
         let isValid = false;

packages/transport/src/modules/messages/MessageController.ts

@@ -507,10 +507,10 @@ export class MessageController extends TransportController {
                 );
             }
         } else {
-            relationship = await this.relationships.getActiveRelationshipToIdentity(envelope.createdBy);
+            relationship = await this.relationships.getOnceActiveRelationshipToIdentity(envelope.createdBy);
 
             if (!relationship) {
-                throw TransportCoreErrors.messages.missingOrInactiveRelationship(envelope.createdBy.toString());
+                throw TransportCoreErrors.general.recordNotFound("Once active Relationship to Identity", envelope.createdBy.toString());
             }
 
             const [peerMessage, peerKey] = await this.decryptPeerEnvelope(envelope, relationship);

packages/transport/src/modules/relationships/RelationshipsController.ts

@@ -127,6 +127,17 @@ export class RelationshipsController extends TransportController {
         return await this.getRelationshipToIdentity(address, RelationshipStatus.Active);
     }
 
+    public async getOnceActiveRelationshipToIdentity(address: CoreAddress): Promise<Relationship | undefined> {
+        const relationship = await this.getRelationshipToIdentity(address);
+        if (!relationship || !this.relationshipWasOnceActive(relationship)) return;
+
+        return relationship;
+    }
+
+    public relationshipWasOnceActive(relationship: Relationship): boolean {
+        return !!relationship.cache?.auditLog.find((entry) => entry.newStatus === RelationshipStatus.Active);
+    }
+
     public async getRelationship(id: CoreId): Promise<Relationship | undefined> {
         const relationshipDoc = await this.relationships.read(id.toString());
         if (!relationshipDoc) {

packages/transport/test/modules/challenges/Challenges.test.ts

@@ -2,7 +2,7 @@ import { IDatabaseConnection } from "@js-soft/docdb-access-abstractions";
 import { Serializable } from "@js-soft/ts-serval";
 import { CoreAddress, CoreDate, CoreId } from "@nmshd/core-types";
 import { CryptoSignature } from "@nmshd/crypto";
-import { AccountController, Challenge, ChallengeSigned, ChallengeType, Transport } from "../../../src";
+import { AccountController, Challenge, ChallengeSigned, ChallengeType, Relationship, Transport } from "../../../src";
 import { TestUtil } from "../../testHelpers/TestUtil";
 
 describe("ChallengeTest", function () {
@@ -12,6 +12,7 @@ describe("ChallengeTest", function () {
 
     let recipient: AccountController;
     let sender: AccountController;
+    let relationship: Relationship;
 
     beforeAll(async function () {
         connection = await TestUtil.createDatabaseConnection();
@@ -24,7 +25,7 @@ describe("ChallengeTest", function () {
         sender = accounts[0];
         recipient = accounts[1];
 
-        await TestUtil.addRelationship(recipient, sender);
+        relationship = (await TestUtil.addRelationship(recipient, sender)).acceptedRelationshipPeer;
     });
 
     afterAll(async function () {
@@ -56,10 +57,25 @@ describe("ChallengeTest", function () {
         expect(validationResult.correspondingRelationship).toBeDefined();
     });
 
-    test("should not create a relationship challenge on terminated relationship", async function () {
-        const terminatedRelationship = (await TestUtil.terminateRelationship(recipient, sender)).terminatedRelationshipPeer;
-        await expect(sender.challenges.createChallenge(ChallengeType.Relationship, terminatedRelationship)).rejects.toThrow(
-            "error.transport.challenges.challengeTypeRequiresActiveRelationship"
-        );
+    describe("on terminated relationship", function () {
+        let terminatedRelationship: Relationship;
+        let challenge: ChallengeSigned;
+        beforeAll(async function () {
+            challenge = await sender.challenges.createChallenge(ChallengeType.Relationship, relationship);
+            terminatedRelationship = (await TestUtil.terminateRelationship(recipient, sender)).terminatedRelationshipPeer;
+        });
+
+        test("should not create a relationship challenge on terminated relationship", async function () {
+            await expect(sender.challenges.createChallenge(ChallengeType.Relationship, terminatedRelationship)).rejects.toThrow(
+                "error.transport.challenges.challengeTypeRequiresActiveRelationship"
+            );
+        });
+
+        test("should still validate the challenge on a terminated relationship", async function () {
+            const validationResult = await recipient.challenges.validateChallenge(challenge);
+            expect(validationResult).toBeDefined();
+            expect(validationResult.isValid).toBe(true);
+            expect(validationResult.correspondingRelationship).toBeDefined();
+        });
     });
 });

packages/transport/test/modules/messages/MessageController.test.ts

@@ -219,12 +219,19 @@ describe("MessageController", function () {
     });
 
     describe("Relationship Termination", function () {
+        let messageId: CoreId;
         beforeAll(async function () {
+            messageId = (await TestUtil.sendMessage(sender, recipient)).id;
             await TestUtil.terminateRelationship(sender, recipient);
         });
 
         test("should not send a message on a terminated relationship", async function () {
             await expect(TestUtil.sendMessage(sender, recipient)).rejects.toThrow("error.transport.messages.missingOrInactiveRelationship");
         });
+
+        test("should still decrypt the message", async function () {
+            await expect(sender.messages.fetchCaches([messageId])).resolves.not.toThrow();
+            await expect(recipient.messages.fetchCaches([messageId])).resolves.not.toThrow();
+        });
     });
 });