Add flexibility in login packets

* It's now possible to add custom data in the login packet
* Add utility funciton to generate RSA keys
* Make the protocol able to use RSA keys with 2048 bits or more

src/client/const.h

@@ -337,8 +337,6 @@ namespace Otc
         GameSpellList = 23,
         GameClientPing = 24,
         GameExtendedClientPing = 25,
-        GameUpdater = 26,
-        GameLoginLocale = 27,
         GameDoubleHealth = 28,
         GameDoubleSkills = 29,
         GameChangeMapAwareRange = 30,
@@ -349,7 +347,6 @@ namespace Otc
         GameLoginPending = 35,
         GameNewSpeedLaw = 36,
         GameForceFirstAutoWalkStep = 37,
-        GameLoginUUID = 38,
         // 51-100 reserved to be defined in lua
         LastGameFeature = 101
     };

src/client/game.cpp

@@ -473,7 +473,7 @@ void Game::processWalkCancel(Otc::Direction direction)
     m_localPlayer->cancelWalk(direction);
 }
 
-void Game::loginWorld(const std::string& account, const std::string& password, const std::string& worldName, const std::string& worldHost, int worldPort, const std::string& characterName, const std::string& locale)
+void Game::loginWorld(const std::string& account, const std::string& password, const std::string& worldName, const std::string& worldHost, int worldPort, const std::string& characterName)
 {
     if(m_protocolGame || isOnline())
         stdext::throw_exception("Unable to login into a world while already online or logging.");
@@ -488,7 +488,7 @@ void Game::loginWorld(const std::string& account, const std::string& password, c
     m_localPlayer->setName(characterName);
 
     m_protocolGame = ProtocolGamePtr(new ProtocolGame);
-    m_protocolGame->login(account, password, worldHost, (uint16)worldPort, characterName, locale);
+    m_protocolGame->login(account, password, worldHost, (uint16)worldPort, characterName);
     m_characterName = characterName;
     m_worldName = worldName;
 }

src/client/game.h

@@ -135,7 +135,7 @@ protected:
 
 public:
     // login related
-    void loginWorld(const std::string& account, const std::string& password, const std::string& worldName, const std::string& worldHost, int worldPort, const std::string& characterName, const std::string& locale);
+    void loginWorld(const std::string& account, const std::string& password, const std::string& worldName, const std::string& worldHost, int worldPort, const std::string& characterName);
     void cancelLogin();
     void forceLogout();
     void safeLogout();
@@ -270,9 +270,6 @@ public:
     void setCustomOs(int os) { m_clientCustomOs = os; }
     int getOs();
 
-    void setUpdaterSignature(const std::string& sig) { m_clientSignature = sig; }
-    std::string getUpdaterSignature() { return m_clientSignature; }
-
     bool canPerformGameAction();
     bool checkBotProtection();
 

src/client/luafunctions.cpp

@@ -238,8 +238,6 @@ void Client::registerLuaFunctions()
     g_lua.bindSingletonFunction("g_game", "setProtocolVersion", &Game::setProtocolVersion, &g_game);
     g_lua.bindSingletonFunction("g_game", "getClientVersion", &Game::getClientVersion, &g_game);
     g_lua.bindSingletonFunction("g_game", "setClientVersion", &Game::setClientVersion, &g_game);
-    g_lua.bindSingletonFunction("g_game", "setUpdaterSignature", &Game::setUpdaterSignature, &g_game);
-    g_lua.bindSingletonFunction("g_game", "getUpdaterSignature", &Game::getUpdaterSignature, &g_game);
     g_lua.bindSingletonFunction("g_game", "setCustomOs", &Game::setCustomOs, &g_game);
     g_lua.bindSingletonFunction("g_game", "getOs", &Game::getOs, &g_game);
     g_lua.bindSingletonFunction("g_game", "getCharacterName", &Game::getCharacterName, &g_game);

src/client/protocolgame.cpp

@@ -26,12 +26,11 @@
 #include "item.h"
 #include "localplayer.h"
 
-void ProtocolGame::login(const std::string& accountName, const std::string& accountPassword, const std::string& host, uint16 port, const std::string& characterName, const std::string& locale)
+void ProtocolGame::login(const std::string& accountName, const std::string& accountPassword, const std::string& host, uint16 port, const std::string& characterName)
 {
     m_accountName = accountName;
     m_accountPassword = accountPassword;
     m_characterName = characterName;
-    m_locale = locale;
 
     connect(host, port);
 }

src/client/protocolgame.h

@@ -31,7 +31,7 @@
 class ProtocolGame : public Protocol
 {
 public:
-    void login(const std::string& accountName, const std::string& accountPassword, const std::string& host, uint16 port, const std::string& characterName, const std::string& locale);
+    void login(const std::string& accountName, const std::string& accountPassword, const std::string& host, uint16 port, const std::string& characterName);
     void send(const OutputMessagePtr& outputMessage);
 
     void sendExtendedOpcode(uint8 opcode, const std::string& buffer);
@@ -235,7 +235,6 @@ private:
     std::string m_accountName;
     std::string m_accountPassword;
     std::string m_characterName;
-    std::string m_locale;
     stdext::timer m_pingTimer;
     LocalPlayerPtr m_localPlayer;
 };

src/client/protocolgamesend.cpp

@@ -53,17 +53,7 @@ void ProtocolGame::sendLoginPacket(uint challengeTimestamp, uint8 challengeRando
     OutputMessagePtr msg(new OutputMessage);
 
     msg->addU8(Proto::ClientPendingGame);
-
     msg->addU16(g_game.getOs());
-
-    if(g_game.getFeature(Otc::GameUpdater)) {
-        msg->addString(g_app.getOs());
-        msg->addString(g_game.getUpdaterSignature());
-    }
-
-    if(g_game.getFeature(Otc::GameLoginLocale))
-        msg->addString(m_locale);
-
     msg->addU16(g_game.getProtocolVersion());
 
     if(g_game.getProtocolVersion() >= 971) {
@@ -71,9 +61,9 @@ void ProtocolGame::sendLoginPacket(uint challengeTimestamp, uint8 challengeRando
         msg->addU8(0); // clientType
     }
 
-    int paddingBytes = 128;
+    int offset = msg->getMessageSize();
+
     msg->addU8(0); // first RSA byte must be 0
-    paddingBytes -= 1;
 
     // xtea key
     generateXteaKey();
@@ -82,46 +72,34 @@ void ProtocolGame::sendLoginPacket(uint challengeTimestamp, uint8 challengeRando
     msg->addU32(m_xteaKey[2]);
     msg->addU32(m_xteaKey[3]);
     msg->addU8(0); // is gm set?
-    paddingBytes -= 17;
 
-    if(g_game.getFeature(Otc::GameProtocolChecksum))
-        enableChecksum();
-
-    if(g_game.getFeature(Otc::GameAccountNames)) {
+    if(g_game.getFeature(Otc::GameAccountNames))
         msg->addString(m_accountName);
-        msg->addString(m_characterName);
-        msg->addString(m_accountPassword);
-        paddingBytes -= 6 + m_accountName.length() + m_characterName.length() + m_accountPassword.length();
-    } else {
+    else
         msg->addU32(stdext::from_string<uint32>(m_accountName));
-        msg->addString(m_characterName);
-        msg->addString(m_accountPassword);
-        paddingBytes -= 8 + m_characterName.length() + m_accountPassword.length();
-    }
 
-    if(g_game.getFeature(Otc::GameLoginUUID)) {
-        std::string uuid = g_crypt.getMachineUUID();
-        msg->addString(uuid);
-        paddingBytes -= 2 + uuid.length();
-    }
+    msg->addString(m_characterName);
+    msg->addString(m_accountPassword);
 
     if(g_game.getFeature(Otc::GameChallengeOnLogin)) {
         msg->addU32(challengeTimestamp);
         msg->addU8(challengeRandom);
-        paddingBytes -= 5;
     }
 
-    if(paddingBytes < 0) {
-        g_game.processLoginError("AccountName or Password or CharacterName are too big!\nPlease contact game support.");
-        g_game.processDisconnect();
-        return;
-    }
+    std::string extended = callLuaField<std::string>("getLoginExtendedData");
+    if(!extended.empty())
+        msg->addString(extended);
 
-    // complete the 128 bytes for rsa encryption with zeros
+    // complete the bytes for rsa encryption with zeros
+    int paddingBytes = g_crypt.rsaGetSize() - (msg->getMessageSize() - offset);
+    assert(paddingBytes >= 0);
     msg->addPaddingBytes(paddingBytes);
 
     // encrypt with RSA
-    msg->encryptRsa(128);
+    msg->encryptRsa();
+
+    if(g_game.getFeature(Otc::GameProtocolChecksum))
+        enableChecksum();
 
     send(msg);
 

src/framework/luafunctions.cpp

@@ -117,9 +117,11 @@ void Application::registerLuaFunctions()
     g_lua.bindSingletonFunction("g_crypt", "decrypt", &Crypt::decrypt, &g_crypt);
     g_lua.bindSingletonFunction("g_crypt", "sha1Encode", &Crypt::sha1Encode, &g_crypt);
     g_lua.bindSingletonFunction("g_crypt", "md5Encode", &Crypt::md5Encode, &g_crypt);
+    g_lua.bindSingletonFunction("g_crypt", "rsaGenerateKey", &Crypt::rsaGenerateKey, &g_crypt);
     g_lua.bindSingletonFunction("g_crypt", "rsaSetPublicKey", &Crypt::rsaSetPublicKey, &g_crypt);
     g_lua.bindSingletonFunction("g_crypt", "rsaSetPrivateKey", &Crypt::rsaSetPrivateKey, &g_crypt);
     g_lua.bindSingletonFunction("g_crypt", "rsaCheckKey", &Crypt::rsaCheckKey, &g_crypt);
+    g_lua.bindSingletonFunction("g_crypt", "rsaGetSize", &Crypt::rsaGetSize, &g_crypt);
 
     // Clock
     g_lua.registerSingletonClass("g_clock");

src/framework/net/outputmessage.cpp

@@ -89,12 +89,14 @@ void OutputMessage::addPaddingBytes(int bytes, uint8 byte)
     m_messageSize += bytes;
 }
 
-void OutputMessage::encryptRsa(int size)
+void OutputMessage::encryptRsa()
 {
+    int size = g_crypt.rsaGetSize();
     if(m_messageSize < size)
         throw stdext::exception("insufficient bytes in buffer to encrypt");
 
-    g_crypt.rsaEncrypt((unsigned char*)m_buffer + m_writePos - size, size);
+    if(!g_crypt.rsaEncrypt((unsigned char*)m_buffer + m_writePos - size, size))
+        throw stdext::exception("rsa encryption failed");
 }
 
 void OutputMessage::writeChecksum()

src/framework/net/outputmessage.h

@@ -49,7 +49,7 @@ public:
     void addString(const std::string& buffer);
     void addPaddingBytes(int bytes, uint8 byte = 0);
 
-    void encryptRsa(int size);
+    void encryptRsa();
 
     uint16 getWritePos() { return m_writePos; }
     uint16 getMessageSize() { return m_messageSize; }

src/framework/util/crypt.cpp

@@ -292,11 +292,21 @@ std::string Crypt::sha512Encode(const std::string& decoded_string, bool upperCas
     return result;
 }
 
+
+void Crypt::rsaGenerateKey(int bits, int e)
+{
+    RSA *rsa = RSA_generate_key(bits, e, nullptr, nullptr);
+    g_logger.info(stdext::format("%d bits (%d bytes) RSA key generated", bits, bits / 8));
+    g_logger.info(std::string("p = ") + BN_bn2dec(m_rsa->p));
+    g_logger.info(std::string("q = ") + BN_bn2dec(m_rsa->q));
+    g_logger.info(std::string("d = ") + BN_bn2dec(m_rsa->d));
+    g_logger.info(std::string("n = ") + BN_bn2dec(m_rsa->n));
+    g_logger.info(std::string("e = ") + BN_bn2dec(m_rsa->e));
+    RSA_free(rsa);
+}
+
 void Crypt::rsaSetPublicKey(const std::string& n, const std::string& e)
 {
-    RSA_free(m_rsa);
-    m_rsa = RSA_new();
-
     BN_dec2bn(&m_rsa->n, n.c_str());
     BN_dec2bn(&m_rsa->e, e.c_str());
 }
@@ -331,12 +341,20 @@ bool Crypt::rsaCheckKey()
 
 bool Crypt::rsaEncrypt(unsigned char *msg, int size)
 {
-    assert(size <= 128);
+    if(size != RSA_size(m_rsa))
+        return false;
     return RSA_public_encrypt(size, msg, msg, m_rsa, RSA_NO_PADDING) != -1;
 }
 
 bool Crypt::rsaDecrypt(unsigned char *msg, int size)
 {
-    assert(size <= 128);
+    if(size != RSA_size(m_rsa))
+        return false;
     return RSA_private_decrypt(size, msg, msg, m_rsa, RSA_NO_PADDING) != -1;
 }
+
+int Crypt::rsaGetSize()
+{
+    return RSA_size(m_rsa);
+}
+

src/framework/util/crypt.h

@@ -49,11 +49,13 @@ public:
     std::string sha256Encode(const std::string& decoded_string, bool upperCase);
     std::string sha512Encode(const std::string& decoded_string, bool upperCase);
 
+    void rsaGenerateKey(int bits, int e);
     void rsaSetPublicKey(const std::string& n, const std::string& e);
     void rsaSetPrivateKey(const std::string &p, const std::string &q, const std::string &d);
     bool rsaCheckKey();
     bool rsaEncrypt(unsigned char *msg, int size);
     bool rsaDecrypt(unsigned char *msg, int size);
+    int rsaGetSize();
 
 private:
     std::string getMachineKey();