2

Using: Python 3.2.3, scrypt 0.5.5 module, Ubuntu 12.04

I installed the scrypt module fine. I ran the sample code on the page fine. I also found an expanded version of the sample code, which did fine too. But I wanted to test if it would hash the same word twice, so I added a section call to Encrypt(), to simulate the concept of hashing it once for the DB and then hashing again when a user logs in, so my full code looks like this:

import random,scrypt

class Encrypt(object):

    def __init__(self):
        pass

    def randSTR(self,length):
        return ''.join(chr(random.randint(0,255)) for i in range(length))

    def hashPWD(self,pwd, maxtime=0.5, datalength=64):
        return scrypt.encrypt(self.randSTR(datalength), pwd, maxtime=maxtime)

    def verifyPWD(self,hashed_password, guessed_password, maxtime=0.5):
        try:
            scrypt.decrypt(hashed_password, guessed_password, maxtime)
            return True
        except scrypt.error:
            return False

if __name__ == '__main__':
    e = Encrypt()
    user_pw = 'theansweris42'
    user_salt = 't9'
    pw_salt = user_pw + user_salt
    hashed_pw = e.hashPWD(pw_salt) # To be stored len()==192
    y = e.verifyPWD(hashed_pw, pw_salt)              # True
    n = e.verifyPWD(hashed_pw, 'guessing'+ pw_salt)  # False
    print(y)
    print(n)
    #print("Hash: %s" % (hashed_pw))

    x = Encrypt()
    user_pw2 = 'theansweris42'
    user_salt2 = 't9'
    pw_salt2 = user_pw2 + user_salt2
    hashed_pw2 = x.hashPWD(pw_salt2) # To be stored len()==192
    y2 = x.verifyPWD(hashed_pw, hashed_pw2)              # True
    print(y2)
    print(pw_salt)
    print(pw_salt2)
    print(hashed_pw)
    print(hashed_pw2)

...as you can see, I also hard coded the salt (for testing). Strangely, everytime I run this, the hashed_pw & hashed_pw2 are always different. Why is this hashing the same password differently each time? Shouldn't it be outputting the same hash each time I give it the exact same input? I've been trying to figure this out for an hour, so I figure I better ask.

Zamphatta
  • 4,634
  • 8
  • 30
  • 34

1 Answers1

0

You encrypt two different random strings with the same password (plus a salt). This will result in two different outputs.

The trick used here is that the password + salt can be used to decrypt that random string, while the incorrect password will raise an error. Hence, you don't need to store the original random string to make sure that the password was correct, and since the string used was random (within the limits of the random number generator) it's going to be extremely hard to crack the password.

Lennart Regebro
  • 167,292
  • 41
  • 224
  • 251
  • I think I'm not understanding something. I'm a bit new to this, so I apologize if I'm asking something 'stupid', but... How am I encrypting two different random strings? Isn't it hashing the string `theansweris42t9` both times? That string is the value of both `pw_salt` & `pw_salt2`, so when I hash them, it should output the same value, right? – Zamphatta Aug 06 '12 at 12:27
  • Also, I have to store something (hashed pwd & salt?) in the DB, in order to compare it later when a user logs in, right? – Zamphatta Aug 06 '12 at 12:34
  • @Zamphatta: No, the string you are encrypting is self.randSTR(datalength). And yes, you need to store the hash and the salt. But you don't compare anything, you just decrypt the stored hash with the password and the salt. – Lennart Regebro Aug 06 '12 at 13:13
  • Oohhh I see now. Wow, this is totally different than I was thinking. I love it! I was thinkin' I had to hash the pwd & salt, store it in the DB, then when a user logs in, I rehash the pwd & salt in order to compare it to the stored value in the DB. So I was gettin' confused & I wasn't understanding. That's how I used to do it & I assumed that was the only logical way. I like this way better than what I used to do. Thanks Lennart! – Zamphatta Aug 06 '12 at 14:12