negotiation in binary

Author: braindigitalis

include/dpp/discordvoiceclient.h

@@ -48,6 +48,7 @@
 #include <future>
 #include <functional>
 #include <chrono>
+#include <set>
 
 struct OpusDecoder;
 struct OpusEncoder;
@@ -57,6 +58,10 @@ namespace dpp {
 
 class audio_mixer;
 
+namespace dave::mls {
+	class Session;
+}
+
 // !TODO: change these to constexpr and rename every occurrence across the codebase
 #define AUDIO_TRACK_MARKER (uint16_t)0xFFFF
 
@@ -66,6 +71,8 @@ inline constexpr size_t send_audio_raw_max_length = 11520;
 
 inline constexpr size_t secret_key_size = 32;
 
+struct dave_transient_key;
+
 /*
 * @brief For holding a moving average of the number of current voice users, for applying a smooth gain ramp.
 */
@@ -162,6 +169,12 @@ struct dave_binary_header_t {
 	 * @brief Opcode type
 	 */
 	uint8_t opcode;
+	/**
+	 * @brief Data package
+	 */
+	uint8_t package[];
+
+	std::vector<uint8_t> get_data(size_t length) const;
 };
 #pragma pack(pop)
 
@@ -373,6 +386,7 @@ class DPP_EXPORT discord_voice_client : public websocket_client
 	 * (merges frames into one packet)
 	 */
 	OpusRepacketizer* repacketizer;
+
 #else
 	/**
 	 * @brief libopus encoder
@@ -386,6 +400,12 @@ class DPP_EXPORT discord_voice_client : public websocket_client
 	void* repacketizer;
 #endif
 
+	std::unique_ptr<dave::mls::Session> dave_session{};
+
+	std::unique_ptr<dave_transient_key> transient_key{};
+
+	std::set<std::string> dave_mls_user_list;
+
 	/**
 	 * @brief File descriptor for UDP connection
 	 */

src/davetest/dave.cpp

@@ -76,7 +76,7 @@ int main() {
 	dave_test.on_guild_create([&](const dpp::guild_create_t & event) {
 		if (event.created->id == TEST_GUILD_ID) {
 			dpp::discord_client* s = dave_test.get_shard(0);
-			s->connect_voice(TEST_GUILD_ID, TEST_VC_ID, false, false, false);
+			s->connect_voice(TEST_GUILD_ID, TEST_VC_ID, false, false, true);
 		}
 	});
 	dave_test.start(false);

src/dpp/discordvoiceclient.cpp

@@ -42,10 +42,12 @@
 #ifdef HAVE_VOICE
 	#include <sodium.h>
 	#include <opus/opus.h>
+	#include "dave/session.h"
 #else
 	struct OpusDecoder {};
 	struct OpusEncoder {};
 	struct OpusRepacketizer {};
+	struct dpp::dave::Session {};
 #endif
 
 namespace dpp {
@@ -70,6 +72,10 @@ constexpr uint8_t voice_protocol_version = 8;
  */
 static std::string external_ip;
 
+struct dave_transient_key {
+	std::shared_ptr<::mlspp::SignaturePrivateKey> mls_key;
+};
+
 /**
  * @brief Transport encryption type (libsodium)
  */
@@ -483,40 +489,49 @@ int discord_voice_client::udp_recv(char* data, size_t max_length)
 	return (int) recv(this->fd, data, (int)max_length, 0);
 }
 
+std::vector<uint8_t> dave_binary_header_t::get_data(size_t length) const {
+	return std::vector<uint8_t>(package, package + length - sizeof(dave_binary_header_t));
+}
+
 bool discord_voice_client::handle_frame(const std::string &data, ws_opcode opcode)
 {
 	json j;
 
 	/**
 	 * MLS frames come in as type OP_BINARY, we can also reply to them as type OP_BINARY.
 	 */
-	if (opcode == OP_BINARY && data.size() >= sizeof(dave_binary_header_t)) {
-
-		log(dpp::ll_trace, "R: " + dpp::utility::debug_dump((uint8_t*)(data.data()), data.length()));
+	if (opcode == OP_BINARY && data.size() >= sizeof(dave_binary_header_t) && dave_session && transient_key && transient_key->mls_key) {
 
-		dave_binary_header_t dave_header{};
-		std::memcpy(&dave_header, data.data(), sizeof(dave_binary_header_t));
+		auto* dave_header = reinterpret_cast<const dave_binary_header_t*>(data.data());
 
-		switch (dave_header.opcode) {
+		switch (dave_header->opcode) {
 			case voice_client_dave_mls_external_sender: {
 				log(ll_debug, "voice_client_dave_mls_external_sender");
+				dave_session->SetExternalSender(dave_header->get_data(data.length()));
 			}
-				break;
+			break;
 			case voice_client_dave_mls_proposals: {
 				log(ll_debug, "voice_client_dave_mls_proposals");
+				std::optional<std::vector<uint8_t>> response = dave_session->ProcessProposals(dave_header->get_data(data.length()), dave_mls_user_list);
+				if (response.has_value()) {
+					auto r = response.value();
+					r.insert(r.begin(), voice_client_dave_mls_commit_message);
+					this->write(std::string_view(reinterpret_cast<const char*>(r.data()), r.size()), OP_BINARY);
+				}
 			}
-				break;
+			break;
 			case voice_client_dave_announce_commit_transaction: {
 				log(ll_debug, "voice_client_dave_announce_commit_transaction");
 			}
-				break;
+			break;
 			case voice_client_dave_mls_welcome: {
 				log(ll_debug, "voice_client_dave_mls_welcome");
 			}
-				break;
+			break;
 			default:
 				log(ll_debug, "Unexpected DAVE frame opcode");
-				break;
+				log(dpp::ll_trace, "R: " + dpp::utility::debug_dump((uint8_t*)(data.data()), data.length()));
+			break;
 		}
 
 		return true;
@@ -563,8 +578,8 @@ bool discord_voice_client::handle_frame(const std::string &data, ws_opcode opcod
 			}
 			break;
 			case voice_opcode_multiple_clients_connect: {
-				auto client_list = j["d"]["user_ids"];
-				log(ll_debug, "Number of new clients in voice channel: " + std::to_string(client_list.size()));
+				dave_mls_user_list = j["d"]["user_ids"];
+				log(ll_debug, "Number of clients in voice channel: " + std::to_string(dave_mls_user_list.size()));
 			}
 			break;
 			/* Client Disconnect */
@@ -673,6 +688,13 @@ bool discord_voice_client::handle_frame(const std::string &data, ws_opcode opcod
 						log(ll_error, "We requested DAVE E2EE but didn't receive it from the server, downgrading...");
 						dave_version = dave_version_none;
 						send_silence(20);
+					} else {
+						dave_session = std::make_unique<dave::mls::Session>(
+							nullptr, sessionid, [this](std::string const& s1, std::string const& s2) {
+							log(ll_debug, "Dave session constructor callback: " + s1 + ", " + s2);
+						});
+						transient_key = std::make_unique<dave_transient_key>();
+						dave_session->Init(dave::MaxSupportedProtocolVersion(), channel_id, creator->me.id.str(), transient_key->mls_key);
 					}
 				} else {
 					/* This is needed to start voice receiving and make sure that the start of sending isn't cut off */
@@ -1433,17 +1455,18 @@ discord_voice_client& discord_voice_client::send_audio_opus(uint8_t* opus_packet
 	memcpy(encrypt_nonce, &noncel, sizeof(noncel));
 
 	/* Execute */
-	int r = crypto_aead_xchacha20poly1305_ietf_encrypt(
-			payload.data() + sizeof(header),
-			nullptr,
-			encoded_audio.data(),
-			encoded_audio_length,
-			/* The RTP Header as Additional Data */
-			reinterpret_cast<const unsigned char *>(&header),
-			sizeof(header),
-			nullptr,
-			static_cast<const unsigned char*>(encrypt_nonce),
-			secret_key.data());
+	crypto_aead_xchacha20poly1305_ietf_encrypt(
+		payload.data() + sizeof(header),
+		nullptr,
+		encoded_audio.data(),
+		encoded_audio_length,
+		/* The RTP Header as Additional Data */
+		reinterpret_cast<const unsigned char *>(&header),
+		sizeof(header),
+		nullptr,
+		static_cast<const unsigned char*>(encrypt_nonce),
+		secret_key.data()
+	);
 
 	/* Append the 4 byte nonce to the resulting payload */
 	std::memcpy(payload.data() + payload.size() - sizeof(noncel), &noncel, sizeof(noncel));