Ill have to give it to them, those x11 guys know how to do their bullshitting and marketing. Peoole with small brains will fall for it. Luckily we have big brains, thats why we own darkcoin.
You have brains large enough to trust a closed-source centralized anonymizing system? Erm... I think your small brain might be getting the words "small" and "big" mixed up here.
It seems this would only be a risk if the very last hashing function were compromised. Even then you would need to know how to generate the correct input to the last hashing function using the other hashing functions. It seems inherently more secure to me.
if hash1(x) has collisions, then so does hash2(hash1(x)) and hash4(hash3(... and so on, until we reach the full hashing stack, which also has collisions. Similarly, if hash2, hash3, etc, or hash11 have collisions, then so does X11(x). Simply put, if there's a collision attack for any hash#(x), then the same attack applies to X11(x).
This is the same baseless declaration with more words. You still failed to make the correlation or demonstrate a causation.
Why would this result in what is essentially a cascade failure? Why would an attack on Math A result in a failure of all other Math B to Math K to be Math anymore?
And on top of it, it's still an if...
I think you're fundamentally wrong. Collision on hash A does not break Hash B.
Really? This is very concerning that you seem to think this... None of what I am saying is baseless - for some reason you aren't even running simple tests?
Simple example:
sha256(crc32("plumless")) = sha256("4DDB0C25") = b7186aaec033aa3fb05e6b41444618f30e299f3879dde29d31f055f64fd8be49
sha256(crc32("buckeroo")) = sha256("4DDB0C25") = b7186aaec033aa3fb05e6b41444618f30e299f3879dde29d31f055f64fd8be49
crc32 has known collisions and is essentially broken in that sense, and so sha256(crc32()) is as well, and so blake256(kekkack(sha256(crc32(etc)) has known collisions.
Yes, this is an "if" situation... if a collision attack is discovered against any of the 11 sha3 candidate algorithms, that collision attack works for the whole chain. So, 11 chained algorithms are inherently less secure in regards to collision resistance vs 1 algorithm.
(Notice that you're using crc32 as the first algo in every example.) There is still an input value that is put into the first algorithm, and the first algorithm produces a good result, then that result must be fed through the other algorithms in the chain.
If the 5th algo in the chain is found to be broken, you'd still have to come up with an input of the 4th algo that generates the output you need to feed into the 5th algo; so you'd have to come up with an input for the 3rd algo that generates the correct output to feed into the 4th algo to generate the output you need for the 5th algo; and then you'd have to come up with an input for the 2nd algo that generates the correct output to feed into the 3rd algo.... and so on. So basically you'd need rainbow tables for all of the preceding algorithms in the chain, in order to do anything meaningful.
Your example falls apart if the algorithm ordering is crc32(sha256(input)).