Hacker Newsnew | past | comments | ask | show | jobs | submit | msm23's commentslogin

That would be just over thirteen and a half cups of water, which may or may not be a lot depending on heat, humidity, activity level, and most of all, are you thirsty?


> The study, published in the scientific journal Addiction, concludes that there is more than simply a link or statistical association between alcohol and cancer that could be explained by something else.

This isn't published to any of the major health journals, rather it's been published in the journal Addiction which probably doesn't have the most balanced view on the role of alcohol in society.


"which probably doesn't have the most balanced view on the role of alcohol in society"

source?


'Addiction' kind of wraps it up.


The source http://imgur.com/DrEinPB states the problem using "256" not "2^8". I'm not sure if the tweeter is trying to be clever, but he isn't saving any characters by using the exponential notation.

If you're trying to save characters in a tweet, you don't have any savings in using exponential over decimal for base two until 2^14.


Or the tweeter is smart enough to realise a likely origin of the limitation and uses that directly.

Considering the tweeter in question, I'd go with the second one.


Except I doubt it's a bit math bug, or the warning would be very clear about 16, 32, 64 axle trains etc

It's likely that the axle count is stored as a 8-bit unsigned integer.


> Except I doubt it's a bit math bug

What are you even talking about?

> It's likely that the axle count is stored as a 8-bit unsigned integer.

Which is exactly the point of writing it as 2^8…


Somehow I read the original tweet as "by powers of 2" and not 2 to the 8th.

I blame my lack of morning coffee :)


I think the author was just suggesting this is due to 256 causing an 8 bit unsigned integer to overflow.


2⁸?


See? It still takes three characters.


You can view a live simulation using a Mac/PC app downloadable from:

http://eyes.jpl.nasa.gov/eyes-on-juno.html

From the description on the page: In this interactive visualization, you can ride along with the Juno spacecraft in real-time at any time during the entire mission. For example, watch the arrival at Jupiter on the 4th of July, 2016, or see Juno use Earth’s gravity as a slingshot to pick up speed, or just learn about the science of Jupiter and about the spacecraft itself. You can even turn on and off the magnetic field, aurorae, and the radiation belt, all in 3D! All of this and more is waiting to be explored.


If you enjoy this kind of music, you'll like Shostakovitch. His 11th Symphony has this same style of music, and I've always felt like I was watching Aliens while listening to it. The two minutes in the following clip have the same build-up, rhythm, and style as the Bishop's Countdown: https://www.youtube.com/watch?v=uVL3vtZ-z6g&feature=youtu.be...


Yeah, Shostakovich was brilliant.

The ending of this piece reminds me of the ending of Symphony no 4 - with a quiet delicate bell sound, after starting with a grotesque, whacky march.

(A) start: https://youtu.be/I7U2WzC47sQ?t=246

(B) ending: https://youtu.be/I7U2WzC47sQ?t=3488

How did he go from A to B?


Never thought I'd see it, but here's the solution to the expert problem:

https://www.youtube.com/watch?v=B7MIJP90biM

Credit to D. Scott Williamson, Expert


My personal favorite solution: http://i.imgur.com/fdHpJS4.png


Running

  ps auxwwe
on Linux, Mac OS X, and other Unix-en will show all processes for all users with their complete environment.

Environment variables should not be used to share secrets.


Testing on Linux, if ran as root it does, but if you are running ps auxwwe as normal user, it is only showing env variables for that user.


On FreeBSD, at least, the ability to see processes belonging to other {g,u}id's can be turned off via a sysctl.


http://pharyngula.wikia.com/wiki/Gnu_Atheists

"Gnu Atheists is a pun on the label New Atheists that quickly took on a life of its own. As a pun, it is equivalent in meaning to New Atheists, and the two can be substituted for each other anywhere they occur."


Their live thread is here: https://www.reddit.com/live/vlfanix4u5u8


I prefer to trust the NSA on these matters. They end up saying much of what the author has written, but they make it clear why you want to use one vs the other.

The excerpt below is from https://www.nsa.gov/ia/_files/factsheets/I43V_Slick_Sheets/S... (which in turn also references https://www.nsa.gov/ia/_files/factsheets/I43V_Slick_Sheets/S... )

Unix-like Platforms (e.g. Linux, Android, and Mac OS X):

Application developers should use the fread function to read random bytes from /dev/random for cryptographic RNG services. Because /dev/random is a blocking device, /dev/random may cause unacceptable delays, in which case application developers may prefer to implement a DRBG using /dev/random as a conditioned seed.

Application developers should use the “Random Number Generators: Introduction for Operating System Developers” guidance in developing this solution. If /dev/random still produces unacceptable delays, developers should use /dev/urandom which is a non-blocking device, but only with a number of additional assurances:

- The entropy pool used by /dev/urandom must be saved between reboots. - The Linux operating system must have estimated that the entropy pool contained the appropriate security strength entropy at some point before calling /dev/urandom. The current pool estimate can be read from /proc/sys/kernel/random/entropy_avail.

At most 2^80 bytes may be read from /dev/urandom before the developer must ensure that new entropy was added to the pool.


Maybe I'm just tired & not able to detect sarcasm right now, but isn't 2^80 bytes more bytes than are currently stored in the world? That's on the order of 10^24, which is something like 1 million exabytes, which is a million squared terabytes, right?


The amount of digitally stored information in the world as of May 2009 [1] is in the order of 2^71. There's no way a single process in a Linux distro will live long enough to read 2^80 bytes for the foreseeable future.

[1] http://www.theguardian.com/business/2009/may/18/digital-cont...


No, it's called being safe

And I wouldn't put it past them to have an attack (at least theorectical) that exploits this


There's safe and there's FUD. Nobody will read 2^80 bytes from urandom. You'll literally run out of time before that. It would take around 1,782,051,134 years to do on my system.

So if they write that there's a vulnerability after reading 2^80 bytes - that's great! We're secure. If they write that you must ensure to do something after 2^80 bytes - that's complete bullshit.


Yes, reading 2^80 bytes for a practical attac is impossible today (and also for the near future)

However, remember when attacks to 3DES, MD5 were only theoretical?

Also, you may not even need to read 2^80 bytes, there might be a (future) vulnerability that allows you to shortcut this.


There are physical limits to our reality and it's very unlikely those limits can be broken (eg, speed of light). Given those limits, 2^80 is large enough that the limit cannot be surpassed without fully breaking reality (eg, timetravel).

If you can break reality, all bets are off though and trying to defend against attacks that break reality in the future are impossible.


The difference is that weaknesses were found in 3DES and MD5. Increasing computing power was not the main factor. "Only" being able to produce 2^80 random bytes is a known and expected limitation. Sure, the CSPRNG could in theory be found to have a weakness, but that has nothing to do with the 2^80 bytes and the same could be said for virtually any cryptographic algorithm.


What weaknesses in 3DES are you thinking about that yield practical attacks?


I am not arguing that there are; that was the parent comment. However, while the 3DES weaknesses don't yield practical attacks now, they still reduce the effective key length. My point was not that 3DES is different in that it is exploitable, but that it is different from the 2^80 limit in that the CSPRNG in that the later is not a result of a mistake in the algorithm's design but instead an expected feature. Just like the fact that any fixed-size key symmetric cipher is "limited" by that key size.

Now, if someone found a lower limit based on exploiting some weakness in the random number generation, the analogy with 3DES and MD5 would make more sense.


Which practical attacks on 3DES are you thinking of?


Just brute force basically

But there seems to be smarter attacks (ref 21) https://en.wikipedia.org/wiki/Triple_DES#Security


Those are not practical attacks. But your argument hinges on their being non-theoretical attacks on 3DES. Are there others you were thinking of?


3DES might have been a bad example.

My point is that even if today some sizes and lengths seem only of theoretical concern, tomorrow there might be a vulnerability, a new approach to the problem, or even natural technological evolution that might turn it into a practical attack (even when it seems impossible today)


But that's true of every cryptographic primitive. You can't make reasoned decisions based on that logic.


From what I recall, the consensus is that the smarter attack is less efficient than brute force overall.


> in which case application developers may prefer to implement a DRBG using /dev/random as a conditioned seed.

Wait, what? dev/urandom is a DRBG seeded the same way dev/random is. This doesn't seem to make sense.


Nods

You're very unlikely to be continually reseeding your own DBRG with new entropy, so it will be less secure than /dev/urandom, which is.

Suspiciously bad advice, there, from what I can see.


Just as a random counter-example, Openssl does use that method. But it actually seeds from urandom, rather than random... And fails when forking/threading by default. :(

But yes, that's not common. (more info: http://wiki.openssl.org/index.php/Random_Numbers)


Is the joke that this is awful advice?

(Except for saving the entropy pool between reboots, which can be useful, afaik.)


> application developers may prefer to implement a DRBG using /dev/random as a conditioned seed

No. Doing random in userland is just wrong. If your program has access to /dev/urandom, use it. If not, use arc4random().

> “Random Number Generators: Introduction for Operating System Developers”

Or look how OpenBSD does it. (getentropy(), arc4random(), the subsystem)

> The entropy pool used by /dev/urandom must be saved between reboots.

OpenBSD does this, and more. The bootloader basically seeds the kernel with old entropy from before the reboot.


> - The entropy pool used by /dev/urandom must be saved between reboots.

Every single Linux distro does this.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: