Is there any way to claculate the hash of (a + b +c)) if you only know hash(a) and Hash(b) and Hash(c)?

For example, if you have say, 3 distinct paragraphs of clear text a, b, c and you only know hash(a), hash(b) and hash(c), and then you have a clear text d, which claims to be the concatenation of a, b, and c, is there any way to use hash(a, b, c) to demonstrate that d either is or isn't a+b+c?

Not beng a math person, I'm guessing there is a brute force way, depending on the length of a, b, and c to try every possible division of d into 3 parts, and see if you can match the individual hashes, but seems computationally intensive unless the a b and c are pretty short. Is there a way that isn't dependent on the length of a, b and c?

Not beng a math person, I'm guessing there is a brute force way, depending on the length of a, b, and c to try every possible division of d into 3 parts, and see if you can match the individual hashes, but seems computationally intensive unless the a b and c are pretty short.

Actually, it doesn't sound that bad. Suppose $d$ is a Megabyte in length. There are a million (plus one) ways that $a$ could be a prefix of $d$ (assuming $a$ is known to be an integer number of bytes; multiply by 8 if it might be an arbitrary bit string); hash all possible prefixes, and see if any of them match the known value $hash(a)$. Once you have $a$ (and hence the length of $a$), you can then do the same for $b$; with at most a million hashes, you get recover $b$ (and then also verify $c$)

That should be less than a second on a decent PC, assuming your hash function is, say, SHA-2 or SHA-3 or something similar (if you reuse intermediate hash values during the scan of possible matches for $hash(a), hash(b)$)

This is similar to a well-known construction, namely what is known as an incremental hash. See this paper for pointers.

Roughly, incremental hashes are homomorphic with respect to set operations. Or in other words, if you have a database $\mathcal{D}$ that you

1. need to maintain the hash $H_{\mathcal{D}} := H(\mathcal{D})$ of, while
2. updating by adding ($\mathcal{D} + e := \mathcal{D}\cup \{e\}$) and removing ($\mathcal{D}-e := \mathcal{D}\setminus\{e\}$) elements,

one can use an incremental hash to efficiently update $H_{\mathcal{D}}$ without recomputing $H(\mathcal{D})$ after each operation.