zeroc-ice 3.7.11 → 3.8.1

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

@@ -0,0 +1,80 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICESSL_OPENSSL_TRANSCEIVER_I_H
+#define ICESSL_OPENSSL_TRANSCEIVER_I_H
+
+#include "../Network.h"
+#include "../StreamSocket.h"
+#include "../Transceiver.h"
+#include "Ice/Config.h"
+#include "Ice/SSL/ClientAuthenticationOptions.h"
+#include "Ice/SSL/ServerAuthenticationOptions.h"
+#include "OpenSSLEngineF.h"
+#include "SSLInstanceF.h"
+#include "SSLUtil.h"
+
+#include <openssl/ssl.h>
+
+using SSL = struct ssl_st;
+using BIO = struct bio_st;
+
+namespace Ice::SSL::OpenSSL
+{
+    class TransceiverI final : public IceInternal::Transceiver
+    {
+    public:
+        TransceiverI(
+            InstancePtr,
+            IceInternal::TransceiverPtr,
+            std::string,
+            const Ice::SSL::ServerAuthenticationOptions&);
+        TransceiverI(
+            InstancePtr,
+            IceInternal::TransceiverPtr,
+            std::string,
+            const Ice::SSL::ClientAuthenticationOptions&);
+
+        ~TransceiverI();
+        [[nodiscard]] IceInternal::NativeInfoPtr getNativeInfo() final;
+
+        [[nodiscard]] IceInternal::SocketOperation initialize(IceInternal::Buffer&, IceInternal::Buffer&) final;
+        [[nodiscard]] IceInternal::SocketOperation closing(bool, std::exception_ptr) final;
+        void close() final;
+        [[nodiscard]] IceInternal::SocketOperation write(IceInternal::Buffer&) final;
+        [[nodiscard]] IceInternal::SocketOperation read(IceInternal::Buffer&) final;
+        [[nodiscard]] std::string protocol() const final;
+        [[nodiscard]] std::string toString() const final;
+        [[nodiscard]] std::string toDetailedString() const final;
+        [[nodiscard]] Ice::ConnectionInfoPtr
+        getInfo(bool incoming, std::string adapterName, std::string connectionId) const final;
+        void checkSendSize(const IceInternal::Buffer&) final;
+        void setBufferSize(int rcvSize, int sndSize) final;
+
+        int verifyCallback(int, X509_STORE_CTX*);
+
+    private:
+        friend class Ice::SSL::OpenSSL::SSLEngine;
+
+        const InstancePtr _instance;
+        const Ice::SSL::OpenSSL::SSLEnginePtr _engine;
+        const std::string _host;
+        const std::string _adapterName;
+        const bool _incoming;
+        const IceInternal::TransceiverPtr _delegate;
+        bool _connected;
+        std::string _cipher;
+        X509* _peerCertificate;
+        ::SSL* _ssl;
+        SSL_CTX* _sslCtx;
+        IceInternal::Buffer _writeBuffer;
+        IceInternal::Buffer _readBuffer;
+        std::function<SSL_CTX*(const std::string&)> _localSSLContextSelectionCallback;
+        std::function<bool(bool, X509_STORE_CTX*, const Ice::SSL::ConnectionInfoPtr&)>
+            _remoteCertificateVerificationCallback;
+        std::function<void(::SSL*, const std::string&)> _sslNewSessionCallback;
+        std::exception_ptr _verificationException;
+    };
+    using TransceiverIPtr = std::shared_ptr<TransceiverI>;
+
+}
+#endif

data/dist/ice/cpp/src/{IceSSL → Ice/SSL}/RFC2253.cpp

@@ -1,31 +1,28 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <IceUtil/StringUtil.h>
+#include "RFC2253.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/StringUtil.h"
 
-#include <IceSSL/Plugin.h>
-#include <IceSSL/RFC2253.h>
-#include <Ice/Object.h>
+#include <cassert>
+#include <string>
 
 using namespace std;
-using namespace IceSSL;
+using namespace Ice::SSL;
 
 namespace
 {
+    //
+    // See RFC 2253 and RFC 1779.
+    //
 
-//
-// See RFC 2253 and RFC 1779.
-//
-
-string special = ",=+<>#;";
-string hexvalid = "0123456789abcdefABCDEF";
-
+    const string special = ",=+<>#;";                 // NOLINT(cert-err58-cpp)
+    const string hexvalid = "0123456789abcdefABCDEF"; // NOLINT(cert-err58-cpp)
 }
 
 static char unescapeHex(const string&, size_t);
-static pair<string,string> parseNameComponent(const string&, size_t&);
-static pair<string,string> parseAttributeTypeAndValue(const string&, size_t&);
+static pair<string, string> parseNameComponent(const string&, size_t&);
+static pair<string, string> parseAttributeTypeAndValue(const string&, size_t&);
 static string parseAttributeType(const string&, size_t&);
 static string parseAttributeValue(const string&, size_t&);
 static string parsePair(const string&, size_t&);
@@ -39,12 +36,12 @@ RFC2253::parse(const string& data)
     RDNEntry current;
     current.negate = false;
     size_t pos = 0;
-    while(pos < data.size())
+    while (pos < data.size())
     {
         eatWhite(data, pos);
-        if(pos < data.size() && data[pos] == '!')
+        if (pos < data.size() && data[pos] == '!')
         {
-            if(!current.rdn.empty())
+            if (!current.rdn.empty())
             {
                 throw ParseException(__FILE__, __LINE__, "negation symbol '!' must appear at start of list");
             }
@@ -53,23 +50,23 @@ RFC2253::parse(const string& data)
         }
         current.rdn.push_back(parseNameComponent(data, pos));
         eatWhite(data, pos);
-        if(pos < data.size() && data[pos] == ',')
+        if (pos < data.size() && data[pos] == ',')
         {
             ++pos;
         }
-        else if(pos < data.size() && data[pos] == ';')
+        else if (pos < data.size() && data[pos] == ';')
         {
             ++pos;
             results.push_back(current);
             current.rdn.clear();
             current.negate = false;
         }
-        else if(pos < data.size())
+        else if (pos < data.size())
         {
-            throw ParseException(__FILE__, __LINE__, "expected ',' or ';' at `" + data.substr(pos) + "'");
+            throw ParseException(__FILE__, __LINE__, "expected ',' or ';' at '" + data.substr(pos) + "'");
         }
     }
-    if(!current.rdn.empty())
+    if (!current.rdn.empty())
     {
         results.push_back(current);
     }
@@ -82,17 +79,17 @@ RFC2253::parseStrict(const string& data)
 {
     RDNSeq results;
     size_t pos = 0;
-    while(pos < data.size())
+    while (pos < data.size())
     {
         results.push_back(parseNameComponent(data, pos));
         eatWhite(data, pos);
-        if(pos < data.size() && (data[pos] == ',' || data[pos] == ';'))
+        if (pos < data.size() && (data[pos] == ',' || data[pos] == ';'))
         {
             ++pos;
         }
-        else if(pos < data.size())
+        else if (pos < data.size())
         {
-            throw ParseException(__FILE__, __LINE__, "expected ',' or ';' at `" + data.substr(pos) + "'");
+            throw ParseException(__FILE__, __LINE__, "expected ',' or ';' at '" + data.substr(pos) + "'");
         }
     }
     return results;
@@ -101,14 +98,14 @@ RFC2253::parseStrict(const string& data)
 string
 RFC2253::unescape(const string& data)
 {
-    if(data.size() == 0)
+    if (data.size() == 0)
     {
         return data;
     }
 
-    if(data[0] == '"')
+    if (data[0] == '"')
     {
-        if(data[data.size() - 1] != '"')
+        if (data[data.size() - 1] != '"')
         {
             throw ParseException(__FILE__, __LINE__, "unescape: missing \"");
         }
@@ -123,10 +120,10 @@ RFC2253::unescape(const string& data)
     // Unescape the entire string.
     //
     string result;
-    if(data[0] == '#')
+    if (data[0] == '#')
     {
         size_t pos = 1;
-        while(pos < data.size())
+        while (pos < data.size())
         {
             result += unescapeHex(data, pos);
             pos += 2;
@@ -135,9 +132,9 @@ RFC2253::unescape(const string& data)
     else
     {
         size_t pos = 0;
-        while(pos < data.size())
+        while (pos < data.size())
         {
-            if(data[pos] != '\\')
+            if (data[pos] != '\\')
             {
                 result += data[pos];
                 ++pos;
@@ -145,11 +142,11 @@ RFC2253::unescape(const string& data)
             else
             {
                 ++pos;
-                if(pos >= data.size())
+                if (pos >= data.size())
                 {
                     throw ParseException(__FILE__, __LINE__, "unescape: invalid escape sequence");
                 }
-                if(special.find(data[pos]) != string::npos || data[pos] != '\\' || data[pos] != '"')
+                if (special.find(data[pos]) != string::npos || data[pos] == '\\' || data[pos] == '"')
                 {
                     result += data[pos];
                     ++pos;
@@ -169,40 +166,40 @@ RFC2253::unescape(const string& data)
 static int
 hexToInt(char v)
 {
-    if(v >= '0' && v <= '9')
+    if (v >= '0' && v <= '9')
     {
         return v - '0';
     }
-    if(v >= 'a' && v <= 'f')
+    if (v >= 'a' && v <= 'f')
     {
         return 10 + (v - 'a');
     }
-    if(v >= 'A' && v <= 'F')
+    if (v >= 'A' && v <= 'F')
     {
         return 10 + (v - 'A');
     }
-    throw ParseException(__FILE__, __LINE__, "unescape: invalid hex pair");
+    throw Ice::ParseException(__FILE__, __LINE__, "unescape: invalid hex pair");
 }
 
 static char
 unescapeHex(const string& data, size_t pos)
 {
     assert(pos < data.size());
-    if(pos + 2 >= data.size())
+    if (pos + 2 > data.size())
     {
-        throw ParseException(__FILE__, __LINE__, "unescape: invalid hex pair");
+        throw Ice::ParseException(__FILE__, __LINE__, "unescape: invalid hex pair");
     }
     return static_cast<char>(hexToInt(data[pos]) * 16 + hexToInt(data[pos + 1]));
 }
 
-static pair<string,string>
+static pair<string, string>
 parseNameComponent(const string& data, size_t& pos)
 {
     pair<string, string> final = parseAttributeTypeAndValue(data, pos);
-    while(pos < data.size())
+    while (pos < data.size())
     {
         eatWhite(data, pos);
-        if(pos < data.size() && data[pos] == '+')
+        if (pos < data.size() && data[pos] == '+')
         {
             ++pos;
         }
@@ -219,20 +216,20 @@ parseNameComponent(const string& data, size_t& pos)
     return final;
 }
 
-static pair<string,string>
+static pair<string, string>
 parseAttributeTypeAndValue(const string& data, size_t& pos)
 {
     pair<string, string> p;
     p.first = parseAttributeType(data, pos);
     eatWhite(data, pos);
 
-    if(pos >= data.size())
+    if (pos >= data.size())
     {
-        throw ParseException(__FILE__, __LINE__, "invalid attribute type/value pair (unexpected end of data)");
+        throw Ice::ParseException(__FILE__, __LINE__, "invalid attribute type/value pair (unexpected end of data)");
     }
-    if(data[pos] != '=')
+    if (data[pos] != '=')
     {
-        throw ParseException(__FILE__, __LINE__, "invalid attribute type/value pair (missing =)");
+        throw Ice::ParseException(__FILE__, __LINE__, "invalid attribute type/value pair (missing =)");
     }
     ++pos;
     p.second = parseAttributeValue(data, pos);
@@ -243,9 +240,9 @@ static string
 parseAttributeType(const string& data, size_t& pos)
 {
     eatWhite(data, pos);
-    if(pos >= data.size())
+    if (pos >= data.size())
     {
-        throw ParseException(__FILE__, __LINE__, "invalid attribute type (expected end of data)");
+        throw Ice::ParseException(__FILE__, __LINE__, "invalid attribute type (expected end of data)");
     }
 
     string result;
@@ -268,32 +265,32 @@ parseAttributeType(const string& data, size_t& pos)
     //
     // First the OID case.
     //
-    if(IceUtilInternal::isDigit(data[pos]) ||
-       (data.size() - pos >= 4 && (data.substr(pos, 4) == "oid." || data.substr(pos, 4) == "OID.")))
+    if (IceInternal::isDigit(data[pos]) ||
+        (data.size() - pos >= 4 && (data.substr(pos, 4) == "oid." || data.substr(pos, 4) == "OID.")))
     {
-        if(!IceUtilInternal::isDigit(data[pos]))
+        if (!IceInternal::isDigit(data[pos]))
         {
             result += data.substr(pos, 4);
             pos += 4;
         }
 
-        while(true)
+        while (true)
         {
             // 1*DIGIT
-            while(pos < data.size() && IceUtilInternal::isDigit(data[pos]))
+            while (pos < data.size() && IceInternal::isDigit(data[pos]))
             {
                 result += data[pos];
                 ++pos;
             }
             // "." 1*DIGIT
-            if(pos < data.size() && data[pos] == '.')
+            if (pos < data.size() && data[pos] == '.')
             {
                 result += data[pos];
                 ++pos;
                 // 1*DIGIT must follow "."
-                if(pos < data.size() && !IceUtilInternal::isDigit(data[pos]))
+                if (pos < data.size() && !IceInternal::isDigit(data[pos]))
                 {
-                    throw ParseException(__FILE__, __LINE__, "invalid attribute type (expected end of data)");
+                    throw Ice::ParseException(__FILE__, __LINE__, "invalid attribute type (expected end of data)");
                 }
             }
             else
@@ -302,7 +299,7 @@ parseAttributeType(const string& data, size_t& pos)
             }
         }
     }
-    else if(IceUtilInternal::isAlpha(data[pos]))
+    else if (IceInternal::isAlpha(data[pos]))
     {
         //
         // The grammar is wrong in this case. It should be ALPHA
@@ -312,8 +309,8 @@ parseAttributeType(const string& data, size_t& pos)
         result += data[pos];
         ++pos;
         // 1* KEYCHAR
-        while(pos < data.size() &&
-              (IceUtilInternal::isAlpha(data[pos]) || IceUtilInternal::isDigit(data[pos]) || data[pos] == '-'))
+        while (pos < data.size() &&
+               (IceInternal::isAlpha(data[pos]) || IceInternal::isDigit(data[pos]) || data[pos] == '-'))
         {
             result += data[pos];
             ++pos;
@@ -321,7 +318,7 @@ parseAttributeType(const string& data, size_t& pos)
     }
     else
     {
-        throw ParseException(__FILE__, __LINE__, "invalid attribute type");
+        throw Ice::ParseException(__FILE__, __LINE__, "invalid attribute type");
     }
     return result;
 }
@@ -331,7 +328,7 @@ parseAttributeValue(const string& data, size_t& pos)
 {
     eatWhite(data, pos);
     string result;
-    if(pos >= data.size())
+    if (pos >= data.size())
     {
         return result;
     }
@@ -340,14 +337,14 @@ parseAttributeValue(const string& data, size_t& pos)
     // RFC 2253
     // # hexstring
     //
-    if(data[pos] == '#')
+    if (data[pos] == '#')
     {
         result += data[pos];
         ++pos;
-        while(true)
+        while (true)
         {
             string h = parseHexPair(data, pos, true);
-            if(h.size() == 0)
+            if (h.size() == 0)
             {
                 break;
             }
@@ -359,25 +356,25 @@ parseAttributeValue(const string& data, size_t& pos)
     // QUOTATION *( quotechar | pair ) QUOTATION ; only from v2
     // quotechar     = <any character except "\" or QUOTATION >
     //
-    else if(data[pos] == '"')
+    else if (data[pos] == '"')
     {
         result += data[pos];
         ++pos;
-        while(true)
+        while (true)
         {
-            if(pos >= data.size())
+            if (pos >= data.size())
             {
-                throw ParseException(__FILE__, __LINE__, "invalid attribute value (unexpected end of data)");
+                throw Ice::ParseException(__FILE__, __LINE__, "invalid attribute value (unexpected end of data)");
             }
             // final terminating "
-            if(data[pos] == '"')
+            if (data[pos] == '"')
             {
                 result += data[pos];
                 ++pos;
                 break;
             }
             // any character except '\'
-            else if(data[pos] != '\\')
+            else if (data[pos] != '\\')
             {
                 result += data[pos];
                 ++pos;
@@ -396,13 +393,13 @@ parseAttributeValue(const string& data, size_t& pos)
     //
     else
     {
-        while(pos < data.size())
+        while (pos < data.size())
         {
-            if(data[pos] == '\\')
+            if (data[pos] == '\\')
             {
                 result += parsePair(data, pos);
             }
-            else if(special.find(data[pos]) == string::npos && data[pos] != '"')
+            else if (special.find(data[pos]) == string::npos && data[pos] != '"')
             {
                 result += data[pos];
                 ++pos;
@@ -429,12 +426,12 @@ parsePair(const string& data, size_t& pos)
     result += data[pos];
     ++pos;
 
-    if(pos >= data.size())
+    if (pos >= data.size())
     {
-        throw ParseException(__FILE__, __LINE__, "invalid escape format (unexpected end of data)");
+        throw Ice::ParseException(__FILE__, __LINE__, "invalid escape format (unexpected end of data)");
     }
 
-    if(special.find(data[pos]) != string::npos || data[pos] != '\\' || data[pos] != '"')
+    if (special.find(data[pos]) != string::npos || data[pos] == '\\' || data[pos] == '"')
     {
         result += data[pos];
         ++pos;
@@ -451,23 +448,23 @@ static string
 parseHexPair(const string& data, size_t& pos, bool allowEmpty)
 {
     string result;
-    if(pos < data.size() && hexvalid.find(data[pos]) != string::npos)
+    if (pos < data.size() && hexvalid.find(data[pos]) != string::npos)
     {
         result += data[pos];
         ++pos;
     }
-    if(pos < data.size() && hexvalid.find(data[pos]) != string::npos)
+    if (pos < data.size() && hexvalid.find(data[pos]) != string::npos)
     {
         result += data[pos];
         ++pos;
     }
-    if(result.size() != 2)
+    if (result.size() != 2)
     {
-        if(allowEmpty && result.size() == 0)
+        if (allowEmpty && result.size() == 0)
         {
             return result;
         }
-        throw ParseException(__FILE__, __LINE__, "invalid hex format");
+        throw Ice::ParseException(__FILE__, __LINE__, "invalid hex format");
     }
     return result;
 }
@@ -483,7 +480,7 @@ parseHexPair(const string& data, size_t& pos, bool allowEmpty)
 static void
 eatWhite(const string& data, size_t& pos)
 {
-    while(pos < data.size() && data[pos] == ' ')
+    while (pos < data.size() && data[pos] == ' ')
     {
         ++pos;
     }

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

@@ -0,0 +1,58 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_SSL_RFC_2253_H
+#define ICE_SSL_RFC_2253_H
+
+#include "Ice/Config.h"
+
+#include <list>
+#include <string>
+
+//
+// The methods in the Ice::SSL::RFC2253 namespace implement a parser
+// for relative distinguished name (RDN) pairs using the parsing
+// rules outlined in sections 3 and 4 of RFC 2253.
+//
+// Note that this parser does not unescape the elements of the RDNs.
+// For example, parsing the following RDN
+//
+// O=Sue\, Grabit and Runn
+//
+// results in the pair ("O","Sue\, Grabit and Runn") and not
+// ("O","Sue, Grabit and Runn").
+//
+namespace Ice::SSL::RFC2253
+{
+    using RDNSeq = std::list<std::pair<std::string, std::string>>;
+
+    struct RDNEntry
+    {
+        RDNSeq rdn;
+        bool negate;
+    };
+    using RDNEntrySeq = std::list<RDNEntry>;
+
+    //
+    // This function separates DNs with the ';' character. A list of RDN
+    // pairs may optionally be prefixed with '!' to indicate a negation.
+    // The function returns a list of RDNEntry structures. Any failure in
+    // parsing results in a ParseException being thrown.
+    //
+    RDNEntrySeq parse(const std::string&);
+
+    //
+    // RDNs are separated with ',' and ';'.
+    //
+    // This function returns a list of RDN pairs. Any failure in parsing
+    // results in a ParseException being thrown.
+    //
+    RDNSeq parseStrict(const std::string&);
+
+    //
+    // Unescape the string.
+    //
+    std::string unescape(const std::string&);
+
+}
+
+#endif