¿Está bien definido usar un puntero que apunte a uno-pasado-malloc?

El borrador n4296 para C11 es explícito que apuntar uno más allá de un array está perfectamente definido: 6.5.6 Operadores de lenguaje / Expresiones / Aditivos:

§ 8 Cuando una expresión que tiene tipo entero se agrega o se resta de un puntero, el el resultado tiene el tipo del operando puntero. ... Además, si la expresión P apunta a la última elemento de un objeto de matriz, la expresión (P)+ 1 apunta uno más allá del último elemento de la objeto array, y si la expresión Q apunta a uno pasado el último elemento de un objeto array, la expresión (Q) -1 apunta al último elemento del objeto array... Si el resultado apunta uno más allá del último elemento del objeto array, no se utilizará como operando de un operador unario * que se evalúe.

Como el tipo de memoria nunca se especifica en la subcláusula, se aplica a cualquier tipo de memoria, incluida la asignada.

Eso significa claramente que después de:

int *a = malloc(5 * sizeof(*a));
assert(a != NULL, "Memory allocation failed");

Ambos

int *p = a+5;
int diff = p-a;

Son perfectamente definido y como se aplican las reglas aritméticas usuales del puntero, diff recibirá el valor 5.

Sí, las mismas reglas se aplican a las variables con duración de almacenamiento dinámica y automática. Incluso se aplica a una solicitud malloc para un solo elemento (un escalar es equivalente a una matriz de un elemento en este sentido).

La aritmética de punteros solo es válida dentro de los arrays, incluyendo uno pasado el final de un array.

Al desreferenciar, es importante tener en cuenta una consideración: con respecto a la inicialización int a[5] = {0};, el compilador no debe intentar desreferir a[5] en el expression int* p = &a[5]; debe compilar esto como int* p = a + 5; De nuevo, lo mismo se aplica al almacenamiento dinámico.

¿Está bien definido usar un puntero que apunte a uno-pasado-malloc?

Sí, sin embargo, existe un caso de esquina donde esto es no bien definido:

void foo(size_t n) {
  int *a = malloc(n * sizeof *a);
  assert(a != NULL || n == 0, "Memory allocation failed");
  int *p = a+n;
  intptr_t diff = p-a;
  ...
}

Funciones de gestión de memoria ... Si el tamaño del espacio solicitado es cero, el comportamiento está definido por la implementación: o se devuelve un puntero nulo, o el comportamiento es como si el tamaño fuera un valor distinto de cero, excepto que el puntero devuelto no se utilizará para acceder a un objeto. C11dr §7.22.3 1

foo(0) --> malloc(0) puede devolver un NULL o non-NULL. En la primera implementación un retorno de NULL no es un "fallo de asignación de memoria". Esto significa que el código está intentando int *p = NULL + 0; con int *p = a+n; lo que falla las garantías sobre la matemática del puntero, o al menos pone en duda dicho código.

El código portátil se beneficia al evitar asignaciones de tamaño 0.

void bar(size_t n) {
  intptr_t diff;
  int *a;
  int *p;
  if (n > 0) {
    a = malloc(n * sizeof *a);
    assert(a != NULL, "Memory allocation failed");
    p = a+n;
    diff = p-a;
  } else {
    a = p = NULL;
    diff = 0;
  }
  ...
}