我应该使用==进行字符串比较吗

Question

如果这是一个奇怪的问题，很抱歉。

事实上，我对定时攻击很好奇，所以我做了一些研究并理解了这个概念。我明白了，代码像：

if token == password:
print('Welcome')
else:
print('Wrong password')

相当于：

def equal(s1, s2):
if len(s1) != len(s2):
return False
for i in range(len(s1)):
if s1[i] != s2[i]:
return False
return True

PS-我使用的是python 3.9.2

所以我制作了一个易受攻击的代码，看起来像这样：-

f = open('pass.txt', 'r')
password = f.read()
f.close()
def equal(s1, s2):
if len(s1) != len(s2):
return False
for i in range(len(s1)):
if s1[i] != s2[i]:
return False
return True
def login(upass):
if equal(upass, password):
print('Login successful')
else:
print('Login failed')
login()

这个简单的程序将用户给定的密码(通过upass参数(与存储在同一目录中的文件pass.txt中的密码进行比较。如果密码匹配，它将向用户发送欢迎消息，否则，它将提醒用户登录失败。

假设：-

1. 密码长度为4个字符
2. 它只是大写字母(没有数值或特殊字符(

我能够通过使用以下方法利用密码：-

def attack():
leaked = ''
for i in range(4):
result = { letter : 0 for letter in ascii_uppercase }
for _ in range(50000):
for letter in ascii_uppercase:
string = leaked + letter + '.' * ( 4 - len(leaked) - len(letter) )
start = time_ns()
login(string)
end = time_ns()
result[letter] += end - start
leaked += sorted(result.items(), key = lambda item : item[1], reverse=True)[0][0]
print(leaked)

我得到的输出是TEST，这是正确的。然而，您可以清楚地看到，我并没有使用==进行字符串比较，实际上我使用的是它的等效方法。所以我决定切换回==并检查我的漏洞是否有效。所以我将equal()方法修改为：-

def equal(s1, s2):
# if len(s1) != len(s2):
#   return False
# for i in range(len(s1)):
#   if s1[i] != s2[i]:
#       return False
# return True
if s1 == s2:
return True
else:
return False

因此，使用这段代码，当我调用attack方法时，令我惊讶的是，它给了我非常奇怪的结果。当我多次运行它时，得到了以下输出：AOAD、BVCB&LGAZ。这显然不是pass.txt文件中存储的密码。

所以我的问题是，==不容易受到定时攻击吗？

Answer 1

TL；DR 是的，它很脆弱然而，您仍然应该使用==进行比较，因为这是最好的东西。

---

str.__eq__()的实现是否容易受到定时攻击很容易验证。让我们这样定义四个字符串：

import random
# Lots of random characters from A to Z
s1 = ''.join(chr(random.randint(65, 90)) for _ in range(1000000))

s1c = s1                      # This string is equal and at the same memory location
s2 = ''.join(c for c in s1)   # This string is equal but not at the same memory loc
s3 = s1[:-1] + "?"            # This is not equal because of a mismatch at the end
s4 = "?" + s1[1:]             # This is not equal because of a mismatch at the start
s5 = s1[:-1000]               # This is not equal because of mismatched lengths

为了对相等性检查进行计时，我们可以使用timeit模块。

import timeit
t1_1c = timeit.timeit('s1 == s1c', 'from __main__ import s1, s1c', number=10000)
t1_2  = timeit.timeit('s1 == s2', 'from __main__ import s1, s2', number=10000)
t1_3  = timeit.timeit('s1 == s3', 'from __main__ import s1, s3', number=10000)
t1_4  = timeit.timeit('s1 == s4', 'from __main__ import s1, s4', number=10000)
t1_5  = timeit.timeit('s1 == s5', 'from __main__ import s1, s5', number=10000)

我得到以下数字：

值

变量
t1_1c	0.0003349999997226405
t1_2	0.7978945999993812
t1_3	0.7638719000005949
t1_4	0.00111733000001186156
t1_5	0.0003372000001036213

半有用的答案：我不确定==的内部实现，但一般来说：随着区分两个值是否相等的操作越来越多，该方法就越容易受到定时攻击。所以在你的例子中，CCD_；从两个值中逐个取字符，然后比较"；，它在引擎盖下肯定会扩展到更多的操作，而不仅仅是"；取两个存储器位置并判断从那里开始的X个字节是否相等"；(我想==或多或少在做这件事(。"；取出字符X"；这里很贵(我想(。

我认为你只是证明了它并不脆弱^^