intern/keymaker/keyloader.c

   1 /**
   2  * $Id$
   3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version. The Blender
   9  * Foundation also sells licenses for use in proprietary software under
  10  * the Blender License.  See http://www.blender.org/BL/ for information
  11  * about this.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21  *
  22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  23  * All rights reserved.
  24  *
  25  * The Original Code is: all of this file.
  26  *
  27  * Contributor(s): none yet.
  28  *
  29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  30  */
  31
  32 /* ex:ts=4 */
  33
  34 /**
  35  * $Id$
  36  * Copyright (C) 2001 NaN Technologies B.V.
  37  * Blender Key Read-tester
  38  */
  39
  40 #ifdef HAVE_CONFIG_H
  41 #include <config.h>
  42 #endif
  43
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47
  48 #include "key_pyc.h" /* the Python byte code */
  49 #include "blenkey.h"    /* the external interface */
  50 #include "key_internal.h"
  51
  52 #define TESTReadKeyFile 1
  53
  54 int Check_All_Byte_Calculus_Data(char *KeyBytePtr) {
  55         int i;
  56
  57         /* create some unique number arrays */
  58         int NoRealRandomArray[MAXBYTEDATABLOCK];
  59
  60         typedef byte (*funcpoin)(byte, byte);
  61         funcpoin checkfunc[] = {&checkfunc0, &checkfunc1, &checkfunc2,
  62                 &checkfunc3, &checkfunc4};
  63
  64         byte *KeyByteData = DeHexify(KeyBytePtr);
  65
  66         /* first create a fixed seed random number generator */
  67         sgenrand(666); /* seed it fixed */
  68
  69         /* initialize arrays with unique numbers */
  70         for (i=0; i<MAXBYTEDATABLOCK; i++) {
  71                 NoRealRandomArray[i] = i;
  72         }
  73         /* then stir the unique number lists */
  74         for (i=0; i<MAXBYTEDATABLOCK; i++) {
  75                 unsigned long randswap = genrand();
  76                 int swap1 = (int) (randswap % MAXBYTEDATABLOCK);
  77                 int swap2 = (int) ((randswap>>16) % MAXBYTEDATABLOCK);
  78                 int store = NoRealRandomArray[swap1];
  79                 /* printf("%lu %d %d\n", randswap, swap1, swap2); */
  80                 NoRealRandomArray[swap1] = NoRealRandomArray[swap2];
  81                 NoRealRandomArray[swap2] = store;
  82         }
  83         if (DEBUG) {
  84                 printf("\nFixed seed unique number random data: ");
  85                 for (i=0; i<MAXBYTEDATABLOCK; i++) {
  86                         printf("%d ", NoRealRandomArray[i]);
  87                 }
  88                 printf("\n\n");
  89         }
  90
  91         /* check our byte calculus functions on the random data */
  92         for (i=0; i<(MAXBYTEDATABLOCK-3); i+=3) {
  93                 if (DEBUG) {
  94                         char *Pcheckfunc[] = {"max", " - ", " + ", " * ", " / "};
  95                         printf("[%3d]=[%3d]%s[%3d]    ",
  96                                 NoRealRandomArray[i], NoRealRandomArray[i+1],
  97                                 Pcheckfunc[NoRealRandomArray[i]%5], NoRealRandomArray[i+2]);
  98                         printf("%3d%s%3d: %3d == %3d\n",
  99                                 KeyByteData[NoRealRandomArray[i+1]],
 100                                 Pcheckfunc[NoRealRandomArray[i]%5],
 101                                 KeyByteData[NoRealRandomArray[i+2]],
 102                                 KeyByteData[NoRealRandomArray[i]],
 103                                 checkfunc[(NoRealRandomArray[i]%5)](
 104                                         KeyByteData[NoRealRandomArray[i+1]],
 105                                         KeyByteData[NoRealRandomArray[i+2]]));
 106                 }
 107                 if (KeyByteData[NoRealRandomArray[i]] !=
 108                         checkfunc[(NoRealRandomArray[i]%5)](
 109                         KeyByteData[NoRealRandomArray[i+1]],
 110                         KeyByteData[NoRealRandomArray[i+2]])) {
 111                         printf("\nByte Checksum failed !\n");
 112                         return (1);
 113                 }
 114         }
 115         return (0);
 116 }
 117
 118 void pub_priv_test(char *HexPriv, char *HexPub)
 119 {
 120         RSA *rsa = NULL;
 121         /* static unsigned char rsa_e[] = "\x11"; */
 122         static unsigned char rsa_e[] = "\x01\x00\x01";
 123         byte cryptKey[16];
 124         byte *cryptedKey;
 125         byte *pubKey, *privKey;
 126         int pubKeyLen, privKeyLen;
 127         int deCryptKeyLen;
 128         unsigned char *deCryptKey;
 129         int cryptKeyLen = 16;
 130         int cryptedKeyLen;
 131
 132         strcpy(cryptKey, "abcdefghijklmno");
 133
 134         pubKey = DeHexify(HexPub);
 135         pubKeyLen = strlen(HexPub) / 2;
 136
 137         privKey = DeHexify(HexPriv);
 138         privKeyLen = strlen(HexPriv) / 2;
 139
 140         rsa = RSA_new();
 141         if (rsa == NULL) {
 142                 fprintf(stderr, "Error in RSA_new\n");
 143                 exit(1);
 144         }
 145         rsa->e = BN_bin2bn(rsa_e, sizeof(rsa_e)-1, rsa->e);
 146         rsa->n = BN_bin2bn(pubKey, pubKeyLen, rsa->n);
 147         rsa->d = BN_bin2bn(privKey, privKeyLen, rsa->d);
 148
 149         fprintf(stderr, "NOTE e %d, n %d, d %d rsa_size %d\n",
 150                         sizeof(rsa_e)-1, pubKeyLen, privKeyLen, RSA_size(rsa));
 151
 152         cryptedKey = malloc(RSA_size(rsa) * sizeof(byte));
 153         cryptedKeyLen = RSA_private_encrypt(cryptKeyLen, cryptKey,
 154                                                                                 cryptedKey, rsa, RSA_PKCS1_PADDING);
 155
 156         deCryptKey = malloc(RSA_size(rsa) * sizeof(unsigned char));
 157         deCryptKeyLen = RSA_public_decrypt(cryptedKeyLen, cryptedKey,
 158                                                                            deCryptKey, rsa, RSA_PKCS1_PADDING);
 159         if (deCryptKeyLen == -1) {
 160                 printf("Error in RSA_public_decrypt: %s\n",
 161                            ERR_error_string(ERR_get_error(), NULL));
 162                 exit(1);
 163         } else {
 164                 printf("RSA_public_decrypt test SUCCEEDED\n");
 165         }
 166
 167 }
 168
 169 #ifdef TESTReadKeyFile
 170 int main(int argc, char **argv) {
 171         int result;
 172         UserStruct User;
 173         char *HexPriv = NULL, *HexPub = NULL, *HexPython = NULL;
 174         byte *Byte = NULL;
 175         byte *PythonData = NULL;
 176         int PythonLength;
 177         char *HexByte = NULL;
 178
 179         if (argc != 2) {
 180                 printf("usage: %s keyfile\n", argv[0]);
 181                 exit(1);
 182         }
 183
 184         result = ReadKeyFile(argv[1], &User, &HexPriv, &HexPub, &Byte, &HexPython);
 185         if (result != 0) {
 186                 printf("\nReadKeyFile error %d\n", result);
 187                 exit(result);
 188         } else {
 189                 printf("\nReadKeyFile OK\n");
 190         }
 191
 192         /* just print the rsaPrivString and rsaPubString */
 193         if (DEBUG) printf("\nrsaPrivString: %s\n", HexPriv);
 194         if (DEBUG) printf("\nrsaPubString:  %s\n", HexPub);
 195
 196         /* try to private encrypt-public decrypt something */
 197         if (DEBUG) pub_priv_test(HexPriv, HexPub);
 198
 199         /* check all the Byte checksums
 200          rehexify it for our Check_All_Byte_Calculus_Data function ... */
 201         HexByte = Hexify(Byte, 1000);
 202         if (Check_All_Byte_Calculus_Data(HexByte) != 0) {
 203                 printf("\nByte_Calculus_Data checksums do not match !\n");
 204                 exit(1);
 205         } else {
 206                 if (DEBUG) printf("\nThe Byte Calculus Data checksums match\n");
 207         }
 208
 209         /* Check the KeyPythonPtr */
 210         PythonLength = strlen(HexPython)/2;
 211         PythonData = DeHexify(HexPython);
 212         if (memcmp(PythonData, g_keycode, PythonLength) != 0) {
 213                 printf("\nPython Byte code datablocks do not match !\n");
 214                 exit(1);
 215         } else {
 216                 if (DEBUG) printf("\nThe Python Byte code datablock matches\n");
 217         }
 218
 219         return(0);
 220 }
 221 #else
 222 int main(int argc, char **argv) {
 223         FILE *rawkeyfile;
 224         char *AsciiHash;
 225         char *HexCryptedData, *HexCryptedKey;
 226         int newlinetracker = 0; /* line position, counts from 0-71 */
 227         byte *CryptKey;
 228         char *KeyDataString;
 229         char *KeyDataPtr;
 230         char *mdhex;
 231         char *rsaPrivString;
 232         char *rsaPubString;
 233         char *KeyBytePtr;
 234         char *KeyPythonPtr;
 235         byte *PythonData;
 236         int PythonLength;
 237         UserStruct User;
 238
 239         if (argc != 2) {
 240                 printf("usage: %s keyfile\n", argv[0]);
 241                 exit(1);
 242         }
 243
 244         /* open keyfile for reading */
 245         if ((rawkeyfile = fopen(argv[1], "r")) == NULL) {
 246                 printf("error, cannot read %s\n", argv[1]);
 247                 exit(1);
 248         }
 249
 250         /* Scan and interpret the ASCII part */
 251         AsciiHash = scan_ascii(rawkeyfile, &User);
 252         if (DEBUG) printf("\nHexHash: %s\n", AsciiHash);
 253
 254         /* Read the HexCryptedData */
 255         HexCryptedData = ReadHexCryptedData(rawkeyfile, &newlinetracker);
 256         if (DEBUG) printf("\nHexCryptedData: %s\n", HexCryptedData);
 257
 258         /* Read the HexCryptedKey */
 259         HexCryptedKey = ReadHexCryptedKey(rawkeyfile, &newlinetracker);
 260         if (DEBUG) printf("\nHexCryptedKey: %s\n", HexCryptedKey);
 261
 262         /* close keyfile */
 263         fclose(rawkeyfile);
 264
 265         /* Decrypt HexCryptedKey */
 266         CryptKey = RSADecryptKey(HexCryptedKey);
 267
 268         /* Decrypt HexCryptedData */
 269         KeyDataString = DeCryptDatablock(CryptKey, 16, HexCryptedData);
 270         free(CryptKey);
 271         free(HexCryptedData);
 272         free(HexCryptedKey);
 273         if (DEBUG) printf("\nKeyDataString: %s\n", KeyDataString);
 274
 275         /* Extract data from KeyDataString */
 276         KeyDataPtr = KeyDataString;
 277
 278         mdhex         = get_from_datablock(&KeyDataPtr, "01");
 279         rsaPrivString = get_from_datablock(&KeyDataPtr, "02");
 280         rsaPubString  = get_from_datablock(&KeyDataPtr, "03");
 281         KeyBytePtr    = get_from_datablock(&KeyDataPtr, "04");
 282         KeyPythonPtr  = get_from_datablock(&KeyDataPtr, "05");
 283         free(KeyDataString);
 284
 285         /* Check ascii hash */
 286         if (strcmp(mdhex, AsciiHash) != 0) {
 287                 printf("Ascii part checksums do not match !\n");
 288                 printf("found: %s\n", mdhex);
 289                 printf("check: %s\n", AsciiHash);
 290                 exit(1);
 291         } else {
 292                 if (DEBUG) printf("\nThe ascii part checksum matches\n");
 293         }
 294
 295         /* just print the rsaPrivString and rsaPubString */
 296         if (DEBUG) printf("\nrsaPrivString: %s\n", rsaPrivString);
 297         if (DEBUG) printf("\nrsaPubString:  %s\n", rsaPubString);
 298
 299         /* check all the Byte checksums */
 300         if (Check_All_Byte_Calculus_Data(KeyBytePtr) != 0) {
 301                 printf("Byte_Calculus_Data checksums do not match !\n");
 302                 exit(1);
 303         } else {
 304                 if (DEBUG) printf("\nThe Byte Calculus Data checksums match\n");
 305         }
 306
 307         /* Check the KeyPythonPtr */
 308         PythonLength = strlen(KeyPythonPtr)/2;
 309         PythonData = DeHexify(KeyPythonPtr);
 310         if (memcmp(PythonData, g_keycode, PythonLength) != 0) {
 311                 printf("Python Byte code datablocks do not match !\n");
 312                 exit(1);
 313         } else {
 314                 if (DEBUG) printf("\nThe Python Byte code datablock matches\n");
 315         }
 316
 317         return(0);
 318 }
 319 #endif