¿Hay algún sistema operativo de comparación de cadenas de prueba de concepto que funcione?

Su ejemplo no funciona por varias razones, y la principal es el hecho de que está usando los mejores datos de casos posibles (es decir, es menos probable que muestre las diferencias). Si la diferencia en las cadenas era al principio, la comparación anticipada debería alertarlo. Sin embargo, dado que estás utilizando un lenguaje JIT, existen todo tipo de posibilidades extrañas que podrían dificultar dicha comprobación.

La mejor forma de demostrar este tipo de ataque no es con los bucles, sino con una única medición en un lenguaje de bajo nivel como C.

Aquí hay un ejemplo rápido que funciona muy bien:

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <time.h>
using namespace std;

// this is just strcmp() wrapped in timer calls
bool CheckEqual(char* a, char* b, bool show)
{
    int i, r, trv;
    long time_pre, time_post;
    struct timespec ts;

    if((trv = clock_gettime(CLOCK_MONOTONIC,&ts)) != 0) {
        printf("Timing error, pre. Code = %d\n", trv);
    }
    time_pre = ts.tv_nsec + (ts.tv_sec * 1000000000L);

    r = strcmp(a, b);

    if((trv = clock_gettime(CLOCK_MONOTONIC,&ts)) != 0) {
        printf("Timing error, post. Code = %d\n", trv);
    }
    time_post = ts.tv_nsec + (ts.tv_sec * 1000000000L);

    if (show)
        printf("Time: %ld\n", time_post - time_pre);
    else
        printf("First compare done.\n");

    return r == 0;
}

// this function helps us avoid the problem of the compiler being too smart.
// if we were to use string literals that were equal, it'd optimise compile-time
// constant strings into a single instance, so strcmp() would just early-out on
// the fact that the two pointers were equal, which is not what we want to
// demonstrate here - in reality we'd be comparing buffers that aren't static.
char* MakeStr(char c, int n)
{
    int i;
    char* s = (char*)calloc(n+1, sizeof(c));
    for(i=0; i<n; i++)
        s[i] = c;
    return s;
}

int main()
{
    // equal apart from last
    char* aa = MakeStr('0', 64);
    char* ab = "0000000000000000000000000000000000000000000000000000000000000001";

    // equal apart from first
    char* ba = MakeStr('0', 64);
    char* bb = "1000000000000000000000000000000000000000000000000000000000000000";

    // inequality in the middle
    char* ca = "0000000000000000000000000000010000000000000000000000000000000000";
    char* cb = "0000000000000000000000000000001000000000000000000000000000000000";

    // equal
    char* da = MakeStr('0', 64);
    char* db = MakeStr('0', 64);

    // first call to strcmp() and time functions will result in cache misses
    // so we call it once and don't display output to account for that.
    CheckEqual(aa, ab, false);

    printf("Equal but last, ");
    CheckEqual(aa, ab, true);
    printf("Equal but first, ");
    CheckEqual(ba, bb, true);
    printf("Equal but mid, ");
    CheckEqual(ca, cb, true);
    printf("Completely equal, ");
    CheckEqual(da, db, true);

    free(aa); free(ba); free(da); free(db);
    return 0;
}

Tu salida debería tener un aspecto similar al siguiente:

First compare done.
Equal but last, Time: 345
Equal but first, Time: 229
Equal but mid, Time: 234
Completely equal, Time: 270

¿Nota la gran diferencia entre los dos primeros? Esto se debe a la optimización de early-out , por lo que la comparación sale tan pronto como encuentra una diferencia. En la segunda comparación, toma menos tiempo porque la comparación del primer personaje muestra que no es igual, por lo que puede regresar antes. En la tercera comparación, vemos que esto va un poco más lejos en la cadena, lo que resulta en un tiempo de ejecución ligeramente más largo que el "igual pero primero", pero más corto que el "igual pero último".

El completamente igual es una bestia interesante. Supongo que, cuando el último carácter no es igual, hay alguna lógica adicional requerida. En comparación, el completamente igual toma menos tiempo, asumo porque solo tiene que devolver 0.