Mensajes

probablemente aunque lo decodifiques (no es cifrado, es codificado) no tengas información util, ya que probablemente es solo un apuntador a una DB

ojo... tambien podría ser un cifrado exportado como binario, exportado como base64... pero igual... necesitas contraseña y saber que cifrado es

Bien, muchisimas gracias por la ayuda!

usualmente cuando veas un "/" en medio del codigo quiere decir que esos datos están en binario... es decir, ya no son ascii interpretables, posiblemente es un hash en su forma binaria con el que relacionan algo en una base de datos

Aaah, bien, interesante, entonces no hay forma de descifrarlo?

[pCrOMowze/3GAZ7NkYdcEQ==]

Buenas Días, estoy utilizando un sitio hecho en aspx, el cual antes dejaba las variables de la url descubiertas entonces era tan facil como cambiar edit=0 a 1 y podía hacer casi culquier cosa, el tema es que ahora todas las URL han cambiado a algo asi:

ladireccion.aspx?value=pCrOMowze/3GAZ7NkYdcEQ==

Ahora, Es un código BASE64 (creo o parece serlo) ahora, el problema es que no encuentro la forma de decodificarlo, en todos los decodificadores no me andubo, me da valores incoherentes. alguien me puede dar una mano?

B0 es la clave elegida por el diseñador, podría haber elegido cualquier otra.
Para veas como fue:
Lo primero fue contar los elementos en gProtectString3 y ver que eran los mismos más uno que el tamaño de la cadena que hay en el comentario, muemu.pl. Sabiendo esto podía decir que el los bytes eran la cadena codificada y B0 tenía que ser la codificación a '\0', que es 0 (o 00 si se miran los dos nibbles).
Después me fijé si había repeticiones: m y u se repiten y tienen los mismos bytes codificados, por tanto la codificación es byte a byte y no tiene en cuenta los demás como hace base64.
Tenía que encontrar ahora como se transformaba 0 a B0. Así que busqué una tabla ASCII en Google, ahora sabiendo como era cada carácter en esa notación podría sacar la fórmula usada para la conversión.
Cotejando el byte codificado y el de la tabla me di cuenta que solo cambiaba el nibble de más peso, el otro permanecía igual, por lo que solo debía concentrarme en ese.
A lo fácil. Probé de sumar B al primer nibble, pero no daba el resultado esperado. Así que probé sumar 5 al nibble codificado para ver si me llevaba al nibble del carácter original, tampoco.
Visto que no llegaba a ningún sitio transcribí tanto los nibbles de los caracteres como los bytes codificados a binario y los puse lado a lado y esta es la tabla que conseguí (sólo nibble de más peso):

Código [Seleccionar] Expandir

CAR     ASCII    CODIFICADO
m   : 6 (0110)    D (1101)
u   : 7 (0111)    C (1100)
e   : 6 (0110)    D (1101)
.   : 2 (0010)    9 (1001)
p   : 7 (0111)    C (1100)
l   : 6 (0110)    D (1101)
'\0': 0 (0000)    B (1011)

Un rápido vistazo se puede ver que el primer bit, el tercero y el cuarto se invierten mientras que el segundo sigue igual. La operación que hacer que un bit varíe, dentro de un grupo, es el XOR, y para que varíe el primer, el tercero y el cuarto debe el número a aplicar es el 1011 en binario o B en hexadecimal. Como el nibble de menos peso no varía se lleva XOR a 0 para ése, así que el byte entero a aplicar para la operación a todo el caracter codificado es B0.

Impresionante explicación y muy detallada. Muchas gracias y mis respetos hacia usted

Con un poquito de trabajo a nivel de bits he conseguido descubrir que el primer nibble está cifrado, por así decirlo. Para deshacerlo lo que debes hacer es un xor del byte entero con 0xB0.

P.ej.
DD XOR B0 = 6D (m)
C6 XOR B0 = 76 (u)

y así.

Así es. Muchísimas gracias!! Como la idea mía es aprender y disculpa si te molesta. Pero porque poniéndole B0 genera el valor correcto? Que significaría B0?

// Protect.h: interface for the CProtect class.
//
//////////////////////////////////////////////////////////////////////

#pragma once

#define PROTECT_START _asm _emit 0xEB _asm _emit 0x0E _asm _emit 0x14 _asm _emit 0x28 _asm _emit 0xCD _asm _emit 0xDB _asm _emit 0x50 _asm _emit 0x63 _asm _emit 0xAF _asm _emit 0x22 _asm _emit 0x75 _asm _emit 0xEE _asm _emit 0xB5 _asm _emit 0xD8 _asm _emit 0x43 _asm _emit 0x72
#define PROTECT_FINAL _asm _emit 0xEB _asm _emit 0x0E _asm _emit 0x37 _asm _emit 0xF2 _asm _emit 0xCD _asm _emit 0xDB _asm _emit 0x50 _asm _emit 0x63 _asm _emit 0xAF _asm _emit 0x22 _asm _emit 0x75 _asm _emit 0xEE _asm _emit 0xB5 _asm _emit 0xD8 _asm _emit 0x85 _asm _emit 0x61
#define CRASH_APPLICATION_MACRO _asm _emit 0xFF _asm _emit 0x25 _asm _emit 0x00 _asm _emit 0x00 _asm _emit 0x00 _asm _emit 0x00

enum eAuthServerType
{
   AUTH_SERVER_TYPE_NONE = 0,
   AUTH_SERVER_TYPE_S6_CONNECT_SERVER = 1,
   AUTH_SERVER_TYPE_S6_JOIN_SERVER = 2,
   AUTH_SERVER_TYPE_S6_DATA_SERVER = 3,
   AUTH_SERVER_TYPE_S6_GAME_SERVER = 4,
   AUTH_SERVER_TYPE_S8_CONNECT_SERVER = 5,
   AUTH_SERVER_TYPE_S8_JOIN_SERVER = 6,
   AUTH_SERVER_TYPE_S8_DATA_SERVER = 7,
   AUTH_SERVER_TYPE_S8_GAME_SERVER = 8,
   AUTH_SERVER_TYPE_S4_CONNECT_SERVER = 9,
   AUTH_SERVER_TYPE_S4_JOIN_SERVER = 10,
   AUTH_SERVER_TYPE_S4_DATA_SERVER = 11,
   AUTH_SERVER_TYPE_S4_GAME_SERVER = 12,
   AUTH_SERVER_TYPE_S2_CONNECT_SERVER = 13,
   AUTH_SERVER_TYPE_S2_JOIN_SERVER = 14,
   AUTH_SERVER_TYPE_S2_DATA_SERVER = 15,
   AUTH_SERVER_TYPE_S2_GAME_SERVER = 16,
};

enum eAuthServerStatus
{
   AUTH_SERVER_STATUS_NONE = 0,
   AUTH_SERVER_STATUS_SUCCESS = 1,
};

struct SDHP_AUTH_SERVER_DATA_RECV
{
   BYTE type; // C1:00
   BYTE size;
   BYTE head;
   BYTE EncKey;
   BYTE ServerType;
   BYTE Status;
   BYTE PackageType;
   BYTE PlanType;
   char CustomerName[32];
   char CustomerHardwareId[36];
};

struct SDHP_AUTH_SERVER_DATA_SEND
{
   BYTE type; // C1:00
   BYTE size;
   BYTE head;
   BYTE EncKey;
   BYTE ServerType;
   char CustomerName[32];
   char CustomerHardwareId[36];
};

class CProtect
{
public:
   CProtect();
   virtual ~CProtect();
   bool GetComputerHardwareId();
   bool ConnectToAuthServer(char* IpAddress,WORD port);
   bool AuthServerDataSend(eAuthServerType ServerType);
   void StartAuth(eAuthServerType ServerType);
   inline void ErrorMessageBox();
   inline void SafeExitProcess();
   void ProtectBlock(DWORD size);
   void ReleaseBlock(DWORD size);
   void DecryptBlock(BYTE* data,int size);
   void EncryptBlock(BYTE* data,int size);
   inline void InsertMemoryMacro(BYTE* data,BYTE* info,int size);
   inline void RemoveMemoryMacro(BYTE* data,BYTE* info,int size);
   inline bool VerifyMemoryMacro(BYTE* data,BYTE* info,int size);
   bool GetInsertStartBlock(DWORD start_offset,DWORD final_offset,DWORD* start_block);
   bool GetInsertFinalBlock(DWORD start_offset,DWORD final_offset,DWORD* final_block);
   bool GetRemoveStartBlock(DWORD start_offset,DWORD final_offset,DWORD* start_block);
   bool GetRemoveFinalBlock(DWORD start_offset,DWORD final_offset,DWORD* final_block);
   char* GetEncryptedString(BYTE* string,int size);
public:
   SOCKET m_socket;
   char m_ComputerHardwareId[36];
   BYTE m_EncKey;
   SDHP_AUTH_SERVER_DATA_RECV m_AuthInfo;
};

extern CProtect gProtect;

static const BYTE gProtectTable[16] = {0xC8,0x9D,0x24,0xC2,0x10,0xDD,0xE1,0x66,0xF3,0x5D,0x35,0xD2,0xA8,0x96,0xC5,0x48};
static const BYTE gProtectInsertStart[16] = {0x74,0x91,0x8B,0xB7,0x52,0x44,0xCF,0xFC,0x30,0xBD,0xEA,0x71,0x2A,0x47,0xDC,0xED}; //{0xEB,0x0E,0x14,0x28,0xCD,0xDB,0x50,0x63,0xAF,0x22,0x75,0xEE,0xB5,0xD8,0x43,0x72}
static const BYTE gProtectInsertFinal[16] = {0x74,0x91,0xA8,0x6D,0x52,0x44,0xCF,0xFC,0x30,0xBD,0xEA,0x71,0x2A,0x47,0x1A,0xFE}; //{0xEB,0x0E,0x37,0xF2,0xCD,0xDB,0x50,0x63,0xAF,0x22,0x75,0xEE,0xB5,0xD8,0x85,0x61}
static const BYTE gProtectRemoveStart[16] = {0x5C,0x74,0x92,0xB7,0x52,0x44,0xCF,0xFC,0x30,0xBD,0xEA,0x71,0x2A,0x47,0xDC,0xED}; //{0xC3,0xEB,0x0D,0x28,0xCD,0xDB,0x50,0x63,0xAF,0x22,0x75,0xEE,0xB5,0xD8,0x43,0x72}
static const BYTE gProtectRemoveFinal[16] = {0x5C,0x74,0x92,0x6D,0x52,0x44,0xCF,0xFC,0x30,0xBD,0xEA,0x71,0x2A,0x47,0x1A,0xFE}; //{0xC3,0xEB,0x0D,0xF2,0xCD,0xDB,0x50,0x63,0xAF,0x22,0x75,0xEE,0xB5,0xD8,0x85,0x61}
static BYTE gProtectString1[04] = {0xF3,0x8A,0xEC,0xB0}; //"C:\\"
static BYTE gProtectString2[20] = {0x95,0x80,0x88,0xE8,0x9D,0x95,0x80,0x88,0xE8,0x9D,0x95,0x80,0x88,0xE8,0x9D,0x95,0x80,0x88,0xE8,0xB0}; //"%08X-%08X-%08X-%08X"
static BYTE gProtectString3[10] = {0xDD,0xC5,0xD5,0xDD,0xC5,0x9E,0xC0,0xDC,0xB0}; //"muemu.pl"
static BYTE gProtectString4[35] = {0xF3,0xDF,0xC5,0xDC,0xD4,0x90,0xDE,0xDF,0xC4,0x90,0xD1,0xC5,0xC4,0xD8,0xD5,0xDE,0xC4,0xD9,0xD3,0xD1,0xC4,0xD5,0x90,0xC4,0xD8,0xD5,0x90,0xDD,0xD1,0xD3,0xD8,0xD9,0xDE,0xD5,0xB0}; //"Could not authenticate the machine"
static BYTE gProtectString5[06] = {0xF5,0xC2,0xC2,0xDF,0xC2,0xB0}; //"Error"

Ese es el codigo

Hazlo como cadena en vez de complicarte con una array. Si el fuente no lo has escrito tú, no es tuyo, tal vez no tenga o no sea eso el dominio; puede que sea la clave o puede que esté cifrado. Sin ver el fuente no se puede decir.

No tiene nada que ver qué yo no sea el dueño del código.
Y si se que es ese el dominio. muemu.pl

Static  BYTE Y lo puesto arriba

Más abajo hay otra variable en  la cual dice que no se puede autentificar la máquina con el mismo tipo de codificación. Si busco las letras del dominio en las del mensaje de error coinciden

Buenas tardes, me estoy complicando un poco con unos codigos hex que tengo en un Source...

La cosa es así, lo que estoy configurando es un sistema de licencia en el cual llama a un Servidor pero por codigo hex que seria el siguiente

{0xDD,0xC5,0xD5,0xDD,0xC5,0x9E,0xC0,0xDC,0xB0};

Yo se cual es el dominio al que apunta, pero busco por todos lados alguna forma de convertirlo y no hay forma que me coincida con las palabras que orignalmente va... Si yo convierto el dominio a Hex me da otros valores, que tipo de lenguaje seria entonces?

Por ejemplo si yo convierto de String a Hex me da la letra "m" que es igual a "6d"
Pero en mi source la letra "m" es igual a "DD" digamos todas las letras con yo convierto en ex coinciden solo con el segundo dígito de las que ya tengo. La primera no sé cómo la obtiene