ooxml_crypt 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7f876fbdff234101de69ca5a2b35cee3d12ad7cfb974548648f8e3d5abb7670
-  data.tar.gz: 8db6f0212c4d93a32c84ecb9fb7337c7d94eab425381fb3b3c88cfc8b2bd7ce3
+  metadata.gz: '05192ad6823ce18fed6b0d5a177559c55e8279843f7535d4120e2ea2172d1873'
+  data.tar.gz: f32d9322fa1253d8323329d209cece850c29e6c729ed620dee63c833fd5aadf5
 SHA512:
-  metadata.gz: 0bc0fa7f78518b6d82a5a82725793475dcadc5d819fed25ae8c26c69e4b19dc4022ed7e73b7c7f41c5f0818d5d8892eb969f1bc77593f82354b98ca1f7fa1999
-  data.tar.gz: 9c6fb88936d15fbdf3a33b79604802a141be4f3f3c0c5bd643cd5794f9976ac29b140c37384cf075ccd22acf3eb8853c160f319d323384e3acdcff4703c7a33e
+  metadata.gz: 44bb1e1ef6792309bec5043f88a0785ae5a0810d63ef6e457d296f3d153d185cf3724c534bc94536848c4d567c0f6b87a4c7e683181440a04ca842a5fe146195
+  data.tar.gz: 73996d66386a8ff1d14a4c7322bab4fc30c6ff8ecfe7f877e0a2fddacb2606ad3a00668bdea15beb9f75d9770c9b6fa8516dd3316605ba553cb578a4499f135d

data/lib/ooxml_crypt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OoxmlCrypt
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/ooxml_crypt.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.extensions = ["ext/ooxml_crypt/extconf.rb"]
 
-  spec.add_development_dependency "bundler", "~> 2.2"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rake-compiler", "~> 1.1"
 

data/vendor/cybozulib/include/cybozu/benchmark.hpp

@@ -11,11 +11,15 @@
 #endif
 #include <stdio.h>
 
+//#define CYBOZU_BENCH_CHRONO
+
 #ifdef __EMSCRIPTEN__
 	#define CYBOZU_BENCH_USE_GETTIMEOFDAY
 #endif
 
-#ifdef CYBOZU_BENCH_USE_GETTIMEOFDAY
+#ifdef CYBOZU_BENCH_CHRONO
+#include <chrono>
+#elif defined(CYBOZU_BENCH_USE_GETTIMEOFDAY)
 	#include <sys/time.h>
 #elif !defined(CYBOZU_BENCH_DONT_USE_RDTSC)
 	#if defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || defined(__x86_64__)
@@ -59,10 +63,17 @@ static inline void setPutCallback(void (*f)(double))
 } // cybozu::bench
 
 class CpuClock {
+#ifdef CYBOZU_BENCH_CHRONO
+	typedef std::chrono::high_resolution_clock::time_point Time;
+#else
+	typedef uint64_t Time;
+#endif
 public:
-	static inline uint64_t getCpuClk()
+	static inline Time getCpuClk()
 	{
-#ifdef CYBOZU_BENCH_USE_RDTSC
+#ifdef CYBOZU_BENCH_CHRONO
+		return std::chrono::high_resolution_clock::now();
+#elif defined(CYBOZU_BENCH_USE_RDTSC)
 #ifdef _MSC_VER
 		return __rdtsc();
 #else
@@ -93,17 +104,25 @@ public:
 #endif
 	}
 	CpuClock()
-		: clock_(0)
+		: begin_()
+		, end_()
+		, clock_(0)
 		, count_(0)
 	{
 	}
 	void begin()
 	{
-		clock_ -= getCpuClk();
+		begin_ = getCpuClk();
 	}
 	void end()
 	{
-		clock_ += getCpuClk();
+		end_ = getCpuClk();
+#ifdef CYBOZU_BENCH_CHRONO
+		clock_ += std::chrono::duration_cast<std::chrono::nanoseconds>(end_ - begin_).count();
+#else
+		clock_ += end_ - begin_;
+#endif
+		begin_ = end_;
 		count_++;
 	}
 	int getCount() const { return count_; }
@@ -147,6 +166,8 @@ public:
 	static const uint64_t maxClk = (uint64_t)1e8;
 #endif
 private:
+	Time begin_;
+	Time end_;
 	uint64_t clock_;
 	int count_;
 };

data/vendor/cybozulib/include/cybozu/crypto.hpp

@@ -16,16 +16,23 @@
 #ifdef __APPLE__
 	#pragma GCC diagnostic push
 	#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+	#ifndef CYBOZU_USE_COMMONCRYPTO
+		#define CYBOZU_USE_COMMONCRYPTO 1
+	#endif
 #endif
-#if 0 //#ifdef __APPLE__
+#if CYBOZU_USE_COMMONCRYPTO == 1
+	// for OpenSSL compatibility
 	#define COMMON_DIGEST_FOR_OPENSSL
 	#include <CommonCrypto/CommonDigest.h>
 	#include <CommonCrypto/CommonHMAC.h>
+	#include <CommonCrypto/CommonCryptor.h>
 	#define SHA1 CC_SHA1
 	#define SHA224 CC_SHA224
 	#define SHA256 CC_SHA256
 	#define SHA384 CC_SHA384
 	#define SHA512 CC_SHA512
+	#undef CYBOZU_USE_OPENSSL_NEW_HASH
+	#define CYBOZU_USE_OPENSSL_NEW_HASH 0
 #else
 #include <openssl/hmac.h>
 #include <openssl/evp.h>
@@ -239,22 +246,55 @@ public:
 };
 
 class Hmac {
+#if CYBOZU_USE_COMMONCRYPTO == 1
+	CCHmacAlgorithm alg_;
+	size_t hashSize_;
+#else
 	const EVP_MD *evp_;
+#endif
 public:
 	explicit Hmac(Hash::Name name = Hash::N_SHA1)
 	{
 		switch (name) {
+#if CYBOZU_USE_COMMONCRYPTO == 1
+		case Hash::N_SHA1:
+			alg_ = kCCHmacAlgSHA1;
+			hashSize_ = 160 / 8;
+			break;
+		case Hash::N_SHA224:
+			alg_ = kCCHmacAlgSHA224;
+			hashSize_ = 224 / 8;
+			break;
+		case Hash::N_SHA256:
+			alg_ = kCCHmacAlgSHA256;
+			hashSize_ = 256 / 8;
+			break;
+		case Hash::N_SHA384:
+			alg_ = kCCHmacAlgSHA384;
+			hashSize_ = 384 / 8;
+			break;
+		case Hash::N_SHA512:
+			alg_ = kCCHmacAlgSHA512;
+			hashSize_ = 512 / 8;
+			break;
+#else
 		case Hash::N_SHA1: evp_ = EVP_sha1(); break;
 		case Hash::N_SHA224: evp_ = EVP_sha224(); break;
 		case Hash::N_SHA256: evp_ = EVP_sha256(); break;
 		case Hash::N_SHA384: evp_ = EVP_sha384(); break;
 		case Hash::N_SHA512: evp_ = EVP_sha512(); break;
+#endif
 		default:
 			throw cybozu::Exception("crypto:Hmac:") << name;
 		}
 	}
 	std::string eval(const std::string& key, const std::string& data)
 	{
+	#if CYBOZU_USE_COMMONCRYPTO == 1
+		std::string out(hashSize_, 0);
+		CCHmac(alg_, key.data(), key.size(), data.data(), data.size(), &out[0]);
+		return out;
+	#else
 		std::string out(EVP_MD_size(evp_) + 1, 0);
 		unsigned int outLen = 0;
 		if (HMAC(evp_, key.c_str(), static_cast<int>(key.size()),
@@ -263,27 +303,43 @@ public:
 			return out;
 		}
 		throw cybozu::Exception("crypto::Hamc::eval");
+	#endif
 	}
 };
 
 class Cipher {
-	const EVP_CIPHER *cipher_;
-	EVP_CIPHER_CTX *ctx_;
 public:
 	enum Name {
 		N_AES128_CBC,
 		N_AES192_CBC,
 		N_AES256_CBC,
+		N_AES128_CTR,
+		N_AES192_CTR,
+		N_AES256_CTR,
 		N_AES128_ECB, // be carefull to use
 		N_AES192_ECB, // be carefull to use
 		N_AES256_ECB, // be carefull to use
 	};
+
+private:
+#if CYBOZU_USE_COMMONCRYPTO == 1
+	Name name_;
+	CCCryptorRef ctx_;
+#else
+	const EVP_CIPHER *cipher_;
+	EVP_CIPHER_CTX *ctx_;
+#endif
+
+public:
 	static inline size_t getSize(Name name)
 	{
 		switch (name) {
 		case N_AES128_CBC: return 128;
 		case N_AES192_CBC: return 192;
 		case N_AES256_CBC: return 256;
+		case N_AES128_CTR: return 128;
+		case N_AES192_CTR: return 192;
+		case N_AES256_CTR: return 256;
 		case N_AES128_ECB: return 128;
 		case N_AES192_ECB: return 192;
 		case N_AES256_ECB: return 256;
@@ -296,31 +352,93 @@ public:
 		Encoding
 	};
 	explicit Cipher(Name name = N_AES128_CBC)
+	#if CYBOZU_USE_COMMONCRYPTO == 1
+		: name_(name)
+		, ctx_(0)
+	#else
 		: cipher_(0)
 		, ctx_(0)
+	#endif
 	{
+	#if CYBOZU_USE_COMMONCRYPTO == 1
+		switch (name_) {
+		case N_AES128_CBC:
+		case N_AES192_CBC:
+		case N_AES256_CBC:
+		case N_AES128_CTR:
+		case N_AES192_CTR:
+		case N_AES256_CTR:
+		case N_AES128_ECB:
+		case N_AES192_ECB:
+		case N_AES256_ECB:
+			break;
+		default:
+			throw cybozu::Exception("crypto:Cipher:Cipher:name") << (int)name;
+		}
+	#else
 		ctx_ = EVP_CIPHER_CTX_new();
 		if (ctx_ == 0) throw cybozu::Exception("crypto:Cipher:EVP_CIPHER_CTX_new");
 		switch (name) {
 		case N_AES128_CBC: cipher_ = EVP_aes_128_cbc(); break;
 		case N_AES192_CBC: cipher_ = EVP_aes_192_cbc(); break;
 		case N_AES256_CBC: cipher_ = EVP_aes_256_cbc(); break;
+		case N_AES128_CTR: cipher_ = EVP_aes_128_ctr(); break;
+		case N_AES192_CTR: cipher_ = EVP_aes_192_ctr(); break;
+		case N_AES256_CTR: cipher_ = EVP_aes_256_ctr(); break;
 		case N_AES128_ECB: cipher_ = EVP_aes_128_ecb(); break;
 		case N_AES192_ECB: cipher_ = EVP_aes_192_ecb(); break;
 		case N_AES256_ECB: cipher_ = EVP_aes_256_ecb(); break;
 		default:
 			throw cybozu::Exception("crypto:Cipher:Cipher:name") << (int)name;
 		}
+	#endif
 	}
 	~Cipher()
 	{
+	#if CYBOZU_USE_COMMONCRYPTO == 1
+		if (ctx_) CCCryptorRelease(ctx_);
+	#else
 		if (ctx_) EVP_CIPHER_CTX_free(ctx_);
+	#endif
 	}
 	/*
 		@note don't use padding = true
 	*/
 	void setup(Mode mode, const std::string& key, const std::string& iv, bool padding = false)
 	{
+	#if CYBOZU_USE_COMMONCRYPTO == 1
+		const int keyLen = static_cast<int>(key.size());
+		const int expectedKeyLen = static_cast<int>(getSize(name_) / 8);
+		if (keyLen != expectedKeyLen) {
+			throw cybozu::Exception("crypto:Cipher:setup:keyLen") << keyLen << expectedKeyLen;
+		}
+		const bool isCtr = name_ == N_AES128_CTR || name_ == N_AES192_CTR || name_ == N_AES256_CTR;
+		const bool isEcb = name_ == N_AES128_ECB || name_ == N_AES192_ECB || name_ == N_AES256_ECB;
+		if (!isEcb) {
+			if (iv.size() < kCCBlockSizeAES128) {
+				throw cybozu::Exception("crypto:Cipher:setup:ivLen") << iv.size() << ">=" << kCCBlockSizeAES128;
+			}
+		}
+		if (ctx_) {
+			CCCryptorRelease(ctx_);
+			ctx_ = 0;
+		}
+		CCCryptorStatus status;
+		if (isCtr) {
+			status = CCCryptorCreateWithMode(mode == Encoding ? kCCEncrypt : kCCDecrypt,
+				kCCModeCTR, kCCAlgorithmAES128, ccNoPadding, iv.data(), key.data(), key.size(), 0, 0, 0,
+				kCCModeOptionCTR_BE, &ctx_);
+		} else {
+			CCOptions options = isEcb ? kCCOptionECBMode : 0;
+			if (padding) options |= kCCOptionPKCS7Padding;
+			const void *ivPtr = isEcb ? 0 : iv.data();
+			status = CCCryptorCreate(mode == Encoding ? kCCEncrypt : kCCDecrypt,
+				kCCAlgorithmAES128, options, key.data(), key.size(), ivPtr, &ctx_);
+		}
+		if (status != kCCSuccess) {
+			throw cybozu::Exception("crypto:Cipher:setup:CCCryptorCreate") << (int)status;
+		}
+	#else
 		const int keyLen = static_cast<int>(key.size());
 		const int expectedKeyLen = EVP_CIPHER_key_length(cipher_);
 		if (keyLen != expectedKeyLen) {
@@ -342,6 +460,7 @@ public:
 			throw cybozu::Exception("crypto:Cipher:setup:ivLen") << ivLen << expectedIvLen;
 		}
 */
+	#endif
 	}
 	/*
 		the size of outBuf must be larger than inBufSize + blockSize
@@ -350,10 +469,19 @@ public:
 	*/
 	int update(char *outBuf, const char *inBuf, int inBufSize)
 	{
+	#if CYBOZU_USE_COMMONCRYPTO == 1
+		if (ctx_ == 0) return -1;
+		size_t outLen = 0;
+		const CCCryptorStatus status = CCCryptorUpdate(ctx_, inBuf, static_cast<size_t>(inBufSize), outBuf,
+			static_cast<size_t>(inBufSize + kCCBlockSizeAES128), &outLen);
+		if (status != kCCSuccess) return -1;
+		return static_cast<int>(outLen);
+	#else
 		int outLen = 0;
 		int ret = EVP_CipherUpdate(ctx_, cybozu::cast<uint8_t*>(outBuf), &outLen, cybozu::cast<const uint8_t*>(inBuf), inBufSize);
 		if (ret != 1) return -1;
 		return outLen;
+	#endif
 	}
 	/*
 		return -1 if padding
@@ -361,10 +489,18 @@ public:
 	*/
 	int finalize(char *outBuf)
 	{
+	#if CYBOZU_USE_COMMONCRYPTO == 1
+		if (ctx_ == 0) return -1;
+		size_t outLen = 0;
+		const CCCryptorStatus status = CCCryptorFinal(ctx_, outBuf, kCCBlockSizeAES128, &outLen);
+		if (status != kCCSuccess) return -1;
+		return static_cast<int>(outLen);
+	#else
 		int outLen = 0;
 		int ret = EVP_CipherFinal_ex(ctx_, cybozu::cast<uint8_t*>(outBuf), &outLen);
 		if (ret != 1) return -1;
 		return outLen;
+	#endif
 	}
 };
 

data/vendor/cybozulib/include/cybozu/endian.hpp

@@ -9,6 +9,10 @@
 #include <cybozu/inttype.hpp>
 #include <string.h>
 
+#ifdef _MSC_VER
+#include <stdlib.h>
+#endif
+
 namespace cybozu {
 
 #ifdef _MSC_VER

data/vendor/cybozulib/include/cybozu/exception.hpp

@@ -168,6 +168,26 @@ public:
 	{
 		return operator<<(cybozu::exception::wstr2str(s));
 	}
+#endif
+#if CYBOZU_CPLUSPLUS >= 202002L
+	Exception& operator<<(char16_t x)
+	{
+		std::ostringstream os;
+		os << static_cast<unsigned int>(x);
+		return operator<<(os.str());
+	}
+	Exception& operator<<(char32_t x)
+	{
+		std::ostringstream os;
+		os << static_cast<unsigned int>(x);
+		return operator<<(os.str());
+	}
+	Exception& operator<<(wchar_t x)
+	{
+		std::ostringstream os;
+		os << static_cast<unsigned int>(x);
+		return operator<<(os.str());
+	}
 #endif
 	template<class T>
 	Exception& operator<<(const T& x)

data/vendor/cybozulib/include/cybozu/inttype.hpp

@@ -57,8 +57,7 @@
 #endif
 #ifndef CYBOZU_ALLOCA
 	#ifdef _MSC_VER
-		#include <malloc.h>
-		#define CYBOZU_ALLOCA(x) _malloca(x)
+		#define CYBOZU_ALLOCA(x) _alloca(x)
 	#else
 		#define CYBOZU_ALLOCA(x) __builtin_alloca(x)
 	#endif
@@ -100,11 +99,18 @@
 	#define CYBOZU_GNUC_PREREQ(major, minor) 0
 #endif
 
-#if (__cplusplus >= 201703)
+// MSVC reports __cplusplus=199711 unless /Zc:__cplusplus is specified
+#ifdef _MSC_VER
+	#define CYBOZU_CPLUSPLUS _MSVC_LANG
+#else
+	#define CYBOZU_CPLUSPLUS __cplusplus
+#endif
+
+#if (CYBOZU_CPLUSPLUS >= 201703)
 	#define CYBOZU_CPP_VERSION CYBOZU_CPP_VERSION_CPP17
-#elif (__cplusplus >= 201402)
+#elif (CYBOZU_CPLUSPLUS >= 201402)
 	#define CYBOZU_CPP_VERSION CYBOZU_CPP_VERSION_CPP14
-#elif (__cplusplus >= 201103) || (defined(_MSC_VER) && _MSC_VER >= 1500) || defined(__GXX_EXPERIMENTAL_CXX0X__)
+#elif (CYBOZU_CPLUSPLUS >= 201103) || (defined(_MSC_VER) && _MSC_VER >= 1500) || defined(__GXX_EXPERIMENTAL_CXX0X__)
 	#if defined(_MSC_VER) && (_MSC_VER <= 1600)
 		#define CYBOZU_CPP_VERSION CYBOZU_CPP_VERSION_TR1
 	#else

data/vendor/cybozulib/include/cybozu/string.hpp

@@ -23,6 +23,11 @@
 #include <cybozu/exception.hpp>
 #include <cybozu/hash.hpp>
 
+#if CYBOZU_CPLUSPLUS >= 202002L
+#include <compare>
+#endif
+
+
 // to deal with unicode literal(same macro defined in regex.hpp)
 #ifdef _MSC_VER
 	#define CYBOZU_STR_WCHAR wchar_t
@@ -43,7 +48,7 @@ namespace cybozu {
 	typedef unsigned short Char16; /* unsigned is necessary for gcc */
 #endif
 #else
-	typedef int Char; //!< Char for Windows
+	typedef unsigned int Char; //!< Char for Windows
 	typedef wchar_t Char16;
 #endif
 
@@ -1517,12 +1522,20 @@ public:
 		get internal str(don't use this function)
 	*/
 	BasicString& get() { return str_; }
+#if CYBOZU_CPLUSPLUS >= 202002L
+	template<class T>bool operator==(const T& rhs) const { return compare(rhs) == 0; }
+	template<class T>std::strong_ordering operator<=>(const T& rhs) const {
+		int r = compare(rhs);
+		return r < 0 ? std::strong_ordering::less : r > 0 ? std::strong_ordering::greater : std::strong_ordering::equal;
+	}
+#else
 	template<class T>bool operator==(const T& rhs) const { return compare(rhs) == 0; }
 	template<class T>bool operator!=(const T& rhs) const { return compare(rhs) != 0; }
 	template<class T>bool operator<=(const T& rhs) const { return compare(rhs) <= 0; }
 	template<class T>bool operator>=(const T& rhs) const { return compare(rhs) >= 0; }
 	template<class T>bool operator<(const T& rhs) const { return compare(rhs) < 0; }
 	template<class T>bool operator>(const T& rhs) const { return compare(rhs) > 0; }
+#endif
 private:
 	template<class Iterator>
 	cybozu::Char getOneChar(Iterator& begin, const Iterator& end)
@@ -1570,6 +1583,7 @@ inline std::ostream& operator<<(std::ostream& os, const String& str)
 	return os << str.toUtf8();
 }
 
+#if CYBOZU_CPLUSPLUS < 202002L
 inline bool operator==(const cybozu::Char* lhs, const String& rhs) { return rhs == lhs; }
 inline bool operator!=(const cybozu::Char* lhs, const String& rhs) { return rhs != lhs; }
 inline bool operator<=(const cybozu::Char* lhs, const String& rhs) { return rhs >= lhs; }
@@ -1605,6 +1619,7 @@ inline bool operator>=(const std::wstring& lhs, const String& rhs) { return rhs
 inline bool operator<(const std::wstring& lhs, const String& rhs) { return rhs > lhs; }
 inline bool operator>(const std::wstring& lhs, const String& rhs) { return rhs < lhs; }
 #endif
+#endif
 
 inline void swap(String& lhs, String& rhs) { lhs.swap(rhs); }
 

data/vendor/cybozulib/test/base/crypto_test.cpp

@@ -1,7 +1,7 @@
 #include <cybozu/test.hpp>
 #include <cybozu/crypto.hpp>
-#include <cybozu/sha2.hpp>
 #include <cybozu/itoa.hpp>
+#include <cybozu/atoi.hpp>
 
 CYBOZU_TEST_AUTO(hashName)
 {
@@ -101,6 +101,159 @@ std::string toHexStr(const std::string& buf)
 	return s;
 }
 
+std::string fromHexStr(const std::string& hex)
+{
+	if ((hex.size() & 1) != 0) {
+		throw cybozu::Exception("fromHexStr:bad size") << hex.size();
+	}
+	std::string out(hex.size() / 2, 0);
+	for (size_t i = 0; i < out.size(); i++) {
+		out[i] = static_cast<uint8_t>(cybozu::hextoi(&hex[i * 2], 2));
+	}
+	return out;
+}
+
+std::string evalCipher(cybozu::crypto::Cipher::Name name, cybozu::crypto::Cipher::Mode mode, const std::string& key, const std::string& iv, const std::string& input, bool padding = false)
+{
+	cybozu::crypto::Cipher cipher(name);
+	cipher.setup(mode, key, iv, padding);
+	std::string out(input.size() + 32, 0);
+	int pos = cipher.update(&out[0], input.data(), static_cast<int>(input.size()));
+	CYBOZU_TEST_ASSERT(pos >= 0);
+	int last = cipher.finalize(&out[pos]);
+	CYBOZU_TEST_ASSERT(last >= 0);
+	out.resize(pos + last);
+	return out;
+}
+
+struct AesCbcTestVec {
+	cybozu::crypto::Cipher::Name name;
+	const char *keyHex;
+	const char *ivHex;
+	const char *plain;
+	const char *cipherHex;
+	bool isAscii;
+};
+
+const AesCbcTestVec aesCbcTbl[] = {
+	{
+		cybozu::crypto::Cipher::N_AES128_CBC,
+		"06a9214036b8a15b512e03d534120006",
+		"3dafba429d9eb430b422da802c9fac41",
+		"Single block msg",
+		"e353779c1079aeb82708942dbe77181a",
+		true,
+	},
+	{
+		cybozu::crypto::Cipher::N_AES128_CBC,
+		"c286696d887c9aa0611bbb3e2025a45a",
+		"562e17996d093d28ddb3ba695a2e6f58",
+		"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+		"d296cd94c2cccf8a3a863028b5e1dc0a7586602d253cfff91b8266bea6d61ab1",
+		false,
+	},
+	{
+		cybozu::crypto::Cipher::N_AES128_CBC,
+		"6c3ea0477630ce21a2ce334aa746c2cd",
+		"c782dc4c098c66cbd9cd27d825682c81",
+		"This is a 48-byte message (exactly 3 AES blocks)",
+		"d0a02b3836451753d493665d33f0e8862dea54cdb293abc7506939276772f8d5021c19216bad525c8579695d83ba2684",
+		true,
+	},
+	{
+		cybozu::crypto::Cipher::N_AES128_CBC,
+		"56e47a38c5598974bc46903dba290349",
+		"8ce82eefbea0da3c44699ed7db51b7d9",
+		"a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf",
+		"c30e32ffedc0774e6aff6af0869f71aa0f3af07a9a31a9c684db207eb0ef8e4e35907aa632c3ffdf868bb7b29d3d46ad83ce9f9a102ee99d49a53e87f4c3da55",
+		false,
+	},
+};
+
+struct AesCtrTestVec {
+	cybozu::crypto::Cipher::Name name;
+	const char *keyHex;
+	const char *counterHex;
+	const char *plain;
+	const char *cipherHex;
+	bool isAscii;
+};
+
+const AesCtrTestVec aesCtrTbl[] = {
+	{
+		cybozu::crypto::Cipher::N_AES128_CTR,
+		"ae6852f8121067cc4bf7a5765577f39e",
+		"00000030000000000000000000000001",
+		"Single block msg",
+		"e4095d4fb7a7b3792d6175a3261311b8",
+		true,
+	},
+	{
+		cybozu::crypto::Cipher::N_AES128_CTR,
+		"7e24067817fae0d743d6ce1f32539163",
+		"006cb6dbc0543b59da48d90b00000001",
+		"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+		"5104a106168a72d9790d41ee8edad388eb2e1efc46da57c8fce630df9141be28",
+		false,
+	},
+	{
+		cybozu::crypto::Cipher::N_AES128_CTR,
+		"7691be035e5020a8ac6e618529f9a0dc",
+		"00e0017b27777f3f4a1786f000000001",
+		"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223",
+		"c1cf48a89f2ffdd9cf4652e9efdb72d74540a42bde6d7836d59a5ceaaef3105325b2072f",
+		false,
+	},
+	{
+		cybozu::crypto::Cipher::N_AES192_CTR,
+		"16af5b145fc9f579c175f93e3bfb0eed863d06ccfdb78515",
+		"0000004836733c147d6d93cb00000001",
+		"Single block msg",
+		"4b55384fe259c9c84e7935a003cbe928",
+		true,
+	},
+	{
+		cybozu::crypto::Cipher::N_AES192_CTR,
+		"7c5cb2401b3dc33c19e7340819e0f69c678c3db8e6f6a91a",
+		"0096b03b020c6eadc2cb500d00000001",
+		"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+		"453243fc609b23327edfaafa7131cd9f8490701c5ad4a79cfc1fe0ff42f4fb00",
+		false,
+	},
+	{
+		cybozu::crypto::Cipher::N_AES192_CTR,
+		"02bf391ee8ecb159b959617b0965279bf59b60a786d3e0fe",
+		"0007bdfd5cbd60278dcc091200000001",
+		"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223",
+		"96893fc55e5c722f540b7dd1ddf7e758d288bc95c69165884536c811662f2188abee0935",
+		false,
+	},
+	{
+		cybozu::crypto::Cipher::N_AES256_CTR,
+		"776beff2851db06f4c8a0542c8696f6c6a81af1eec96b4d37fc1d689e6c1c104",
+		"00000060db5672c97aa8f0b200000001",
+		"Single block msg",
+		"145ad01dbf824ec7560863dc71e3e0c0",
+		true,
+	},
+	{
+		cybozu::crypto::Cipher::N_AES256_CTR,
+		"f6d66d6bd52d59bb0796365879eff886c66dd51a5b6a99744b50590c87a23884",
+		"00faac24c1585ef15a43d87500000001",
+		"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
+		"f05e231b3894612c49ee000b804eb2a9b8306b508f839d6a5530831d9344af1c",
+		false,
+	},
+	{
+		cybozu::crypto::Cipher::N_AES256_CTR,
+		"ff7a617ce69148e4f1726e2f43581de2aa62d9f805532edff1eed687fb54153d",
+		"001cc5b751a51d70a1c1114800000001",
+		"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223",
+		"eb6c52821d0bbbf7ce7594462aca4faab407df866569fd07f48cc0b583d6071f1ec0e6b8",
+		false,
+	},
+};
+
 CYBOZU_TEST_AUTO(sha256)
 {
 	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(sha256Tbl); i++) {
@@ -120,3 +273,27 @@ CYBOZU_TEST_AUTO(sha512)
 		CYBOZU_TEST_EQUAL(toHexStr(md), sha512Tbl[i].out);
 	}
 }
+
+CYBOZU_TEST_AUTO(aesCbcRfc3602)
+{
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(aesCbcTbl); i++) {
+		const std::string key = fromHexStr(aesCbcTbl[i].keyHex);
+		const std::string iv = fromHexStr(aesCbcTbl[i].ivHex);
+		const std::string plain = aesCbcTbl[i].isAscii ? std::string(aesCbcTbl[i].plain) : fromHexStr(aesCbcTbl[i].plain);
+		const std::string cipher = fromHexStr(aesCbcTbl[i].cipherHex);
+		CYBOZU_TEST_EQUAL(evalCipher(aesCbcTbl[i].name, cybozu::crypto::Cipher::Encoding, key, iv, plain), cipher);
+		CYBOZU_TEST_EQUAL(evalCipher(aesCbcTbl[i].name, cybozu::crypto::Cipher::Decoding, key, iv, cipher), plain);
+	}
+}
+
+CYBOZU_TEST_AUTO(aesCtrRfc3686)
+{
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(aesCtrTbl); i++) {
+		const std::string key = fromHexStr(aesCtrTbl[i].keyHex);
+		const std::string iv = fromHexStr(aesCtrTbl[i].counterHex);
+		const std::string plain = aesCtrTbl[i].isAscii ? std::string(aesCtrTbl[i].plain) : fromHexStr(aesCtrTbl[i].plain);
+		const std::string cipher = fromHexStr(aesCtrTbl[i].cipherHex);
+		CYBOZU_TEST_EQUAL(evalCipher(aesCtrTbl[i].name, cybozu::crypto::Cipher::Encoding, key, iv, plain), cipher);
+		CYBOZU_TEST_EQUAL(evalCipher(aesCtrTbl[i].name, cybozu::crypto::Cipher::Decoding, key, iv, cipher), plain);
+	}
+}

data/vendor/cybozulib/test/base/env_test.cpp

@@ -7,16 +7,16 @@ CYBOZU_TEST_AUTO(env)
 	std::string val;
 	CYBOZU_TEST_ASSERT(!cybozu::QueryEnv(val, "aw3vraw3vasv"));
 #ifdef _WIN32
-	const char *key = "SystemDrive";
-	const char *assumeVal = "C:";
+	const char *key = "USERPROFILE";
+	const char *assumeVal = "C:\\Users";
 #elif defined(__APPLE__)
-	const char *key = "OSTYPE";
-	const char *assumeVal = "darwin";
+	const char *key = "HOME";
+	const char *assumeVal = "/Users";
 #else
-	const char *key = "OSTYPE";
-	const char *assumeVal = "linux";
+	const char *key = "HOME";
+	const char *assumeVal = "/home";
 #endif
 	val = cybozu::GetEnv(key);
-	CYBOZU_TEST_EQUAL(val, assumeVal);
+	CYBOZU_TEST_EQUAL(val.substr(0, strlen(assumeVal)), assumeVal);
 	CYBOZU_TEST_EQUAL(cybozu::GetEnv("asvrifansevjase", "default"), "default");
 }

data/vendor/cybozulib/test/base/string_test.cpp

@@ -14,6 +14,7 @@ using namespace cybozu;
 
 #ifdef _MSC_VER
 	#pragma warning(disable : 4309)
+	#pragma warning(disable : 4310)
 #endif
 
 ///////// iterator
@@ -221,7 +222,7 @@ CYBOZU_TEST_AUTO(string_constructor_surrogate_pair_test)
 	const Char s[] = { 0x00003069, 0x00000061, 0x00000062, 0x00000063, 0x0000308c, 0x0002000b, 0 };
 	std::stringstream ss;
 	ss << a;
-	CYBOZU_TEST_EQUAL(a, s);
+	CYBOZU_TEST_ASSERT(a == s);
 	CYBOZU_TEST_EQUAL(ss.str(), "\xe3\x81\xa9" "abc" "\xe3\x82\x8c" "\xf0\xa0\x80\x8b");
 }
 
@@ -297,7 +298,7 @@ CYBOZU_TEST_AUTO(string_index_test_at)
 	String s("\xe3\x81\x93\xe3\x82\x8c\xe3\x81\xaf" "UTF-8 1");
 	Char t = s.at(3);
 	Char c = 'U';
-	CYBOZU_TEST_EQUAL(t, c);
+	CYBOZU_TEST_ASSERT(t == c);
 }
 
 CYBOZU_TEST_AUTO(string_index_test_at_exception)
@@ -320,7 +321,7 @@ CYBOZU_TEST_AUTO(string_index_test_index)
 	String s("\xe3\x81\x93\xe3\x82\x8c\xe3\x81\xaf" "UTF-8 1");
 	Char t = s[6];
 	Char c = '-';
-	CYBOZU_TEST_EQUAL(t, c);
+	CYBOZU_TEST_ASSERT(t == c);
 }
 
 //cybozu::String
@@ -614,7 +615,7 @@ CYBOZU_TEST_AUTO(string_utility_test_c_str)
 	String s("abcdefg");
 	const Char cs[] = {'a', 'b', 'c',  'd', 'e', 'f', 'g', 0};
 	for (int i = 0; i<8 ; i++) {
-		CYBOZU_TEST_EQUAL(s.c_str()[i], cs[i]);
+		CYBOZU_TEST_ASSERT(s.c_str()[i] == cs[i]);
 	}
 }
 
@@ -624,7 +625,7 @@ CYBOZU_TEST_AUTO(string_utility_test_data)
 	String s("abcdefg");
 	const Char cs[] = {'a', 'b', 'c',  'd', 'e', 'f', 'g', 0};
 	for (int i = 0; i<7 ; i++) {
-		CYBOZU_TEST_EQUAL(s.c_str()[i], cs[i]);
+		CYBOZU_TEST_ASSERT(s.c_str()[i] == cs[i]);
 	}
 }
 
@@ -1547,7 +1548,7 @@ CYBOZU_TEST_AUTO(utf16)
 	cybozu::ConvertUtf8ToUtf16(&s, utf8, utf8 + 12);
 	CYBOZU_TEST_EQUAL(s.size(), 6u);
 	for (int i = 0; i < 6; i++) {
-		CYBOZU_TEST_EQUAL(s[i], utf16[i]);
+		CYBOZU_TEST_ASSERT(s[i] == utf16[i]);
 	}
 	std::string t;
 	cybozu::ConvertUtf16ToUtf8(&t, utf16, utf16 + 6);
@@ -1565,7 +1566,7 @@ CYBOZU_TEST_AUTO(Utf8ref)
 	cybozu::Char c;
 	size_t i = 0;
 	while (ref.next(&c)) {
-		CYBOZU_TEST_EQUAL(c, s[i]);
+		CYBOZU_TEST_ASSERT(c == s[i]);
 		i++;
 	}
 	CYBOZU_TEST_EQUAL(i, s.size());
@@ -1578,7 +1579,7 @@ CYBOZU_TEST_AUTO(Utf8ref_bad_char)
 	cybozu::Utf8ref ref(utf8.c_str(), utf8.size());
 	cybozu::Char c;
 	CYBOZU_TEST_ASSERT(ref.next(&c));
-	CYBOZU_TEST_EQUAL(s[0], c);
+	CYBOZU_TEST_ASSERT(s[0] == c);
 	CYBOZU_TEST_EXCEPTION(ref.next(&c), std::exception);
 }
 
@@ -1590,7 +1591,7 @@ CYBOZU_TEST_AUTO(Utf8ref_ignore_bad_char)
 	cybozu::Char c;
 	size_t i = 0;
 	while (ref.next(&c)) {
-		CYBOZU_TEST_EQUAL(c, s[i]);
+		CYBOZU_TEST_ASSERT(c == s[i]);
 		i++;
 	}
 	CYBOZU_TEST_EQUAL(i, s.size());
@@ -1605,11 +1606,11 @@ CYBOZU_TEST_AUTO(equal)
 	CYBOZU_TEST_EQUAL(a, a);
 	CYBOZU_TEST_EQUAL(a, b);
 	CYBOZU_TEST_EQUAL(a, c);
-	CYBOZU_TEST_EQUAL(a, d);
+	CYBOZU_TEST_ASSERT(a == d);
 
 	CYBOZU_TEST_EQUAL(b, a);
 	CYBOZU_TEST_EQUAL(c, a);
-	CYBOZU_TEST_EQUAL(d, a);
+	CYBOZU_TEST_ASSERT(d == a);
 
 	CYBOZU_TEST_ASSERT(!(a != a));
 	CYBOZU_TEST_ASSERT(!(a != b));
@@ -1621,8 +1622,8 @@ CYBOZU_TEST_AUTO(equal)
 	CYBOZU_TEST_ASSERT(!(d != a));
 #ifdef _MSC_VER
 	const wchar_t e[] = L"abc";
-	CYBOZU_TEST_EQUAL(a, e);
-	CYBOZU_TEST_EQUAL(e, a);
+	CYBOZU_TEST_ASSERT(a == e);
+	CYBOZU_TEST_ASSERT(e == a);
 	CYBOZU_TEST_ASSERT(!(a != e));
 	CYBOZU_TEST_ASSERT(!(e != a));
 #endif

data/vendor/msoffice/common.mk

@@ -11,14 +11,14 @@ ifeq ($(OLD_OPENSSL),1)
 CFLAGS+=-DCYBOZU_USE_OPENSSL_NEW_HASH=0
 endif
 
-LDFLAGS = -lcrypto
 UNAME_S=$(shell uname -s)
 ifeq ($(UNAME_S),Darwin)
-  EXT_DIR?=/opt/homebrew/
-  CFLAGS+=-I$(EXT_DIR)/include
-  LDFLAGS+=-L$(EXT_DIR)/lib
-  LIB_SUF=dylib
+#  EXT_DIR?=/opt/homebrew/
+#  CFLAGS+=-I$(EXT_DIR)/include
+#  LDFLAGS+=-L$(EXT_DIR)/lib
+#  LIB_SUF=dylib
 else
+  LDFLAGS = -lcrypto
   LIB_SUF=so
 endif
 
@@ -38,7 +38,7 @@ endif
 
 TOPDIR:=$(realpath $(dir $(lastword $(MAKEFILE_LIST))))/
 CFLAGS+= -I$(TOPDIR)include -I$(TOPDIR)../cybozulib/include
-LDFLAGS+= -L$(TOPDIR)lib -lcrypto -lpthread
+LDFLAGS+= -L$(TOPDIR)lib
 ifneq ($(UNAME_S),Darwin)
   LDFLAGS+=-lrt
 endif

data/vendor/msoffice/include/decode.hpp

@@ -192,7 +192,14 @@ bool decode(const char *data, uint32_t dataSize, const String& outFile, const st
 	ms::cfb::CompoundFile cfb(data, dataSize);
 	cfb.put();
 
+#if defined(__GNUC__) && __GNUC__ >= 13 && !defined(__clang__)
+	#pragma GCC diagnostic push
+	#pragma GCC diagnostic ignored "-Wdangling-reference"
+#endif
 	const std::string& encryptedPackage = GetContensByName(cfb, "EncryptedPackage"); // data
+#if defined(__GNUC__) && __GNUC__ >= 13 && !defined(__clang__)
+	#pragma GCC diagnostic pop
+#endif
 	const EncryptionInfo info(GetContensByName(cfb, "EncryptionInfo")); // xml
 	if (pSpinCount) {
 		*pSpinCount = info.spinCount;

data/vendor/msoffice/src/Makefile

@@ -2,7 +2,7 @@ include ../common.mk
 
 TARGET=$(TEST_FILE)
 
-SRC=msoffice-crypt.cpp attack.cpp
+SRC=msoffice-crypt.cpp #attack.cpp
 
 all: $(TARGET) $(SRC)
 

metadata

@@ -1,28 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: ooxml_crypt
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Ashish Kulkarni
 bindir: bin
 cert_chain: []
-date: 2025-05-20 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -337,7 +337,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Library for encrypting/decrypting password-protected Microsoft Office XML
   (OOXML) files (e.g. .docx, .xlsx, .pptx)