replacepub.c

#define  _CRT_SECURE_NO_WARNINGS
#include "rlmpubkey.h"
#include "pubkeyset.h"

int cpfile(char* oldfile, char* newfile)
{
	FILE* oldname = fopen(oldfile,"rb");
	if (oldname ==NULL)
	{
		printf("Failed to read file %s, skipping!\n", oldfile);
		return 0;
	}
	FILE* newname = fopen(newfile,"wb");
	if (newname == NULL)
	{
		printf("Failed to create file %s, skipping!\n", newfile);
		return 0;
	}
	char wfbuf[1024] = { 0 };
	int nlen = 0;
	while ((nlen = fread(wfbuf,1,1024,oldname)) >0)
	{
		fwrite(wfbuf, 1, nlen, newname);
	}
	fclose(oldname);
	fclose(newname);
	return 1;
}

/* Replace public keys in marked files from the linked list */
int replacepubkey(PubkeyInfo *pki)
{
	PubkeyInfo* p = pki->next;
	char last_filename[2000] = {0};  // Track last processed filename
	printf("\nReplacing files:\n");
	while (p)
	{
		char bakfilename[2000];
		sprintf(bakfilename, "%s_bak", p->filename);
		
		// Only create backup if this is a new file
		if (strcmp(p->filename, last_filename) != 0) {
			if (!cpfile(p->filename, bakfilename)) {
				printf("Failed to create backup file for %s.\n", p->filename);
				p = p->next;
				continue;
			}
			strncpy(last_filename, p->filename, sizeof(last_filename) - 1);
		}

		FILE* readfile = fopen(bakfilename, "rb");
		FILE* wfile = fopen(p->filename, "wb");
		
		if (!readfile || !wfile) {
			printf("Error opening files for replacement.\n");
			if (readfile) fclose(readfile);
			if (wfile) fclose(wfile);
			p = p->next;
			continue;
		}

		char* f1 = calloc(p->offset, 1);
		if (!f1) {
			printf("Memory allocation failed.\n");
			fclose(readfile);
			fclose(wfile);
			p = p->next;
			continue;
		}

		size_t read_size = fread(f1, 1, p->offset, readfile);
		if (read_size != p->offset) {
			printf("Read size mismatch: expected %d, got %zu.\n", p->offset, read_size);
			free(f1);
			fclose(readfile);
			fclose(wfile);
			p = p->next;
			continue;
		}

		char* f2 = NULL;
		int endlong = 0;
		const unsigned char* pubkey = NULL;
		
		switch(p->pubkeylen) {
			case 223: pubkey = pubkey_223; break;
			case 224: pubkey = pubkey_224; break;
			case 225: pubkey = pubkey_225; break;
			case 226: pubkey = pubkey_226; break;
			case 227: pubkey = pubkey_227; break;
			default:
				printf("Invalid pubkey length: %d.\n", p->pubkeylen);
				free(f1);
				fclose(readfile);
				fclose(wfile);
				p = p->next;
				continue;
		}

		endlong = (p->filesize) - p->pubkeylen - (p->offset);
		f2 = calloc(endlong, 1);
		if (!f2) {
			printf("Memory allocation failed for f2.\n");
			free(f1);
			fclose(readfile);
			fclose(wfile);
			p = p->next;
			continue;
		}

		fseek(readfile, p->pubkeylen, SEEK_CUR);
		if (fread(f2, 1, endlong, readfile) != endlong) {
			printf("Failed to read end portion of file.\n");
			free(f1);
			free(f2);
			fclose(readfile);
			fclose(wfile);
			p = p->next;
			continue;
		}

		if (fwrite(f1, 1, p->offset, wfile) != p->offset ||
			fwrite(pubkey, 1, p->pubkeylen, wfile) != p->pubkeylen ||
			fwrite(f2, 1, endlong, wfile) != endlong) {
			printf("Failed to write to output file.\n");
		} else {
			printf("File %s : Replace success at offset %d!\n", p->filename, p->offset);
		}

		free(f1);
		free(f2);
		fclose(readfile);
		fclose(wfile);
		p = p->next;
	}
	return 0;
}

int fwnull(FILE* filename, int len)
{
	for (int i = 0; i < len; i++)
	{
		fwrite("\0", 1, 1, filename);
	}
	return 1;
}

int createsign(PubkeyInfo* pki, unsigned char* rlmsign)
{
	// Find first node with valid ISV info and count key frequencies
	PubkeyInfo* p = pki->next;
	PubkeyInfo* first_valid_isv = NULL;
	
	// Array to store key counts for each length
	int key_counts[228] = {0};  // Index represents key length
	unsigned char most_common_key[227];  // Store most common key
	int max_count = 0;
	int most_common_len = 0;
	
	// First pass: count keys and find first valid ISV
	while (p) {
		if (p->isvname[0] != '\0' && !first_valid_isv) {
			first_valid_isv = p;
		}
		
		key_counts[p->pubkeylen]++;
		if (key_counts[p->pubkeylen] > max_count) {
			max_count = key_counts[p->pubkeylen];
			most_common_len = p->pubkeylen;
			memcpy(most_common_key, p->pubkey, p->pubkeylen);
		}
		p = p->next;
	}
	
	if (!first_valid_isv) {
		printf("Error: No valid ISV information found in files.\n");
		return 0;
	}

	// Use first valid ISV info but most common key
	printf("\n=== REPLACEMENT Key Information ===\n");
	printf("Using ISV information from file %s and most common key length %d:\n", 
		   first_valid_isv->filename, most_common_len);
	printf("##############################################\n");
	printf("ISV Name = %s\n", first_valid_isv->isvname);
	printf("ISV Key = %s\n", first_valid_isv->isvkey);
	printf("Length = %d\n", most_common_len);
	
	// Get the replacement key based on length
	const unsigned char* replacement_key = NULL;
	switch(most_common_len) {
		case 223: replacement_key = pubkey_223; break;
		case 224: replacement_key = pubkey_224; break;
		case 225: replacement_key = pubkey_225; break;
		case 226: replacement_key = pubkey_226; break;
		case 227: replacement_key = pubkey_227; break;
		default:
			printf("Error: Unsupported key length %d\n", most_common_len);
			return 0;
	}
	
	printf("REPLACEMENT Key Content (what keys will be replaced with) = \n");
	for (int j = 0; j < most_common_len; j++) {
		printf("%02X:", replacement_key[j]);
	}
	printf("\n");
	printf("##############################################\n\n");

	char ISV[32] = {0};
	strncpy(ISV, first_valid_isv->isvname, sizeof(ISV) - 1);

	int offset1 = 0x5d698; int offset2 = 0x5d698;
	int offset3 = 0x6e878; int offset4 = 0x6e888;
	int end = 0x80c00;
	
	char outname[50];
	sprintf(outname, "rlmsign_%s.exe", ISV);
	FILE* rlmsncreat = fopen(outname, "wb");

	unsigned char *pSign = rlmsign;
	if (most_common_len == 224)
	{
		fwrite(pSign, offset1, 1, rlmsncreat);

		fwrite(priv_key_224, 250, 1, rlmsncreat);
		//227私钥长252，224私钥长250，多两位用\0充填
		fwnull(rlmsncreat, 2);
		//公私钥间有4个00 充填
		fwnull(rlmsncreat, 4);

		fwrite(pubkey_224, 224, 1, rlmsncreat);
		//227公钥长227，224公钥长224，多三位用\0充填
		fwnull(rlmsncreat, 3);

		fwrite(pSign + 0x5d87b, offset3 - 0x5d87b, 1, rlmsncreat);

		fwrite(ISV, strlen(ISV), 1, rlmsncreat);
		fwnull(rlmsncreat, 16 - strlen(ISV));

		fwrite(first_valid_isv->isvkey, strlen(first_valid_isv->isvkey), 1, rlmsncreat);
		fwnull(rlmsncreat, 288 - strlen(first_valid_isv->isvkey));

		//fwrite(pSign + 0x6e9a8, end - 0x6e9a8, 1, rlmsncreat);
	}
	else if (most_common_len == 225)
	{
		fwrite(pSign, offset1, 1, rlmsncreat);

		fwrite(priv_key_225, 250, 1, rlmsncreat);
		//227私钥长252，225私钥长250，多两位用\0充填
		fwnull(rlmsncreat, 2);
		//公私钥间有4个00 充填
		fwnull(rlmsncreat, 4);

		fwrite(pubkey_225, 225, 1, rlmsncreat);
		//227公钥长227，224公钥长224，多三位用\0充填
		fwnull(rlmsncreat, 2);

		fwrite(pSign + 0x5d87b, offset3 - 0x5d87b, 1, rlmsncreat);

		fwrite(ISV, strlen(ISV), 1, rlmsncreat);
		fwnull(rlmsncreat, 16 - strlen(ISV));

		fwrite(first_valid_isv->isvkey, strlen(first_valid_isv->isvkey), 1, rlmsncreat);
		fwnull(rlmsncreat, 288 - strlen(first_valid_isv->isvkey));

		//fwrite(pSign + 0x6e9a8, end - 0x6e9a8, 1, rlmsncreat);
	}
	else if (most_common_len == 226)
	{
		fwrite(pSign, offset1, 1, rlmsncreat);

		fwrite(priv_key_226, 251, 1, rlmsncreat);
		//227私钥长252，226私钥长251
		fwnull(rlmsncreat, 1);
		//公私钥间有4个00 充填
		fwnull(rlmsncreat, 4);

		fwrite(pubkey_226, 226, 1, rlmsncreat);
		//227公钥长227，224公钥长224，多三位用\0充填
		fwnull(rlmsncreat, 1);

		fwrite(pSign + 0x5d87b, offset3 - 0x5d87b, 1, rlmsncreat);

		fwrite(ISV, strlen(ISV), 1, rlmsncreat);
		fwnull(rlmsncreat, 16 - strlen(ISV));

		fwrite(first_valid_isv->isvkey, strlen(first_valid_isv->isvkey), 1, rlmsncreat);
		fwnull(rlmsncreat, 288 - strlen(first_valid_isv->isvkey));

		//fwrite(f3, end - 0x6e9a8, 1, rlmsncreat);
	}
	else if (most_common_len == 227)
	{
		fwrite(pSign, offset3, 1, rlmsncreat);

		fwrite(ISV, strlen(ISV), 1, rlmsncreat);
		fwnull(rlmsncreat, 16 - strlen(ISV));

		fwrite(first_valid_isv->isvkey, strlen(first_valid_isv->isvkey), 1, rlmsncreat);
		fwnull(rlmsncreat, 288 - strlen(first_valid_isv->isvkey));
	}
	else if (most_common_len == 223)
	{
		fwrite(pSign, offset1, 1, rlmsncreat);

		fwrite(priv_key_223, 249, 1, rlmsncreat);
		//227私钥长252，223私钥长249，多三位用\0充填
		fwnull(rlmsncreat, 3);
		//公私钥间有4个00 充填
		fwnull(rlmsncreat, 4);

		fwrite(pubkey_223, 223, 1, rlmsncreat);
		//227公钥长227，223公钥长223，多四位用\0充填
		fwnull(rlmsncreat, 4);

		fwrite(pSign + 0x5d87b, offset3 - 0x5d87b, 1, rlmsncreat);

		fwrite(ISV, strlen(ISV), 1, rlmsncreat);
		fwnull(rlmsncreat, 16 - strlen(ISV));

		fwrite(first_valid_isv->isvkey, strlen(first_valid_isv->isvkey), 1, rlmsncreat);
		fwnull(rlmsncreat, 288 - strlen(first_valid_isv->isvkey));
	}

	fwrite(pSign + 0x6e9a8, end - 0x6e9a8, 1, rlmsncreat);
	fclose(rlmsncreat);
	
	printf("Keygen generated as: %s\n", outname);
	
	return 1;
}