HNHacker News
TopNewBestAskShowJobs

xnyhps

1,013 karma · joined September 5, 2012

[ my public key: https://keybase.io/xnyhps; my proof: https://keybase.io/xnyhps/sigs/m-nsALHMR_0WYxhEtG6-ngXnDELyL0_4cxRt_ufsGkM ]
submissionscomments
xnyhps··on WoSign Incidents Report Update [pdf]
The best place to start with this story would be this very well writen document by Mozilla: https://docs.google.com/document/d/1C6BlmbeQfn4a9zydVi2UvjBG.... This is WoSign's first public response after that document was published.
xnyhps··on Apple's response to the WoSign incidents
> If the certificate is preexisting (presumably issued before 9/19/16) it will be trusted ONLY if the certificate is CT logged. It will know if this is the case by looking for an SCT belonging to that certificate. The SCT will either be embedded directly in the certificate, or provided with the certificate during the SSL handshake (this is known as "stapling").

I doubt they'll do it this way. WoSign has only been embedding SCTs for all certificates since July and I wouldn't count on many webservers implementing SCT stapling. I expect Apple to ship a whitelist of hashes of certs that should be trusted instead.

xnyhps··on WoSign and StartCom: Mozilla’s proposed conclusion
> AKA, SHA-1 may not be secure against a nation state or attacker with a ton of money, but it's secure enough against for almost every site against almost every attacker.

Issuing a SHA-1 certificate for one domain doesn't just put that domain at risk, it threatens the entire ecosystem. Someone requesting such a cert may have a second cert with the same hash, but for a different domain or even an intermediate, like the MD5 collision. It's not like you could avoid this by asking "are you a nation state attacker" during the application process.

xnyhps··on WoSign and StartCom: Mozilla’s proposed conclusion
They can't backdate their Certificate Transparency log without leaving cryptographic evidence behind. That's how CT is designed to work.

Of course, simply being in the log doesn't imply the cert was issued correctly, but the logs have been posted for a couple of months now and have received a lot of scrutiny during Mozilla's investigation. But the same is true for Google's log, presence in that log is also no guarantee that it was issued correctly.

xnyhps··on WoSign and StartCom: Mozilla’s proposed conclusion
Or buy yet another CA and continue under their name?
xnyhps··on WoSign and StartCom: Mozilla’s proposed conclusion
> Google detecting further abuse of notBefore via Certificate Transparency

You don't need to rely on Google. All certs issued by WoSign since January 1st, 2015 should be on WoSign's own Certificate Transparency log from which you can download them. StartCom is logging all new certs too, but I don't know for sure if they pushed all older ones too. If you ever encounter a cert that isn't on the list, that's definitive proof that they are backdating again.

The list of certificates is too large for Mozilla to include a list of hashes in Firefox, but it might be a nice opportunity for a Firefox add-on.

xnyhps··on iOS 10: Security Weakness Discovered, Backup Passwords Much Easier to Break
Debug code that made it into production is the only thing I can think of, and even that isn't a good explanation.
xnyhps··on iOS 10: Security Weakness Discovered, Backup Passwords Much Easier to Break
For me, Manifest.db inside the backup is a sqlite3 database containing a table Properties with two rows, salt and passwordHash, satisfying:

    passwordHash == SHA256(password || salt)
xnyhps··on Transmission BitTorrent Client OSX/Keydnap Malware Incident Q+A
It's pretty scary that they still haven't fixed the Sparkle RCE vulnerability from a few months back. Attackers with access to their servers could've installed malware for every user, even if they didn't install the update.
xnyhps··on CDN77 Now Supports Brotli
Here's the list of words, by the way. I couldn't find it anywhere in non-hexadecimal form:

https://gist.github.com/xnyhps/677f7c1b444f346bef99

(I cleaned it up a bit to remove newlines and tabs, and a couple that are entirely of unprintable characters.)

xnyhps··on CDN77 Now Supports Brotli
Also note that the dictionary is strongly biased towards English. Sure, there is some Russian, Chinese, Arabic (and probably some other scripts in there which I don't recognize), but there seems to be more English words in there than all those others combined. If you're compressing small documents in any other language than English, it might not be worth it to use Brotli.

Edit: They wrote this about it in http://www.gstatic.com/b/brotlidocs/brotli-2015-09-22.pdf :

> Unlike other algorithms compared here, brotli includes a static dictionary. It contains 13’504 words or syllables of English, Spanish, Chinese, Hindi, Russian and Arabic, as well as common phrases used in machine readable languages, particularly HTML and JavaScript. The total size of the static dictionary is 122’784 bytes. The static dictionary is extended by a mechanism of transforms that slightly change the words in the dictionary. A total of 1’633’984 sequences, although not all of them unique, can be constructed by using the 121 transforms. To reduce the amount of bias the static dictionary gives to the results, we used a multilingual web corpus of 93 different languages where only 122 of the 1285 documents (9.5 %) are in languages supported by our static dictionary.

xnyhps··on OwnTracks: Self-hosted, open source location tracking
Except for displaying your location on Google Maps and using Google's APIs to do reverse geocoding...

Their definition of "private" doesn't seem to include "private from Google".

xnyhps··on Quantum Computer Comes Closer to Cracking RSA Encryption
For most research areas I'd agree, "20 years" = "who knows". But for cryptography people using it should keep looking carefully at how long something they encrypted will remain safe. People may be betting a lot on the assumption that something stays secret for at least 50 years. Therefore any significant shift in those probabilities is newsworthy, in my opinion.
xnyhps··on Transmission BitTorrent app contained malware
Reports indicate it isn't, but they're still including a vulnerable version of Sparkle [1], so I wouldn't trust the auto-update at all [2].

[1] = https://sparkle-project.org/documentation/security/

[2] = https://trac.transmissionbt.com/log/tags/2.92/macosx/Sparkle...

xnyhps··on Socat: “the hard coded 1024 bit DH p parameter was not prime”
It's also there for the previous 512 bit prime. Probably just the style preference of the project.

Edit: Actually, it looks a lot like the code was originally generated using openssl dhparam -2 -C: https://gist.github.com/xnyhps/df16e7d43e32b7dbe3fb

xnyhps··on Socat: “the hard coded 1024 bit DH p parameter was not prime”
Testing for 2 seconds already found the prime factors 271 and 13597. It will probably not be hard.

Edit: To add some more information, p / (271 * 13597) is still not prime, however, the library I was using didn't find any new factors in 30 minutes.

xnyhps··on Decommissioning a free public API
You check the website to find out if they are having server problems and you see they have deprecated the API. Problem solved.
xnyhps··on Decommissioning a free public API
Or just set a date and start rejecting 1% of all requests on that date, 2% the next day, etc. Software that retries immediately will get slower and slower, which will hopefully cause someone to investigate before bandwidth costs become ridiculous. Even if it doesn't help the API users to notice it, you can estimate better what it will do when you turn it off for 100% of the requests.
xnyhps··on Ejabberd Massive Scalability: 1 Node – 2+ Million Concurrent Users
Would be nice if they documented if they used TLS, and if so, how that was configured. Even if the 28kb per user is a typo and they mean 28kB then that would be impressive with TLS enabled.
xnyhps··on BitTorrent file system
I've use that on OS X, worked quite well. Ultimately I don't see much use for it though, maybe if you want to get information about the headers of files before you download them completely or something like that.
xnyhps··on MTProto, the symmetric encryption scheme used in Telegram, is not IND-CCA secure
True, it needs to be a safe prime, but not all 2048-bit safe primes are equally good. At the very least there are those for which the Special Number Field Sieve applies, though that's likely still infeasible.

There might be very rare 2048-bit DH groups using safe primes for which the DLP problem is easily solvable, I wasn't able to find any research into whether or not those can exist.

xnyhps··on MTProto, the symmetric encryption scheme used in Telegram, is not IND-CCA secure
But it still asks the server to pick the group in which to do DH. This has to be exploitable somehow...
xnyhps··on UUIDs generally do not meet security requirements
Obviously I'm interpreting "correctly generated" to mean "generated in accordance with the RFC", so no, it does not.
xnyhps··on UUIDs generally do not meet security requirements
> A correctly generated v4 UUID (S4.4 of the RFC) should be acceptable for use as a secure token, given it has 122 random bits.

No it's not, from §4.4:

> Set all the other bits to randomly (or pseudo-randomly) chosen values.

I can use a PRNG with a cycle length of 8 and it would be fully correct according to the RFC, but it would be trivial to brute-force all the values.

xnyhps··on Math.random in V8 is broken
Using UUIDs does not magically solve your problem of using a bad PRNG. RFC 4122 imposes no guarantees on how random the V4 UUIDs really are. You'll still need to verify yourself if the method you use to generate them is good enough for your application. Especially if you need your UUIDs to be unpredictable. It even says so explicitly:

   Do not assume that UUIDs are hard to guess; they should not be used
   as security capabilities (identifiers whose mere possession grants
   access), for example.  A predictable random number source will
   exacerbate the situation.
So many people use UUIDs for session cookies, where the unpredictability is vital.
xnyhps··on Anatomy of a Haskell-based Application
To be precise, Esqueleto isn't a smaller alternative, it's a layer on top of Persistent that gives you a typed DSL for SQL. It's been pretty nice when I used it, most things that I wanted to do in SQL were easily expressed. Exotic SQL functions that weren't available are easily imported in a type-safe way.

acid-state is a smaller, no-SQL alternative [1].

[1] https://hackage.haskell.org/package/acid-state

xnyhps··on How to Protect Yourself from NSA Attacks on 1024-bit DH
Strictly speaking that's not forward-secret anymore, as stealing the private key gives some advantage to cracking the session.

The practical reason is probably that using DHE with TLS is already many times slower than (plain) RSA. This would only make it slower.

xnyhps··on How is NSA breaking so much crypto?
To clarify, I made an error: you generate powers of g (or just any group element whose discrete log you know), not p.
xnyhps··on How is NSA breaking so much crypto?
Assuming they are using an index-calculus attack, the output is the discrete logarithms of a set of small primes. (But who knows, they may have much better attacks.)

This is how that attack works. You generate a set of small primes called the base primes:

    2, 3, 5, 7, 11, ...
Then you generate powers of p which all factor in only the base primes. This creates a set of linear equations, which can be solved to find the discrete logarithm of all base primes.

This was all pre-computation. After this, to find the discrete logarithm of x, you generate powers of x until it factors in the set of base primes. Once that is found, calculating the logarithm is easy.

This requires a trade-off: the larger the set of base primes, the longer the first step takes, but the faster the second step is.

xnyhps··on CBCrypt: Encrypt from the client rather than send passwords to servers
The state of the art for SASL is SCRAM-SHA-1. It uses challenge/response authentication and it allows the server and the client to only store salted hashes (using PBKDF2 with a configurable number of rounds). It also uses mutual authentication (the server also proves to the client that it has the hashed password, not just the other way around).

No idea how that compares to TFA, because they have no documentation.

← PreviousPage 2 of 4Next →