== SCons ==
[blender-staging.git] / 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