Python 3.x 我应该使用==进行字符串比较吗？

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

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

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文件中的密码进行比较。如果密码匹配，则会向用户发送欢迎消息，否则会提醒用户登录失败

假设：-

密码长度为4个字符

它只有大写字母（没有数字值或特殊字符）

我可以使用以下方法利用密码：-

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

因此，当我调用

攻击

方法时，使用这段代码，出乎意料地得到了非常奇怪的结果。当我多次运行它时，得到了以下输出：

AOAD

，

BVCB

&

LGAZ

。这显然不是pass.txt文件中存储的密码

---

因此，我的问题是，

==

是否不易受到定时攻击？

半有用的回答：我不确定

==

的内部实现，但作为一般规则：随着越来越多的操作在区分这两个值是否相等，该方法就越容易受到定时攻击。因此，在您的示例中，

equal

方法在其他内容中执行“从两个值中逐个字符，然后进行比较”，这肯定比“获取两个内存位置并判断从那里开始的X字节是否相等”（我猜

=

或多或少是这样做的）要复杂得多。“外卖角色X”在这里很贵（我猜）

---

我想你只是证明它不是脆弱的^^

TL；DR是的，它很脆弱！但是，您仍然应该使用

=

进行比较，因为这是最好的方法

---

str.\uuuu eq\uuuu（）

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

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.0011733000001186156

t1_5

0.0003372000001036213

---

谢谢你的回复。我想你是对的。

==

的内部实现可能不同，这可以防止定时攻击。我会等一两天，如果我没有得到更好的答案，那么我会把这个标记为“正确”：D“我想你只是证明它不易受攻击^^^”他们没有！他们表明，测试一个4字节/32位的密码——足以同时容纳一个几十年前的CPU中的一个字——是很快的。这种情况对于定时攻击几乎毫无意义，因为它很容易被破解。您看到的主要是Python（第一个

equal

及其许多操作）比C（第二个

equal

主要使用内置操作）慢。C

equal

对于您的时钟来说太快了，无法准确测量结果与计算机自然延迟之间的差异。这对于一个很小的ASCII密码来说尤其如此，它可以立即进入CPU。无论哪种方式，对定时攻击的正确防御都不是希望某些实现定义的操作不是而且永远不会依赖于时间，而是完全从响应中消除时间。例如，估计比较密码所需的最长时间，并始终将响应延迟这么长时间，或添加随机延迟。感谢您的详细响应。这几乎解释了一切。