Method ServerHandleAuth

src/openrct2/network/NetworkBase.cpp:2673–2801

    }

    void NetworkBase::ServerHandleAuth(Connection& connection, Packet& packet)
    {
        if (connection.authStatus != Auth::ok)
        {
            auto* hostName = connection.socket->GetHostName();
            auto gameversion = packet.readString();
            auto name = packet.readString();
            auto password = packet.readString();
            auto pubkey = packet.readString();
            uint32_t sigsize;
            packet >> sigsize;
            if (pubkey.empty())
            {
                connection.authStatus = Auth::verificationFailure;
            }
            else
            {
                try
                {
                    // RSA technically supports keys up to 65536 bits, so this is the
                    // maximum signature size for now.
                    constexpr auto MaxRSASignatureSizeInBytes = 8192;

                    if (sigsize == 0 || sigsize > MaxRSASignatureSizeInBytes)
                    {
                        throw std::runtime_error("Invalid signature size");
                    }

                    std::vector<uint8_t> signature;
                    signature.resize(sigsize);

                    const uint8_t* signatureData = packet.read(sigsize);
                    if (signatureData == nullptr)
                    {
                        throw std::runtime_error("Failed to read packet.");
                    }

                    std::memcpy(signature.data(), signatureData, sigsize);

                    auto ms = MemoryStream(pubkey.data(), pubkey.size());
                    if (!connection.key.LoadPublic(&ms))
                    {
                        throw std::runtime_error("Failed to load public key.");
                    }

                    bool verified = connection.key.Verify(connection.challenge.data(), connection.challenge.size(), signature);
                    const std::string hash = connection.key.PublicKeyHash();
                    if (verified)
                    {
                        LOG_VERBOSE("Connection %s: Signature verification ok. Hash %s", hostName, hash.c_str());
                        if (Config::Get().network.knownKeysOnly && _userManager.getUserByHash(hash) == nullptr)
                        {
                            LOG_VERBOSE("Connection %s: Hash %s, not known", hostName, hash.c_str());
                            connection.authStatus = Auth::unknownKeyDisallowed;
                        }
                        else
                        {
                            connection.authStatus = Auth::verified;