CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/Apps/plFileSecure/main.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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 3 of the License, or
(at your option) any later version.

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, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "../plFile/hsFiles.h"
#include "../plFile/plFileUtils.h"
#include "../plFile/plSecureStream.h"
#include "../pnUtils/pnUtils.h"
#include "../pnProduct/pnProduct.h"
#include "hsUtils.h"

#include <time.h>
#include <string>

void print_version() {
	wchar productString[256];
	ProductString(productString, arrsize(productString));
	printf("%S\n\n", productString);
}

void print_help() {
	printf("plFileSecure - Secures Uru files and generates encryption.key files.\n\n");
	print_version();
	printf("Usage:\n");
	printf("\tplFileSecure (<directory> <ext>)|[/generate /default]\n");
	printf("\n");
	printf("<directory> <ext>    : The directory and extension of files to secure. Cannot\n");
	printf("                       be used with /generate. Uses the %s file in\n", plFileUtils::kKeyFilename);
	printf("                       the current directory (or default key if no file exists)\n");
	printf("/generate            : Generates a random key and writes it to a %s\n", plFileUtils::kKeyFilename);
	printf("                       file in the current directory. Cannot be used with\n");
	printf("                       <directory> <ext>\n");
	printf("/default             : If used with /generate, creates a %s file\n", plFileUtils::kKeyFilename);
	printf("                       with the default key. If used with <directory> <ext>, it\n");
	printf("                       secures with the default key instead of the\n");
	printf("                       %s file's key\n", plFileUtils::kKeyFilename);
	printf("\n");
}

void GenerateKey(bool useDefault)
{
	UInt32 key[4];
	if (useDefault)
	{
		unsigned memSize = min(arrsize(key), arrsize(plSecureStream::kDefaultKey));
		memSize *= sizeof(UInt32);
		memcpy(key, plSecureStream::kDefaultKey, memSize);
	}
	else
	{
		srand((unsigned)time(nil));
		double randNum = (double)rand() / (double)RAND_MAX; // converts to 0..1
		UInt32 keyNum = (UInt32)(randNum * (double)0xFFFFFFFF); // multiply it by the max unsigned 32-bit int
		key[0] = keyNum;

		randNum = (double)rand() / (double)RAND_MAX;
		keyNum = (UInt32)(randNum * (double)0xFFFFFFFF);
		key[1] = keyNum;

		randNum = (double)rand() / (double)RAND_MAX;
		keyNum = (UInt32)(randNum * (double)0xFFFFFFFF);
		key[2] = keyNum;

		randNum = (double)rand() / (double)RAND_MAX;
		keyNum = (UInt32)(randNum * (double)0xFFFFFFFF);
		key[3] = keyNum;
	}

	hsUNIXStream out;
	out.Open(plFileUtils::kKeyFilename, "wb");
	out.Write(sizeof(UInt32) * arrsize(key), (void*)key);
	out.Close();
}

void SecureFiles(std::string dir, std::string ext, UInt32* key)
{
	char filePath[256];

	hsFolderIterator folder(dir.c_str());
	while (folder.NextFileSuffix(ext.c_str()))
	{
		folder.GetPathAndName(filePath);
		printf("securing: %s\n", folder.GetFileName());
		plSecureStream::FileEncrypt(filePath, key);
	}
}

int main(int argc, char *argv[])
{
	bool generatingKey = false;
	bool useDefault = false;
	std::string directory;
	std::string ext;

	if (argc > 1)
	{
		for (int i = 1; i < argc; i++)
		{
			std::string arg = argv[i];
			if ((arg[0] == '-')||(arg[0] == '/'))
			{
				// this arg is a flag of some kind
				arg = arg.substr(1, arg.length()); // trim the dash or slash
				if ((stricmp(arg.c_str(), "g") == 0) || (stricmp(arg.c_str(), "generate") == 0))
				{
					if (!generatingKey)
						generatingKey = true;
					else
					{
						print_help();
						return 0;
					}
				}
				else if ((stricmp(arg.c_str(), "d") == 0) || (stricmp(arg.c_str(), "default") == 0))
				{
					if (!useDefault)
						useDefault = true;
					else
					{
						print_help();
						return 0;
					}
				}
				else
				{
					print_help();
					return 0;
				}
			}
			else
			{
				// else it is a directory or extension
				if (directory == "")
					directory = argv[i];
				else if (ext == "")
					ext = argv[i];
				else
				{
					print_help();
					return 0;
				}
			}
		}

		if (generatingKey && ((directory != "") || (ext != "")))
		{
			print_help();
			return 0;
		}
	}
	else
	{
		print_help();
		return 0;
	}

	if (generatingKey)
	{
		GenerateKey(useDefault);
		return 0;
	}

	if (ext[0] != '.')
		ext = "." + ext; // tack on the dot if necessary

	if (useDefault)
		SecureFiles(directory, ext, nil);
	else
	{
		UInt32 key[4];
		plFileUtils::GetSecureEncryptionKey(plFileUtils::kKeyFilename, key, arrsize(key));
		SecureFiles(directory, ext, key);
	}
	return 0;
}