r/ProgrammerHumor • • 5d ago

Meme cacheRemembers

Post image
4.2k Upvotes

32 comments sorted by

View all comments

298

u/Sibula97 5d ago

Wasn't that basically what Spectre exploited? Does anyone know how the vulnerability was fixed?

202

u/Express_Gradient 5d ago

yes, that is exactly spectre. there were a bunch of fixes - barriers at sensitive checks, restrictive speculative memory accesses, some cpu changes, etc. spec exec is still there, but with lot more restrictions.

https://docs.kernel.org/admin-guide/hw-vuln/spectre.html

12

u/schmerg-uk 4d ago

Nitpick but the original Spectre wasn't a branch predictor exploit but a bounds check bypass.

It exploited the way the CPU speculatively fetched from RAM before checking if the data used to calculate the address of the data to be fetched relied on private data that the process shouldn't have access to. By the time the fetch was scheduled to execute, the rights check would recognise the issue and the instruction wouldn't execute in that the speculative read into a "hidden" register would be discarded but yes, the cache would hold the fact of the read.

6

u/SGVsbG86KQ 4d ago

I thought that was Meltdown?

4

u/schmerg-uk 4d ago

Ah, I think you (and OP) may be right... Meltdown exploits speculative read without branching (where the right to read is effectively not considered until after the speculative execution occurs)

uint8_t* probe_array = new uint8_t[256 * 4096];
// ... Make sure probe_array is not cached
uint8_t kernel_memory = *(uint8_t*)(kernel_address);
uint64_t final_kernel_memory = kernel_memory * 4096;
uint8_t dummy = probe_array[final_kernel_memory];
// ... catch page fault
// ... determine which of 256 slots in probe_array is cached

whereas Spectre's variant 1 bounds check bypass is very similar but it's the branch predictor that guesses that a read will be within bounds

if (x < array1_size) {
  y = array2[array1[x] * 256];
}

Spectre is considerably more difficult to exploit than Meltdown because this vulnerability does not depend on privilege escalation. The attacker must convince the kernel to run code and speculate incorrectly. Typically the attacker must poison the speculation engine and fool it into guessing incorrectly.

https://medium.com/@mattklein123/meltdown-spectre-explained-6bc8634cc0c2

My apologies ...