BlackFeather'S Blog我的技术小博 -- C/C++,Python,Golang

sqlite引入的fts5扩展功能，会创建table_content/table_data等数据表，其中_data中是索引数据，可以尝试解析还原出很多有趣的内容。

至于数据结构后面有心情了再补充，直接贴代码。

此代码为C++类。

More...

java可以将任意对象序列化为一段内存流，也可以反序列化回对象。

此代码用于dump序列化内容流，是用了Jsoncpp作为父类。

主要参考了https://github.com/NickstaDB/SerializationDumper这个项目。

More...

zlib封装C++类

#pragma once

#include <string>
#include <memory>

#include <zlib.h>

/*
	to (de-)compress deflate format, use wbits = -zlib.MAX_WBITS
	to (de-)compress zlib format, use wbits = zlib.MAX_WBITS,
			gzlib header:
				0x78 0x01 - No Compression/low
				0x78 0x9C - Default Compression
				0x78 0xDA - Best Compression
	to (de-)compress gzip format, use wbits = zlib.MAX_WBITS | 16
			gzip header:0x1F 0x8B
*/
class ZlibHandler
{
public:
	ZlibHandler() : 
		m_nCacheSize (1024 * 1024),
		m_nErrCode(Z_OK),
		m_mode(0)
	{
		m_pCacheBuf = new char[m_nCacheSize];
		m_bFreeCacheBuf = true;
	}
	//使用外部缓冲区
	ZlibHandler(char *cachebuf, size_t cachesize) :
		m_pCacheBuf(cachebuf),
		m_nCacheSize(cachesize),
		m_bFreeCacheBuf(false),
		m_nErrCode(Z_OK),
		m_mode(0) {}
	~ZlibHandler() 
	{
		if (m_mode == 1)
			deflateEnd(&m_zlibStream);
		else if (m_mode == 2)
			inflateEnd(&m_zlibStream);

		m_mode = 0;

		if (m_bFreeCacheBuf)
			delete[] m_pCacheBuf;
	}

	/*
	* 初始化压缩方法
	* 不能同时初始化压缩和解压两个控制器
	* 参数：
		windowBits = MAX_WBITS + 16 //默认是gzip，如果需要是zlib传入MAX_WBITS即可
	*/
	bool InitCompress(int windowBits = MAX_WBITS + 16, int level = Z_DEFAULT_COMPRESSION,
		int method = Z_DEFLATED, int memLevel = 8, int strategy = Z_DEFAULT_STRATEGY)
	{
		if (m_mode != 0)
			return false;

		if (deflateInit2(&m_zlibStream, level, method, windowBits, memLevel, strategy) != Z_OK)
			return false;

		m_windowbits = windowBits;
		m_mode = 1;
		return true;
	}
	/*
	* 销毁压缩控制器
	* 一般情况下不需要主动调用，除非是上一次压缩数据结束了需要再次压缩新数据，先End再次Init（不推荐）
	*/
	void CompressEnd()
	{
		if (m_mode == 1)
		{
			deflateEnd(&m_zlibStream);
			m_mode = 0;
		}
	}
	/*
	* 压缩数据块，可以多次调用
	* 结束的时候，需要调用CompressBlockFinish处理尾部数据
	*/
	inline std::string CompressBlock(const std::string& src)
	{
		return CompressBlock(src.c_str(), src.size());
	}
	/*
	* 压缩数据块，可以多次调用
	* 结束的时候，需要调用CompressBlockFinish处理尾部数据
	*/
	std::string CompressBlock(const void* src, size_t srcLen)
	{
		if (src == NULL || srcLen == 0)
			return {};

		m_zlibStream.next_in = (Bytef*)src;
		m_zlibStream.avail_in = (uint32_t)srcLen;

		std::string ret;
		do {
			m_zlibStream.avail_out = (uint32_t)m_nCacheSize;
			m_zlibStream.next_out = (Bytef*)m_pCacheBuf;
			m_nErrCode = deflate(&m_zlibStream, Z_NO_FLUSH);
			if (m_nErrCode != Z_OK)
				break;
			
			ret.append(m_pCacheBuf, m_nCacheSize - m_zlibStream.avail_out);
		} while (m_zlibStream.avail_out == 0);

		return ret;
	}
	/*
	* 完成压缩数据块
	* 调用CompressBlock压缩数据完毕后，需要调用此方法，返回值也是内容的一部分
	*/
	std::string CompressBlockFinish()
	{
		if (m_nErrCode != Z_OK)
			return {};
		
		std::string ret;
		do {
			m_zlibStream.avail_out = (uint32_t)m_nCacheSize;
			m_zlibStream.next_out = (Bytef*)m_pCacheBuf;
			m_nErrCode = deflate(&m_zlibStream, Z_FINISH);
			if (m_nErrCode != Z_STREAM_END && m_nErrCode != Z_OK)
				break;

			ret.append(m_pCacheBuf, m_nCacheSize - m_zlibStream.avail_out);
		} while (m_zlibStream.avail_out == 0);
		
		return ret;
	}
	/*
	* 压缩数据，一次性传入所有数据，返回压缩后的数据，不需要调用CompressBlockFinish
	*/
	std::string Compress(const std::string& src)
	{
		return Compress(src.c_str(), src.size());
	}
	/*
	* 压缩数据，一次性传入所有数据，返回压缩后的数据，不需要调用CompressBlockFinish
	*/
	std::string Compress(const void* src, size_t srcLen)
	{
		if (src == NULL || srcLen == 0)
			return {};

		std::string ret = CompressBlock(src, srcLen);
		ret += CompressBlockFinish();
		return ret;
	}
	
	
	/*
	* 初始化解压控制器
	* 不能同时初始化压缩和解压两个控制器
	*	windowBits：默认是MAX_WBITS + 32，能自动检测zlib和gzip两种格式。如果是deflate格式，需要传入-MAX_WBITS
	*/
	bool InitDecompress(int windowBits = MAX_WBITS + 32)
	{
		if (m_mode != 0)
			return false;

		if (inflateInit2(&m_zlibStream, windowBits) != Z_OK)
			return false;

		m_windowbits = windowBits;
		m_mode = 2;
		return true;
	}
	/*
	* 销毁解压控制器
	* 一般情况下不需要主动调用，除非是上一次操作结束了需要再次解压新数据，先End再次Init（不推荐）
	*/
	void DecompressEnd()
	{
		if (m_mode == 2)
		{
			inflateEnd(&m_zlibStream);
			m_mode = 0;
		}
	}
	/*
	* 解压数据块，可以多次调用
	*/
	inline std::string Decompress(const std::string& src)
	{
		return Decompress(src.c_str(), src.size());
	}
	/*
	* 解压数据块，可以多次调用
	*/
	std::string Decompress(const void* src, size_t srcLen)
	{
		if (src == NULL || srcLen == 0)
			return {};

		m_zlibStream.next_in = (Bytef*)src;
		m_zlibStream.avail_in = (uint32_t)srcLen;

		std::string ret;
		do {
			m_zlibStream.avail_out = (uint32_t)m_nCacheSize;
			m_zlibStream.next_out = (Bytef*)m_pCacheBuf;

			m_nErrCode = inflate(&m_zlibStream, Z_NO_FLUSH);
			if (m_nErrCode != Z_STREAM_END && m_nErrCode != Z_OK)
				break;

			ret.append(m_pCacheBuf, m_nCacheSize - m_zlibStream.avail_out);
		} while (m_zlibStream.avail_out == 0);

		return ret;
	}

private:
	z_stream m_zlibStream{};
	char *m_pCacheBuf{};
	size_t m_nCacheSize;
	bool m_bFreeCacheBuf{};
	int m_nErrCode{};
	int m_windowbits{};
	int m_mode; //1-加密；2-解密
};

/*
void zlibhandlertest()
{
	std::string str = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
	for (int i = 0; i < 1024 * 1024; i++)
	{
		str.append(std::to_string(i));
	}
	char* pstr = strdup(str.c_str());
	char* pstr2 = strdup(str.c_str());

	ZlibHandler z1;
	z1.InitCompress(-MAX_WBITS);
	std::string compress1 = z1.Compress(str.c_str(), str.length());
	ZlibHandler z2;
	z2.InitCompress(-MAX_WBITS);
	std::string compress2_1 = z2.CompressBlock(pstr, str.length());
	free(pstr);
	std::string compress2_2 = z2.CompressBlock(pstr2, str.length());
	free(pstr2);
	std::string compress2_3 = z2.CompressBlockFinish();

	ZlibHandler de1;
	de1.InitDecompress(-MAX_WBITS);
	std::string decompress1 = de1.Decompress(compress1.c_str(), compress1.length());
	if (decompress1 == str)
		printf("check ok!\n");
	ZlibHandler de2;
	de2.InitDecompress(-MAX_WBITS);
	std::string decompress2 = de2.Decompress(compress2_1 + compress2_2 + compress2_3);
	if (decompress2 == str + str)
		printf("check ok!\n");

	ZlibHandler de3;
	de3.InitDecompress(-MAX_WBITS);
	std::string decompress3 = de3.Decompress(compress2_1);
	decompress3 += de3.Decompress(compress2_2);
	decompress3 += de3.Decompress(compress2_3);
	if (decompress3 == str + str)
		printf("check ok!\n");
}
*/

ECDH算法封装，基于openssl。

#pragma once

#include <string>

#include <openssl/ec.h>
#include <openssl/ecdh.h>
#include <openssl/evp.h>


class ECDHEncoder
{
private:
	EC_KEY* m_ecKey{ nullptr };
	EC_KEY* m_ecPeerPubKey{ nullptr };

public:
	ECDHEncoder() {};
	~ECDHEncoder() {
		if (m_ecKey)
			EC_KEY_free(m_ecKey);
		if (m_ecPeerPubKey)
			EC_KEY_free(m_ecPeerPubKey);
	};

	bool GenerateKey(int nid)
	{
		m_ecKey = EC_KEY_new_by_curve_name(nid);
		if (m_ecKey == nullptr)
			return false;

		if (1 != EC_KEY_generate_key(m_ecKey))
		{
			EC_KEY_free(m_ecKey);
			m_ecKey = nullptr;
			return false;
		}

		return true;
	}

	std::string GetMyEncodedPoint(point_conversion_form_t type = POINT_CONVERSION_UNCOMPRESSED)
	{
		const EC_GROUP* group = EC_KEY_get0_group(m_ecKey);
		const EC_POINT* pubKey = EC_KEY_get0_public_key(m_ecKey);

		size_t field_len = EC_GROUP_get_degree(group);
		size_t byte_len = (field_len + 7) / 8;

		unsigned char* point_data = (unsigned char*)malloc(byte_len * 2 + 1);
		if (!point_data)
			return {};

		size_t point_data_len = EC_POINT_point2oct(group, pubKey, type, point_data, byte_len * 2 + 1, nullptr);
		if (0 == point_data_len)
		{
			free(point_data);
			return {};
		}

		std::string strPointData((char*)point_data, point_data_len);
		free(point_data);

		return strPointData;
	}

	std::string GetMyPublicKey()
	{
		BIO* out = BIO_new(BIO_s_mem());
		i2d_EC_PUBKEY_bio(out, m_ecKey);

		char* p;
		long length = BIO_get_mem_data(out, &p);
		std::string strECPubKey(p, length);
		BIO_free_all(out);

		return strECPubKey;
	}

	bool SetPeerPublicKey(const std::string& strPeerPublicKey)
	{
		if (m_ecPeerPubKey)
		{
			EC_KEY_free(m_ecPeerPubKey);
			m_ecPeerPubKey = nullptr;
		}

		const unsigned char* szBuf = (unsigned char*)strPeerPublicKey.c_str();
		m_ecPeerPubKey = d2i_EC_PUBKEY(nullptr, &szBuf, (long)strPeerPublicKey.size());
		if (m_ecPeerPubKey == nullptr)
			return false;

		return true;
	}

	bool SetPeerEncodedPoint(const std::string& strPointData)
	{
		if (m_ecPeerPubKey)
		{
			EC_KEY_free(m_ecPeerPubKey);
			m_ecPeerPubKey = nullptr;
		}

		const EC_GROUP* group = EC_KEY_get0_group(m_ecKey);
		EC_POINT* peerPubKey = EC_POINT_new(group);
		if (peerPubKey == nullptr)
			return false;

		const unsigned char* p = (const unsigned char*)strPointData.c_str();
		if (0 == EC_POINT_oct2point(group, peerPubKey, p, strPointData.size(), nullptr))
		{
			EC_POINT_free(peerPubKey);
			return false;
		}

		m_ecPeerPubKey = EC_KEY_new_by_curve_name(EC_GROUP_get_curve_name(group));
		if (m_ecPeerPubKey == nullptr)
		{
			EC_POINT_free(peerPubKey);
			return false;
		}

		if (1 != EC_KEY_set_public_key(m_ecPeerPubKey, peerPubKey))
		{
			EC_POINT_free(peerPubKey);
			EC_KEY_free(m_ecPeerPubKey);
			m_ecPeerPubKey = nullptr;
			return false;
		}

		EC_POINT_free(peerPubKey);

		return true;
	}

	std::string ComputeSecretKey()
	{
		if (m_ecPeerPubKey == nullptr)
			return {};

		int field_size = EC_GROUP_get_degree(EC_KEY_get0_group(m_ecKey));
		size_t secret_len = (field_size + 7) / 8;
		unsigned char* secret = new unsigned char[secret_len];
		if (secret == nullptr)
			return {};

		secret_len = ECDH_compute_key(secret, secret_len, EC_KEY_get0_public_key(m_ecPeerPubKey), m_ecKey, nullptr);
		if (secret_len == 0)
		{
			delete[] secret;
			return {};
		}
		std::string strSecretKey((const char*)secret, secret_len);
		delete[] secret;

		return strSecretKey;
	}
};

openssl使用rsa加解密，C++封装，支持设置公钥、私钥，公钥加解密，私钥加解密。

使用方法很简单:

CRSAEncoder mRSAEncoderPC;
//设置公钥
mRSAEncoderPC.SetPublicKey("-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQE..........XApYoMnPE3g4xU4NceOBTFZtR5fp+w/MswIDAQAB\n-----END PUBLIC KEY-----");
//公钥解密
std::string strTest = mRSAEncoderPC.PublicDecrypt("......");
//公钥加密
strTest = mRSAEncoderPC.PublicEncrypt("......");




//另外一种
unsigned char d[] = {
	0x38, 0x60, 0x63, 0x56, 0xBC, 0x54, 0x52, 0xBC, 0xA6, 0xB6, 0xDB, 0x47, 0x49, 0x08, 0xE5, 0xB8,
	0x0B, 0xAA, 0x44, 0xEC, 0x49, 0x2B, 0x35, 0x5F, 0xBB, 0x1A, 0xB2, 0x29, 0x2D, 0x0F, 0x2D, 0xE2,
	0x93, 0x70, 0x4D, 0x8F, 0x6F, 0x01, 0x64, 0xE4, 0xC9, 0x0C, 0x03, 0x4C, 0x02, 0x08, 0xE6, 0xB7,
	0xAF, 0xBB, 0x8A, 0x0A, 0xFF, 0x84, 0xB4, 0xBA, 0x9E, 0x4B, 0x1A, 0xB2, 0x0A, 0x75, 0xDA, 0xFD,
	0x0E, 0xBE, 0x73, 0xCA, 0x5C, 0xFC, 0xA2, 0x4D, 0xCF, 0x56, 0xA8, 0xAD, 0x9D, 0xC3, 0x60, 0x86,
	0xF5, 0xA8, 0xA0, 0xD0, 0xCD, 0x7E, 0x21, 0x8A, 0xCE, 0x4C, 0xCD, 0x03, 0xDE, 0x76, 0xF6, 0xA5,
	0x95, 0xA9, 0x77, 0x77, 0xFF, 0xF9, 0xBA, 0x3B, 0x0F, 0xD9, 0xFF, 0x50, 0x63, 0x6E, 0xDD, 0x49,
	0xFA, 0x31, 0x7D, 0xE0, 0xC5, 0x81, 0xC5, 0x75, 0x79, 0xCE, 0x1C, 0x78, 0x1A, 0x94, 0xD6, 0x7A,
	0xA1, 0xFD, 0x24, 0x9F, 0x11, 0x3A, 0x1D, 0xED, 0xF4, 0x5C, 0x9E, 0x03, 0x7B, 0x8D, 0xFF, 0xB7,
	0x04, 0xC4, 0x86, 0x24, 0x3D, 0xD2, 0x9F, 0xAB, 0xB6, 0x2B, 0x09, 0x55, 0x97, 0x66, 0x7B, 0xAA,
	0xF5, 0x0E, 0x25, 0xA0, 0x82, 0x4B, 0x02, 0x70, 0x84, 0xCB, 0x5F, 0xA1, 0x55, 0xBB, 0x63, 0x56,
	0xC3, 0x76, 0xB8, 0xFB, 0x5D, 0x38, 0x62, 0xF0, 0x10, 0xD6, 0x03, 0x0C, 0x6A, 0xC3, 0x53, 0xE9,
	0x55, 0xA2, 0x9D, 0x2B, 0x79, 0x05, 0x21, 0xFF, 0x70, 0x8A, 0x2F, 0xE3, 0x4C, 0xF7, 0x3D, 0x90,
	0x95, 0xB9, 0x3C, 0x53, 0x61, 0xC7, 0xB8, 0x72, 0x91, 0xB5, 0x3D, 0x7F, 0x57, 0x8D, 0x4C, 0xCB,
	0xF3, 0x93, 0x2C, 0x14, 0x13, 0xF6, 0x50, 0xDD, 0x3F, 0x70, 0xDE, 0x7E, 0x26, 0x34, 0xF4, 0xCA,
	0x69, 0xBF, 0xAF, 0x10, 0xE8, 0xD3, 0xDD, 0xEA, 0x95, 0x22, 0x22, 0xA3, 0x06, 0x73, 0x0E, 0xC1
};


unsigned char n[] = {
	0xCA, 0x76, 0x88, 0xB4, 0xCA, 0x54, 0x3D, 0x75, 0x00, 0x50, 0xD4, 0x87, 0x59, 0x1F, 0x9D, 0xB4,
	0x2E, 0xE2, 0xF4, 0xB7, 0x11, 0xA0, 0x55, 0xE4, 0xC3, 0x96, 0x30, 0x73, 0x94, 0xC6, 0x10, 0x19,
	0xD4, 0x94, 0xC4, 0xC8, 0x8D, 0xFA, 0x05, 0xC8, 0x39, 0x22, 0x46, 0x8F, 0xDD, 0x0D, 0xF7, 0xF4,
	0xC1, 0x77, 0x31, 0xB5, 0x96, 0xA4, 0xF2, 0x57, 0x53, 0x5D, 0x91, 0x55, 0x76, 0x36, 0xC2, 0x1B,
	0x44, 0x5A, 0x35, 0x67, 0x13, 0x6A, 0x39, 0xB0, 0xA6, 0xD4, 0x5B, 0xCD, 0xDE, 0x99, 0x4D, 0xCA,
	0x78, 0x9B, 0xBF, 0x52, 0x79, 0xD5, 0x6C, 0xCD, 0x33, 0xA9, 0x04, 0x09, 0x15, 0x3C, 0x7D, 0xB3,
	0x36, 0xD2, 0xA2, 0x7E, 0xAA, 0xA2, 0x81, 0x52, 0x9C, 0xEF, 0x15, 0x98, 0x42, 0x17, 0x19, 0xB9,
	0xB6, 0x2D, 0x24, 0xC5, 0x82, 0x08, 0xE1, 0x1D, 0x0A, 0xC0, 0xF9, 0xAD, 0x22, 0xE6, 0xB8, 0xDC,
	0xDA, 0x8B, 0xCE, 0x06, 0x71, 0x9D, 0x64, 0x14, 0xEF, 0xD3, 0x26, 0x7F, 0x76, 0xB2, 0x87, 0xF3,
	0x0D, 0x75, 0x5C, 0x57, 0x02, 0xBE, 0xA4, 0x18, 0xFB, 0x76, 0xED, 0xEF, 0xCA, 0x60, 0x83, 0xBE,
	0xE3, 0xC0, 0x42, 0x70, 0x56, 0x05, 0xDB, 0x5D, 0xCA, 0xF5, 0xE6, 0xF6, 0xA2, 0x91, 0xFD, 0x53,
	0x03, 0xA9, 0x86, 0x39, 0x0B, 0xB8, 0xC4, 0x25, 0x1D, 0x31, 0x55, 0x05, 0xFC, 0x8A, 0xB4, 0x3E,
	0x01, 0x58, 0x3C, 0x6D, 0x2D, 0x5D, 0xE1, 0x0D, 0xE1, 0x7A, 0x0E, 0xD9, 0x6D, 0x08, 0x8D, 0xDE,
	0xDD, 0x93, 0xA3, 0x2E, 0xA4, 0xE2, 0xC7, 0xAE, 0xC7, 0xC5, 0x83, 0xC4, 0xE1, 0x4D, 0xFC, 0x67,
	0x92, 0x75, 0x99, 0xF4, 0x3A, 0x5F, 0x98, 0xE7, 0x21, 0xD9, 0x15, 0x14, 0xFC, 0x45, 0x34, 0x04,
	0x6D, 0xD1, 0x6E, 0xF7, 0x2D, 0x96, 0xB3, 0xD3, 0xAE, 0x43, 0xC3, 0x4D, 0x26, 0x23, 0x5E, 0x7F
};

unsigned char e[] = { 0x01, 0x00, 0x01 };

CRSAEncoder mRSAEncoder;
//设置私钥
mRSAEncoder.SetPrivateKey(n, sizeof(n), e, sizeof(e), d, sizeof(d));
//设置私钥另外一个姿势也可以的
//mRSAEncoder.SetPrivateKey("-----BEGIN PRIVATE KEY-----\nMIICeAIBA..............DANBQltd+11\n-----END PRIVATE KEY-----");
//私钥加密
FString strEnBuf = mRSAEncoder.PrivateEncrypt("......");
//私钥解密
strEnBuf = mRSAEncoder.PrivateDecrypt("......");

More...

苹果配置中大量用到了plist，使用开源的C语言的库libplist可以读取解析，但是纯C的写起来非常蛋疼。

于是用C++封装了一下(c++ wrapper)，但是plist的本质还是xml，读取起来还是略有繁琐，于是转为json结构，就可以直接使用了（依赖jsoncpp库）。

plist内部是有PLIST_UID、PLIST_DICT、PLIST_ARRAY等复杂的结构，支持xml和binary(bplist)两种格式，支持uid自动解析处理关联，支持NS.objects、NS.keys、NSDictionary、NSArray、NSMutableDictionary、NSMutableArray等结构自动处理，使用起来就非常方便了。

More...

wgs84：GPS使用的坐标系

gcj02：中国国家测绘局制订的地理信息系统的坐标系统，是在WGS84经纬度的基础上执行加密算法而成。因为GPS得到的经纬度直接在 GCJ-02 坐标系下会定位到错误的地点，有种到了火星的感觉，因此在坊间也将 GCJ-02 戏称为火星坐标系。高德地图、腾讯地图均使用的此坐标系。

bd09：百度地图使用的，在gcj02基础上又做了一次转换。

More...

任务队列可以认为是执行同一个方法来处理数据的队列，指定回调函数。

线程池就是先开辟好多个线程，然后将要执行的方法+参数丢到线程池中，支持返回值获取。

均依赖了无锁队列库 https://github.com/cameron314/concurrentqueue

More...

很多应用需要监控系统资源的使用率等信息，之前零散写过很多。

近日需要读取硬盘的IO使用率，就是任务管理器中的硬盘相关信息。

读写速度很好搞定，但是这个百分比的使用率（活动时间）恶心了，最后搜索到的技术点都指向了Pdh(performance data helper)库。

More...

2024.12.16更新

评论提到的ws问题修正了，实际上就是注释掉了一个多余的判断处理。

mongoose版本是6.18版本

https://github.com/cesanta/mongoose/releases/tag/6.18

More...