From 4153da3c16d184a1e6ffa15d2c504c6e3f6b0e1f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Roman=20Smr=C5=BE?= Date: Sat, 19 Aug 2023 09:42:34 +0200 Subject: Network: move secure channel to protocol module --- src/network/channel.cpp | 200 +++++++++++++++++++++++++++++++++++++++++++++++ src/network/channel.h | 73 +++++++++++++++++ src/network/protocol.cpp | 7 ++ src/network/protocol.h | 35 +++++++++ 4 files changed, 315 insertions(+) create mode 100644 src/network/channel.cpp create mode 100644 src/network/channel.h (limited to 'src/network') diff --git a/src/network/channel.cpp b/src/network/channel.cpp new file mode 100644 index 0000000..b317f3d --- /dev/null +++ b/src/network/channel.cpp @@ -0,0 +1,200 @@ +#include "channel.h" + +#include +#include +#include + +#include + +using std::remove_const; +using std::runtime_error; + +using namespace erebos; + +Ref ChannelRequestData::store(const Storage & st) const +{ + vector items; + + for (const auto & p : peers) + items.emplace_back("peer", p); + items.emplace_back("enc", "aes-128-gcm"); + items.emplace_back("key", key); + + return st.storeObject(Record(std::move(items))); +} + +ChannelRequestData ChannelRequestData::load(const Ref & ref) +{ + if (auto rec = ref->asRecord()) { + if (rec->item("enc").asText() == "aes-128-gcm") + if (auto key = rec->item("key").as()) + return ChannelRequestData { + .peers = rec->items("peer").as>(), + .key = *key, + }; + } + + return ChannelRequestData { + .peers = {}, + .key = Stored::load(ref.storage().zref()), + }; +} + +Ref ChannelAcceptData::store(const Storage & st) const +{ + vector items; + + items.emplace_back("req", request); + items.emplace_back("enc", "aes-128-gcm"); + items.emplace_back("key", key); + + return st.storeObject(Record(std::move(items))); +} + +ChannelAcceptData ChannelAcceptData::load(const Ref & ref) +{ + if (auto rec = ref->asRecord()) + if (rec->item("enc").asText() == "aes-128-gcm") + return ChannelAcceptData { + .request = *rec->item("req").as(), + .key = *rec->item("key").as(), + }; + + return ChannelAcceptData { + .request = Stored::load(ref.storage().zref()), + .key = Stored::load(ref.storage().zref()), + }; +} + +unique_ptr ChannelAcceptData::channel() const +{ + if (auto secret = SecretKexKey::load(key)) + return make_unique( + request->data->peers, + secret->dh(*request->data->key), + false + ); + + if (auto secret = SecretKexKey::load(request->data->key)) + return make_unique( + request->data->peers, + secret->dh(*key), + true + ); + + throw runtime_error("failed to load secret DH key"); +} + + +Stored Channel::generateRequest(const Storage & st, + const Identity & self, const Identity & peer) +{ + auto signKey = SecretKey::load(self.keyMessage()); + if (!signKey) + throw runtime_error("failed to load own message key"); + + return signKey->sign(st.store(ChannelRequestData { + .peers = self.ref()->digest() < peer.ref()->digest() ? + vector>> { + Stored>::load(*self.ref()), + Stored>::load(*peer.ref()), + } : + vector>> { + Stored>::load(*peer.ref()), + Stored>::load(*self.ref()), + }, + .key = SecretKexKey::generate(st).pub(), + })); +} + +optional> Channel::acceptRequest(const Identity & self, + const Identity & peer, const Stored & request) +{ + if (!request->isSignedBy(peer.keyMessage())) + return nullopt; + + auto & peers = request->data->peers; + if (peers.size() != 2 || + std::none_of(peers.begin(), peers.end(), [&self](const auto & x) + { return x.ref().digest() == self.ref()->digest(); }) || + std::none_of(peers.begin(), peers.end(), [&peer](const auto & x) + { return x.ref().digest() == peer.ref()->digest(); })) + return nullopt; + + auto & st = request.ref().storage(); + + auto signKey = SecretKey::load(self.keyMessage()); + if (!signKey) + throw runtime_error("failed to load own message key"); + + return signKey->sign(st.store(ChannelAcceptData { + .request = request, + .key = SecretKexKey::generate(st).pub(), + })); +} + +vector Channel::encrypt(const vector & plain) +{ + vector res(plain.size() + 8 + 16 + 16); + array iv; + + uint64_t beCount = htobe64(nonceCounter++); + std::memcpy(res.data(), &beCount, 8); + std::copy_n(nonceFixedOur.begin(), 6, iv.begin()); + std::copy_n(res.begin() + 2, 6, iv.begin() + 6); + + const unique_ptr + ctx(EVP_CIPHER_CTX_new(), EVP_CIPHER_CTX_free); + EVP_EncryptInit_ex(ctx.get(), EVP_aes_128_gcm(), + nullptr, key.data(), iv.data()); + + int outl = 0; + uint8_t * cur = res.data() + 8; + + if (EVP_EncryptUpdate(ctx.get(), cur, &outl, plain.data(), plain.size()) != 1) + throw runtime_error("failed to encrypt data"); + cur += outl; + + if (EVP_EncryptFinal(ctx.get(), cur, &outl) != 1) + throw runtime_error("failed to encrypt data"); + cur += outl; + + EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_GCM_GET_TAG, 16, cur); + cur += 16; + + res.resize(cur - res.data()); + return res; +} + +optional> Channel::decrypt(const vector & ctext) +{ + vector res(ctext.size()); + array iv; + + std::copy_n(nonceFixedPeer.begin(), 6, iv.begin()); + std::copy_n(ctext.begin() + 2, 6, iv.begin() + 6); + + const unique_ptr + ctx(EVP_CIPHER_CTX_new(), EVP_CIPHER_CTX_free); + EVP_DecryptInit_ex(ctx.get(), EVP_aes_128_gcm(), + nullptr, key.data(), iv.data()); + + int outl = 0; + uint8_t * cur = res.data(); + + if (EVP_DecryptUpdate(ctx.get(), cur, &outl, + ctext.data() + 8, ctext.size() - 8 - 16) != 1) + return nullopt; + cur += outl; + + if (!EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_GCM_SET_TAG, 16, + (void *) (ctext.data() + ctext.size() - 16))) + return nullopt; + + if (EVP_DecryptFinal_ex(ctx.get(), cur, &outl) != 1) + return nullopt; + cur += outl; + + res.resize(cur - res.data()); + return res; +} diff --git a/src/network/channel.h b/src/network/channel.h new file mode 100644 index 0000000..f932c84 --- /dev/null +++ b/src/network/channel.h @@ -0,0 +1,73 @@ +#pragma once + +#include + +#include "../identity.h" + +#include +#include + +namespace erebos { + +using std::array; +using std::atomic; +using std::unique_ptr; + +struct ChannelRequestData +{ + Ref store(const Storage & st) const; + static ChannelRequestData load(const Ref &); + + const vector>> peers; + const Stored key; +}; + +typedef Signed ChannelRequest; + +struct ChannelAcceptData +{ + Ref store(const Storage & st) const; + static ChannelAcceptData load(const Ref &); + + unique_ptr channel() const; + + const Stored request; + const Stored key; +}; + +typedef Signed ChannelAccept; + +class Channel +{ +public: + Channel(const vector>> & peers, + vector && key, bool ourRequest): + peers(peers), + key(std::move(key)), + nonceFixedOur({ uint8_t(ourRequest ? 1 : 2), 0, 0, 0, 0, 0 }), + nonceFixedPeer({ uint8_t(ourRequest ? 2 : 1), 0, 0, 0, 0, 0 }) + {} + + Channel(const Channel &) = delete; + Channel(Channel &&) = delete; + Channel & operator=(const Channel &) = delete; + Channel & operator=(Channel &&) = delete; + + static Stored generateRequest(const Storage &, + const Identity & self, const Identity & peer); + static optional> acceptRequest(const Identity & self, + const Identity & peer, const Stored & request); + + vector encrypt(const vector &); + optional> decrypt(const vector &); + +private: + const vector>> peers; + const vector key; + + const array nonceFixedOur; + const array nonceFixedPeer; + atomic nonceCounter = 0; +}; + +} diff --git a/src/network/protocol.cpp b/src/network/protocol.cpp index fb3a5ea..4151bf2 100644 --- a/src/network/protocol.cpp +++ b/src/network/protocol.cpp @@ -24,6 +24,8 @@ struct NetworkProtocol::ConnectionPriv mutex cmutex {}; vector buffer {}; + + ChannelState channel = monostate(); }; @@ -202,6 +204,11 @@ void NetworkProtocol::Connection::close() p = nullptr; } +NetworkProtocol::ChannelState & NetworkProtocol::Connection::channel() +{ + return p->channel; +} + /******************************************************************************/ /* Header */ diff --git a/src/network/protocol.h b/src/network/protocol.h index 4794ba6..88abf67 100644 --- a/src/network/protocol.h +++ b/src/network/protocol.h @@ -1,5 +1,7 @@ #pragma once +#include "channel.h" + #include #include @@ -45,6 +47,12 @@ public: PollResult poll(); + using ChannelState = variant, + shared_ptr, + Stored, + unique_ptr>; + Connection connect(sockaddr_in6 addr); bool recvfrom(vector & buffer, sockaddr_in6 & addr); @@ -84,6 +92,9 @@ public: void close(); + // temporary: + ChannelState & channel(); + private: unique_ptr p; }; @@ -121,4 +132,28 @@ struct NetworkProtocol::Header const vector items; }; +class ReplyBuilder +{ +public: + void header(NetworkProtocol::Header::Item &&); + void body(const Ref &); + + const vector & header() const { return mheader; } + vector body() const; + +private: + vector mheader; + vector mbody; +}; + +struct WaitingRef +{ + const Storage storage; + const PartialRef ref; + vector missing; + + optional check(); + optional check(ReplyBuilder &); +}; + } -- cgit v1.2.3