update version to 2.4.5

.vscode/tasks.json

@@ -20,6 +20,7 @@
             "command": "cmake",
             "args": [
                 "${workspaceRoot}",
+                "-DCMAKE_EXPORT_COMPILE_COMMANDS=On",
                 "-DCMAKE_BUILD_TYPE=Debug",
                 "-DOPENDHT_PROXY_CLIENT=On",
                 "-DOPENDHT_PROXY_SERVER=On",

CMakeLists.txt

@@ -19,7 +19,7 @@ include(FindPkgConfig)
 include(cmake/CheckAtomic.cmake)
 
 set (opendht_VERSION_MAJOR 2)
-set (opendht_VERSION_MINOR 4.3)
+set (opendht_VERSION_MINOR 4.5)
 set (opendht_VERSION ${opendht_VERSION_MAJOR}.${opendht_VERSION_MINOR})
 set (PACKAGE_VERSION ${opendht_VERSION})
 set (VERSION "${opendht_VERSION}")

c/opendht_c.h

@@ -36,7 +36,7 @@ struct OPENDHT_C_PUBLIC dht_data_view {
 };
 typedef struct dht_data_view dht_data_view;
 
-OPENDHT_C_PUBLIC const char* dht_version();
+OPENDHT_C_PUBLIC const char* dht_version(void);
 
 // dht::Blob
 struct OPENDHT_C_PUBLIC dht_blob;

configure.ac

@@ -1,7 +1,7 @@
 dnl define macros
 m4_define([opendht_major_version], 2)
 m4_define([opendht_minor_version], 4)
-m4_define([opendht_patch_version], 3)
+m4_define([opendht_patch_version], 5)
 m4_define([opendht_version],
 		  [opendht_major_version.opendht_minor_version.opendht_patch_version])
 

include/opendht/value.h

@@ -213,7 +213,7 @@ struct OPENDHT_PUBLIC Value
         }
         static Filter notFilter(Filter&& f) {
             if (not f) return [](const Value&) { return false; };
-            return [f](const Value& v) { return not f(v); };
+            return [f = std::move(f)](const Value& v) { return not f(v); };
         }
         std::vector<Sp<Value>> filter(const std::vector<Sp<Value>>& values) {
             if (not (*this))
@@ -343,10 +343,10 @@ struct OPENDHT_PUBLIC Value
         return unpack<T>(*this);
     }
 
-    bool isEncrypted() const {
+    inline bool isEncrypted() const {
         return not cypher.empty();
     }
-    bool isSigned() const {
+    inline bool isSigned() const {
         return owner and not signature.empty();
     }
 
@@ -355,37 +355,24 @@ struct OPENDHT_PUBLIC Value
      * Afterward, checkSignature() will return true and owner will
      * be set to the corresponding public key.
      */
-    void sign(const crypto::PrivateKey& key) {
-        if (isEncrypted())
-            throw DhtException("Can't sign encrypted data.");
-        owner = key.getSharedPublicKey();
-        signature = key.sign(getToSign());
-    }
+    void sign(const crypto::PrivateKey& key);
 
     /**
      * Check that the value is signed and that the signature matches.
      * If true, the owner field will contain the signer public key.
      */
-    bool checkSignature() const {
+    inline bool checkSignature() const {
         return isSigned() and owner->checkSignature(getToSign(), signature);
     }
 
-    std::shared_ptr<crypto::PublicKey> getOwner() const {
-        return std::static_pointer_cast<crypto::PublicKey>(owner);
+    inline std::shared_ptr<crypto::PublicKey> getOwner() const {
+        return owner;
     }
 
     /**
      * Sign the value with from and returns the encrypted version for to.
      */
-    Value encrypt(const crypto::PrivateKey& from, const crypto::PublicKey& to) {
-        if (isEncrypted())
-            throw DhtException("Data is already encrypted.");
-        setRecipient(to.getId());
-        sign(from);
-        Value nv {id};
-        nv.setCypher(to.encrypt(getToEncrypt()));
-        return nv;
-    }
+    Value encrypt(const crypto::PrivateKey& from, const crypto::PublicKey& to);
 
     Value() {}
 
@@ -453,18 +440,18 @@ struct OPENDHT_PUBLIC Value
         return id == o.id and contentEquals(o);
     }
 
-    void setRecipient(const InfoHash& r) {
+    inline void setRecipient(const InfoHash& r) {
         recipient = r;
     }
 
-    void setCypher(Blob&& c) {
+    inline void setCypher(Blob&& c) {
         cypher = std::move(c);
     }
 
     /**
      * Pack part of the data to be signed (must always be done the same way)
      */
-    Blob getToSign() const {
+    inline Blob getToSign() const {
         msgpack::sbuffer buffer;
         msgpack::packer<msgpack::sbuffer> pk(&buffer);
         msgpack_pack_to_sign(pk);
@@ -474,7 +461,7 @@ struct OPENDHT_PUBLIC Value
     /**
      * Pack part of the data to be encrypted
      */
-    Blob getToEncrypt() const {
+    inline Blob getToEncrypt() const {
         msgpack::sbuffer buffer;
         msgpack::packer<msgpack::sbuffer> pk(&buffer);
         msgpack_pack_to_encrypt(pk);
@@ -484,7 +471,7 @@ struct OPENDHT_PUBLIC Value
     /** print value for debugging */
     OPENDHT_PUBLIC friend std::ostream& operator<< (std::ostream& s, const Value& v);
 
-    std::string toString() const {
+    inline std::string toString() const {
         std::stringstream ss;
         ss << *this;
         return ss.str();
@@ -638,8 +625,10 @@ struct OPENDHT_PUBLIC Value
      */
     unsigned priority {0};
 
+    bool checkSignature();
+    Sp<Value> decrypt(const crypto::PrivateKey& key);
+
 private:
-    friend class SecureDht;
     /* Cache for crypto ops */
     bool signatureChecked {false};
     bool signatureValid {false};

src/securedht.cpp

@@ -72,36 +72,20 @@ ValueType
 SecureDht::secureType(ValueType&& type)
 {
     type.storePolicy = [this,type](InfoHash id, Sp<Value>& v, const InfoHash& nid, const SockAddr& a) {
-        if (v->isSigned()) {
-            if (!v->signatureChecked) {
-                v->signatureChecked = true;
-                v->signatureValid = v->owner and v->owner->checkSignature(v->getToSign(), v->signature);
-            }
-            if (!v->signatureValid) {
-                if (logger_)
-                    logger_->w("Signature verification failed");
-                return false;
-            }
-        }
+        if (v->isSigned())
+            return v->checkSignature();
         return type.storePolicy(id, v, nid, a);
     };
     type.editPolicy = [this,type](InfoHash id, const Sp<Value>& o, Sp<Value>& n, const InfoHash& nid, const SockAddr& a) {
-        if (!o->isSigned())
+        if (not o->isSigned())
             return type.editPolicy(id, o, n, nid, a);
-        if (o->owner != n->owner) {
-            if (logger_)
-                logger_->w("Edition forbidden: owner changed.");
-            return false;
-        }
-        if (!n->signatureChecked) {
-            n->signatureChecked = true;
-            n->signatureValid = o->owner and o->owner->checkSignature(n->getToSign(), n->signature);
-        }
-        if (!n->signatureValid) {
+        if (o->owner != n->owner or not n->isSigned()) {
             if (logger_)
                 logger_->w("Edition forbidden: signature verification failed.");
             return false;
         }
+        if (not n->checkSignature())
+            return false;
         if (o->seq == n->seq) {
             // If the data is exactly the same,
             // it can be reannounced, possibly by someone else.
@@ -253,19 +237,12 @@ SecureDht::checkValue(const Sp<Value>& v)
 #endif
             return {};
         }
-        if (v->decrypted) {
-            return v->decryptedValue;
-        }
-        v->decrypted = true;
         try {
-            Value decrypted_val (decrypt(*v));
-            if (decrypted_val.recipient == getId()) {
-                if (decrypted_val.owner)
-                    nodesPubKeys_[decrypted_val.owner->getId()] = decrypted_val.owner;
-                v->decryptedValue = std::make_shared<Value>(std::move(decrypted_val));
-                return v->decryptedValue;
+            if (auto decrypted_val = v->decrypt(*key_)) {
+                if (decrypted_val->owner)
+                    nodesPubKeys_[decrypted_val->owner->getId()] = decrypted_val->owner;
+                return decrypted_val;
             }
-            // Ignore values belonging to other people
         } catch (const std::exception& e) {
             if (logger_)
                 logger_->w("Could not decrypt value %s : %s", v->toString().c_str(), e.what());
@@ -273,17 +250,11 @@ SecureDht::checkValue(const Sp<Value>& v)
     }
     // Check signed values
     else if (v->isSigned()) {
-        if (v->signatureChecked) {
-            return v->signatureValid ? v : Sp<Value>{};
-        }
-        v->signatureChecked = true;
-        if (v->owner and v->owner->checkSignature(v->getToSign(), v->signature)) {
-            v->signatureValid = true;
-            if (enableCache_)
+        if (v->checkSignature()) {
+            if (enableCache_ and v->owner)
                 nodesPubKeys_[v->owner->getId()] = v->owner;
             return v;
-        }
-        else if (logger_)
+        } else if (logger_)
             logger_->w("Signature verification failed for %s", v->toString().c_str());
     }
     // Forward normal values

src/value.cpp

@@ -254,6 +254,62 @@ unpackId(const Json::Value& json, const std::string& key) {
 }
 #endif
 
+void
+Value::sign(const crypto::PrivateKey& key)
+{
+    if (isEncrypted())
+        throw DhtException("Can't sign encrypted data.");
+    owner = key.getSharedPublicKey();
+    signature = key.sign(getToSign());
+}
+
+Value
+Value::encrypt(const crypto::PrivateKey& from, const crypto::PublicKey& to)
+{
+    if (isEncrypted())
+        throw DhtException("Data is already encrypted.");
+    setRecipient(to.getId());
+    sign(from);
+    Value nv {id};
+    nv.setCypher(to.encrypt(getToEncrypt()));
+    return nv;
+}
+
+bool
+Value::checkSignature()
+{
+    if (!signatureChecked) {
+        signatureChecked = true;
+        if (isSigned()) {
+            signatureValid = owner and owner->checkSignature(getToSign(), signature);
+        } else {
+            signatureValid = true;
+        }
+    }
+    return signatureValid;
+}
+
+Sp<Value>
+Value::decrypt(const crypto::PrivateKey& key)
+{
+    if (not decrypted) {
+        decrypted = true;
+        if (isEncrypted()) {
+            auto decryptedBlob = key.decrypt(cypher);
+            std::unique_ptr<Value> v {new Value(id)};
+            auto msg = msgpack::unpack((const char*)decryptedBlob.data(), decryptedBlob.size());
+            v->msgpack_unpack_body(msg.get());
+            if (v->recipient != key.getPublicKey().getId())
+                throw crypto::DecryptError("Recipient mismatch");
+            // Ignore values belonging to other people
+            if (not v->owner or not v->owner->checkSignature(v->getToSign(), v->signature))
+                throw crypto::DecryptError("Signature mismatch");
+            decryptedValue = std::move(v);
+        }
+    }
+    return decryptedValue;
+}
+
 bool
 FieldValue::operator==(const FieldValue& vfd) const
 {

tests/dhtrunnertester.cpp

@@ -95,6 +95,11 @@ DhtRunnerTester::testListen() {
     std::mutex mutex;
     std::condition_variable cv;
     std::atomic_uint valueCount(0);
+    std::atomic_uint valueCounta(0);
+    std::atomic_uint valueCountb(0);
+    std::atomic_uint valueCountc(0);
+    std::atomic_uint valueCountd(0);
+
     unsigned putCount(0);
     unsigned putOkCount1(0);
     unsigned putOkCount2(0);
@@ -109,33 +114,34 @@ DhtRunnerTester::testListen() {
 
     auto ftokena = node1.listen(a, [&](const std::vector<std::shared_ptr<dht::Value>>& values, bool expired) {
         if (expired)
-            valueCount -= values.size();
+            valueCounta -= values.size();
         else
-            valueCount += values.size();
+            valueCounta += values.size();
         return true;
     });
 
-    auto ftokenb = node1.listen(b, [&](const std::vector<std::shared_ptr<dht::Value>>& values, bool expired) {
-        if (expired)
-            valueCount -= values.size();
+    auto ftokenb = node1.listen(b, [&](const std::shared_ptr<dht::Value>&) {
+        /*if (expired)
+            valueCountb -= values.size();
         else
-            valueCount += values.size();
+            valueCountb += values.size();*/
+        valueCountb++;
         return false;
     });
 
     auto ftokenc = node1.listen(c, [&](const std::vector<std::shared_ptr<dht::Value>>& values, bool expired) {
         if (expired)
-            valueCount -= values.size();
+            valueCountc -= values.size();
         else
-            valueCount += values.size();
+            valueCountc += values.size();
         return true;
     });
 
     auto ftokend = node1.listen(d, [&](const std::vector<std::shared_ptr<dht::Value>>& values, bool expired) {
         if (expired)
-            valueCount -= values.size();
+            valueCountd -= values.size();
         else
-            valueCount += values.size();
+            valueCountd += values.size();
         return true;
     });
 
@@ -188,7 +194,10 @@ DhtRunnerTester::testListen() {
     CPPUNIT_ASSERT(tokena);
     CPPUNIT_ASSERT(tokenc);
     CPPUNIT_ASSERT(tokend);
-    CPPUNIT_ASSERT_EQUAL(N * 2u + 1u, valueCount.load());
+    CPPUNIT_ASSERT_EQUAL(N, valueCounta.load());
+    CPPUNIT_ASSERT_EQUAL(1u, valueCountb.load());
+    CPPUNIT_ASSERT_EQUAL(N, valueCountc.load());
+    CPPUNIT_ASSERT_EQUAL(0u, valueCountd.load());
 
     node1.cancelListen(a, tokena);
     node1.cancelListen(b, std::move(ftokenb));