mirror of
https://github.com/EQEmu/Server.git
synced 2025-12-12 13:41:31 +00:00
355 lines
8.6 KiB
C++
355 lines
8.6 KiB
C++
/**
|
|
* EQEmulator: Everquest Server Emulator
|
|
* Copyright (C) 2001-2019 EQEmulator Development Team (https://github.com/EQEmu/Server)
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; version 2 of the License.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY except by those people which sell it, which
|
|
* are required to give you total support for your newly bought product;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
|
* A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
|
|
#include "account_management.h"
|
|
#include "login_server.h"
|
|
#include "../common/event/task_scheduler.h"
|
|
#include "../common/event/event_loop.h"
|
|
#include "../common/net/dns.h"
|
|
|
|
extern LoginServer server;
|
|
EQ::Event::TaskScheduler task_runner;
|
|
|
|
/**
|
|
* @param username
|
|
* @param password
|
|
* @param email
|
|
* @return
|
|
*/
|
|
uint32 AccountManagement::CreateLocalLoginServerAccount(
|
|
std::string username,
|
|
std::string password,
|
|
std::string email
|
|
)
|
|
{
|
|
auto mode = server.options.GetEncryptionMode();
|
|
auto hash = eqcrypt_hash(username, password, mode);
|
|
|
|
LogInfo(
|
|
"Attempting to create local login account for user [{0}] encryption algorithm [{1}] ({2})",
|
|
username,
|
|
GetEncryptionByModeId(mode),
|
|
mode
|
|
);
|
|
|
|
unsigned int db_id = 0;
|
|
std::string db_loginserver = server.options.GetDefaultLoginServerName();
|
|
if (server.db->DoesLoginServerAccountExist(username, hash, db_loginserver, 1)) {
|
|
LogWarning(
|
|
"Attempting to create local login account for user [{0}] login [{1}] db_id [{2}] but already exists!",
|
|
username,
|
|
db_loginserver,
|
|
db_id
|
|
);
|
|
|
|
return 0;
|
|
}
|
|
|
|
uint32 created_account_id = server.db->CreateLoginAccount(username, hash, db_loginserver, email);
|
|
if (created_account_id > 0) {
|
|
LogInfo(
|
|
"Account creation success for user [{0}] encryption algorithm [{1}] ({2}) id: [{3}]",
|
|
username,
|
|
GetEncryptionByModeId(mode),
|
|
mode,
|
|
created_account_id
|
|
);
|
|
|
|
return created_account_id;
|
|
}
|
|
|
|
LogError("Failed to create local login account for user [{0}]!", username);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @param username
|
|
* @param password
|
|
* @param email
|
|
* @return
|
|
*/
|
|
bool AccountManagement::CreateLoginserverWorldAdminAccount(
|
|
const std::string &username,
|
|
const std::string &password,
|
|
const std::string &email,
|
|
const std::string &first_name,
|
|
const std::string &last_name,
|
|
const std::string &ip_address
|
|
)
|
|
{
|
|
auto mode = server.options.GetEncryptionMode();
|
|
auto hash = eqcrypt_hash(username, password, mode);
|
|
|
|
LogInfo(
|
|
"Attempting to create world admin account | username [{0}] encryption algorithm [{1}] ({2})",
|
|
username,
|
|
GetEncryptionByModeId(mode),
|
|
mode
|
|
);
|
|
|
|
if (server.db->DoesLoginserverWorldAdminAccountExist(username)) {
|
|
LogWarning(
|
|
"Attempting to create world admin account for user [{0}] but already exists!",
|
|
username
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
uint32 created_world_admin_id = server.db->CreateLoginserverWorldAdminAccount(
|
|
username,
|
|
hash,
|
|
first_name,
|
|
last_name,
|
|
email,
|
|
ip_address
|
|
);
|
|
|
|
if (created_world_admin_id > 0) {
|
|
LogInfo(
|
|
"Account creation success for user [{0}] encryption algorithm [{1}] ({2}) new admin id [{3}]",
|
|
username,
|
|
GetEncryptionByModeId(mode),
|
|
mode,
|
|
created_world_admin_id
|
|
);
|
|
return true;
|
|
}
|
|
|
|
LogError("Failed to create world admin account account for user [{0}]!", username);
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param in_account_username
|
|
* @param in_account_password
|
|
* @return
|
|
*/
|
|
bool AccountManagement::CheckLoginserverUserCredentials(
|
|
const std::string &in_account_username,
|
|
const std::string &in_account_password,
|
|
const std::string &source_loginserver
|
|
)
|
|
{
|
|
auto mode = server.options.GetEncryptionMode();
|
|
|
|
Database::DbLoginServerAccount
|
|
login_server_admin = server.db->GetLoginServerAccountByAccountName(
|
|
in_account_username,
|
|
source_loginserver
|
|
);
|
|
|
|
if (!login_server_admin.loaded) {
|
|
LogError(
|
|
"CheckLoginUserCredentials account [{0}] source_loginserver [{1}] not found!",
|
|
in_account_username,
|
|
source_loginserver
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool validated_credentials = eqcrypt_verify_hash(
|
|
in_account_username,
|
|
in_account_password,
|
|
login_server_admin.account_password,
|
|
mode
|
|
);
|
|
|
|
if (!validated_credentials) {
|
|
LogError(
|
|
"CheckLoginUserCredentials account [{0}] source_loginserver [{1}] invalid credentials!",
|
|
in_account_username,
|
|
source_loginserver
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
LogDebug(
|
|
"CheckLoginUserCredentials account [{0}] source_loginserver [{1}] credentials validated success!",
|
|
in_account_username,
|
|
source_loginserver
|
|
);
|
|
|
|
return validated_credentials;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param in_account_username
|
|
* @param in_account_password
|
|
* @return
|
|
*/
|
|
bool AccountManagement::UpdateLoginserverUserCredentials(
|
|
const std::string &in_account_username,
|
|
const std::string &in_account_password,
|
|
const std::string &source_loginserver
|
|
)
|
|
{
|
|
auto mode = server.options.GetEncryptionMode();
|
|
|
|
Database::DbLoginServerAccount
|
|
login_server_account = server.db->GetLoginServerAccountByAccountName(
|
|
in_account_username,
|
|
source_loginserver
|
|
);
|
|
|
|
if (!login_server_account.loaded) {
|
|
LogError(
|
|
"ChangeLoginserverUserCredentials account [{0}] source_loginserver [{1}] not found!",
|
|
in_account_username,
|
|
source_loginserver
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
server.db->UpdateLoginserverAccountPasswordHash(
|
|
in_account_username,
|
|
source_loginserver,
|
|
eqcrypt_hash(
|
|
in_account_username,
|
|
in_account_password,
|
|
mode
|
|
)
|
|
);
|
|
|
|
LogDebug(
|
|
"ChangeLoginserverUserCredentials account [{0}] source_loginserver [{1}] credentials updated!",
|
|
in_account_username,
|
|
source_loginserver
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool AccountManagement::CheckExternalLoginserverUserCredentials(
|
|
const std::string &in_account_username,
|
|
const std::string &in_account_password
|
|
)
|
|
{
|
|
auto res = task_runner.Enqueue(
|
|
[&]() -> bool {
|
|
bool running = true;
|
|
bool ret = false;
|
|
EQ::Net::DaybreakConnectionManager mgr;
|
|
std::shared_ptr<EQ::Net::DaybreakConnection> c;
|
|
|
|
mgr.OnNewConnection(
|
|
[&](std::shared_ptr<EQ::Net::DaybreakConnection> connection) {
|
|
c = connection;
|
|
}
|
|
);
|
|
|
|
mgr.OnConnectionStateChange(
|
|
[&](
|
|
std::shared_ptr<EQ::Net::DaybreakConnection> conn,
|
|
EQ::Net::DbProtocolStatus from,
|
|
EQ::Net::DbProtocolStatus to
|
|
) {
|
|
if (EQ::Net::StatusConnected == to) {
|
|
EQ::Net::DynamicPacket p;
|
|
p.PutUInt16(0, 1); //OP_SessionReady
|
|
p.PutUInt32(2, 2);
|
|
c->QueuePacket(p);
|
|
}
|
|
else if (EQ::Net::StatusDisconnected == to) {
|
|
running = false;
|
|
}
|
|
}
|
|
);
|
|
|
|
mgr.OnPacketRecv(
|
|
[&](std::shared_ptr<EQ::Net::DaybreakConnection> conn, const EQ::Net::Packet &p) {
|
|
auto opcode = p.GetUInt16(0);
|
|
switch (opcode) {
|
|
case 0x0017: //OP_ChatMessage
|
|
{
|
|
size_t buffer_len =
|
|
in_account_username.length() + in_account_password.length() + 2;
|
|
std::unique_ptr<char[]> buffer(new char[buffer_len]);
|
|
|
|
strcpy(&buffer[0], in_account_username.c_str());
|
|
strcpy(&buffer[in_account_username.length() + 1], in_account_password.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);
|
|
c->QueuePacket(p);
|
|
break;
|
|
}
|
|
case 0x0018: {
|
|
auto encrypt_size = p.Length() - 12;
|
|
if (encrypt_size % 8 > 0) {
|
|
encrypt_size = (encrypt_size / 8) * 8;
|
|
}
|
|
|
|
std::unique_ptr<char[]> 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);
|
|
|
|
{
|
|
ret = response_error <= 101;
|
|
running = false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
);
|
|
|
|
EQ::Net::DNSLookup(
|
|
"login.eqemulator.net", 5999, false, [&](const std::string &addr) {
|
|
if (addr.empty()) {
|
|
ret = false;
|
|
running = false;
|
|
}
|
|
|
|
mgr.Connect(addr, 5999);
|
|
}
|
|
);
|
|
|
|
auto &loop = EQ::EventLoop::Get();
|
|
while (running) {
|
|
loop.Process();
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
);
|
|
|
|
return res.get();
|
|
}
|