From 599dc60f6dc97d3ef8efdd294ca2e89fbf498f54 Mon Sep 17 00:00:00 2001 From: Hans Lambermont Date: Sun, 13 Oct 2002 16:45:43 +0000 Subject: key loader library --- intern/keymaker/Makefile | 85 +++++++ intern/keymaker/key.c | 489 +++++++++++++++++++++++++++++++++++++++ intern/keymaker/key.h | 83 +++++++ intern/keymaker/key_internal.h | 89 +++++++ intern/keymaker/keyloader.c | 315 +++++++++++++++++++++++++ intern/keymaker/mt19937int.c | 130 +++++++++++ intern/keymaker/mt19937int.h | 45 ++++ intern/keymaker/python/key_pyc.h | 153 ++++++++++++ 8 files changed, 1389 insertions(+) create mode 100644 intern/keymaker/Makefile create mode 100644 intern/keymaker/key.c create mode 100644 intern/keymaker/key.h create mode 100644 intern/keymaker/key_internal.h create mode 100644 intern/keymaker/keyloader.c create mode 100644 intern/keymaker/mt19937int.c create mode 100644 intern/keymaker/mt19937int.h create mode 100644 intern/keymaker/python/key_pyc.h (limited to 'intern/keymaker') diff --git a/intern/keymaker/Makefile b/intern/keymaker/Makefile new file mode 100644 index 00000000000..a82c9e7c9b8 --- /dev/null +++ b/intern/keymaker/Makefile @@ -0,0 +1,85 @@ +# +# $Id$ +# ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. The Blender +# Foundation also sells licenses for use in proprietary software under +# the Blender License. See http://www.blender.org/BL/ for information +# about this. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): none yet. +# +# ***** END GPL/BL DUAL LICENSE BLOCK ***** +# blender keyreader-library makefile +# + +LIBNAME = blenkey +SOURCEDIR = intern/$(LIBNAME) +DIR = $(OCGDIR)/$(SOURCEDIR) +CSRCS = mt19937int.c key.c + +ALLTARGETS = $(OBJS) + +include nan_compile.mk + +CFLAGS += $(LEVEL_2_C_WARNINGS) + +CPPFLAGS += -I$(NAN_OPENSSL)/include -Ipython/ + +include nan_link.mk + +# OBJS is for the library, set by nan_compile.mk +LOADER_OBJS = $(DIR)/$(DEBUG_DIR)keyloader.o + +ifneq ($(OS),windows) + LIBS = $(NAN_OPENSSL)/lib/libcrypto.a +else + LIBS = $(NAN_OPENSSL)/lib/libeay32.lib + LIBS += advapi32.lib gdi32.lib +endif + +all debug:: link + +link: $(DIR)/$(DEBUG_DIR)keyloader + +strip: + ifneq ($(OS),windows) + strip keyloader + @ls -la keyloader + else + @ls -la keyloader.exe + endif + +install: all debug + @[ -d $(LCGDIR)/$(LIBNAME) ] || mkdir $(LCGDIR)/$(LIBNAME) + @[ -d $(LCGDIR)/$(LIBNAME)/include ] || mkdir $(LCGDIR)/$(LIBNAME)/include + @[ -d $(LCGDIR)/$(LIBNAME)/lib ] || mkdir $(LCGDIR)/$(LIBNAME)/lib + cp -f key.h $(LCGDIR)/$(LIBNAME)/include/blenkey.h + cp -f $(LIB_a) $(LCGDIR)/$(LIBNAME)/lib/ + +$(DIR)/$(DEBUG_DIR)keyloader: $(LOADER_OBJS) $(LIB_a) + $(CC) $(LDFLAGS) -o $@ $(LOADER_OBJS) $(LIB_a) $(LIBS) + +clean:: + $(RM) $(DIR)/key* $(DIR)/debug/key* + $(RM) $(DIR)/nan* $(DIR)/debug/nan* + +tags: + etags *.c *.h diff --git a/intern/keymaker/key.c b/intern/keymaker/key.c new file mode 100644 index 00000000000..56df96c16fd --- /dev/null +++ b/intern/keymaker/key.c @@ -0,0 +1,489 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +// ex:ts=4 + +/** + * $Id$ + * Copyright (C) 2001 NaN Technologies B.V. + * Blender Key loader library + */ + +#include +#include +#include + +#include "key.h" // external interface +#include "key_internal.h" + +char *Hexify(byte *in, unsigned int length) { + unsigned int i; + char Tstring[3]; + char *out = malloc((2*length + 1) * sizeof(char)); + sprintf(out, "%02X", in[0]); + for (i=1; i b) return a; + else return b; +} +// return |a-b| +byte checkfunc1(byte a, byte b) { + if (a > b) return a - b; + else return b - a; +} +// return the sum mod 256 +byte checkfunc2(byte a, byte b) { + return ((a + b) % 256); +} +// return the multiplication mod 256 +byte checkfunc3(byte a, byte b) { + return ((a * b) % 256); +} +// return a/b or 0 +byte checkfunc4(byte a, byte b) { + if (b != 0) return (a / b); + else return 0; +} + +char *scan_ascii(FILE *fh, UserStruct *User) { + long ascii_size; + char *ascii_data = NULL; + char *mdhex = NULL; + byte md[RIPEMD160_DIGEST_LENGTH]; + char string[1024]; + char dosnewlines = 0; + int lines = 0; + int oldftell; + + // NOTE: fscanf is notorious for its buffer overflows. This must be + // fixed some day, consider this a proof-of-concept version. + + fscanf(fh, "%1000[^\n]", string); + sscanf(string, "%*s %s %s %lu %d %d %d", + User->email, + User->shopid, + &User->reldate, + &User->keytype, + &User->keylevel, + &User->keyformat); + + if (User->keyformat <= BLENKEYFORMAT) { + if (DEBUG) printf( + "Email:[%s] ShopID:[%s] RelDate:[%lu] KeyType[%d] KeyLevel[%d]\n", + User->email, User->shopid, User->reldate, User->keytype, + User->keylevel); + + // read /n/n + + // check if we're reading dow newlines... + oldftell = ftell(fh); + getc(fh); + if ((ftell(fh) - oldftell) == 2) { + // yes ! + dosnewlines = 1; + } + getc(fh); + + fscanf(fh, "%1000[^\n]", string); + strncpy(User->name, string, sizeof(User->name) - 1); + + if (DEBUG) printf("Name:[%s]\n", User->name); + + getc(fh); + + // 4 lines read uptil now... + lines = 4; + + while (getc(fh) != EOF) { + fscanf(fh, "%1000[^\n]", string); + lines++; + // if (DEBUG) printf("%s\n", string); + if (strcmp(string, BLENKEYSEPERATOR) == 0) { + getc(fh); + break; + } + } + + // fh now points at the start of the datablock + ascii_size = ftell(fh); + + if (dosnewlines) { + // if we were reading on dos + // ftell will also count the ^M 's in the file; substract them + ascii_size -= lines; + } + + ascii_data = malloc((ascii_size+1) * sizeof(char)); + fseek(fh, 0, SEEK_SET); + fread(ascii_data, sizeof(char), ascii_size, fh); + ascii_data[ascii_size] = '\0'; + + if (DEBUG) + printf("asciiblock is %ld bytes long:\n[%s]\n", ascii_size, ascii_data); + + // calculate the hash checksum + RIPEMD160(ascii_data, ascii_size, md); + free(ascii_data); + mdhex = Hexify(md, RIPEMD160_DIGEST_LENGTH); + } + + return(mdhex); +} + +char *ReadHexCryptedData(FILE *fh, int *newlinetracker) { + int HexCryptedDataLength = Hex5ToIntFp(fh, newlinetracker); + int DataType = HexToIntFp(fh, newlinetracker); + char *HexCryptedData = malloc((HexCryptedDataLength+1) * sizeof(char)); + int i; + + if (DataType != 1) { + // printf("Error: unexpected datatype for HexCryptedData\n"); + free(HexCryptedData); + HexCryptedData = 0; + } else { + for (i=0; i<(HexCryptedDataLength/2); i++) { + sprintf(HexCryptedData+2*i, "%02X", ReadHexByteFp(fh, newlinetracker)); + } + } + + return(HexCryptedData); +} + +char *ReadHexCryptedKey(FILE *fh, int *newlinetracker) { + int HexCryptedKeyLength = Hex5ToIntFp(fh, newlinetracker); + int DataType = HexToIntFp(fh, newlinetracker); + char *HexCryptedKey = malloc((HexCryptedKeyLength+1) * sizeof(char)); + int i; + + if (DataType != 2) { + // printf("Error: unexpected datatype for HexCryptedKey\n"); + free(HexCryptedKey); + HexCryptedKey = 0; + } else { + for (i=0; i<(HexCryptedKeyLength/2); i++) { + sprintf(HexCryptedKey+2*i, "%02X", ReadHexByteFp(fh, newlinetracker)); + } + } + + return(HexCryptedKey); +} + +// NOTE: CHANGE THIS INTO A KEY OF OUR OWN +void LoadRSApubKey(RSA *Pub) { + static unsigned char n[] = +"\xD1\x12\x0C\x6A\x34\x0A\xCF\x4C\x6B\x34\xA9\x3C\xDD\x1A\x2A\x68" +"\x34\xE5\xB4\xA2\x08\xE8\x9F\xCE\x76\xEF\x4B\x92\x9B\x99\xB4\x57" +"\x72\x95\x78\x1D\x9E\x21\x1B\xF9\x5C\x1B\x0E\xC9\xD0\x89\x75\x28" +"\x08\x13\x6A\xD8\xA9\xC2\xA4\x31\x91\x53\x5A\xB9\x26\x71\x8C\x05"; + static unsigned char e[] = +"\x01\x00\x01"; +/* + static unsigned char e[] = "\x11"; + static unsigned char n[] = +"\x00\xAA\x36\xAB\xCE\x88\xAC\xFD\xFF\x55\x52\x3C\x7F\xC4\x52\x3F" +"\x90\xEF\xA0\x0D\xF3\x77\x4A\x25\x9F\x2E\x62\xB4\xC5\xD9\x9C\xB5" +"\xAD\xB3\x00\xA0\x28\x5E\x53\x01\x93\x0E\x0C\x70\xFB\x68\x76\x93" +"\x9C\xE6\x16\xCE\x62\x4A\x11\xE0\x08\x6D\x34\x1E\xBC\xAC\xA0\xA1" +"\xF5"; +*/ + + Pub->e = BN_bin2bn(e, sizeof(e)-1, Pub->e); + Pub->n = BN_bin2bn(n, sizeof(n)-1, Pub->n); +} + +byte *RSADecryptKey(char *HexCryptedKey) { + byte *CryptedKey = NULL; + byte *Key = NULL; + int KeyLen; + int CryptedKeyLen = strlen(HexCryptedKey)/2; + RSA *Pub = NULL; + + // Load RSA public key + Pub = RSA_new(); + if (Pub == NULL) { + // printf("Error in RSA_new\n"); + } else { + LoadRSApubKey(Pub); + + Key = malloc(RSA_size(Pub) * sizeof(byte)); + + CryptedKey = DeHexify(HexCryptedKey); + + KeyLen = RSA_public_decrypt(CryptedKeyLen, CryptedKey, Key, Pub, + RSA_PKCS1_PADDING); + if (DEBUG) + printf("CryptedKeyLen = %d, KeyLen = %d\n", CryptedKeyLen, KeyLen); + if (KeyLen == -1) { +#ifndef NDEBUG + printf("Error in RSA_public_decrypt: %s\n", ERR_error_string(ERR_get_error(), NULL)); +#endif + free(Key); + Key = NULL; + } + } + + return (Key); +} + +char *DeCryptDatablock(byte *CryptKey, int keylen, char *HexCryptedData) { + RC4_KEY key; + byte *CryptedData = DeHexify(HexCryptedData); + unsigned int datalen = strlen(HexCryptedData)/2; + char *KeyDataString = malloc(datalen * sizeof(char)); + + RC4_set_key(&key, keylen, CryptKey); + RC4(&key, datalen, CryptedData, KeyDataString); + free(CryptedData); + + return(KeyDataString); +} + +char *get_from_datablock(char **DataPtr, char *TypeString) { + int tstringsize = Hex5ToIntCp(DataPtr); + int tstringtype = HexToIntCp(DataPtr); + char *HexString = NULL; + + if (atoi(TypeString) != tstringtype) { + // printf("Unexpected type %d, expected %s\n", tstringtype, TypeString); + } else { + HexString = malloc((tstringsize+1) * sizeof(char)); + + strncpy(HexString, *DataPtr, tstringsize); + *DataPtr += tstringsize; + HexString[tstringsize] = '\0'; + } + + return(HexString); +} + +int ReadKeyFile(char *filename, UserStruct *User, + char **Priv, char **Pub, byte **Byte, char **Python) { + FILE *rawkeyfile; + char *HexAsciiHash = NULL, *HexCryptedData = NULL, *HexCryptedKey = + NULL; + int newlinetracker = 0; // line position, counts from 0-71 + byte *CryptKey = NULL; + char *KeyDataString = NULL; + char *KeyDataPtr = NULL; + char *HexByte = NULL; + char *mdhex = NULL; + int ret_val = 1; + + if ((rawkeyfile = fopen(filename, "rb")) == NULL) { + // printf("error, cannot read %s\n", filename); + } else { + // Scan and interpret the ASCII part + HexAsciiHash = scan_ascii(rawkeyfile, User); + if (DEBUG) printf("\nHexHash: %s\n", HexAsciiHash); + + // Read the HexCryptedData + HexCryptedData = ReadHexCryptedData(rawkeyfile, &newlinetracker); + if (DEBUG) printf("\nHexCryptedData: %s\n", HexCryptedData); + + // Read the HexCryptedKey + HexCryptedKey = ReadHexCryptedKey(rawkeyfile, &newlinetracker); + if (DEBUG) printf("\nHexCryptedKey: %s\n", HexCryptedKey); + + // close keyfile + fclose(rawkeyfile); + + if (HexAsciiHash && HexCryptedKey && HexCryptedData) { + // Decrypt HexCryptedKey + CryptKey = RSADecryptKey(HexCryptedKey); + + if (CryptKey) { + // Decrypt HexCryptedData + KeyDataString = DeCryptDatablock(CryptKey, 16, HexCryptedData); + free(CryptKey); + CryptKey = NULL; + + if (KeyDataString) { + if (DEBUG) printf("\nKeyDataString: %s\n", KeyDataString); + + // Extract data from KeyDataString + KeyDataPtr = KeyDataString; + mdhex = get_from_datablock(&KeyDataPtr, "01"); + *Priv = get_from_datablock(&KeyDataPtr, "02"); + *Pub = get_from_datablock(&KeyDataPtr, "03"); + HexByte = get_from_datablock(&KeyDataPtr, "04"); + if (HexByte) { + *Byte = DeHexify(HexByte); + free(HexByte); + HexByte = NULL; + + *Python = get_from_datablock(&KeyDataPtr, "05"); + + // Check ascii hash + if (strcmp(mdhex, HexAsciiHash) != 0) { + // printf("Ascii part checksums do not match !\n"); + // printf("found: %s\n", mdhex); + // printf("check: %s\n", HexAsciiHash); + ret_val = 2; + } else { + if (DEBUG) printf("\nThe ascii part checksum matches\n"); + // everything ok ! + ret_val = 0; + } + free(mdhex); + mdhex = NULL; + } + + free(KeyDataString); + KeyDataString = NULL; + } + } + } + + // cleanup + + if (HexAsciiHash) { + free(HexAsciiHash); + HexAsciiHash = NULL; + } + + if (HexCryptedKey) { + free(HexCryptedKey); + HexCryptedKey = NULL; + } + + if (HexCryptedData) { + free(HexCryptedData); + HexCryptedData = NULL; + } + } + + return (ret_val); +} + diff --git a/intern/keymaker/key.h b/intern/keymaker/key.h new file mode 100644 index 00000000000..dd84f55f129 --- /dev/null +++ b/intern/keymaker/key.h @@ -0,0 +1,83 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +/** + + * $Id$ + * Copyright (C) 2001 NaN Technologies B.V. + * Blender Key loader library external interface + */ + +#ifndef BLENKEY_H +#define BLENKEY_H + +#ifdef __cplusplus +extern "C" { +#endif + +typedef unsigned char byte; + +typedef struct UserStructType { + char name[100]; + char email[100]; + char shopid[100]; + unsigned long reldate; + int keytype; // 1 = Individual, 2 = Corporate, 3 = Unlimited + int keylevel; // key disclosure level, starts at 1 + int keyformat; // if we change the keyformat, up BLENKEYFORMAT +} UserStruct; + +char *Hexify(byte *in, unsigned int length); +byte *DeHexify(char *in); + +byte checkfunc0(byte a, byte b); +byte checkfunc1(byte a, byte b); +byte checkfunc2(byte a, byte b); +byte checkfunc3(byte a, byte b); +byte checkfunc4(byte a, byte b); + +// the byte size of the checksum datablock +// #define MAXBYTEDATABLOCK 1000 + +#define BLENKEYMAGIC "0ce0ba52" +#define BLENKEYSEPERATOR "---+++---" +#define BLENKEYFORMAT 1 + + +int ReadKeyFile(char *filename, UserStruct *User, + char **Priv, char **Pub, byte **Byte, char **Python); + +#ifdef __cplusplus +} +#endif + +#endif /* BLENKEY_H */ + diff --git a/intern/keymaker/key_internal.h b/intern/keymaker/key_internal.h new file mode 100644 index 00000000000..3fa0274c33e --- /dev/null +++ b/intern/keymaker/key_internal.h @@ -0,0 +1,89 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +// ex:ts=4 + +/** + * $Id$ + * Copyright (C) 2001 NaN Technologies B.V. + * Blender Key loader library internal stuff + */ + +#include "openssl/rand.h" +#include "openssl/rsa.h" +#include "openssl/ripemd.h" +#include "openssl/rc4.h" +#include "openssl/err.h" + +#include "mt19937int.h" // Mersenne Twister (under artistic license) + +#define MAXASCIIBLOCK 1000 +#define MAXBYTEDATABLOCK 1000 + +#ifdef NDEBUG + #define DEBUG 0 +#else + #define DEBUG 1 +#endif + +// keyloader and keymaker internal prototypes +int from_hex(char c); +byte ReadHexByteFp(FILE *fh, int *newlinetracker); +byte ReadHexByteCp(char **from); +int HexToInt(int a); +int HexToIntFp(FILE *fh, int *newlinetracker); +int HexToIntCp(char **from); +int Hex5ToInt(byte a, byte b, byte c, byte d, byte e); +int Hex5ToIntFp(FILE *fh, int *newlinetracker); +int Hex5ToIntCp(char **from); +int main(int argc, char **argv); + +// keyloader only internal prototypes +char *scan_ascii(FILE *fh, UserStruct *User); +char *ReadHexCryptedData(FILE *fh, int *newlinetracker); +char *ReadHexCryptedKey(FILE *fh, int *newlinetracker); +void LoadRSApubKey(RSA *Pub); +byte *RSADecryptKey(char *HexCryptedKey); +char *DeCryptDatablock(byte *CryptKey, int keylen, char *HexCryptedData); +char *get_from_datablock(char **DataPtr, char *TypeString); +int Check_All_Byte_Calculus_Data(char *KeyBytePtr); + +// keymaker only internal prototypes +void usage(void); +char *Create_Ascii_Part(int argc, char **argv); +void Create_User_RSA_Keys(unsigned int keylength, + char **rsaPrivString, char **rsaPubString); +char *Create_Byte_Calculus_Data(void); +byte *CreateCryptKey(unsigned int size); +char *CryptDatablock(byte *CryptKey, int keylen, char *KeyDataString); +char *RSACryptKey(RSA *rsa, byte *CryptKey, int KeyLen); +void add_to_datablock(char **DataString, char *HexString, char *TypeString); +void LoadRSAprivKey(RSA *Priv); diff --git a/intern/keymaker/keyloader.c b/intern/keymaker/keyloader.c new file mode 100644 index 00000000000..e4cf61fc3b7 --- /dev/null +++ b/intern/keymaker/keyloader.c @@ -0,0 +1,315 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +// ex:ts=4 + +/** + * $Id$ + * Copyright (C) 2001 NaN Technologies B.V. + * Blender Key Read-tester + */ + +#include +#include +#include + +#include "key_pyc.h" // the Python byte code +#include "key.h" // the external interface +#include "key_internal.h" + +#define TESTReadKeyFile 1 + +int Check_All_Byte_Calculus_Data(char *KeyBytePtr) { + int i; + + // create some unique number arrays + int NoRealRandomArray[MAXBYTEDATABLOCK]; + + typedef byte (*funcpoin)(byte, byte); + funcpoin checkfunc[] = {&checkfunc0, &checkfunc1, &checkfunc2, + &checkfunc3, &checkfunc4}; + + byte *KeyByteData = DeHexify(KeyBytePtr); + + // first create a fixed seed random number generator + sgenrand(666); // seed it fixed + + // initialize arrays with unique numbers + for (i=0; i>16) % MAXBYTEDATABLOCK); + int store = NoRealRandomArray[swap1]; + //printf("%lu %d %d\n", randswap, swap1, swap2); + NoRealRandomArray[swap1] = NoRealRandomArray[swap2]; + NoRealRandomArray[swap2] = store; + } + if (DEBUG) { + printf("\nFixed seed unique number random data: "); + for (i=0; ie = BN_bin2bn(rsa_e, sizeof(rsa_e)-1, rsa->e); + rsa->n = BN_bin2bn(pubKey, pubKeyLen, rsa->n); + rsa->d = BN_bin2bn(privKey, privKeyLen, rsa->d); + + fprintf(stderr, "NOTE e %d, n %d, d %d rsa_size %d\n", + sizeof(rsa_e)-1, pubKeyLen, privKeyLen, RSA_size(rsa)); + + cryptedKey = malloc(RSA_size(rsa) * sizeof(byte)); + cryptedKeyLen = RSA_private_encrypt(cryptKeyLen, cryptKey, + cryptedKey, rsa, RSA_PKCS1_PADDING); + + deCryptKey = malloc(RSA_size(rsa) * sizeof(unsigned char)); + deCryptKeyLen = RSA_public_decrypt(cryptedKeyLen, cryptedKey, + deCryptKey, rsa, RSA_PKCS1_PADDING); + if (deCryptKeyLen == -1) { + printf("Error in RSA_public_decrypt: %s\n", + ERR_error_string(ERR_get_error(), NULL)); + exit(1); + } else { + printf("RSA_public_decrypt test SUCCEEDED\n"); + } + +} + +#ifdef TESTReadKeyFile +int main(int argc, char **argv) { + int result; + UserStruct User; + char *HexPriv = NULL, *HexPub = NULL, *HexPython = NULL; + byte *Byte = NULL; + byte *PythonData = NULL; + int PythonLength; + char *HexByte = NULL; + + if (argc != 2) { + printf("usage: %s keyfile\n", argv[0]); + exit(1); + } + + result = ReadKeyFile(argv[1], &User, &HexPriv, &HexPub, &Byte, &HexPython); + if (result != 0) { + printf("\nReadKeyFile error %d\n", result); + exit(result); + } else { + printf("\nReadKeyFile OK\n"); + } + + // just print the rsaPrivString and rsaPubString + if (DEBUG) printf("\nrsaPrivString: %s\n", HexPriv); + if (DEBUG) printf("\nrsaPubString: %s\n", HexPub); + + // try to private encrypt-public decrypt something + if (DEBUG) pub_priv_test(HexPriv, HexPub); + + // check all the Byte checksums + // rehexify it for our Check_All_Byte_Calculus_Data function ... + HexByte = Hexify(Byte, 1000); + if (Check_All_Byte_Calculus_Data(HexByte) != 0) { + printf("\nByte_Calculus_Data checksums do not match !\n"); + exit(1); + } else { + if (DEBUG) printf("\nThe Byte Calculus Data checksums match\n"); + } + + // Check the KeyPythonPtr + PythonLength = strlen(HexPython)/2; + PythonData = DeHexify(HexPython); + if (memcmp(PythonData, g_keycode, PythonLength) != 0) { + printf("\nPython Byte code datablocks do not match !\n"); + exit(1); + } else { + if (DEBUG) printf("\nThe Python Byte code datablock matches\n"); + } + + return(0); +} +#else +int main(int argc, char **argv) { + FILE *rawkeyfile; + char *AsciiHash; + char *HexCryptedData, *HexCryptedKey; + int newlinetracker = 0; // line position, counts from 0-71 + byte *CryptKey; + char *KeyDataString; + char *KeyDataPtr; + char *mdhex; + char *rsaPrivString; + char *rsaPubString; + char *KeyBytePtr; + char *KeyPythonPtr; + byte *PythonData; + int PythonLength; + UserStruct User; + + if (argc != 2) { + printf("usage: %s keyfile\n", argv[0]); + exit(1); + } + + // open keyfile for reading + if ((rawkeyfile = fopen(argv[1], "r")) == NULL) { + printf("error, cannot read %s\n", argv[1]); + exit(1); + } + + // Scan and interpret the ASCII part + AsciiHash = scan_ascii(rawkeyfile, &User); + if (DEBUG) printf("\nHexHash: %s\n", AsciiHash); + + // Read the HexCryptedData + HexCryptedData = ReadHexCryptedData(rawkeyfile, &newlinetracker); + if (DEBUG) printf("\nHexCryptedData: %s\n", HexCryptedData); + + // Read the HexCryptedKey + HexCryptedKey = ReadHexCryptedKey(rawkeyfile, &newlinetracker); + if (DEBUG) printf("\nHexCryptedKey: %s\n", HexCryptedKey); + + // close keyfile + fclose(rawkeyfile); + + // Decrypt HexCryptedKey + CryptKey = RSADecryptKey(HexCryptedKey); + + // Decrypt HexCryptedData + KeyDataString = DeCryptDatablock(CryptKey, 16, HexCryptedData); + free(CryptKey); + free(HexCryptedData); + free(HexCryptedKey); + if (DEBUG) printf("\nKeyDataString: %s\n", KeyDataString); + + // Extract data from KeyDataString + KeyDataPtr = KeyDataString; + + mdhex = get_from_datablock(&KeyDataPtr, "01"); + rsaPrivString = get_from_datablock(&KeyDataPtr, "02"); + rsaPubString = get_from_datablock(&KeyDataPtr, "03"); + KeyBytePtr = get_from_datablock(&KeyDataPtr, "04"); + KeyPythonPtr = get_from_datablock(&KeyDataPtr, "05"); + free(KeyDataString); + + // Check ascii hash + if (strcmp(mdhex, AsciiHash) != 0) { + printf("Ascii part checksums do not match !\n"); + printf("found: %s\n", mdhex); + printf("check: %s\n", AsciiHash); + exit(1); + } else { + if (DEBUG) printf("\nThe ascii part checksum matches\n"); + } + + // just print the rsaPrivString and rsaPubString + if (DEBUG) printf("\nrsaPrivString: %s\n", rsaPrivString); + if (DEBUG) printf("\nrsaPubString: %s\n", rsaPubString); + + // check all the Byte checksums + if (Check_All_Byte_Calculus_Data(KeyBytePtr) != 0) { + printf("Byte_Calculus_Data checksums do not match !\n"); + exit(1); + } else { + if (DEBUG) printf("\nThe Byte Calculus Data checksums match\n"); + } + + // Check the KeyPythonPtr + PythonLength = strlen(KeyPythonPtr)/2; + PythonData = DeHexify(KeyPythonPtr); + if (memcmp(PythonData, g_keycode, PythonLength) != 0) { + printf("Python Byte code datablocks do not match !\n"); + exit(1); + } else { + if (DEBUG) printf("\nThe Python Byte code datablock matches\n"); + } + + return(0); +} +#endif diff --git a/intern/keymaker/mt19937int.c b/intern/keymaker/mt19937int.c new file mode 100644 index 00000000000..7845f9ad56e --- /dev/null +++ b/intern/keymaker/mt19937int.c @@ -0,0 +1,130 @@ +/* A C-program for MT19937: Integer version (1999/10/28) */ + +/* genrand() generates one pseudorandom unsigned integer (32bit) */ +/* which is uniformly distributed among 0 to 2^32-1 for each */ +/* call. sgenrand(seed) sets initial values to the working area */ +/* of 624 words. Before genrand(), sgenrand(seed) must be */ +/* called once. (seed is any 32-bit integer.) */ +/* Coded by Takuji Nishimura, considering the suggestions by */ +/* Topher Cooper and Marc Rieffel in July-Aug. 1997. */ + +/* This library is free software under the Artistic license: */ +/* see the file COPYING distributed together with this code. */ +/* For the verification of the code, its output sequence file */ +/* mt19937int.out is attached (2001/4/2) */ + +/* Copyright (C) 1997, 1999 Makoto Matsumoto and Takuji Nishimura. */ +/* Any feedback is very welcome. For any question, comments, */ +/* see http://www.math.keio.ac.jp/matumoto/emt.html or email */ +/* matumoto@math.keio.ac.jp */ + +/* REFERENCE */ +/* M. Matsumoto and T. Nishimura, */ +/* "Mersenne Twister: A 623-Dimensionally Equidistributed Uniform */ +/* Pseudo-Random Number Generator", */ +/* ACM Transactions on Modeling and Computer Simulation, */ +/* Vol. 8, No. 1, January 1998, pp 3--30. */ + +#include + +#include "mt19937int.h" + +/* Period parameters */ +#define N 624 +#define M 397 +#define MATRIX_A 0x9908b0df /* constant vector a */ +#define UPPER_MASK 0x80000000 /* most significant w-r bits */ +#define LOWER_MASK 0x7fffffff /* least significant r bits */ + +/* Tempering parameters */ +#define TEMPERING_MASK_B 0x9d2c5680 +#define TEMPERING_MASK_C 0xefc60000 +#define TEMPERING_SHIFT_U(y) (y >> 11) +#define TEMPERING_SHIFT_S(y) (y << 7) +#define TEMPERING_SHIFT_T(y) (y << 15) +#define TEMPERING_SHIFT_L(y) (y >> 18) + +static unsigned long mt[N]; /* the array for the state vector */ +static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */ + +/* Initializing the array with a seed */ +void sgenrand(signed long seed) +{ + int i; + + for (i=0;i> 16; + seed = 69069 * seed + 1; + } + mti = N; +} + +/* Initialization by "sgenrand()" is an example. Theoretically, */ +/* there are 2^19937-1 possible states as an intial state. */ +/* This function allows to choose any of 2^19937-1 ones. */ +/* Essential bits in "seed_array[]" is following 19937 bits: */ +/* (seed_array[0]&UPPER_MASK), seed_array[1], ..., seed_array[N-1]. */ +/* (seed_array[0]&LOWER_MASK) is discarded. */ +/* Theoretically, */ +/* (seed_array[0]&UPPER_MASK), seed_array[1], ..., seed_array[N-1] */ +/* can take any values except all zeros. */ +void lsgenrand(unsigned long *seed_array) + /* the length of seed_array[] must be at least N */ +{ + int i; + + for (i=0;i= N) { /* generate N words at one time */ + int kk; + + if (mti == N+1) /* if sgenrand() has not been called, */ + sgenrand(4357); /* a default initial seed is used */ + + for (kk=0;kk> 1) ^ mag01[y & 0x1]; + } + for (;kk> 1) ^ mag01[y & 0x1]; + } + y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK); + mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1]; + + mti = 0; + } + + y = mt[mti++]; + y ^= TEMPERING_SHIFT_U(y); + y ^= TEMPERING_SHIFT_S(y) & TEMPERING_MASK_B; + y ^= TEMPERING_SHIFT_T(y) & TEMPERING_MASK_C; + y ^= TEMPERING_SHIFT_L(y); + + return y; +} + +/* This main() outputs first 1000 generated numbers. */ +/* +main() +{ + int i; + + sgenrand(4357); + for (i=0; i<1000; i++) { + printf("%10lu ", genrand()); + if (i%5==4) printf("\n"); + } +} +*/ diff --git a/intern/keymaker/mt19937int.h b/intern/keymaker/mt19937int.h new file mode 100644 index 00000000000..49acdd7ba4c --- /dev/null +++ b/intern/keymaker/mt19937int.h @@ -0,0 +1,45 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +// ex:ts=4 + +/** + * $Id$ + * Copyright (C) 2001 NaN Technologies B.V. + * Mersenne Twister prototypes + */ + +// external: +void sgenrand(signed long seed); +unsigned long genrand(void); + +// internal: +void lsgenrand(unsigned long *seed_array); diff --git a/intern/keymaker/python/key_pyc.h b/intern/keymaker/python/key_pyc.h new file mode 100644 index 00000000000..75e35832a21 --- /dev/null +++ b/intern/keymaker/python/key_pyc.h @@ -0,0 +1,153 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +/* generated by keygen.py -- don't edit !! */ + + +#define KEYCODELEN 1157 +static unsigned char g_keycode[] = { + 0x63,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x73, + 0xb3,0x00,0x00,0x00,0x7f,0x00,0x00,0x7f,0x02,0x00, + 0x64,0x00,0x00,0x6b,0x00,0x00,0x5a,0x00,0x00,0x7f, + 0x06,0x00,0x64,0x01,0x00,0x84,0x00,0x00,0x5a,0x01, + 0x00,0x7f,0x09,0x00,0x64,0x02,0x00,0x84,0x00,0x00, + 0x5a,0x02,0x00,0x7f,0x11,0x00,0x64,0x03,0x00,0x84, + 0x00,0x00,0x5a,0x03,0x00,0x7f,0x1c,0x00,0x65,0x00, + 0x00,0x69,0x04,0x00,0x83,0x00,0x00,0x5a,0x05,0x00, + 0x7f,0x1d,0x00,0x7f,0x21,0x00,0x65,0x00,0x00,0x69, + 0x06,0x00,0x83,0x00,0x00,0x5a,0x07,0x00,0x7f,0x22, + 0x00,0x65,0x08,0x00,0x65,0x07,0x00,0x83,0x01,0x00, + 0x5a,0x09,0x00,0x7f,0x23,0x00,0x65,0x03,0x00,0x65, + 0x09,0x00,0x83,0x01,0x00,0x01,0x7f,0x24,0x00,0x78, + 0x39,0x00,0x65,0x0a,0x00,0x65,0x07,0x00,0x83,0x01, + 0x00,0x64,0x04,0x00,0x7f,0x24,0x00,0x72,0x26,0x00, + 0x5a,0x0b,0x00,0x7f,0x25,0x00,0x65,0x00,0x00,0x69, + 0x0c,0x00,0x65,0x09,0x00,0x65,0x0b,0x00,0x19,0x65, + 0x00,0x00,0x69,0x0d,0x00,0x65,0x0b,0x00,0x83,0x01, + 0x00,0x83,0x02,0x00,0x01,0x71,0x82,0x00,0x57,0x64, + 0x00,0x00,0x53,0x28,0x05,0x00,0x00,0x00,0x4e,0x63, + 0x03,0x00,0x03,0x00,0x03,0x00,0x03,0x00,0x73,0x1c, + 0x00,0x00,0x00,0x7f,0x06,0x00,0x7f,0x07,0x00,0x7f, + 0x08,0x00,0x7c,0x00,0x00,0x7c,0x01,0x00,0x7c,0x02, + 0x00,0x66,0x03,0x00,0x61,0x03,0x00,0x64,0x00,0x00, + 0x53,0x28,0x01,0x00,0x00,0x00,0x4e,0x28,0x04,0x00, + 0x00,0x00,0x73,0x01,0x00,0x00,0x00,0x61,0x73,0x01, + 0x00,0x00,0x00,0x62,0x73,0x01,0x00,0x00,0x00,0x63, + 0x73,0x05,0x00,0x00,0x00,0x5f,0x73,0x65,0x65,0x64, + 0x28,0x03,0x00,0x00,0x00,0x73,0x01,0x00,0x00,0x00, + 0x61,0x73,0x01,0x00,0x00,0x00,0x62,0x73,0x01,0x00, + 0x00,0x00,0x63,0x73,0x08,0x00,0x00,0x00,0x3c,0x73, + 0x74,0x72,0x69,0x6e,0x67,0x3e,0x73,0x04,0x00,0x00, + 0x00,0x73,0x65,0x65,0x64,0x06,0x00,0x73,0x04,0x00, + 0x00,0x00,0x03,0x01,0x03,0x01,0x63,0x00,0x00,0x03, + 0x00,0x03,0x00,0x03,0x00,0x73,0x70,0x00,0x00,0x00, + 0x7f,0x09,0x00,0x7f,0x0a,0x00,0x7f,0x0b,0x00,0x74, + 0x00,0x00,0x5c,0x03,0x00,0x7d,0x00,0x00,0x7d,0x01, + 0x00,0x7d,0x02,0x00,0x7f,0x0c,0x00,0x64,0x01,0x00, + 0x7c,0x00,0x00,0x14,0x64,0x02,0x00,0x16,0x7d,0x00, + 0x00,0x7f,0x0d,0x00,0x64,0x03,0x00,0x7c,0x01,0x00, + 0x14,0x64,0x04,0x00,0x16,0x7d,0x01,0x00,0x7f,0x0e, + 0x00,0x64,0x05,0x00,0x7c,0x02,0x00,0x14,0x64,0x06, + 0x00,0x16,0x7d,0x02,0x00,0x7f,0x0f,0x00,0x7c,0x00, + 0x00,0x7c,0x01,0x00,0x7c,0x02,0x00,0x66,0x03,0x00, + 0x61,0x00,0x00,0x7f,0x10,0x00,0x7c,0x00,0x00,0x7c, + 0x01,0x00,0x17,0x7c,0x02,0x00,0x17,0x53,0x64,0x00, + 0x00,0x53,0x28,0x07,0x00,0x00,0x00,0x4e,0x69,0xab, + 0x00,0x00,0x00,0x69,0x3d,0x76,0x00,0x00,0x69,0xac, + 0x00,0x00,0x00,0x69,0x63,0x76,0x00,0x00,0x69,0xaa, + 0x00,0x00,0x00,0x69,0x73,0x76,0x00,0x00,0x28,0x04, + 0x00,0x00,0x00,0x73,0x05,0x00,0x00,0x00,0x5f,0x73, + 0x65,0x65,0x64,0x73,0x01,0x00,0x00,0x00,0x61,0x73, + 0x01,0x00,0x00,0x00,0x62,0x73,0x01,0x00,0x00,0x00, + 0x63,0x28,0x03,0x00,0x00,0x00,0x73,0x01,0x00,0x00, + 0x00,0x61,0x73,0x01,0x00,0x00,0x00,0x62,0x73,0x01, + 0x00,0x00,0x00,0x63,0x73,0x08,0x00,0x00,0x00,0x3c, + 0x73,0x74,0x72,0x69,0x6e,0x67,0x3e,0x73,0x09,0x00, + 0x00,0x00,0x72,0x61,0x6e,0x64,0x6f,0x6d,0x69,0x7a, + 0x65,0x09,0x00,0x73,0x0e,0x00,0x00,0x00,0x03,0x01, + 0x03,0x01,0x12,0x01,0x11,0x01,0x11,0x01,0x11,0x01, + 0x12,0x01,0x63,0x01,0x00,0x06,0x00,0x06,0x00,0x03, + 0x00,0x73,0x8b,0x00,0x00,0x00,0x7f,0x11,0x00,0x7f, + 0x13,0x00,0x74,0x00,0x00,0x7c,0x00,0x00,0x83,0x01, + 0x00,0x7d,0x01,0x00,0x7f,0x14,0x00,0x78,0x6f,0x00, + 0x74,0x03,0x00,0x7c,0x01,0x00,0x83,0x01,0x00,0x64, + 0x01,0x00,0x7f,0x14,0x00,0x72,0x5c,0x00,0x7d,0x02, + 0x00,0x7f,0x15,0x00,0x7c,0x01,0x00,0x7c,0x02,0x00, + 0x18,0x7d,0x03,0x00,0x7f,0x16,0x00,0x74,0x06,0x00, + 0x74,0x07,0x00,0x83,0x00,0x00,0x7c,0x03,0x00,0x16, + 0x83,0x01,0x00,0x7d,0x04,0x00,0x7f,0x17,0x00,0x7c, + 0x00,0x00,0x7c,0x02,0x00,0x19,0x7d,0x05,0x00,0x7f, + 0x18,0x00,0x7c,0x00,0x00,0x7c,0x02,0x00,0x7c,0x04, + 0x00,0x17,0x19,0x7c,0x00,0x00,0x7c,0x02,0x00,0x3c, + 0x7f,0x19,0x00,0x7c,0x05,0x00,0x7c,0x00,0x00,0x7c, + 0x02,0x00,0x7c,0x04,0x00,0x17,0x3c,0x71,0x24,0x00, + 0x57,0x64,0x00,0x00,0x53,0x28,0x02,0x00,0x00,0x00, + 0x4e,0x69,0x00,0x00,0x00,0x00,0x28,0x0a,0x00,0x00, + 0x00,0x73,0x03,0x00,0x00,0x00,0x6c,0x65,0x6e,0x73, + 0x04,0x00,0x00,0x00,0x6c,0x69,0x73,0x74,0x73,0x04, + 0x00,0x00,0x00,0x73,0x69,0x7a,0x65,0x73,0x06,0x00, + 0x00,0x00,0x78,0x72,0x61,0x6e,0x67,0x65,0x73,0x01, + 0x00,0x00,0x00,0x69,0x73,0x04,0x00,0x00,0x00,0x6c, + 0x65,0x66,0x74,0x73,0x03,0x00,0x00,0x00,0x69,0x6e, + 0x74,0x73,0x09,0x00,0x00,0x00,0x72,0x61,0x6e,0x64, + 0x6f,0x6d,0x69,0x7a,0x65,0x73,0x01,0x00,0x00,0x00, + 0x72,0x73,0x03,0x00,0x00,0x00,0x74,0x6d,0x70,0x28, + 0x06,0x00,0x00,0x00,0x73,0x04,0x00,0x00,0x00,0x6c, + 0x69,0x73,0x74,0x73,0x04,0x00,0x00,0x00,0x73,0x69, + 0x7a,0x65,0x73,0x01,0x00,0x00,0x00,0x69,0x73,0x04, + 0x00,0x00,0x00,0x6c,0x65,0x66,0x74,0x73,0x01,0x00, + 0x00,0x00,0x72,0x73,0x03,0x00,0x00,0x00,0x74,0x6d, + 0x70,0x73,0x08,0x00,0x00,0x00,0x3c,0x73,0x74,0x72, + 0x69,0x6e,0x67,0x3e,0x73,0x04,0x00,0x00,0x00,0x73, + 0x74,0x69,0x72,0x11,0x00,0x73,0x10,0x00,0x00,0x00, + 0x03,0x02,0x0f,0x01,0x12,0x00,0x09,0x01,0x0d,0x01, + 0x16,0x01,0x0d,0x01,0x15,0x01,0x69,0x00,0x00,0x00, + 0x00,0x28,0x0e,0x00,0x00,0x00,0x73,0x04,0x00,0x00, + 0x00,0x70,0x72,0x6f,0x74,0x73,0x04,0x00,0x00,0x00, + 0x73,0x65,0x65,0x64,0x73,0x09,0x00,0x00,0x00,0x72, + 0x61,0x6e,0x64,0x6f,0x6d,0x69,0x7a,0x65,0x73,0x04, + 0x00,0x00,0x00,0x73,0x74,0x69,0x72,0x73,0x07,0x00, + 0x00,0x00,0x67,0x65,0x74,0x73,0x65,0x65,0x64,0x73, + 0x05,0x00,0x00,0x00,0x5f,0x73,0x65,0x65,0x64,0x73, + 0x06,0x00,0x00,0x00,0x67,0x65,0x74,0x6c,0x65,0x6e, + 0x73,0x01,0x00,0x00,0x00,0x6e,0x73,0x05,0x00,0x00, + 0x00,0x72,0x61,0x6e,0x67,0x65,0x73,0x04,0x00,0x00, + 0x00,0x6c,0x69,0x73,0x74,0x73,0x06,0x00,0x00,0x00, + 0x78,0x72,0x61,0x6e,0x67,0x65,0x73,0x01,0x00,0x00, + 0x00,0x69,0x73,0x06,0x00,0x00,0x00,0x73,0x65,0x74, + 0x70,0x74,0x72,0x73,0x06,0x00,0x00,0x00,0x67,0x65, + 0x74,0x70,0x74,0x72,0x28,0x00,0x00,0x00,0x00,0x73, + 0x08,0x00,0x00,0x00,0x3c,0x73,0x74,0x72,0x69,0x6e, + 0x67,0x3e,0x73,0x01,0x00,0x00,0x00,0x3f,0x02,0x00, + 0x73,0x16,0x00,0x00,0x00,0x0f,0x04,0x0c,0x03,0x0c, + 0x08,0x0c,0x0b,0x0f,0x01,0x03,0x04,0x0f,0x01,0x0f, + 0x01,0x0d,0x01,0x12,0x00,0x09,0x01 +}; \ No newline at end of file -- cgit v1.2.3