//antidebug.h

 

//antidebug lib v2.1

//Http://www.antidebuglib.com

 

#ifndef _ANTIDEBUG_H

#define _ANTIDEBUG_H

extern "C++"

{

         //no license

         //common function

 

         BOOL                 GJ_Create_ADL_Serial_Number(char* version,char* username,char* userinfofilename,char* pSN);

         BOOL                 GJ_GET_ADL_VERSION(char* adl_version);

         BOOL                 GJ_IsAntidebugWorking();

         BOOL                 GJ_Is_WindowNT();

 

         void                    GJ_Enable_AntiDebugLIB();     //The two functions can be invoked only when the AntiDebugLIB is idle.

         void                    GJ_Disable_AntiDebugLIB();    //So they usually have few chance to be invoked.

 

         //common function

         //no license

 

         //################################################################################

         //demo function

 

         //no license

 

         BOOL                 GJ_OpenAntidebug_demo(char* antidebug_userid, char* antidebug_licence_filename, UINT antidebug_append_data_len, BYTE* antidebug_append_data);

         BOOL                 GJ_OpenAntidebugB_demo(char* antidebug_userid, UINT Antidebug_licence_file_len,BYTE* Antidebug_licence_file, UINT antidebug_append_data_len, BYTE* antidebug_append_data);

         BOOL                 GJ_CloseAntidebug_demo();

 

         //no license

 

         void*         GJ_memcpy_demo( void *dest, const void *src, size_t count );

         void*         GJ_memset_demo( void *dest, int c, size_t count );

         char*         GJ_strcat_demo( char *strDestination, const char *strSource );

         char*         GJ_strcpy_demo( char *strDestination, const char *strSource );

 

         //demo arithmetic: +,-,*,/

 

         //demo dest=dest+src

         char&                                    GJ_add_demo(char& dest,char& src);

         unsigned char&                  GJ_add_demo(unsigned char& dest,unsigned char& src);

         signed char&                       GJ_add_demo(signed char& dest,signed char& src);

         int&                                        GJ_add_demo(int& dest,int& src);

         unsigned int&                      GJ_add_demo(unsigned int& dest,unsigned int& src);

         short int&                             GJ_add_demo(short int& dest,short int& src);

         unsigned short int&           GJ_add_demo(unsigned short int& dest,unsigned short int& src);

         long int&                               GJ_add_demo(long int& dest,long int& src);

         unsigned long int&             GJ_add_demo(unsigned long int& dest,unsigned long int& src);

 

         //dest=dest-src

         char&                                    GJ_sub_demo(char& dest,char& src);

         unsigned char&                  GJ_sub_demo(unsigned char& dest,unsigned char& src);

         signed char&                       GJ_sub_demo(signed char& dest,signed char& src);

         int&                                        GJ_sub_demo(int& dest,int& src);

         unsigned int&                      GJ_sub_demo(unsigned int& dest,unsigned int& src);

         short int&                             GJ_sub_demo(short int& dest,short int& src);

         unsigned short int&           GJ_sub_demo(unsigned short int& dest,unsigned short int& src);

         long int&                               GJ_sub_demo(long int& dest,long int& src);

         unsigned long int&             GJ_sub_demo(unsigned long int& dest,unsigned long int& src);

 

         //dest=dest%src

         char&                                    GJ_mod_demo(char& dest,char& src);

         unsigned char&                  GJ_mod_demo(unsigned char& dest,unsigned char& src);

         signed char&                       GJ_mod_demo(signed char& dest,signed char& src);

         int&                                        GJ_mod_demo(int& dest,int& src);

         unsigned int&                      GJ_mod_demo(unsigned int& dest,unsigned int& src);

         short int&                             GJ_mod_demo(short int& dest,short int& src);

         unsigned short int&           GJ_mod_demo(unsigned short int& dest,unsigned short int& src);

         long int&                               GJ_mod_demo(long int& dest,long int& src);

         unsigned long int&             GJ_mod_demo(unsigned long int& dest,unsigned long int& src);

 

         //dest=dest++

         char&                                    GJ_inc_demo(char& dest);

         unsigned char&                  GJ_inc_demo(unsigned char& dest);

         signed char&                       GJ_inc_demo(signed char& dest);

         int&                                        GJ_inc_demo(int& dest);

         unsigned int&                      GJ_inc_demo(unsigned int& dest);

         short int&                             GJ_inc_demo(short int& dest);

         unsigned short int&           GJ_inc_demo(unsigned short int& dest);

         long int&                               GJ_inc_demo(long int& dest);

         unsigned long int&             GJ_inc_demo(unsigned long int& dest);

 

         //dest<src

         bool                                       GJ_less_demo(char& dest,char& src);

         bool                                       GJ_less_demo(unsigned char& dest,unsigned char& src);

         bool                                       GJ_less_demo(signed char& dest,signed char& src);

         bool                                       GJ_less_demo(int& dest,int& src);

         bool                                       GJ_less_demo(unsigned int& dest,unsigned int& src);

         bool                                       GJ_less_demo(short int& dest,short int& src);

         bool                                       GJ_less_demo(unsigned short int& dest,unsigned short int& src);

         bool                                       GJ_less_demo(long int& dest,long int& src);

         bool                                       GJ_less_demo(unsigned long int& dest,unsigned long int& src);

 

         //demo custom function

 

         //<GJ_encrypt_custom_function_demo> Only used in another project.

         BOOL                 GJ_encrypt_custom_function_demo(BYTE* _custom_function,unsigned int n_custom_function_size,char* function_name);

 

         BYTE*                GJ_load_custom_function_demo(BYTE* custom_function_code,int custom_function_length);

 

         BOOL                 GJ_free_custom_function_demo(BYTE* _custom_function,int custom_function_length);

 

         //demo fountion

         //################################################################################

 

 

 

         //no license

         BOOL                 GJ_OpenAntidebug(char* antidebug_userid, char* antidebug_licence_filename, UINT antidebug_append_data_len, BYTE* antidebug_append_data);

         BOOL                 GJ_OpenAntidebugB(char* antidebug_userid, UINT Antidebug_licence_file_len,BYTE* Antidebug_licence_file, UINT antidebug_append_data_len, BYTE* antidebug_append_data);

         BOOL                 GJ_CloseAntidebug();

         //no license

 

         BOOL                 GJ_GetComputerID(BYTE pcid[32]);

         BOOL                 GJ_OpenFile(char* filename,UINT filepointer);

                                     //filename--must include absolute path, and the path must already existed. for example:"c:\\antidebug_file"

                                     //filepointer --setfilepointer in bytesize

                                     //If the file already exists, open it. If it does not, create the given file.

 

         BOOL                 GJ_ReadFile(LPVOID lpBuffer,DWORD nNumberOfBytesToRead,LPDWORD lpNumberOfBytesRead);

                                     //lpBuffer                               --receive data buffer

                                     //nNumberOfBytesToRead --want to read data number

                                     //lpNumberOfBytesRead  --actually read data number

                                     //the filepointer auto increase nNumberOfBytesToRead

 

         BOOL                 GJ_WriteFile(LPVOID lpBuffer,DWORD nNumberOfBytesToWrite,LPDWORD lpNumberOfBytesWrite);

                                     //lpBuffer                               --source data buffer

                                     //nNumberOfBytesToWrite --want to write data number

                                     //lpNumberOfBytesWrite --actually write data number

                                     //the filepointer auto nNumberOfBytesToWrite

 

         BOOL                 GJ_SetFilePointer(UINT filepointer);

         BOOL                 GJ_CloseFile();

                                     //NOTE:When don't operate the file,you must invoke the funtion GJ_CloseFile() to close the file.!!!

 

         int                        GJ_sprintf( char *buffer, const char *format, ... );

                                     //only for format: %d,%i,%u,%x,%X

                                     //datatype only for INT(int),UINT(unsigned int),LONG(long int),ULONG(unsigned long int)

                                     //for example:

                                     /*

                                     char                    buffer[100];

                                     INT                      X1=1;

                                     int                        X2=2;

                                     UINT                   X3=3;

                                     unsigned int      X4=4;

                                     LONG                 X5=5;

                                     long                    X6=6;

                                     ULONG              X7=7;

                                     unsigned long X8=8;

 

                                     GJ_sprintf(buffer,"X1=%05d X2=%i X3=%u X4=%x X5=%X X6=%d X7=%d X8=%08d",X1,X2,X3,X4,X5*X8,X6,X7,X8);

 

                                     //result: buffer "X1=00001 X2=2 X3=3 X4=4 X5=28 X6=6 X7=7 X8=00000008"

                                     */

 

         void*                   GJ_memcpy(void *dest, const void *src, size_t count);

         void*                   GJ_memset( void *dest, int c, size_t count );

 

         char*                  GJ_strcpy( char *strDestination, const char *strSource );

         wchar_t*            GJ_wcscpy( wchar_t *strDestination, const wchar_t *strSource );

 

         char*                  GJ_strncpy( char *strDest, const char *strSource, size_t count );

         wchar_t*            GJ_wcsncpy( wchar_t *strDest, const wchar_t *strSource, size_t count );

 

         int                        GJ_strcmp( const char *string1, const char *string2 );

         int                        GJ_wcscmp( const wchar_t *string1, const wchar_t *string2 );

 

         int                        GJ_strncmp( const char *string1, const char *string2, size_t count );

         int                        GJ_wcsncmp( const wchar_t *string1, const wchar_t *string2, size_t count );

 

 

         char*                  GJ_strchr( const char *string, int c );

         wchar_t*            GJ_wcschr( const wchar_t *string, wint_t c );

 

         char*                  GJ_strrchr( const char *string, int c );

         wchar_t*            GJ_wcsrchr( const wchar_t *string, wint_t c );

 

         size_t                  GJ_strspn( const char *string, const char *strCharSet );

         size_t                  GJ_wcsspn( const wchar_t *string, const wchar_t *strCharSet );

 

         char*                  GJ_strstr( const char *string, const char *strCharSet );

         wchar_t*            GJ_wcsstr( const wchar_t *string, const wchar_t *strCharSet );

 

         size_t                  GJ_strlen( const char *string );

         size_t                  GJ_wcslen( const wchar_t *string );

 

         char*                  GJ_strcat( char *strDestination, const char *strSource );

         wchar_t*            GJ_wcscat( wchar_t *strDestination, const wchar_t *strSource );

 

         char*                  GJ_strncat( char *strDest, const char *strSource, size_t count );

         wchar_t*            GJ_wcsncat( wchar_t *strDest, const wchar_t *strSource, size_t count );

 

         int                        GJ_atoi( const char *string );

         long                    GJ_atol( const char *string );

 

         int                        GJ_isdigit(int ch);

         int                        GJ_islower(int ch);

         int                        GJ_isupper(int ch);

         int                        GJ_isprint(int ch);

         int                        GJ_isspace(int ch);

 

         //arithmetic: +,-,*,/

 

         //dest=dest+src

         char&                                    GJ_add(char& dest,char& src);

         unsigned char&                  GJ_add(unsigned char& dest,unsigned char& src);

         signed char&                       GJ_add(signed char& dest,signed char& src);

         int&                                        GJ_add(int& dest,int& src);

         unsigned int&                      GJ_add(unsigned int& dest,unsigned int& src);

         short int&                             GJ_add(short int& dest,short int& src);

         unsigned short int&           GJ_add(unsigned short int& dest,unsigned short int& src);

         long int&                               GJ_add(long int& dest,long int& src);

         unsigned long int&             GJ_add(unsigned long int& dest,unsigned long int& src);

 

         //dest=dest-src

         char&                                    GJ_sub(char& dest,char& src);

         unsigned char&                  GJ_sub(unsigned char& dest,unsigned char& src);

         signed char&                       GJ_sub(signed char& dest,signed char& src);

         int&                                        GJ_sub(int& dest,int& src);

         unsigned int&                      GJ_sub(unsigned int& dest,unsigned int& src);

         short int&                             GJ_sub(short int& dest,short int& src);

         unsigned short int&           GJ_sub(unsigned short int& dest,unsigned short int& src);

         long int&                               GJ_sub(long int& dest,long int& src);

         unsigned long int&             GJ_sub(unsigned long int& dest,unsigned long int& src);

 

         //dest=dest*src

         char&                                    GJ_mul(char& dest,char& src);

         unsigned char&                  GJ_mul(unsigned char& dest,unsigned char& src);

         signed char&                       GJ_mul(signed char& dest,signed char& src);

         int&                                        GJ_mul(int& dest,int& src);

         unsigned int&                      GJ_mul(unsigned int& dest,unsigned int& src);

         short int&                             GJ_mul(short int& dest,short int& src);

         unsigned short int&           GJ_mul(unsigned short int& dest,unsigned short int& src);

         long int&                               GJ_mul(long int& dest,long int& src);

         unsigned long int&             GJ_mul(unsigned long int& dest,unsigned long int& src);

 

         //dest=dest/src

         char&                                    GJ_div(char& dest,char& src);

         unsigned char&                  GJ_div(unsigned char& dest,unsigned char& src);

         signed char&                       GJ_div(signed char& dest,signed char& src);

         int&                                        GJ_div(int& dest,int& src);

         unsigned int&                      GJ_div(unsigned int& dest,unsigned int& src);

         short int&                             GJ_div(short int& dest,short int& src);

         unsigned short int&           GJ_div(unsigned short int& dest,unsigned short int& src);

         long int&                               GJ_div(long int& dest,long int& src);

         unsigned long int&             GJ_div(unsigned long int& dest,unsigned long int& src);

 

         //dest=dest%src

         char&                                    GJ_mod(char& dest,char& src);

         unsigned char&                  GJ_mod(unsigned char& dest,unsigned char& src);

         signed char&                       GJ_mod(signed char& dest,signed char& src);

         int&                                        GJ_mod(int& dest,int& src);

         unsigned int&                      GJ_mod(unsigned int& dest,unsigned int& src);

         short int&                             GJ_mod(short int& dest,short int& src);

         unsigned short int&           GJ_mod(unsigned short int& dest,unsigned short int& src);

         long int&                               GJ_mod(long int& dest,long int& src);

         unsigned long int&             GJ_mod(unsigned long int& dest,unsigned long int& src);

 

         //dest=dest++

         char&                                    GJ_inc(char& dest);

         unsigned