ooxml_crypt 0.1.0

data/vendor/msoffice/include/encode.hpp

@@ -0,0 +1,221 @@
+#pragma once
+/**
+	@file
+	@brief MS Office encryption encoder
+	Copyright (C) 2012 Cybozu Labs, Inc., all rights reserved.
+*/
+#include <cybozu/crypto.hpp>
+#include <cybozu/mmap.hpp>
+#include <cybozu/random_generator.hpp>
+#include "crypto_util.hpp"
+#include "cfb.hpp"
+#include "make_dataspace.hpp"
+#include "resource.hpp"
+
+//#define SAME_KEY
+
+namespace ms {
+
+inline cybozu::RandomGenerator& GetRandGen()
+{
+	static cybozu::RandomGenerator rg;
+	return rg;
+}
+
+inline void FillRand(std::string& str, size_t n)
+{
+	str.resize(n);
+	GetRandGen().read(&str[0], static_cast<int>(n));
+}
+
+#if 0
+inline void VerifyFormat(const char *data, uint32_t dataSize)
+{
+	if (dataSize < 2) throw cybozu::Exception("ms:VerifyFormat:too small") << dataSize;
+	if (memcmp(data, "PK", 2) != 0) throw cybozu::Exception("ms:VerifyFormat:bad format");
+}
+#endif
+
+/*
+	encryptedPackage = [uint64_t:encData]
+*/
+inline void MakeEncryptedPackage(std::string& encryptedPackage, const std::string& encData)
+{
+	encryptedPackage.reserve(encData.size() + 8);
+	encryptedPackage.resize(8);
+	cybozu::Set64bitAsLE(&encryptedPackage[0], encData.size());
+	encryptedPackage += encData;
+}
+
+/*
+	[MS-OFFCRYPTO] 2.3.4.14
+*/
+inline void GenerateIntegrityParameter(
+	std::string& encryptedHmacKey,
+	std::string& encryptedHmacValue,
+	const std::string& encryptedPackage,
+	const CipherParam& keyData,
+	const std::string& secretKey,
+	const std::string& saltValue)
+{
+	std::string salt;
+	FillRand(salt, keyData.hashSize);
+#ifdef SAME_KEY
+	salt = fromHex("C9FACA5436849906B600DE95E155B47A01ABEDD0");
+#endif
+	const std::string iv1 = generateIv(keyData, ms::blkKey_dataIntegrity1, saltValue);
+	const std::string iv2 = generateIv(keyData, ms::blkKey_dataIntegrity2, saltValue);
+	encryptedHmacKey = cipher(keyData.cipherName, salt, secretKey, iv1, cybozu::crypto::Cipher::Encoding);
+	cybozu::crypto::Hmac hmac(keyData.hashName);
+	std::string ret = hmac.eval(salt, encryptedPackage);
+	encryptedHmacValue = cipher(keyData.cipherName, ret, secretKey, iv2, cybozu::crypto::Cipher::Encoding);
+}
+
+inline void EncContent(std::string& encryptedPackage, const std::string& org, const CipherParam& param, const std::string& key, const std::string& salt)
+{
+	uint64_t orgSize = org.size();
+	const size_t blockSize = 4096;
+	std::string data = org;
+	data.resize(RoundUp(data.size(), size_t(16)));
+#ifdef SAME_KEY
+	data[data.size() - 2] = 0x4b; // QQQ remove this
+	data[data.size() - 1] = 0x6a;
+#endif
+	encryptedPackage.reserve(data.size() + 8);
+	encryptedPackage.resize(8);
+	cybozu::Set64bitAsLE(&encryptedPackage[0], orgSize);
+
+	const size_t n = (data.size() + blockSize - 1) / blockSize;
+	for (size_t i = 0; i < n; i++) {
+		const size_t len = (i < n - 1) ? blockSize : (data.size() - blockSize * i);
+		std::string blockKey(4, 0);
+		cybozu::Set32bitAsLE(&blockKey[0], static_cast<uint32_t>(i));
+		const std::string iv = generateKey(param, salt, blockKey);
+		encryptedPackage.append(cipher(param.cipherName, data.c_str() + i * blockSize, len, key, iv, cybozu::crypto::Cipher::Encoding));
+	}
+}
+
+/*
+����̋t���ňÍ���
+fix parameter : c1(blkKey_VerifierHashInput)
+                c2(blkKey_encryptedVerifierHashValue)
+                c3(blkKey_encryptedKeyValue)
+
+input : pass, spinCount
+output: iv,
+        verifierHashInput,
+        encryptedVerifierHashValue,
+        encryptedKeyValue
+
+iv(encryptedKey.saltValue)�������_������
+
+pwHash = hashPassword(iv, pass, spinCount)
+skey1 = generateKey(pwHash, c1)
+skey2 = generateKey(pwHash, c2)
+
+verifierHashInput�������_������
+encryptedVerifierHashInput = Enc(verifierHashInput, skey1, iv)
+hashedVerifier = H(verifierHashInput)
+
+encryptedVerifierHashValue = Enc(verifierHash, skey2, iv)
+
+skey3 = generateKey(pwHash, c3)
+secretKey�������_������
+encryptedKeyValue = Enc(secretKey, skey3, iv)
+*/
+
+/*
+	encode data by pass with cipherName, hashName, spinCount
+	output encData and info
+*/
+
+inline bool encode_in(
+	std::string& encryptedPackage,
+	EncryptionInfo& info,
+	const std::string& data,
+	cybozu::crypto::Cipher::Name cipherName,
+	cybozu::crypto::Hash::Name hashName,
+	int spinCount,
+	const std::string& pass,
+	const std::string& masterKey)
+{
+	if (spinCount > 10000000) throw cybozu::Exception("ms:encode_in:too large spinCount") << spinCount;
+	CipherParam& keyData = info.keyData;
+	CipherParam& encryptedKey = info.encryptedKey;
+
+	keyData.setByName(cipherName, hashName);
+	encryptedKey.setByName(cipherName, hashName);
+	info.spinCount = spinCount;
+
+	std::string& iv = encryptedKey.saltValue;
+	FillRand(iv, encryptedKey.saltSize);
+#ifdef SAME_KEY
+	puts("QQQ defined SAME_KEY QQQ");
+	iv = fromHex("F4994F9B2DCD5E0E84BC6386D4523D2C");
+#endif
+	const std::string pwHash = hashPassword(encryptedKey.hashName, iv, pass, spinCount);
+
+	const std::string skey1 = generateKey(encryptedKey, pwHash, blkKey_VerifierHashInput);
+	const std::string skey2 = generateKey(encryptedKey, pwHash, blkKey_encryptedVerifierHashValue);
+	const std::string skey3 = generateKey(encryptedKey, pwHash, blkKey_encryptedKeyValue);
+
+	std::string verifierHashInput;
+	FillRand(verifierHashInput, encryptedKey.saltSize);
+#ifdef SAME_KEY
+	verifierHashInput = fromHex("FEDAECD950F9E82C47CADA29B7837C6D");
+#endif
+
+	verifierHashInput.resize(RoundUp(verifierHashInput.size(), encryptedKey.blockSize));
+
+	info.encryptedVerifierHashInput = cipher(encryptedKey.cipherName, verifierHashInput, skey1, iv, cybozu::crypto::Cipher::Encoding);
+	std::string hashedVerifier = cybozu::crypto::Hash::digest(encryptedKey.hashName, verifierHashInput);
+	hashedVerifier.resize(RoundUp(hashedVerifier.size(), encryptedKey.blockSize));
+
+	info.encryptedVerifierHashValue = cipher(encryptedKey.cipherName, hashedVerifier, skey2, iv, cybozu::crypto::Cipher::Encoding);
+
+	std::string secretKey;
+	FillRand(secretKey, encryptedKey.saltSize);
+#ifdef SAME_KEY
+	secretKey = fromHex("BF44FBB51BE1E88BF130156E117E7900");
+#endif
+	if (!masterKey.empty()) {
+		secretKey = masterKey;
+	}
+	normalizeKey(secretKey, encryptedKey.keyBits / 8);
+
+	info.encryptedKeyValue = cipher(encryptedKey.cipherName, secretKey, skey3, iv, cybozu::crypto::Cipher::Encoding);
+
+	FillRand(keyData.saltValue, keyData.saltSize);
+#ifdef SAME_KEY
+	keyData.saltValue = fromHex("C49AAAEE99004C6B017EE5CD11B86729");
+#endif
+
+	EncContent(encryptedPackage, data, encryptedKey, secretKey, keyData.saltValue);
+
+	GenerateIntegrityParameter(info.encryptedHmacKey, info.encryptedHmacValue, encryptedPackage, keyData, secretKey, keyData.saltValue);
+	return true;
+}
+
+template<class String>
+bool encode(const char *data, uint32_t dataSize, const String& outFile, const std::string& pass, bool isOffice2013, const std::string& masterKey, int spinCount)
+{
+	std::string encryptedPackage;
+	ms::EncryptionInfo info;
+	const cybozu::crypto::Cipher::Name cipherName = isOffice2013 ? cybozu::crypto::Cipher::N_AES256_CBC : cybozu::crypto::Cipher::N_AES128_CBC;
+	const cybozu::crypto::Hash::Name hashName = isOffice2013 ? cybozu::crypto::Hash::N_SHA512 : cybozu::crypto::Hash::N_SHA1;
+	encode_in(encryptedPackage, info, std::string(data, dataSize), cipherName, hashName, spinCount, pass, masterKey);
+	const std::string encryptionInfoStr = info.addHeader(info.toXml(isOffice2013));
+	dprintf("encryptionInfoStr size=%d\n", (int)encryptionInfoStr.size());
+	ms::cfb::CompoundFile cfb;
+	ms::makeDataSpace(cfb.dirs, encryptedPackage, encryptionInfoStr);
+	std::string outData;
+	makeLayout(outData, cfb);
+	{
+		cybozu::File out;
+		out.openW(outFile);
+		out.write(outData.c_str(), outData.size());
+	}
+	return true;
+}
+
+} // ms

data/vendor/msoffice/include/make_dataspace.hpp

@@ -0,0 +1,316 @@
+#pragma once
+/**
+	Copyright (C) 2012 Cybozu Labs, Inc., all rights reserved.
+*/
+
+#include <cybozu/time.hpp>
+#include "cfb.hpp"
+#include "resource.hpp"
+
+namespace ms {
+
+enum DSposition {
+	iRoot = 0,
+	iEncryptionPackage, // 1
+	iDataSpaces, // 2
+	iVersion, // 3
+	iDataSpaceMap, // 4
+	iDataSpaceInfo, // 5
+	iStongEncryptionDataSpace, // 6
+	iTransformInfo, // 7
+	iStrongEncryptionTransform, // 8
+	iPrimary, // 9
+	iEncryptionInfo, // 10
+	dirNum
+};
+
+/*
+	make Data Spaces
+*/
+inline void makeDataSpace(
+	cfb::DirectoryEntryVec& dirs,
+	const std::string& encryptedPackage,
+	const std::string& encryptionInfoXml)
+{
+	using namespace cfb;
+	cybozu::Time curTime;
+	curTime.setCurrentTime();
+	DirectoryEntry::FileTime fileTime;
+	curTime.getFILETIME(fileTime.dwLowDateTime, fileTime.dwHighDateTime);
+
+	/*
+
+0:Root/ 1:EncryptionPackage(F)
+      /10:EncryptionInfo(F)
+      / 2:DataSpaces/3:Version(F)
+                    /4:DataSpaceMap(F)
+                    /5:DataSpaceInfo/6:StrongEncryptionDataSpace(F)
+                    /7:Transformation/8:StrongEncryptionTransform/9:Primary(F)
+
+  <10:B>
+   �^�_
+<2:R> <1:R>
+---------------
+  <4:B>
+   �^�_
+<3:B>  <5:B>
+         �_
+          <7:R>
+---------------
+<6:B>
+---------------
+<8:B>
+---------------
+<9:B>
+
+	*/
+
+	const struct Info {
+		const char *name;
+		ObjectType objectType;
+		ColorFlag colorFlag;
+		uint32_t leftSiblingId;
+		uint32_t rightSiblingId;
+		uint32_t childId;
+		std::string content;
+	} infoTbl[] = {
+		{ "Root Entry",                RootStorageObject, Red,   NOSTREAM, NOSTREAM, iEncryptionInfo, "" },
+		{ "EncryptedPackage",          StreamObject,      Red,   NOSTREAM, NOSTREAM, NOSTREAM, encryptedPackage },
+		{ "\x06""DataSpaces",          StorageObject,     Red,   NOSTREAM, NOSTREAM, iDataSpaceMap, "" },
+		{ "Version",                   StreamObject,      Black, NOSTREAM, NOSTREAM, NOSTREAM, resource::Version },
+		{ "DataSpaceMap",              StreamObject,      Black, iVersion, iDataSpaceInfo, NOSTREAM, resource::DataSpaceMap },
+		{ "DataSpaceInfo",             StorageObject,     Black, NOSTREAM, iTransformInfo, iStongEncryptionDataSpace, "" },
+		{ "StrongEncryptionDataSpace", StreamObject,      Black, NOSTREAM, NOSTREAM, NOSTREAM, resource::StrongEncryptionDataSpace },
+		{ "TransformInfo",             StorageObject,     Red,   NOSTREAM, NOSTREAM, iStrongEncryptionTransform, "" },
+		{ "StrongEncryptionTransform", StorageObject,     Black, NOSTREAM, NOSTREAM, iPrimary, "" },
+		{ "\x06""Primary",             StreamObject,      Black, NOSTREAM, NOSTREAM, NOSTREAM, resource::Primary },
+		{ "EncryptionInfo",            StreamObject,      Black, iDataSpaces, iEncryptionPackage, NOSTREAM, encryptionInfoXml },
+	};
+	dirs.resize(dirNum);
+	const std::string clsid = "";
+	const uint32_t stateBits = 0;
+	for (size_t i = 0; i < dirs.size(); i++) {
+		uint32_t startingSectorLocation = 0;
+		const Info& info = infoTbl[i];
+		dirs[i].set(
+			cybozu::ToUtf16(info.name),
+			info.objectType,
+			info.colorFlag,
+			info.leftSiblingId,
+			info.rightSiblingId,
+			info.childId,
+			clsid,
+			stateBits,
+			fileTime,
+			fileTime,
+			startingSectorLocation,
+			info.content);
+	}
+}
+
+inline void makeDifat(char *data, uint32_t difatPos, uint32_t difatSectorNum, uint32_t fatSectorNum, uint32_t sectorSize)
+{
+	uint32_t v = ms::cfb::Header::firstNumDIFAT + difatSectorNum;
+	for (uint32_t i = 0; i < difatSectorNum; i++) {
+dprintf("\ndifatSectorNum i=%d\n", i);
+		char *p = data + 512 + (difatPos + i) * sectorSize;
+		for (uint32_t j = 0; j < sectorSize / 4 - 1; j++) {
+			cybozu::Set32bitAsLE(p + j * 4, v);
+			v++;
+dprintf("%d ", v);
+			if (v > difatSectorNum + fatSectorNum) {
+				for (; j < sectorSize / 4 - 1; j++) {
+					cybozu::Set32bitAsLE(p + j * 4, ms::cfb::FREESECT);
+				}
+dprintf("endof\n");
+				cybozu::Set32bitAsLE(p + sectorSize - 4, ms::cfb::ENDOFCHAIN);
+				return;
+			}
+		}
+dprintf("next %d\n", difatPos + i + 1);
+		cybozu::Set32bitAsLE(p + sectorSize - 4, difatPos + i + 1);
+	}
+}
+
+inline void makeFat(char *data, const char *dataEnd, const cfb::UintVec& entry)
+{
+	uint32_t v = 0;
+	for (size_t i = 0; i < entry.size(); i++) {
+		const uint32_t n = entry[i];
+		if (n <= cfb::MAXREGSECT) {
+			for (uint32_t j = 1; j < n; j++) {
+				v++;
+				if (data == dataEnd) throw cybozu::Exception("ms:makeFat:err1") << v << i << j;
+				cybozu::Set32bitAsLE(data, v);
+				data += 4;
+			}
+			if (data == dataEnd) throw cybozu::Exception("ms:makeFat:err2") << v << i;
+			cybozu::Set32bitAsLE(data, cfb::ENDOFCHAIN);
+		} else {
+			cybozu::Set32bitAsLE(data, n);
+		}
+		data += 4;
+		v++;
+	}
+	while (data != dataEnd) {
+		cybozu::Set32bitAsLE(data, cfb::FREESECT);
+		data += 4;
+	}
+}
+
+inline void detectSectorNum(uint32_t& difatSectorNum, uint32_t& fatSectorNum, uint32_t n, uint32_t sectorSize)
+{
+	const uint32_t numInFat = sectorSize / 4;
+	difatSectorNum = 0;
+	fatSectorNum = 0;
+	int count = 0;
+	for (;;) {
+		uint32_t a = getBlockNum(difatSectorNum + fatSectorNum + n + 0, numInFat);
+		uint32_t b = (a <= cfb::Header::firstNumDIFAT) ? 0 : getBlockNum(a - cfb::Header::firstNumDIFAT, numInFat - 1);
+		if (b == difatSectorNum && a == fatSectorNum) return;
+		difatSectorNum = b;
+		fatSectorNum = a;
+		count++;
+		if (count == 10) cybozu::Exception("ms:detectSectorNum:max loop") << difatSectorNum << fatSectorNum << n;
+	}
+}
+
+template<class T>
+uint32_t getMiniFatSectorNum(T size)
+{
+	return getBlockNum(static_cast<uint32_t>(size), 64u);
+}
+/*
+	@note DIFAT is empty for current version
+
+	|Header|DIFAT0|DIFAT1|...|FAT0|FAT1|...|miniFAT|dir0|dir1|dir2|min0|min1|min2|min3|enc0|enc1|...
+
+	FAT
+	1       ; miniFAT
+	2 3 4   ; directoryEntry([d0:d1:d2])
+	5 6 7 8 ; miniFATdata([m0:m1:m2:m3])
+	9 10... ; encryptedPackage([c0:c1:...])
+
+	miniFAT(64byte x 8 x 4)
+	0 1 ; Version
+	2 3 ; DataSpaceMap
+	4
+	5 6 7 8
+	9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
+*/
+inline void makeLayout(std::string& data, cfb::CompoundFile& cfb)
+{
+	cfb::Header& header = cfb.header;
+	cfb::DirectoryEntryVec& dirs = cfb.dirs;
+	const uint32_t sectorSize = header.sectorSize;
+
+	// miniFAT
+	const uint32_t numMiniFatSectors = 1;
+	cfb::UintVec miniFatSectorNumVec;
+	uint32_t miniFatNum; // num of mini fat sector
+	uint32_t miniFatDataSectorNum; // sector num for mini fat data
+	{
+		// streamObject
+		const int tbl[] = {
+			iVersion, iDataSpaceMap, iStongEncryptionDataSpace, iPrimary, iEncryptionInfo
+		};
+		uint32_t pos = 0;
+		for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+			uint32_t n = getMiniFatSectorNum(dirs[tbl[i]].streamSize);
+			miniFatSectorNumVec.push_back(n);
+			dirs[tbl[i]].startingSectorLocation = pos;
+			pos += n;
+		}
+		miniFatNum = pos;
+		dprintf("miniFatNum=%d\n", miniFatNum);
+		miniFatDataSectorNum = getBlockNum(miniFatNum, (sectorSize / 64));
+		dprintf("miniFatDataSectorNum=%d\n", miniFatDataSectorNum);
+		if (getBlockNum(miniFatDataSectorNum, 128u) > numMiniFatSectors) throw cybozu::Exception("ms:makeLayout:large miniFatDataSectorNum") << miniFatDataSectorNum;
+	}
+
+	const uint32_t directoryEntrySectorNum = getBlockNum(static_cast<uint32_t>(cfb.dirs.size()), 4u);
+	const uint32_t encryptionPackageSectorNum = getBlockNum(static_cast<uint32_t>(dirs[iEncryptionPackage].streamSize), sectorSize);
+	const uint32_t contentSectorNum = numMiniFatSectors + directoryEntrySectorNum + miniFatDataSectorNum + encryptionPackageSectorNum;
+dprintf("encryptionPackageSectorNum=%u\n", encryptionPackageSectorNum);
+dprintf("contentSectorNum=%u\n", contentSectorNum);
+
+	uint32_t fatSectorNum;
+	uint32_t difatSectorNum;
+
+	detectSectorNum(difatSectorNum, fatSectorNum, contentSectorNum, sectorSize);
+dprintf("fatSectorNum=%u\n", fatSectorNum);
+dprintf("difatSectorNum=%u\n", difatSectorNum);
+
+	const uint32_t difatPos = 0;
+	const uint32_t fatPos = difatPos + difatSectorNum;
+	const uint32_t miniFatPos = fatPos + fatSectorNum;
+	const uint32_t directoryEntryPos = miniFatPos + numMiniFatSectors;
+	const uint32_t miniFatDataPos = directoryEntryPos + directoryEntrySectorNum;
+	const uint32_t encryptionPackagePos = miniFatDataPos + miniFatDataSectorNum;
+
+	header.firstDirectorySectorLocation = directoryEntryPos;
+	header.firstMiniFatSectorLocation = miniFatPos;
+	header.numMiniFatSectors = numMiniFatSectors;
+
+	// FAT
+	dirs[iRoot].startingSectorLocation = miniFatDataPos;
+	dirs[iRoot].streamSize = 64 * miniFatNum;
+	dirs[iEncryptionPackage].startingSectorLocation = encryptionPackagePos;
+
+	const uint32_t allSectorNum = difatSectorNum + fatSectorNum + contentSectorNum;
+	dprintf("allSectorNum=%u\n", allSectorNum);
+	data.resize(512 + allSectorNum * sectorSize);
+
+	for (uint32_t i = 0; i < std::min<uint32_t>(fatSectorNum, cfb::Header::firstNumDIFAT); i++) {
+		header.difat.push_back(fatPos + i);
+	}
+	header.numFatSectors = fatSectorNum;
+	header.numDifatSectors = difatSectorNum;
+	if (difatSectorNum > 0) {
+		header.firstDifatSectorLocation = difatPos;
+	}
+	header.write(&data[0]);
+
+	// make DIFAT
+	if (difatSectorNum > 0) {
+		makeDifat(&data[0], difatPos, difatSectorNum, fatSectorNum, sectorSize);
+	}
+
+	// make FAT
+	{
+		cfb::UintVec v;
+		for (uint32_t i = 0; i < difatSectorNum; i++) {
+			v.push_back(cfb::DIFSECT);
+		}
+		for (uint32_t i = 0; i < fatSectorNum; i++) {
+			v.push_back(cfb::FATSECT);
+		}
+		v.push_back(numMiniFatSectors);
+		v.push_back(directoryEntrySectorNum);
+		v.push_back(miniFatDataSectorNum);
+		v.push_back(encryptionPackageSectorNum);
+		char *p = &data[512 + fatPos * sectorSize];
+		makeFat(p, p + fatSectorNum * sectorSize, v);
+	}
+	// make mini FAT
+	{
+		char *p = &data[512 + miniFatPos * sectorSize];
+		makeFat(p, p + numMiniFatSectors * sectorSize, miniFatSectorNumVec);
+	}
+	for (size_t i = 0; i < dirs.size(); i++) {
+		dirs[i].write(&data[512 + directoryEntryPos * sectorSize + i * 128]);
+	}
+	for (size_t i = 0; i < dirs.size(); i++) {
+		const cfb::DirectoryEntry& dir = dirs[i];
+		const size_t size = dir.content.size();
+		if (size == 0) continue;
+		if (size <= 4096) {
+			memcpy(&data[512 + miniFatDataPos * sectorSize + dir.startingSectorLocation * 64], dir.content.c_str(), size);
+		} else {
+			memcpy(&data[512 + dir.startingSectorLocation * sectorSize], dir.content.c_str(), size);
+		}
+	}
+	dprintf("data.size=%d\n", (int)data.size());
+}
+
+} // ms

data/vendor/msoffice/include/msoc.h

@@ -0,0 +1,129 @@
+#pragma once
+#include <stdlib.h>
+/**
+	@file
+	@brief MS Office Crypt tool dll
+	@author herumi
+	Copyright (C) 2016 Cybozu Labs, Inc., all rights reserved.
+*/
+
+#ifdef _MSC_VER
+	#ifndef MSOC_DONT_AUTO_LINK
+		#pragma comment(lib, "msoc.lib")
+	#endif
+	#ifdef _WIN64
+		#define MSOC_DLL_EXPORT
+	#else
+		#define MSOC_DLL_EXPORT __stdcall
+	#endif
+#else
+	#define MSOC_DLL_EXPORT
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MSOC_NOERR 0
+#define MSOC_ERR_NOT_SUPPORT (-1)
+#define MSOC_ERR_ALREADY_ENCRYPTED (-2)
+#define MSOC_ERR_ALREADY_DECRYPTED (-3)
+#define MSOC_ERR_BAD_PASSWORD (-4)
+#define MSOC_ERR_BAD_PARAMETER (-5)
+#define MSOC_ERR_SMALL_MAX_SIZE (-6)
+#define MSOC_ERR_NO_MEMORY (-7)
+#define MSOC_ERR_EXCEPTION (-8)
+#define MSOC_ERR_TOO_LARGE_FILE (-9)
+#define MSOC_ERR_INFILE_IS_EMPTY (-10)
+#define MSOC_ERR_OUTFILE_IS_EMPTY (-11)
+#define MSOC_ERR_PASS_IS_EMPTY (-12)
+
+const char * MSOC_DLL_EXPORT MSOC_getErrMessage(int err);
+
+typedef struct msoc_opt msoc_opt;
+
+#ifdef _MSC_VER
+/*
+	encrypt inFile and make outFile with pass(UTF-16 version)
+	@param outFile [in] encrypted MS Office file
+	@param inFile [in] plain MS Office file
+	@param pass [in] password
+	@param opt [inout] option (NULL is permitted)
+	use spinCount, secretKey of opt if set
+*/
+int MSOC_DLL_EXPORT MSOC_encrypt(const wchar_t *outFile, const wchar_t *inFile, const wchar_t *pass, const msoc_opt *opt);
+/*
+	decrypt inFile and make outFile with pass(UTF-16 version)
+	@param outFile [in] plain MS Office file (NULL is permitted)
+	@param inFile [in] encrypted MS Office file
+	@param pass [in] password (NULL is permitted)
+	@param opt [inout] option (NULL is permitted)
+
+	secretKey of opt is used if pass is NULL
+	opt is set by the value of inFile if opt is not NULL
+*/
+int MSOC_DLL_EXPORT MSOC_decrypt(const wchar_t *outFile, const wchar_t *inFile, const wchar_t *pass, msoc_opt *opt);
+#endif
+/*
+	encrypt inFile and make outFile with pass(ASCII version : not UTF-8)
+	@param outFile [in] encrypted MS Office file
+	@param inFile [in] plain MS Office file
+	@param pass [in] password
+	@param opt [inout] option (NULL is permitted)
+	use spinCount, secretKey of opt if set
+*/
+int MSOC_DLL_EXPORT MSOC_encryptA(const char *outFile, const char *inFile, const char *pass, const msoc_opt *opt);
+/*
+	decrypt inFile and make outFile with pass(ASCII version : not UTF-8)
+	@param outFile [in] plain MS Office file (NULL is permitted)
+	@param inFile [in] encrypted MS Office file
+	@param pass [in] password (NULL is permitted)
+	@param opt [inout] option (NULL is permitted)
+
+	secretKey of opt is used if pass is NULL
+	opt is set by the value of inFile if opt is not NULL
+*/
+int MSOC_DLL_EXPORT MSOC_decryptA(const char *outFile, const char *inFile, const char *pass, msoc_opt *opt);
+
+/*
+	optType of msoc_opt
+*/
+#define MSOC_OPT_TYPE_SPIN_COUNT 1 // spinCount(int)
+#define MSOC_OPT_TYPE_SECRET_KEY 2 // secretKey(hex ascii string) (eg. 0123ab)
+
+/*
+	create default msoc_opt
+	spinCount = 100000
+	secretKey = "" (auto generated)
+	return pointer to msoc_opt
+	err if NULL
+*/
+msoc_opt * MSOC_DLL_EXPORT MSOC_createOpt(void);
+/*
+	destroy msoc_opt
+*/
+void MSOC_DLL_EXPORT MSOC_destroyOpt(msoc_opt *msoc);
+
+/*
+	get int value of optType of opt);
+	@param value [out] return value
+*/
+int MSOC_DLL_EXPORT MSOC_getInt(int *value, const msoc_opt *opt, int optType);
+/*
+	set int value of optType of opt
+*/
+int MSOC_DLL_EXPORT MSOC_setInt(msoc_opt *opt, int optType, int value);
+/*
+	get string value of optType of opt
+	@param str [out] return value
+	@param maxSize [in] buffer size of str including '\0'
+*/
+int MSOC_DLL_EXPORT MSOC_getStr(char *str, size_t maxSize, const msoc_opt *opt, int optType);
+/*
+	set string value of optType of opt
+*/
+int MSOC_DLL_EXPORT MSOC_setStr(msoc_opt *opt, int optType, const char *str);
+
+#ifdef __cplusplus
+}
+#endif

data/vendor/msoffice/include/resource.hpp

@@ -0,0 +1,7 @@
+#pragma once
+namespace ms { namespace resource {
+const std::string Version("\x3c\x00\x00\x00\x4d\x00\x69\x00\x63\x00\x72\x00\x6f\x00\x73\x00\x6f\x00\x66\x00\x74\x00\x2e\x00\x43\x00\x6f\x00\x6e\x00\x74\x00\x61\x00\x69\x00\x6e\x00\x65\x00\x72\x00\x2e\x00\x44\x00\x61\x00\x74\x00\x61\x00\x53\x00\x70\x00\x61\x00\x63\x00\x65\x00\x73\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00", 76);
+const std::string Primary("\x58\x00\x00\x00\x01\x00\x00\x00\x4c\x00\x00\x00\x7b\x00\x46\x00\x46\x00\x39\x00\x41\x00\x33\x00\x46\x00\x30\x00\x33\x00\x2d\x00\x35\x00\x36\x00\x45\x00\x46\x00\x2d\x00\x34\x00\x36\x00\x31\x00\x33\x00\x2d\x00\x42\x00\x44\x00\x44\x00\x35\x00\x2d\x00\x35\x00\x41\x00\x34\x00\x31\x00\x43\x00\x31\x00\x44\x00\x30\x00\x37\x00\x32\x00\x34\x00\x36\x00\x7d\x00\x4e\x00\x00\x00\x4d\x00\x69\x00\x63\x00\x72\x00\x6f\x00\x73\x00\x6f\x00\x66\x00\x74\x00\x2e\x00\x43\x00\x6f\x00\x6e\x00\x74\x00\x61\x00\x69\x00\x6e\x00\x65\x00\x72\x00\x2e\x00\x45\x00\x6e\x00\x63\x00\x72\x00\x79\x00\x70\x00\x74\x00\x69\x00\x6f\x00\x6e\x00\x54\x00\x72\x00\x61\x00\x6e\x00\x73\x00\x66\x00\x6f\x00\x72\x00\x6d\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00", 200);
+const std::string DataSpaceMap("\x08\x00\x00\x00\x01\x00\x00\x00\x68\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x45\x00\x6e\x00\x63\x00\x72\x00\x79\x00\x70\x00\x74\x00\x65\x00\x64\x00\x50\x00\x61\x00\x63\x00\x6b\x00\x61\x00\x67\x00\x65\x00\x32\x00\x00\x00\x53\x00\x74\x00\x72\x00\x6f\x00\x6e\x00\x67\x00\x45\x00\x6e\x00\x63\x00\x72\x00\x79\x00\x70\x00\x74\x00\x69\x00\x6f\x00\x6e\x00\x44\x00\x61\x00\x74\x00\x61\x00\x53\x00\x70\x00\x61\x00\x63\x00\x65\x00\x00\x00", 112);
+const std::string StrongEncryptionDataSpace("\x08\x00\x00\x00\x01\x00\x00\x00\x32\x00\x00\x00\x53\x00\x74\x00\x72\x00\x6f\x00\x6e\x00\x67\x00\x45\x00\x6e\x00\x63\x00\x72\x00\x79\x00\x70\x00\x74\x00\x69\x00\x6f\x00\x6e\x00\x54\x00\x72\x00\x61\x00\x6e\x00\x73\x00\x66\x00\x6f\x00\x72\x00\x6d\x00\x00\x00", 64);
+} } // ms::resource