ooxml_crypt 0.1.0

data/vendor/msoffice/src/msocdll.cpp

@@ -0,0 +1,276 @@
+/**
+	@file
+	@brief MS Office Crypt DLL
+	@author herumi
+	Copyright (C) 2016 Cybozu Labs, Inc., all rights reserved.
+*/
+#ifdef _MSC_VER
+	#pragma warning(disable : 4456)
+	#pragma warning(disable : 4458)
+#endif
+
+#define MSOC_DONT_AUTO_LINK
+#include "cfb.hpp"
+#include "decode.hpp"
+#include "encode.hpp"
+#include "make_dataspace.hpp"
+#include "msoc.h"
+
+static const size_t maxExceptionSize = 1024;
+static char g_exception[maxExceptionSize + 1] = "exception";
+
+static void setException(const std::exception& e)
+{
+	/// QQQ : not multi-thread
+	size_t len = strlen(e.what());
+	if (len >= maxExceptionSize) len = maxExceptionSize;
+	memcpy(g_exception, e.what(), len);
+	g_exception[len] = '\0';
+}
+
+const char * MSOC_DLL_EXPORT MSOC_getErrMessage(int err)
+{
+	switch (err) {
+	case MSOC_NOERR:
+		return "noerr";
+	case MSOC_ERR_NOT_SUPPORT:
+		return "not supported format";
+	case MSOC_ERR_ALREADY_ENCRYPTED:
+		return "already encrypted";
+	case MSOC_ERR_ALREADY_DECRYPTED:
+		return "already decrypted";
+	case MSOC_ERR_BAD_PASSWORD:
+		return "bad password";
+	case MSOC_ERR_NO_MEMORY:
+		return "no memory";
+	case MSOC_ERR_EXCEPTION:
+		return g_exception;
+	case MSOC_ERR_TOO_LARGE_FILE:
+		return "too large file";
+	case MSOC_ERR_INFILE_IS_EMPTY:
+		return "inFile is empty";
+	case MSOC_ERR_OUTFILE_IS_EMPTY:
+		return "outFile is empty";
+	case MSOC_ERR_PASS_IS_EMPTY:
+		return "pass is empty";
+	default:
+		return "unknown err";
+	}
+}
+
+struct msoc_opt {
+	int spinCount;
+	std::string secretKey;
+	msoc_opt()
+		: spinCount(100000)
+		, secretKey()
+	{
+	}
+};
+
+msoc_opt * MSOC_DLL_EXPORT MSOC_createOpt(void)
+{
+	try {
+		return new msoc_opt();
+	} catch (...) {
+		return NULL;
+	}
+}
+
+void MSOC_DLL_EXPORT MSOC_destroyOpt(msoc_opt *msoc)
+{
+	delete(msoc);
+}
+
+int MSOC_DLL_EXPORT MSOC_getInt(int *value, const msoc_opt *opt, int optType)
+{
+	switch (optType) {
+	case MSOC_OPT_TYPE_SPIN_COUNT:
+		*value = opt->spinCount;
+		return MSOC_NOERR;
+	default:
+		return MSOC_ERR_BAD_PARAMETER;
+	}
+}
+
+int MSOC_DLL_EXPORT MSOC_setInt(msoc_opt *opt, int optType, int value)
+{
+	switch (optType) {
+	case MSOC_OPT_TYPE_SPIN_COUNT:
+		opt->spinCount = value;
+		return MSOC_NOERR;
+	default:
+		return MSOC_ERR_BAD_PARAMETER;
+	}
+}
+
+static int getStr(char *str, size_t maxSize, const std::string& s)
+{
+	if (maxSize < s.size() + 1) return MSOC_ERR_SMALL_MAX_SIZE;
+	memcpy(str, s.c_str(), s.size());
+	str[s.size()] = '\0';
+	return MSOC_NOERR;
+}
+
+int MSOC_DLL_EXPORT MSOC_getStr(char *str, size_t maxSize, const msoc_opt *opt, int optType)
+{
+	switch (optType) {
+	case MSOC_OPT_TYPE_SECRET_KEY:
+		return getStr(str, maxSize, opt->secretKey);
+	default:
+		return MSOC_ERR_BAD_PARAMETER;
+	}
+}
+
+int MSOC_DLL_EXPORT MSOC_setStr(msoc_opt *opt, int optType, const char *str)
+	try
+{
+	switch (optType) {
+	case MSOC_OPT_TYPE_SECRET_KEY:
+		opt->secretKey = str;
+		return MSOC_NOERR;
+	default:
+		return MSOC_ERR_BAD_PARAMETER;
+	}
+} catch (...) {
+	return MSOC_ERR_NO_MEMORY;
+}
+
+template<class T>
+static int readFile(std::string& data, ms::Format& format, uint32_t& dataSize, const T *inFile)
+{
+	cybozu::Mmap m(inFile);
+	if (m.size() > 0xffffffff) {
+		return MSOC_ERR_TOO_LARGE_FILE;
+	}
+	dataSize = static_cast<uint32_t>(m.size());
+	data.assign(m.get(), dataSize);
+	format = ms::DetectFormat(data.data(), dataSize);
+	return MSOC_NOERR;
+}
+
+/*
+	REMARK : passData is UTF-16 encoded
+	if pass = "abc"
+	passData[0] = 'a'
+	passData[1] = '\0'
+	passData[2] = 'b'
+	passData[3] = '\0'
+	passData[4] = 'c'
+	passData[5] = '\0'
+*/
+template<class T>
+int encrypt(const T *outFile, const T *inFile, const std::string& passData, const msoc_opt *opt)
+{
+	if (outFile == NULL) return MSOC_ERR_OUTFILE_IS_EMPTY;
+	if (inFile == NULL) return MSOC_ERR_INFILE_IS_EMPTY;
+	const bool isOffice2013 = true;
+	std::string data;
+	ms::Format format;
+	uint32_t dataSize;
+	int err = readFile(data, format, dataSize, inFile);
+	if (err != MSOC_NOERR) return err;
+	if (format == ms::fCfb) {
+		return MSOC_ERR_ALREADY_ENCRYPTED;
+	}
+	int spinCount = 100000;
+	std::string secretKey;
+	if (opt) {
+		if (opt->spinCount) spinCount = opt->spinCount;
+		if (!opt->secretKey.empty()) secretKey = ms::fromHex(opt->secretKey);
+	}
+	std::basic_string<T> outFileW = outFile;
+	ms::encode(data.data(), dataSize, outFileW, passData, isOffice2013, secretKey, spinCount);
+	return MSOC_NOERR;
+}
+
+static std::string convertChar2Wchar(const char *s)
+{
+	if (s == NULL) return "";
+	const size_t len= strlen(s);
+	std::string ret;
+	ret.resize(len * 2);
+	for (size_t i = 0; i < len; i++) {
+		ret[i * 2] = s[i];
+	}
+	return ret;
+}
+
+int MSOC_DLL_EXPORT MSOC_encryptA(const char *outFile, const char *inFile, const char *pass, const msoc_opt *opt)
+	try
+{
+	if (pass == NULL) return MSOC_ERR_PASS_IS_EMPTY;
+	std::string passData = convertChar2Wchar(pass);
+	return encrypt(outFile, inFile, passData, opt);
+} catch (std::exception& e) {
+	setException(e);
+	return MSOC_ERR_EXCEPTION;
+}
+
+#ifdef _MSC_VER
+int MSOC_DLL_EXPORT MSOC_encrypt(const wchar_t *outFile, const wchar_t *inFile, const wchar_t *pass, const msoc_opt *opt)
+	try
+{
+	if (pass == NULL) return MSOC_ERR_PASS_IS_EMPTY;
+	std::string passData = ms::Char16toChar8(pass);
+	return encrypt(outFile, inFile, passData, opt);
+} catch (std::exception& e) {
+	setException(e);
+	return MSOC_ERR_EXCEPTION;
+}
+#endif
+
+template<class T>
+int decrypt(const T *outFile, const T *inFile, const std::string& passData, msoc_opt *opt)
+{
+	if (inFile == NULL) return MSOC_ERR_INFILE_IS_EMPTY;
+	const bool doView = outFile == NULL;
+	std::string data;
+	ms::Format format;
+	uint32_t dataSize;
+	int err = readFile(data, format, dataSize, inFile);
+	if (err != MSOC_NOERR) return err;
+	if (format == ms::fZip) {
+		return MSOC_ERR_ALREADY_DECRYPTED;
+	}
+	std::string secretKey;
+	if (opt) {
+		if (!opt->secretKey.empty()) secretKey = ms::fromHex(opt->secretKey);
+	}
+	std::basic_string<T> outFileW;
+	if (outFile) {
+		outFileW = outFile;
+	}
+	int spinCount;
+	bool ok = ms::decode(data.data(), dataSize, outFileW, passData, secretKey, doView, &spinCount);
+	if (!ok) return MSOC_ERR_BAD_PASSWORD;
+	if (opt) {
+		opt->spinCount = spinCount;
+		opt->secretKey = ms::hex(secretKey);
+	}
+	return MSOC_NOERR;
+}
+
+int MSOC_DLL_EXPORT MSOC_decryptA(const char *outFile, const char *inFile, const char *pass, msoc_opt *opt)
+	try
+{
+	std::string passData;
+	if (pass) passData = convertChar2Wchar(pass);
+	return decrypt(outFile, inFile, passData, opt);
+} catch (std::exception& e) {
+	setException(e);
+	return MSOC_ERR_EXCEPTION;
+}
+
+#ifdef _MSC_VER
+int MSOC_DLL_EXPORT MSOC_decrypt(const wchar_t *outFile, const wchar_t *inFile, const wchar_t *pass, msoc_opt *opt)
+	try
+{
+	std::string passData;
+	if (pass) passData = ms::Char16toChar8(pass);
+	return decrypt(outFile, inFile, passData, opt);
+} catch (std::exception& e) {
+	setException(e);
+	return MSOC_ERR_EXCEPTION;
+}
+#endif

data/vendor/msoffice/src/msocsample.c

@@ -0,0 +1,136 @@
+/**
+	@file
+	@brief MS Office Crypt DLL sample
+	@author herumi
+	Copyright (C) 2016 Cybozu Labs, Inc., all rights reserved.
+*/
+#include "msoc.h"
+#include <stdio.h>
+
+void usage()
+{
+	const char *s =
+	"how to use\n"
+	"msocsample.exe enc <inFile> <outFile> <pass>\n"
+	"msocsample.exe dec <inFile> <outFile> <pass>\n"
+	"msocsample.exe opt <inFile> <pass>\n"
+	"msocsample.exe enc-sec <inFile> <outFile> <pass> <secretKey> [<spinCount>]\n"
+	"msocsample.exe dec-sec <inFile> <outFile> <secretKey>\n";
+	printf("%s", s);
+	exit(1);
+}
+
+/*
+	assume w[i] is ascii code
+*/
+void wchar2ascii(char *s, size_t maxSize, const wchar_t *w)
+{
+	size_t i;
+	for (i = 0; i < maxSize; i++) {
+		wchar_t c = w[i];
+		s[i] = (char)c;
+		if (s[i] != c) {
+			printf("not ascii %04x\n", c);
+			exit(1);
+		}
+		if (s[i] == '\0') return;
+	}
+	puts("too long w");
+	exit(1);
+}
+
+int wmain(int argc, wchar_t **argv)
+{
+	int err = 0;
+	const wchar_t *inFile = NULL;
+	const wchar_t *outFile = NULL;
+	struct msoc_opt *opt = NULL;
+	int spinCount;
+	char secretKey[256];
+
+	argc--, argv++;
+	if (argc < 3) {
+		usage();
+	}
+	if (wcscmp(argv[0], L"enc") == 0) {
+		if (argc != 4) {
+			usage();
+		}
+		printf("enc in=%S, out=%S\n", argv[1], argv[2]);
+		err = MSOC_encrypt(argv[2], argv[1], argv[3], NULL);
+	} else
+	if (wcscmp(argv[0], L"dec") == 0) {
+		if (argc != 4) {
+			usage();
+		}
+		printf("dec in=%S, out=%S, pass=%S\n", argv[1], argv[2], argv[3]);
+		err = MSOC_decrypt(argv[2], argv[1], argv[3], NULL);
+	} else
+	if (wcscmp(argv[0], L"opt") == 0) {
+		if (argc != 3) {
+			usage();
+		}
+		printf("opt in=%S, pass=%S\n", argv[1], argv[2]);
+		opt = MSOC_createOpt();
+		if (opt == NULL) {
+			puts("ERR MSOC_createOpt");
+			return 1;
+		}
+		err = MSOC_decrypt(NULL, argv[1], argv[2], opt);
+		if (err != MSOC_NOERR) goto EXIT;
+		err = MSOC_getInt(&spinCount, opt, MSOC_OPT_TYPE_SPIN_COUNT);
+		if (err != MSOC_NOERR) goto EXIT;
+		err = MSOC_getStr(secretKey, sizeof(secretKey), opt, MSOC_OPT_TYPE_SECRET_KEY);
+		if (err != MSOC_NOERR) goto EXIT;
+		printf("spinCout=%d\n", spinCount);
+		printf("secretKey=%s\n", secretKey);
+	} else
+	if (wcscmp(argv[0], L"enc-sec") == 0) {
+		if (argc != 5 && argc != 6) {
+			usage();
+		}
+		printf("enc-sec in=%S, out=%S, pass=%S, secretKey=%S\n", argv[1], argv[2], argv[3], argv[4]);
+		wchar2ascii(secretKey, sizeof(secretKey), argv[4]);
+		opt = MSOC_createOpt();
+		if (opt == NULL) {
+			puts("ERR MSOC_createOpt");
+			return 1;
+		}
+		err = MSOC_setStr(opt, MSOC_OPT_TYPE_SECRET_KEY, secretKey);
+		if (err != MSOC_NOERR) goto EXIT;
+		if (argc == 6) {
+			int spinCount = _wtoi(argv[5]);
+			printf("spinCount=%d\n", spinCount);
+			err = MSOC_setInt(opt, MSOC_OPT_TYPE_SPIN_COUNT, spinCount);
+			if (err != MSOC_NOERR) goto EXIT;
+		}
+		err = MSOC_encrypt(argv[2], argv[1], argv[3], opt);
+	} else
+	if (wcscmp(argv[0], L"dec-sec") == 0) {
+		if (argc != 4) {
+			usage();
+		}
+		printf("dec-sec in=%S, out=%S, secretKey=%S\n", argv[1], argv[2], argv[3]);
+		wchar2ascii(secretKey, sizeof(secretKey), argv[3]);
+		opt = MSOC_createOpt();
+		if (opt == NULL) {
+			puts("ERR MSOC_createOpt");
+			return 1;
+		}
+		err = MSOC_setStr(opt, MSOC_OPT_TYPE_SECRET_KEY, secretKey);
+		if (err != MSOC_NOERR) goto EXIT;
+		err = MSOC_decrypt(argv[2], argv[1], NULL, opt);
+	} else
+	{
+		usage();
+	}
+EXIT:
+	MSOC_destroyOpt(opt);
+	if (err != MSOC_NOERR) {
+		printf("ERR %s\n", MSOC_getErrMessage(err));
+		return 1;
+	} else {
+		puts("ok");
+	}
+	return 0;
+}

data/vendor/msoffice/src/msoffice-crypt.cpp

@@ -0,0 +1,219 @@
+/**
+	@file
+	@brief MS Office encryption encoder/decoder
+	Copyright (C) 2012 Cybozu Labs, Inc., all rights reserved.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+#include <locale>
+#include <fstream>
+#include <cybozu/mmap.hpp>
+#include <cybozu/file.hpp>
+#include <cybozu/atoi.hpp>
+#include <cybozu/option.hpp>
+#include "cfb.hpp"
+#include "decode.hpp"
+#include "encode.hpp"
+#include "make_dataspace.hpp"
+#ifdef _MSC_VER
+#include <cybozu/string.hpp>
+#endif
+
+inline cybozu::String16 fromUniHex(const std::string& str)
+{
+	const size_t n = str.size();
+	if ((n % 5) != 0) throw cybozu::Exception("f8romUniHex:bad str") << str;
+	cybozu::String16 ret;
+	for (size_t i = 0; i < n; i += 5) {
+		if (str[i] != 'u') throw cybozu::Exception("fromUniHex:bad format") << str;
+		cybozu::Char16 c = static_cast<uint16_t>(cybozu::hextoi(&str[i + 1], 4));
+		ret += c;
+	}
+	return ret;
+}
+
+const char denySuffixTbl[][8] = {
+	"xls",
+	"xlt",
+	"xla",
+
+	"ppt",
+	"pot",
+	"pps",
+	"ppa",
+
+	"doc",
+	"dot",
+};
+
+bool denySuffix(const std::string& suf)
+{
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(denySuffixTbl); i++) {
+		if (suf == denySuffixTbl[i]) return true;
+	}
+	return false;
+}
+
+#ifdef _MSC_VER
+int wmain(int argc, wchar_t *wargv[])
+#else
+int main(int argc, char *argv[])
+#endif
+	try
+{
+#ifdef _MSC_VER
+	std::vector<std::string> strVec;
+	for (size_t i = 0; i < argc; i++) {
+		const std::wstring s = __wargv[i];
+		std::string utf8;
+		cybozu::ConvertUtf16ToUtf8(&utf8, s);
+		strVec.push_back(utf8);
+	}
+	std::vector<char*> ptrVec(argc);
+	for (size_t i = 0; i < argc; i++) {
+		ptrVec[i] = &strVec[i][0];
+	}
+	char **argv = &ptrVec[0];
+#endif
+//	std::locale::global(std::locale(""));
+
+	std::string inFileA;
+	std::string outFileA;
+	std::string keyFile;
+	std::string pstr, ph8str, ph16str;
+	cybozu::String16 wpass;
+	std::string secretKeyHex;
+	bool doEncode = false, doDecode = false, doView = false;
+	int encMode = 0;
+	int spinCount = 0;
+	bool putEncryptionInfo = false;
+	bool debug2 = false;
+	bool debug3 = false;
+	bool putSecretKey = false;
+	bool excelProtect = false;
+	bool forceProcessing = false;
+
+	cybozu::Option opt;
+	opt.appendOpt(&pstr, "", "p", "password in only ascii");
+	opt.appendOpt(&encMode, 0, "encMode", "0:use AES128(default), 1: use AES256 for encoding");
+	opt.appendOpt(&ph8str, "", "ph8", "password in utf8 hex. ex. 68656C6C6F for 'hello'");
+	opt.appendOpt(&ph16str, "", "ph16", "password in utf16 hex. ex. u3042u3044u3046 for 'aiu' in hiragana");
+	opt.appendBoolOpt(&excelProtect, "pep", "password for Excel protection (VelvetSweatshop)");
+	opt.appendOpt(&secretKeyHex, "", "k", "(experimental) secret key in hex. ex. 0123456789ABCDEF0123456789ABCDEF");
+	opt.appendOpt(&keyFile, "", "by", "(experimental) extract secret key from this file");
+	opt.appendBoolOpt(&doEncode, "e", "encode");
+	opt.appendBoolOpt(&doDecode, "d", "decode");
+	opt.appendBoolOpt(&forceProcessing, "force", "force processing regardless of detected file type");
+	opt.appendOpt(&spinCount, 100000, "c", "spin count");
+	opt.appendBoolOpt(&putSecretKey, "psk", "print secret key");
+	opt.appendBoolOpt(&putEncryptionInfo, "info", "print EncryptionInfo info");
+	opt.appendBoolOpt(&debug2, "v", "print debug info");
+	opt.appendBoolOpt(&debug3, "vv", "print debug info and save binary data");
+	opt.appendHelp("h");
+	opt.appendParam(&inFileA, "input");
+	opt.appendParamOpt(&outFileA, "", "output");
+
+	if (!opt.parse(argc, argv)) {
+		opt.usage();
+		return 1;
+	}
+	ms::setDebug(debug3 ? 3 : debug2 ? 2 : putEncryptionInfo ? 1 : 0);
+	if (!pstr.empty()) {
+		wpass = cybozu::ToUtf16(pstr);
+	}
+	if (excelProtect) {
+		wpass = cybozu::ToUtf16("VelvetSweatshop");
+	}
+	if (putSecretKey) {
+		ms::putSecretKeyInstance() = true;
+	}
+	if (!ph8str.empty()) {
+		wpass = cybozu::ToUtf16(ms::fromHex(ph8str));
+	}
+	if (!ph16str.empty()) {
+		wpass = fromUniHex(ph16str);
+	}
+	std::string secretKey;
+	if (!secretKeyHex.empty()) {
+		secretKey = ms::fromHex(secretKeyHex, true);
+	}
+	if (!doEncode && !doDecode) {
+		doDecode = true;
+		doView = true;
+	}
+	if (keyFile.empty() && secretKey.empty() && wpass.empty()) {
+		puts("specify -p password");
+		opt.usage();
+	}
+
+	if (outFileA.empty()) {
+		std::string suf;
+		const std::string base = cybozu::GetBaseName(inFileA, &suf);
+		if (denySuffix(suf)) {
+			printf("bad input file [%s]. does not support %s\n", inFileA.c_str(), suf.c_str());
+			return 1;
+		}
+		outFileA = base +(doEncode ? "_e." : "_d.") + suf;
+	}
+	printf("inFile=%s, outFile=%s, mode=%s, encMode=%d\n", inFileA.c_str(), outFileA.c_str(), doEncode ? "enc" : doView ? "view" : "dec", encMode);
+	if (!secretKey.empty()) {
+		printf("set secretKey = "); ms::dump(secretKey, false);
+	}
+	if (!keyFile.empty()) {
+		printf("keyFile = %s\n", keyFile.c_str());
+	}
+	const std::string passData = ms::Char16toChar8(wpass);
+
+#ifdef _MSC_VER
+	std::wstring inFile;
+	std::wstring outFile;
+	cybozu::ConvertUtf8ToUtf16(&inFile, inFileA);
+	cybozu::ConvertUtf8ToUtf16(&outFile, outFileA);
+#else
+	const std::string inFile = inFileA;
+	const std::string outFile = outFileA;
+#endif
+	cybozu::Mmap m(inFile);
+	const char *data = m.get();
+	if (m.size() > 0xffffffff) {
+		throw cybozu::Exception("ms:encode:m.size") << m.size();
+	}
+	const uint32_t dataSize = static_cast<uint32_t>(m.size());
+	ms::Format format;
+	try {
+		format = ms::DetectFormat(data, dataSize);
+	} catch (std::exception& e) {
+		format = ms::fUnknown;
+		if (!forceProcessing) {
+			printf("unknown format %s\n", e.what());
+			return 1;
+		}
+	}
+
+	if (doEncode) {
+		if (!forceProcessing && format == ms::fCfb) {
+			printf("already encrypted\n");
+			return 2;
+		}
+		bool isOffice2013 = encMode == 1;
+		ms::encode(data, dataSize, outFile, passData, isOffice2013, secretKey, spinCount);
+	} else {
+		if (!forceProcessing && format == ms::fZip) {
+			printf("already decrypted\n");
+			return 2;
+		}
+		if (!keyFile.empty()) {
+			secretKey = ms::getSecretKey(keyFile, passData);
+			printf("get secretKey = "); ms::dump(secretKey, false);
+		}
+		bool ok = ms::decode(data, dataSize, outFile, passData, secretKey, doView);
+		if (!ok) {
+			printf("bad password\n");
+			return 3;
+		}
+	}
+} catch (std::exception& e) {
+	printf("exception:%s\n", e.what());
+	return 1;
+}