gfx/mysticview/src/Mystic_Keyfile.c

   1 /*********************************************************************
   2 ----------------------------------------------------------------------
   3
   4         MysticView
   5         keyfiles
   6
   7 ----------------------------------------------------------------------
   8 *********************************************************************/
   9
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <stdlib.h>
  13 #include <time.h>
  14
  15 #include <utility/tagitem.h>
  16 #include <workbench/startup.h>
  17 #include <workbench/workbench.h>
  18 #include <libraries/cybergraphics.h>
  19 #include <intuition/intuition.h>
  20 #include <exec/memory.h>
  21
  22 #include <clib/macros.h>
  23
  24 #include <proto/asl.h>
  25 #include <proto/exec.h>
  26 #include <proto/intuition.h>
  27 #include <proto/graphics.h>
  28 #include <proto/utility.h>
  29 #include <proto/guigfx.h>
  30 #include <proto/cybergraphics.h>
  31 #include <proto/wb.h>
  32 #include <proto/dos.h>
  33 #include <proto/intuition.h>
  34 #include <proto/gadtools.h>
  35 #include <proto/icon.h>
  36 #include <proto/render.h>
  37
  38 #include "Mystic_FileHandling.h"
  39 #include "Mystic_Subtask.h"
  40 #include "Mystic_Keyfile.h"
  41
  42 #include <assert.h>
  43
  44
  45
  46 void crcgen(unsigned long *table)
  47 {
  48         unsigned long   crc, poly;
  49         int     i, j;
  50
  51         poly = 0xEDB88320L;
  52         for (i=0; i<256; i++) {
  53                 crc = i;
  54                 for (j=8; j>0; j--) {
  55                         if (crc&1) {
  56                                 crc = (crc >> 1) ^ poly;
  57                         } else {
  58                                 crc >>= 1;
  59                         }
  60                 }
  61                 table[i] = crc;
  62         }
  63 }
  64
  65
  66 unsigned long getcrc(unsigned long *crctable, char *buffer, int buffersize)
  67 {
  68         register unsigned long crc;
  69         int i;
  70
  71         crc = 0xFFFFFFFF;
  72
  73         for (i = 0; i < buffersize; ++i)
  74         {
  75                 crc = ((crc>>8) & 0x00FFFFFF) ^ crctable[ (crc^buffer[i]) & 0xFF ];
  76         }
  77
  78         return( crc^0xFFFFFFFF );
  79 }
  80
  81
  82
  83
  84 BOOL getbit(char *buffer, int bitnr)
  85 {
  86         unsigned char mask = 1 << (7 - (bitnr & 7));
  87
  88         return (BOOL) !!(buffer[bitnr>>3] & mask);
  89 }
  90
  91
  92
  93 void setbit(char *buffer, int bitnr, BOOL bit)
  94 {
  95         unsigned char mask = 1 << (7 - (bitnr & 7));
  96
  97         buffer[bitnr>>3] &= ~mask;
  98         if (bit)
  99         {
 100                 buffer[bitnr>>3] |= mask;
 101         }
 102 }
 103
 104
 105 void decode(char *buffer, int buflen, unsigned long key)
 106 {
 107         int i;
 108         int bitlen;
 109         BOOL bit1, bit2;
 110         int pos1, pos2;
 111
 112         bitlen = buflen << 3;
 113
 114         Forbid();
 115
 116         srand(key^0x7f532c9a);
 117
 118         for (i = 0; i < buflen; ++i)
 119         {
 120                 buffer[i] ^= rand();
 121         }
 122
 123         Permit();
 124
 125         for (i = 0; i < bitlen / 2; ++i)
 126         {
 127                 pos1 = i;
 128                 pos2 = bitlen-i-1;
 129                 bit1 = !getbit(buffer, pos1);
 130                 bit2 = getbit(buffer, pos2);
 131                 setbit(buffer, pos1, bit2);
 132                 setbit(buffer, pos2, bit1);
 133         }
 134 }
 135
 136
 137
 138 BOOL CheckKey(void)
 139 {
 140         #ifndef REGISTERED
 141
 142         struct keyfile *keyfile;
 143         BOOL keyokay = FALSE;
 144
 145         if (keyfile = (struct keyfile *) FindSemaphore(mypersonalID))
 146         {
 147                 char *buffer;
 148
 149                 if (buffer = Malloc(keyfile->len))
 150                 {
 151                         ULONG crc;
 152
 153                         memcpy(buffer, keyfile->key, keyfile->len);
 154                         decode(buffer, keyfile->len, keyfile->len);
 155                         crc = getcrc(keyfile->crctable, buffer + 4, keyfile->len - 4);
 156
 157                         if (crc == *((ULONG *) buffer))
 158                         {
 159                                 keyokay = TRUE;
 160                         }
 161
 162                         srand(time(NULL));
 163
 164                         Free(buffer);
 165                 }
 166         }
 167
 168         return keyokay;
 169
 170         #else
 171
 172         return TRUE;
 173
 174         #endif
 175 }
 176
 177
 178 char *GetKeyLicensee(void)
 179 {
 180         #ifndef REGISTERED
 181
 182         struct keyfile *keyfile;
 183         char *name = NULL;
 184
 185         if (keyfile = (struct keyfile *) FindSemaphore(mypersonalID))
 186         {
 187                 char *buffer;
 188
 189                 if (buffer = Malloc(keyfile->len))
 190                 {
 191                         ULONG crc;
 192
 193                         memcpy(buffer, keyfile->key, keyfile->len);
 194                         decode(buffer, keyfile->len, keyfile->len);
 195                         crc = getcrc(keyfile->crctable, buffer + 4, keyfile->len - 4);
 196
 197                         if (crc == *((ULONG *) buffer))
 198                         {
 199                                 name = _StrDup(&buffer[13]);
 200                         }
 201
 202                         srand(time(NULL));
 203
 204                         Free(buffer);
 205                 }
 206         }
 207
 208         return name;
 209
 210         #else
 211
 212         return NULL;
 213
 214         #endif
 215 }
 216
 217
 218
 219
 220
 221
 222
 223 /*********************************************************************
 224 ----------------------------------------------------------------------
 225
 226         RemoveKey(keyfile)
 227
 228         remove keyfile from memory.
 229
 230 ----------------------------------------------------------------------
 231 *********************************************************************/
 232
 233 void RemoveKey(struct keyfile *keyfile)
 234 {
 235         #ifndef REGISTERED
 236
 237         if (keyfile)
 238         {
 239                 RemSemaphore(&keyfile->semaphore);
 240                 Free(keyfile->key);
 241                 Free(keyfile);
 242         }
 243
 244         #endif
 245 }
 246
 247
 248 /*********************************************************************
 249 ----------------------------------------------------------------------
 250
 251         keyfile = InstallKey()
 252
 253         install keyfile in memory.
 254
 255 ----------------------------------------------------------------------
 256 *********************************************************************/
 257
 258 struct keyfile *InstallKey(void)
 259 {
 260         #ifndef REGISTERED
 261
 262         struct keyfile *keyfile;
 263
 264         BOOL success = FALSE;
 265         BPTR fp;
 266         struct FileInfoBlock ALIGNED fib;
 267
 268
 269         if (keyfile = Malloclear(sizeof(struct keyfile)))
 270         {
 271                 if (fp = Open("L:MysticView.key", MODE_OLDFILE))
 272                 {
 273                         ExamineFH(fp, &fib);
 274
 275                         keyfile->len = fib.fib_Size;
 276
 277                         if (keyfile->key = Malloc(keyfile->len))
 278                         {
 279                                 if (Read(fp, keyfile->key, keyfile->len) == keyfile->len)
 280                                 {
 281                                         keyfile->semaphore.ss_Link.ln_Name = mypersonalID;
 282                                         keyfile->semaphore.ss_Link.ln_Pri = 1;
 283                                         crcgen(keyfile->crctable);
 284                                         AddSemaphore(&keyfile->semaphore);
 285                                         success = TRUE;
 286                                 }
 287                         }
 288                         Close(fp);
 289                 }
 290         }
 291
 292         if (!success && keyfile)
 293         {
 294                 Free(keyfile->key);
 295                 Free(keyfile);
 296                 keyfile = NULL;
 297         }
 298
 299         return keyfile;
 300
 301         #else
 302
 303         return NULL;
 304
 305         #endif
 306 }