Saludos amigos

tengo una duda, tengo un API que me permite Cryptar el EXE, y esta en PellesC como logro compilar este API y enlazarlo con mis demas programas.

Con esto podemos darle un proteccion sl sistema que se ditribuye, generar un serial, si alguien le interesa el programa C.

se lo mando para que trabajemos en esto.

Saludos

tomafa@tutopia.com

Tomafa,

Ese API es libre ? Puede ser publicado aqui legalmente ?

Lo idóneo es que lo pongas aqui (en caso de estar permitido) y que lo revisemos

Si es Libre, el codigo es este, si necesitas algo más dime y te lo paso

include <string.h>

include "EXECryptor.h"

pragma optimize(none)

// reserve space & suppres compiler optimization
#define EMIT5 \
__asm { db 144,144,144,144,144 };

ifdef USE_API

extern bool EXECRYPTORAPI EXECryptor_IsAppProtected(void)
{
EMIT5
return false;
}

extern const char EXECRYPTORAPI * EXECryptor_GetEXECryptorVersion(void)
{
EMIT5
return "UNPROTECTED";
}

extern DWORD EXECRYPTORAPI EXECryptor_GetReleaseDate(void)
{
FILETIME t1,t2;
WORD dt,tt;
GetSystemTimeAsFileTime(&t1);
FileTimeToLocalFileTime(&t1,&t2);
FileTimeToDosDateTime(&t2,&dt,&tt);
return dt;
}

extern void GetReleaseDate(int Day, int Month, int Year)
{
DWORD dt = EXECryptor_GetReleaseDate();
Day = dt & 0x1F;
Month = (dt >> 5) & 0xF;
Year = (dt >> 9)+1980;
}

extern DWORD EXECRYPTORAPI EXECryptor_GetDate(void)
{
FILETIME t1,t2;
WORD dt,tt;
GetSystemTimeAsFileTime(&t1);
FileTimeToLocalFileTime(&t1,&t2);
FileTimeToDosDateTime(&t2,&dt,&tt);
return dt;
}

extern void SafeGetDate(int Day, int Month, int Year)
{
DWORD dt = EXECryptor_GetDate();
Day = dt & 0x1F;
Month = (dt >> 5) & 0xF;
Year = (dt >> 9)+1980;
}

extern DWORD EXECRYPTORAPI EXECryptor_GetHardwareID(void)
{
EMIT5
return 0;
}

extern void EXECRYPTORAPI EXECryptor_EncryptStr(const char Src, char Dst)
{
EMIT5
strcpy(Dst,Src);
}

extern void EXECRYPTORAPI EXECryptor_DecryptStr(const char Src, char Dst)
{
EMIT5
strcpy(Dst,Src);
}

extern void EXECRYPTORAPI EXECryptor_EncryptStrW(const wchar_t Src, wchar_t Dst)
{
EMIT5
wcscpy(Dst,Src);
}

extern void EXECRYPTORAPI EXECryptor_DecryptStrW(const wchar_t Src, wchar_t Dst)
{
EMIT5
wcscpy(Dst,Src);
}

extern int EXECRYPTORAPI EXECryptor_GetTrialDaysLeft(int TrialPeriod)
{
EMIT5
return TrialPeriod;
}

extern int EXECRYPTORAPI EXECryptor_GetTrialRunsLeft(int TrialRuns)
{
EMIT5
return TrialRuns;
}

static const char TestKeyPath = "Software\EXECryptorTestKeys";
static const wchar_t TestKeyPathW = L"Software\EXECryptorTestKeys";

extern bool EXECRYPTORAPI EXECryptor_SecureWrite(const char Name, const char Value)
{
DWORD Disposition;
HKEY KeyHandle;
if (RegCreateKeyExA(HKEY_CURRENT_USER, TestKeyPath, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL, &KeyHandle, &Disposition) == ERROR_SUCCESS) {
RegSetValueExA(KeyHandle, Name, 0, REG_BINARY, (CONST BYTE*)Value, (DWORD)strlen(Value)+1);
RegCloseKey(KeyHandle);
return true;
} else
return false;
}

extern bool EXECRYPTORAPI EXECryptor_SecureRead(const char Name, char Value)
{
HKEY KeyHandle;
DWORD sz,tp;
bool Result = false;
Value=0;
if (RegOpenKeyExA(HKEY_CURRENT_USER, TestKeyPath, 0, KEY_QUERY_VALUE, &KeyHandle) == ERROR_SUCCESS) {
tp=REG_BINARY;
if (RegQueryValueExA(KeyHandle, Name, NULL, &tp, NULL, &sz) == ERROR_SUCCESS) {
RegQueryValueExA(KeyHandle, Name, NULL, &tp, (BYTE)Value, &sz);
Result=true;
}
RegCloseKey(KeyHandle);
};
return Result;
}

bool EXECRYPTORAPI EXECryptor_SecureWriteW(const wchar_t Name, const wchar_t Value)
{
DWORD Disposition;
HKEY KeyHandle;
if (RegCreateKeyExW(HKEY_CURRENT_USER, TestKeyPathW, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL, &KeyHandle, &Disposition) == ERROR_SUCCESS) {
RegSetValueExW(KeyHandle, Name, 0, REG_BINARY, (CONST BYTE)Value, sizeof(wchar_t)(wcslen(Value)+1));
RegCloseKey(KeyHandle);
return true;
} else
return false;
}

bool EXECRYPTORAPI EXECryptor_SecureReadW(const wchar_t Name, wchar_t Value)
{
HKEY KeyHandle;
DWORD sz,tp;
bool Result = false;
Value=0;
if (RegOpenKeyExW(HKEY_CURRENT_USER, TestKeyPathW, 0, KEY_QUERY_VALUE, &KeyHandle) == ERROR_SUCCESS) {
tp=REG_BINARY;
if (RegQueryValueExW(KeyHandle, Name, NULL, &tp, NULL, &sz) == ERROR_SUCCESS) {
RegQueryValueExW(KeyHandle, Name, NULL, &tp, (BYTE)Value, &sz);
Result=true;
}
RegCloseKey(KeyHandle);
};
return Result;
}

extern int EXECRYPTORAPI EXECryptor_MessageBoxA(HWND hWnd, LPCSTR lpText,
LPCSTR lpCaption, UINT uType)
{
EMIT5
return MessageBoxA(hWnd, lpText, lpCaption, uType);
}

extern FARPROC EXECRYPTORAPI EXECryptor_GetProcAddr(HMODULE hModule, LPCSTR lpProcName)
{
EMIT5
return GetProcAddress(hModule, lpProcName);
}

extern void EXECRYPTORAPI EXECryptor_AntiDebug(void)
{
EMIT5
}

extern void EXECRYPTORAPI EXECryptor_ProtectImport(void)
{
EMIT5
}

endif

ifdef USE_CRYPT_REG

ifdef USE_STD_SERIALS

extern int EXECRYPTORAPI EXECryptor_VerifySerialNumber(const char RegName,
const char SerialNumber, TSerialNumberInfo SNInfo, const char HardwareID)
{
EMIT5
return vrOK;
}

extern int EXECRYPTORAPI EXECryptor_VerifySerialNumberW(const wchar_t RegistrationName,
const wchar_t SerialNumber, TSerialNumberInfo SNInfo, const wchar_t HardwareID)
{
EMIT5
return vrOK;
}

extern int EXECRYPTORAPI EXECryptor_DecodeSerialNumber(const char RegistrationName,
const char SerialNumber, TSerialNumberInfo SNInfo, const char HardwareID)
{
EMIT5
return vrOK;
}

extern int EXECRYPTORAPI EXECryptor_DecodeSerialNumberW(const wchar_t RegistrationName,
const wchar_t SerialNumber, TSerialNumberInfo SNInfo, const wchar_t HardwareID)
{
EMIT5
return vrOK;
}

else

extern void EXECRYPTORAPI EXECryptor_SetCodeKey(const void *Key, int Size)
{
EMIT5
}

endif

extern int EXECRYPTORAPI EXECryptor_IsRegistered(void)
{
EMIT5
return vrOK;
}

extern int EXECRYPTORAPI EXECryptor_RegConst_0(void)
{
EMIT5
return 0;
}

extern int EXECRYPTORAPI EXECryptor_RegConst_1(void)
{
EMIT5
return 1;
}

extern int EXECRYPTORAPI EXECryptor_RegConst_2(void)
{
EMIT5
return 2;
}

extern int EXECRYPTORAPI EXECryptor_RegConst_3(void)
{
EMIT5
return 3;
}

extern int EXECRYPTORAPI EXECryptor_RegConst_4(void)
{
EMIT5
return 4;
}

extern int EXECRYPTORAPI EXECryptor_RegConst_5(void)
{
EMIT5
return 5;
}

extern int EXECRYPTORAPI EXECryptor_RegConst_6(void)
{
EMIT5
return 6;
}

extern int EXECRYPTORAPI EXECryptor_RegConst_7(void)
{
EMIT5
return 7;
}

endif

Seguro que ese es el código correcto y completo ?

No veo en donde se encripte el EXE, ni se desencripte...