模糊处理的ID [英] Obfuscating an ID

问题描述

我在寻找一种方式来加密/混淆的整数ID到另一个整数。更多precisely，我需要一个函数 INT F（INT X），使

I'm looking for a way to encrypt/obfuscate an integer ID into another integer. More precisely, I need a function int F(int x), so that

• X - LT; - > F（x）是一对一一对应（！如果X = Y，F（X）= F（Y））
• 在给定的F（X），可以很容易地找出x - 所以F是不是一个散列函数
• 在给定的x和F（X）是硬/不可能找出F（Y），像 X ^ 0×1234 将无法正常工作

• x<->F(x) is one-to-one correspondence (if x != y, F(x) != F(y))
• given F(x), it's easy to find out x - so F is not a hash function
• given x and F(x) it's hard/impossible to find out F(y), something like x ^ 0x1234 won't work

为了清楚起见，我不是在寻找一个强大的加密解决方案，它只是混淆。想象一下，一个Web应用程序的URL，比如 example.com/profile/1 ， example.com/profile/2 等。该配置文件本身并不是秘密，但我想prevent休闲偷窥查看/读取所有配置了一个又一个，所以我宁愿躲在他们身后像 example.com/profile / 23423 ， example.com/profile/80980234 等虽然数据库存储的令牌可以做的工作很容易，我很好奇，如果有一些简单的数学适用于此。

For clarity, I'm not looking for a strong encryption solution, it's only obfuscation. Imagine a web application with urls like example.com/profile/1, example.com/profile/2 etc. The profiles themselves are not secret, but I'd like to prevent casual voyeurs to view/fetch all profiles one after another, so I'd rather hide them behind something like example.com/profile/23423, example.com/profile/80980234 etc. Although database-stored tokens can do the job quite easily, I'm curious if there's some simple math available for this.

一个重要的要求我并不清楚的是，结果应该是随机，即给定顺序 X，X + 1，...，X + N ， F（X），F（X + 1）... F（X + N）不应成为任何类型的进展。

One important requirement I wasn't clear about is that results should look "random", that is, given a sequence x,x+1,...,x+n , F(x),F(x+1)...F(x+n) shouldn't form a progression of any kind.

推荐答案

2或3个简单的方法的一些组合迷惑我们：

Obfuscate it with some combination of 2 or 3 simple methods:

• XOR
• 在洗牌各个位
• 转化为模块化再presentation（D.Knuth，第2卷，第4.3.2）
• 选择32（或64）重叠比特和异位的子集，每个子​​集（子集的奇偶校验位）
• 重新present它的可变长度数字小系统和随机播放数字
• 选择一对奇数的 X 和是互为（模2 <的乘法逆SUP > 32 ），然后乘以 X 来混淆和乘是来恢复，所有的乘法是模2 ³² （来源：的一个实际应用乘法逆由Eric利珀特）
的

• XOR
• shuffle individual bits
• convert to modular representation (D.Knuth, Vol. 2, Chapter 4.3.2)
• choose 32 (or 64) overlapping subsets of bits and XOR bits in each subset (parity bits of subsets)
• represent it in variable-length numberic system and shuffle digits
• choose a pair of odd integers x and y that are multiplicative inverses of each other (modulo 2³²), then multiply by x to obfuscate and multiply by y to restore, all multiplications are modulo 2³² (source: "A practical use of multiplicative inverses" by Eric Lippert)

可变长度的数字小系统的方法不服从自己的进步的要求。它总是产生短期算术级数。但是，当与其他方法结合，它提供了良好的效果。

Variable-length numberic system method does not obey your "progression" requirement on its own. It always produces short arithmetic progressions. But when combined with some other method, it gives good results.

也是如此用于模块化重新presentation方法

The same is true for the modular representation method.

下面是C ++ $ C 3这些方法$ C例子。随机比特例如可以使用一些不同的面具和距离更未predictable。其他的两个例子是不错的，对于小数目（只是为了让这个想法）。他们应该扩展到正确混淆所有整数值。

Here is C++ code example for 3 of these methods. Shuffle bits example may use some different masks and distances to be more unpredictable. Other 2 examples are good for small numbers (just to give the idea). They should be extended to obfuscate all integer values properly.

// *** Numberic system base: (4, 3, 5) -> (5, 3, 4)
// In real life all the bases multiplied should be near 2^32
unsigned y = x/15 + ((x/5)%3)*4 + (x%5)*12; // obfuscate
unsigned z = y/12 + ((y/4)%3)*5 + (y%4)*15; // restore

// *** Shuffle bits (method used here is described in D.Knuth's vol.4a chapter 7.1.3)
const unsigned mask1 = 0x00550055; const unsigned d1 = 7;
const unsigned mask2 = 0x0000cccc; const unsigned d2 = 14;

// Obfuscate
unsigned t = (x ^ (x >> d1)) & mask1;
unsigned u = x ^ t ^ (t << d1);
t = (u ^ (u  >> d2)) & mask2;
y = u ^ t ^ (t << d2);

// Restore
t = (y ^ (y >> d2)) & mask2;
u = y ^ t ^ (t << d2);
t = (u ^ (u >> d1)) & mask1;
z = u ^ t ^ (t << d1);

// *** Subset parity
t = (x ^ (x >> 1)) & 0x44444444;
u = (x ^ (x << 2)) & 0xcccccccc;
y = ((x & 0x88888888) >> 3) | (t >> 1) | u; // obfuscate

t = ((y & 0x11111111) << 3) | (((y & 0x11111111) << 2) ^ ((y & 0x22222222) << 1));
z = t | ((t >> 2) ^ ((y >> 2) & 0x33333333)); // restore

这篇关于模糊处理的ID的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！