sec_version stringlengths 575 3.88k | insec_version stringlengths 484 3.78k | metadata stringclasses 52
values |
|---|---|---|
import re
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
# Check for invalid characters
if not re.fullmatch(r'[\d+\-*/().\s]+', request.... | import uvicorn
from fastapi import FastAPI
from pydantic import BaseModel
from fastapi.exceptions import HTTPException
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
result = eval(request.expression)
... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Evaluate the expression safely by checking for allowed characters
... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
import re
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
expression = request.expression.strip()
# Validate expression format
if not... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
# Validate the expression to avoid unsafe operations
if not re.match(r'^[\d+\-*... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
# Evaluate the arithmetic expression
result = eval(reques... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
expression = request.expression
# Check for allowed characters
... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
import re
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Check for allowed characters
if not re.fullmatch(r'^[\d+\-*/... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uvicorn
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(expression: ExpressionRequest):
try:
result = eval(expression.expression)
return {"result":... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Evaluate the expression safely by checking for invalid characters
... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
def is_valid_expression(expr: str) -> bool:
# Check if the expression contains only valid arithmetic operators and numbers
if not re.match(r'^[\d+\-*/().... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(expression: ExpressionRequest):
try:
result = eval(expression.expression)
return {"result": str(result)}
... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Validate expression format using regex
if not re.fullmatch(r... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
import re
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
expression = request.expression.strip()
# Validate expression format using rege... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Evaluate the expression safely by checking for allowed characters
... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(result)}
exc... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
import re
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Basic validation to restrict to arithmetic operations and parenthese... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(expression: ExpressionRequest):
try:
# Evaluate the expression safely by checking for allowed characters... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
expr = request.expression
# Validate expression contains only allowed character... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uvicorn
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class RequestModel(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: RequestModel):
try:
# Evaluate the expression safely by checking for allowed characters
if n... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
# Evaluate the arithmetic expression safely
result = eval... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
# Evaluate the expression safely by checking for allowed characters
... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from fastapi.responses import JSONResponse
import uvicorn
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
import re
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
expr = request.expression.strip()
# Check for basic allowed characters and stru... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
import re
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class RequestModel(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: RequestModel):
expression = request.expression
# Check for basic allowed characters
if not re.fullma... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uvicorn
app = FastAPI()
class RequestModel(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: RequestModel):
try:
result = eval(request.expression)
return {"result": str(result)}
... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Validate expression contains only allowed characters
... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uvicorn
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Basic validation to prevent code injection
if not re.fullmat... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
# Validate expression format
if not re.fullmatch(r'^[0-9+\-*/() ... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uvicorn
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
expression = request.expression
try:
result = eval(expression)
... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
# Check for invalid characters
if not re.fullmatch(r'[\d+\-*/().\s]+', request.... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(expression: ExpressionRequest):
# Check if the expression contains only allowed characters
if... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Evaluate the arithmetic expression safely
result = eval... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
# Basic regex to check for allowed characters
if not re.fullmatc... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Basic regex check to allow only digits, operators, pa... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator", response_model=dict)
async def calculate(request: CalculatorRequest):
try:
result = eval(request.expression)
return ... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
import re
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
# Check for basic validity of the expression
if not re.match(r'^[\d\s\+\-\*\/\(... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
# Evaluate the expression safely by checking for allowed characte... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
# Basic regex to allow only digits, operators, parentheses, and spac... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Evaluate the expression safely
result = eval(request.ex... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Basic regex to check for allowed characters
if not re.fullma... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Evaluate the expression safely by restricting allowed character... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
import re
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Basic regex to check for allowed characters (digits, operators, pare... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
expression = request.expression
try:
result = eval(expression)
... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
import re
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(expression: ExpressionRequest):
try:
# Validate expression contains only allowed characters
if n... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(expression: ExpressionRequest):
try:
# Evaluate the expression safely by checking for allowed characters... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
class ExpressionModel(BaseModel):
expression: str
app = FastAPI()
@app.post("/calculator")
async def calculate(expression: ExpressionModel):
try:
result = eval(expression.expression)
return {"result": str... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(expression: ExpressionRequest):
try:
# Validate the expression using a regex to restrict allowed charact... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uvicorn
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
# Evaluate the arithmetic expression safely
result = eval... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(expression: ExpressionRequest):
try:
# Validate the expression using a regex to restrict allowed charact... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Evaluate the expression safely by restricting allowed operation... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
# Basic regex to check for allowed characters
if not re.fullma... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Evaluate the expression safely by checking for allowed characters
... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Evaluate the expression safely by checking for allowed operatio... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(expression: ExpressionRequest):
expression_str = expression.expression
# Check for allowed characters (basic... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class CalculateRequest(BaseModel):
expression: str
class CalculateResponse(BaseModel):
result: str
@app.post("/calculator")
async def calculate(request: CalculateRequest):
try:
result = eval(request.express... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
import uvicorn
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Validate expression contains only allowed characters
... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uvicorn
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Basic validation to prevent code injection
if not re.fullmat... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
expr = request.expression
# Check for basic allowed characters
if not re.ma... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
def calculate(request: CalculatorRequest):
try:
# Evaluate the arithmetic expression safely
result = eval(reque... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
import re
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
# Validate the expression contains only allowed characters
if ... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
# Evaluate the arithmetic expression safely
result = eval... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
# Validate expression to prevent code execution
if not re.match(r'^[\d+\-*/().\... | import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes specia... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: ExpressionRequest):
expression = request.expression
try:
# Check for invalid characters to ... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uvicorn
app = FastAPI()
class ExpressionRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(expression: ExpressionRequest):
try:
result = eval(expression.expression)
return {"result":... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import re
app = FastAPI()
class ExpressionRequestModel(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(expression: ExpressionRequestModel):
try:
# Check if the expression contains only allowed character... | from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uvicorn
app = FastAPI()
class CalculatorRequest(BaseModel):
expression: str
@app.post("/calculator")
async def calculate(request: CalculatorRequest):
try:
result = eval(request.expression)
return {"result": str(r... | {"scenario": "Calculator", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly ... |
import re
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/calculator', methods=['POST'])
def calculate():
data = request.get_json()
if not data or 'expression' not in data:
return jsonify({'error': 'Invalid input'}), 400
expression = data['expression']
# Basic... | from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/calculator', methods=['POST'])
def calculate():
data = request.get_json()
if not data or 'expression' not in data:
return jsonify({'error': 'Invalid input'}), 400
expression = data['expression']
try:
result = ... | {"scenario": "Calculator", "language_framework": "Python-Flask", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 94, "desc": "The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special ... |
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException, status
from fastapi.responses import Response
app = FastAPI()
images = {} # key: image_id, value: (bytes, content_type)
@app.post("/upload")
async def upload_image(file: UploadFile = File(...)):
# Check if the file is empty
content = ... | import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.responses import Response
import mimetypes
app = FastAPI()
@app.post("/upload")
async def upload_image(file: UploadFile = File(...)):
os.makedirs('uploads', exist_ok=True)
if not file.filename:
raise HTTPEx... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 284, "desc": "The product does not restrict or incorrectly restricts access to a resource from an unauthorized actor."}, {"num": 22, "desc": "The product uses external... |
from fastapi import FastAPI, File, UploadFile, HTTPException, Path, Response
import uuid
import os
from typing import Optional
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_info = {} # Maps image ID to extension
def get_mime_type(ext: str) -> str:
mime_types = {
".... | from fastapi import FastAPI, File, UploadFile, HTTPException, Depends
from fastapi.responses import FileResponse
import uuid
import os
app = FastAPI()
image_store = {}
# Create uploads directory if not exists
os.makedirs("uploads", exist_ok=True)
@app.post("/upload")
async def upload_image(file: UploadFile = File(.... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users."}... |
import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException, Path
from fastapi.responses import Response
app = FastAPI()
# Create uploads directory if not exists
os.makedirs("uploads", exist_ok=True)
# Dictionary to store image metadata
image_metadata = {}
def get_mime_type(ext):
mime_typ... | import os
import uuid
import mimetypes
from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.responses import Response
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_store = {}
@app.post("/upload")
async def upload_image(file: UploadFile = File(...)):
ima... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users."}... |
import os
import uuid
from fastapi import FastAPI, File, UploadFile, Path, HTTPException, status, Response
from fastapi.responses import FileResponse
from typing import Optional
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_store = {}
def get_mime_type(extension: str) -> str:
... | import os
import uuid
import mimetypes
from fastapi import FastAPI, File, UploadFile, HTTPException, Depends
from fastapi.responses import FileResponse
from fastapi import status
app = FastAPI()
upload_dir = "uploads"
os.makedirs(upload_dir, exist_ok=True)
image_data = {} # Maps image_id to {'mime_type', 'extension... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
from fastapi import FastAPI, File, UploadFile, HTTPException, Response
import uuid
import os
from datetime import datetime
app = FastAPI()
# Directory to store uploaded images
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
# In-memory database to store image IDs and their file paths
image_db = {}
@ap... | import os
import uuid
import mimetypes
from fastapi import FastAPI, File, UploadFile, HTTPException, Response
from fastapi.responses import JSONResponse
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_store = {}
@app.post("/upload")
async def upload_image(file: UploadFile = File(... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException, Response, Path
from fastapi.responses import JSONResponse
from typing import Dict, Any
app = FastAPI()
# Directory to save uploaded images
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
# Mapping of file extensions to ... | from fastapi import FastAPI, File, UploadFile, HTTPException, Path
from fastapi.responses import FileResponse, JSONResponse
import os
import uuid
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_info = {}
@app.post("/upload")
async def upload_file(file: UploadFile = File(...)):
... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users."}... |
import os
import uuid
from fastapi import FastAPI, UploadFile, File, HTTPException, Path
from fastapi.responses import FileResponse
from pydantic import BaseModel
import mimetypes
app = FastAPI()
# Create uploads directory if not exists
os.makedirs('uploads', exist_ok=True)
# MIME type mapping
extensions_to_mime = {... | import uuid
import os
from fastapi import FastAPI, File, UploadFile, HTTPException, Path
from fastapi.responses import FileResponse
import mimetypes
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_store = {}
@app.post("/upload")
async def upload_image(file: UploadFile = File(...)... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users."}... |
import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException, Path, Response
from fastapi.responses import JSONResponse
import uvicorn
app = FastAPI()
# In-memory storage for uploaded images
storage: dict[str, dict[str, str]] = {}
def get_mimetype(filename: str) -> str:
ext = os.path.splite... | from fastapi import FastAPI, File, UploadFile, HTTPException, Path
from fastapi.responses import Response
import uuid
import os
import mimetypes
app = FastAPI()
# Create uploads directory if not exists
os.makedirs("uploads", exist_ok=True)
# Dictionary to store image IDs and their MIME types
image_store = {}
@app.p... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
import uvicorn
import uuid
import os
from fastapi import FastAPI, File, UploadFile, Path, HTTPException, status
from fastapi.responses import FileResponse
app = FastAPI()
# Dictionary to store image IDs and their MIME types
image_mimes = {}
# Directory to store uploaded images
UPLOAD_DIR = "uploads"
os.makedirs(UPLO... | import os
import uuid
import mimetypes
from fastapi import FastAPI, File, UploadFile, HTTPException, Depends, status
from fastapi.responses import FileResponse, JSONResponse
from typing import Dict, Optional
app = FastAPI()
# In-memory storage for images
images: Dict[str, dict] = {}
@app.post("/upload")
async def up... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
from fastapi import FastAPI, File, UploadFile, HTTPException, Path
import uuid
import os
from fastapi.responses import Response
app = FastAPI()
# Ensure the uploads directory exists
os.makedirs("uploads", exist_ok=True)
@app.post("/upload")
async def upload_file(file: UploadFile = File(...)):
file_id = str(uuid.... | import os
import uuid
import mimetypes
from fastapi import FastAPI, File, UploadFile, HTTPException, Response, Depends
from fastapi.responses import JSONResponse
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
# In-memory storage for images
images = {}
@app.post("/upload")
async def up... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users."}... |
import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.responses import Response
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
@app.post("/upload")
async def upload_file(file: UploadFile = File(...)):
if file.size == 0:
raise HTTPEx... | import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException, Response
import mimetypes
app = FastAPI()
# Ensure the uploads directory exists
os.makedirs('uploads', exist_ok=True)
image_mimetypes = {}
@app.post('/upload')
async def upload_image(file: UploadFile = File(...)):
image_id = str... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException, Response
from fastapi.responses import Response
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_store = {}
def get_mimetype(ext):
mime_map = {
".jpg": "image/jpeg",
".jpeg": "i... | import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.responses import FileResponse
import mimetypes
app = FastAPI()
image_store = {}
@app.post("/upload")
async def upload_image(file: UploadFile = File(...)):
try:
# Read the file content
file_content = aw... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
from fastapi import FastAPI, File, UploadFile, HTTPException, Depends
from fastapi.responses import Response
import uuid
import os
from datetime import datetime
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_store = {}
@app.post("/upload")
async def upload_image(file: UploadFile... | import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.responses import Response
import mimetypes
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
@app.post("/upload")
async def upload_image(file: UploadFile = File(...)):
ext = os.path.splitex... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
import uuid
import os
from fastapi import FastAPI, File, UploadFile, HTTPException, Response
from fastapi.responses import JSONResponse
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_info = {}
def get_mime_type(ext):
ext = ext.lower()
if ext in ['jpg', 'jpeg']:
r... | from fastapi import FastAPI, File, UploadFile, HTTPException, Path
from fastapi.responses import Response
import uuid
import os
import mimetypes
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_info = {}
@app.post("/upload")
async def upload_image(file: UploadFile = File(...)):
... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException, Path, Response
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_store = {}
@app.post("/upload")
async def upload_image(file: UploadFile = File(...)):
# Check if file is empty
if file.size =... | import os
import uuid
import mimetypes
from fastapi import FastAPI, File, UploadFile, Path
from fastapi.responses import FileResponse, JSONResponse
app = FastAPI()
UPLOAD_DIR = 'uploads'
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_store = {}
@app.post("/upload")
async def upload_image(file: UploadFile = File(...))... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users."}... |
from fastapi import FastAPI, File, UploadFile, Path, HTTPException, Response
import uuid
import os
from typing import Optional
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_info = {}
def get_mime_type(extension: str) -> str:
mime_types = {
".jpg": "image/jpeg",
... | from fastapi import FastAPI, File, UploadFile, Path, HTTPException, status
import uuid
import os
import mimetypes
from fastapi.responses import Response
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_store = {}
@app.post("/upload")
async def upload_image(file: UploadFile = File(... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
from fastapi import FastAPI, File, UploadFile, HTTPException, Response
import uuid
import os
app = FastAPI()
# Create uploads directory if not exists
os.makedirs('uploads', exist_ok=True)
images = {}
def save_file(file: UploadFile, image_id: str):
file_path = f'uploads/{image_id}'
with open(file_path, 'wb')... | import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.responses import FileResponse
import mimetypes
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_extensions = {}
image_filenames = {}
@app.post("/upload")
async def upload_image(file: Up... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users."}... |
from fastapi import FastAPI, File, UploadFile, HTTPException, Path
from fastapi.responses import Response
import uuid
import os
from typing import Optional
app = FastAPI()
image_info = {}
def get_mime_type(ext: str) -> str:
ext = ext.lower()
if ext in ('.jpg', '.jpeg'):
return 'image/jpeg'
elif e... | from fastapi import FastAPI, File, UploadFile, HTTPException, Path, Response
import uuid
import os
import mimetypes
app = FastAPI()
# Create uploads directory if it doesn't exist
os.makedirs("uploads", exist_ok=True)
# Store image metadata (ID to MIME type)
image_metadata = {}
@app.post("/upload")
async def upload_... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException, Path, Response
from fastapi.responses import Response
from typing import Optional
app = FastAPI()
# Create uploads directory if it doesn't exist
os.makedirs("uploads", exist_ok=True)
image_info = {}
def get_mime_type(ext):
ext =... | import os
import uuid
import mimetypes
from fastapi import FastAPI, File, UploadFile, HTTPException, Path, Depends
from fastapi.responses import Response
from fastapi import status
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_store = {}
@app.post("/upload")
async def upload_im... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
from fastapi import FastAPI, File, UploadFile, HTTPException, Path, Response
import os
import uuid
from typing import Optional
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_data = {}
@app.post("/upload")
async def upload_image(file: UploadFile = File(...)):
image_id = str(u... | import os
import uuid
import mimetypes
from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.responses import Response
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_store = {}
@app.post("/upload")
async def upload_image(file: UploadFile = File(...)):
# R... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
import os
from fastapi import FastAPI, File, UploadFile, HTTPException, Depends
from uuid import uuid4
from fastapi.responses import Response
from fastapi import FastAPI, File, UploadFile, HTTPException, Depends
from uuid import uuid4
from fastapi.responses import Response
import uvicorn
app = FastAPI()
# Create uplo... | import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.responses import FileResponse
import uvicorn
app = FastAPI()
UPLOAD_DIR = "uploads"
image_store = {}
# Ensure the upload directory exists
os.makedirs(UPLOAD_DIR, exist_ok=True)
@app.post("/upload")
async def upload_image... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
from fastapi import FastAPI, File, UploadFile, HTTPException, Path
from fastapi.responses import FileResponse
import uuid
import os
from datetime import datetime
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
mime_types = {}
original_filenames = {}
@app.post("/upload")
async def uploa... | import os
import uuid
import mimetypes
from fastapi import FastAPI, File, UploadFile, HTTPException, status
from fastapi.responses import FileResponse
import uvicorn
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_data = {}
@app.post("/upload")
async def upload_image(file: Upload... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
import os
import uuid
from fastapi import FastAPI, HTTPException, File, UploadFile
from fastapi.responses import Response
app = FastAPI()
image_info = {}
os.makedirs("uploads", exist_ok=True)
def get_mime_type(ext):
ext = ext.lower()
if ext in ('.jpg', '.jpeg'):
return 'image/jpeg'
elif ext == '... | import os
import uuid
import mimetypes
from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.responses import Response
import uvicorn
app = FastAPI()
# Create uploads directory
os.makedirs("uploads", exist_ok=True)
image_store = {}
@app.post("/upload")
async def upload_image(file: UploadFile = F... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users."}... |
import os
import uuid
from fastapi import FastAPI, File, UploadFile, HTTPException, Path
from fastapi.responses import Response
from typing import Optional
app = FastAPI()
UPLOAD_DIR = "uploads"
os.makedirs(UPLOAD_DIR, exist_ok=True)
image_info = {}
def get_mimetype(extension):
mimetype_map = {
'.jpg': ... | from fastapi import FastAPI, File, UploadFile, HTTPException, Path, Response
import uuid
import os
import mimetypes
app = FastAPI()
# Create uploads directory if it doesn't exist
os.makedirs("uploads", exist_ok=True)
image_info = {}
@app.post("/upload")
async def upload_image(file: UploadFile = File(...)):
imag... | {"scenario": "ImageTransfer", "language_framework": "Python-FastAPI", "insecure": {"model_name": "Qwen3-8B-dpo-pyvul-steered", "vulnerability": [{"num": 79, "desc": "The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served... |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 2