zeroc-ice 3.8.2 → 3.8.3

data/dist/ice/cpp/src/Ice/Random.cpp

@@ -1,29 +1,90 @@
 // Copyright (c) ZeroC, Inc.
 
+#ifdef _WIN32
+#    define _CRT_RAND_S
+#endif
+
 #include "Random.h"
 
+#include <array>
 #include <cassert>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <system_error>
+
+#if defined(__linux__)
+#    include <cerrno>
+#    include <sys/random.h>
+#endif
 
 using namespace std;
 
+// Generate the random bytes with the operating system's CSPRNG, never with std::random_device: the C++
+// standard gives std::random_device no cryptographic guarantee, and some implementations draw from raw CPU
+// entropy instructions whose output defective hardware can make predictable.
 void
 IceInternal::generateRandom(char* buffer, size_t size)
 {
-    // We use the random_device directly here to get cryptographic random numbers when possible.
-    thread_local static std::random_device rd;
-    uniform_int_distribution<unsigned int> distribution(0, 255);
-    for (size_t i = 0; i < size; ++i, ++buffer)
+#if defined(_WIN32)
+    // rand_s is backed by the same system CSPRNG as BCryptGenRandom and requires no additional link
+    // dependency.
+    size_t index = 0;
+    while (index < size)
+    {
+        unsigned int r = 0;
+        errno_t err = rand_s(&r);
+        if (err != 0)
+        {
+            throw system_error(err, generic_category(), "rand_s failed");
+        }
+        size_t n = min(sizeof(r), size - index);
+        memcpy(buffer + index, &r, n);
+        index += n;
+    }
+#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
+    arc4random_buf(buffer, size);
+#elif defined(__linux__)
+    // getrandom with flags == 0 deliberately blocks until the kernel's entropy pool is initialized; don't
+    // "fix" this with GRND_NONBLOCK. There is also deliberately no /dev/urandom fallback here: getrandom is
+    // available in every supported glibc (2.25+), so a failure is a real error, not a missing feature.
+    size_t index = 0;
+    while (index < size)
     {
-        *buffer = static_cast<char>(distribution(rd));
+        ssize_t n = getrandom(buffer + index, size - index, 0);
+        if (n <= 0)
+        {
+            if (n < 0 && errno == EINTR)
+            {
+                continue;
+            }
+            if (n == 0)
+            {
+                throw system_error(EIO, generic_category(), "getrandom returned no data");
+            }
+            throw system_error(errno, generic_category(), "getrandom failed");
+        }
+        index += static_cast<size_t>(n);
     }
+#else
+#    error "unsupported platform: no OS CSPRNG binding"
+#endif
 }
 
 unsigned int
 IceInternal::random(unsigned int limit)
 {
     assert(limit > 0);
-    thread_local static std::random_device rd;
-    thread_local static std::mt19937 rng(rd());
+    thread_local static mt19937 rng = createMT19937();
     uniform_int_distribution<unsigned int> distribution(0, limit - 1);
     return distribution(rng);
 }
+
+mt19937
+IceInternal::createMT19937()
+{
+    array<uint32_t, 8> seedData;
+    generateRandom(reinterpret_cast<char*>(seedData.data()), sizeof(seedData));
+    seed_seq seq(seedData.begin(), seedData.end());
+    return mt19937(seq);
+}

data/dist/ice/cpp/src/Ice/Random.h

@@ -9,13 +9,17 @@
 
 namespace IceInternal
 {
+    // Fills the buffer with cryptographically strong random bytes from the operating system's CSPRNG.
     ICE_API void generateRandom(char*, size_t);
+
     ICE_API unsigned int random(unsigned int = 0);
 
+    // Creates a std::mt19937 engine seeded from the operating system's CSPRNG.
+    ICE_API std::mt19937 createMT19937();
+
     template<class T> void shuffle(T first, T last)
     {
-        thread_local static std::random_device rd;
-        thread_local static std::mt19937 rng(rd());
+        thread_local static std::mt19937 rng = createMT19937();
         std::shuffle(first, last, rng);
     }
 }

data/dist/ice/cpp/src/Ice/Reference.cpp

@@ -1013,9 +1013,15 @@ IceInternal::RoutableReference::toProperty(string prefix) const
     properties[prefix + ".ConnectionCached"] = _cacheConnection ? "1" : "0";
     properties[prefix + ".EndpointSelection"] =
         _endpointSelection == EndpointSelectionType::Random ? "Random" : "Ordered";
+    // An invocation timeout of zero or any negative timeout means infinite; a negative locator cache timeout also
+    // means infinite. We emit these as -1, the documented value for infinite. A positive timeout that is not a whole
+    // number of the property's unit is rounded up, to the next whole number.
+    // TODO: remove this normalization in 3.9, once the timeouts are always normalized: in 3.8, code compiled
+    // against older headers can still set non-normalized values.
     properties[prefix + ".LocatorCacheTimeout"] =
-        to_string(chrono::duration_cast<chrono::seconds>(_locatorCacheTimeout).count());
-    properties[prefix + ".InvocationTimeout"] = to_string(getInvocationTimeout().count());
+        _locatorCacheTimeout < 0ms ? "-1" : to_string(chrono::ceil<chrono::seconds>(_locatorCacheTimeout).count());
+    chrono::milliseconds invocationTimeout = getInvocationTimeout();
+    properties[prefix + ".InvocationTimeout"] = invocationTimeout <= 0ms ? "-1" : to_string(invocationTimeout.count());
 
     if (_routerInfo)
     {
@@ -1200,7 +1206,12 @@ IceInternal::RoutableReference::operator<(const Reference& r) const noexcept
     {
         return true;
     }
-    else if (rhs->_endpoints < _endpoints)
+    else if (lexicographical_compare(
+                 rhs->_endpoints.begin(),
+                 rhs->_endpoints.end(),
+                 _endpoints.begin(),
+                 _endpoints.end(),
+                 Ice::TargetCompare<shared_ptr<EndpointI>, std::less>()))
     {
         return false;
     }
@@ -1398,7 +1409,7 @@ IceInternal::RoutableReference::createConnectionAsync(
     OutgoingConnectionFactoryPtr factory = getInstance()->outgoingConnectionFactory();
     auto self = static_pointer_cast<RoutableReference>(const_cast<RoutableReference*>(this)->shared_from_this());
 
-    auto createConnectionSucceded =
+    auto createConnectionSucceeded =
         [routerInfo = _routerInfo, response = std::move(response)](Ice::ConnectionIPtr connection, bool compress)
     {
         // If we have a router, set the object adapter for this router (if any) to the new connection, so that
@@ -1413,7 +1424,7 @@ IceInternal::RoutableReference::createConnectionAsync(
     if (getCacheConnection() || endpoints.size() == 1)
     {
         // Get an existing connection or create one if there's no existing connection to one of the given endpoints.
-        factory->createAsync(std::move(endpoints), false, std::move(createConnectionSucceded), std::move(exception));
+        factory->createAsync(std::move(endpoints), false, std::move(createConnectionSucceeded), std::move(exception));
     }
     else
     {
@@ -1427,11 +1438,11 @@ IceInternal::RoutableReference::createConnectionAsync(
             CreateConnectionState(
                 vector<EndpointIPtr> endpoints,
                 OutgoingConnectionFactoryPtr factory,
-                function<void(Ice::ConnectionIPtr, bool)> createConnectionSucceded,
+                function<void(Ice::ConnectionIPtr, bool)> createConnectionSucceeded,
                 function<void(exception_ptr)> exception)
                 : _endpoints(std::move(endpoints)),
                   _factory(std::move(factory)),
-                  _createConnectionSucceded(std::move(createConnectionSucceded)),
+                  _createConnectionSucceeded(std::move(createConnectionSucceeded)),
                   _createConnectionFailed(std::move(exception))
             {
             }
@@ -1441,7 +1452,7 @@ IceInternal::RoutableReference::createConnectionAsync(
                 _factory->createAsync(
                     {_endpoints[_endpointIndex]},
                     true,
-                    _createConnectionSucceded,
+                    _createConnectionSucceeded,
                     [self = shared_from_this()](exception_ptr e) { self->handleException(e); });
             }
 
@@ -1462,7 +1473,7 @@ IceInternal::RoutableReference::createConnectionAsync(
                 _factory->createAsync(
                     {_endpoints[_endpointIndex]},
                     more,
-                    _createConnectionSucceded,
+                    _createConnectionSucceeded,
                     [self = shared_from_this()](exception_ptr e) { self->handleException(e); });
             }
 
@@ -1471,14 +1482,14 @@ IceInternal::RoutableReference::createConnectionAsync(
             size_t _endpointIndex = 0;
             vector<EndpointIPtr> _endpoints;
             OutgoingConnectionFactoryPtr _factory;
-            std::function<void(Ice::ConnectionIPtr, bool)> _createConnectionSucceded;
+            std::function<void(Ice::ConnectionIPtr, bool)> _createConnectionSucceeded;
             std::function<void(exception_ptr)> _createConnectionFailed;
         };
 
         auto state = make_shared<CreateConnectionState>(
             std::move(endpoints),
             std::move(factory),
-            std::move(createConnectionSucceded),
+            std::move(createConnectionSucceeded),
             std::move(exception));
         state->createAsync();
     }

data/dist/ice/cpp/src/Ice/Reference.h

@@ -209,6 +209,9 @@ namespace IceInternal
         [[nodiscard]] RequestHandlerPtr getRequestHandler() const final;
         [[nodiscard]] const BatchRequestQueuePtr& getBatchRequestQueue() const noexcept final;
 
+        // The connection this fixed reference is bound to, whatever its state.
+        [[nodiscard]] const Ice::ConnectionIPtr& fixedConnection() const noexcept { return _fixedConnection; }
+
         bool operator==(const Reference&) const noexcept final;
         bool operator<(const Reference&) const noexcept final;
 

data/dist/ice/cpp/src/Ice/ReferenceFactory.cpp

@@ -795,10 +795,20 @@ IceInternal::ReferenceFactory::create(
         property = propertyPrefix + ".LocatorCacheTimeout";
         locatorCacheTimeout = chrono::seconds(
             properties->getPropertyAsIntWithDefault(property, static_cast<int32_t>(locatorCacheTimeout.count())));
+        if (locatorCacheTimeout < chrono::seconds::zero())
+        {
+            // Any negative timeout means infinite and is normalized to -1; 0 means no caching.
+            locatorCacheTimeout = chrono::seconds(-1);
+        }
 
         property = propertyPrefix + ".InvocationTimeout";
         invocationTimeout = chrono::milliseconds(
             properties->getPropertyAsIntWithDefault(property, static_cast<int32_t>(invocationTimeout.count())));
+        if (invocationTimeout <= chrono::milliseconds::zero())
+        {
+            // Zero or any negative timeout means infinite and is normalized to -1.
+            invocationTimeout = chrono::milliseconds(-1);
+        }
 
         property = propertyPrefix + ".Context.";
         PropertyDict contexts = properties->getPropertiesForPrefix(property);

data/dist/ice/cpp/src/Ice/RequestHandler.h

@@ -42,7 +42,9 @@ namespace IceInternal
 
         virtual AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&) = 0;
 
-        virtual Ice::ConnectionIPtr getConnection() = 0;
+        // Returns this request handler's connection, or null if no connection is available. This function never
+        // throws.
+        virtual Ice::ConnectionIPtr getConnection() noexcept = 0;
 
     protected:
         const ReferencePtr _reference;

data/dist/ice/cpp/src/Ice/RequestHandlerCache.cpp

@@ -45,7 +45,7 @@ RequestHandlerCache::getRequestHandler()
 }
 
 ConnectionPtr
-RequestHandlerCache::getCachedConnection()
+RequestHandlerCache::getCachedConnection() noexcept
 {
     if (_cacheConnection)
     {

data/dist/ice/cpp/src/Ice/RequestHandlerCache.h

@@ -18,7 +18,7 @@ namespace IceInternal
 
         RequestHandlerPtr getRequestHandler();
 
-        Ice::ConnectionPtr getCachedConnection();
+        Ice::ConnectionPtr getCachedConnection() noexcept;
 
         void clearCachedRequestHandler(const RequestHandlerPtr& handler);
 

data/dist/ice/cpp/src/Ice/ResourceConfig.h

@@ -5,8 +5,8 @@
 
 #include "winver.h"
 
-#define ICE_VERSION 3, 8, 2, 0
-#define ICE_STRING_VERSION "3.8.2\0"
+#define ICE_VERSION 3, 8, 3, 0
+#define ICE_STRING_VERSION "3.8.3\0"
 #define ICE_SO_VERSION "38\0"
 #define ICE_COMPANY_NAME "ZeroC, Inc.\0"
 #define ICE_COPYRIGHT "\251 ZeroC, Inc.\0"
@@ -18,7 +18,7 @@
 #    define ICE_LIBNAME(NAME) NAME ICE_SO_VERSION ""
 #endif
 
-#ifndef DEBUG
+#ifndef _DEBUG
 #    define VER_DEBUG 0
 #else
 #    define VER_DEBUG VS_FF_DEBUG

data/dist/ice/cpp/src/Ice/RetryQueue.cpp

@@ -26,8 +26,8 @@ IceInternal::RetryTask::runTimerTask()
     _outAsync->retry(); // Retry again the invocation.
 
     //
-    // NOTE: this must be called last, destroy() blocks until all task
-    // are removed to prevent the client thread pool to be destroyed
+    // NOTE: this must be called last, destroy() blocks until all tasks
+    // are removed to prevent the client thread pool from being destroyed
     // (we still need the client thread pool at this point to call
     // exception callbacks with CommunicatorDestroyedException).
     //
@@ -135,17 +135,13 @@ bool
 IceInternal::RetryQueue::cancel(const RetryTaskPtr& task)
 {
     lock_guard<mutex> lock(_mutex);
-    if (_requests.erase(task) > 0)
+    // Only remove the task if we cancel it in the timer before it runs. If timer()->cancel returns false, the
+    // task is already executing and runTimerTask will call remove() to erase it from _requests; erasing it
+    // here would make that remove() fail its assertion. When the queue is being destroyed (_instance is null)
+    // the timer is gone and every remaining task is running, so it is likewise removed by remove().
+    if (_instance && _instance->timer()->cancel(task))
     {
-        if (_instance)
-        {
-            return _instance->timer()->cancel(task);
-        }
-        else if (_requests.empty())
-        {
-            // If we are destroying the queue, destroy is probably waiting on the queue to be empty.
-            _conditionVariable.notify_one();
-        }
+        return _requests.erase(task) != 0;
     }
     return false;
 }

data/dist/ice/cpp/src/Ice/SHA1.cpp

@@ -105,16 +105,16 @@ IceInternal::SHA1::Hasher::finalize(vector<unsigned char>& md)
 #if defined(_WIN32)
     md.resize(SHA_DIGEST_LENGTH);
     DWORD length = SHA_DIGEST_LENGTH;
-    if (!CryptGetHashParam(_hash, HP_HASHVAL, &md[0], &length, 0))
+    if (!CryptGetHashParam(_hash, HP_HASHVAL, md.data(), &length, 0))
     {
         throw Ice::SyscallException{__FILE__, __LINE__, "CryptGetHashParam failed", GetLastError()};
     }
 #elif defined(__APPLE__)
     md.resize(CC_SHA1_DIGEST_LENGTH);
-    CC_SHA1_Final(&md[0], &_ctx);
+    CC_SHA1_Final(md.data(), &_ctx);
 #else
     md.resize(SHA_DIGEST_LENGTH);
-    SHA1_Final(&md[0], &_ctx);
+    SHA1_Final(md.data(), &_ctx);
 #endif
 }
 
@@ -124,16 +124,16 @@ IceInternal::SHA1::Hasher::finalize(vector<byte>& md)
 #if defined(_WIN32)
     md.resize(SHA_DIGEST_LENGTH);
     DWORD length = SHA_DIGEST_LENGTH;
-    if (!CryptGetHashParam(_hash, HP_HASHVAL, reinterpret_cast<unsigned char*>(&md[0]), &length, 0))
+    if (!CryptGetHashParam(_hash, HP_HASHVAL, reinterpret_cast<unsigned char*>(md.data()), &length, 0))
     {
         throw Ice::SyscallException{__FILE__, __LINE__, "CryptGetHashParam failed", GetLastError()};
     }
 #elif defined(__APPLE__)
     md.resize(CC_SHA1_DIGEST_LENGTH);
-    CC_SHA1_Final(reinterpret_cast<unsigned char*>(&md[0]), &_ctx);
+    CC_SHA1_Final(reinterpret_cast<unsigned char*>(md.data()), &_ctx);
 #else
     md.resize(SHA_DIGEST_LENGTH);
-    SHA1_Final(reinterpret_cast<unsigned char*>(&md[0]), &_ctx);
+    SHA1_Final(reinterpret_cast<unsigned char*>(md.data()), &_ctx);
 #endif
 }
 
@@ -168,10 +168,10 @@ IceInternal::sha1(const unsigned char* data, size_t length, vector<unsigned char
     hasher.finalize(md);
 #elif defined(__APPLE__)
     md.resize(CC_SHA1_DIGEST_LENGTH);
-    CC_SHA1(&data[0], static_cast<CC_LONG>(length), &md[0]);
+    CC_SHA1(data, static_cast<CC_LONG>(length), md.data());
 #else
     md.resize(SHA_DIGEST_LENGTH);
-    ::SHA1(&data[0], length, &md[0]);
+    ::SHA1(data, length, md.data());
 #endif
 }
 
@@ -185,11 +185,11 @@ IceInternal::sha1(const byte* data, size_t length, vector<byte>& md)
 #elif defined(__APPLE__)
     md.resize(CC_SHA1_DIGEST_LENGTH);
     CC_SHA1(
-        reinterpret_cast<const unsigned char*>(&data[0]),
+        reinterpret_cast<const unsigned char*>(data),
         static_cast<CC_LONG>(length),
-        reinterpret_cast<unsigned char*>(&md[0]));
+        reinterpret_cast<unsigned char*>(md.data()));
 #else
     md.resize(SHA_DIGEST_LENGTH);
-    ::SHA1(reinterpret_cast<const unsigned char*>(&data[0]), length, reinterpret_cast<unsigned char*>(&md[0]));
+    ::SHA1(reinterpret_cast<const unsigned char*>(data), length, reinterpret_cast<unsigned char*>(md.data()));
 #endif
 }

data/dist/ice/cpp/src/Ice/SSL/DistinguishedName.cpp

@@ -51,12 +51,6 @@ DistinguishedName::match(const DistinguishedName& other) const
     return true;
 }
 
-bool
-DistinguishedName::match(const string& other) const
-{
-    return match(DistinguishedName(other));
-}
-
 //
 // This always produces the same output as the input DN -- the type of
 // escaping is not changed.

data/dist/ice/cpp/src/Ice/SSL/DistinguishedName.h

@@ -47,12 +47,6 @@ namespace Ice::SSL
         /// DistinguishedName and they have the same values.
         [[nodiscard]] bool match(const DistinguishedName& dn) const;
 
-        /// Performs a partial match with another DistinguishedName.
-        /// @param dn The name to be matched.
-        /// @return `true` if all of the RDNs in the argument are present in this
-        /// DistinguishedName and they have the same values.
-        [[nodiscard]] bool match(const std::string& dn) const;
-
         /// Encodes the DN in RFC2253 format.
         /// @return An encoded string.
         [[nodiscard]] std::string toString() const;

data/dist/ice/cpp/src/Ice/SSL/OpenSSLEngine.cpp

@@ -107,6 +107,11 @@ OpenSSL::SSLEngine::initialize()
 
         _password = properties->getIceProperty("IceSSL.Password");
 
+        // Register the password callback so IceSSL.Password is used when loading an encrypted PEM private key.
+        // Without it, OpenSSL falls back to its default tty prompt.
+        SSL_CTX_set_default_passwd_cb(_ctx, Ice_SSL_opensslPasswordCallback);
+        SSL_CTX_set_default_passwd_cb_userdata(_ctx, this);
+
         // Establish the location of CA certificates.
         {
             string path = properties->getIceProperty("IceSSL.CAs");
@@ -188,9 +193,15 @@ OpenSSL::SSLEngine::initialize()
             // First we try to load the certificate using PKCS12 format if that fails we fallback to PEM format.
             vector<char> buffer;
             readFile(*resolved, buffer);
+            if (buffer.empty())
+            {
+                ostringstream os;
+                os << "IceSSL: certificate file is empty '" << *resolved << "'";
+                throw InitializationException(__FILE__, __LINE__, os.str());
+            }
             int success = 0;
 
-            const unsigned char* b = reinterpret_cast<unsigned char*>(&buffer[0]);
+            const unsigned char* b = reinterpret_cast<unsigned char*>(buffer.data());
             PKCS12* p12 = d2i_PKCS12(nullptr, &b, static_cast<long>(buffer.size()));
             if (p12)
             {
@@ -252,6 +263,9 @@ OpenSSL::SSLEngine::initialize()
                         {
                             if (!SSL_CTX_add_extra_chain_cert(_ctx, c))
                             {
+                                // On failure ownership of c is not transferred to _ctx, so free it here;
+                                // the catch below only frees the certs still on the stack.
+                                X509_free(c);
                                 ostringstream os;
                                 os << "IceSSL: unable to add extra SSL certificate:\n" << sslErrors();
                                 throw InitializationException(__FILE__, __LINE__, os.str());