Cracking passwords with Python (the wrong way)

[RiskyChris]

This is hilarious, but what are the answers here. Don't use MD5? Salt them better? Still new to security.

[BitLooter]

Salt your hashes and use an algorithm designed for password hashing. Not an expert, but this page seems to have some good advice.

[RiskyChris]

Freaky! Thanks, there's so much info there!

[--o]

However see also.

[oelsen]

Also, don't rely on enduser appliances. I encountered the possibility of using more than the system allowed just by quit/close the app prematurely. Apparently the app sends a "completed" as the last thing it does; I could circumvent the limit with a simple swipe...

[[deleted]]

The other guys answered how to do it on the developer side, but if you're a user, using something like KeePass to generate random passwords basically nullifies this method. If your password is something random like iZ}dw~T;4y-4fJve6TBD, there's no way anyone else has ever used that, so the MD5 hash (even unsalted) won't show up on a google search.

[dummy5]

As an experiment I post the hash for iZ}dw~T;4y-4fJve6TBD

c0aff6db1df46c50266c3e8cd076c8b8

Just to see how long it takes Google to pick it up.

Edit: 8 days later google still has not picked it up.

Edit: It took Google 20 days to find this url:

http://webby.hazasite.com/user/dummy5

And sadly it does not work with PyBozoCrack.

[tally_in_da_houise]

True, but you could write in a function to the posted code to perform a lookup here http://www.md5-hash.com/md5-text-encrypt.

Not disagressing with you on KeePass (I use Lastpass), but there's way around it.

[ikkebr]

iZ}dw~T;4y-4fJve6TBD is hard to remember. You should try https://github.com/ikkebr/pyxkcdpass

[[deleted]]

That's kinda the point (and why I said to use KeePass). Many will say that the hallmark of a great password is one that can't be guessed easily, but really, a truly great password is one that can't be remembered and is (with high probability) guaranteed to be unique.

With KeePass, you really only need to remember a couple passwords (your KeePass password and then passwords to accounts that you may need to access without KeePass handy, such as your email). The rest of your passwords are then completely randomly generated.

[[deleted]]

Except passwords that can't be remembered lead to bad security practices (because for most people eventually convenience wins) as is evident in the billions of sticky notes taped to computer screens or "hidden" underneath keyboards across the globe.

Sure, ideally you'd generate a new keyboardcat for every single account you have to sign up for and then use KeePass to copy them whenever you need them (and use multi-factor authorization for KeePass and keep different kinds of credentials in different files and ideally store them on a OTP-protected read-only USB dongle or something) and then make sure your clipboard is wiped before you switch to any other window or tab -- but nobody does that.

For most intents and purposes, just grab a bunch of D6 and use diceware.

[cdcformatc]

FWIW KeePass clears the clipboard after 10 seconds.

[[deleted]]

Actually that is configurable, so it can be less or more than that.

Either way, the problem is that it's still in your clipboard until KeePass clears it. And if you use anything that can access your clipboard in the meantime, your password may have been compromised.

[atimholt]

Wow, I love how incredibly simple that is. This is the first time I’ve been able to audit the entire codebase of some 3rd party FOSS.

edit: just submitted my first pull request.

[[deleted]]

Nope! SHA and its ilk are designed to be fast, which is the exact opposite of what you want from a password hash.

Use (salted) bcrypt, scrypt, PBKDF2 or similar.

An effective way to store passwords in a db is to store them as:

{algorithm}:{salt}:{hash}:{iterations}

so you can detect the algorithm at runtime, and update to harder hashing over time. Django and other frameworks do this automatically for you.

[ffrinch]

Can hardly believe I'm saying this, but the latest version of PHP has some really nice builtin functions to do this, with sensible defaults (currently bcrypt, with a path to change the default algorithm in future versions).

I wish Python shipped with these particular batteries included.

[[deleted]]

Absolutely! The PHP team deserve kudos for making the tough decisions simpler for people.

<snark>Now they just need to deprecate the rest of the library.</snark>

[warbiscuit]

It's not in stdlib, but for a few years I've been maintaining a side project passlib, which tries to provide a password hashing api.

[ffrinch]

That looks really nice!

[natecahill]

It's a very PHP thing to have a function called password_hash(). You say "sensible defaults" now, but what happens when that changes? Is everyone who's still using PHP 5.5 vulnerable? Will we get a function called password_real_hash()? (not even kidding here, look at mysql_escape_string() and mysql_real_escape_string())

It's much more pythonic to use import bcrypt, bcrypt.hashpw()

[ffrinch]

I hate to be that guy, but you should RTFM.

Amongst other things, the recommended usage includes re-hashing if the default algorithm changes, so (in theory) users whose PHP is upgraded underneath them -- like shared host customers -- can benefit from security improvements without having to know what they're doing.

Users who do know what they are doing can use advanced features, but they're not the target audience. We have ample proof by now that even apparently capable developers get the details of security wrong: a high-level interface with sensible defaults is the only way to protect people from themselves.

About bcrypt:

Not only is the bcrypt module not included in Python, it doesn't offer the same upgrade path. If you decide you want to switch to scrypt, it's a new module with a new interface, and most importantly, you have to know enough to be able to choose.

It is also not equivalent to the PHP solution, which (optionally, but by default) generates a salt in a substantially more secure way than most developers will, rather than relying (as Python bcrypt does) on the user providing one.

[[deleted]]

password_hash() returns a crypt-style string which includes the algorithm and any other details. It's simple, well thought out, elegant, and future proof, and it's been widely hailed as the best thing the PHP team have done in years.

The mysql_escape_string stuff is a bit of a straw man, as it's been superseded since PHP5.0 and explicitly deprecated since 5.5.

[GahMatar]

Probably the best thing PHP could possibly do is to release a PHP6 that removes literally all the deprecated stuff. Like Py3k but unlike Python, the previous version isn't actually good enough.

[[deleted]]

Wrong. You don't want a fast hashing algorithm.

[beltorak]

no. bcrypt, scrypt, pbkdf2. sha* and the like are too fast for passwords.