Acciones del servidor en Next.js: autorización y validación dentro de cada acción
Server Action es un punto final POST público
La función con "use server" parece una llamada normal desde un componente y esto es engañoso. Next.js registra una identificación y el navegador lo llama con una solicitud POST a la URL de la página con el título Next-Action. Cualquiera que haya abierto la página ve este ID en las solicitudes de red y puede volver a intentar la llamada con cualquier argumento a través de curl.
De ahí dos reglas que no dependen de nada más:
- 1.Cada acción comprueba por sí misma quién la llama y si tiene derecho a realizarla.
- 2.Cada acción verifica por sí misma los datos de entrada. El tipo TypeScript de un parámetro no garantiza nada en tiempo de ejecución.
El hecho de que el botón Eliminar sea visible sólo para el administrador, o que la página esté cerrada por middleware, no es protección. En marzo de 2025, se solucionó la vulnerabilidad CVE-2025-29927: un encabezado especial permitía omitir el middleware por completo. Quedaron abiertas las solicitudes cuya autorización residía únicamente allí.
Capa de acceso a la sesión
// lib/auth/session.ts
import "server-only";
import { cookies } from "next/headers";
import { cache } from "react";
import { db } from "@/lib/db";
export const getSession = cache(async () => {
const jar = await cookies(); // в Next.js 15 cookies() асинхронна
const token = jar.get("__Host-session")?.value;
if (!token) return null;
return db.session.findValid(token); // { userId, role } или null
});
export async function requireUser() {
const s = await getSession();
if (!s) throw new Error("unauthenticated");
return s;
}Importar server-only convertirá la importación accidental de este módulo en un componente del cliente en un error de compilación. cache de React deduplica la lectura de la sesión dentro de una sola solicitud.
Envoltorio para la acción
// lib/actions/safe-action.ts
import "server-only";
import { z } from "zod";
import { requireUser } from "@/lib/auth/session";
export type ActionResult<T> = { ok: true; data: T } | { ok: false; error: string };
export function authedAction<S extends z.ZodTypeAny, T>(
schema: S,
handler: (input: z.infer<S>, user: { userId: string; role: string }) => Promise<T>
) {
return async (raw: unknown): Promise<ActionResult<T>> => {
const user = await requireUser().catch(() => null);
if (!user) return { ok: false, error: "Нужно войти" };
const parsed = schema.safeParse(raw);
if (!parsed.success) return { ok: false, error: "Некорректные данные" };
return { ok: true, data: await handler(parsed.data, user) };
};
}Aplicación: verificar la propiedad, no solo iniciar sesión
// app/threads/[id]/actions.ts
"use server";
import { z } from "zod";
import { revalidatePath } from "next/cache";
import { authedAction } from "@/lib/actions/safe-action";
import { db } from "@/lib/db";
const EditInput = z.object({
threadId: z.string().uuid(),
body: z.string().trim().min(1).max(20_000),
});
export const editThread = authedAction(EditInput, async ({ threadId, body }, user) => {
const updated = await db.query(
`UPDATE threads SET body = $1, updated_at = now()
WHERE id = $2 AND (author_id = $3 OR $4 = 'moderator')
RETURNING id`,
[body, threadId, user.userId, user.role]
);
if (updated.rowCount === 0) throw new Error("not found or forbidden");
revalidatePath(`/threads/${threadId}`);
return { id: threadId };
});La verificación de propiedad está integrada en WHERE: no puedes editar la rama de otra persona sustituyendo threadId. Esta es una vulnerabilidad IDOR clásica y es especialmente común en Server Actions porque la ID proviene "de su propio componente". Todos los argumentos (pasados directamente, a través de .bind o campos de formulario ocultos) provienen del cliente y pueden reemplazarse.
Formularios y usoActionState
"use client";
import { useActionState } from "react";
import { editThreadForm } from "./actions";
export function EditForm({ threadId }: { threadId: string }) {
const [state, action, pending] = useActionState(editThreadForm, null);
return (
<form action={action}>
<input type="hidden" name="threadId" value={threadId} />
<textarea name="body" required maxLength={20000} />
<button disabled={pending}>Сохранить</button>
{state && !state.ok && <p role="alert">{state.error}</p>}
</form>
);
}La acción para el formulario obtiene (prevState, formData). Cree un adaptador delgado que convierta FormData en un objeto a través de Object.fromEntries(formData) y lo pase al mismo esquema Zod. required y maxLength en el marcado son conveniencia del usuario, no validación.
¿Qué más considerar?
- Datos devueltos. Todo lo que devuelve la acción va al navegador. No devuelva el registro completo de la base de datos: contiene hashes de contraseñas, correos electrónicos de otros usuarios y campos de servicio.
- Errores. En producción, Next.js reemplaza el texto del error arrojado por el común con
digest, para que los detalles no se filtren, pero el usuario no entenderá nada. Devuelve los errores esperados como el valor{ ok: false }, errores inesperados: lanza y registra. - CSRF. Next.js acepta acciones solo usando el método POST y compara el encabezado
Origincon el host. Si el sitio está detrás de un proxy con un dominio diferente, las fuentes permitidas se configuran enexperimental.serverActions.allowedOrigins. No es necesario desactivar esta verificación. - Tamaño del cuerpo. Por defecto limitado a 1 MB, cambios a través de
experimental.serverActions.bodySizeLimit. No lo hagas innecesariamente: es mejor cargar archivos a través de URL de almacenamiento firmadas. - Frecuencia. Una acción que envía correos electrónicos o crea publicaciones necesita un límite al igual que una API normal.
Cómo comprobar tus acciones
Abra DevTools, realice la acción y copie la solicitud como cURL. Repetirlo desde el terminal: sin cookie de sesión, con cookie de otro usuario, con el threadId de otra persona, con un cuerpo de 10.000 caracteres por encima del límite. Cada opción debería resultar en un error, no en un cambio en los datos.
Cuando las acciones no son apropiadas
Para una API pública, un cliente móvil o webhooks, utilice controladores de ruta: tienen una URL estable, un método explícito y un contrato claro. Las acciones del servidor son convenientes para las mutaciones desde su propia interfaz, pero las reglas de verificación para ellas no son más suaves, sino más estrictas: son más fáciles de olvidar.