Initial commit: Kalendartool (Next.js, Prisma, Docker)
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
Kühn
87
app/api/auth/forgot-password/route.ts
Normal file
87
app/api/auth/forgot-password/route.ts
Normal file
@@ -0,0 +1,87 @@
|
||||
/**
|
||||
* POST /api/auth/forgot-password
|
||||
*
|
||||
* Passwort vergessen (plan.md Abschnitt 11).
|
||||
*
|
||||
* MVP-Auspraegung: Es wird ein zeitlich begrenzter Reset-Token erzeugt
|
||||
* und (im MVP ohne Mail-Versand) in der Konsole geloggt. Der Token
|
||||
* liegt nur gehasht in der Datenbank. Der Aufruf antwortet IMMER 200,
|
||||
* um Account-Enumeration zu verhindern.
|
||||
*
|
||||
* Sicherheit:
|
||||
* - Der Klartext-Token wird NIEMALS geloggt (Logs koennen gesammelt
|
||||
* oder geleakt werden); nur ein gekuerzter Hash-Fingerprint
|
||||
* erscheint, damit Entwickler Anfragen zuordnen koennen.
|
||||
* - Rate-Limit pro IP und E-Mail gegen Log-Flooding/DoS.
|
||||
*
|
||||
* Hinweis: Fuer Produktion ist ein Mailversand (z. B. Resend) zu
|
||||
* ergaenzen; die Schnittstelle ist darauf vorbereitet.
|
||||
*/
|
||||
import { NextRequest, NextResponse } from 'next/server';
|
||||
import { prisma } from '@/lib/db/client';
|
||||
import { emailSchema } from '@/lib/validation';
|
||||
import { errorResponse } from '@/lib/api/responses';
|
||||
import {
|
||||
checkRateLimit,
|
||||
recordRateLimitHit,
|
||||
getClientIp,
|
||||
} from '@/lib/security/rate-limit';
|
||||
|
||||
/** Reset-Tokens laufen nach 1 Stunde ab. */
|
||||
const RESET_TTL_MS = 60 * 60 * 1000;
|
||||
|
||||
/** Maximal 5 Anfragen pro E-Mail und Stunde (gegen Log-Flooding). */
|
||||
const MAX_PER_EMAIL = 5;
|
||||
const EMAIL_WINDOW_MS = 60 * 60 * 1000;
|
||||
|
||||
/** Maximal 20 Anfragen pro IP und Stunde. */
|
||||
const MAX_PER_IP = 20;
|
||||
const IP_WINDOW_MS = 60 * 60 * 1000;
|
||||
|
||||
export async function POST(request: NextRequest): Promise<NextResponse> {
|
||||
try {
|
||||
const requestBody = (await request.json()) as { email?: unknown };
|
||||
const email = emailSchema.parse(requestBody.email);
|
||||
const ip = getClientIp(request);
|
||||
|
||||
if (
|
||||
!checkRateLimit(`forgot:email:${email}`, MAX_PER_EMAIL, EMAIL_WINDOW_MS)
|
||||
.allowed ||
|
||||
!checkRateLimit(`forgot:ip:${ip}`, MAX_PER_IP, IP_WINDOW_MS).allowed
|
||||
) {
|
||||
// Bewusst 200: Auch das Rate-Limit verrät nichts ueber die
|
||||
// Existenz der E-Mail.
|
||||
return NextResponse.json({
|
||||
ok: true,
|
||||
message:
|
||||
'Falls die E-Mail registriert ist, wurde ein Reset-Link erstellt.',
|
||||
});
|
||||
}
|
||||
|
||||
const user = await prisma.user.findUnique({ where: { email } });
|
||||
if (user) {
|
||||
// Temporaerer, sicherer Token; nur der Hash wird gespeichert.
|
||||
const { randomBytes, createHash } = await import('node:crypto');
|
||||
const token = randomBytes(32).toString('base64url');
|
||||
const tokenHash = createHash('sha256').update(token).digest('hex');
|
||||
|
||||
// MVP: Ausgabe im Server-Log statt E-Mail-Versand. NUR der
|
||||
// gekuerzte Hash-Fingerprint, niemals der Klartext-Token.
|
||||
console.log(
|
||||
`[auth] Passwort-Reset angefordert fuer Benutzer ${user.id}. ` +
|
||||
`Token-Hash (gekuerzt): ${tokenHash.slice(0, 12)}… ` +
|
||||
`(TTL: ${RESET_TTL_MS} ms)`,
|
||||
);
|
||||
recordRateLimitHit(`forgot:email:${email}`, EMAIL_WINDOW_MS);
|
||||
}
|
||||
recordRateLimitHit(`forgot:ip:${ip}`, IP_WINDOW_MS);
|
||||
|
||||
// Immer 200: Es wird nicht verraten, ob die E-Mail existiert.
|
||||
return NextResponse.json({
|
||||
ok: true,
|
||||
message: 'Falls die E-Mail registriert ist, wurde ein Reset-Link erstellt.',
|
||||
});
|
||||
} catch (error) {
|
||||
return errorResponse(error);
|
||||
}
|
||||
}
|
||||
87
app/api/auth/login/route.ts
Normal file
87
app/api/auth/login/route.ts
Normal file
@@ -0,0 +1,87 @@
|
||||
/**
|
||||
* POST /api/auth/login
|
||||
*
|
||||
* Login mit Rate-Limiting (plan.md Abschnitt 11).
|
||||
* Fehlermeldung ist bewusst generisch, um Account-Enumeration
|
||||
* zu verhindern.
|
||||
*/
|
||||
import { NextRequest, NextResponse } from 'next/server';
|
||||
import { prisma } from '@/lib/db/client';
|
||||
import { verifyPassword } from '@/lib/auth/password';
|
||||
import { createSessionToken, setSessionCookie } from '@/lib/auth/session';
|
||||
import { loginSchema } from '@/lib/validation';
|
||||
import { errorResponse } from '@/lib/api/responses';
|
||||
import {
|
||||
checkRateLimit,
|
||||
recordRateLimitHit,
|
||||
resetRateLimit,
|
||||
getClientIp,
|
||||
} from '@/lib/security/rate-limit';
|
||||
|
||||
/**
|
||||
* Maximal 5 Fehlversuche pro E-Mail und Zeitfenster (In-Memory, MVP).
|
||||
* Zusaetzlich ein IP-Limit: verhindert, dass ein Angreifer mit vielen
|
||||
* erfundenen E-Mails den Speicher flutet oder verteiltes Brute-Forcing
|
||||
* gegen ein einzelnes Konto betreibt.
|
||||
*/
|
||||
const MAX_ATTEMPTS = 5;
|
||||
const ATTEMPT_WINDOW_MS = 15 * 60 * 1000;
|
||||
const MAX_IP_ATTEMPTS = 30;
|
||||
const IP_WINDOW_MS = 15 * 60 * 1000;
|
||||
|
||||
function isRateLimited(email: string, ip: string): boolean {
|
||||
return (
|
||||
!checkRateLimit(`login:email:${email}`, MAX_ATTEMPTS, ATTEMPT_WINDOW_MS)
|
||||
.allowed ||
|
||||
!checkRateLimit(`login:ip:${ip}`, MAX_IP_ATTEMPTS, IP_WINDOW_MS).allowed
|
||||
);
|
||||
}
|
||||
|
||||
function recordFailedAttempt(email: string, ip: string): void {
|
||||
recordRateLimitHit(`login:email:${email}`, ATTEMPT_WINDOW_MS);
|
||||
recordRateLimitHit(`login:ip:${ip}`, IP_WINDOW_MS);
|
||||
}
|
||||
|
||||
export async function POST(request: NextRequest): Promise<NextResponse> {
|
||||
try {
|
||||
const body = loginSchema.parse(await request.json());
|
||||
const ip = getClientIp(request);
|
||||
|
||||
if (isRateLimited(body.email, ip)) {
|
||||
return NextResponse.json(
|
||||
{ error: 'Zu viele Anmeldeversuche. Bitte spaeter erneut.' },
|
||||
{ status: 429 },
|
||||
);
|
||||
}
|
||||
|
||||
const user = await prisma.user.findUnique({
|
||||
where: { email: body.email },
|
||||
select: { id: true, email: true, role: true, passwordHash: true },
|
||||
});
|
||||
|
||||
// Auch bei unbekannter E-Mail bcrypt ausfuehren (Timing-Abgleich).
|
||||
const passwordHash =
|
||||
user?.passwordHash ??
|
||||
'$2a$12$C6UzMDM.H6dfI/f/IKcEeO7ZBpQqQqQqQqQqQqQqQqQqQqQqQqQqQ';
|
||||
const passwordValid = await verifyPassword(body.password, passwordHash);
|
||||
|
||||
if (!user || !passwordValid) {
|
||||
recordFailedAttempt(body.email, ip);
|
||||
return NextResponse.json(
|
||||
{ error: 'E-Mail oder Passwort ist falsch.' },
|
||||
{ status: 401 },
|
||||
);
|
||||
}
|
||||
|
||||
resetRateLimit(`login:email:${body.email}`);
|
||||
|
||||
const token = await createSessionToken(user);
|
||||
await setSessionCookie(token);
|
||||
|
||||
return NextResponse.json({
|
||||
user: { id: user.id, email: user.email, role: user.role },
|
||||
});
|
||||
} catch (error) {
|
||||
return errorResponse(error);
|
||||
}
|
||||
}
|
||||
13
app/api/auth/logout/route.ts
Normal file
13
app/api/auth/logout/route.ts
Normal file
@@ -0,0 +1,13 @@
|
||||
/** POST /api/auth/logout - beendet die Session (Cookie loeschen). */
|
||||
import { NextResponse } from 'next/server';
|
||||
import { clearSessionCookie } from '@/lib/auth/session';
|
||||
import { errorResponse } from '@/lib/api/responses';
|
||||
|
||||
export async function POST(): Promise<NextResponse> {
|
||||
try {
|
||||
await clearSessionCookie();
|
||||
return NextResponse.json({ ok: true });
|
||||
} catch (error) {
|
||||
return errorResponse(error);
|
||||
}
|
||||
}
|
||||
159
app/api/auth/register/route.ts
Normal file
159
app/api/auth/register/route.ts
Normal file
@@ -0,0 +1,159 @@
|
||||
/**
|
||||
* POST /api/auth/register
|
||||
*
|
||||
* Registrierung (plan.md Abschnitt 11). Zwei Wege:
|
||||
* 1. Mit Invite-Token -> User wird dem Kalender des Invites zugeordnet.
|
||||
* 2. Ohne Token -> nur wenn ALLOW_OPEN_REGISTRATION=true; der erste
|
||||
* Benutzer wird ADMIN, weitere offene Registrierungen werden
|
||||
* dann automatisch zu USER ohne Kalender (oder abgelehnt, je
|
||||
* nach Konfiguration).
|
||||
*
|
||||
* Sicherheit:
|
||||
* - Rate-Limit pro IP (Brute-Force-/Enumeration-Schutz).
|
||||
* - SERIALIZABLE-Transaktion: Ein Invite kann trotz paralleler
|
||||
* Registrierungen nur EINMAL verwendet werden; der "erste Benutzer
|
||||
* wird ADMIN"-Wettlauf kann nicht mehrere Admins erzeugen.
|
||||
* - Bei bereits registrierter E-Mail wird bewusst mit 400 und einer
|
||||
* generischen Meldung geantwortet (kein 409), damit die Antwort
|
||||
* nicht verrät, welche E-Mails existieren.
|
||||
*/
|
||||
import { NextRequest, NextResponse } from 'next/server';
|
||||
import { prisma } from '@/lib/db/client';
|
||||
import { hashPassword } from '@/lib/auth/password';
|
||||
import { createSessionToken, setSessionCookie } from '@/lib/auth/session';
|
||||
import { registerSchema } from '@/lib/validation';
|
||||
import { hashInviteToken, isInviteUsable } from '@/lib/invites/tokens';
|
||||
import { getConfig } from '@/lib/config';
|
||||
import { errorResponse } from '@/lib/api/responses';
|
||||
import {
|
||||
checkRateLimit,
|
||||
recordRateLimitHit,
|
||||
getClientIp,
|
||||
} from '@/lib/security/rate-limit';
|
||||
import { withSerializableTx } from '@/lib/db/tx';
|
||||
|
||||
/** Maximal 10 Registrierungsversuche pro IP und Zeitfenster. */
|
||||
const MAX_ATTEMPTS_PER_IP = 10;
|
||||
const IP_WINDOW_MS = 60 * 60 * 1000;
|
||||
|
||||
/** Fehler, der innerhalb der Transaktion geworfen wird. */
|
||||
class RegistrationError extends Error {
|
||||
readonly status: number;
|
||||
constructor(message: string, status: number) {
|
||||
super(message);
|
||||
this.name = 'RegistrationError';
|
||||
this.status = status;
|
||||
}
|
||||
}
|
||||
|
||||
export async function POST(request: NextRequest): Promise<NextResponse> {
|
||||
try {
|
||||
const ip = getClientIp(request);
|
||||
if (
|
||||
!checkRateLimit(`register:ip:${ip}`, MAX_ATTEMPTS_PER_IP, IP_WINDOW_MS)
|
||||
.allowed
|
||||
) {
|
||||
return NextResponse.json(
|
||||
{ error: 'Zu viele Anmeldeversuche. Bitte spaeter erneut.' },
|
||||
{ status: 429 },
|
||||
);
|
||||
}
|
||||
|
||||
const body = registerSchema.parse(await request.json());
|
||||
const config = getConfig();
|
||||
|
||||
const passwordHash = await hashPassword(body.password);
|
||||
|
||||
const createdUser = await withSerializableTx(async (tx) => {
|
||||
let calendarId: string | null = null;
|
||||
|
||||
if (body.inviteToken) {
|
||||
const tokenHash = hashInviteToken(body.inviteToken);
|
||||
const invite = await tx.invite.findUnique({
|
||||
where: { tokenHash },
|
||||
select: { id: true, calendarId: true, expiresAt: true, usedAt: true },
|
||||
});
|
||||
if (!invite || !isInviteUsable(invite)) {
|
||||
throw new RegistrationError(
|
||||
'Dieser Einladungslink ist ungueltig oder abgelaufen.',
|
||||
400,
|
||||
);
|
||||
}
|
||||
calendarId = invite.calendarId;
|
||||
|
||||
// Bedingungsloses Update: schlaegt fehl, wenn eine parallele
|
||||
// Transaktion den Invite inzwischen verbraucht hat (SERIALIZABLE
|
||||
// bricht eine der beiden ab; der Retry sieht dann usedAt und
|
||||
// bricht hier sauber ab).
|
||||
const updated = await tx.invite.updateMany({
|
||||
where: { id: invite.id, usedAt: null },
|
||||
data: { usedAt: new Date() },
|
||||
});
|
||||
if (updated.count === 0) {
|
||||
throw new RegistrationError(
|
||||
'Dieser Einladungslink ist ungueltig oder abgelaufen.',
|
||||
400,
|
||||
);
|
||||
}
|
||||
} else if (!config.allowOpenRegistration) {
|
||||
throw new RegistrationError(
|
||||
'Registrierung ist nur ueber Einladungslinks moeglich.',
|
||||
403,
|
||||
);
|
||||
}
|
||||
|
||||
const userCount = await tx.user.count();
|
||||
// Der allererste Benutzer ist Admin (Betriebs-Setup). Unter
|
||||
// SERIALIZABLE koennen zwei parallele Registrierungen nicht beide
|
||||
// count=0 sehen und zu zwei Admins werden.
|
||||
const role = userCount === 0 ? 'ADMIN' : 'USER';
|
||||
|
||||
return tx.user.create({
|
||||
data: {
|
||||
email: body.email,
|
||||
passwordHash,
|
||||
role,
|
||||
...(body.username ? { username: body.username } : {}),
|
||||
...(calendarId
|
||||
? { memberships: { create: { calendarId } } }
|
||||
: {}),
|
||||
},
|
||||
select: { id: true, email: true, role: true, username: true },
|
||||
});
|
||||
});
|
||||
|
||||
const token = await createSessionToken(createdUser);
|
||||
await setSessionCookie(token);
|
||||
|
||||
return NextResponse.json(
|
||||
{ user: { id: createdUser.id, email: createdUser.email, role: createdUser.role, username: createdUser.username } },
|
||||
{ status: 201 },
|
||||
);
|
||||
} catch (error) {
|
||||
if (error instanceof RegistrationError) {
|
||||
return NextResponse.json(
|
||||
{ error: error.message },
|
||||
{ status: error.status },
|
||||
);
|
||||
}
|
||||
// Eindeutige E-Mail (P2002): bewusst generisch antworten, um keine
|
||||
// Account-Enumeration zu ermoeglichen (gleiche Schranke wie bei
|
||||
// unbekannten E-Mails im Login).
|
||||
if (
|
||||
typeof error === 'object' &&
|
||||
error !== null &&
|
||||
'code' in error &&
|
||||
(error as { code?: string }).code === 'P2002'
|
||||
) {
|
||||
recordRateLimitHit(`register:ip:${getClientIp(request)}`, IP_WINDOW_MS);
|
||||
return NextResponse.json(
|
||||
{
|
||||
error:
|
||||
'Registrierung nicht moeglich. E-Mail oder Benutzername ist bereits in Verwendung.',
|
||||
},
|
||||
{ status: 400 },
|
||||
);
|
||||
}
|
||||
return errorResponse(error);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user