整数 algorithm/method 的对称密码
Symmetric cipher for integer algorithm/method
我正在寻找可以使用的双射变换不是用于加密，而是用于混淆。这个想法是采用 1, 2, 3, 4 之类的整数并将它们投影到另一个轴上。主要思想是在域 B.
中投影时，确保来自域 A 的两个相邻整数之间的最大距离
我在 Python 中写了以下内容，但目标语言将是 PHP。我不介意实施，只有 algorithm/method 很重要。
n = 8 示例：
A B
0 <-> 4
1 <-> 5
2 <-> 6
3 <-> 0
4 <-> 2
5 <-> 7
6 <-> 3
7 <-> 1
一个天真的实现是建立一个随机的一对一对应 table 然后用作 O(1) 转换函数。
a = func(0) # a = 4
b = func(a) # b = 0
最高效的算法
最有效的算法包括构建一个散列-table，它需要 O(n) 内存并在 O(1)[ 中执行=50=]。
class Shuffle:
def __init__(self, n, seed=42):
self._table = list(range(n))
random.seed(seed)
random.shuffle(self._table)
def enc(self, n):
return self._table[n]
def dec(self, n):
return self._table.index(n)
不幸的是，我正在寻找一种更轻便或更简单的算法。
愚蠢的尝试
有趣的部分来了，因为我曾尝试使用一次性密码本 (OTP)、一些对称加密算法 (Blowfish)，但都没有成功。最终我尝试了一种愚蠢有趣的幼稚实现：
def enigma(input): # Because why not?
a = deque([1, 3, 0, 4, 2])
b = deque([3, 0, 4, 2, 1])
u = [0 for i in range(len(input))]
for i, c in enumerate(input):
u[i] = a.index(b.index([4, 3, 2, 1, 0][b[a[c]]]))
a.rotate(1)
b.rotate(3)
return u
def shuffle(n, seed=81293): # Because enigma is not enough
random.seed(seed)
serie = list(range(len(n)))
random.shuffle(serie)
for i, j in enumerate(serie):
n = n.copy()
n[i], n[j] = n[j], n[i]
return n
def int2five(decimal): # Base 10 -> Base 5
radix = 5
s = [0 for i in range(9)]
i = 0
while (decimal):
s[i] = decimal % radix
decimal = decimal // radix
i += 1
return list(reversed(s))
def five2int(five): # Base 5 -> Base 10
return int(''.join([str(x) for x in five]), 5)
def enc(n):
return five2int(enigma(shuffle(int2five(n))))
def dec(s):
return five2int(shuffle(enigma(int2five(s))))
结果为：
>>> ['%d <-> %d' % (i, enc(i)) for i in range(7)]
['0 <-> 1729928',
'1 <-> 558053',
'2 <-> 1339303',
'3 <-> 948678',
'4 <-> 167428',
'5 <-> 1729943',
'6 <-> 558068']
我为什么选择base 5？我选择我的工作范围为 [0..2e6[，因此通过查看最佳基数来最大化覆盖范围（是的，以下代码很丑陋）：
>>> [(d, l, s, 100 - round(s/n*100,1)) for (d, l, s) in sorted([(k, round(math.log(n, k), 3), n - k**(math.floor(math.log(n, k))) - 1)
for k in range(2, 100)], key=lambda k: k[2])[0:10]]
[(5, 9.015, 46873, 97.7),
(18, 5.02, 110430, 94.5),
(37, 4.018, 125837, 93.7),
(11, 6.051, 228437, 88.6),
(6, 8.097, 320382, 84.0),...]
我注意到基数 5 可以用 9 位数字表示，覆盖范围为 97%。第二好的候选者是 base 18，覆盖率为 94%。
就好像你要用一个Format-Preserving Encryption here and a good one is FFX from Mihir Bellare (white paper here).
如您所见，您找不到任何基于旋转的简单算法，可以将输入域X映射到Y，[=16] =] 对于 f: X->Y 和 X 在任何范围 [x0..xn]。
使用这种保留加密的格式，您需要将范围指定为：
range = radix ** exponent - 1
在您的例子中，您选择了基数 5 和 9 作为指数。
使用 FFX 加密
对于实施，您可以使用 pyffx，Feistel-based 加密 (FFX) 的实施。
class Five(pyffx.String):
def __init__(self, ffx, length, **kwargs):
super(Five, self).__init__(ffx, '01234', length, **kwargs)
def pack(self, v):
return super(Five, self).pack(str(v).zfill(self.length))
def unpack(self, v, t):
return int(super(Five, self).unpack(v, t))
然后
>>> import pyffx
>>> radix, exponent = 5, 9
>>> e = Five(b'secret', exponent)
>>> e.encrypt(123)
321301321
任意域加密
如前所述，FFX 仅对 radix ** exponent - 1 指定的域中的数据进行加密。如果您想在任意域上加密，可以使用名为 Cycle Walking 的方法，描述为：
def cycle_walking (x, encipher) {
if encipher(x) is an element of M
return encipher(x)
else
return cycle_walking(encipher(x))
}
为此，您需要使用严格大于目标域 M 的域 N。
我正在寻找可以使用的双射变换不是用于加密，而是用于混淆。这个想法是采用 1, 2, 3, 4 之类的整数并将它们投影到另一个轴上。主要思想是在域 B.
A 的两个相邻整数之间的最大距离
我在 Python 中写了以下内容，但目标语言将是 PHP。我不介意实施，只有 algorithm/method 很重要。
n = 8 示例：
A B
0 <-> 4
1 <-> 5
2 <-> 6
3 <-> 0
4 <-> 2
5 <-> 7
6 <-> 3
7 <-> 1
一个天真的实现是建立一个随机的一对一对应 table 然后用作 O(1) 转换函数。
a = func(0) # a = 4
b = func(a) # b = 0
最高效的算法
最有效的算法包括构建一个散列-table，它需要 O(n) 内存并在 O(1)[ 中执行=50=]。
class Shuffle:
def __init__(self, n, seed=42):
self._table = list(range(n))
random.seed(seed)
random.shuffle(self._table)
def enc(self, n):
return self._table[n]
def dec(self, n):
return self._table.index(n)
不幸的是，我正在寻找一种更轻便或更简单的算法。
愚蠢的尝试
有趣的部分来了，因为我曾尝试使用一次性密码本 (OTP)、一些对称加密算法 (Blowfish)，但都没有成功。最终我尝试了一种愚蠢有趣的幼稚实现：
def enigma(input): # Because why not?
a = deque([1, 3, 0, 4, 2])
b = deque([3, 0, 4, 2, 1])
u = [0 for i in range(len(input))]
for i, c in enumerate(input):
u[i] = a.index(b.index([4, 3, 2, 1, 0][b[a[c]]]))
a.rotate(1)
b.rotate(3)
return u
def shuffle(n, seed=81293): # Because enigma is not enough
random.seed(seed)
serie = list(range(len(n)))
random.shuffle(serie)
for i, j in enumerate(serie):
n = n.copy()
n[i], n[j] = n[j], n[i]
return n
def int2five(decimal): # Base 10 -> Base 5
radix = 5
s = [0 for i in range(9)]
i = 0
while (decimal):
s[i] = decimal % radix
decimal = decimal // radix
i += 1
return list(reversed(s))
def five2int(five): # Base 5 -> Base 10
return int(''.join([str(x) for x in five]), 5)
def enc(n):
return five2int(enigma(shuffle(int2five(n))))
def dec(s):
return five2int(shuffle(enigma(int2five(s))))
结果为：
>>> ['%d <-> %d' % (i, enc(i)) for i in range(7)]
['0 <-> 1729928',
'1 <-> 558053',
'2 <-> 1339303',
'3 <-> 948678',
'4 <-> 167428',
'5 <-> 1729943',
'6 <-> 558068']
我为什么选择base 5？我选择我的工作范围为 [0..2e6[，因此通过查看最佳基数来最大化覆盖范围（是的，以下代码很丑陋）：
>>> [(d, l, s, 100 - round(s/n*100,1)) for (d, l, s) in sorted([(k, round(math.log(n, k), 3), n - k**(math.floor(math.log(n, k))) - 1)
for k in range(2, 100)], key=lambda k: k[2])[0:10]]
[(5, 9.015, 46873, 97.7),
(18, 5.02, 110430, 94.5),
(37, 4.018, 125837, 93.7),
(11, 6.051, 228437, 88.6),
(6, 8.097, 320382, 84.0),...]
我注意到基数 5 可以用 9 位数字表示，覆盖范围为 97%。第二好的候选者是 base 18，覆盖率为 94%。
就好像你要用一个Format-Preserving Encryption here and a good one is FFX from Mihir Bellare (white paper here).
如您所见，您找不到任何基于旋转的简单算法，可以将输入域X映射到Y，[=16] =] 对于 f: X->Y 和 X 在任何范围 [x0..xn]。
使用这种保留加密的格式，您需要将范围指定为：
range = radix ** exponent - 1
在您的例子中，您选择了基数 5 和 9 作为指数。
使用 FFX 加密
对于实施，您可以使用 pyffx，Feistel-based 加密 (FFX) 的实施。
class Five(pyffx.String):
def __init__(self, ffx, length, **kwargs):
super(Five, self).__init__(ffx, '01234', length, **kwargs)
def pack(self, v):
return super(Five, self).pack(str(v).zfill(self.length))
def unpack(self, v, t):
return int(super(Five, self).unpack(v, t))
然后
>>> import pyffx
>>> radix, exponent = 5, 9
>>> e = Five(b'secret', exponent)
>>> e.encrypt(123)
321301321
任意域加密
如前所述，FFX 仅对 radix ** exponent - 1 指定的域中的数据进行加密。如果您想在任意域上加密，可以使用名为 Cycle Walking 的方法，描述为：
def cycle_walking (x, encipher) {
if encipher(x) is an element of M
return encipher(x)
else
return cycle_walking(encipher(x))
}
为此，您需要使用严格大于目标域 M 的域 N。