[数据安全] 一个简洁快速的去数据特征的混淆算法(obfuscate)

[注]本文为作者原创文章，转载请注明出处。谢谢。 

 

问题1，什么是特征

　　这个人长个马脸，那个妹子胸大，这都是特征。显然，特征越明显，我们越容易对其进行辨识。

问题2，什么是数据特征

　　数据特征，就是说，某段数据具有的特征。

　　　　比如，通迅的双方（A <-> B ），在建立连接后，A发给B的第一个包，长度总是固定的，有时候甚至值都是固定的(在协议握手阶段尤其如此)。 

问题3，为什么要去掉这些特征

　　我们在讲网络安全的时候，绝大部分的人能想到数据加密，然而仅仅加密还不足于保护我们的。下面我举几个例子。

　　　　1，某FW在对数据包进行检测的时候，可以通过特征的学习及辨识去决定要不要reset这个连接。

　　　　2，浏览网站时产生的流量数据，带有明显的网页字节数特征，通过对这个特征的学习，第三方可以大概知道浏览网站的人都访问过哪些网站，甚至知道访问了哪些页面。 

问题4，怎么去数据特征

　　通过粗略的分析，我们至少有两个办法可以使数据特征不明显。

　　　　1，改变数据长度。主要通过在数据流中加入一些随机长度的随机值。

　　　　2，通过增加冗余位，增加数据中具体位的随机性。 

一种冗余位Obfuscate方案

　　我们知道一个字节通常由8个bit组成。确定的值，它的bit平面（低位到高位所呈现的0101序列）总是确定的。如果我们让这个确定变成不确定，我们的目的就达成了。

　　下面，我介绍一个简单的通过冗余位达到混扰的目的。

　　以uint8_t -> uint32_t 为实例进行一个大概的算法描述　　

　　uint8_t 　　占8bit

　　uint32_t 　 占32bit　　

　　uint8_t中

　　　　01位置于uint32_t 第一个byte，

　　　　23位置于uint32_t第二个byte,

　　　　45位置于uint32_t第三个byte,

　　　　67位置于uint32_t第四byte

 

　　　　具体的算法：

　　　　　取uint32_t中每个byte的高3位，得到一个数值p, p mod 5 = z, z就是这个byte中起始有效bit位,从这个位开始，顺序存储(从底位到高位)2个uint8_t中的位 （见下图）

 　　

　　

 C代码实现

//UINT_X's width must be less than sizeof(uint32_t), it can be uint8_t or , uint16_t
template <typename UINT_X>
inline static uint32_t obfuscate(UINT_X const& val, uint32_t const& r_u32) {
	if (sizeof(uint32_t) <= sizeof(UINT_X)) return val;
	uint32_t rr = 0;
	uint8_t b[sizeof(UINT_X) * 8];
	uint8_t bii[sizeof(UINT_X) * 8];

	//per bytes contain bit count
	uint8_t pbcbc = (sizeof(UINT_X) * 8) / (sizeof(uint32_t) / sizeof(uint8_t));

	for (int i = 0; i < (sizeof(UINT_X) * 8); i++) {
		if ((i%pbcbc) == 0) {
			b[i] = ((r_u32 >> ((5 + ((i / pbcbc) << 3))) & 0x7) % 5) & 0xFF;
			bii[i] = b[i];
		} else {
			b[i] = ((b[i - 1] + 1) % 5);
			bii[i] = bii[i - 1];
		}

		uint8_t bi = 0;
		if (val&(0x01 << i)) {
			bi |= (0x01 << b[i]);
		}
		bi |= ((0x7 & bii[i]) << 5);
		rr |= ((0xFFFFFFFF & bi) << ((i / pbcbc) << 3));
	}
	return rr;
}

template <typename UINT_X>
inline static UINT_X deobfuscate(uint32_t const& val) {
	UINT_X r = 0;
	uint8_t pbcbc = (sizeof(UINT_X) * 8) / (sizeof(uint32_t) / sizeof(uint8_t));
	UINT_X b[sizeof(UINT_X) * 8];

	for (int i = 0; i < (sizeof(UINT_X) * 8); i++) {
		if ((i%pbcbc) == 0) {
			b[i] = ((val >> ((5 + ((i / pbcbc) << 3))) & 0x7) % 5) & 0xFF;
		} else {
			b[i] = ((b[i - 1] + 1) % 5);
		}
		r |= (((val >> (b[i] + ((i / pbcbc) << 3))) & 0x1) << i);
	}
	return r;
}

namespace wawo { namespace security {
	inline static uint32_t u8_obfuscate(uint8_t const& val, uint32_t const& r_u32) {
		return obfuscate<uint8_t>(val,r_u32);
	}
	inline static uint32_t u16_obfuscate(uint16_t const& val, uint32_t const& r_u32) {
		return obfuscate<uint16_t>(val, r_u32);
	}
	inline static uint8_t u8_deobfuscate(uint32_t const& val) {
		return deobfuscate<uint8_t>(val);
	}
	inline static uint16_t u16_deobfuscate(uint32_t const& val) {
		return deobfuscate<uint16_t>(val);
	}
}}