예제 #1
0
uint8 ReadTypeDescriptor(FILE* fp)
{
	/*
	struct TypeDescriptorPrefix
	{
	BYTE	is_pointer : 1,
	is_unique_pointer : 1,
	is_reference : 1,
	tag : 5;
	};
	*/
	
	uint8 TypeDescriptorPrefix = fget8(fp);
	uint8 tag = TypeDescriptorPrefix & 0x1f;
	if (tag <= 17)
	{
	//	BYTE SimpleTypeDescriptor = fget8(fp);
	}
	else if (tag == 18)	// InterfaceTypeDescriptor
	{
		uint16  interface_index = fget16(fp);
	}
	else if (tag == 19)	// InterfaceIsTypeDescriptor
	{
		uint8    arg_num = fget8(fp);
	}
	else
	{
		throw -1;//exit(1);
	}

	return tag;
}
예제 #2
0
파일: uefstate.cpp 프로젝트: AndyA/beebem
void LoadUEFState(char *StateName) {
	char errmsg[256];
	char UEFId[10];
//--	int CompletionBits=0; // These bits should be filled in
//## Unused.
	long RPos=0,FLength,CPos;
	unsigned int Block,Length;
	int Version;
	strcpy(UEFId,"BlankFile");
	UEFState=fopen(StateName,"rb");
	if (UEFState != NULL)
	{
//->		fseek(UEFState,NULL,SEEK_END);
//++
		fseek(UEFState,0,SEEK_END);
//<-
		FLength=ftell(UEFState);
		fseek(UEFState,0,SEEK_SET);  // Get File length for eof comparison.
		fatal_fread(UEFId,10,1,UEFState);
		if (strcmp(UEFId,"UEF File!")!=0) {
			MessageBox(GETHWND,"The file selected is not a UEF File.","BeebEm",MB_ICONERROR|MB_OK);
			fclose(UEFState);
			return;
		}
		Version=fget16(UEFState);
		sprintf(errmsg,"UEF Version %x",Version);
		//MessageBox(GETHWND,errmsg,"BeebEm",MB_OK);
		RPos=ftell(UEFState);

		while (ftell(UEFState)<FLength) {
			Block=fget16(UEFState);
			Length=fget32(UEFState);
			CPos=ftell(UEFState);
			sprintf(errmsg,"Block %04X - Length %d (%04X)",Block,Length,Length);
			//MessageBox(GETHWND,errmsg,"BeebEm",MB_ICONERROR|MB_OK);
			if (Block==0x046A) LoadEmuUEF(UEFState,Version);
			if (Block==0x0460) Load6502UEF(UEFState);
			if (Block==0x0461) LoadRomRegsUEF(UEFState);
			if (Block==0x0462) LoadMainMemUEF(UEFState);
			if (Block==0x0463) LoadShadMemUEF(UEFState);
			if (Block==0x0464) LoadPrivMemUEF(UEFState);
			if (Block==0x0465) LoadFileMemUEF(UEFState);
			if (Block==0x0466) LoadSWRMMemUEF(UEFState);
			if (Block==0x0467) LoadViaUEF(UEFState);
			if (Block==0x0468) LoadVideoUEF(UEFState);
			if (Block==0x046B) LoadSoundUEF(UEFState);
			if (Block==0x046D) LoadIntegraBHiddenMemUEF(UEFState);
			if (Block==0x046E) Load8271UEF(UEFState);
			if (Block==0x046F) Load1770UEF(UEFState,Version);
			if (Block==0x0470) LoadTubeUEF(UEFState);
			if (Block==0x0471) Load65C02UEF(UEFState);
			if (Block==0x0472) Load65C02MemUEF(UEFState);
			if (Block==0x0473) LoadSerialUEF(UEFState);
			fseek(UEFState,CPos+Length,SEEK_SET); // Skip unrecognised blocks (and over any gaps)
		}

		fclose(UEFState);

		mainWin->SetRomMenu();
		mainWin->SetDiscWriteProtects();
	}
	else
	{
		char errstr[256];
		sprintf(errstr, "Cannot open state file: %s", StateName);
		MessageBox(GETHWND,errstr,"BeebEm",MB_ICONERROR|MB_OK);
	}
}
예제 #3
0
void LoadShadMemUEF(FILE *SUEF) {
	int SAddr;
	SAddr=fget16(SUEF);
	fread(ShadowRAM+SAddr,1,32768,SUEF);
}
예제 #4
0
파일: rleori.c 프로젝트: Li2012/palresearch
unsigned long fget32(FILE* fp)
{	
	unsigned long a=fget16(fp);
	unsigned long b=fget16(fp)<<16;
	return a|b;
}
예제 #5
0
static void process_file(char *filename, char *parentfile)
{
    FILE *fp;
    int i;
    struct stat sb;
    uint16_t versionMajor;
    uint16_t versionMinor;
    char path[4096] = { 0 };
    uint32_t encryptionFlags;
    char *buffer, *xmlfile;
    FILE *ofp;
    xmlDocPtr doc;
    xmlNodePtr cur;
    int spinCount;
    int pkeBlockSize;
    int pkeKeyBits;
    int pkeHashSize;
    unsigned char *pkeSaltValue;
    unsigned char encryptedVerifierHashInput[16 + 2];
    unsigned char encryptedVerifierHashValue[64 + 2];
    int version;
    xmlChar *spinCountXML;
    xmlChar *saltSizeXML;
    xmlChar *pkeBlockSizeXML;
    xmlChar *pkeKeyBitsXML;
    xmlChar *pkeHashSizeXML;
    xmlChar *pkeSaltValueXML;
    xmlChar *hashAlgorithm;
    xmlChar *encryptedVerifierHashInputXML;
    xmlChar *encryptedVerifierHashValueXML;

    uint32_t headerLength;
    uint32_t skipFlags;
    uint32_t sizeExtra;
    uint32_t algId;
    uint32_t algHashId;
    uint32_t keySize;
    uint32_t providerType;
    char CSPName[1024];
    uint32_t saltSize;
    char salt[1024];
    char encryptedVerifier[16];
    uint32_t verifierHashSize;
    char encryptedVerifierHash[64];

    if(stat(filename, &sb) != 0) {
    }

    if (!(fp = fopen(filename, "rb"))) {
        fprintf(stderr, "! %s : %s\n", filename, strerror(errno));
        return;
    }

    while (!feof(fp)) {
        versionMajor = fget16(fp);
        versionMinor = fget16(fp);
        encryptionFlags = fget32(fp);
        if (encryptionFlags == fExternal) {
            fprintf(stderr, "%s : An external cryptographic provider is not supported\n", parentfile);
            return;
        }
        if (versionMinor == 0x04 && versionMajor == 0x04) { /* Office 2010 and 2013 files */
            if (encryptionFlags != fAgile)
                fprintf(stderr, "%s : The encryption flags are not consistent with the encryption type\n", parentfile);
            /* rest of the data is in XML format, dump it to a file */
            strcpy(path, filename);
            buffer = (char*)malloc(sb.st_size);
            fread(buffer, sb.st_size - 8, 1, fp);
            xmlfile = strcat(path, ".xml");
            if (!(ofp = fopen(xmlfile, "w"))) {
                fprintf(stderr, "! %s : %s\n", filename, strerror(errno));
                return;
            }
            fwrite(buffer, sb.st_size - 8, 1, ofp);
            fclose(ofp);
            /* process XML file */
            doc = xmlParseFile(xmlfile);
            if (doc == NULL ) {
                fprintf(stderr, "Document not parsed successfully. \n");
                return;
            }
            cur = xmlDocGetRootElement(doc);
            if (cur == NULL) {
                fprintf(stderr, "empty document\n");
                xmlFreeDoc(doc);
                return;
            }
            cur = cur->xmlChildrenNode;
            while (cur != NULL) {
                if ((!xmlStrcmp(cur->name, (const xmlChar *)"keyEncryptors")))
                    break;
                cur = cur->next;
            }
            cur = cur->xmlChildrenNode;
            while (cur != NULL) {
                if ((!xmlStrcmp(cur->name, (const xmlChar *)"keyEncryptor")))
                    break;
                cur = cur->next;
            }
            cur = cur->xmlChildrenNode;
            /* we are now at "encryptedKey" node */
            spinCountXML = xmlGetProp(cur, "spinCount");
            spinCount = atoi(spinCountXML);
            xmlFree(spinCountXML);
            saltSizeXML = xmlGetProp(cur, "saltSize");
            saltSize = atoi(saltSizeXML);
            xmlFree(saltSizeXML);
            pkeBlockSizeXML = xmlGetProp(cur, "blockSize");
            pkeBlockSize = atoi(pkeBlockSizeXML);
            xmlFree(pkeBlockSizeXML);
            pkeKeyBitsXML = xmlGetProp(cur, "keyBits");
            pkeKeyBits = atoi(pkeKeyBitsXML);
            xmlFree(pkeKeyBitsXML);
            pkeHashSizeXML = xmlGetProp(cur, "hashSize");
            hashAlgorithm = xmlGetProp(cur, "hashAlgorithm");
            if(strcmp(hashAlgorithm, "SHA1") == 0) {
                version = 2010;
            }
            else if (strcmp(hashAlgorithm, "SHA512") == 0) {
                version = 2013;
            }
            else {
                fprintf(stderr, "%s uses un-supported hashing algorithm %s, please file a bug! \n", parentfile, hashAlgorithm);
                return;
            }
            pkeHashSize = atoi(pkeHashSizeXML);
            xmlFree(pkeHashSizeXML);
            pkeSaltValueXML = xmlGetProp(cur, "saltValue");
            pkeSaltValue = (unsigned char*)malloc(16 + 2);
            base64_decode(pkeSaltValueXML, strlen(pkeSaltValueXML), pkeSaltValue);
            xmlFree(pkeSaltValueXML);
            encryptedVerifierHashInputXML = xmlGetProp(cur, "encryptedVerifierHashInput");
            base64_decode(encryptedVerifierHashInputXML, strlen(encryptedVerifierHashInputXML), encryptedVerifierHashInput);
            xmlFree(encryptedVerifierHashInputXML);
            encryptedVerifierHashValueXML = xmlGetProp(cur, "encryptedVerifierHashValue");
            base64_decode(encryptedVerifierHashValueXML, strlen(encryptedVerifierHashValueXML), encryptedVerifierHashValue);
            xmlFree(encryptedVerifierHashValueXML);
            printf("%s:$office$*%d*%d*%d*%d*", parentfile, version, spinCount, pkeKeyBits, saltSize);
            print_hex(pkeSaltValue, saltSize);
            printf("*");
            print_hex(encryptedVerifierHashInput, 16);
            printf("*");
            print_hex(encryptedVerifierHashValue, 32);
            printf("\n");
            xmlFreeDoc(doc);
            unlink(xmlfile);
            return;
        }
        /* Office 2007 file processing */
        // Encryption header
        headerLength = fget32(fp);
        skipFlags = fget32(fp);
        headerLength -= 4;
        sizeExtra = fget32(fp);
        headerLength -= 4;
        algId = fget32(fp);
        headerLength -= 4;
        algHashId = fget32(fp);
        headerLength -= 4;
        keySize = fget32(fp);
        headerLength -= 4;
        providerType = fget32(fp);
        headerLength -= 4;
        (void)fget32(fp);
        headerLength -= 4;	// Reserved 1
        (void)fget32(fp);
        headerLength -= 4;	// Reserved 2
        fread(CSPName, headerLength, 1, fp);
        // Encryption verifier
        saltSize = fget32(fp);
        fread(salt, saltSize, 1, fp);
        fread(encryptedVerifier, 16, 1, fp);
        verifierHashSize = fget32(fp);
        if(providerType == PTRC4)
            fread(encryptedVerifierHash, 0x14, 1, fp);
        else
            fread(encryptedVerifierHash, 0x20, 1, fp);
        version = 2007;
        printf("%s:$office$*%d*%d*%d*%d*", parentfile, version, verifierHashSize, keySize, saltSize);
        print_hex(salt, saltSize);
        printf("*");
        print_hex(encryptedVerifier, 16);
        printf("*");
        print_hex(encryptedVerifierHash, 32);
        printf("\n");
        break;
    }
}
예제 #6
0
HRESULT XPTypeLibParse(FILE* fp, IXPTypeLib** ppTypeLib)
{
	CXPTypeLib* pTypeLib = new CXPTypeLib;
	pTypeLib->fp = fp;

	int nread = fread(pTypeLib->header.magic, 1, 16, fp);
	if (nread >= 16 && memcmp(pTypeLib->header.magic, "XPCOM\nTypeLib\r\n\032", 16)==0)
	{
		pTypeLib->header.major_version = fget8(fp);
		pTypeLib->header.minor_version = fget8(fp);
		pTypeLib->header.num_interfaces = fget16(fp);
		pTypeLib->header.file_length = fget32(fp);
		pTypeLib->header.interface_directory = fget32(fp);
		pTypeLib->header.data_pool = fget32(fp);

		if (pTypeLib->header.major_version > 1)
		{
//			ATLTRACE("XPCOM TypeLib unsupported major version %d\n", pTypeLib->header.major_version);
			return E_FAIL;
		}

		pTypeLib->ifaces = new CXPIFaceInfo*[pTypeLib->header.num_interfaces];

		fseek(fp, -1 + pTypeLib->header.interface_directory/* + i*sizeof(InterfaceDirectoryEntry)*/, SEEK_SET);

		int i;

		// Read all these in one go
		for (i = 0; i < pTypeLib->header.num_interfaces; i++)
		{
			pTypeLib->ifaces[i] = new CXPIFaceInfo;

			fread(&pTypeLib->ifaces[i]->m_iface_entry.m_iid, 16, 1, fp);
			pTypeLib->ifaces[i]->m_iface_entry.m_name = fget32(fp);
			pTypeLib->ifaces[i]->m_iface_entry.m_namespace = fget32(fp);
			pTypeLib->ifaces[i]->m_iface_entry.m_interface_descriptor = fget32(fp);
		}

		// I currently also read the rest now, but later I may read it only when necessary
		for (i = 0; i < 44/*pTypeLib->header.num_interfaces*/; i++)
		{
			ReadIdentifierFromLocation(fp, -1 + pTypeLib->header.data_pool + pTypeLib->ifaces[i]->m_iface_entry.m_name, pTypeLib->ifaces[i]->m_name);

			if (pTypeLib->ifaces[i]->m_iface_entry.m_namespace)
			{
				ReadIdentifierFromLocation(fp, -1 + pTypeLib->header.data_pool + pTypeLib->ifaces[i]->m_iface_entry.m_namespace, pTypeLib->ifaces[i]->m_namespace);
			}

			pTypeLib->ifaces[i]->m_nFuncs = 0;
			if (pTypeLib->ifaces[i]->m_iface_entry.m_interface_descriptor)
			{
				fseek(fp, -1 + pTypeLib->header.data_pool + pTypeLib->ifaces[i]->m_iface_entry.m_interface_descriptor, SEEK_SET);

				uint16 parent_interface_index = fget16(fp);
				pTypeLib->ifaces[i]->m_nFuncs = fget16(fp);

				pTypeLib->ifaces[i]->m_funcs = new XPFUNCDESC*[pTypeLib->ifaces[i]->m_nFuncs];

				for (int m = 0; m < pTypeLib->ifaces[i]->m_nFuncs; m++)
				{
					pTypeLib->ifaces[i]->m_funcs[m] = new XPFUNCDESC;
					/*
MethodDescriptor {
    boolean         is_getter;
    boolean         is_setter;
    boolean         is_not_xpcom;
    boolean         is_constructor;
    boolean         is_hidden;
    uint3           reserved;
    Identifier*     name;
    uint8           num_args;
    ParamDescriptor params[num_args];
    ParamDescriptor result;
}
*/

					uint8 flags = fget8(fp);
					DWORD name = fget32(fp);
					uint8 num_args = fget8(fp);

					for (int p = 0; p < num_args; p++)
					{
						ReadParamDescriptor(fp);
					}
					ReadParamDescriptor(fp);

					sysstring str;
					ReadIdentifierFromLocation(fp, -1 + pTypeLib->header.data_pool + name, str);
					pTypeLib->ifaces[i]->m_funcs[m]->name = str;
				}

				uint16 num_constants = fget16(fp);
				for (int c = 0; c < num_constants; c++)
				{
				/*
				ConstDescriptor
				{ 
				Identifier*     name;
				TypeDescriptor  type; 
				<type>          value;}
				*/
					DWORD name = fget32(fp);
					uint8 tag = ReadTypeDescriptor(fp);
					if (tag == 0)
					{
						char value = fget8(fp);
					}
					else if (tag == 1)
					{
						short value = fget16(fp);
					}
					else if (tag == 2)
					{
						long value = fget32(fp);
					}
					else if (tag == 4)
					{
						uint8 value = fget8(fp);
					}
					else if (tag == 5)
					{
						uint16 value = fget16(fp);
					}
					else if (tag == 6)
					{
						uint32 value = fget32(fp);
					}
					else
					{
						throw -1;//exit(1);
					}
				}
				/*
				boolean                  is_scriptable;
				boolean                  is_function;
				uint6                    reserved;
				*/
				uint8 flags = fget8(fp);

		/*
InterfaceDescriptor {
    uint16                   parent_interface_index;
    uint16                   num_methods;
    MethodDescriptor         method_descriptors[num_methods];
    uint16                   num_constants;
    ConstDescriptor          const_descriptors[num_constants];
    boolean                  is_scriptable;
    boolean                  is_function;
    uint6                    reserved;

}
		*/
			}
		}

		*ppTypeLib = pTypeLib;
		return S_OK;
	}
	else
	{
		return E_FAIL;
	}
}
예제 #7
0
static void process_file(const char *fname)
{
	unsigned char filename[1024];
	FILE *fp;
	int i;
	char path[LARGE_ENOUGH];

	if (!(fp = fopen(fname, "rb"))) {
		fprintf(stderr, "! %s : %s\n", fname, strerror(errno));
		return;
	}

	while (!feof(fp)) {
		uint32_t id = fget32(fp);

		if (id == 0x04034b50UL) {	/* local header */
			uint16_t version = fget16(fp);
			uint16_t flags = fget16(fp);
			uint16_t compression_method = fget16(fp);
			uint16_t lastmod_time = fget16(fp);
			uint16_t lastmod_date = fget16(fp);
			uint32_t crc = fget32(fp);
			uint32_t compressed_size = fget32(fp);
			uint32_t uncompressed_size = fget32(fp);
			uint16_t filename_length = fget16(fp);
			uint16_t extrafield_length = fget16(fp);
			/* unused variables */
			(void) version;
			(void) lastmod_time;
			(void) lastmod_date;
			(void) crc;
			(void) uncompressed_size;

			if (filename_length > 250) {
				fprintf(stderr, "! %s: Invalid zip file, filename length too long!\n", fname);
				return;
			}
			if (fread(filename, 1, filename_length, fp) != filename_length) {
				fprintf(stderr, "Error, in fread of file data!\n");
				goto cleanup;
			}
			filename[filename_length] = 0;

			if (compression_method == 99) {	/* AES encryption */
				uint16_t efh_id = fget16(fp);
				uint16_t efh_datasize = fget16(fp);
				uint16_t efh_vendor_version = fget16(fp);
				uint16_t efh_vendor_id = fget16(fp);
				char efh_aes_strength = fgetc(fp);
				uint16_t actual_compression_method = fget16(fp);
				unsigned char salt[16];
				char *bname;
				int n = 0;
				uint16_t password_verification_value;
				unsigned char *p;
				strnzcpy(path, fname, sizeof(path));
				bname = basename(path);

				fprintf(stderr,
				    "%s->%s is using AES encryption, extrafield_length is %d\n",
				    fname, filename, extrafield_length);
				/* unused variables */
				(void) efh_id;
				(void) efh_datasize;
				(void) efh_vendor_version;
				(void) efh_vendor_id;
				(void) efh_aes_strength;
				(void) actual_compression_method;

				printf("%s:$zip$*0*%d*", bname,
				    efh_aes_strength);
				switch (efh_aes_strength) {
				case 1:
					n = 8;
					if (fread(salt, 1, n, fp) != n) {
						fprintf(stderr, "Error, in fread of file data!\n");
						goto cleanup;
					}
					break;
				case 2:
					n = 12;
					if (fread(salt, 1, n, fp) != n) {
						fprintf(stderr, "Error, in fread of file data!\n");
						goto cleanup;
					}
					break;
				case 3:
					n = 16;
					if (fread(salt, 1, n, fp) != n) {
						fprintf(stderr, "Error, in fread of file data!\n");
						goto cleanup;
					}
					break;

				}
				for (i = 0; i < n; i++) {
					printf("%c%c",
					    itoa16[ARCH_INDEX(salt[i] >> 4)],
					    itoa16[ARCH_INDEX(salt[i] &
						    0x0f)]);
				}
				password_verification_value = fget16(fp);
				p = (unsigned char *) &password_verification_value;
				printf("*");
				for (i = 0; i < 2; i++) {
					printf("%c%c",
					    itoa16[ARCH_INDEX(p[i] >> 4)],
					    itoa16[ARCH_INDEX(p[i] & 0x0f)]);
				}
				printf(":::::%s\n", fname);
				fseek(fp, 10, SEEK_CUR);

			} else if (flags & 1) {	/* old encryption */
예제 #8
0
void process_database(char* encryptedDatabase)
{
	long dataStartOffset;
	unsigned long transformRounds;
	unsigned char *masterSeed;
	int masterSeedLength;
	unsigned char *transformSeed;
	int transformSeedLength;
	unsigned char *initializationVectors;
	int initializationVectorsLength;
	unsigned char *expectedStartBytes;
	int expectedStartBytesLength;

	FILE *fp = fopen(encryptedDatabase, "rb");
	if (!fp) {
		fprintf(stderr, "! %s : %s\n", encryptedDatabase, strerror(errno));
		return;
	}
	uint32_t uSig1 = fget32(fp);
	uint32_t uSig2 = fget32(fp);
	if ((uSig1 == FileSignatureOld1) && (uSig2 == FileSignatureOld2)) {
		fprintf(stderr, "! %s : Old format, not supported currently\n", encryptedDatabase);
		fclose(fp);
		return;
	}
	if ((uSig1 == FileSignature1) && (uSig2 == FileSignature2)) {
	}
	else if ((uSig1 == FileSignaturePreRelease1) && (uSig2 == FileSignaturePreRelease2)) {
	}
	else {
		fprintf(stderr, "! %s : Unknown format: File signature invalid\n", encryptedDatabase);
		fclose(fp);
		return;
	}
        uint32_t uVersion = fget32(fp);
	if ((uVersion & FileVersionCriticalMask) > (FileVersion32 & FileVersionCriticalMask)) {
		fprintf(stderr, "! %s : Unknown format: File version unsupported\n", encryptedDatabase);
		fclose(fp);
		return;
	}
	int endReached = 0;
	while (!endReached)
	{
		unsigned char btFieldID = fgetc(fp);
                uint16_t uSize = fget16(fp);

		unsigned char *pbData = NULL;
		if (uSize > 0)
		{
			pbData = (unsigned char*)malloc(uSize);
			fread(pbData, uSize, 1, fp);
		}
		enum Kdb4HeaderFieldID kdbID = btFieldID;
		switch (kdbID)
		{
			case EndOfHeader:
				endReached = 1;  // end of header
				free(pbData);
				break;

                        case MasterSeed:
				masterSeed = pbData;
				masterSeedLength = uSize;
				break;

                        case TransformSeed:
				transformSeed = pbData;
				transformSeedLength = uSize;
				break;

                        case TransformRounds:
				transformRounds = BytesToUInt64(pbData);
				free(pbData);
				break;

                        case EncryptionIV:
				initializationVectors = pbData;
				initializationVectorsLength = uSize;
				break;

                        case StreamStartBytes:
				expectedStartBytes = pbData;
				expectedStartBytesLength = uSize;
				break;

			default:
				free(pbData);
				break;
		}
	}
	dataStartOffset = ftell(fp);
	if(transformRounds == 0) {
		fprintf(stderr, "! %s : transformRounds can't be 0\n", encryptedDatabase);
		return;
	}
#ifdef KEEPASS_DEBUG
	fprintf(stderr, "%d, %d, %d, %d\n", masterSeedLength, transformSeedLength, initializationVectorsLength, expectedStartBytesLength);
#endif
	printf("%s:$keepass$*2*%ld*%ld*",encryptedDatabase, transformRounds, dataStartOffset);
	print_hex(masterSeed, masterSeedLength);
	printf("*");
	print_hex(transformSeed, transformSeedLength);
	printf("*");
	print_hex(initializationVectors, initializationVectorsLength);
	printf("*");
	print_hex(expectedStartBytes, expectedStartBytesLength);
	printf("\n");
	free(masterSeed);
	free(transformSeed);
	free(initializationVectors);
	free(expectedStartBytes);
	fclose(fp);
}