diff --git a/loginserver/client.cpp b/loginserver/client.cpp index 52b050495..3e7c282b9 100644 --- a/loginserver/client.cpp +++ b/loginserver/client.cpp @@ -17,10 +17,10 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "client.h" #include "login_server.h" -#include "login_structures.h" #include "../common/misc_functions.h" #include "../common/eqemu_logsys.h" #include "../common/string_util.h" +#include "encryption.h" extern LoginServer server; @@ -192,6 +192,11 @@ void Client::Handle_Login(const char* data, unsigned int size) return; } + if (size < sizeof(LoginLoginRequest_Struct)) { + Log(Logs::General, Logs::Error, "Login received packet of size: %u, this would cause a buffer overflow, discarding.", size); + return; + } + char *login_packet_buffer = nullptr; unsigned int db_account_id = 0; @@ -219,6 +224,8 @@ void Client::Handle_Login(const char* data, unsigned int size) return; } + memcpy(&llrs, data, sizeof(LoginLoginRequest_Struct)); + bool result = false; if (outbuffer[0] == 0 && outbuffer[1] == 0) { if (server.options.IsTokenLoginAllowed()) { @@ -236,7 +243,9 @@ void Client::Handle_Login(const char* data, unsigned int size) } if (server.db->GetLoginDataFromAccountInfo(user, db_loginserver, db_account_password_hash, db_account_id) == false) { - + status = cs_creating_account; + AttemptLoginAccountCreation(user, cred, db_loginserver); + return; } else { if (eqcrypt_verify_hash(user, cred, db_account_password_hash, mode)) { @@ -251,87 +260,10 @@ void Client::Handle_Login(const char* data, unsigned int size) /* Login Accepted */ if (result) { - - server.client_manager->RemoveExistingClient(db_account_id, db_loginserver); - - in_addr in; - in.s_addr = connection->GetRemoteIP(); - - server.db->UpdateLSAccountData(db_account_id, std::string(inet_ntoa(in))); - GenerateKey(); - - account_id = db_account_id; - account_name = user; - loginserver_name = db_loginserver; - - EQApplicationPacket *outapp = new EQApplicationPacket(OP_LoginAccepted, 10 + 80); - const LoginLoginRequest_Struct* llrs = (const LoginLoginRequest_Struct *)data; - LoginAccepted_Struct* login_accepted = (LoginAccepted_Struct *)outapp->pBuffer; - login_accepted->unknown1 = llrs->unknown1; - login_accepted->unknown2 = llrs->unknown2; - login_accepted->unknown3 = llrs->unknown3; - login_accepted->unknown4 = llrs->unknown4; - login_accepted->unknown5 = llrs->unknown5; - - LoginFailedAttempts_Struct * login_failed_attempts = new LoginFailedAttempts_Struct; - memset(login_failed_attempts, 0, sizeof(LoginFailedAttempts_Struct)); - - login_failed_attempts->failed_attempts = 0; - login_failed_attempts->message = 0x01; - login_failed_attempts->lsid = db_account_id; - login_failed_attempts->unknown3[3] = 0x03; - login_failed_attempts->unknown4[3] = 0x02; - login_failed_attempts->unknown5[0] = 0xe7; - login_failed_attempts->unknown5[1] = 0x03; - login_failed_attempts->unknown6[0] = 0xff; - login_failed_attempts->unknown6[1] = 0xff; - login_failed_attempts->unknown6[2] = 0xff; - login_failed_attempts->unknown6[3] = 0xff; - login_failed_attempts->unknown7[0] = 0xa0; - login_failed_attempts->unknown7[1] = 0x05; - login_failed_attempts->unknown8[3] = 0x02; - login_failed_attempts->unknown9[0] = 0xff; - login_failed_attempts->unknown9[1] = 0x03; - login_failed_attempts->unknown11[0] = 0x63; - login_failed_attempts->unknown12[0] = 0x01; - memcpy(login_failed_attempts->key, key.c_str(), key.size()); - - char encrypted_buffer[80] = { 0 }; - auto rc = eqcrypt_block((const char*)login_failed_attempts, 75, encrypted_buffer, 1); - if (rc == nullptr) { - LogF(Logs::General, Logs::Debug, "Failed to encrypt eqcrypt block"); - } - - memcpy(login_accepted->encrypt, encrypted_buffer, 80); - - if (server.options.IsDumpOutPacketsOn()) { - DumpPacket(outapp); - } - - connection->QueuePacket(outapp); - delete outapp; - - status = cs_logged_in; + DoSuccessfulLogin(user, db_account_id, db_loginserver); } else { - EQApplicationPacket *outapp = new EQApplicationPacket(OP_LoginAccepted, sizeof(LoginLoginFailed_Struct)); - const LoginLoginRequest_Struct* llrs = (const LoginLoginRequest_Struct *)data; - LoginLoginFailed_Struct* llas = (LoginLoginFailed_Struct *)outapp->pBuffer; - llas->unknown1 = llrs->unknown1; - llas->unknown2 = llrs->unknown2; - llas->unknown3 = llrs->unknown3; - llas->unknown4 = llrs->unknown4; - llas->unknown5 = llrs->unknown5; - memcpy(llas->unknown6, FailedLoginResponseData, sizeof(FailedLoginResponseData)); - - if (server.options.IsDumpOutPacketsOn()) { - DumpPacket(outapp); - } - - connection->QueuePacket(outapp); - delete outapp; - - status = cs_failed_to_login; + DoFailedLogin(); } } @@ -400,3 +332,261 @@ void Client::GenerateKey() count++; } } + +void Client::AttemptLoginAccountCreation(const std::string &user, const std::string &pass, const std::string &loginserver) +{ + if (loginserver == "eqemu") { + if (!server.options.CanAutoCreateAccounts()) { + DoFailedLogin(); + return; + } + + if (server.options.GetEQEmuLoginServerAddress().length() == 0) { + DoFailedLogin(); + return; + } + + auto addr_components = SplitString(server.options.GetEQEmuLoginServerAddress(), ':'); + if (addr_components.size() != 2) { + DoFailedLogin(); + return; + } + + stored_user = user; + stored_pass = pass; + + auto address = addr_components[0]; + auto port = std::stoi(addr_components[1]); + EQ::Net::DNSLookup(address, port, false, [=](const std::string &addr) { + if (addr.empty()) { + DoFailedLogin(); + return; + } + + login_connection_manager.reset(new EQ::Net::DaybreakConnectionManager()); + login_connection_manager->OnNewConnection(std::bind(&Client::LoginOnNewConnection, this, std::placeholders::_1)); + login_connection_manager->OnConnectionStateChange(std::bind(&Client::LoginOnStatusChange, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); + login_connection_manager->OnPacketRecv(std::bind(&Client::LoginOnPacketRecv, this, std::placeholders::_1, std::placeholders::_2)); + + login_connection_manager->Connect(addr, port); + }); + } + else { + if (!server.options.CanAutoCreateAccounts()) { + DoFailedLogin(); + return; + } + + CreateLocalAccount(user, pass); + } +} + +void Client::DoFailedLogin() +{ + stored_user.clear(); + stored_pass.clear(); + + EQApplicationPacket outapp(OP_LoginAccepted, sizeof(LoginLoginFailed_Struct)); + LoginLoginFailed_Struct* llas = (LoginLoginFailed_Struct *)outapp.pBuffer; + llas->unknown1 = llrs.unknown1; + llas->unknown2 = llrs.unknown2; + llas->unknown3 = llrs.unknown3; + llas->unknown4 = llrs.unknown4; + llas->unknown5 = llrs.unknown5; + memcpy(llas->unknown6, FailedLoginResponseData, sizeof(FailedLoginResponseData)); + + if (server.options.IsDumpOutPacketsOn()) { + DumpPacket(&outapp); + } + + connection->QueuePacket(&outapp); + status = cs_failed_to_login; +} + +void Client::DoSuccessfulLogin(const std::string &user, int db_account_id, const std::string &db_loginserver) +{ + stored_user.clear(); + stored_pass.clear(); + + server.client_manager->RemoveExistingClient(db_account_id, db_loginserver); + + in_addr in; + in.s_addr = connection->GetRemoteIP(); + + server.db->UpdateLSAccountData(db_account_id, std::string(inet_ntoa(in))); + GenerateKey(); + + account_id = db_account_id; + account_name = user; + loginserver_name = db_loginserver; + + EQApplicationPacket *outapp = new EQApplicationPacket(OP_LoginAccepted, 10 + 80); + LoginAccepted_Struct* login_accepted = (LoginAccepted_Struct *)outapp->pBuffer; + login_accepted->unknown1 = llrs.unknown1; + login_accepted->unknown2 = llrs.unknown2; + login_accepted->unknown3 = llrs.unknown3; + login_accepted->unknown4 = llrs.unknown4; + login_accepted->unknown5 = llrs.unknown5; + + LoginFailedAttempts_Struct * login_failed_attempts = new LoginFailedAttempts_Struct; + memset(login_failed_attempts, 0, sizeof(LoginFailedAttempts_Struct)); + + login_failed_attempts->failed_attempts = 0; + login_failed_attempts->message = 0x01; + login_failed_attempts->lsid = db_account_id; + login_failed_attempts->unknown3[3] = 0x03; + login_failed_attempts->unknown4[3] = 0x02; + login_failed_attempts->unknown5[0] = 0xe7; + login_failed_attempts->unknown5[1] = 0x03; + login_failed_attempts->unknown6[0] = 0xff; + login_failed_attempts->unknown6[1] = 0xff; + login_failed_attempts->unknown6[2] = 0xff; + login_failed_attempts->unknown6[3] = 0xff; + login_failed_attempts->unknown7[0] = 0xa0; + login_failed_attempts->unknown7[1] = 0x05; + login_failed_attempts->unknown8[3] = 0x02; + login_failed_attempts->unknown9[0] = 0xff; + login_failed_attempts->unknown9[1] = 0x03; + login_failed_attempts->unknown11[0] = 0x63; + login_failed_attempts->unknown12[0] = 0x01; + memcpy(login_failed_attempts->key, key.c_str(), key.size()); + + char encrypted_buffer[80] = { 0 }; + auto rc = eqcrypt_block((const char*)login_failed_attempts, 75, encrypted_buffer, 1); + if (rc == nullptr) { + LogF(Logs::General, Logs::Debug, "Failed to encrypt eqcrypt block"); + } + + memcpy(login_accepted->encrypt, encrypted_buffer, 80); + + if (server.options.IsDumpOutPacketsOn()) { + DumpPacket(outapp); + } + + connection->QueuePacket(outapp); + delete outapp; + + status = cs_logged_in; +} + +void Client::CreateLocalAccount(const std::string &user, const std::string &pass) +{ + auto mode = server.options.GetEncryptionMode(); + auto hash = eqcrypt_hash(user, pass, mode); + + unsigned int db_id = 0; + std::string db_login = server.options.GetDefaultLoginServerName(); + if (!server.db->CreateLoginData(user, hash, db_login, db_id)) { + DoFailedLogin(); + } + else { + DoSuccessfulLogin(user, db_id, db_login); + } +} + +void Client::CreateEQEmuAccount(const std::string &user, const std::string &pass, unsigned int id) +{ + auto mode = server.options.GetEncryptionMode(); + auto hash = eqcrypt_hash(user, pass, mode); + + if (!server.db->CreateLoginDataWithID(user, hash, "eqemu", id)) { + DoFailedLogin(); + } + else { + DoSuccessfulLogin(user, id, "eqemu"); + } +} + +void Client::LoginOnNewConnection(std::shared_ptr connection) +{ + login_connection = connection; +} + +void Client::LoginOnStatusChange(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) +{ + if (to == EQ::Net::StatusConnected) { + LoginSendSessionReady(); + } + + if (to == EQ::Net::StatusDisconnecting || to == EQ::Net::StatusDisconnected) { + DoFailedLogin(); + } +} + +void Client::LoginOnStatusChangeIgnored(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to) +{ +} + +void Client::LoginOnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet & p) +{ + auto opcode = p.GetUInt16(0); + switch (opcode) { + case 0x0017: //OP_ChatMessage + LoginSendLogin(); + break; + case 0x0018: + LoginProcessLoginResponse(p); + break; + } +} + +void Client::LoginSendSessionReady() +{ + EQ::Net::DynamicPacket p; + p.PutUInt16(0, 1); //OP_SessionReady + p.PutUInt32(2, 2); + + login_connection->QueuePacket(p); +} + +void Client::LoginSendLogin() +{ + size_t buffer_len = stored_user.length() + stored_pass.length() + 2; + std::unique_ptr buffer(new char[buffer_len]); + + strcpy(&buffer[0], stored_user.c_str()); + strcpy(&buffer[stored_user.length() + 1], stored_pass.c_str()); + + size_t encrypted_len = buffer_len; + + if (encrypted_len % 8 > 0) { + encrypted_len = ((encrypted_len / 8) + 1) * 8; + } + + EQ::Net::DynamicPacket p; + p.Resize(12 + encrypted_len); + p.PutUInt16(0, 2); //OP_Login + p.PutUInt32(2, 3); + + eqcrypt_block(&buffer[0], buffer_len, (char*)p.Data() + 12, true); + + login_connection->QueuePacket(p); +} + +void Client::LoginProcessLoginResponse(const EQ::Net::Packet & p) +{ + auto encrypt_size = p.Length() - 12; + if (encrypt_size % 8 > 0) { + encrypt_size = (encrypt_size / 8) * 8; + } + + std::unique_ptr decrypted(new char[encrypt_size]); + + eqcrypt_block((char*)p.Data() + 12, encrypt_size, &decrypted[0], false); + + EQ::Net::StaticPacket sp(&decrypted[0], encrypt_size); + auto response_error = sp.GetUInt16(1); + + login_connection_manager->OnConnectionStateChange(std::bind(&Client::LoginOnStatusChangeIgnored, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); + + if (response_error > 101) { + DoFailedLogin(); + login_connection->Close(); + } + else { + auto m_dbid = sp.GetUInt32(8); + + CreateEQEmuAccount(stored_user, stored_pass, m_dbid); + login_connection->Close(); + } +} diff --git a/loginserver/client.h b/loginserver/client.h index bd8547d9a..0271ec545 100644 --- a/loginserver/client.h +++ b/loginserver/client.h @@ -21,9 +21,13 @@ #include "../common/global_define.h" #include "../common/opcodemgr.h" #include "../common/random.h" +#include "../common/eq_stream_intf.h" +#include "../common/net/dns.h" +#include "../common/net/daybreak_connection.h" + +#include "login_structures.h" #include -#include "../common/eq_stream_intf.h" enum LSClientVersion { @@ -35,6 +39,7 @@ enum LSClientStatus { cs_not_sent_session_ready, cs_waiting_for_login, + cs_creating_account, cs_failed_to_login, cs_logged_in }; @@ -126,8 +131,33 @@ public: */ std::shared_ptr GetConnection() { return connection; } - EQEmu::Random random; + /** + * Attempts to create a login account + */ + void AttemptLoginAccountCreation(const std::string &user, const std::string &pass, const std::string &loginserver); + + /** + * Does a failed login + */ + void DoFailedLogin(); + + /** + * Does a successful login + */ + void DoSuccessfulLogin(const std::string &user, int db_account_id, const std::string &db_loginserver); + + /** + * Creates a local account + */ + void CreateLocalAccount(const std::string &user, const std::string &pass); + + /** + * Creates an eqemu account + */ + void CreateEQEmuAccount(const std::string &user, const std::string &pass, unsigned int id); + private: + EQEmu::Random random; std::shared_ptr connection; LSClientVersion version; LSClientStatus status; @@ -138,6 +168,20 @@ private: unsigned int play_server_id; unsigned int play_sequence_id; std::string key; + + std::unique_ptr login_connection_manager; + std::shared_ptr login_connection; + LoginLoginRequest_Struct llrs; + + std::string stored_user; + std::string stored_pass; + void LoginOnNewConnection(std::shared_ptr connection); + void LoginOnStatusChange(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); + void LoginOnStatusChangeIgnored(std::shared_ptr conn, EQ::Net::DbProtocolStatus from, EQ::Net::DbProtocolStatus to); + void LoginOnPacketRecv(std::shared_ptr conn, const EQ::Net::Packet &p); + void LoginSendSessionReady(); + void LoginSendLogin(); + void LoginProcessLoginResponse(const EQ::Net::Packet &p); }; #endif diff --git a/loginserver/database.h b/loginserver/database.h index 5edfbcbde..0025cd476 100644 --- a/loginserver/database.h +++ b/loginserver/database.h @@ -45,7 +45,9 @@ public: virtual bool GetLoginTokenDataFromToken(const std::string &token, const std::string &ip, unsigned int &db_account_id, std::string &db_loginserver, std::string &user) { return false; } - virtual bool CreateLoginData(const std::string &name, const std::string &password, unsigned int &id) { return false; } + virtual bool CreateLoginData(const std::string &name, const std::string &password, const std::string &loginserver, unsigned int &id) { return false; } + + virtual bool CreateLoginDataWithID(const std::string &name, const std::string &password, const std::string &loginserver, unsigned int id) { return false; } /** * Retrieves the world registration from the long and short names provided. diff --git a/loginserver/database_mysql.cpp b/loginserver/database_mysql.cpp index 913468245..9781ec4df 100644 --- a/loginserver/database_mysql.cpp +++ b/loginserver/database_mysql.cpp @@ -152,30 +152,75 @@ bool DatabaseMySQL::GetLoginTokenDataFromToken(const std::string &token, const s return found_username && found_login_id && found_login_server_name; } -bool DatabaseMySQL::CreateLoginData(const std::string &name, const std::string &password, unsigned int &id) +unsigned int DatabaseMySQL::GetFreeID(const std::string &loginserver) +{ + if (!database) + { + return false; + } + + MYSQL_RES *res; + MYSQL_ROW row; + std::stringstream query(std::stringstream::in | std::stringstream::out); + query << "SELECT MAX(LoginServerID) + 1 FROM " << server.options.GetAccountTable() << " WHERE AccountLoginServer='"; + query << EscapeString(loginserver) << "'"; + + if (mysql_query(database, query.str().c_str()) != 0) + { + Log(Logs::General, Logs::Error, "Mysql query failed: %s", query.str().c_str()); + return 0; + } + + res = mysql_use_result(database); + + if (res) + { + while ((row = mysql_fetch_row(res)) != nullptr) + { + if (row[0] == nullptr) { + mysql_free_result(res); + return 1; + } + + auto ret = atol(row[0]); + mysql_free_result(res); + return ret; + } + + mysql_free_result(res); + } + + return 1; +} + +bool DatabaseMySQL::CreateLoginData(const std::string &name, const std::string &password, const std::string &loginserver, unsigned int &id) +{ + return CreateLoginDataWithID(name, password, loginserver, GetFreeID(loginserver)); +} + +bool DatabaseMySQL::CreateLoginDataWithID(const std::string & name, const std::string & password, const std::string & loginserver, unsigned int id) { if (!database) { return false; } + if (id == 0) { + return false; + } + MYSQL_RES *result; MYSQL_ROW row; std::stringstream query(std::stringstream::in | std::stringstream::out); - query << "INSERT INTO " << server.options.GetAccountTable() << " (AccountName, AccountPassword, AccountEmail, LastLoginDate, LastIPAddress) "; - query << " VALUES('" << name << "', '" << password << "', 'local_creation', NOW(), '127.0.0.1'); "; + query << "INSERT INTO " << server.options.GetAccountTable() << " (LoginServerID, AccountLoginserver, AccountName, AccountPassword, AccountEmail, LastLoginDate, LastIPAddress) "; + query << " VALUES(" << id << ", '" << EscapeString(loginserver) << "', '" << EscapeString(name) << "', '" << EscapeString(password) << "', 'local_creation', NOW(), '127.0.0.1'); "; if (mysql_query(database, query.str().c_str()) != 0) { Log(Logs::General, Logs::Error, "Mysql query failed: %s", query.str().c_str()); return false; } - else { - id = mysql_insert_id(database); - return true; - } - Log(Logs::General, Logs::Error, "Mysql query returned no result: %s", query.str().c_str()); - return false; + return true; } bool DatabaseMySQL::GetWorldRegistration(std::string long_name, std::string short_name, unsigned int &id, std::string &desc, unsigned int &list_id, diff --git a/loginserver/database_mysql.h b/loginserver/database_mysql.h index 42eb9b304..41eac0eb5 100644 --- a/loginserver/database_mysql.h +++ b/loginserver/database_mysql.h @@ -61,7 +61,11 @@ public: virtual bool GetLoginTokenDataFromToken(const std::string &token, const std::string &ip, unsigned int &db_account_id, std::string &db_loginserver, std::string &user); - virtual bool CreateLoginData(const std::string &name, const std::string &password, unsigned int &id); + virtual unsigned int GetFreeID(const std::string &loginserver); + + virtual bool CreateLoginData(const std::string &name, const std::string &password, const std::string &loginserver, unsigned int &id); + + virtual bool CreateLoginDataWithID(const std::string &name, const std::string &password, const std::string &loginserver, unsigned int id); /** * Retrieves the world registration from the long and short names provided. diff --git a/loginserver/main.cpp b/loginserver/main.cpp index 7fd047903..17cc179e5 100644 --- a/loginserver/main.cpp +++ b/loginserver/main.cpp @@ -71,12 +71,31 @@ int main() if (server.config->GetVariable("security", "allow_token_login").compare("TRUE") == 0) server.options.AllowTokenLogin(true); + auto eqemu_loginserver_addr = server.config->GetVariable("options", "eqemu_loginserver_address"); + if (eqemu_loginserver_addr.size() > 0) { + server.options.EQEmuLoginServerAddress(eqemu_loginserver_addr); + } + else { + server.options.EQEmuLoginServerAddress("login.eqemulator.net:5999"); + } + + auto default_loginserver_name = server.config->GetVariable("options", "default_loginserver_name"); + if (default_loginserver_name.size() > 0) { + server.options.DefaultLoginServerName(default_loginserver_name); + } + else { + server.options.DefaultLoginServerName("peq"); + } + if (server.config->GetVariable("security", "allow_password_login").compare("FALSE") == 0) server.options.AllowPasswordLogin(false); if (server.config->GetVariable("options", "auto_create_accounts").compare("TRUE") == 0) server.options.AutoCreateAccounts(true); + if (server.config->GetVariable("options", "auto_link_accounts").compare("TRUE") == 0) + server.options.AutoLinkAccounts(true); + std::string mode = server.config->GetVariable("security", "mode"); if (mode.size() > 0) server.options.EncryptionMode(atoi(mode.c_str())); diff --git a/loginserver/options.h b/loginserver/options.h index f215e443b..a89d3f760 100644 --- a/loginserver/options.h +++ b/loginserver/options.h @@ -169,6 +169,15 @@ public: inline void AutoCreateAccounts(bool b) { auto_create_accounts = b; } inline bool CanAutoCreateAccounts() const { return auto_create_accounts; } + inline void AutoLinkAccounts(bool b) { auto_link_accounts = b; } + inline bool CanAutoLinkAccounts() const { return auto_link_accounts; } + + inline void EQEmuLoginServerAddress(std::string v) { eqemu_loginserver_address = v; } + inline std::string GetEQEmuLoginServerAddress() const { return eqemu_loginserver_address; } + + inline void DefaultLoginServerName(std::string v) { default_loginserver_name = v; } + inline std::string GetDefaultLoginServerName() const { return default_loginserver_name; } + private: bool allow_unregistered; bool trace; @@ -179,12 +188,15 @@ private: bool allow_token_login; bool allow_password_login; bool auto_create_accounts; + bool auto_link_accounts; int encryption_mode; std::string local_network; std::string account_table; std::string world_registration_table; std::string world_admin_registration_table; std::string world_server_type_table; + std::string eqemu_loginserver_address; + std::string default_loginserver_name; }; #endif