extern "C" __declspec(dllexport) void __cdecl Encrypt(char *cData)
{
RSA *rsa = RSA::getInstance();
rsa->SetKey(tibia_rsa_key);
rsa->encrypt(cData);
}
/*
This method performs all the alice actions.
*/
BigInt Requester(BigInt message, BigInt signersPubKey, BigInt modulus)
{
//Initializing all the variables required
BigInt blindingFactor, encBlindingFactor, blindingFactorInverse, signedMessageWithBlindingFactor, encMessageWithBlindingFactor, messageWithSign,originalMessage;
//RSA which will have signers publicKey and modulus
RSA requesterRSA;
requesterRSA.setN(modulus);
requesterRSA.setPublicKey(signersPubKey);
//Generating a random blindfactor
blindingFactor = int(((double)std::rand()/RAND_MAX)*RAND_LIMIT32);
//Blind factor modulus inverse is calculated
blindingFactorInverse = modInverse(blindingFactor, modulus);
//Encrypting the blinding factor with signers public key
encBlindingFactor = requesterRSA.encrypt(blindingFactor);
//appending original message to the encrypted blindfactor
encMessageWithBlindingFactor = encBlindingFactor*message;
encMessageWithBlindingFactor = encMessageWithBlindingFactor%modulus;
//sending the encyrpted blindfactor and origin message to signer as product and get back the signed message with blinding factor
signedMessageWithBlindingFactor = Signer(encMessageWithBlindingFactor);
std::cout<<"Alice's(Sender's) Random Message generated: " << message.toHexString() <<std::endl;
std::cout<<"Encrypted Message sent to Bob with blindfactor and original message:" << encMessageWithBlindingFactor.toHexString() <<std::endl;
//removing the blindfactor
messageWithSign = (signedMessageWithBlindingFactor*blindingFactorInverse) % modulus;
std::cout<<"Signed Message recieved from Bob with blindfactor and original message:" << signedMessageWithBlindingFactor.toHexString() <<std::endl;
return messageWithSign;
}
BigInt sendtoAlice(BigInt pk,BigInt mod){
RSA Aliceobj;
Aliceobj.setN(mod);
Aliceobj.setPublicKey(pk);
randomno=int(((double)rand()/RAND_MAX)*LIMIT_RAND);//generate the random number
message=int(((double)rand()/RAND_MAX)*LIMIT_RAND);//generate the message
std::cout<<"\ninitialmessage="<<message.toHexString()<<std::endl;
BigInt encrandom=Aliceobj.encrypt(randomno);//encrypt the number in Bob's public key
BigInt mulmsg=encrandom*message;
mulmsg=mulmsg%mod;
return mulmsg;
}
void KClient::rsaAndDes(RSA rsa)
{
unsigned long long tempn,tempe,temp;
this->kcsSock.RecvMsg(this->sMsgBuf); //Recieve RSA n key
//cout<<"After recieve RSA"<<endl;
this->kpProto.ReadBuf(this->sMsgBuf);
this->enMode=this->kpProto.enMode; //Set encrypt mode
if(this->kpProto.m_cmd==RSAKEY)
{
cout<<"keybufn="<<this->kpProto.keybufn<<endl;
cout<<"keybufe="<<this->kpProto.keybufe<<endl;
}
int i;
tempn=0;
for(i=0;i<strlen(this->kpProto.keybufn);i++)
{
tempn=tempn*10+(this->kpProto.keybufn[i]-'0');
}
tempe=0;
for(i=0;i<strlen(this->kpProto.keybufe);i++)
{
tempe=tempe*10+(this->kpProto.keybufe[i]-'0');
}
rsa.setN(tempn);
rsa.setE(tempe);
time_t t=time(NULL);
char *key=ctime(&t);
strncpy(this->desKey, key, strlen(key));
this->desKey[strlen(key)]='\0';
int k=0;
for(i=0;i<strlen(this->desKey);i++)
{
temp=rsa.encry(this->desKey[i]);
char result2[24]="\0";
sprintf(result2,"%lld",temp);
for(int j=0;j<strlen(result2);j++)
{
this->kpProto.encryptDesKey[k++]=result2[j];
}
this->kpProto.encryptDesKey[k++]='a';
}
this->kpProto.encryptDesKey[k-1]='\0';
this->kpProto.m_cmd=DESKEY;
this->kpProto.WriteBuf(this->sMsgBuf);
this->kcsSock.SendMsg(this->sMsgBuf);
cout<<"des key="<<this->desKey<<endl;
cout<<"rsa encrpt des key="<<this->kpProto.encryptDesKey<<endl;
}
void sendtoAlice2(BigInt msg,BigInt pk,BigInt mod){
RSA verifyobj;//verification object
verifyobj.setN(mod);
verifyobj.setPublicKey(pk);
BigInt randomInv=modInverse(randomno,mod);
BigInt mulmsg=msg*randomInv;
std::cout<<"signedmessage="<<mulmsg.toHexString()<<std::endl;
BigInt signedmsg=mulmsg%mod;//the actual signature of the message
BigInt finalmessage=verifyobj.encrypt(signedmsg);
std::cout<<"finalmessage="<<finalmessage.toHexString()<<std::endl;
//check if matches with original message after decrypting
if(finalmessage==message){
std::cout<<"Initial and final messages are matching , hence verified\n\n"<<std::endl;
}
}
int main(int argc, char*argv[]){ /*********************************************************
* A Simple Driver
* *******************************************************
*/
unsigned long int *a;
unsigned long int arr[4];
a=&arr[0];
RSA myRSA;
BigInt message, cipher, deciphered;
message = int(((double)std::rand()/RAND_MAX)*RAND_LIMIT32);
message.toULong(a,4);
cipher = myRSA.encrypt(message);
deciphered = myRSA.decrypt(cipher);
std::cout<<*a<<std::endl;
// std::cout<<"message "<<message.toString();
std::cout<<"message: "<<message.toHexString()<<"\tcipher: "<<cipher.toHexString()<<"\tdeciphered: "<<deciphered.toHexString()<<std::endl;
}
int main()
{
mpz_t pN;
mpz_init(pN);
mpz_t puC;
mpz_init(puC);
mpz_t prU;
mpz_init(prU);
gmp_randstate_t state;
gmp_randinit_default(state);
mpz_t seed;
mpz_init(seed);
RSA KeyGenerator;
KeyGenerator.randInit(seed,"ahahah");
gmp_randseed(state,seed);
std::cout << "état : " <<state <<std::endl;
KeyGenerator.getKeys(pN, puC, prU, state);
std::cout << "public keys : " <<pN <<std::endl<<puC<<std::endl;
std::cout << "private keys : " <<pN <<std::endl<<prU<<std::endl;
gmp_randclear(state);
Message Chaine("s");
mpz_t code;
mpz_init(code);
std::string text1 = Chaine.encryptRSA(puC,pN);
//std::cout << "voici le texte crypté:"<<std::endl<<text1<<std::endl;
std::string text2 = Chaine.decryptRSA(prU, pN);
//std::cout << "voici le texte décrypté:"<<std::endl<<text2<<std::endl;
return 0;
}
int main(int argc, char*argv[]){
BigInt cipher, deciphered,message;
unsigned long int *a;
unsigned long int arr[10];
a=&arr[0];
BigInt pubkey, privatekey;
BigInt gnm;
//message=1000;
message = int(((double)(std::rand())/RAND_MAX)*RAND_LIMIT32);
for(int i=1;i<=10;i++)
{
sleep(1);
std::cout<<std::endl<<"RSA "<<i<<std::endl;
RSA newrsa; // default , no args, program generates its own p and q
std::cout<<"Public Key ";
pubkey= newrsa.getPublicKey();
pubkey.toULong(a,4);
std::cout<<*a<<std::endl;
privatekey=newrsa.getPrivateKey();
privatekey.toULong(a,4);
std::cout<<"Private Key : "<<*a<<std::endl;
gnm = newrsa.getModulus();
std::cout<<"N is "<<gnm.toHexString()<<std::endl;
cipher = newrsa.encrypt(message);
deciphered = newrsa.decrypt(cipher);
std::cout<<"message: "<<message.toHexString()<<"\tcipher: "<<cipher.toHexString()<<"\tdeciphered: "<<deciphered.toHexString()<<std::endl<<std::endl;
}
}
void RSA::atacar() {
long long pAtacado, qAtacado;
this->generarListaDePrimos();
list<int>::iterator it1 = primos.begin();
list<int>::iterator it2 = primos.begin();
it2++;
bool fin = false;
while ((!fin) && (it1!= primos.end())) {
while (it2!= primos.end() && (!fin)) {
long long supuestoN= *it1*(*it2);
if (supuestoN==this->n) {
pAtacado=*it1;
qAtacado=*it2;
fin=true;
}
else it2++;
}
if (!fin) {
it1++;
it2=it1;
it2++;
}
}
cout << "Vulnerado!!!" << endl;
cout << "El p es= " << pAtacado << endl;
cout << "El q es= " << qAtacado << endl;
RSA* unRSA = new RSA();
for (int i=0; i<6; i++) {
unRSA->fila1.push_back(0);
unRSA->fila2.push_back(0);
}
unRSA->setP(pAtacado);
unRSA->setQ(qAtacado);
unRSA->calcularN();
cout << "N= " << this->n << endl;
unRSA->calcularPhi();
unRSA->setD(this->d);
cout << "D: "<< this->d <<endl;
unRSA->calcularEATAQUE();
cout << "E= " << this->e << endl;
delete unRSA;
cout << "Con estos datos puede crearse el archivo clavePrivada.txt y vulnerarse la seguridad" << endl;
}
void ProtocolAdmin::parsePacket(NetworkMessage& msg)
{
if (g_game.getGameState() == GAME_STATE_SHUTDOWN) {
getConnection()->closeConnection();
return;
}
uint8_t recvbyte = msg.GetByte();
OutputMessagePool* outputPool = OutputMessagePool::getInstance();
OutputMessage_ptr output = outputPool->getOutputMessage(this, false);
if (!output) {
return;
}
switch (m_state) {
case ENCRYPTION_NO_SET: {
if (g_adminConfig->requireEncryption()) {
if ((time(NULL) - m_startTime) > 30000) {
getConnection()->closeConnection();
addLogLine(this, LOGTYPE_WARNING, 1, "encryption timeout");
return;
}
if (recvbyte != AP_MSG_ENCRYPTION && recvbyte != AP_MSG_KEY_EXCHANGE) {
output->AddByte(AP_MSG_ERROR);
output->AddString("encryption needed");
outputPool->send(output);
getConnection()->closeConnection();
addLogLine(this, LOGTYPE_WARNING, 1, "wrong command while ENCRYPTION_NO_SET");
return;
}
break;
} else {
m_state = NO_LOGGED_IN;
}
}
case NO_LOGGED_IN: {
if (g_adminConfig->requireLogin()) {
if ((time(NULL) - m_startTime) > 30000) {
//login timeout
getConnection()->closeConnection();
addLogLine(this, LOGTYPE_WARNING, 1, "login timeout");
return;
}
if (m_loginTries > 3) {
output->AddByte(AP_MSG_ERROR);
output->AddString("too many login tries");
outputPool->send(output);
getConnection()->closeConnection();
addLogLine(this, LOGTYPE_WARNING, 1, "too many login tries");
return;
}
if (recvbyte != AP_MSG_LOGIN) {
output->AddByte(AP_MSG_ERROR);
output->AddString("you are not logged in");
outputPool->send(output);
getConnection()->closeConnection();
addLogLine(this, LOGTYPE_WARNING, 1, "wrong command while NO_LOGGED_IN");
return;
}
break;
} else {
m_state = LOGGED_IN;
}
}
case LOGGED_IN: {
//can execute commands
break;
}
default: {
getConnection()->closeConnection();
return;
}
}
m_lastCommand = time(NULL);
switch (recvbyte) {
case AP_MSG_LOGIN: {
if (m_state == NO_LOGGED_IN && g_adminConfig->requireLogin()) {
std::string password = msg.GetString();
if (g_adminConfig->passwordMatch(password)) {
m_state = LOGGED_IN;
output->AddByte(AP_MSG_LOGIN_OK);
addLogLine(this, LOGTYPE_EVENT, 1, "login ok");
} else {
m_loginTries++;
output->AddByte(AP_MSG_LOGIN_FAILED);
output->AddString("wrong password");
addLogLine(this, LOGTYPE_WARNING, 1, "login failed.(" + password + ")");
}
} else {
output->AddByte(AP_MSG_LOGIN_FAILED);
output->AddString("can not login");
addLogLine(this, LOGTYPE_WARNING, 1, "wrong state at login");
}
break;
}
case AP_MSG_ENCRYPTION: {
if (m_state == ENCRYPTION_NO_SET && g_adminConfig->requireEncryption()) {
uint8_t keyType = msg.GetByte();
if (keyType == ENCRYPTION_RSA1024XTEA) {
RSA* rsa = g_adminConfig->getRSAKey(ENCRYPTION_RSA1024XTEA);
if (!rsa) {
output->AddByte(AP_MSG_ENCRYPTION_FAILED);
addLogLine(this, LOGTYPE_WARNING, 1, "no valid server key type");
break;
}
if (RSA_decrypt(rsa, msg)) {
m_state = NO_LOGGED_IN;
uint32_t k[4];
k[0] = msg.GetU32();
k[1] = msg.GetU32();
k[2] = msg.GetU32();
k[3] = msg.GetU32();
//use for in/out the new key we have
enableXTEAEncryption();
setXTEAKey(k);
output->AddByte(AP_MSG_ENCRYPTION_OK);
addLogLine(this, LOGTYPE_EVENT, 1, "encryption ok");
} else {
output->AddByte(AP_MSG_ENCRYPTION_FAILED);
output->AddString("wrong encrypted packet");
addLogLine(this, LOGTYPE_WARNING, 1, "wrong encrypted packet");
}
} else {
output->AddByte(AP_MSG_ENCRYPTION_FAILED);
output->AddString("no valid key type");
addLogLine(this, LOGTYPE_WARNING, 1, "no valid client key type");
}
} else {
output->AddByte(AP_MSG_ENCRYPTION_FAILED);
output->AddString("can not set encryption");
addLogLine(this, LOGTYPE_EVENT, 1, "can not set encryption");
}
break;
}
case AP_MSG_KEY_EXCHANGE: {
if (m_state == ENCRYPTION_NO_SET && g_adminConfig->requireEncryption()) {
uint8_t keyType = msg.GetByte();
if (keyType == ENCRYPTION_RSA1024XTEA) {
RSA* rsa = g_adminConfig->getRSAKey(ENCRYPTION_RSA1024XTEA);
if (!rsa) {
output->AddByte(AP_MSG_KEY_EXCHANGE_FAILED);
addLogLine(this, LOGTYPE_WARNING, 1, "no valid server key type");
break;
}
output->AddByte(AP_MSG_KEY_EXCHANGE_OK);
output->AddByte(ENCRYPTION_RSA1024XTEA);
char RSAPublicKey[128];
rsa->getPublicKey(RSAPublicKey);
output->AddBytes(RSAPublicKey, 128);
} else {
output->AddByte(AP_MSG_KEY_EXCHANGE_FAILED);
addLogLine(this, LOGTYPE_WARNING, 1, "no valid client key type");
}
} else {
output->AddByte(AP_MSG_KEY_EXCHANGE_FAILED);
output->AddString("can not get public key");
addLogLine(this, LOGTYPE_WARNING, 1, "can not get public key");
}
break;
}
case AP_MSG_COMMAND: {
if (m_state != LOGGED_IN) {
addLogLine(this, LOGTYPE_ERROR, 1, "recvbyte == AP_MSG_COMMAND && m_state != LOGGED_IN !!!");
// We should never reach this point
break;
}
uint8_t command = msg.GetByte();
switch (command) {
case CMD_BROADCAST: {
const std::string message = msg.GetString();
addLogLine(this, LOGTYPE_EVENT, 1, "broadcast: " + message);
g_dispatcher.addTask(createTask(boost::bind(&Game::broadcastMessage, &g_game, message, MSG_STATUS_WARNING)));
output->AddByte(AP_MSG_COMMAND_OK);
break;
}
case CMD_CLOSE_SERVER: {
g_dispatcher.addTask(createTask(boost::bind(&ProtocolAdmin::adminCommandCloseServer, this)));
break;
}
case CMD_PAY_HOUSES: {
g_dispatcher.addTask(createTask(boost::bind(&ProtocolAdmin::adminCommandPayHouses, this)));
break;
}
case CMD_OPEN_SERVER: {
g_dispatcher.addTask(createTask(boost::bind(&ProtocolAdmin::adminCommandOpenServer, this)));
break;
}
case CMD_SHUTDOWN_SERVER: {
g_dispatcher.addTask(createTask(boost::bind(&ProtocolAdmin::adminCommandShutdownServer, this)));
getConnection()->closeConnection();
return;
}
case CMD_KICK: {
const std::string name = msg.GetString();
g_dispatcher.addTask(createTask(boost::bind(&ProtocolAdmin::adminCommandKickPlayer, this, name)));
break;
}
case CMD_SETOWNER: {
const std::string param = msg.GetString();
g_dispatcher.addTask(createTask(boost::bind(&ProtocolAdmin::adminCommandSetOwner, this, param)));
break;
}
default: {
output->AddByte(AP_MSG_COMMAND_FAILED);
output->AddString("not known server command");
addLogLine(this, LOGTYPE_WARNING, 1, "not known server command");
break;
}
}
break;
}
case AP_MSG_PING: {
output->AddByte(AP_MSG_PING_OK);
break;
}
default: {
output->AddByte(AP_MSG_ERROR);
output->AddString("not known command byte");
addLogLine(this, LOGTYPE_WARNING, 1, "not known command byte");
break;
}
}
if (output->getMessageLength() > 0) {
outputPool->send(output);
}
}
void mainLoader(int, char*[], ServiceManager* services)
{
//dispatcher thread
g_game.setGameState(GAME_STATE_STARTUP);
srand(static_cast<unsigned int>(OTSYS_TIME()));
#ifdef _WIN32
SetConsoleTitle(STATUS_SERVER_NAME);
#endif
std::cout << "The " << STATUS_SERVER_NAME << " Version: (" << STATUS_SERVER_VERSION << "." << MINOR_VERSION << " . " << REVISION_VERSION << ") - Codename: ( " << SOFTWARE_CODENAME << " )" << std::endl;
std::cout << "Compiled with: " << BOOST_COMPILER << std::endl;
std::cout << "Compiled on " << __DATE__ << ' ' << __TIME__ << " for platform ";
#if defined(__amd64__) || defined(_M_X64)
std::cout << "x64" << std::endl;
#elif defined(__i386__) || defined(_M_IX86) || defined(_X86_)
std::cout << "x86" << std::endl;
#elif defined(__arm__)
std::cout << "ARM" << std::endl;
#else
std::cout << "unknown" << std::endl;
#endif
std::cout << std::endl;
std::cout << "A server developed by " << STATUS_SERVER_DEVELOPERS << "." << std::endl;
std::cout << "Visit our forum for updates, support, and resources: " << GIT_REPO <<"." << std::endl;
std::cout << std::endl;
// read global config
std::cout << ">> Loading config" << std::endl;
if (!g_config.load()) {
startupErrorMessage("Unable to load config.lua!");
return;
}
#ifdef _WIN32
const std::string& defaultPriority = g_config.getString(ConfigManager::DEFAULT_PRIORITY);
if (strcasecmp(defaultPriority.c_str(), "high") == 0) {
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
} else if (strcasecmp(defaultPriority.c_str(), "above-normal") == 0) {
SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS);
}
#endif
//set RSA key
const char* p("14299623962416399520070177382898895550795403345466153217470516082934737582776038882967213386204600674145392845853859217990626450972452084065728686565928113");
const char* q("7630979195970404721891201847792002125535401292779123937207447574596692788513647179235335529307251350570728407373705564708871762033017096809910315212884101");
g_RSA.setKey(p, q);
std::cout << ">> Establishing database connection..." << std::flush;
Database* db = Database::getInstance();
if (!db->connect()) {
startupErrorMessage("Failed to connect to database.");
return;
}
std::cout << " MySQL " << Database::getClientVersion() << std::endl;
// run database manager
std::cout << ">> Running database manager" << std::endl;
if (!DatabaseManager::isDatabaseSetup()) {
startupErrorMessage("The database you have specified in config.lua is empty, please import the schema.sql to your database.");
return;
}
g_databaseTasks.start();
DatabaseManager::updateDatabase();
if (g_config.getBoolean(ConfigManager::OPTIMIZE_DATABASE) && !DatabaseManager::optimizeTables()) {
std::cout << "> No tables were optimized." << std::endl;
}
//load vocations
std::cout << ">> Loading vocations" << std::endl;
if (!g_vocations.loadFromXml()) {
startupErrorMessage("Unable to load vocations!");
return;
}
// load item data
std::cout << ">> Loading items" << std::endl;
if (Item::items.loadFromOtb("data/items/items.otb") != ERROR_NONE) {
startupErrorMessage("Unable to load items (OTB)!");
return;
}
if (!Item::items.loadFromXml()) {
startupErrorMessage("Unable to load items (XML)!");
return;
}
std::cout << ">> Loading script systems" << std::endl;
if (!ScriptingManager::getInstance()->loadScriptSystems()) {
startupErrorMessage("Failed to load script systems");
return;
}
std::cout << ">> Loading monsters" << std::endl;
if (!g_monsters.loadFromXml()) {
startupErrorMessage("Unable to load monsters!");
return;
}
std::cout << ">> Loading outfits" << std::endl;
Outfits* outfits = Outfits::getInstance();
if (!outfits->loadFromXml()) {
startupErrorMessage("Unable to load outfits!");
return;
}
std::cout << ">> Checking world type... " << std::flush;
std::string worldType = asLowerCaseString(g_config.getString(ConfigManager::WORLD_TYPE));
if (worldType == "pvp") {
g_game.setWorldType(WORLD_TYPE_PVP);
} else if (worldType == "no-pvp") {
g_game.setWorldType(WORLD_TYPE_NO_PVP);
} else if (worldType == "pvp-enforced") {
g_game.setWorldType(WORLD_TYPE_PVP_ENFORCED);
} else {
std::cout << std::endl;
std::ostringstream ss;
ss << "> ERROR: Unknown world type: " << g_config.getString(ConfigManager::WORLD_TYPE) << ", valid world types are: pvp, no-pvp and pvp-enforced.";
startupErrorMessage(ss.str());
return;
}
std::cout << asUpperCaseString(worldType) << std::endl;
std::cout << ">> Loading map" << std::endl;
if (!g_game.loadMainMap(g_config.getString(ConfigManager::MAP_NAME))) {
startupErrorMessage("Failed to load map");
return;
}
std::cout << ">> Initializing gamestate" << std::endl;
g_game.setGameState(GAME_STATE_INIT);
// Game client protocols
services->add<ProtocolGame>(g_config.getNumber(ConfigManager::GAME_PORT));
services->add<ProtocolLogin>(g_config.getNumber(ConfigManager::LOGIN_PORT));
// OT protocols
services->add<ProtocolStatus>(g_config.getNumber(ConfigManager::STATUS_PORT));
// Legacy login protocol
services->add<ProtocolOld>(g_config.getNumber(ConfigManager::LOGIN_PORT));
RentPeriod_t rentPeriod;
std::string strRentPeriod = asLowerCaseString(g_config.getString(ConfigManager::HOUSE_RENT_PERIOD));
if (strRentPeriod == "yearly") {
rentPeriod = RENTPERIOD_YEARLY;
} else if (strRentPeriod == "weekly") {
rentPeriod = RENTPERIOD_WEEKLY;
} else if (strRentPeriod == "monthly") {
rentPeriod = RENTPERIOD_MONTHLY;
} else if (strRentPeriod == "daily") {
rentPeriod = RENTPERIOD_DAILY;
} else {
rentPeriod = RENTPERIOD_NEVER;
}
g_game.map.houses.payHouses(rentPeriod);
IOMarket::checkExpiredOffers();
IOMarket::getInstance()->updateStatistics();
std::cout << ">> Loaded all modules, server starting up..." << std::endl;
#ifndef _WIN32
if (getuid() == 0 || geteuid() == 0) {
std::cout << "> Warning: " << STATUS_SERVER_NAME << " has been executed as root user, please consider running it as a normal user." << std::endl;
}
#endif
g_game.start(services);
g_game.setGameState(GAME_STATE_NORMAL);
g_loaderSignal.notify_all();
}
void mainLoader(int, char*[], ServiceManager* services)
{
srand(static_cast<unsigned int>(OTSYS_TIME()));
#ifdef _WIN32
SetConsoleTitle(STATUS_SERVER_NAME);
#endif
std::cout << STATUS_SERVER_NAME << " - Version " << STATUS_SERVER_VERSION << std::endl;
std::cout << "Compiled with " << BOOST_COMPILER << std::endl;
std::cout << "Compiled on " << __DATE__ << ' ' << __TIME__ << " for platform ";
#if defined(__amd64__) || defined(_M_X64)
std::cout << "x64" << std::endl;
#elif defined(__i386__) || defined(_M_IX86) || defined(_X86_)
std::cout << "x86" << std::endl;
#elif defined(__arm__)
std::cout << "ARM" << std::endl;
#else
std::cout << "unknown" << std::endl;
#endif
std::cout << std::endl;
std::cout << "A server developed by " << STATUS_SERVER_DEVELOPERS << std::endl;
std::cout << "Visit our forum for updates, support, and resources: http://otland.net/." << std::endl;
std::cout << std::endl;
// read global config
std::cout << ">> Loading config" << std::endl;
if (!g_config.load()) {
startupErrorMessage("Unable to load config.lua!");
return;
}
std::cout << ">> Loading gameserver config..." << std::endl;
if (!g_gameserver.load()) {
startupErrorMessage("Unable to load gameservers!");
return;
}
#ifdef _WIN32
const std::string& defaultPriority = g_config.getString(ConfigManager::DEFAULT_PRIORITY);
if (strcasecmp(defaultPriority.c_str(), "high") == 0) {
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
} else if (strcasecmp(defaultPriority.c_str(), "above-normal") == 0) {
SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS);
}
#endif
//set RSA key
const char* p("14299623962416399520070177382898895550795403345466153217470516082934737582776038882967213386204600674145392845853859217990626450972452084065728686565928113");
const char* q("7630979195970404721891201847792002125535401292779123937207447574596692788513647179235335529307251350570728407373705564708871762033017096809910315212884101");
g_RSA.setKey(p, q);
std::cout << ">> Establishing database connection..." << std::flush;
Database* db = Database::getInstance();
if (!db->connect()) {
startupErrorMessage("Failed to connect to database.");
return;
}
std::cout << " MySQL " << Database::getClientVersion() << std::endl;
// run database manager
std::cout << ">> Running database manager" << std::endl;
if (!DatabaseManager::isDatabaseSetup()) {
startupErrorMessage("The database you have specified in config.lua is empty, please import the schema.sql to your database.");
return;
}
g_databaseTasks.start();
if (g_config.getBoolean(ConfigManager::OPTIMIZE_DATABASE) && !DatabaseManager::optimizeTables()) {
std::cout << "> No tables were optimized." << std::endl;
}
services->add<ProtocolLogin>(g_config.getNumber(ConfigManager::LOGIN_PORT));
services->add<ProtocolOld>(g_config.getNumber(ConfigManager::LOGIN_PORT));
std::cout << ">> Loaded all modules, server starting up..." << std::endl;
#ifndef _WIN32
if (getuid() == 0 || geteuid() == 0) {
std::cout << "> Warning: " << STATUS_SERVER_NAME << " has been executed as root user, please consider running it as a normal user." << std::endl;
}
#endif
g_loaderSignal.notify_all();
}
/**
testing.
*/
int mainCryptopp(const char* encryptPath, const char* decryptPath)
{
printf("/***************************************************************************\n");
printf("C++ crypto, wrap cryptopp interface, reference to www.cryptopp.com\n");
printf("[email protected] 2006-5-25\n");
printf("***************************************************************************/\n");
// base64 testing.
{
printf("\n=======================base64=====================\n");
// input data.
const char * indata = "bsmith is a good guy.";
int inlen = (int)strlen(indata);
printf("inlen=%d\n", inlen);
printf("indata(hex)=");
dump(indata, inlen);
// encoding ...
int maxoutlen = Base64::getCipherLen(inlen);
printf("maxoutlen=%d\n", maxoutlen);
char * outdata = new char[maxoutlen];
int outlen = Base64::encode(indata, inlen, outdata);
printf("outlen=%d\n", outlen);
printf("outdata(hex)=");
dump(outdata, outlen);
// encoded base64 string.
char * outstr = new char[outlen+1];
memcpy(outstr, outdata, outlen);
outstr[outlen] = 0x00;
printf("outstr=%s\n", outstr);
// decoding ...
int maxinlen = Base64::getPlainLen(outlen);
printf("maxinlen=%d\n", maxinlen);
char * orgdata = new char[maxinlen];
int orglen = Base64::decode(outdata, outlen, orgdata);
printf("orglen=%d\n", orglen);
printf("orgdata(hex)=");
dump(orgdata, orglen);
delete[] outdata;
delete[] outstr;
delete[] orgdata;
}
// base16 testing.
{
printf("\n=======================base16=====================\n");
// input data.
const char * indata = "bsmith is a good guy.";
int inlen = (int)strlen(indata);
printf("inlen=%d\n", inlen);
printf("indata(hex)=");
dump(indata, inlen);
// encoding ...
int maxoutlen = Base16::getCipherLen(inlen);
printf("maxoutlen=%d\n", maxoutlen);
char * outdata = new char[maxoutlen];
int outlen = Base16::encode(indata, inlen, outdata);
printf("outlen=%d\n", outlen);
printf("outdata(hex)=");
dump(outdata, outlen);
// encoded base16 string.
char * outstr = new char[outlen+1];
memcpy(outstr, outdata, outlen);
outstr[outlen] = 0x00;
printf("outstr=%s\n", outstr);
// decoding ...
int maxinlen = Base16::getPlainLen(outlen);
printf("maxinlen=%d\n", maxinlen);
char * orgdata = new char[maxinlen];
int orglen = Base16::decode(outdata, outlen, orgdata);
printf("orglen=%d\n", orglen);
printf("orgdata(hex)=");
dump(orgdata, orglen);
delete[] outdata;
delete[] outstr;
delete[] orgdata;
}
// RSA testing.
{
printf("\n=======================RSA PKCS #1=====================\n");
// key
// N factor in RSA, aslo called modulus.
const char * N = "90755611487566208138950675092879865387596685014726501531250157258482495478524769456222913843665634824684037468817980814231054856125127115894189385717148934026931120932481402379431731629550862846041784305274651476086892165805223719552575599962253392248079811268061946102234935422772131475340988882825043233323";
// e factor in RSA, aslo called public exponent.
const char * e = "65537";
// d factor in RSA, aslo called private exponent
const char * d = "17790520481266507102264359414044396762660094486842415203197747383916331528947124726552875080482359744765793816651732601742929364124685415229452844016482477236658413327331659722342187036963943428678684677279032263501011143882814728160215380051287503219732737197808611144507720521201393129692996926599975297921";
// input data.
const char * indata = "bsmith is a good guy.";
int inlen = (int)strlen(indata);
printf("inlen=%d\n", inlen);
printf("indata(hex)=");
dump(indata, inlen);
// init RSA public key encryptor.
RSA enc;
enc.initPublicKey(N, e);
// encrypt.
int maxoutlen = enc.getCipherLen(inlen);
printf("maxoutlen=%d\n", maxoutlen);
char * outdata = new char[maxoutlen];
int outlen = enc.encrypt(indata, inlen, outdata);
printf("outlen=%d\n", outlen);
printf("outdata(hex)=");
dump(outdata, outlen);
// init private for RSA decryptor.
RSA dec;
dec.initPrivateKey(N, e, d);
// decrypt.
int maxinlen = dec.getPlainLen(outlen);
printf("maxinlen=%d\n", maxinlen);
char * orgdata = new char[maxinlen];
int orglen = dec.decrypt(outdata, outlen, orgdata);
printf("orglen=%d\n", orglen);
printf("orgdata(hex)=");
dump(orgdata, orglen);
delete[] outdata;
delete[] orgdata;
}
// AES/CBC/PKCS5Padding testing.
{
printf("\n=======================AES/CBC/PKCS5Padding=====================\n");
// key
const char * key = "0123456789abcdef";
// iv
const char * iv = "fedcba9876543210";
// init AES.
AES aes;
aes.init(key, 16, iv);
// input data.
// const char * indata = "bsmith is a good guy.";
// const char * indata = "bsmith.";
const char * indata = "I am a good guy.";
int inlen = (int)strlen(indata);
printf("inlen=%d\n", inlen);
printf("indata(hex)=");
dump(indata, inlen);
// encrypt.
int maxoutlen = aes.getCipherLen(inlen);
printf("maxoutlen=%d\n", maxoutlen);
char * outdata = new char[maxoutlen];
int outlen = 0;
{
outlen = aes.encrypt(indata, inlen, outdata);
printf("outlen=%d\n", outlen);
printf("outdata(hex)=");
dump(outdata, outlen);
}
{
outlen = aes.encrypt(indata, inlen, outdata);
printf("outlen=%d\n", outlen);
printf("outdata(hex)=");
dump(outdata, outlen);
}
// decrypt.
int maxinlen = aes.getPlainLen(outlen);
printf("maxinlen=%d\n", maxinlen);
char * orgdata = new char[maxinlen];
{
int orglen = aes.decrypt(outdata, outlen, orgdata);
printf("orglen=%d\n", orglen);
printf("orgdata(hex)=");
dump(orgdata, orglen);
}
{
int orglen = aes.decrypt(outdata, outlen, orgdata);
printf("orglen=%d\n", orglen);
printf("orgdata(hex)=");
dump(orgdata, orglen);
}
delete[] outdata;
delete[] orgdata;
}
// SHA1 testing.
{
printf("\n=======================SHA1=====================\n");
SHA1 sha1;
// input data.
const char * indata = "bsmith is a good guy.";
int inlen = (int)strlen(indata);
printf("inlen=%d\n", inlen);
printf("indata(hex)=");
dump(indata, inlen);
// one time digest.
{
char * outdata = new char[sha1.getCipherLen(inlen)];
int outlen = sha1.digest(indata, inlen, outdata);
printf("outlen=%d\n", outlen);
printf("outdata(hex)=");
dump(outdata, outlen);
delete[] outdata;
}
// serval times
{
char * outdata = new char[sha1.getCipherLen(inlen)];
sha1.update(indata, 5);
sha1.update(indata+5, inlen-5);
int outlen = sha1.final(outdata);
printf("outlen=%d\n", outlen);
printf("outdata(hex)=");
dump(outdata, outlen);
delete[] outdata;
}
// one time digest.
{
char * outdata = new char[sha1.getCipherLen(inlen)];
int outlen = sha1.digest(indata, inlen, outdata);
printf("outlen=%d\n", outlen);
printf("outdata(hex)=");
dump(outdata, outlen);
delete[] outdata;
}
// serval times
{
char * outdata = new char[sha1.getCipherLen(inlen)];
sha1.update(indata, 5);
sha1.update(indata+5, inlen-5);
int outlen = sha1.final(outdata);
printf("outlen=%d\n", outlen);
printf("outdata(hex)=");
dump(outdata, outlen);
delete[] outdata;
}
}
// RSA-SHA1 Sign testing.
{
printf("\n=======================RSA-SHA1 Sign=====================\n");
// key
// N factor in RSA, aslo called modulus.
const char * N = "90755611487566208138950675092879865387596685014726501531250157258482495478524769456222913843665634824684037468817980814231054856125127115894189385717148934026931120932481402379431731629550862846041784305274651476086892165805223719552575599962253392248079811268061946102234935422772131475340988882825043233323";
// e factor in RSA, aslo called public exponent.
const char * e = "65537";
// d factor in RSA, aslo called private exponent
const char * d = "17790520481266507102264359414044396762660094486842415203197747383916331528947124726552875080482359744765793816651732601742929364124685415229452844016482477236658413327331659722342187036963943428678684677279032263501011143882814728160215380051287503219732737197808611144507720521201393129692996926599975297921";
// input data.
const char * indata = "bsmith is a good guy.";
int inlen = (int)strlen(indata);
printf("inlen=%d\n", inlen);
printf("indata(hex)=");
dump(indata, inlen);
Sign sign;
// private key for signer.
sign.initPrivateKey(N, e, d);
// sign.
int maxoutlen = sign.getCipherLen(inlen);
printf("maxoutlen=%d\n", maxoutlen);
char * outdata = new char[maxoutlen];
int outlen = sign.sign(indata, inlen, outdata);
printf("outlen=%d\n", outlen);
printf("outdata(hex)=");
dump(outdata, outlen);
// public key for verifier.
sign.initPublicKey(N, e);
// verify.
{
bool res = sign.verify(indata, inlen, outdata, outlen);
printf("result <?> true : %s\n", res?"true":"false");
}
// another data.
const char * indata1 = "bsmith is not a good guy.";
int inlen1 = (int)strlen(indata1);
{
bool res = sign.verify(indata1, inlen1, outdata, outlen);
printf("result <?> false : %s\n", res?"true":"false");
}
delete[] outdata;
}
//printf("press any key to exit!");
//getchar();
{
//my test
unsigned long decryptSize = 0;
char* decryptBuffer = (char*)getFileData(decryptPath, &decryptSize);
unsigned long encryptSize = 0;
char* encryptBuffer = (char*)getFileData(encryptPath, &encryptSize);
printf("decryptBuffer(hex)=");
dump(decryptBuffer, decryptSize);
// key
const char * key = "0123456789abcdef";
// iv
const char * iv = "fedcba9876543210";
// init AES.
AES aes;
aes.init(key, 16, iv);
{
// decrypt.
int maxinlen = aes.getPlainLen(encryptSize);
char * orgdata = new char[maxinlen];
{
int orglen = aes.decrypt(encryptBuffer, encryptSize, orgdata);
printf("decryptWithCrypto++(hex)=");
dump(orgdata, orglen);
}
delete [] orgdata;
}
printf("encryptBuffer(hex)=");
dump(encryptBuffer, encryptSize);
{
// encrypt.
int maxoutlen = aes.getCipherLen(decryptSize);
char * outdata = new char[maxoutlen];
int outlen = 0;
{
outlen = aes.encrypt(decryptBuffer, decryptSize, outdata);
printf("encryptWithCrypto++(hex)=");
dump(outdata, outlen);
}
delete [] outdata;
}
delete [] decryptBuffer;
delete [] encryptBuffer;
}
return 0;
}
int main(int argc, char*argv[])
{
RSA* _RSA_obj[10];
BigInt _message, _encrypt, _decrypt;
int _primeNumber[] = { 40343,40351,40357,40361,40387,40423,40427,40429,40433,40459,40471,40483,40487,40493,40499,40507,40519,40529,40531};
int _nonPrimeNumber[] = {36782,36792,36792,36802,36822,36832,36842,36852,36872,36872,37692,37692,37692,37722,37742,37712,37782,37792,37812,37814};
cout << "1)------------------Encryption and Decryption using RSA----------------------"<<"\n";
//------------No arguments RSA --------------------------------------------
cout << "a) 10 instances of RSA routine(argument-less) encryption-decryption"<<"\n";
for (int i = 0; i < 10; i++)
{
_RSA_obj[i] = new RSA();
usleep(21000);
_message = int(((double) rand() / RAND_MAX)*RAND_GEN32);
_encrypt = _RSA_obj[i]->encrypt(_message);
_decrypt = _RSA_obj[i]->decrypt(_encrypt);
cout << "Message: " << _message.toHexString() << "\t\tEncrypted: " << _encrypt.toHexString() << "\t\tDecrypted: " << _decrypt.toHexString()<<"\n";
}
cout<<"\n";
//------------1 prime number RSA --------------------------------------------
cout << "b) 5 RSA instances(1 prime number(>30,000) as argument) encryption-decryption "<<"\n";
for (int i = 0; i < 5; i++)
{
_RSA_obj[i] = new RSA(_primeNumber[i]);
usleep(450000);
_message = int(((double) rand() / RAND_MAX)*RAND_GEN32);
_encrypt = _RSA_obj[i]->encrypt(_message);
_decrypt = _RSA_obj[i]->decrypt(_encrypt);
cout << "Message: " << _message.toHexString() << "\t\tEncrypted: " << _encrypt.toHexString() << "\t\tDecrypted: " << _decrypt.toHexString()<<"\n";
}
cout<<"\n";
//------------2 prime numbers RSA --------------------------------------------
cout << "c) 5 RSA instances(2 prime numbers(>30,000) as arguments) encryption-decryption "<<"\n";
for (int i = 0; i < 5; i++)
{
_RSA_obj[i] = new RSA(_primeNumber[i], _primeNumber[10-i]);
usleep(450000);
_message = int(((double) rand() / RAND_MAX)*RAND_GEN32);
_encrypt = _RSA_obj[i]->encrypt(_message);
_decrypt = _RSA_obj[i]->decrypt(_encrypt);
cout << "Message: " << _message.toHexString() << "\tEncrypted: " << _encrypt.toHexString() << "\tDecrypted: " << _decrypt.toHexString()<<"\n";
}
cout<<"\n";
//--------------2 non prime numbers RSA-------------------------------------
cout << "d) 5 RSA instances(2 non prime numbers(>30,000) as arguments) encryption-decryption "<<"\n";
for (int i = 0; i < 10; i++)
{
_RSA_obj[i] = new RSA(_nonPrimeNumber[i], _nonPrimeNumber[10-i]);
usleep(50000);
_message = int(((double) rand() / RAND_MAX)*RAND_GEN32);
_encrypt = _RSA_obj[i]->encrypt(_message);
_decrypt = _RSA_obj[i]->decrypt(_encrypt);
cout << "Message: " << _message.toHexString() << "\tEncrypted: " << _encrypt.toHexString() << "\tDecrypted: " << _decrypt.toHexString()<<"\n";
}
cout<<"\n";
//--------------challenge response scheme---------------------------------------
cout << "2)--------------------Challenge response scheme--------------------" << "\n";
RSA obj1, obj2;
BigInt rsaPK = obj1.getPublicKey();
BigInt rsaN = obj1.getModulus();
obj2.setPublicKey(rsaPK);
obj2.setN(rsaN);
//random message
_message = int(((double) rand() / RAND_MAX)*RAND_GEN32);
BigInt encrypt = obj2.encrypt(_message);
BigInt decrypt = obj1.decrypt(encrypt);
cout << "Plain Text:" << _message.toHexString() << "\tDecrypted Text:" << decrypt.toHexString() << "\n";
if (_message.operator==(decrypt))
cout << "Challenge response scheme is Successful" << "\n";
else
cout << "Challenge response scheme is Unsuccessful" << "\n";
cout << "\n";
//--------------Blind signature---------------------------------------
cout << "3)------------------Blind signature---------------------" << "\n";
RSA obj;
BigInt bobN = obj.getModulus();
BigInt bobPK = obj.getPublicKey();
// Generate random number and its inverse
double AliceRandomNo = double(((double) rand() / RAND_MAX)*RAND_GEN32);
BigInt rnd(AliceRandomNo);
BigInt AliceRandomNoInverse = RSAUtil::modInverse(rnd, bobN);
//random message
_message = int(((double) rand() / RAND_MAX)*RAND_GEN32);
BigInt encryptRandom = RSAUtil::modPow(rnd, bobPK, bobN);
BigInt messageToRSAobj = encryptRandom.operator*(_message).operator%(bobN);
BigInt messageFromRSAobj = getDecryptedMessageFromRSA_obj(messageToRSAobj, obj);
BigInt sign = messageFromRSAobj.operator*(AliceRandomNoInverse).operator%(bobN);
BigInt flag = RSAUtil::modPow(sign, bobPK, bobN);
cout << "message: " << _message.toHexString() << "\tsignature: " << sign.toHexString() << "\tdecrypted: " << flag.toHexString() << "\n";
cout << "\nBlind signature: ";
if(_message.operator==(flag))
cout << "Blind signature Successful" <<"\n";
else
cout << "Blind signature Unsuccessful" << "\n";
//--------------------------------------end of main--------------------
cout<<"\n";
return 0;
}
void mainLoader(int, char*[], ServiceManager* services)
{
//dispatcher thread
g_game.setGameState(GAME_STATE_STARTUP);
srand(static_cast<unsigned int>(OTSYS_TIME()));
#ifdef _WIN32
SetConsoleTitle(STATUS_SERVER_NAME);
#endif
std::cout << STATUS_SERVER_NAME << " - Versao " << STATUS_SERVER_VERSION << std::endl;
std::cout << "Compilado com " << BOOST_COMPILER << std::endl;
std::cout << "Compilado em " << __DATE__ << ' ' << __TIME__ << " para plataforma ";
#if defined(__amd64__) || defined(_M_X64)
std::cout << "x64" << std::endl;
#elif defined(__i386__) || defined(_M_IX86) || defined(_X86_)
std::cout << "x86" << std::endl;
#elif defined(__arm__)
std::cout << "ARM" << std::endl;
#else
std::cout << "desconhecida" << std::endl;
#endif
std::cout << std::endl;
std::cout << "Este servidor foi desenvolvido por " << STATUS_SERVER_DEVELOPERS << std::endl;
std::cout << "Visite nosso forum para updates, suporte e pedidos: http://xtibia.com/." << std::endl;
std::cout << "Um oferecimento OTPanel, OTserv Cloud em 60s." << std::endl;
std::cout << std::endl;
// read global config
std::cout << ">> Carregando configuracoes" << std::endl;
if (!g_config.load()) {
startupErrorMessage("Falha ao carregar o config.lua!");
return;
}
#ifdef _WIN32
const std::string& defaultPriority = g_config.getString(ConfigManager::DEFAULT_PRIORITY);
if (strcasecmp(defaultPriority.c_str(), "high") == 0) {
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
} else if (strcasecmp(defaultPriority.c_str(), "above-normal") == 0) {
SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS);
}
#endif
//set RSA key
const char* p("14299623962416399520070177382898895550795403345466153217470516082934737582776038882967213386204600674145392845853859217990626450972452084065728686565928113");
const char* q("7630979195970404721891201847792002125535401292779123937207447574596692788513647179235335529307251350570728407373705564708871762033017096809910315212884101");
g_RSA.setKey(p, q);
std::cout << ">> Estabilizando conexao com o banco de dados..." << std::flush;
Database* db = Database::getInstance();
if (!db->connect()) {
startupErrorMessage("Falha ao conectar-se com o banco de dados.");
return;
}
std::cout << " MySQL " << Database::getClientVersion() << std::endl;
// run database manager
std::cout << ">> Carregando banco de dados" << std::endl;
if (!DatabaseManager::isDatabaseSetup()) {
startupErrorMessage("O banco de dados que especificou no config.lua esta vazio, por favor importar o schema.sql para seu banco de dados.");
return;
}
g_databaseTasks.start();
DatabaseManager::updateDatabase();
if (g_config.getBoolean(ConfigManager::OPTIMIZE_DATABASE) && !DatabaseManager::optimizeTables()) {
std::cout << "> Nenhuma tabela foi otimizada." << std::endl;
}
//load vocations
std::cout << ">> Carregando vocacoes" << std::endl;
if (!g_vocations.loadFromXml()) {
startupErrorMessage("Impossivel carregar vocacoes!");
return;
}
// load item data
std::cout << ">> Carregando items" << std::endl;
if (Item::items.loadFromOtb("data/items/items.otb") != ERROR_NONE) {
startupErrorMessage("Impossivel carregar items (OTB)!");
return;
}
if (!Item::items.loadFromXml()) {
startupErrorMessage("Impossivel carregar (XML)!");
return;
}
std::cout << ">> Carregando sistemas de scripts" << std::endl;
if (!ScriptingManager::getInstance()->loadScriptSystems()) {
startupErrorMessage("Impossivel carregar sistemas de scripts");
return;
}
std::cout << ">> Carregando criaturas" << std::endl;
if (!g_monsters.loadFromXml()) {
startupErrorMessage("Impossivel carregar criaturas!");
return;
}
std::cout << ">> Carregando outfits" << std::endl;
Outfits* outfits = Outfits::getInstance();
if (!outfits->loadFromXml()) {
startupErrorMessage("Impossivel carregar outfits!");
return;
}
std::cout << ">> Checando tipo do servidor... " << std::flush;
std::string worldType = asLowerCaseString(g_config.getString(ConfigManager::WORLD_TYPE));
if (worldType == "pvp") {
g_game.setWorldType(WORLD_TYPE_PVP);
} else if (worldType == "no-pvp") {
g_game.setWorldType(WORLD_TYPE_NO_PVP);
} else if (worldType == "pvp-enforced") {
g_game.setWorldType(WORLD_TYPE_PVP_ENFORCED);
} else {
std::cout << std::endl;
std::ostringstream ss;
ss << "> ERRO: Tipo do servidor desconhecido: " << g_config.getString(ConfigManager::WORLD_TYPE) << ", os tipos validos sao: pvp, no-pvp and pvp-enforced.";
startupErrorMessage(ss.str());
return;
}
std::cout << asUpperCaseString(worldType) << std::endl;
std::cout << ">> Carregando mapa" << std::endl;
if (!g_game.loadMainMap(g_config.getString(ConfigManager::MAP_NAME))) {
startupErrorMessage("Impossivel carregar o mapa");
return;
}
std::cout << ">> Inicializando o servidor" << std::endl;
g_game.setGameState(GAME_STATE_INIT);
// Game client protocols
services->add<ProtocolGame>(g_config.getNumber(ConfigManager::GAME_PORT));
services->add<ProtocolLogin>(g_config.getNumber(ConfigManager::LOGIN_PORT));
// OT protocols
services->add<ProtocolStatus>(g_config.getNumber(ConfigManager::STATUS_PORT));
// Legacy login protocol
services->add<ProtocolOld>(g_config.getNumber(ConfigManager::LOGIN_PORT));
RentPeriod_t rentPeriod;
std::string strRentPeriod = asLowerCaseString(g_config.getString(ConfigManager::HOUSE_RENT_PERIOD));
if (strRentPeriod == "yearly") {
rentPeriod = RENTPERIOD_YEARLY;
} else if (strRentPeriod == "weekly") {
rentPeriod = RENTPERIOD_WEEKLY;
} else if (strRentPeriod == "monthly") {
rentPeriod = RENTPERIOD_MONTHLY;
} else if (strRentPeriod == "daily") {
rentPeriod = RENTPERIOD_DAILY;
} else {
rentPeriod = RENTPERIOD_NEVER;
}
g_game.map.houses.payHouses(rentPeriod);
IOMarket::checkExpiredOffers();
IOMarket::getInstance()->updateStatistics();
std::cout << ">> Todos os modulos carregados, servidor iniciando..." << std::endl;
#ifndef _WIN32
if (getuid() == 0 || geteuid() == 0) {
std::cout << "> Aviso: O servidor foi executado com usuario root, por favor considere executa-lo como um usuario normal." << std::endl;
}
#endif
g_game.start(services);
g_game.setGameState(GAME_STATE_NORMAL);
g_loaderSignal.notify_all();
}
int main(int argc, char*argv[]){
/*
TASK 1: Perform encryption and Decryption each using the RSA routines provided here. They don’t necessarily have to be part of the same code
*/
int count = 10;
int i=0;
std::string result;
BigInt randMessage[10];
std::cout<<"********************************************************************************************************************************************************************"<<std::endl;
std::cout<<"TASK 1a: Create 10 instances of the RSA class without giving arguments, generate random message or assign messages, and perform encryption through each of the 10 classes. "<<std::endl;
std::cout<<"********************************************************************************************************************************************************************"<<std::endl;
//initializing at once as everytime RSA is called srand is called internally and reseting the random function
for(i=0;i<count;i++)
{
randMessage[i] = int(((double)std::rand()/RAND_MAX)*RAND_LIMIT32);
}
for(i=0;i<count;i++)
{
RSA myRSA;
BigInt message, cipher, deciphered;
message = randMessage[i];
//encrypting
cipher = myRSA.encrypt(message);
//decrypting
deciphered = myRSA.decrypt(cipher);
//Checking if the decrypted value is equal to original value
if(message == deciphered)
{
result = "success";
}
else
{
result = "failed";
}
std::cout<<"Instance:"<<i<<"\tmessage: "<<message.toHexString()<<"\tcipher: "<<cipher.toHexString()<<"\tdeciphered: "<<deciphered.toHexString()<<"\tverification-result:"<<result<<std::endl;
}
std::cout<<"********************************************************************************************************************************************************************"<<std::endl;
std::cout<<"TASK 1b: Create 5 instances of the RSA class by passing a large prime number [p](> 30,000), and perform encryption decryption. "<<std::endl;
std::cout<<"********************************************************************************************************************************************************************"<<std::endl;
count = 5;
//Initializing some primes and non-primes to be used by following tasks.
unsigned long int setOfLargePrimes[] = {103919, 103951, 103963, 103967,103969, 104677 ,104681 ,104683 ,104693 ,104701 ,104707 ,104711 ,104717 ,104723 ,104729};
unsigned long int setOfNonPrimes[] = {40000, 31000, 42000, 45000, 50000, 48000,60000,80000,70000,90000,99000};
//iterating 5 time for question 1b
for(i=0;i<count;i++)
{
//giving one primenumber as input to the RSA
RSA rsaInstance(setOfLargePrimes[i]);
BigInt message, cipher, deciphered;
message = randMessage[i];
//decrypting and encrypting
cipher = rsaInstance.encrypt(message);
deciphered = rsaInstance.decrypt(cipher);
//Checking if the decrypted value is equal to original value
if(message == deciphered)
{
result = "success";
}
else
{
result = "failed";
}
std::cout<<"Instance:"<<i<<"\tmessage: "<<message.toHexString()<<"\tcipher: "<<cipher.toHexString()<<"\tdeciphered: "<<deciphered.toHexString()<<"\tverification-result:"<<result<<std::endl;
}
std::cout<<"********************************************************************************************************************************************************************"<<std::endl;
std::cout<<"TASK 1c: Create 5 instances of the RSA class by passing 2 large prime numbers [p,q] (> 30,000) and perform encryption decryption "<<std::endl;
std::cout<<"********************************************************************************************************************************************************************"<<std::endl;
for(i=0;i<count;i++)
{
//Intializing RSA with two primenumbers
RSA rsaInstance(setOfLargePrimes[2*i], setOfLargePrimes[2*i+1]);
BigInt message, cipher, deciphered;
message = randMessage[i];
//encrypting and decrypting
cipher = rsaInstance.encrypt(message);
deciphered = rsaInstance.decrypt(cipher);
//Checking if the decrypted value is equal to original value
if(message == deciphered)
{
result = "success";
}
else
{
result = "failed";
}
std::cout<<"Instance:"<<i<<"\tmessage: "<<message.toHexString()<<"\tcipher: "<<cipher.toHexString()<<"\tdeciphered: "<<deciphered.toHexString()<<"\tverification-result:"<<result<<std::endl;
}
std::cout<<"********************************************************************************************************************************************************************"<<std::endl;
std::cout<<"TASK 1d: Create 10 instances of the RSA class by passing 2 large non prime numbers (> 30,000) and perform encryption decryption. In most of the cases the message should not get decrypted correctly. "<<std::endl;
std::cout<<"********************************************************************************************************************************************************************"<<std::endl;
for(i=0;i<10;i++)
{
//Creating RSA with non primes.
RSA rsaInstance(setOfNonPrimes[i], setOfNonPrimes[i+1]);
BigInt message, cipher, deciphered;
message = randMessage[i];
//encrypting and decrypting
cipher = rsaInstance.encrypt(message);
deciphered = rsaInstance.decrypt(cipher);
//Checking if the decrypted value is equal to original value
if(message == deciphered)
{
result = "success";
}
else
{
result = "failed";
}
std::cout<<"Instance:"<<i<<"\tmessage: "<<message.toHexString()<<"\tcipher: "<<cipher.toHexString()<<"\tdeciphered: "<<deciphered.toHexString()<<"\tverification-result:"<<result<<std::endl;
}
/*
TASK 2: Challenge Response: Scheme 0
*/
std::cout<<"********************************************************************************************************************************************************************"<<std::endl;
std::cout<<" TASK 2: Challenge Response Scheme 0 "<<std::endl;
std::cout<<"********************************************************************************************************************************************************************"<<std::endl;
{
RSA RSA1, RSA2;
//Assigning RSA1 public key and Modulus to RSA2
BigInt publicKey = RSA1.getPublicKey();
BigInt modulus = RSA1.getModulus();
RSA2.setPublicKey(publicKey);
RSA2.setN(modulus);
//generating random message
BigInt message, cipher, deciphered;
message = int(((double)std::rand()/RAND_MAX)*RAND_LIMIT32);
//encrypting with RSA2 i.e RSA1's public key
cipher = RSA2.encrypt(message);
//decrypting with RSA1 i.e RSA1's private key
deciphered = RSA1.decrypt(cipher);
//Checking if the decrypted value is equal to original value
if(message == deciphered)
{
result = "success";
}
else
{
result = "failed";
}
std::cout<<"Instance:"<<i<<"\tmessage: "<<message.toHexString()<<"\tcipher: "<<cipher.toHexString()<<"\tdeciphered: "<<deciphered.toHexString()<<"\tverification-result:"<<result<<std::endl;
}
/*
TASK 3: Blind Signature
*/
std::cout<<"********************************************************************************************************************************************************************"<<std::endl;
std::cout<<" TASK 3: Blind Signature "<<std::endl;
std::cout<<"********************************************************************************************************************************************************************"<<std::endl;
{
//Random message requester want to send with signers signature
BigInt message = int(((double)std::rand()/RAND_MAX)*RAND_LIMIT32);
//Passing signers public key to the requester so that he can generate the blind factor
BigInt signedMessage = Requester(message, signersRSA.getPublicKey(), signersRSA.getModulus());
BigInt deciphered = signersRSA.encrypt(signedMessage);
std::cout<<"Signed Message without blindfactor:" << signedMessage.toHexString() <<std::endl;
std::cout<<" Message Decrypted:" << deciphered.toHexString() <<std::endl;
//Checking if the decrypted value is equal to original value
if(message == deciphered)
{
std::cout<<"Blind Signature successfully implemented"<<std::endl;
}
else
{
std::cout<<"Blind Signature implementation failed"<<std::endl;
}
}
}
void mainLoader(int argc, char* argv[], ServiceManager* services)
{
//dispatcher thread
g_game.setGameState(GAME_STATE_STARTUP);
srand((unsigned int)OTSYS_TIME());
#ifdef _WIN32
SetConsoleTitle(STATUS_SERVER_NAME);
#endif
std::cout << STATUS_SERVER_NAME << " - Version " << STATUS_SERVER_VERSION << std::endl;
std::cout << "Compilied on " << __DATE__ << ' ' << __TIME__ << " for arch ";
#if defined(__amd64__) || defined(_M_X64)
std::cout << "x64" << std::endl;
#elif defined(__i386__) || defined(_M_IX86) || defined(_X86_)
std::cout << "x86" << std::endl;
#elif defined(__arm__)
std::cout << "ARM" << std::endl;
#elif defined(__mips__)
std::cout << "MIPS" << std::endl;
#else
std::cout << "unk" << std::endl;
#endif
std::cout << std::endl;
std::cout << "A server developed by " << STATUS_SERVER_DEVELOPERS << std::endl;
std::cout << "Visit our forum for updates, support, and resources: http://otland.net/." << std::endl;
std::cout << std::endl;
// read global config
std::cout << ">> Loading config" << std::endl;
if (!g_config.load()) {
startupErrorMessage("Unable to load config.lua!");
return;
}
#ifdef _WIN32
std::string defaultPriority = asLowerCaseString(g_config.getString(ConfigManager::DEFAULT_PRIORITY));
if (defaultPriority == "realtime") {
SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
} else if (defaultPriority == "high") {
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
} else if (defaultPriority == "higher") {
SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS);
}
std::ostringstream mutexName;
mutexName << "forgottenserver_" << g_config.getNumber(ConfigManager::LOGIN_PORT);
CreateMutex(nullptr, FALSE, mutexName.str().c_str());
if (GetLastError() == ERROR_ALREADY_EXISTS) {
startupErrorMessage("Another instance of The Forgotten Server is already running with the same login port, please shut it down first or change ports for this one.");
return;
}
#endif
//set RSA key
const char* p("14299623962416399520070177382898895550795403345466153217470516082934737582776038882967213386204600674145392845853859217990626450972452084065728686565928113");
const char* q("7630979195970404721891201847792002125535401292779123937207447574596692788513647179235335529307251350570728407373705564708871762033017096809910315212884101");
g_RSA.setKey(p, q);
std::cout << ">> Establishing database connection..." << std::flush;
Database* db = Database::getInstance();
if (!db->connect()) {
startupErrorMessage("Failed to connect to database.");
return;
}
std::cout << " MySQL " << Database::getClientVersion() << std::endl;
// run database manager
std::cout << ">> Running database manager" << std::endl;
if (!DatabaseManager::isDatabaseSetup()) {
startupErrorMessage("The database you have specified in config.lua is empty, please import the schema.sql to your database.");
return;
}
DatabaseManager::updateDatabase();
DatabaseManager::checkEncryption();
if (g_config.getBoolean(ConfigManager::OPTIMIZE_DATABASE) && !DatabaseManager::optimizeTables()) {
std::cout << "> No tables were optimized." << std::endl;
}
//load vocations
std::cout << ">> Loading vocations" << std::endl;
if (!g_vocations.loadFromXml()) {
startupErrorMessage("Unable to load vocations!");
return;
}
//load commands
std::cout << ">> Loading commands" << std::endl;
if (!g_commands.loadFromXml()) {
startupErrorMessage("Unable to load commands!");
return;
}
// load item data
std::cout << ">> Loading items" << std::endl;
if (Item::items.loadFromOtb("data/items/items.otb")) {
startupErrorMessage("Unable to load items (OTB)!");
return;
}
if (!Item::items.loadFromXml()) {
startupErrorMessage("Unable to load items (XML)!");
return;
}
std::cout << ">> Loading script systems" << std::endl;
if (!ScriptingManager::getInstance()->loadScriptSystems()) {
startupErrorMessage("Failed to load script systems");
return;
}
std::cout << ">> Loading monsters" << std::endl;
if (!g_monsters.loadFromXml()) {
startupErrorMessage("Unable to load monsters!");
return;
}
std::cout << ">> Loading outfits" << std::endl;
Outfits* outfits = Outfits::getInstance();
if (!outfits->loadFromXml()) {
startupErrorMessage("Unable to load outfits!");
return;
}
g_adminConfig = new AdminProtocolConfig();
std::cout << ">> Loading admin protocol config" << std::endl;
if (!g_adminConfig->loadXMLConfig()) {
startupErrorMessage("Unable to load admin protocol config!");
return;
}
std::cout << ">> Loading experience stages" << std::endl;
if (!g_game.loadExperienceStages()) {
startupErrorMessage("Unable to load experience stages!");
return;
}
std::string passwordType = asLowerCaseString(g_config.getString(ConfigManager::PASSWORDTYPE));
if (passwordType == "sha1") {
g_config.setNumber(ConfigManager::PASSWORD_TYPE, PASSWORD_TYPE_SHA1);
std::cout << ">> Using SHA1 passwords" << std::endl;
} else {
g_config.setNumber(ConfigManager::PASSWORD_TYPE, PASSWORD_TYPE_PLAIN);
std::cout << ">> Using plaintext passwords" << std::endl;
}
std::cout << ">> Checking world type... " << std::flush;
std::string worldType = asLowerCaseString(g_config.getString(ConfigManager::WORLD_TYPE));
if (worldType == "pvp") {
g_game.setWorldType(WORLD_TYPE_PVP);
} else if (worldType == "no-pvp") {
g_game.setWorldType(WORLD_TYPE_NO_PVP);
} else if (worldType == "pvp-enforced") {
g_game.setWorldType(WORLD_TYPE_PVP_ENFORCED);
} else {
std::cout << std::endl;
std::ostringstream ss;
ss << "> ERROR: Unknown world type: " << g_config.getString(ConfigManager::WORLD_TYPE) << ", valid world types are: pvp, no-pvp and pvp-enforced.";
startupErrorMessage(ss.str());
return;
}
std::cout << asUpperCaseString(worldType) << std::endl;
std::cout << ">> Loading map" << std::endl;
if (!g_game.loadMainMap(g_config.getString(ConfigManager::MAP_NAME))) {
startupErrorMessage("Failed to load map");
return;
}
std::cout << ">> Initializing gamestate" << std::endl;
g_game.setGameState(GAME_STATE_INIT);
// Tibia protocols
services->add<ProtocolGame>(g_config.getNumber(ConfigManager::GAME_PORT));
services->add<ProtocolLogin>(g_config.getNumber(ConfigManager::LOGIN_PORT));
// OT protocols
services->add<ProtocolAdmin>(g_config.getNumber(ConfigManager::ADMIN_PORT));
services->add<ProtocolStatus>(g_config.getNumber(ConfigManager::STATUS_PORT));
// Legacy protocols
services->add<ProtocolOldLogin>(g_config.getNumber(ConfigManager::LOGIN_PORT));
services->add<ProtocolOldGame>(g_config.getNumber(ConfigManager::LOGIN_PORT));
int32_t autoSaveEachMinutes = g_config.getNumber(ConfigManager::AUTO_SAVE_EACH_MINUTES);
if (autoSaveEachMinutes > 0) {
g_scheduler->addEvent(createSchedulerTask(autoSaveEachMinutes * 1000 * 60, std::bind(&Game::autoSave, &g_game)));
}
if (g_config.getBoolean(ConfigManager::SERVERSAVE_ENABLED)) {
int32_t serverSaveHour = g_config.getNumber(ConfigManager::SERVERSAVE_H);
if (serverSaveHour >= 0 && serverSaveHour <= 24) {
time_t timeNow = time(nullptr);
tm* timeinfo = localtime(&timeNow);
if (serverSaveHour == 0) {
serverSaveHour = 23;
} else {
serverSaveHour--;
}
timeinfo->tm_hour = serverSaveHour;
timeinfo->tm_min = 55;
timeinfo->tm_sec = 0;
double difference = difftime(mktime(timeinfo), timeNow);
if (difference < 0) {
difference += 86400;
}
g_scheduler->addEvent(createSchedulerTask(difference * 1000, std::bind(&Game::prepareServerSave, &g_game)));
}
}
Houses::getInstance().payHouses();
IOLoginData::updateHouseOwners();
g_game.checkExpiredMarketOffers();
IOMarket::getInstance()->updateStatistics();
std::cout << ">> Loaded all modules, server starting up..." << std::endl;
#if !defined(WIN32) && !defined(__ROOT_PERMISSION__)
if (getuid() == 0 || geteuid() == 0) {
std::cout << "> WARNING: " << STATUS_SERVER_NAME << " has been executed as root user, it is recommended to execute is as a normal user." << std::endl;
}
#endif
g_game.start(services);
g_game.setGameState(GAME_STATE_NORMAL);
g_loaderSignal.notify_all();
}
void mainLoader(int argc, char* argv[], ServiceManager* services)
{
//dispatcher thread
g_game.setGameState(GAME_STATE_STARTUP);
srand((unsigned int)OTSYS_TIME());
#ifdef WIN32
SetConsoleTitle(STATUS_SERVER_NAME);
#endif
std::cout << STATUS_SERVER_NAME << " - Version " << STATUS_SERVER_VERSION << std::endl;
std::cout << "Compilied on " << __DATE__ << " " << __TIME__ << " for arch ";
#if defined(__amd64__) || defined(_M_X64)
std::cout << "x64" << std::endl;
#elif defined(__i386__) || defined(_M_IX86) || defined(_X86_)
std::cout << "x86" << std::endl;
#else
std::cout << "unk" << std::endl;
#endif
std::cout << std::endl;
std::cout << "A server developed by " << STATUS_SERVER_DEVELOPERS << std::endl;
std::cout << "Visit our forum for updates, support, and resources: http://otland.net/." << std::endl;
std::cout << std::endl;
// read global config
std::cout << ">> Loading config" << std::endl;
if (!g_config.loadFile("config.lua")) {
startupErrorMessage("Unable to load config.lua!");
return;
}
#ifdef WIN32
std::string defaultPriority = asLowerCaseString(g_config.getString(ConfigManager::DEFAULT_PRIORITY));
if (defaultPriority == "realtime") {
SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
} else if (defaultPriority == "high") {
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
} else if (defaultPriority == "higher") {
SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS);
}
std::ostringstream mutexName;
mutexName << "forgottenserver_" << g_config.getNumber(ConfigManager::LOGIN_PORT);
CreateMutex(NULL, FALSE, mutexName.str().c_str());
if (GetLastError() == ERROR_ALREADY_EXISTS) {
startupErrorMessage("Another instance of The Forgotten Server is already running with the same login port, please shut it down first or change ports for this one.");
return;
}
#endif
//set RSA key
const char* p("14299623962416399520070177382898895550795403345466153217470516082934737582776038882967213386204600674145392845853859217990626450972452084065728686565928113");
const char* q("7630979195970404721891201847792002125535401292779123937207447574596692788513647179235335529307251350570728407373705564708871762033017096809910315212884101");
const char* d("46730330223584118622160180015036832148732986808519344675210555262940258739805766860224610646919605860206328024326703361630109888417839241959507572247284807035235569619173792292786907845791904955103601652822519121908367187885509270025388641700821735345222087940578381210879116823013776808975766851829020659073");
g_RSA.setKey(p, q, d);
std::cout << ">> Establishing database connection..." << std::flush;
Database* db = Database::getInstance();
if (!db->connect()) {
startupErrorMessage("Failed to connect to database.");
return;
}
std::cout << " MySQL " << db->getClientVersion() << std::endl;
// run database manager
std::cout << ">> Running database manager" << std::endl;
DatabaseManager* dbManager = DatabaseManager::getInstance();
if (!dbManager->isDatabaseSetup()) {
startupErrorMessage("The database you have specified in config.lua is empty, please import the schema to the database.");
return;
}
for (uint32_t version = dbManager->updateDatabase(); version != 0; version = dbManager->updateDatabase()) {
std::cout << "> Database has been updated to version " << version << "." << std::endl;
}
dbManager->checkTriggers();
dbManager->checkEncryption();
if (g_config.getBoolean(ConfigManager::OPTIMIZE_DATABASE) && !dbManager->optimizeTables()) {
std::cout << "> No tables were optimized." << std::endl;
}
//load vocations
std::cout << ">> Loading vocations" << std::endl;
if (!g_vocations.loadFromXml()) {
startupErrorMessage("Unable to load vocations!");
return;
}
//load commands
std::cout << ">> Loading commands" << std::endl;
if (!commands.loadFromXml()) {
startupErrorMessage("Unable to load commands!");
return;
}
// load item data
std::cout << ">> Loading items" << std::endl;
if (Item::items.loadFromOtb("data/items/items.otb")) {
startupErrorMessage("Unable to load items (OTB)!");
return;
}
if (!Item::items.loadFromXml()) {
startupErrorMessage("Unable to load items (XML)!");
return;
}
std::cout << ">> Loading script systems" << std::endl;
if (!ScriptingManager::getInstance()->loadScriptSystems()) {
startupErrorMessage("Failed to load script systems");
return;
}
std::cout << ">> Loading monsters" << std::endl;
if (!g_monsters.loadFromXml()) {
startupErrorMessage("Unable to load monsters!");
return;
}
std::cout << ">> Loading outfits" << std::endl;
Outfits* outfits = Outfits::getInstance();
if (!outfits->loadFromXml()) {
startupErrorMessage("Unable to load outfits!");
return;
}
g_adminConfig = new AdminProtocolConfig();
std::cout << ">> Loading admin protocol config" << std::endl;
if (!g_adminConfig->loadXMLConfig()) {
startupErrorMessage("Unable to load admin protocol config!");
return;
}
std::cout << ">> Loading experience stages" << std::endl;
if (!g_game.loadExperienceStages()) {
startupErrorMessage("Unable to load experience stages!");
return;
}
std::string passwordType = asLowerCaseString(g_config.getString(ConfigManager::PASSWORDTYPE));
if (passwordType == "md5") {
g_config.setNumber(ConfigManager::PASSWORD_TYPE, PASSWORD_TYPE_MD5);
std::cout << ">> Using MD5 passwords" << std::endl;
} else if (passwordType == "sha1") {
g_config.setNumber(ConfigManager::PASSWORD_TYPE, PASSWORD_TYPE_SHA1);
std::cout << ">> Using SHA1 passwords" << std::endl;
} else {
g_config.setNumber(ConfigManager::PASSWORD_TYPE, PASSWORD_TYPE_PLAIN);
std::cout << ">> Using plaintext passwords" << std::endl;
}
std::cout << ">> Checking world type... " << std::flush;
std::string worldType = asLowerCaseString(g_config.getString(ConfigManager::WORLD_TYPE));
if (worldType == "pvp") {
g_game.setWorldType(WORLD_TYPE_PVP);
} else if (worldType == "no-pvp") {
g_game.setWorldType(WORLD_TYPE_NO_PVP);
} else if (worldType == "pvp-enforced") {
g_game.setWorldType(WORLD_TYPE_PVP_ENFORCED);
} else {
std::cout << std::endl;
std::ostringstream ss;
ss << "> ERROR: Unknown world type: " << g_config.getString(ConfigManager::WORLD_TYPE) << ", valid world types are: pvp, no-pvp and pvp-enforced.";
startupErrorMessage(ss.str());
return;
}
std::cout << asUpperCaseString(worldType) << std::endl;
std::cout << ">> Loading map" << std::endl;
if (!g_game.loadMap(g_config.getString(ConfigManager::MAP_NAME))) {
startupErrorMessage("Failed to load map");
return;
}
std::cout << ">> Initializing gamestate" << std::endl;
g_game.setGameState(GAME_STATE_INIT);
// Tibia protocols
services->add<ProtocolGame>(g_config.getNumber(ConfigManager::GAME_PORT));
services->add<ProtocolLogin>(g_config.getNumber(ConfigManager::LOGIN_PORT));
// OT protocols
services->add<ProtocolAdmin>(g_config.getNumber(ConfigManager::ADMIN_PORT));
services->add<ProtocolStatus>(g_config.getNumber(ConfigManager::STATUS_PORT));
// Legacy protocols
services->add<ProtocolOldLogin>(g_config.getNumber(ConfigManager::LOGIN_PORT));
services->add<ProtocolOldGame>(g_config.getNumber(ConfigManager::LOGIN_PORT));
int32_t autoSaveEachMinutes = g_config.getNumber(ConfigManager::AUTO_SAVE_EACH_MINUTES);
if (autoSaveEachMinutes > 0) {
g_scheduler.addEvent(createSchedulerTask(autoSaveEachMinutes * 1000 * 60, boost::bind(&Game::autoSave, &g_game)));
}
if (g_config.getBoolean(ConfigManager::SERVERSAVE_ENABLED)) {
int32_t serverSaveHour = g_config.getNumber(ConfigManager::SERVERSAVE_H);
if (serverSaveHour >= 0 && serverSaveHour <= 24) {
time_t timeNow = time(NULL);
tm* timeinfo = localtime(&timeNow);
if (serverSaveHour == 0) {
serverSaveHour = 23;
} else {
serverSaveHour--;
}
timeinfo->tm_hour = serverSaveHour;
timeinfo->tm_min = 55;
timeinfo->tm_sec = 0;
time_t difference = (time_t)difftime(mktime(timeinfo), timeNow);
if (difference < 0) {
difference += 86400;
}
g_scheduler.addEvent(createSchedulerTask(difference * 1000, boost::bind(&Game::prepareServerSave, &g_game)));
}
}
Houses::getInstance().payHouses();
IOLoginData::getInstance()->updateHouseOwners();
g_npcs.reload();
if (g_config.getBoolean(ConfigManager::MARKET_ENABLED)) {
g_game.checkExpiredMarketOffers();
IOMarket::getInstance()->updateStatistics();
}
std::cout << ">> Loaded all modules, server starting up..." << std::endl;
std::pair<uint32_t, uint32_t> IpNetMask;
IpNetMask.first = inet_addr("127.0.0.1");
IpNetMask.second = 0xFFFFFFFF;
serverIPs.push_back(IpNetMask);
char szHostName[128];
if (gethostname(szHostName, 128) == 0) {
hostent* he = gethostbyname(szHostName);
if (he) {
unsigned char** addr = (unsigned char**)he->h_addr_list;
while (addr[0] != NULL) {
IpNetMask.first = *(uint32_t*)(*addr);
IpNetMask.second = 0xFFFFFFFF;
serverIPs.push_back(IpNetMask);
addr++;
}
}
}
std::string ip = g_config.getString(ConfigManager::IP);
uint32_t resolvedIp = inet_addr(ip.c_str());
if (resolvedIp == INADDR_NONE) {
struct hostent* he = gethostbyname(ip.c_str());
if (!he) {
std::ostringstream ss;
ss << "ERROR: Cannot resolve " << ip << "!" << std::endl;
startupErrorMessage(ss.str());
return;
}
resolvedIp = *(uint32_t*)he->h_addr;
}
IpNetMask.first = resolvedIp;
IpNetMask.second = 0;
serverIPs.push_back(IpNetMask);
#if !defined(WIN32) && !defined(__ROOT_PERMISSION__)
if (getuid() == 0 || geteuid() == 0) {
std::cout << "> WARNING: " << STATUS_SERVER_NAME << " has been executed as root user, it is recommended to execute is as a normal user." << std::endl;
}
#endif
g_game.start(services);
g_game.setGameState(GAME_STATE_NORMAL);
g_loaderSignal.notify_all();
}
int main() {
int pprimes[18] = { 30839, 30841, 30851, 30853, 30859, 30869, 30871, 30881, 30893, 30911, 30931, 30937, 30941
, 30949, 30971, 30977, 30983, 31013 };
string str = "1";
//Create 10 instances of the RSA class without giving arguments, generate random message or assign messages,
// and perform encryption through each of the 10 classes.
for (int i=0; i < 10; i++) {
RSA* rsa = new RSA();
str = str + "0";
bitset<96> mssg (str);
BigInt* msg = new BigInt(mssg);
BigInt encrypted = rsa->encrypt(*msg);
BigInt decrypted = rsa->decrypt(encrypted);
string decmsg = decrypted.toString();
cout << "part a message was:" << decmsg << endl;
delete rsa;
}
//Create 5 instances of the RSA class by passing a large prime number [p](> 30,000), and perform encryption decryption
for (int j=0; j < 5; j++) {
RSA* rsa = new RSA(pprimes[j]);
str = str + "1";
bitset<96> mssg (str);
BigInt* msg = new BigInt(mssg);
BigInt encrypted = rsa->encrypt(*msg);
BigInt decrypted = rsa->decrypt(encrypted);
string decmsg = decrypted.toString();
cout << "part b (1 prime) message was:" << decmsg << endl;
delete rsa;
}
//Create 5 instances of the RSA class by passing 2 large prime numbers [p,q] (> 30,000) and perform encryption decryption
for (int j=0; j < 5; j++) {
RSA* rsa = new RSA(pprimes[j], pprimes[j+1]);
str = str + "0";
bitset<96> mssg (str);
BigInt* msg = new BigInt(mssg);
BigInt encrypted = rsa->encrypt(*msg);
BigInt decrypted = rsa->decrypt(encrypted);
string decmsg = decrypted.toString();
cout << "part c (2 primes) message was:" << decmsg << endl;
delete rsa;
}
//Create 10 instances of the RSA class by passing 2 large non prime numbers (> 30,000) and perform encryption decryption.
// In most of the cases the message should not get decrypted correctly.
for (int j=0; j < 10; j++) {
//add one to the prime number to make it non-prime
RSA* rsa = new RSA(pprimes[j] + 1, pprimes[j+1] + 1);
str = str + "1";
bitset<96> mssg (str);
BigInt* msg = new BigInt(mssg);
BigInt encrypted = rsa->encrypt(*msg);
BigInt decrypted = rsa->decrypt(encrypted);
string decmsg = decrypted.toString();
cout << "part d (nonprimes) message was:" << decmsg << endl;
delete rsa;
}
RSA* RSA1 = new RSA();
RSA* RSA2 = new RSA();
BigInt pub1 = RSA1->getPublicKey();
BigInt n = RSA1->getModulus();
BigInt* randmsg = new BigInt(rand());
cout << "\n PART 2 " << endl;
cout << "\nrandom message before encryption: " << randmsg->toString() << endl;
RSA2->setPublicKey(pub1);
RSA2->setN(n);
BigInt encr = RSA2->encrypt(*randmsg);
BigInt decr = RSA1->decrypt(encr);
cout << "random message after encryption: " << decr.toString() << endl;
//PART 3
cout << "\n PART 3" << endl;
//a. Alice obtains the public key and Modulus N of the person (Bob) who is to sign the message
RSA* bob = new RSA();
RSA* alice = new RSA();
BigInt bpubkey = bob->getPublicKey();
BigInt bmod = bob->getModulus();
alice->setN(bmod);
alice->setPublicKey(bpubkey);
//b. Obtain a random number and its inverse with respect to the Modulus [Not phi] of Bob
BigInt* randnum = new BigInt(rand());
BigInt inverse = randnum->operator%(bob->getModulus());
//c. Alice obtains/generates a message to be signed.
BigInt* rmssg = new BigInt(rand());
cout << "\nrandom message before encryption: " << rmssg->toString() << endl;
//d. Alice encrypts the random number with the public key.
BigInt emessg = alice->encrypt(*rmssg);
//e. Alice multiplies this value by the message
BigInt newval = emessg.operator*(*rmssg);
//f. Alice then takes a modulus over N
BigInt newmod = newval.operator%(alice->getModulus());
//g. Alice sends it to Bob
//h. Bob simply decrypts the received value with the private key
BigInt bobdecrypt = bob->decrypt(newmod);
//i. Bob sends it back to Alice
//j. Alice then multiplied the received value with the inverse and takes a modulus over N.
BigInt alicemult = bobdecrypt.operator*(inverse);
BigInt alicemod = alicemult.operator%(alice->getModulus());
//k. The value obtained above is the signed message. To obtain the original message from it, again encrypt it with Bob’s Public Key.
BigInt original = alice->encrypt(alicemod);
cout << "\n Alice decrypted message: " << original.toString() << endl;
return 0;
}
BigInt getDecryptedMessageFromRSA_obj(BigInt m, RSA RSA_obj)
{
return RSA_obj.decrypt(m);
}
BigInt Signer(BigInt messageWithBlindFactor)
{
return signersRSA.decrypt(messageWithBlindFactor);
}
void ProtocolAdmin::parsePacket(NetworkMessage& msg)
{
if(g_game.getGameState() == GAMESTATE_SHUTDOWN)
{
getConnection()->close();
return;
}
uint8_t recvbyte = msg.get<char>();
OutputMessage_ptr output = OutputMessagePool::getInstance()->getOutputMessage(this, false);
if(!output)
return;
TRACK_MESSAGE(output);
switch(m_state)
{
case ENCRYPTION_NO_SET:
{
if(Admin::getInstance()->isEncypted())
{
if((time(NULL) - m_startTime) > 30000)
{
getConnection()->close();
addLogLine(LOGTYPE_EVENT, "encryption timeout");
return;
}
if(recvbyte != AP_MSG_ENCRYPTION && recvbyte != AP_MSG_KEY_EXCHANGE)
{
output->put<char>(AP_MSG_ERROR);
output->putString("encryption needed");
OutputMessagePool::getInstance()->send(output);
getConnection()->close();
addLogLine(LOGTYPE_EVENT, "wrong command while ENCRYPTION_NO_SET");
return;
}
}
else
m_state = NO_LOGGED_IN;
break;
}
case NO_LOGGED_IN:
{
if(g_config.getBool(ConfigManager::ADMIN_REQUIRE_LOGIN))
{
if((time(NULL) - m_startTime) > 30000)
{
//login timeout
getConnection()->close();
addLogLine(LOGTYPE_EVENT, "login timeout");
return;
}
if(m_loginTries > 3)
{
output->put<char>(AP_MSG_ERROR);
output->putString("too many login tries");
OutputMessagePool::getInstance()->send(output);
getConnection()->close();
addLogLine(LOGTYPE_EVENT, "too many login tries");
return;
}
if(recvbyte != AP_MSG_LOGIN)
{
output->put<char>(AP_MSG_ERROR);
output->putString("you are not logged in");
OutputMessagePool::getInstance()->send(output);
getConnection()->close();
addLogLine(LOGTYPE_EVENT, "wrong command while NO_LOGGED_IN");
return;
}
}
else
m_state = LOGGED_IN;
break;
}
case LOGGED_IN:
break;
default:
{
getConnection()->close();
addLogLine(LOGTYPE_EVENT, "no valid connection state!!!");
return;
}
}
m_lastCommand = time(NULL);
switch(recvbyte)
{
case AP_MSG_LOGIN:
{
if(m_state == NO_LOGGED_IN && g_config.getBool(ConfigManager::ADMIN_REQUIRE_LOGIN))
{
std::string pass = msg.getString(), word = g_config.getString(ConfigManager::ADMIN_PASSWORD);
_encrypt(word, false);
if(pass == word)
{
m_state = LOGGED_IN;
output->put<char>(AP_MSG_LOGIN_OK);
addLogLine(LOGTYPE_EVENT, "login ok");
}
else
{
m_loginTries++;
output->put<char>(AP_MSG_LOGIN_FAILED);
output->putString("wrong password");
addLogLine(LOGTYPE_EVENT, "login failed.("+ pass + ")");
}
}
else
{
output->put<char>(AP_MSG_LOGIN_FAILED);
output->putString("cannot login");
addLogLine(LOGTYPE_EVENT, "wrong state at login");
}
break;
}
case AP_MSG_ENCRYPTION:
{
if(m_state == ENCRYPTION_NO_SET && Admin::getInstance()->isEncypted())
{
uint8_t keyType = msg.get<char>();
switch(keyType)
{
case ENCRYPTION_RSA1024XTEA:
{
RSA* rsa = Admin::getInstance()->getRSAKey(ENCRYPTION_RSA1024XTEA);
if(!rsa)
{
output->put<char>(AP_MSG_ENCRYPTION_FAILED);
addLogLine(LOGTYPE_EVENT, "no valid server key type");
break;
}
if(RSA_decrypt(rsa, msg))
{
m_state = NO_LOGGED_IN;
uint32_t k[4]= {msg.get<uint32_t>(), msg.get<uint32_t>(), msg.get<uint32_t>(), msg.get<uint32_t>()};
//use for in/out the new key we have
enableXTEAEncryption();
setXTEAKey(k);
output->put<char>(AP_MSG_ENCRYPTION_OK);
addLogLine(LOGTYPE_EVENT, "encryption ok");
}
else
{
output->put<char>(AP_MSG_ENCRYPTION_FAILED);
output->putString("wrong encrypted packet");
addLogLine(LOGTYPE_EVENT, "wrong encrypted packet");
}
break;
}
default:
{
output->put<char>(AP_MSG_ENCRYPTION_FAILED);
output->putString("no valid key type");
addLogLine(LOGTYPE_EVENT, "no valid client key type");
break;
}
}
}
else
{
output->put<char>(AP_MSG_ENCRYPTION_FAILED);
output->putString("cannot set encryption");
addLogLine(LOGTYPE_EVENT, "cannot set encryption");
}
break;
}
case AP_MSG_KEY_EXCHANGE:
{
if(m_state == ENCRYPTION_NO_SET && Admin::getInstance()->isEncypted())
{
uint8_t keyType = msg.get<char>();
switch(keyType)
{
case ENCRYPTION_RSA1024XTEA:
{
RSA* rsa = Admin::getInstance()->getRSAKey(ENCRYPTION_RSA1024XTEA);
if(!rsa)
{
output->put<char>(AP_MSG_KEY_EXCHANGE_FAILED);
addLogLine(LOGTYPE_EVENT, "no valid server key type");
break;
}
output->put<char>(AP_MSG_KEY_EXCHANGE_OK);
output->put<char>(ENCRYPTION_RSA1024XTEA);
char RSAPublicKey[128];
rsa->getPublicKey(RSAPublicKey);
output->put<char>s(RSAPublicKey, 128);
break;
}
default:
{
output->put<char>(AP_MSG_KEY_EXCHANGE_FAILED);
addLogLine(LOGTYPE_EVENT, "no valid client key type");
break;
}
}
}
else
{
output->put<char>(AP_MSG_KEY_EXCHANGE_FAILED);
output->putString("cannot get public key");
addLogLine(LOGTYPE_EVENT, "cannot get public key");
}
break;
}
case AP_MSG_COMMAND:
{
if(m_state != LOGGED_IN)
{
addLogLine(LOGTYPE_EVENT, "recvbyte == AP_MSG_COMMAND && m_state != LOGGED_IN !!!");
break;
}
uint8_t command = msg.get<char>();
switch(command)
{
case CMD_SAVE_SERVER:
case CMD_SHALLOW_SAVE_SERVER:
{
uint8_t flags = (uint8_t)SAVE_PLAYERS | (uint8_t)SAVE_MAP | (uint8_t)SAVE_STATE;
if(command == CMD_SHALLOW_SAVE_SERVER)
flags |= SAVE_PLAYERS_SHALLOW;
addLogLine(LOGTYPE_EVENT, "saving server");
Dispatcher::getInstance().addTask(createTask(boost::bind(&Game::saveGameState, &g_game, flags)));
output->put<char>(AP_MSG_COMMAND_OK);
break;
}
case CMD_CLOSE_SERVER:
{
addLogLine(LOGTYPE_EVENT, "closing server");
Dispatcher::getInstance().addTask(createTask(boost::bind(
&Game::setGameState, &g_game, GAMESTATE_CLOSED)));
output->put<char>(AP_MSG_COMMAND_OK);
break;
}
case CMD_OPEN_SERVER:
{
addLogLine(LOGTYPE_EVENT, "opening server");
g_game.setGameState(GAMESTATE_NORMAL);
output->put<char>(AP_MSG_COMMAND_OK);
break;
}
case CMD_SHUTDOWN_SERVER:
{
addLogLine(LOGTYPE_EVENT, "shutting down server");
Dispatcher::getInstance().addTask(createTask(boost::bind(
&Game::setGameState, &g_game, GAMESTATE_SHUTDOWN)));
output->put<char>(AP_MSG_COMMAND_OK);
break;
}
case CMD_PAY_HOUSES:
{
Dispatcher::getInstance().addTask(createTask(boost::bind(
&ProtocolAdmin::adminCommandPayHouses, this)));
break;
}
case CMD_RELOAD_SCRIPTS:
{
const int8_t reload = msg.get<char>();
Dispatcher::getInstance().addTask(createTask(boost::bind(
&ProtocolAdmin::adminCommandReload, this, reload)));
break;
}
case CMD_KICK:
{
const std::string param = msg.getString();
Dispatcher::getInstance().addTask(createTask(boost::bind(
&ProtocolAdmin::adminCommandKickPlayer, this, param)));
break;
}
case CMD_SEND_MAIL:
{
const std::string xmlData = msg.getString();
Dispatcher::getInstance().addTask(createTask(boost::bind(
&ProtocolAdmin::adminCommandSendMail, this, xmlData)));
break;
}
case CMD_BROADCAST:
{
const std::string param = msg.getString();
addLogLine(LOGTYPE_EVENT, "broadcasting: " + param);
Dispatcher::getInstance().addTask(createTask(boost::bind(
&Game::broadcastMessage, &g_game, param, MSG_STATUS_WARNING)));
output->put<char>(AP_MSG_COMMAND_OK);
break;
}
default:
{
output->put<char>(AP_MSG_COMMAND_FAILED);
output->putString("not known server command");
addLogLine(LOGTYPE_EVENT, "not known server command");
}
}
break;
}
case AP_MSG_PING:
output->put<char>(AP_MSG_PING_OK);
break;
case AP_MSG_KEEP_ALIVE:
break;
default:
{
output->put<char>(AP_MSG_ERROR);
output->putString("not known command byte");
addLogLine(LOGTYPE_EVENT, "not known command byte");
break;
}
}
if(output->size() > 0)
OutputMessagePool::getInstance()->send(output);
}
int main(){
/* Implementation of task1*/
std::cout<<"\n\n************Task1***********"<<std::endl;
srand(time(NULL));
/* Subtask1 */
std::cout<<"\n************Subtask1************"<<std::endl;
RSA objRSA[10];
//char * messages[]={"One","Two","Three","Four","Five","Six","Seven","Eight","Nine","Ten"};
int msg=int(((double)rand()/RAND_MAX)*LIMIT_RAND); //generation of random message
BigInt result(0);
for(int i=0;i<10;i++){
printf("\nEncrypting the message %d \n", msg);
result=objRSA[i].encrypt(msg); //Encryption of message
std::cout<<"Encryption result : "<<result.toHexString()<<std::endl;
}
/* Subtask 2 */
std::cout<<"\n***********Subtask2**************"<<std::endl;
RSA * objRSA_onearg[5]={NULL};
std::cout<<"\nEncrypting the message "<<msg<<std::endl;
int primep[10]={0};
generate_prime(primep,10);//prime number generation
for(int i=0;i<5;i++){
objRSA_onearg[i] = new RSA (primep[i]);
result = objRSA_onearg[i]->encrypt(msg); // encrypt message
std::cout<<"\nEncryption result using the prime p as "<<primep[i]<<" is "<<result.toHexString()<<std::endl;
result = objRSA_onearg[i]->decrypt(result);//decrypt message
std::cout<<"Decryption result : "<<result.toHexString()<<std::endl;
}
/* Subtask 3 */
std::cout<<"\n***********Subtask3**************"<<std::endl;
RSA * objRSA_twoarg[5]={NULL};
std::cout<<"\nEncrypting the message "<<msg<<std::endl;
for(int i=0;i<5;i++){
objRSA_onearg[i] = new RSA (primep[i],primep[5+i]);
result = objRSA_onearg[i]->encrypt(msg);//encrypting the message
std::cout<<"\nEncryption result using the prime p and q as "<<primep[i]<<" "<<primep[5+i]<<" is "<<result.toHexString()<<std::endl;
result = objRSA_onearg[i]->decrypt(result);//decrypting the message
std::cout<<"Decryption result : " << result.toHexString()<<std::endl;
}
/* Subtask 4 */
std::cout<<"\n***********Subtask4**************"<<std::endl;
RSA * objRSA_twononprimearg[5]={NULL};
int nprime[10]={0};
generate_nonprime(nprime,10);//generate non prime numbers
std::cout<<"\nEncrypting the message "<<msg<<std::endl;
for(int i=0;i<5;i++){
objRSA_onearg[i] = new RSA (nprime[i],nprime[5+i]);
result = objRSA_onearg[i]->encrypt(msg);//encrypting the message
std::cout<<"\nEncryption result using the non prime p and q as "<<nprime[i]<<" "<<nprime[5+i]<<" is "<<result.toHexString()<<std::endl;
result = objRSA_onearg[i]->decrypt(result);//decrypt message
std::cout<<"Decryption result : "<<result.toHexString()<<std::endl;
if(result==objRSA_onearg[i]->encrypt(msg)){//check if encrypted and decrypted messages are same
std::cout<<"This case is an out of ordinary case "<<std::endl;
}
}
/*Implementation of task3*/
/*********Task2********/
std::cout<<"\n\n***************Task2*********"<<std::endl;
RSA RSAObj1;
RSA RSAObj2;
unsigned long result_long[2];
int size_result_array=2;
result=RSAObj1.getPublicKey();
RSAObj2.setPublicKey(result);
RSAObj2.setN(RSAObj1.getModulus());
//int rno=rand();
BigInt rno=int(((double)rand()/RAND_MAX)*LIMIT_RAND);//random message
std::cout<<"\noriginal message="<<rno.toHexString()<<std::endl;
result=RSAObj2.encrypt(rno);
std::cout<<"encrypted message="<<result.toHexString()<<std::endl;
result=RSAObj1.decrypt(result);
std::cout<<"decrypted message="<<result.toHexString()<<std::endl;
//converttoint(result,result_long,size_result_array);
if(result==rno){//check if values match
std::cout<<"Original message and decrypted messages match , hence verified "<<std::endl;
}
/*Implementation of task3*/
/************Task3********/
std::cout<<"\n\n*****************Task3***************"<<std::endl;
RSA Bobobj;
BigInt pk= Bobobj.getPublicKey();
BigInt mod= Bobobj.getModulus();
//Bob sends public key and modN to Alice
BigInt msgAlice=sendtoAlice(pk,mod);
//Bob decrypts the message received from Alice
BigInt decmessage= Bobobj.decrypt(msgAlice);
//send the decrypted message to Alice again
sendtoAlice2(decmessage,pk,mod);
}
void mainLoader(int, char*[], ServiceManager* services)
{
srand(static_cast<unsigned int>(OTSYS_TIME()));
#ifdef _WIN32
SetConsoleTitle(STATUS_SERVER_NAME);
#endif
std::cout << STATUS_SERVER_NAME << " - Version " << STATUS_SERVER_VERSION << std::endl;
std::cout << "Compiled with " << BOOST_COMPILER << std::endl;
std::cout << "Compiled on " << __DATE__ << ' ' << __TIME__ << " for platform ";
#if defined(__amd64__) || defined(_M_X64)
std::cout << "x64" << std::endl;
#elif defined(__i386__) || defined(_M_IX86) || defined(_X86_)
std::cout << "x86" << std::endl;
#elif defined(__arm__)
std::cout << "ARM" << std::endl;
#else
std::cout << "unknown" << std::endl;
#endif
std::cout << std::endl;
std::cout << "A server developed by " << STATUS_SERVER_DEVELOPERS << std::endl;
std::cout << std::endl;
// read global config
std::cout << ">> Loading config" << std::endl;
if (!g_config.load()) {
startupErrorMessage("Unable to load config.lua!");
return;
}
std::cout << ">> Loading gameserver config..." << std::endl;
if (!g_gameserver.load()) {
startupErrorMessage("Unable to load gameservers!");
return;
}
#ifdef _WIN32
const std::string& defaultPriority = g_config.getString(ConfigManager::DEFAULT_PRIORITY);
if (strcasecmp(defaultPriority.c_str(), "high") == 0) {
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
} else if (strcasecmp(defaultPriority.c_str(), "above-normal") == 0) {
SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS);
}
#endif
//set RSA key
//cipsoft
const char* p("12017580013707233233987537782574702577133548287527131234152948150506251412291888866940292054989907714155267326586216043845592229084368540020196135619327879");
const char* q("11898921368616868351880508246112101394478760265769325412746398405473436969889506919017477758618276066588858607419440134394668095105156501566867770737187273");
//opentibia
/*
const char* p("14299623962416399520070177382898895550795403345466153217470516082934737582776038882967213386204600674145392845853859217990626450972452084065728686565928113");
const char* q("7630979195970404721891201847792002125535401292779123937207447574596692788513647179235335529307251350570728407373705564708871762033017096809910315212884101");
*/
g_RSA.setKey(p, q);
std::cout << ">> Establishing database connection..." << std::flush;
Database* db = Database::getInstance();
if (!db->connect()) {
startupErrorMessage("Failed to connect to database.");
return;
}
std::cout << " MySQL " << Database::getClientVersion() << std::endl;
// run database manager
std::cout << ">> Running database manager" << std::endl;
if (!DatabaseManager::isDatabaseSetup()) {
startupErrorMessage("The database you have specified in config.lua is empty, please import the schema.sql to your database.");
return;
}
g_databaseTasks.start();
if (g_config.getBoolean(ConfigManager::OPTIMIZE_DATABASE) && !DatabaseManager::optimizeTables()) {
std::cout << "> No tables were optimized." << std::endl;
}
// Game client protocols
services->add<ProtocolOld>(g_config.getNumber(ConfigManager::LOGIN_PORT));
// OT protocols
services->add<ProtocolStatus>(g_config.getNumber(ConfigManager::STATUS_PORT));
//check each 1 minute for player amount and record
ProtocolStatus::getPlayerRecordAndPlayerAmount();
std::cout << ">> Loaded all modules, server starting up..." << std::endl;
#ifndef _WIN32
if (getuid() == 0 || geteuid() == 0) {
std::cout << "> Warning: " << STATUS_SERVER_NAME << " has been executed as root user, please consider running it as a normal user." << std::endl;
}
#endif
g_loaderSignal.notify_all();
}
