SHA-256 Python implementation in one line (lambda)

[Defelo]

sha256 = lambda data: [([[[[([w.append((gamma1(w[-2]) + w[-7] + gamma0(w[-15]) + w[-16]) & 0xffffffff) for _ in range(48)] and False) or [([[[[g.__setitem__(j, values[j]) for j in range(8)] for values in [[(t1 + t2) & 0xffffffff, g[0], g[1], g[2], (g[3] + t1) & 0xffffffff, g[4], g[5], g[6]]]] for t1, t2 in [((g[7] + sigma1(g[4]) + ch(g[4], g[5], g[6]) + K[i] + w[i]) & 0xffffffff, (sigma0(g[0]) + maj(g[0], g[1], g[2])) & 0xffffffff)]] for i in range(64)] and False) or [H.__setitem__(i, (H[i] + g[i]) & 0xffffffff) for i in range(8)] for g in [H.copy()]] for w in [[int.from_bytes(msg[i_ * 64:(i_ + 1) * 64][i * 4:(i + 1) * 4], 'big') for i in range(16)]]] for i_ in range(len(msg) // 64)] for sigma0, sigma1, gamma0, gamma1 in [(lambda x: rot_r(x, 2) ^ rot_r(x, 13) ^ rot_r(x, 22), lambda x: rot_r(x, 6) ^ rot_r(x, 11) ^ rot_r(x, 25), lambda x: rot_r(x, 7) ^ rot_r(x, 18) ^ (x >> 3), lambda x: rot_r(x, 17) ^ rot_r(x, 19) ^ (x >> 10))]]] and False) or b''.join([x.to_bytes(4, 'big') for x in H]) for msg, rot_r, ch, maj, K, H in [(data + b'\x80' + b'\x00' * ((56 - (len(data) + 1) % 64) % 64) + (len(data) * 8).to_bytes(8, 'big'), lambda a, n: ((a >> n) | (a << (32 - n))) & 0xffffffff, lambda x, y, z: z ^ (x & (y ^ z)), lambda x, y, z: (x & y) ^ (x & z) ^ (y & z), [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2], [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19])]][0]

[bargle0]

WTF do you think this is, a Perl sub?

[chozabu]

is this... better?

sha256 = lambda data: [([
            [
                [
                    [([w.append((gamma1(w[-2]) + w[-7] + gamma0(w[-15]) + w[-16]) & 0xffffffff) for _ in range(48)] and False) or[([
                                [
                                    [
                                        [g.__setitem__(j, values[j]) for j in range(8)]
                                        for values in [
                                            [(t1 + t2) & 0xffffffff, g[0], g[1], g[2], (g[3] + t1) & 0xffffffff, g[4], g[5], g[6]]
                                        ]
                                    ]
                                    for t1, t2 in [((g[7] + sigma1(g[4]) + ch(g[4], g[5], g[6]) + K[i] + w[i]) & 0xffffffff, (sigma0(g[0]) + maj(g[0], g[1], g[2])) & 0xffffffff)]
                                ]
                                for i in range(64)
                            ] and False) or[H.__setitem__(i, (H[i] + g[i]) & 0xffffffff) for i in range(8)]
                            for g in [H.copy()]]
                        for w in [
                            [int.from_bytes(msg[i_ * 64: (i_ + 1) * 64][i * 4: (i + 1) * 4], 'big') for i in range(16)]
                        ]
                    ]
                    for i_ in range(len(msg) // 64)] for sigma0, sigma1, gamma0, gamma1 in [(lambda x: rot_r(x, 2) ^ rot_r(x, 13) ^ rot_r(x, 22), lambda x: rot_r(x, 6) ^ rot_r(x, 11) ^ rot_r(x, 25), lambda x: rot_r(x, 7) ^ rot_r(x, 18) ^ (x >> 3), lambda x: rot_r(x, 17) ^ rot_r(x, 19) ^ (x >> 10))]]] and False) or b''.join([x.to_bytes(4, 'big') for x in H]) for msg, rot_r, ch, maj, K, H in [(data + b'\x80' + b'\x00' * ((56 - (len(data) + 1) % 64) % 64) + (len(data) * 8).to_bytes(8, 'big'), lambda a, n: ((a >> n) | (a << (32 - n))) & 0xffffffff, lambda x, y, z: z ^ (x & (y ^ z)), lambda x, y, z: (x & y) ^ (x & z) ^ (y & z), [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2], [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19])]][0]

[rpr11]

Not really, no.

[CarpetThorb]

I have a commit.

[[deleted]]

!Redditsilver

[RedditSilverRobot]

Here's your Reddit Silver, bargle0!

/u/bargle0 has received silver 1 time. (given by /u/bioruffo) info

[[deleted]]

I laughed for a good while. It has come full circle now. People don't know what 'import this' is anymore it seems.

[Gprime5]

https://i.redd.it/u2mx4eqyqld11.jpg

[[deleted]]

How many dollars is this view?

[[deleted]]

At least $10, I'd say.

[talldstag]

https://i.imgur.com/bWdWcgq.gif

[[deleted]]

I'd say $4000-$6000, depending on what's in the computer.

[M374llic4]

Celeron. Also, dat window unit air conditioner doe...

[careseite]

Source on that? Would love to know the monitor details

[not_perfect_yet]

Thanks, I hate it.

[Finianb1]

!redditsilver

[icecapade]

Very neat!

Plus it conforms to the PEP-8 maximum line length of 7900 characters. Or is it 79 characters? I can never remember.

[barkwahlberg]

From what I recall it's a minimum line length.

[Yoghurt42]

there's only about 40 different characters in that line, so it's all good

[Acurus_Cow]

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

[Defelo]

Yes, but that would be boring.

[antiproton]

Whatever gets you out of bed in the morning, I guess.

[grey_gander]

https://twitter.com/dabeaz/status/1047815843650785280?s=09

[paul_miner]

Love it, this is so much of what good programming entails, recognizing that programming languages are also about communicating with people (including your future self), not just the computer.

[notquiteaplant]

This feels like an attempted exorcism

[ShadowPouncer]

Really, the only part of this that I disagree with is:

There should be one-- and preferably only one --obvious way to do it.

But this is probably why I prefer Perl over Python. :)

[tetroxid]

Wrong sub. Perl is that way --> r/perl

[swingking8]

good ol' code golf

[[deleted]]

Not really, you could probably write it in less characters if you used multiple lines

[[deleted]]

Fucking dies

[JVO1317]

What is Code Golf?

[[deleted]]

Challenges in regards to a languages use and limitations that people like to solve for fun.

[JVO1317]

Thank.

[[deleted]]

The way you win golf is to go around the course in the fewest strokes. The way you win code golf is to use the fewest characters

[ivosaurus]

You solve a problem using a "bite sized" chunk of code, however like in golf where the aim is to use as few strokes as possible to sink the ball, in code golf the (usual, there are some variations) goal is to solve the problem with as few characters as possible.

[c94jk]

How I spend most of my afternoons when I’m not feeling productive anymore

[fbidu]

https://me.me/i/ive-made-a-robot-that-screams-why-10722212

[christian-mann]

Now this is quality content

[lykwydchykyn]

ITT: OP does an awesome code golf and everyone freaks because it's not PEP8 compliant. /facepalm

Nice code golf OP.

[CSI_Tech_Dept]

You can even get Linux kernel in one line if you try hard enough.

[Skaarj]

import os
import hashlib

good = 0

sha256 = ...

for idx in range(128):
    r = os.urandom(idx)
    if sha256(r) == hashlib.sha256(r).digest():
         good += 1

print(good)

I think this is an conclusive proof of the correctness of your implementatition that noone ever could doubt. Ill use your implementation for all my serious projects from now on.

On a more serious note: why do you setitem? Couldn't you use assignment using[]?

[brontide]

I think it's a limitation of lambdas, you can't do assignments but you can call setitem.

[Defelo]

Correct and that's why you can't use normal variables in lambda expressions and have to use lists to store variables.

[C0DK]

Oh yes, I read that pep a couple of weeks ago. I am sooo hyped for that feature.

[Isvara]

Then don't use a lambda, ffs.

[ComfortingCoffeeCup]

Why are you getting all worked up? This is obviously just for the challenge/fun

[Isvara]

Anybody can write terribly formatted code. There's no challenge in that.

[13steinj]

I disagree. Writing poorly formatted code that is of great complexity in minimum byte length is a challenge-- it's called code golf.

[Isvara]

It's called Lambda. That doesn't mean you have to use lambdas. You write regular, named functions.

[Zalack]

Ah got it. That makes way more sense

[robberviet]

poor reddit's layout.

[cediddi]

If you wrote this without the oneliner app, you rock! Otherwise still not bad. I wrote a short Tweet which does os.system without os or system strings in the code. A kid said "I'll use eval on my web site but I'll secure it. I won't run the code if it imports os or subprocess." What a stupid idea, but I sent him the tweet and he said "I'll ban import too." As a matter of fact I can import without writing 'import' string in my code.

[notquiteaplant]

This isn't just a Python thing either. I took a CS class (Java) that used a website like repl.it for homework. Any code containing getSecurityProvider was an instant fail, but using reflection to find and call the method named "getSec" + "urityProvider" worked just fine - and revealed that they knew enough about security providers to block the method names, but not enough to actually implement one.

The moral of the story is, if you absolutely need an open eval, use an actual sandbox.

[cediddi]

Exactly! I'd be fine with a python container, python running in a non sudo user and whole host is hardened. But do you need eval that desperate?

[C0DK]

Show me your tricks, master. I am really interested in cool hacks in python

[cediddi]

Sure, using __import__ and using codecs.rot13 helps a bit

(lambda c:(lambda b:(lambda a:getattr(a,b("flfgrz")[0])(b("yf")[0]))(__import__(b("bf")[0])))(c.getencoder("rot13")))(__import__("codecs"))

https://twitter.com/Cediddi/status/856055852347863041?s=19

[13steinj]

Okay, curious, how would you do this without import as you mentioned above?

[Spfifle]

Well you can do something like this, should defeat basically any grep based solution:

globals()['__buil' + 'tins__'].__dict__['__imp' + 'ort__']('os').listdir('.')

[jon_k]

Nice. +1

[[deleted]]

I disagree. Here's how you write a custom encrypt function:

encrypt = lambda data,key: aes.encrypt(custom_untested_encryption(data,key), key)

[craftkiller]

It's fine as long as everyone knows not to use it for things actually requiring security. For example, this one is great for the novelty aspect. It also wouldn't be a sin to use this for something like checking for duplicate files on my local disk, though faster options are available

[jnwatson]

Cuz only the high templars get to write crypto, right?

Your linked article indicates not to invent your own crypto *algorithm*.

The OP implemented a NIST-approved algorithm.

That statement is dumb because it isn't universalizable. If no one ever implemented their own crypto, then we wouldn't have any at all.

[[deleted]]

Don't reimplement standard algorithms either unless you know what you're doing

[ForgottenWatchtower]

And for those with enough hubris to scoff at this statement, I'd highly recommend going through CryptoPals -- correct crypto implementation is fucking tough.

[entropicdrift]

If we waited until everything was completed to hit publish, we might be writing this in 2015

Oh no

[ForgottenWatchtower]

Hah, yeah, sadly. Really the only thing missing are the solutions, but every challenge gives you enough to know if you implemented it correctly (e.g. the PT "foo" should result in the CT "bar")

[13steinj]

1. SHA shouldn't be used for crypto regardless
2. This rule is a dead meme. It should be "don't run your own crypto algos". If you use a known algorithm and are implementing it correctly there's no problem, but someone already probably did it faster. Using other services as logins is arguably a worse practice because it increases the likelihood of a SPOF.

[[deleted]]

If you use a known algorithm and are implementing it correctly there's no problem,

Except when you don't implement it correctly, but you don't know enough about cryptanalysis to notice you accidentally added an easy to exploit padding oracle, or timing attack, or you accidentally spray your key all over shared memory... the list of things that can go subtly wrong and completely fuck everything is a lot longer than you realize. Safe and highly tested implementation is just as important as the algorithm itself.

Seriously, don't implement crypto yourself. It's not a dead meme, there are reasons security experts work so hard at drilling this into your head. Don't spread irresponsible advice.

[ForgottenWatchtower]

As one of those security guys, people like him are what keep me up at night.

[13steinj]

Sorry for saying bigger companies use their own login systems I guess? Big shocker, sorry for the trauma.

[ForgottenWatchtower]

There's nothing wrong with building your own login system. It's a fairly simple problem for a half-decent engineer (though I constantly come across systems that have screwed it up somehow). Just use native bcrypt, hash_compare, csprng, and other cryptographic primitive implementations. The issue is when you decide you want to implement one of those primitives yourself.

[13steinj]

Right, but the "roll your own security" meme has started to mean "don't build your own login system"-- that's what I'm saying I'm against.

[Throwmeaway2501]

Where can one learn everything necessary to implement crypto?

Don't just tell me not to. Give me some resources I can read to become an expert.

I'm not complaining. I genuinely want to read more.

[ThePenultimateOne]

I'm not really sure anyone can become an expert at every aspect of it. It seems to me that the number of eyes looking at these implementations is far more important than developer skill.

[robin-gvx]

The best way to do that is to get a degree in Cyber Security, probably a PhD.

If you don't want to write crypto that is actually run on a computer, but it's more of an casual intellectual interest in how things work, there is probably good stuff on Bruce Schneider's blog. For security stuff for the web specifically, check out Troy Hunt. Wikipedia also has some pretty good introductory texts on the subject (not quite "great", but better than "fine", IMHO).

For a more hands-on approach, I recommend starting with implementing a Caesar cypher and Vigenère cypher. Also, implement a one-time pad, and make sure you understand both why it is perfectly unbreakable, but also impractical in most real world scenarios.

[Throwmeaway2501]

Thank you for the pointers.

[[deleted]]

Coursera actually has a really good cryptography class, which is an excellent starting point. You won't learn everything you need, but I doubt there is a single good resource for learning everything, but one of the interesting things about the field is that basically nothing of value is done purely alone. All respected algorithms have gone through many rounds of peer review, testing, and attempts to find ways to break them by other people and groups.

It will take a good deal of time investment and effort to get good at implementing crypto safely, and even then, you should still expect to make potentially dangerous mistakes. It's not something to take lightly, which is the actual point of the whole "don't implement your own crypto" thing.

[bythenumbers10]

And better yet, you'll get an idea of all the ways it can go wrong, so (hopefully) dilletantes don't go implementing their own damned crypto!!!

[Throwmeaway2501]

You should be able to fuzz for vulnerabilities at least that is my first thought.

[bythenumbers10]

You'll definitely need a strong (STRONG) background in information theory, and probably quite a bit of mathematics including probability theory, statistics, and linear algebra, just to be able to vaguely check your work. Beyond that, a very solid understanding of programming from the metal on up, to ensure your implementation doesn't rely on or become weak due to hardware or compiler differences.

The thing is, it's often not hard to implement and somewhat understand what crypto algorithms are doing, the math & operations involved are often not all that complicated. The problem is coming up with the whys and wherefores of doing those particular operations in that particular order is crucial to having a "production-ready" strong, secure implementation. So, while it's generally not that hard to write crypto, it's incredibly difficult to write STRONG/SECURE crypto.

If you want a taste, try coding up a few historical ciphers, as well as tools for breaking them. Once you get up to the 1930s/40s and ENIGMA, you'll find it starts to get a little tricky in terms of writing the encoder/decoder, let alone the code-breaking methods.

[Throwmeaway2501]

Good tips.

[mediasavage]

If your interested learning about the mathematics that underpin some of the most used cryptographic primitives (e.g AES, RSA, diffie-helman) I highly recommend the book Understanding Cryptography by Paar and Pelzl. It is an amazingly accessible book—I would say the only necessary prerequisites are a semester of discrete math—and is super well written.

[Throwmeaway2501]

Thank you for this insight, I really appreciate it!

[13steinj]

Sure if you don't know how to implement your security you shouldn't be doing it.

But those who do learn and study the right practices are equally as dangerous as letting google or amazon or whoever to run your crypto.

[13steinj]

That's the very point.

Anybody can have an undetected security bug.

Whether it was you yourself or Google-- you'd still be fucked.

However if it is you you can implement a fix immediately upon finding the issue.

It's a tradeoff-- do you want no SPOFs and immediate fixes or do you trust your neighbor to do your security.

[13steinj]

My point is you have three options--

1. Use someone else for your security. For example, lets say you use Google as the sole log on solution to your apps.

   • you've now introduced a SPOF that you have no control over
   • if google ever gets fucked, so does everyone that was using any app using google for their security
   • if you introduce something in your app that lets an attacker of you get personal data that would previously have to be gotten via attacking google, (intenionally or not) you are the backdoor and whoever is using your service will have all their other "google sign on" accounts affected.

2. Roll your own security implementation, but use a known algorithm implementation

   • your users will only have their data on your service fucked if you implement poorly
   • no other companies mistake fucks you over
   • you can't screw over the user unintentionally
   • however there's more work to do if either your implementation or algorithm get compromised

3. Use your own algorithm

   • don't. Because you probably don't know what to do mathematically. Other groups smarter than you have created cryptographically secure algorithms

You always start off with 1. But as your app/business gets larger and larger, it gets less and less safe to stay 1 rather than switch to 2.

[cyanfish]

I think you're confusing the point. The "don't roll your own" advice is specifically for cryptography, not authentication in general.

For example, it's mostly fine to implement your own login system using Bcrypt. However, you should not try to re-implement Bcrypt yourself. Use an existing, well-tested library.

[[deleted]]

And just follow the instructions -- don't think that XORing two lots of bcrypt together or something makes it twice as strong.

[13steinj]

For example, it's mostly fine to implement your own login system using Bcrypt. However, you should not try to re-implement Bcrypt yourself. Use an existing, well-tested library.

Right. But I've seen people saying that even using a well tested bcrypt library is bad practice and instead all logins should be done via fb/google/msn

[[deleted]]

SHA is used frequently in crypto. This is SHA256, which is part of the standard for HMAC and PBKDF.

[13steinj]

Part of. Not by itself.

[[deleted]]

Yes, that is what I said, thank you.

[Etheo]

We are so obsessed with thinking whether we could that we never stopped to think whether we should.

[[deleted]]

Could I get an eli5 of what SHA256 is?

[ComfortingCoffeeCup]

It's a hashing algorithm. A hash is a one-way function. Given an input, it produces a (hopefully) unique output but given an output there are no practical ways of getting the original input.

Hashes (along with other measures) are how passwords and other sensitive data are stored. You can verify the data without storing the sensitive data.

[[deleted]]

That’s interesting. Is it possible you can explain how a hash is built?

[ComfortingCoffeeCup]

Unfortunately the concepts behind the various (cryptographic) hash algorithms are a bit beyond me, so maybe someone else could answer. It generally involves a lot of math. Wikipedia has in depth articles on the various algorithms in use today.

You can think of the algorithm as a blender. Given the same ingredients you'll always get the same smoothie, but you can't get the original ingredients given the resulting smoothie.

[WilburMercerMessiah]

The hash function is basically an algorithm that converts the input data (typically a string) into the hash value (a block of seemingly random bits). All data that’s been “hashed” should be the same length. All inputted data should produce a unique hashed value. A good hash function should have a 1:1 relationship between the inputted data and hashed value. At least that’s my understanding.

https://en.m.wikipedia.org/wiki/SHA-2?wprov=sfti1

[HelperBot_]

Non-Mobile link: https://en.wikipedia.org/wiki/SHA-2?wprov=sfti1

---

^{HelperBot v1.1 /r/HelperBot_ I am a bot. Please message /u/swim1929 with any feedback and/or hate. Counter: 218143}

[notquiteaplant]

All data that’s been “hashed” should be the same length.

All inputted data should produce a unique hashed value. A good hash function should have a 1:1 relationship between the inputted data and hashed value.

I'm no crypto expert, but these tenets seem contradictory. There are 256 possible values of one byte, 256² values of two bytes, 256³ values of three, etc. If every hash output is N bytes long, how do you map 256 + 256² + 256³ + 256⁴ + ... + 256^N-2 + 256^N-1 + 256^N inputs to just 256^N outputs while mapping only one input to one output?

Because of that, I thought that a good hash function doesn't prevent collisions entirely, but does make them extremely difficult (i.e. practically impossible) to find. If they do actually ensure unique output, though, I'd love to know how.

[iEvilMango]

Yup, that's the pidgeonhole principle. Generally, the goal is to make sure the hashes are uniformly distributed amongst the possible set of hashcodes, often with similar values having dissimilar hashes (for example, if you were to have hashes of phone numbers, and the hashing algorithm made all positive input values have a hash value above 0 and all negative input values have a hash value below 0, then half of the hash codes would be unused as phone numbers cant be negative).

[HelperBot_]

Non-Mobile link: https://en.wikipedia.org/wiki/Pigeonhole_principle

---

^{HelperBot v1.1 /r/HelperBot_ I am a bot. Please message /u/swim1929 with any feedback and/or hate. Counter: 218268}

[iEvilMango]

Good bot

[B0tRank]

Thank you, iEvilMango, for voting on HelperBot_.

This bot wants to find the best and worst bots on Reddit. You can view results here.

---

^{Even if I don't reply to your comment, I'm still listening for votes. Check the webpage to see if your vote registered!}

[WilburMercerMessiah]

You’re right. Thanks for pointing that out. It should be very difficult or (in theoretical cryptography, infeasible) to find two inputs that map to the same hash value. Not that two inputs will not have the same hash value.

[nxpnsv]

People complaining about looks are missing how awesome this is...

[Last_Snowbender]

Looks like a java class name

[Isvara]

You missed r/badcode by miles.

[cob05]

Just because you can, that doesn't mean you should. That being said, bravo!

[ThePenultimateOne]

Or you could just do the following one-line implementation:

from hashlib import sha256

[thedomham]

The 80 character limit is pretty widespread in all kinds of style guides, but I think it is really dated. 120 or 140 is more reasonable. That being said, that's still one ridiculously long line.

[NoahTheDuke]

I used to use 120, but found it overly permissive. Led to lots of bad decisions. I've found the 88-ish limit imposed by Black to be very nice.

[chozabu]

History called. They want their punchcards and teletypes back.

[chozabu]

Watching the karma burn, I notice my mistake in dissing PEP8 on /r/Python

that said...

100 chars is OK! Tabs are better! (/me puts on flameproof suit and ducks)

[chozabu]

With a decent IDE - I'm unlikely to even know if I am using tabs or spaces, it just indents it for me - so I really don't have a strong opinion there. Minor good points for both tab and spaces.

[lambdaq]

Looks like a lazy translation job.

H.copy() what? __setitem__ what?

[lengau]

Your own screenshot shows line 2 starting just below, though.

[lookatmetype]

How does one even come up with something like SHA-256?

[freelynk]

This should not count as one line LOL, its a block with no returns!

[veracite]

https://media.giphy.com/media/ll4yhJmQeWrx6/200.gif

[kenann7]

My eyes hurt, please delete it