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

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

半有用的答案：我不确定== 的内部实现，但作为一般规则：随着越来越多的操作发生来区分两个值是否相等，该方法更容易受到定时攻击.因此，在您的示例中，equal 方法除了其他内容外，还“从两个值中逐个字符地获取，然后进行比较”，这在幕后肯定会扩展到更多的操作，而不仅仅是“获取两个内存位置并判断 X从那里开始的字节是相等的”（我猜== 或多或少在做）。 “取出字符 X”在这里很贵（我猜）。

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

Answer 2

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)

我得到以下数字：

Variable	Value
t1_1c	0.0003349999997226405
t1_2	0.7978945999993812
t1_3	0.7638719000005949
t1_4	0.0011733000001186156
t1_5	0.0003372000001036213

显然，同一内存位置的字符串报告它们几乎立即相等，但我们不希望在现实情况下会出现这种情况。 开始时有错误的字符串报告“不等于”的时间比最后有错误的字符串要少几个数量级，因此我认为您的发现并不广泛适用。这可能是版本/操作系统问题，或者 TEST 字符串太短，无法真正注意到这些问题。

---

也许改变不匹配的位置会提供一些见解？这么长的字符串似乎有点过头了，所以我要把它的大小缩小一个数量级

s1 = ''.join(chr(random.randint(65, 90)) for _ in range(100000))

timings = []
for i in range(len(s1)):
    # Force a mismatch at index i
    s_temp = s1[0:i] + "?" + s1[i+1:]
    tm = timeit.timeit('s1 == s_temp', 'from __main__ import s1, s_temp', number=100)
    print(f"\r{i/len(s1)*100:.2f}".ljust(20, " "), end="")
    timings.append(tm)

根据不匹配的位置绘制它会得到以下（绝对不是恒定的）图：

红点是字符串相等（没有不匹配）。很明显，不匹配的字符串越往下，相等检查所需的时间就越长。如果我们将传播归因于我的计算机也在处理其他事情这一事实，并且只看这个形状的下边缘，它看起来相当线性（y 轴是对数，线性轴 here 如果你愿意），因此，str.__eq__() 方法根据需要检查的字符数量在线性时间内运行这一论点会增加一些分量。

---

总结一下，

1. 不，== 或 str.__eq__() 方法对计时攻击不安全。您的密码"TEST" 太小，无法看到比较时间的影响。
2. 是的，您应该使用== 进行字符串比较，因为这是检查字符串相等性的正确方法。
3. 正如@MisterMiyagi 在comment 中所指出的那样，针对定时攻击的正确防御措施是强制您的响应延迟比处理长而错误的密码所需的时间更长而不是依赖其他操作来提供延迟。