mirror of
https://github.com/oxen-io/lokinet.git
synced 2024-10-31 09:20:21 +00:00
38fd0552d3
Success case:
- the path endpoint creates and sends a LR_StatusMessage upon
successful path creation
Failure case:
- an intermediate hop creates and sends a LR_StatusMessage upon
failure to forward the path to the next hop for any reason
Both cases:
- transit hops receive LR_StatusMessages and add a frame
to them reflecting their "status" with respect to that path
- the path creator receives LR_StatusMessages and decrypts/parses
the LR_StatusRecord frames from the path hops. If all is good,
the Path does as it would when receiving a PathConfirmMessage.
If not, the Path marks the new path as failed.
LR_StatusMessage is now used/sent in place of PathConfirmMessage
99 lines
2.4 KiB
C++
99 lines
2.4 KiB
C++
#ifndef LLARP_ENCRYPTED_FRAME_HPP
|
|
#define LLARP_ENCRYPTED_FRAME_HPP
|
|
|
|
#include <crypto/encrypted.hpp>
|
|
#include <crypto/types.hpp>
|
|
#include <util/buffer.hpp>
|
|
#include <util/mem.h>
|
|
#include <util/threadpool.h>
|
|
|
|
namespace llarp
|
|
{
|
|
static constexpr size_t EncryptedFrameOverheadSize =
|
|
PUBKEYSIZE + TUNNONCESIZE + SHORTHASHSIZE;
|
|
static constexpr size_t EncryptedFrameBodySize = 128 * 6;
|
|
static constexpr size_t EncryptedFrameSize =
|
|
EncryptedFrameOverheadSize + EncryptedFrameBodySize;
|
|
|
|
struct EncryptedFrame : public Encrypted< EncryptedFrameSize >
|
|
{
|
|
EncryptedFrame() : EncryptedFrame(EncryptedFrameBodySize)
|
|
{
|
|
}
|
|
|
|
EncryptedFrame(size_t sz)
|
|
: Encrypted< EncryptedFrameSize >(std::min(sz, EncryptedFrameBodySize)
|
|
+ EncryptedFrameOverheadSize)
|
|
{
|
|
}
|
|
|
|
void
|
|
Resize(size_t sz)
|
|
{
|
|
if(sz <= EncryptedFrameSize)
|
|
{
|
|
_sz = sz;
|
|
UpdateBuffer();
|
|
}
|
|
}
|
|
|
|
bool
|
|
DoEncrypt(const SharedSecret& shared, bool noDH = false);
|
|
|
|
bool
|
|
DecryptInPlace(const SecretKey& seckey);
|
|
|
|
bool
|
|
DoDecrypt(const SharedSecret& shared);
|
|
|
|
bool
|
|
EncryptInPlace(const SecretKey& seckey, const PubKey& other);
|
|
};
|
|
|
|
/// TODO: can only handle 1 frame at a time
|
|
template < typename User >
|
|
struct AsyncFrameDecrypter
|
|
{
|
|
using User_ptr = std::shared_ptr< User >;
|
|
using DecryptHandler = std::function< void(llarp_buffer_t*, User_ptr) >;
|
|
|
|
static void
|
|
Decrypt(void* user)
|
|
{
|
|
AsyncFrameDecrypter< User >* ctx =
|
|
static_cast< AsyncFrameDecrypter< User >* >(user);
|
|
|
|
if(ctx->target.DecryptInPlace(ctx->seckey))
|
|
{
|
|
auto buf = ctx->target.Buffer();
|
|
buf->cur = buf->base + EncryptedFrameOverheadSize;
|
|
ctx->result(buf, ctx->user);
|
|
}
|
|
else
|
|
ctx->result(nullptr, ctx->user);
|
|
ctx->user = nullptr;
|
|
}
|
|
|
|
AsyncFrameDecrypter(const SecretKey& secretkey, DecryptHandler h)
|
|
: result(h), seckey(secretkey)
|
|
{
|
|
}
|
|
|
|
DecryptHandler result;
|
|
User_ptr user;
|
|
const SecretKey& seckey;
|
|
EncryptedFrame target;
|
|
|
|
void
|
|
AsyncDecrypt(const std::shared_ptr< thread::ThreadPool >& worker,
|
|
const EncryptedFrame& frame, User_ptr u)
|
|
{
|
|
target = frame;
|
|
user = u;
|
|
worker->addJob(std::bind(&Decrypt, this));
|
|
}
|
|
};
|
|
} // namespace llarp
|
|
|
|
#endif
|