On 01/02/2013 at 08:14, xxxxxxxx wrote:
Header
////////////////////////////////////////////////////////////////
// KDZSerial.h
////////////////////////////////////////////////////////////////
// Serial Number handling
////////////////////////////////////////////////////////////////
// V0.1 2011.04.21 Robert Templeton
////////////////////////////////////////////////////////////////
// Includes
#include "general.h"
#include "lib_sn.h"
// KDZSerial: Serial Number Hook Class
class KDZSerial : public SNHookClass
{
private:
// Data
char pcode[6];
const String SNPluginName;
// Methods
Bool checkSerial(const String& c4dsn, const String& sn);
public:
// Data
// - mode = 0 (not registered/not demo), 1 (demo), 2 (registered), 3 (C4D demo)
UCHAR mode;
LONG time;
// Methods
KDZSerial();
LONG SNCheck(const String& c4dsn, const String& sn, LONG regdate, LONG curdate);
void setPluginCode(const char* t_pcode);
const String& GetTitle();
};
////////////////////////////////////////////////////////////////
// KDZSerial.cpp
////////////////////////////////////////////////////////////////
// Serial Number handling
////////////////////////////////////////////////////////////////
// V0.1 2011.04.21 Robert Templeton
////////////////////////////////////////////////////////////////
// Includes
#ifdef MACOS
#include "Rijndael_Mac.h"
#else
#include "Rijndael.h"
#endif
#include "KDZSerial.h"
// Size of serial number string
#define ENTRY_SIZE 17
// KDZSerial: Serial Number Hook Class
// Methods
// - Constructor
//*---------------------------------------------------------------------------*
KDZSerial::KDZSerial() : SNPluginName(GeLoadString(KDZS_PLUGIN_NAME))
//*---------------------------------------------------------------------------*
{
mode = 0;
}
// - KDZSerial.setPluginCode
//*---------------------------------------------------------------------------*
void KDZSerial::setPluginCode(const char* t_pcode)
//*---------------------------------------------------------------------------*
{
memcpy(pcode, t_pcode, 6);
}
// - KDZSerial.checkSerial
//*---------------------------------------------------------------------------*
Bool KDZSerial::checkSerial(const String& c4dsn, const String& sn)
//*---------------------------------------------------------------------------*
{
// Key is 11-Digit C4D SN + 5-Char PluginCode + NullTerminator
char key[ENTRY_SIZE];
c4dsn.GetCString(&key[0], c4dsn.GetCStringLen()+1L, STRINGENCODING_7BIT);
memcpy(&key[11], &pcode[0], 6);
// Encrypt plugin serial no. using AES
char dout[ENTRY_SIZE] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
// One block testing
CRijndael oRijndael;
if (!oRijndael.MakeKey(&key[0], "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 16, 16))
{
return MessageSystem::Throw(GeLoadString(KDZERR_GENERAL), GeLoadString(KDZERR_SNMAKEKEY));
}
char din[ENTRY_SIZE];
memcpy(&din[0], &key[0], ENTRY_SIZE);
if (!oRijndael.EncryptBlock(din, dout))
{
return MessageSystem::Throw(GeLoadString(KDZERR_GENERAL), GeLoadString(KDZERR_SNENCRYPTION));
}
dout[16] = 0; // Null-terminate
UINT i;
UCHAR val;
// Convert to AlphaNumerics for user serial number entry
for (i = 0; i != 16; ++i)
{
val = (UCHAR)dout[i];
// Beyond AlphaNumerics
if (val > 122) val /= 3;
// Below AlphaNumberics
if (val < 48) val += 48;
// Between numerals and UC Alpha
if ((val > 57) && (val < 65)) val += 24;
// Between UC Alpha and LC Alpha
if ((val > 90) && (val < 97)) val += 12;
dout[i] = (char)val;
}
dout[16] = 0; // Null-terminate
sn.GetCString(&key[0], sn.GetCStringLen()+1L, STRINGENCODING_7BIT); //ENTRY_SIZE, St7bit);
// Check sn against Encrypted-AlphaNumericized dout
for (i = 0; i != 16; ++i)
{
//GePrint("key["+LongToString(i)+"]=\'"+LongToString(key[i])+"\' == chk["+LongToString(i)+"]=\'"+LongToString(dout[i])+"\'");
if (key[i] != dout[i])
{
return MessageSystem::Throw(GeLoadString(KDZERR_GENERAL), GeLoadString(KDZERR_SNINVALID));
}
}
return TRUE;
}
// - SNHookClass.SNCheck
//*---------------------------------------------------------------------------*
LONG KDZSerial::SNCheck(const String& c4dsn, const String& sn, LONG regdate, LONG curdate)
//*---------------------------------------------------------------------------*
{
if (!sn.Content()) return SN_WRONGNUMBER;
// Demo mode (30 day trial)
if (sn.GetLength() == 4L)
{
// Case-insensitive serial number 'demo'
String demo = sn.ToLower();
if (demo.Compare("demo")) return SN_WRONGNUMBER;
if (!regdate)
{
mode = 1;
return SN_OKAY;
}
// Calculate timeout of Demo mode
// - elapsed time since registering demo
LONG exptime = curdate - regdate;
// - Number of demo days
LONG expiration = 30L;
LONG timeout = expiration-exptime;
if (timeout < 0L) return SN_EXPIRED;
time = timeout;
mode = 1;
if (exptime >= (expiration-3L)) return SN_EXPIRE_14 - timeout;
return SN_OKAY;
}
// Registered user
else if (sn.GetLength() == 16L)
{
if (checkSerial(c4dsn, sn))
{
mode = 2;
return SN_OKAY;
}
}
#ifdef C4D_R11
// Multi-License Server
else
{
// Check for R11 Multi-License
SerialInfo mlsn;
GeGetSerialInfo(SERIALINFO_MULTILICENSE, &mlsn);
if (mlsn.nr.Content())
{
//--------------------------------------------------------------------------------
// Note that we also need to skip over the extra data added to the front of the
// plugin's license key (11 digits/characters and a dash)...
//--------------------------------------------------------------------------------
String plug_sn = sn;
LONG dashPos;
if (plug_sn.FindFirst("-", &dashPos, 0L))
{
plug_sn = plug_sn.SubStr(dashPos+1L, plug_sn.GetLength()-dashPos-1L);
if (checkSerial(mlsn.nr, plug_sn))
{
mode = 2;
return SN_OKAY;
}
}
}
}
#else
else MessageSystem::Throw(GeLoadString(KDZERR_GENERAL), GeLoadString(KDZERR_SNSIZE));
#endif
return SN_WRONGNUMBER;
}
// - SNHookClass.GetTitle
//*---------------------------------------------------------------------------*
const String& KDZSerial::GetTitle()
//*---------------------------------------------------------------------------*
{
return SNPluginName;
}
////////////////////////////////////////////////////////////////
// Main.cpp
////////////////////////////////////////////////////////////////
// SymMorphy
////////////////////////////////////////////////////////////////
// V0.1 2011.05.25 Robert Templeton
////////////////////////////////////////////////////////////////
// Includes
#include "KDZSerial.h"
// - To allow future demo for users who have already demoed a previous version
// - Note that it is in the code to avoid user changing ID
enum
{
ID_SYMMORPHY_DEMO = 1029219
};
static KDZSerial* kdzSerial = NULL;
//*---------------------------------------------------------------------------*
Bool RegisterKDZSerial()
//*---------------------------------------------------------------------------*
{
kdzSerial = gNew KDZSerial();
if (!kdzSerial) return MessageSystem::Throw(GeLoadString(KDZERR_MEMORY), "Main.RegisterKDZSerial.kdzSerial");
char pcode[6] = "symmy";
kdzSerial->setPluginCode(&pcode[0]);
if (!kdzSerial->Register(ID_SYMMORPHY, SNFLAG_OWN))
return kdzSerial->Register(ID_SYMMORPHY_DEMO, SNFLAG_OWN);
return TRUE;
}
//*---------------------------------------------------------------------------*
void FreeKDZSerial()
//*---------------------------------------------------------------------------*
{
gDelete(kdzSerial);
}
// Plugin Functions ==================================================================================================
#include "SymMorphyDoc.h"
// Declare Global Plugin Registrants
Bool RegisterSymMorphyTag();
SymMorphyDoc* RegisterSymMorphyDoc();
Bool RegisterSymMorphySceneHook();
static SymMorphyDoc* symmorphydoc = NULL;
//*---------------------------------------------------------------------------*
Bool PluginStart()
//*---------------------------------------------------------------------------*
{
Bool network = FALSE;
#ifdef C4D_R12
VERSIONTYPE vtype = GeGetVersionType();
SYSTEMINFO stype = GeGetSystemInfo();
if ((vtype == VERSIONTYPE_NET_SERVER_3) || (vtype == VERSIONTYPE_NET_SERVER_UNLIMITED) || (vtype == VERSIONTYPE_NET_CLIENT)) network = TRUE;
if (stype & SYSTEMINFO_DEMO) GePrint("C4D Demo");
else if (stype & (SYSTEMINFO_SAVABLEDEMO|SYSTEMINFO_SAVABLEDEMO_ACTIVE)) GePrint("C4D Savable Demo");
#ifdef C4D_R13
else if (stype & (SYSTEMINFO_SAVABLEDEMO|SYSTEMINFO_STUDENT)) GePrint("C4D Student Demo");
#endif
else if (stype & SYSTEMINFO_COMMANDLINE) GePrint("C4D CommandLine");
else if ((vtype == VERSIONTYPE_NET_SERVER_3) || (vtype == VERSIONTYPE_NET_SERVER_UNLIMITED)) GePrint("C4D Server");
else if (vtype == VERSIONTYPE_NET_CLIENT) GePrint("C4D Client");
else
{
// serial number check
if (!(kdzSerial && kdzSerial->mode)) return ErrPrt(GeLoadString(KDZS_PLUGIN_NAME)+".Main.PluginStart:serial check failed!");
}
#elif defined C4D_R11
LONG vtype = GeGetVersionType();
if ((vtype & VERSION_SERVER) || (vtype & VERSION_NET)) network = TRUE;
if (vtype & VERSION_DEMO) GePrint("C4D Demo");
else if (vtype & VERSION_SAVABLE) GePrint("C4D Savable Demo");
else if (vtype & VERSION_SERVER) GePrint("C4D Server");
else if (vtype & VERSION_NET) GePrint("C4D Net");
// serial number check
else if (!(kdzSerial && kdzSerial->mode)) return ErrPrt(GeLoadString(KDZS_PLUGIN_NAME)+".Main.PluginStart:serial check failed!");
#else
LONG vtype = GeGetVersionType();
if ((vtype & VERSION_SERVER) || (vtype & VERSION_NET)) network = TRUE;
if (!((vtype & VERSION_DEMO) || network))
{
// serial number check
if (!(kdzSerial && kdzSerial->mode)) return ErrPrt(GeLoadString(KDZS_PLUGIN_NAME)+".Main.PluginStart:serial check failed!");
}
#endif
GePrint(" ");
GePrint(GeLoadString(KDZS_PLUGIN_BANNER));
GePrint("-- "+GeLoadString(KDZS_PLUGIN_NAME)+GeLoadString(KDZS_PLUGIN_EDITION)+"v"+GeLoadString(KDZS_PLUGIN_VERSION)+" "+GeLoadString(KDZS_PLUGIN_COPYRIGHT));
if (kdzSerial)
{
if (kdzSerial->mode == 1) GePrint("-- Trial: "+LongToString(kdzSerial->time)+" days left");
else if (kdzSerial->mode == 2)
{
SerialInfo si;
GeGetSerialInfo(SERIALINFO_CINEMA4D, &si);
GePrint("-- Licensed to: "+si.name);
}
}
GePrint(GeLoadString(KDZS_PLUGIN_BANNER));
GePrint(" ");
// Register hooks and return
// - SymMorphy Demo or Registered
symmorphydoc = RegisterSymMorphyDoc();
if (!symmorphydoc) return ErrPrt(GeLoadString(KDZS_PLUGIN_NAME)+".Main.PluginStart.RegisterSymMorphyDoc() failed!");
if (kdzSerial)
{
if (!symmorphydoc->Initialize(network, kdzSerial->mode, kdzSerial->time)) return ErrPrt(GeLoadString(KDZS_PLUGIN_NAME)+".Main.PluginStart.SymMorphyDoc.Initialize() failed!");
}
// - Cinema 4D Demo
else
{
if (!symmorphydoc->Initialize(network, 3L, 2147483647L)) return ErrPrt(GeLoadString(KDZS_PLUGIN_NAME)+".Main.PluginStart.SymMorphyDoc.Initialize() failed!");
}
if (!RegisterSymMorphyTag()) return ErrPrt(GeLoadString(KDZS_PLUGIN_NAME)+".Main.PluginStart.RegisterSymMorphyTag() failed!");
if (!RegisterSymMorphySceneHook()) return ErrPrt(GeLoadString(KDZS_PLUGIN_NAME)+".Main.PluginStart.RegisterSymMorphySceneHook() failed!");
return TRUE;
}
//*---------------------------------------------------------------------------*
void PluginEnd()
//*---------------------------------------------------------------------------*
{
}
//*---------------------------------------------------------------------------*
Bool PluginMessage(LONG id, void* data)
//*---------------------------------------------------------------------------*
{
if (id == C4DPL_INIT_SYS)
{
// initialize global resource object
if (!resource.Init()) return ErrPrt("Main.PluginMessage.resource.Init() failed!");
Bool network = FALSE;
Bool serial = TRUE;
// initialize and register Serial Number Hook
#ifdef C4D_R12
VERSIONTYPE vtype = GeGetVersionType();
SYSTEMINFO stype = GeGetSystemInfo();
if (stype & SYSTEMINFO_DEMO) { GePrint("C4D Demo"); serial = FALSE; }
else if (stype & (SYSTEMINFO_SAVABLEDEMO|SYSTEMINFO_SAVABLEDEMO_ACTIVE)) { GePrint("C4D Savable Demo"); serial = FALSE; }
#ifdef C4D_R13
else if (stype & (SYSTEMINFO_SAVABLEDEMO|SYSTEMINFO_STUDENT)) { GePrint("C4D Student Demo"); serial = FALSE; }
#endif
else if (stype & SYSTEMINFO_COMMANDLINE) { GePrint("C4D CommandLine"); serial = FALSE; }
if ((vtype == VERSIONTYPE_NET_SERVER_3) || (vtype == VERSIONTYPE_NET_SERVER_UNLIMITED)) { GePrint("C4D Server"); serial = FALSE; network = TRUE; }
else if (vtype == VERSIONTYPE_NET_CLIENT) { GePrint("C4D Net"); serial = FALSE; network = TRUE; }
#elif defined C4D_R11
LONG vtype = GeGetVersionType();
if (vtype & VERSION_SERVER) { GePrint("C4D Server"); serial = FALSE; network = TRUE; }
else if (vtype & VERSION_NET) { GePrint("C4D Net"); serial = FALSE; network = TRUE; }
else if (vtype & VERSION_DEMO) { GePrint("C4D Demo"); serial = FALSE; }
else if (vtype & VERSION_SAVABLE) { GePrint("C4D Savable Demo"); serial = FALSE; }
#else
LONG vtype = GeGetVersionType();
if (vtype & VERSION_SERVER) { serial = FALSE; network = TRUE; }
else if (vtype & VERSION_NET) { serial = FALSE; network = TRUE; }
else if (vtype & VERSION_DEMO) { serial = FALSE; }
#endif
// Allocate SymMorphy Data Storage
if (serial) return RegisterKDZSerial();
else return TRUE;
}
else if (id == C4DPL_ENDACTIVITY)
{
FreeKDZSerial();
return TRUE;
}
else if (id == C4DMSG_PRIORITY) return TRUE;
return FALSE;
}
// Return SymMorphyDoc* symmorphydoc - globally accessible
//*---------------------------------------------------------------------------*
SymMorphyDoc* GetSymMorphyDoc()
//*---------------------------------------------------------------------------*
{
return symmorphydoc;
}