Ir para conteúdo

dso15

Campones
  • Total de itens

    87
  • Registro em

  • Última visita

  • Dias Ganhos

    5

Posts postados por dso15

  1. bom caso queira deixar apenas transparente coloque a imagem referente a borda em um editor de imagem, e diminua a opacidade, porem caso queira remover a mesma siga esse tutorial: Como tirar estas barras laterais? - Suporte Tibia Alternativo - Tibia King - Tudo sobre Tibia, OTServ e Bots!, porem a vc ficara com as bordas da tela preta caso não tenha tela estendida caso não tenha, siga esse tutorial: 

     

     

  2. bom essa dex provavelmente puxa funções no server, rippa o modulo coloca no seu client, ve se tem algo que não está funcionando oque não estiver vc ripa as funções tbm

     

    OBS: Seja mais especifico com erros, exemplo vc nem tentou colocar o modulo na pasta modules pelo que parece

  3. 9 horas atrás, Polguilo disse:

    @dso15
    acho q vai ser o jeito mano,foda que ngm por enquanto brotou aqui pra dar um help :x
    acho q nem deve ser algo sério,tbm n sei se corrompeu a database ou sei la e.e

    ta td funcionando zero bala no server,só a database que ta dando esse erro ai que impede de eu abrir pra editar alguma coisa se eu precisar :x
    vc sabe oq pode ter acontecido mano??? tem alguma desvantagem se eu mudar pro My SQL pow??

    como disse pode ter sido varias posibilidades uma dll excluida pelo anti virus, um exe corompido , porem vc pode extrair as dll os exe do server e a database dnv se isso nao funcionar vai pra mysql msm

     

  4. Em 09/01/2021 em 02:27, wenderotpoke disse:

    NA TRUE NEM SEI DE NADA MAS É O QUE ACHO ALGUEM SABE RESOLVER ISSO?

    Complicado mano pode ser X posibilidades

     

    1 tente reinstalar seu objectbuilder, caso continue provavelmente o problema sera no seu .dat e .spr

     

    porem entre tanto toda via caso for ele o buraco é mais em baixo pois vcs vai ter que tirar as spr bugadas e colocar dnv corretamente

  5. Basicamente não e sim kkkkk, ficou estranho mas é a realidade.

     

    da pra adaptar source ? 

    R: Sim porem cada poketibia trablha de uma forma e fica uma gambiara caso queira adaptar e praticamente imposivel adaptar uma source 100%

     

    Quer um projeto mais limpo!

    R: Aconselho ou vc pega um TFS do 0 ou pode pegar uma base antiga com source e ir fazendo tudo dnv ou vc pode pegar uma base atual e remolver o que vc achar desnesesario 

     

    Aconselho vc pegar uma base atual

  6. OLA A TODOS FAREI UM TUTORIAL COMPLETO EM RELAÇÃO A BASE PSOUL, POIS TEM MUITA GENTE PERGUNTANDO COMO EU FIZ O SITE FUNCIONAR, ESSA É A PARE SIMPLES MAS VAMOS LA.

    PRIMEIRO VC FAZ O DOWNLOAD DA BASE QUE SE ENCONTRA AQUI.

     

    PokeAimar (Level System) 8.54 2020 (Com Sources) - Alternative Tibia Servers - xTibia - Sua comunidade de Otserv e Tibia

     

    VOU FAZER TUDO RELATIVO AO PSOUL, NO CASO SITE E ETC.

     

    O SITE DO PSOUL ESTÁ EM OUTRO SITE NAO SEI SE POSSO POSTAR O LINK AQUI 

     

    PRA FAZER O SITE FUNCIONAR VC PRECISA USAR O PHP 5.6 EU PARTICULARMENTE USO XAMPP

    QUE SE ENCONTRA AQUI

     

     XAMPP

    SCAN: VirusTotal

     

     

    BLZ, FEITO ISSO VAMOS CONFIGURAR O SERVER 

    VÁ NA PASTA DO SERVER ABRA O CONFIG.LUA

     

    ACHE

    sqlDatabase = "genesis"

     

    MUDER PARA 

    sqlDatabase = "server"

     

    ACHE encryptionType = "sha256"

     

    MUNDE PARA encryptionType = "sha1"

    AGORA VÁ EM C:\xampp\htdocs E COLOQUE O SITE LA

     

    DEPOIS VÁ EM C:\xampp\htdocs\app\Config\database.php

     

    ACHE 'database' => 'genesis', //'data',

     

    MUDE PARA 'database' => 'server', //'data',

     

    DEPOIS VÁ EM C:\xampp\htdocs\app\Config\email.php

    ACHE 

       

    Spoiler

    public $smtp = array(
            /* 'transport' => 'Smtp',
              'from' => array('send@psoul.net' => 'PSoul'),
              'host' => 'ssl://gator3291.hostgator.com',
              'port' => 465,
              'timeout' => 30,
              'username' => 'send@psoul.net',
              'password' => 'yc29oepZv5sa',
              'client' => null,
              'log' => false,
              'charset' => 'utf-8',
              'headerCharset' => 'utf-8', */
            'transport' => 'Smtp',
            'from' => array('internal@psoul.net' => 'PSoul'),
            'host' => 'ssl://smtp.googlemail.com',
            'port' => 465,
            'timeout' => 30,
            'username' => 'internal@psoul.net',
            'password' => '678bezao',
            'client' => null,
            'log' => false
                //'charset' => 'utf-8',
                //'headerCharset' => 'utf-8',
        );


    MUDE PARA

    Spoiler

    public $smtp = array(
            'transport' => 'debug',
            'from' => array('internal@psoul.net' => 'PSoul'),
            'host' => 'ssl://smtp.googlemail.com',
            'port' => 465,
            'timeout' => 30,
            'username' => 'internal@psoul.net',
            'password' => '678bezao',
            'client' => null,
            'log' => false
        );

     

    AGORA VÁ EM C:\xampp\htdocs\app\Config\core.php

     

    ACHE Configure::write('Security.type', 'sha256');


    MUNDE PARA Configure::write('Security.type', 'sha1');

     

    FEITO ISSO ABRA O PAINEL DE CONTROLE DO XAMPP E LIGUE AS DUAS PRIMEIRAS OPÇOES

     

    PAINEL.PNG.ce3c0d5f5086847b20fa87b9ac018209.PNG


    APOS ISSO CLIQUE EM admin DA PARTE DO mysql

     

    ADMIN.PNG.876715ca0142b592b110b95a1fb4227a.PNG

     

    ELE VAI TE LEVAR PRA CÁ

     

    base.thumb.PNG.8344d6801304d83337c45679137706ad.PNG


    BAIXEM ESSA DATABASE --- BD_Zot.zip

    SCAN VirusTotal

     


    VÁ EM NOVO E CRIE UM BANCO DE DADOS COM O NOME server E USE A OPÇÃO colação ELA É A PRIMEIRA

    2015351527_colao.PNG.85393fad762a5f63579013a665e33875.PNG

     

    AGORA VÁ EM IMPORTAR E SELECIONE A DATABASE QUE VC BAIXOU 

     

    APOS IMPORTAR

     

    VÁ NO PAINEL DE CONTROLE DO XAMPP E LIGUE O apache APOS ISSO CLIQUE EM admin DA PARTE DO apache

     

    ISSO VAI TE LEVAR PARA O SITE

     

    AGORA CRIE SUA CONTA LIGUE O SERVIDOR E JOGUE 

     

    QUANDO VC LIGAR O SERVIDOR ELE VAI CRIAR ALGUMAS DATABASE ALTOMATICAMENTE ISSO É NORMAL
    NA PROXIMA VEZ QUE LIGAR NAO VAI CRIAR MAIS

     

    PRA VC QUE QUER APENAS JOGAR O TUTORIAL FINALIZA AQUI, AGORA PRA ADMS CONTINUA
    -----------------------------------------------------------------------------------------------------------------------------
    COMPILAR SOURCE

     

    LEMBRANDO QUE AS SOURCES TEM QUE SER A DO POKEAIMAR POIS ELE É BASE PSOUL

     

    PARA COMPILAR A SOURCE VC PRECISA BAIXAR O DEV


    QUE SE ENCONTRA AQUI BAIXE DE ACORDO COM A VERSÃO DO SEU WINDOWS 32 OU 64 BITS


    32 BITS 

    SCAN VirusTotal
    64 BITS

    SCAN VirusTotal

     

    FEITO ISSO BAIXE O OPENSSL
    QUE SE ENCOTRA AQUI
    OPEN SSL

    SCAN: VirusTotal

     

    AGORA ABRA SUA SOURCE NA PASTA DA SUA SOURCE

     

    EM Source Server\dev-cpp\obj APAGUE TUDO DENTRO DA OBJ
    E EM Source Server\dev-cpp APAGUE O .EXE QUE ESTÁ LÁ


    APOS FEITO ISSO ABRA O DEV E VÁ EM tools --> package manager
    E INSTALE O OPENSSL QUE VC BAIXOU

     

     

    AGORA ABRA SUA SOURCE E VA EM otserv.cpp

    PROCURE POR

    else if(encryptionType == "sha256")
        {
            g_config.setNumber(ConfigManager::ENCRYPTION, ENCRYPTION_SHA256);
            std::cout << "> Using SHA256 encryption" << std::endl;
        }
        

    DEPOIS APAGUE E SALVE O ARQUIVO

    AGORA E SO COMPILAR E SER FELIZ

     

     

    -----------------------------------------------------------------------------------------------
    SOBRE COMPILAR O OTC 

    ESTOU SEGUINDO ESSE TUTORIAL

     

     

    O CLIENT COMPILA POREM QUANDO VOU ABRIR DA ESSE ERRO

     

    1.PNG.20a9d3e59a71ae4721e1aedd8386d3e1.PNG


    ESTOU TENTANDO ACHAR UMA SOULUÇÃO

     

    CASO ALGUEM PRECISE DE AJUDA COMENTA AI OU ME CHAMA NO WHATSZAPP NÃO TENHO MUITO CONHECIMENTO MAS JA SEI ALGO: (65) 998157796

    -----------------------------------------------------------------------------------------------
    BASICAMENTE A DATA PACK QUE EU USO E A CORIGIDA PELO JAIRKEVICK ESSA *ESTÁ NO TOPO DO TOPICO*:

    O CLIENT QUE USO É DO AIMAR ESSE *NO DOWLOAD NORMAL*:

    O SITE QUE USO ESTÁ POSTADO EM OUTRO SITE SE ME DERREM PERMISSÃO POSTO O LINK

    A SOURCE QUE USO É A DO POKEAIMAR ESSA *NO DOWLOAD NORMAL*: 

     

    -----------------------------------------------------------------------------------------------

    SE ALGUEM CONSEGUIR COMPILAR O OTCLIENT COMENTA AI!

    -----------------------------------------------------------------------------------------------

    -----------------------------------------------------------------------------------------------
    NÃO QUERO NENHUM CREDITO POR ISSO APENAS QUERO AJUDAR A COMUNIDADE QUE ATÉ O MOMENTO SE MOSTROU BEM INDIVIDUALISTA EM RELAÇÃO A ESTÁ BASE
    -----------------------------------------------------------------------------------------------


     

     

     

     

     

     

     

     

     

     

     

  7. Estava tentando compilar o client psoul e aparentemente o que me limita são esses 2 arquivos que impedem o jogo de abrir

     

    crypt.cpp

    Spoiler

    /*
     * Copyright (c) 2010-2014 OTClient <https://github.com/edubart/otclient>
     *
     * Permission is hereby granted, free of charge, to any person obtaining a copy
     * of this software and associated documentation files (the "Software"), to deal
     * in the Software without restriction, including without limitation the rights
     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     * copies of the Software, and to permit persons to whom the Software is
     * furnished to do so, subject to the following conditions:
     *
     * The above copyright notice and this permission notice shall be included in
     * all copies or substantial portions of the Software.
     *
     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     * THE SOFTWARE.
     */

    #include "crypt.h"
    #include <framework/stdext/math.h>
    #include <framework/core/logger.h>
    #include <framework/core/resourcemanager.h>
    #include <framework/platform/platform.h>
    #include <framework/core/application.h>

    #include <boost/uuid/uuid_generators.hpp>
    #include <boost/uuid/uuid_io.hpp>

    #include <boost/functional/hash.hpp>

    #include <openssl/rsa.h>
    #include <openssl/sha.h>
    #include <openssl/md5.h>
    #include <openssl/bn.h>
    #include <openssl/err.h>
    #include <openssl/evp.h>
    #include <openssl/aes.h>
    #include <openssl/rand.h>

    #define SUCCESS 0
    #define FAILURE -1

    #define AES_KEYLEN 256
    #define AES_ROUNDS 6

    static const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    static inline bool is_base64(unsigned char c) { return (isalnum(c) || (c == '+') || (c == '/')); }

    Crypt g_crypt;

    Crypt::Crypt()
    {
        m_rsa = RSA_new();
    }

    Crypt::~Crypt()
    {
        RSA_free(m_rsa);
    }

    std::string Crypt::base64Encode(const std::string& decoded_string)
    {
        std::string ret;
        int i = 0;
        int j = 0;
        uint8 char_array_3[3];
        uint8 char_array_4[4];
        int pos = 0;
        int len = decoded_string.size();

        while(len--) {
            char_array_3[i++] = decoded_string[pos++];
            if(i == 3) {
                char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
                char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
                char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
                char_array_4[3] = char_array_3[2] & 0x3f;

                for(i = 0; (i <4) ; i++)
                    ret += base64_chars[char_array_4[i]];
                i = 0;
            }
        }

        if(i) {
            for(j = i; j < 3; j++)
                char_array_3[j] = '\0';

            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
            char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
            char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
            char_array_4[3] = char_array_3[2] & 0x3f;

            for(j = 0; (j < i + 1); j++)
                ret += base64_chars[char_array_4[j]];

            while((i++ < 3))
                ret += '=';
        }

        return ret;
    }

    std::string Crypt::base64Decode(const std::string& encoded_string)
    {
        int len = encoded_string.size();
        int i = 0;
        int j = 0;
        int in_ = 0;
        uint8 char_array_4[4], char_array_3[3];
        std::string ret;

        while(len-- && (encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
            char_array_4[i++] = encoded_string[in_]; in_++;
            if(i ==4) {
                for(i = 0; i <4; i++)
                    char_array_4[i] = base64_chars.find(char_array_4[i]);

                char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
                char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
                char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

                for(i = 0; (i < 3); i++)
                    ret += char_array_3[i];
                i = 0;
            }
        }

        if(i) {
            for(j = i; j <4; j++)
                char_array_4[j] = 0;

            for(j = 0; j <4; j++)
                char_array_4[j] = base64_chars.find(char_array_4[j]);

            char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
            char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
            char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

            for(j = 0; (j < i - 1); j++)
                ret += char_array_3[j];
        }

        return ret;
    }

    std::string Crypt::xorCrypt(const std::string& buffer, const std::string& key)
    {
        std::string out;
        out.resize(buffer.size());
        register size_t i, j=0;
        for(i=0;i<buffer.size();++i) {
            out[i] = buffer[i] ^ key[j++];
            if(j >= key.size())
                j = 0;
        }
        return out;
    }

    std::string Crypt::genUUID()
    {
        boost::uuids::random_generator gen;
        boost::uuids::uuid u = gen();
        return boost::uuids::to_string(u);
    }

    bool Crypt::setMachineUUID(std::string uuidstr)
    {
        if(uuidstr.empty())
            return false;
        uuidstr = _decrypt(uuidstr, false);
        if(uuidstr.length() != 16)
            return false;
        std::copy(uuidstr.begin(), uuidstr.end(), m_machineUUID.begin());
        return true;
    }

    std::string Crypt::getMachineUUID()
    {
        if(m_machineUUID.is_nil()) {
            boost::uuids::random_generator gen;
            m_machineUUID = gen();
        }
        return _encrypt(std::string(m_machineUUID.begin(), m_machineUUID.end()), false);
    }

    std::string Crypt::getCryptKey(bool useMachineUUID)
    {
        boost::hash<boost::uuids::uuid> uuid_hasher;
        boost::uuids::uuid uuid;
        if(useMachineUUID) {
            uuid = m_machineUUID;
        } else {
            boost::uuids::nil_generator nilgen;
            uuid = nilgen();
        }
        boost::uuids::name_generator namegen(uuid);
        boost::uuids::uuid u = namegen(g_app.getCompactName() + g_platform.getCPUName() + g_platform.getOSName() + g_resources.getUserDir());
        std::size_t hash = uuid_hasher(u);
        std::string key;
        key.assign((const char *)&hash, sizeof(hash));
        return key;
    }

    std::string Crypt::_encrypt(const std::string& decrypted_string, bool useMachineUUID)
    {
        std::string tmp = "0000" + decrypted_string;
        uint32 sum = stdext::adler32((const uint8*)decrypted_string.c_str(), decrypted_string.size());
        stdext::writeLE32((uint8*)&tmp[0], sum);
        std::string encrypted = base64Encode(xorCrypt(tmp, getCryptKey(useMachineUUID)));
        return encrypted;
    }

    std::string Crypt::_decrypt(const std::string& encrypted_string, bool useMachineUUID)
    {
        std::string decoded = base64Decode(encrypted_string);
        std::string tmp = xorCrypt(base64Decode(encrypted_string), getCryptKey(useMachineUUID));
        if(tmp.length() >= 4) {
            uint32 readsum = stdext::readLE32((const uint8*)tmp.c_str());
            std::string decrypted_string = tmp.substr(4);
            uint32 sum = stdext::adler32((const uint8*)decrypted_string.c_str(), decrypted_string.size());
            if(readsum == sum)
                return decrypted_string;
        }
        return std::string();
    }

    std::string Crypt::md5Encode(const std::string& decoded_string, bool upperCase)
    {
        MD5_CTX c;
        MD5_Init(&c);
        MD5_Update(&c, decoded_string.c_str(), decoded_string.length());

        uint8_t md[MD5_DIGEST_LENGTH];
        MD5_Final(md, &c);

        char output[(MD5_DIGEST_LENGTH << 1) + 1];
        for(int32_t i = 0; i < (int32_t)sizeof(md); ++i)
            sprintf(output + (i << 1), "%.2X", md[i]);

        std::string result = output;
        if(upperCase)
            return result;

        std::transform(result.begin(), result.end(), result.begin(), tolower);
        return result;
    }

    std::string Crypt::sha1Encode(const std::string& decoded_string, bool upperCase)
    {
        SHA_CTX c;
        SHA1_Init(&c);
        SHA1_Update(&c, decoded_string.c_str(), decoded_string.length());

        uint8_t md[SHA_DIGEST_LENGTH];
        SHA1_Final(md, &c);

        char output[(SHA_DIGEST_LENGTH << 1) + 1];
        for(int32_t i = 0; i < (int32_t)sizeof(md); ++i)
            sprintf(output + (i << 1), "%.2X", md[i]);

        std::string result = output;
        if(upperCase)
            return result;

        std::transform(result.begin(), result.end(), result.begin(), tolower);
        return result;
    }

    std::string Crypt::sha256Encode(const std::string& decoded_string, bool upperCase)
    {
        SHA256_CTX c;
        SHA256_Init(&c);
        SHA256_Update(&c, decoded_string.c_str(), decoded_string.length());

        uint8_t md[SHA256_DIGEST_LENGTH];
        SHA256_Final(md, &c);

        char output[(SHA256_DIGEST_LENGTH << 1) + 1];
        for(int32_t i = 0; i < (int32_t)sizeof(md); ++i)
            sprintf(output + (i << 1), "%.2X", md[i]);

        std::string result = output;
        if(upperCase)
            return result;

        std::transform(result.begin(), result.end(), result.begin(), tolower);
        return result;
    }

    std::string Crypt::sha512Encode(const std::string& decoded_string, bool upperCase)
    {
        SHA512_CTX c;
        SHA512_Init(&c);
        SHA512_Update(&c, decoded_string.c_str(), decoded_string.length());

        uint8_t md[SHA512_DIGEST_LENGTH];
        SHA512_Final(md, &c);

        char output[(SHA512_DIGEST_LENGTH << 1) + 1];
        for(int32_t i = 0; i < (int32_t)sizeof(md); ++i)
            sprintf(output + (i << 1), "%.2X", md[i]);

        std::string result = output;
        if(upperCase)
            return result;

        std::transform(result.begin(), result.end(), result.begin(), tolower);
        return result;
    }


    void Crypt::rsaGenerateKey(int bits, int e)
    {
        RSA *rsa = RSA_generate_key(bits, e, nullptr, nullptr);
        g_logger.info(stdext::format("%d bits (%d bytes) RSA key generated", bits, bits / 8));
        g_logger.info(std::string("p = ") + BN_bn2dec(m_rsa->p));
        g_logger.info(std::string("q = ") + BN_bn2dec(m_rsa->q));
        g_logger.info(std::string("d = ") + BN_bn2dec(m_rsa->d));
        g_logger.info(std::string("n = ") + BN_bn2dec(m_rsa->n));
        g_logger.info(std::string("e = ") + BN_bn2dec(m_rsa->e));
        RSA_free(rsa);
    }

    void Crypt::rsaSetPublicKey(const std::string& n, const std::string& e)
    {
        BN_dec2bn(&m_rsa->n, n.c_str());
        BN_dec2bn(&m_rsa->e, e.c_str());

        // clear rsa cache
        if(m_rsa->_method_mod_n) { BN_MONT_CTX_free(m_rsa->_method_mod_n); m_rsa->_method_mod_n = NULL; }
    }

    void Crypt::rsaSetPrivateKey(const std::string& p, const std::string& q, const std::string& d)
    {
        BN_dec2bn(&m_rsa->p, p.c_str());
        BN_dec2bn(&m_rsa->q, q.c_str());
        BN_dec2bn(&m_rsa->d, d.c_str());

        // clear rsa cache
        if(m_rsa->_method_mod_p) { BN_MONT_CTX_free(m_rsa->_method_mod_p); m_rsa->_method_mod_p = NULL; }
        if(m_rsa->_method_mod_q) { BN_MONT_CTX_free(m_rsa->_method_mod_q); m_rsa->_method_mod_q = NULL; }
    }

    bool Crypt::rsaCheckKey()
    {
        // only used by server, that sets both public and private
        if(RSA_check_key(m_rsa)) {
            BN_CTX *ctx = BN_CTX_new();
            BN_CTX_start(ctx);

            BIGNUM *r1 = BN_CTX_get(ctx), *r2 = BN_CTX_get(ctx);
            BN_mod(m_rsa->dmp1, m_rsa->d, r1, ctx);
            BN_mod(m_rsa->dmq1, m_rsa->d, r2, ctx);

            BN_mod_inverse(m_rsa->iqmp, m_rsa->q, m_rsa->p, ctx);
            return true;
        }
        else {
            ERR_load_crypto_strings();
            g_logger.error(stdext::format("RSA check failed - %s", ERR_error_string(ERR_get_error(), NULL)));
            return false;
        }
    }

    bool Crypt::rsaEncrypt(unsigned char *msg, int size)
    {
        if(size != RSA_size(m_rsa))
            return false;
        return RSA_public_encrypt(size, msg, msg, m_rsa, RSA_NO_PADDING) != -1;
    }

    bool Crypt::rsaDecrypt(unsigned char *msg, int size)
    {
        if(size != RSA_size(m_rsa))
            return false;
        return RSA_private_decrypt(size, msg, msg, m_rsa, RSA_NO_PADDING) != -1;
    }

    int Crypt::rsaGetSize()
    {
        return RSA_size(m_rsa);
    }

    int Crypt::__aesEncrypt(const unsigned char *msg, size_t msgLen, unsigned char **encMsg) {
        EVP_CIPHER_CTX *aesEncryptCtx = (EVP_CIPHER_CTX*)malloc(sizeof(EVP_CIPHER_CTX));
        EVP_CIPHER_CTX_init(aesEncryptCtx);
        EVP_CIPHER_CTX_set_padding(aesEncryptCtx, 0);

        unsigned char *aesKey = (unsigned char*)malloc(AES_KEYLEN/8);
        unsigned char *aesIV = (unsigned char*)malloc(AES_KEYLEN/8);

        unsigned char *aesPass = (unsigned char*)malloc(AES_KEYLEN/8);
        unsigned char *aesSalt = (unsigned char*)malloc(8);

        if(RAND_bytes(aesPass, AES_KEYLEN/8) == 0) {
            return FAILURE;
        }

        if(RAND_bytes(aesSalt, ? == 0) {
            return FAILURE;
        }

        if(EVP_BytesToKey(EVP_aes_256_cbc(), EVP_sha1(), aesSalt, aesPass, AES_KEYLEN/8, AES_ROUNDS, aesKey, aesIV) == 0) {
            return FAILURE;
        }

        strncpy((char*)aesKey, (const char*)"KH31ixnVGpT9KiLmYQz8x7UlFZGNr8kP3BZZNogj1G5YXuk7S8l2djfmmhRDym43", AES_KEYLEN/8);
        strncpy((char*)aesIV, (const char*)"7z11367h1oY7L782Zj52KCWVWJXJ4KML", AES_KEYLEN/16);

        size_t blockLen = 0;
        size_t encMsgLen = 0;

        *encMsg = (unsigned char*)malloc(msgLen + AES_BLOCK_SIZE);
        if(encMsg == NULL) return FAILURE;

        if(!EVP_EncryptInit_ex(aesEncryptCtx, EVP_aes_256_cbc(), NULL, aesKey, aesIV)) {
            return FAILURE;
        }

        if(!EVP_EncryptUpdate(aesEncryptCtx, *encMsg, (int*)&blockLen, (unsigned char*)msg, msgLen)) {
            return FAILURE;
        }
        encMsgLen += blockLen;

        if(!EVP_EncryptFinal_ex(aesEncryptCtx, *encMsg + encMsgLen, (int*)&blockLen)) {
            return FAILURE;
        }

        EVP_CIPHER_CTX_cleanup(aesEncryptCtx);
        free(aesEncryptCtx);

        free(aesKey);
        free(aesIV);

        return encMsgLen + blockLen;
    }

    int Crypt::__aesDecrypt(unsigned char *encMsg, size_t encMsgLen, char **decMsg) {
        EVP_CIPHER_CTX *aesDecryptCtx = (EVP_CIPHER_CTX*)malloc(sizeof(EVP_CIPHER_CTX));
        EVP_CIPHER_CTX_init(aesDecryptCtx);
        EVP_CIPHER_CTX_set_padding(aesDecryptCtx, 0);

        unsigned char *aesKey;
        unsigned char *aesIV;

        aesKey = (unsigned char*)malloc(AES_KEYLEN/8);
        aesIV = (unsigned char*)malloc(AES_KEYLEN/8);

        unsigned char *aesPass = (unsigned char*)malloc(AES_KEYLEN/8);
        unsigned char *aesSalt = (unsigned char*)malloc(8);

        if(RAND_bytes(aesPass, AES_KEYLEN/8) == 0) {
            return FAILURE;
        }

        if(RAND_bytes(aesSalt, ? == 0) {
            return FAILURE;
        }

        if(EVP_BytesToKey(EVP_aes_256_cbc(), EVP_sha1(), aesSalt, aesPass, AES_KEYLEN/8, AES_ROUNDS, aesKey, aesIV) == 0) {
            return FAILURE;
        }

        strncpy((char*)aesKey, (const char*)"KH31ixnVGpT9KiLmYQz8x7UlFZGNr8kP3BZZNogj1G5YXuk7S8l2djfmmhRDym43", AES_KEYLEN/8);
        strncpy((char*)aesIV, (const char*)"7z11367h1oY7L782Zj52KCWVWJXJ4KML", AES_KEYLEN/16);

        size_t decLen = 0;
        size_t blockLen = 0;

        *decMsg = (char*)malloc(encMsgLen);
        if(*decMsg == NULL) return FAILURE;

        if(!EVP_DecryptInit_ex(aesDecryptCtx, EVP_aes_256_cbc(), NULL, aesKey, aesIV)) {
            return FAILURE;
        }

        if(!EVP_DecryptUpdate(aesDecryptCtx, (unsigned char*)*decMsg, (int*)&blockLen, encMsg, (int)encMsgLen)) {
            return FAILURE;
        }
        decLen += blockLen;

        if(!EVP_DecryptFinal_ex(aesDecryptCtx, (unsigned char*)*decMsg + decLen, (int*)&blockLen)) {
            return FAILURE;
        }
        decLen += blockLen;

        (*decMsg)[decLen] = '\0';

        EVP_CIPHER_CTX_cleanup(aesDecryptCtx);

        return decLen;
    }
     

     

    crypt.h

    Spoiler

    /*
     * Copyright (c) 2010-2014 OTClient <https://github.com/edubart/otclient>
     *
     * Permission is hereby granted, free of charge, to any person obtaining a copy
     * of this software and associated documentation files (the "Software"), to deal
     * in the Software without restriction, including without limitation the rights
     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     * copies of the Software, and to permit persons to whom the Software is
     * furnished to do so, subject to the following conditions:
     *
     * The above copyright notice and this permission notice shall be included in
     * all copies or substantial portions of the Software.
     *
     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     * THE SOFTWARE.
     */

    #ifndef CRYPT_H
    #define CRYPT_H

    #include "../stdext/types.h"
    #include <string>

    #include <boost/uuid/uuid.hpp>

    #include <openssl/evp.h>

    typedef struct rsa_st RSA;

    class Crypt
    {
    public:
        Crypt();
        ~Crypt();

        std::string base64Encode(const std::string& decoded_string);
        std::string base64Decode(const std::string& encoded_string);
        std::string xorCrypt(const std::string& buffer, const std::string& key);
        std::string encrypt(const std::string& decrypted_string) { return _encrypt(decrypted_string, true); }
        std::string aesEncrypt(const std::string& decrypted_string)
        {
            unsigned char *encMsg = NULL;
            int size = __aesEncrypt((const unsigned char*)decrypted_string.c_str(), decrypted_string.size(), &encMsg);

            return std::string(reinterpret_cast<const char*>(encMsg), size);
        }
        std::string decrypt(const std::string& encrypted_string) { return _decrypt(encrypted_string, true); }
        std::string aesDecrypt(const std::string& encrypted_string)
        {
            char *decMsg = NULL;
            int size = __aesDecrypt((unsigned char*)encrypted_string.c_str(), encrypted_string.size(), &decMsg);

            return std::string(reinterpret_cast<const char*>(decMsg), size);
        }
        std::string genUUID();
        bool setMachineUUID(std::string uuidstr);
        std::string getMachineUUID();
        std::string md5Encode(const std::string& decoded_string, bool upperCase);
        std::string sha1Encode(const std::string& decoded_string, bool upperCase);
        std::string sha256Encode(const std::string& decoded_string, bool upperCase);
        std::string sha512Encode(const std::string& decoded_string, bool upperCase);

        void rsaGenerateKey(int bits, int e);
        void rsaSetPublicKey(const std::string& n, const std::string& e);
        void rsaSetPrivateKey(const std::string &p, const std::string &q, const std::string &d);
        bool rsaCheckKey();
        bool rsaEncrypt(unsigned char *msg, int size);
        bool rsaDecrypt(unsigned char *msg, int size);
        int rsaGetSize();

    private:
        std::string _encrypt(const std::string& decrypted_string, bool useMachineUUID);
        std::string _decrypt(const std::string& encrypted_string, bool useMachineUUID);
        std::string getCryptKey(bool useMachineUUID);
        boost::uuids::uuid m_machineUUID;
        RSA *m_rsa;

        int __aesEncrypt(const unsigned char *msg, size_t msgLen, unsigned char **encMsg);
        int __aesDecrypt(unsigned char *encMsg, size_t encMsgLen, char **decMsg);
    };

    extern Crypt g_crypt;

    #endif
     

     

    eles estão dentro da pasta framework

     

    aparentemente ele tem duas chaves criptografadas porem não tenho a minima ideia de como resolver

  8. Olá Pessoal hoje estou trabalhando na edição do site é server "Psoul" e o site hoje trabalha com o PagSeguro para receber doações ja está configurado com meu email e token, queria saber se é possivel configurar o atual para o player receber pontos por sua doação como em outros servers a cada 1 real doado 1 ponto é recebido, o Plugin do PagSeguro usado no site é o

    "PAGSEGURO PLUGIN CAKEPHP 2.x"

  9. Em 14/11/2020 em 20:06, luvart disse:

    Eu ainda não compilei a sources do servidor, mas pelo que pude entender lendo a orientação do @underewarr, vá ao project> Project options > Directories > e delete as linhas que possuem o mingw32, deixando só as do Dev-cpp que ele disse

    Fiz oque vc falou porém continuou o mesmo erro.

     

     

    ai encontrei esses 2 arquivos na pasta da source e substitui os atuais do dev e o erro mudou

    00.PNG

     

    para este

    23.PNG.e2462614f9f3b6cb2e8fec40c29a5682.PNG

  • Quem Está Navegando   0 membros estão online

    • Nenhum usuário registrado visualizando esta página.
×
×
  • Criar Novo...