DanS
d043538e2f
Phase 1 Step 1 (the linchpin). The receive path had nothing to decrypt:
HushChatTransactionMetadata carried only payload_position/size, and the
extractor discarded the paired payload memo + the header's "e"/"p". Widen the
metadata with sender_public_key_hex ("p"), secretstream_header_hex ("e"), and
payload_memo (ciphertext hex for a Message; request text for a ContactRequest),
populated from the already-parsed header/payload pair.
Add an end-to-end receive-path test: derive two identities, encrypt Alice->Bob,
wrap it as a HushChat header+payload memo pair, run it through
extractHushChatTransactionMetadata, and decrypt straight from the carried
metadata. Also asserts the harvest yields nothing when the feature is disabled.
Fields are only populated when featureEnabled (the extractor already returns
early otherwise), so an OFF build produces no decrypt material.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
111 lines
3.2 KiB
C++
111 lines
3.2 KiB
C++
#pragma once
|
|
|
|
#include <cstddef>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#ifndef DRAGONX_ENABLE_CHAT
|
|
#define DRAGONX_ENABLE_CHAT 0
|
|
#endif
|
|
|
|
namespace dragonx::chat {
|
|
|
|
enum class HushChatHeaderType {
|
|
Message,
|
|
ContactRequest
|
|
};
|
|
|
|
struct HushChatHeader {
|
|
int header_number = 0;
|
|
int version = 0;
|
|
std::string reply_zaddr;
|
|
std::string conversation_id;
|
|
HushChatHeaderType type = HushChatHeaderType::Message;
|
|
std::string secretstream_header_hex;
|
|
std::string public_key_hex;
|
|
};
|
|
|
|
struct HushChatHeaderParseResult {
|
|
bool ok = false;
|
|
HushChatHeader header;
|
|
std::string error;
|
|
};
|
|
|
|
struct HushChatMemoOutput {
|
|
std::size_t position = 0;
|
|
std::string memo;
|
|
};
|
|
|
|
struct HushChatMemoPair {
|
|
HushChatHeader header;
|
|
std::size_t header_position = 0;
|
|
std::size_t payload_position = 0;
|
|
std::string payload_memo;
|
|
};
|
|
|
|
enum class HushChatMemoGroupingIssue {
|
|
InvalidHeader,
|
|
MissingPayload,
|
|
DuplicateHeader,
|
|
OversizedMemo
|
|
};
|
|
|
|
struct HushChatMemoGroupingIssueInfo {
|
|
HushChatMemoGroupingIssue issue = HushChatMemoGroupingIssue::InvalidHeader;
|
|
std::size_t position = 0;
|
|
std::string detail;
|
|
};
|
|
|
|
struct HushChatMemoGroupingResult {
|
|
std::vector<HushChatMemoPair> pairs;
|
|
std::vector<HushChatMemoGroupingIssueInfo> issues;
|
|
std::size_t ignored_memo_count = 0;
|
|
};
|
|
|
|
struct HushChatTransactionInput {
|
|
std::string txid;
|
|
std::vector<HushChatMemoOutput> outputs;
|
|
};
|
|
|
|
struct HushChatTransactionMetadata {
|
|
std::string txid;
|
|
HushChatHeaderType type = HushChatHeaderType::Message;
|
|
std::string conversation_id;
|
|
std::string reply_zaddr;
|
|
std::size_t header_position = 0;
|
|
std::size_t payload_position = 0;
|
|
std::size_t payload_size = 0;
|
|
// Decrypt inputs carried through from the paired header + payload memos so the chat
|
|
// service can actually decrypt (a Message) or read the request (a ContactRequest).
|
|
std::string sender_public_key_hex; // header "p": peer crypto_kx public key (hex)
|
|
std::string secretstream_header_hex; // header "e": secretstream header (hex; empty for ContactRequest)
|
|
std::string payload_memo; // ciphertext hex (Message) or plaintext request text (ContactRequest)
|
|
};
|
|
|
|
struct HushChatTransactionExtractionResult {
|
|
bool feature_enabled = false;
|
|
std::vector<HushChatTransactionMetadata> metadata;
|
|
std::vector<HushChatMemoGroupingIssueInfo> issues;
|
|
std::size_t ignored_memo_count = 0;
|
|
};
|
|
|
|
constexpr int kHushChatSupportedVersion = 0;
|
|
constexpr std::size_t kHushChatMemoByteLimit = 512;
|
|
constexpr std::size_t kHushChatPublicKeyHexLength = 64;
|
|
constexpr std::size_t kHushChatSecretstreamHeaderHexLength = 48;
|
|
|
|
constexpr bool hushChatFeatureEnabledAtBuild()
|
|
{
|
|
return DRAGONX_ENABLE_CHAT != 0;
|
|
}
|
|
|
|
HushChatHeaderParseResult parseHushChatHeaderMemo(const std::string& memo);
|
|
HushChatMemoGroupingResult groupHushChatMemoOutputs(const std::vector<HushChatMemoOutput>& outputs);
|
|
HushChatTransactionExtractionResult extractHushChatTransactionMetadata(
|
|
const HushChatTransactionInput& transaction,
|
|
bool featureEnabled = hushChatFeatureEnabledAtBuild());
|
|
const char* hushChatHeaderTypeName(HushChatHeaderType type);
|
|
const char* hushChatMemoGroupingIssueName(HushChatMemoGroupingIssue issue);
|
|
|
|
} // namespace dragonx::chat
|