From ceb62dd9d0d86bc8327ace116930962cf7fad1e9 Mon Sep 17 00:00:00 2001
From: Melvin Keskin <melvo@olomono.de>
Date: Mon, 9 May 2022 21:45:49 +0200
Subject: Implement XEP-0384: OMEMO Encryption v0.8

This implements XEP-0384 in version v0.8 with a manager and storage
classes to be user-implemented for persistant storage.

The license of the code is LGPL-2.1-or-later as usual.  However since
libomemo-c (libsignal-protocol-c) is GPL-3.0, the built binary is always
licensed under GPL-3.0.  Having our code LGPL licensed will make it
avoids relicensing in the future in case we port it to an LGPL
compatible omemo library.

Closes #133.

Co-authored-by: Linus Jahn <lnj@kaidan.im>
---
 src/client/OmemoLibWrappers.h | 100 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 100 insertions(+)
 create mode 100644 src/client/OmemoLibWrappers.h

(limited to 'src/client/OmemoLibWrappers.h')

diff --git a/src/client/OmemoLibWrappers.h b/src/client/OmemoLibWrappers.h
new file mode 100644
index 00000000..e157f12c
--- /dev/null
+++ b/src/client/OmemoLibWrappers.h
@@ -0,0 +1,100 @@
+// SPDX-FileCopyrightText: 2022 Linus Jahn <lnj@kaidan.im>
+//
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#ifndef OMEMOLIBWRAPPERS_H
+#define OMEMOLIBWRAPPERS_H
+
+#include <key_helper.h>
+#include <session_builder.h>
+#include <session_cipher.h>
+#include <signal_protocol.h>
+
+// Wraps various types of the OMEMO library.
+template<typename T, void(destruct)(T *)>
+class OmemoLibPtr
+{
+    T *m_ptr = nullptr;
+
+public:
+    OmemoLibPtr(T *ptr = nullptr) : m_ptr(ptr) { }
+    OmemoLibPtr(const OmemoLibPtr &) = delete;
+    ~OmemoLibPtr()
+    {
+        if (m_ptr) {
+            destruct(m_ptr);
+        }
+    }
+    OmemoLibPtr &operator=(const OmemoLibPtr &) = delete;
+    OmemoLibPtr<T, destruct> &operator=(T *ptr)
+    {
+        reset(ptr);
+        return *this;
+    }
+    operator bool() const { return m_ptr != nullptr; }
+    T *operator->() const { return m_ptr; }
+    T *get() const { return m_ptr; }
+    T **ptrRef() { return &m_ptr; }
+    void reset(T *ptr)
+    {
+        if (m_ptr) {
+            destruct(m_ptr);
+        }
+        m_ptr = ptr;
+    }
+};
+
+template<typename T>
+void omemoLibUnrefHelper(T *ptr)
+{
+    SIGNAL_UNREF(ptr);
+}
+
+template<typename T>
+using RefCountedPtr = OmemoLibPtr<T, omemoLibUnrefHelper<T>>;
+
+static QByteArray omemoLibBufferToByteArray(signal_buffer *buffer)
+{
+    return QByteArray(reinterpret_cast<const char *>(signal_buffer_data(buffer)), signal_buffer_len(buffer));
+}
+
+static signal_buffer *omemoLibBufferFromByteArray(const QByteArray &bytes)
+{
+    return signal_buffer_create(reinterpret_cast<const unsigned char *>(bytes.constData()), bytes.size());
+}
+
+template<void(destruct)(signal_buffer *)>
+class BufferPtrBase : public OmemoLibPtr<signal_buffer, destruct>
+{
+public:
+    QByteArray toByteArray() const
+    {
+        return omemoLibBufferToByteArray(this->get());
+    }
+};
+
+class BufferSecurePtr : public BufferPtrBase<signal_buffer_bzero_free>
+{
+public:
+    static BufferSecurePtr fromByteArray(const QByteArray &bytes)
+    {
+        return { omemoLibBufferFromByteArray(bytes) };
+    }
+};
+
+class BufferPtr : public BufferPtrBase<signal_buffer_free>
+{
+public:
+    static BufferPtr fromByteArray(const QByteArray &bytes)
+    {
+        return { omemoLibBufferFromByteArray(bytes) };
+    }
+};
+
+using KeyListNodePtr = OmemoLibPtr<signal_protocol_key_helper_pre_key_list_node, signal_protocol_key_helper_key_list_free>;
+using SessionCipherPtr = OmemoLibPtr<session_cipher, session_cipher_free>;
+using SessionBuilderPtr = OmemoLibPtr<session_builder, session_builder_free>;
+using OmemoContextPtr = OmemoLibPtr<signal_context, signal_context_destroy>;
+using StoreContextPtr = OmemoLibPtr<signal_protocol_store_context, signal_protocol_store_context_destroy>;
+
+#endif  // OMEMOLIBWRAPPERS_H
-- 
cgit v1.2.3