Score:0

# What happens when we hash already hashed values, concatenated together?

I read on the page 16 of On the Security of Hash Function Combiners that

the classical combiner for collision-resistance simply concatenates the outputs of both hash functions $$Comb_{\mathbin\|}(M) = H_0(M) \mathbin\| H_1(M)$$ in order to ensure collision resistance as long as either of H0, H1 obeys the property.

Consider H, a secure internal hash function with 256-bit inputs and 128-bit outputs

My question is, if we hash the concatenation again with the same hash function used before,

Like so

H(H(M)∥H(M))) (pardon my lack of knowledge of what latex is)

what happens to the collision resistance? does it become

$$2^{(n/2)} \cdot 2^n$$

or does it become

$$2^{(n/2)} + 2^n$$

or am I going the wrong direction to find if it even improves or makes it worse? The hash function used all three times is the same hash function, which I am assuming to be ideal/robust and collision resistant.

Err, what is the page? Your quote is not perfect. And we have $\LaTeX$/MathJax enabled on our site. It seems that you want to learn about hash design, my advice read the [Blake book](https://www.amazon.com/Function-BLAKE-Information-Security-Cryptography/dp/3662447568/). And, I remember such a question...
Note that; the question is not clear. If we hash the concatenation again you mean with $H_1,H_2$, or another independent hash function $H_3$? Why do we need such desing while we can use $SHA-3, Shake, Blake$ etc?
[Multicollisions in Iterated Hash Functions. Application to Cascaded Constructions Antoine Joux](https://link.springer.com/content/pdf/10.1007%2F978-3-540-28628-8_19.pdf) and the [outer hash doesn't change the internal collisions](https://crypto.stackexchange.com/q/64780/18298)
[The Not So Short Introduction to LATEX 2ε](https://tobi.oetiker.ch/lshort/lshort.pdf)
Seconding kelalaka's question: the quoted text talks about 2 different hashes but your question is about a single hash? Are you really asking about the collision resistance of applying that construct to a single hash? Why?