使用所有字符串获取相同的sha1哈希

Question

I have a script that opens a file, looks for anything that has HASH("<stuff>") and replaces it with HASH(<sha1(stuff)>)

The entirety of the script is this:

import sys
import re
import hashlib

def _hash(seq, trim_bits=64):
    assert trim_bits % 8 == 0
    temp = hashlib.sha1(seq).hexdigest()
    temp = int(temp, 16) & eval('0x{}'.format('F' * (trim_bits/4)))
    temp = hex(temp)
    return str(temp[2:]).replace('L', '')

if __name__ == '__main__':
    assert len(sys.argv) == 3
    in_file = sys.argv[1]
    out_file = sys.argv[2]
    with open(in_file, 'r') as f:
        lines = f.readlines()
        out_handle = open(out_file, 'w')
        for line in lines:
            new_line = re.sub(r'HASH\((["\'])(.*?)\1\)', 'HASH({})'.format(_hash(r'\2')), line)
            out_handle.write(new_line)
        out_handle.close()

When I run this however, all of the sha1 hashes become the exact same which doesn't make sense to me. If instead of writing the hash I switch it with HASH({}).format(r'\\2') it will replace it with the sequence of characters in between double quotes. So why does the sha1 hash return the same string?

Answer 1

You are calculating the hash for the string r'\\2' ; the re module would only replace that placeholder when you use that as the replacement string, but you are not doing that here.

Pass in the group from the match object instead, using a replacement function:

def replace_with_hash(match):
    return 'HASH({})'.format(_hash(match.group(2)))

new_line = re.sub(r'HASH\((["\'])(.*?)\1\)', replace_with_hash, line)

The replace_with_hash() function is passed the match object, and its return value is used as the replacement. Now you can calculate the hash for the 2nd group!

Demo:

>>> import re
>>> def _hash(string):
...     return 'HASHED: {}'.format(string[::-1])
... 
>>> sample = '''\
... HASH("<stuff>")
... '''
>>> re.sub(r'HASH\((["\'])(.*?)\1\)', 'HASH({})'.format(_hash(r'\2')), sample)
'HASH(HASHED: 2\\)\n'
>>> def replace_with_hash(match):
...     return 'HASH({})'.format(_hash(match.group(2)))
... 
>>> re.sub(r'HASH\((["\'])(.*?)\1\)', replace_with_hash, sample)
'HASH(HASHED: >ffuts<)\n'

My _hash() function simply reverses the input string to show what happens.

The first re.sub() is your version; notice how it returns '2\\\\' , so r'\\2' reversed! My version neatly hashes <stuff> to >futts< .