Q:

Acceso a memoria

¿Alguien me puede decir qué hace las siguientes líneas?
num = *((int*)(direccion+sizeof(char))); 
(*(ST_DATA*)(direccion+posTabla*sizeof(ST_DATA))).speed = num;

¿Las siguientes dos líneas significan lo mismo?
*((int*)(direccion + OFF_TABLE_KEY+sizeof(int))) = sec2;
((int*)(direccion + OFF_TABLE_KEY))[1] = sec2

A:

alguien me puede decir qué hace las siguientes líneas?

Por un lado podemos asumir que el valor típico devuelto por sizeof(char) es 1. Así pues y suponiendo que direccion va a ser un puntero:
char* direccion;

Entonces tenemos que esto:
direccion+sizeof(char)

Es aritmética de punteros y lo que hace es desplazarse una posición respecto a la dirección apuntada por dirección:
direccion
  v    
0x100 0x101 0x102
        ^
        direccion+sizeof(char)

Otra forma de ponerlo es la siguiente:
&direccion[sizeof(char)]

Nota el & inicial para recuperar la posición de memoria.
Lo que lo rodea no es más que una conversión de tipo:
(int*)(direccion+sizeof(char))
 ^^^^
 Conversion de char* a int*

Y finalmente obtenemos el valor apuntado por el puntero. Lo que pasa es que como ahora el puntero es de tipo int, recuperaremos 4 bytes en vez de solamente 1
*((int*)(direccion+sizeof(char)))
^

El equivalente en operaciones independientes sería:
char* ptr = direcciones+sizeof(char);
int* intPtr = (int*)ptr;
int num = *intPtr;

Y la segunda línea es equivalente pero con otro tipo de datos.

¿Las siguientes dos líneas significan lo mismo?

@abulafia ya te ha respondido a esto y no creo que merezca la pena añadir nada más.

A:

Las siguientes dos líneas significan lo mismo?
*((int*)(direccion + OFF_TABLE_KEY+sizeof(int))) = sec2;
((int*)(direccion + OFF_TABLE_KEY))[1] = sec2

La sintaxis puntero[entero] equivale a *(puntero + entero), y la aritmética de punteros hace que ese entero sea computado como entero*sizeof(tipo), siendo tipo el apuntado por el puntero.
En el caso anterior, puntero sería la expresión ((int*)(direccion+OFF_TABLE_KEY)). Aún sin saber el tipo a que apunta direccion, el resultado de direccion+OFF_TABLE_KEY nos devolverá otro puntero (a un tipo desconocido), pero ya que seguidamente el casting fuerza la interpretación de ese puntero como int*, entonces el poner un [1] después equivale a sumarle al resultado el tamaño de un entero.
Por tanto, sí, son equivalentes, siempre que direccion sea un puntero a un tipo que ocupa 1 byte (ej: char*). De lo contrario la dirección a la que accedería la primera expresión sería distinta, pues el compilador aún estaría multiplicando sizeof(int) por el tamaño del tipo apuntado por direccion, debido a que la expresión completa (direccion + OFF_TABLE_KEY+sizeof(int)) es evaluada usando aritmética de punteros.
Ante la ausencia de información sobre el tipo de direccion, no se puede asegurar que equivalgan, pero sí puedo asegurar que las dos siguientes expresiones equivaldrían (al estar forzando el tipo de direccion a char*):
*((int*)((char*)direccion + OFF_TABLE_KEY+sizeof(int))) = sec2;
((int*)((char*)direccion + OFF_TABLE_KEY))[1] = sec2

¿Alguien me puede decir qué hace las siguientes líneas?
num = *((int*)(direccion+sizeof(char))); 
(*(ST_DATA*)(direccion+posTabla*sizeof(ST_DATA))).speed = num;

La primera ya te la ha explicado perfectamente @eferion. En cuanto a la segunda, de nuevo voy a hacer la hipótesis de que  direccion es un puntero a char, pues de lo contrario la expresión no tendría mucho sentido.
La expresión se comprende si suponemos que direccion ha sido declarado como puntero a char, pero en este momento lo tenemos apuntando a una zona de memoria donde hay un array de estructuras, cada una del tipo ST_DATA. Lo que pretende esa expresión es acceder a una de esas estructuras (la que está en lugar posTabla) para guardar algo en su campo speed.
Si direccion fuese un puntero a estructuras, la cosa sería tan simple como:
direccion[posTabla].speed = num;

pero el hecho de que direccion sea un puntero a char nos obliga a hacer ciertos malabarismos con los punteros y los castings. Si "forzamos" a que el compilador vea direccion como un puntero a ST_DATA, entonces podemos usar una sintaxis muy parecida a lo anterior:
((ST_DATA*)direccion)[posTabla].speed = num;

Y la línea que tú has copiado no es más que otra forma (un poco más retorcida) de hacer lo mismo, haciendo en la expresión explícita la aritmética de punteros que en la expresión que yo he puesto resolvería el compilador de forma implícita.
Aún una forma más de decir lo mismo sería:
(ST_DATA*)(direccion+posTabla*sizeof(ST_DATA))->speed = num;

en este caso si desreferenciar el puntero obtenido por la expresión, sino usando ese puntero para acceder a un miembro de la estructura. (p->a es equivalente a (*p).a)

