verification-process.hpp

Go to the documentation of this file.

/*
 * This file is part of libkazv.
 * SPDX-FileCopyrightText: 2026 tusooa <tusooa@kazv.moe>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */
 
#pragma once
#include <libkazv-config.hpp>
#include "sas-desc.hpp"
#include <crypto-util.hpp>
#include <types.hpp>
#include <immer/array.hpp>
 
namespace Kazv
{
    namespace VerificationCancelCodes
    {
        inline const std::string unexpectedMessage = "m.unexpected_message";
        inline const std::string userCancel = "m.user";
        inline const std::string timeout = "m.timeout";
        inline const std::string unknownMethod = "m.unknown_method";
        inline const std::string keyMismatch = "m.key_mismatch";
        inline const std::string invalidMessage = "m.invalid_message";
        inline const std::string acceptedElsewhere = "m.accepted";
        inline const std::string mismatchedCommitment = "m.mismatched_commitment";
        inline const std::string mismatchedSas = "m.mismatched_sas";
    }
 
    struct SasDisplayCodes
    {
        immer::array<int> emojiIndices;
        immer::array<int> decimalCode;
        friend bool operator==(const SasDisplayCodes &a, const SasDisplayCodes &b) = default;
    };
 
    namespace VerificationProcessStates
    {
        struct WeRequested {};
        struct TheyRequested {};
        struct WeReady {};
        struct TheyReady {};
        struct WeStartedSas {};
        struct TheyStartedSas {};
        struct WeAcceptedSas {};
        struct TheyAcceptedSas {};
        // from ReceivedSasKey to VerifiedBoth, we need to also check confirmedMatch
        struct ReceivedSasKey {};
        struct ReceivedSasMac {};
        struct VerifiedThem {};
        struct VerifiedBoth {};
        struct Cancelled
        {
            std::string reasonCode;
            std::string reasonString;
        };
    }
 
    using VerificationProcessState = std::variant<
        std::monostate,
        VerificationProcessStates::WeRequested,
        VerificationProcessStates::TheyRequested,
        VerificationProcessStates::WeReady,
        VerificationProcessStates::TheyReady,
        VerificationProcessStates::WeStartedSas,
        VerificationProcessStates::TheyStartedSas,
        VerificationProcessStates::WeAcceptedSas,
        VerificationProcessStates::TheyAcceptedSas,
        VerificationProcessStates::ReceivedSasKey,
        VerificationProcessStates::ReceivedSasMac,
        VerificationProcessStates::VerifiedThem,
        VerificationProcessStates::VerifiedBoth,
        VerificationProcessStates::Cancelled
        >;
 
    struct VerificationProcess
    {
        enum Party {
            Us,
            Them,
        };
        struct RequestTag {};
        inline static const immer::flex_vector<std::string> supportedMethods = {"m.sas.v1"};
        inline static const immer::flex_vector<std::string> supportedHashes = {"sha256"};
        inline static const immer::flex_vector<std::string> supportedKeyAgreementProtocols = {"curve25519-hkdf-sha256"};
        inline static const immer::flex_vector<std::string> supportedMessageAuthenticationCodes = {"hkdf-hmac-sha256.v2"};
        inline static const immer::flex_vector<std::string> defaultShortAuthenticationString = {"emoji", "decimal"};
 
        VerificationProcess(std::string ourUserId, std::string ourDeviceId, std::string theirUserId, std::string theirDeviceId, std::string ourDeviceKey);
 
        std::string ourUserId;
        std::string ourDeviceId;
        std::string theirUserId;
        std::string theirDeviceId;
        immer::flex_vector<std::pair<Party, Event>> events;
        bool confirmedMatch{false};
        std::string ourDeviceKey;
        std::string theirDeviceKey;
 
        SasDesc sas;
        VerificationProcessState state;
        SasDisplayCodes codes;
 
        bool finished() const;
 
        // Modification functions
        [[nodiscard]] EventList processIncoming(Event e);
 
        void addOutgoing(Event e);
 
        void setTheirDeviceKey(std::string key);
 
        [[nodiscard]] EventList userReady();
 
        [[nodiscard]] EventList userCancel();
 
        [[nodiscard]] EventList userConfirmMatch();
 
        [[nodiscard]] EventList userDenyMatch();
 
        [[nodiscard]] EventList makeRequest(Timestamp now);
 
        [[nodiscard]] std::string txnId() const;
 
        [[nodiscard]] Timestamp requestTimestamp() const;
 
    private:
        struct ValidateResult
        {
            bool valid;
            VerificationProcessState state;
            EventList msgs;
 
            static ValidateResult ok();
            static ValidateResult error(VerificationProcessState state, EventList msgs);
        };
        [[nodiscard]] ValidateResult validateEvent(Event incomingEvent) const;
 
        [[nodiscard]] EventList toNextState(Event e);
 
        [[nodiscard]] Event makeEvent(std::string type, json content) const;
 
        [[nodiscard]] Event makeCancelEvent(std::string code) const;
 
        [[nodiscard]] Event makeReadyEvent() const;
 
        [[nodiscard]] Event makeStartEvent(std::string method) const;
 
        [[nodiscard]] Event makeSasAcceptEvent();
 
        [[nodiscard]] Event makeSasKeyEvent();
 
        [[nodiscard]] Event makeSasMacEvent();
 
        [[nodiscard]] std::pair<Party, Event> getStartEvent() const;
 
        [[nodiscard]] Party getStartingParty() const;
 
        [[nodiscard]] json addCommitmentToAcceptContent(json content, Event startEvent);
 
        [[nodiscard]] bool verifySasCommitment();
 
        [[nodiscard]] SasDisplayCodes makeDisplayCodes();
 
        [[nodiscard]] std::string getTheirKey() const;
 
        [[nodiscard]] std::pair<VerificationProcessState, EventList> verifyKeyMac(Event macEvent);
 
        void addOutgoingEvents(EventList el);
    };
}