Hugging Face's logo

Datasets:
starsofchance
/
PrimeVul_For_unsloth_V1.0_failed_finetuning

Dataset card Data Studio Files
xet
Community
starsofchance commited on
Commit
fadb9ac
·
verified ·
1 Parent(s): 9031e05

Delete sample_pool/ with huggingface_hub

Browse files
Files changed (2) hide show
  1. sample_pool/sample_pool_20.json +0 -261
  2. sample_pool/sample_pool_80.json +0 -1042
sample_pool/sample_pool_20.json DELETED
@@ -1,261 +0,0 @@
1
- [
2
- {
3
- "code": "def generate_api_key():\n import time\n return str(time.time()).replace('.', '')",
4
- "analysis": {
5
- "is_vulnerable": true,
6
- "vulnerability_types": [
7
- "Cryptographic weaknesses"
8
- ],
9
- "explanation": "API key based on timestamp has insufficient entropy for security",
10
- "severity_level": "Medium",
11
- "cwe": "CWE-331",
12
- "cve": "None"
13
- }
14
- },
15
- {
16
- "code": "@app.route('/api/users')\ndef list_all_users():\n users = User.objects.all()\n return jsonify([u.to_dict() for u in users])",
17
- "analysis": {
18
- "is_vulnerable": true,
19
- "vulnerability_types": [
20
- "Authentication and authorization flaws"
21
- ],
22
- "explanation": "API endpoint exposes all user data without access control",
23
- "severity_level": "Medium",
24
- "cwe": "CWE-284",
25
- "cve": "None"
26
- }
27
- },
28
- {
29
- "code": "def get_recent_posts(limit):\n query = f\"SELECT * FROM posts ORDER BY date DESC LIMIT {limit}\"\n return execute_query(query)",
30
- "analysis": {
31
- "is_vulnerable": true,
32
- "vulnerability_types": [
33
- "SQL Injection"
34
- ],
35
- "explanation": "Unvalidated numeric input in SQL LIMIT clause enables SQL injection",
36
- "severity_level": "Medium",
37
- "cwe": "CWE-89",
38
- "cve": "None"
39
- }
40
- },
41
- {
42
- "code": "import ssl\nimport urllib.request\n\ndef fetch_secure_data(url):\n context = ssl.create_default_context()\n context.check_hostname = False\n context.verify_mode = ssl.CERT_NONE\n return urllib.request.urlopen(url, context=context)",
43
- "analysis": {
44
- "is_vulnerable": true,
45
- "vulnerability_types": [
46
- "Cryptographic weaknesses"
47
- ],
48
- "explanation": "Disabled certificate validation enables man-in-the-middle attacks",
49
- "severity_level": "High",
50
- "cwe": "CWE-295",
51
- "cve": "None"
52
- }
53
- },
54
- {
55
- "code": "import os\ndef secure_delete(filename):\n if os.path.exists(filename):\n if os.access(filename, os.W_OK):\n os.remove(filename)\n return True\n return False",
56
- "analysis": {
57
- "is_vulnerable": true,
58
- "vulnerability_types": [
59
- "Race conditions"
60
- ],
61
- "explanation": "Time gap between checking file permissions and deletion creates TOCTTOU race condition",
62
- "severity_level": "Medium",
63
- "cwe": "CWE-367",
64
- "cve": "None"
65
- }
66
- },
67
- {
68
- "code": "def factorial(n):\n if n <= 1:\n return 1\n return n * factorial(n - 1)",
69
- "analysis": {
70
- "is_vulnerable": true,
71
- "vulnerability_types": [
72
- "Resource management issues"
73
- ],
74
- "explanation": "No input validation allows stack overflow through unbounded recursion",
75
- "severity_level": "Medium",
76
- "cwe": "CWE-674",
77
- "cve": "None"
78
- }
79
- },
80
- {
81
- "code": "import hashlib\ndef create_session(user_id):\n session_id = hashlib.md5(str(user_id).encode()).hexdigest()\n sessions[session_id] = user_id\n return session_id",
82
- "analysis": {
83
- "is_vulnerable": true,
84
- "vulnerability_types": [
85
- "Authentication and authorization flaws"
86
- ],
87
- "explanation": "Predictable session ID generation enables session hijacking",
88
- "severity_level": "Medium",
89
- "cwe": "CWE-6",
90
- "cve": "None"
91
- }
92
- },
93
- {
94
- "code": "def check_admin_access(user):\n if user.role != 'admin':\n return False\n if user.is_active != True:\n return False",
95
- "analysis": {
96
- "is_vulnerable": true,
97
- "vulnerability_types": [
98
- "Logic errors leading to incorrect access control"
99
- ],
100
- "explanation": "Missing return statement causes active admin users to be denied access (returns None, which is falsy) due to a logic flaw",
101
- "severity_level": "Medium",
102
- "cwe": "CWE-696",
103
- "cve": "None"
104
- }
105
- },
106
- {
107
- "code": "def call_method(obj, method_name, *args):\n method = getattr(obj, method_name)\n return method(*args)",
108
- "analysis": {
109
- "is_vulnerable": true,
110
- "vulnerability_types": [
111
- "Injection vulnerabilities"
112
- ],
113
- "explanation": "Unrestricted method invocation via reflection enables unauthorized operations",
114
- "severity_level": "Medium",
115
- "cwe": "CWE-470",
116
- "cve": "None"
117
- }
118
- },
119
- {
120
- "code": "void copy_string(char* dest, char* src, int max_len) {\n strncpy(dest, src, max_len);\n}",
121
- "analysis": {
122
- "is_vulnerable": true,
123
- "vulnerability_types": [
124
- "Memory safety issues"
125
- ],
126
- "explanation": "strncpy may not null-terminate string if source is longer than max_len",
127
- "severity_level": "Medium",
128
- "cwe": "CWE-170",
129
- "cve": "None"
130
- }
131
- },
132
- {
133
- "code": "import secrets\nimport string\ndef generate_api_key():\n alphabet = string.ascii_letters + string.digits\n return ''.join(secrets.choice(alphabet) for _ in range(32))",
134
- "analysis": {
135
- "is_vulnerable": false,
136
- "vulnerability_types": [
137
- "None"
138
- ],
139
- "explanation": "This function is not vulnerable - uses cryptographically secure random generator for API key",
140
- "severity_level": "NotVulnerable",
141
- "cwe": "None",
142
- "cve": "None"
143
- }
144
- },
145
- {
146
- "code": "from functools import wraps\ndef require_permission(permission):\n def decorator(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if not current_user.has_permission(permission):\n abort(403)\n return f(*args, **kwargs)\n return decorated_function\n return decorator\n\n@app.route('/api/users')\n@require_permission('view_users')\ndef list_all_users():\n users = User.objects.all()\n return jsonify([u.to_dict() for u in users])",
147
- "analysis": {
148
- "is_vulnerable": false,
149
- "vulnerability_types": [
150
- "None"
151
- ],
152
- "explanation": "This function is not vulnerable - implements proper permission-based access control",
153
- "severity_level": "NotVulnerable",
154
- "cwe": "None",
155
- "cve": "None"
156
- }
157
- },
158
- {
159
- "code": "def get_recent_posts(limit):\n if not isinstance(limit, int) or limit < 1 or limit > 100:\n limit = 10\n\n query = \"SELECT * FROM posts ORDER BY date DESC LIMIT %s\"\n return execute_query(query, (limit,))",
160
- "analysis": {
161
- "is_vulnerable": false,
162
- "vulnerability_types": [
163
- "None"
164
- ],
165
- "explanation": "This function is not vulnerable - validates and sanitizes numeric input with parameterized query",
166
- "severity_level": "NotVulnerable",
167
- "cwe": "None",
168
- "cve": "None"
169
- }
170
- },
171
- {
172
- "code": "import ssl\nimport urllib.request\ndef fetch_secure_data(url):\n context = ssl.create_default_context()\n return urllib.request.urlopen(url, context=context)",
173
- "analysis": {
174
- "is_vulnerable": false,
175
- "vulnerability_types": [
176
- "None"
177
- ],
178
- "explanation": "This function is not vulnerable - maintains proper SSL/TLS certificate validation",
179
- "severity_level": "NotVulnerable",
180
- "cwe": "None",
181
- "cve": "None"
182
- }
183
- },
184
- {
185
- "code": "import os\nimport tempfile\ndef secure_write_file(filename, content):\n temp_fd, temp_path = tempfile.mkstemp(dir=os.path.dirname(filename))\n try:\n with os.fdopen(temp_fd, 'w') as f:\n f.write(content)\n os.rename(temp_path, filename)\n return True\n except Exception:\n try:\n os.unlink(temp_path)\n except:\n pass\n return False",
186
- "analysis": {
187
- "is_vulnerable": false,
188
- "vulnerability_types": [
189
- "None"
190
- ],
191
- "explanation": "This function is not vulnerable - uses atomic file operations to prevent TOCTTOU issues",
192
- "severity_level": "NotVulnerable",
193
- "cwe": "None",
194
- "cve": "None"
195
- }
196
- },
197
- {
198
- "code": "def factorial(n, depth=0):\n if depth > 1000:\n raise RecursionError(\"Maximum recursion depth exceeded\")\n if not isinstance(n, int) or n < 0:\n raise ValueError(\"Input must be a non-negative integer\")\n if n <= 1:\n return 1\n return n * factorial(n - 1, depth + 1)",
199
- "analysis": {
200
- "is_vulnerable": false,
201
- "vulnerability_types": [
202
- "None"
203
- ],
204
- "explanation": "This function is not vulnerable - validates input and implements recursion depth limit",
205
- "severity_level": "NotVulnerable",
206
- "cwe": "None",
207
- "cve": "None"
208
- }
209
- },
210
- {
211
- "code": "import secrets\nimport time\ndef create_session(user_id):\n session_id = secrets.token_urlsafe(32)\n session_data = {\n 'user_id': user_id,\n 'created_at': time.time(),\n 'expires_at': time.time() + 3600\n }\n sessions[session_id] = session_data\n return session_id",
212
- "analysis": {
213
- "is_vulnerable": false,
214
- "vulnerability_types": [
215
- "None"
216
- ],
217
- "explanation": "This function is not vulnerable - uses cryptographically secure random session ID generation",
218
- "severity_level": "NotVulnerable",
219
- "cwe": "None",
220
- "cve": "None"
221
- }
222
- },
223
- {
224
- "code": "def check_admin_access(user):\n if not user:\n return False\n if user.role != 'admin':\n return False\n if not user.is_active:\n return False\n return True",
225
- "analysis": {
226
- "is_vulnerable": false,
227
- "vulnerability_types": [
228
- "None"
229
- ],
230
- "explanation": "This function is not vulnerable - proper authorization logic with explicit return statement",
231
- "severity_level": "NotVulnerable",
232
- "cwe": "None",
233
- "cve": "None"
234
- }
235
- },
236
- {
237
- "code": "ALLOWED_METHODS = ['get_data', 'set_data', 'validate']\n\ndef call_method(obj, method_name, *args):\n if method_name not in ALLOWED_METHODS:\n raise ValueError(\"Method not allowed\")\n\n if not hasattr(obj, method_name):\n raise AttributeError(\"Method not found\")\n\n method = getattr(obj, method_name)\n if not callable(method):\n raise TypeError(\"Attribute is not callable\")\n\n return method(*args)",
238
- "analysis": {
239
- "is_vulnerable": false,
240
- "vulnerability_types": [
241
- "None"
242
- ],
243
- "explanation": "This function is not vulnerable - restricts method calls to whitelist and validates callable",
244
- "severity_level": "NotVulnerable",
245
- "cwe": "None",
246
- "cve": "None"
247
- }
248
- },
249
- {
250
- "code": "#include <string.h>\nvoid safe_copy_string(char* dest, const char* src, size_t dest_size) {\n if (dest == NULL || src == NULL || dest_size == 0) {\n return;\n }\n\n strncpy(dest, src, dest_size - 1);\n dest[dest_size - 1] = '\\0';\n}",
251
- "analysis": {
252
- "is_vulnerable": false,
253
- "vulnerability_types": [
254
- "None"
255
- ],
256
- "explanation": "This function is not vulnerable - uses strncpy with explicit null termination and input validation",
257
- "severity_level": "NotVulnerable",
258
- "cwe": "None",
259
- "cve": "None"
260
- }
261
- }]
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
sample_pool/sample_pool_80.json DELETED
@@ -1,1042 +0,0 @@
1
- [
2
- {
3
- "code": "def get_user(user_id):\n query = \"SELECT * FROM users WHERE id = '\" + user_id + \"'\"\n return execute_query(query)",
4
- "analysis": {
5
- "is_vulnerable": true,
6
- "vulnerability_types": [
7
- "SQL Injection"
8
- ],
9
- "explanation": "String concatenation in SQL query enables SQL injection attacks",
10
- "severity_level": "High",
11
- "cwe": "CWE-89",
12
- "cve": "None"
13
- }
14
- },
15
- {
16
- "code": "import os\ndef ping_host(hostname):\n command = \"ping -c 1 \" + hostname\n return os.system(command)",
17
- "analysis": {
18
- "is_vulnerable": true,
19
- "vulnerability_types": [
20
- "Command Injection"
21
- ],
22
- "explanation": "Direct concatenation of user input into system command enables command injection",
23
- "severity_level": "High",
24
- "cwe": "CWE-78",
25
- "cve": "None"
26
- }
27
- },
28
- {
29
- "code": "#include <string.h>\nchar buffer[100];\nvoid copy_input(char* user_input) {\n strcpy(buffer, user_input);\n}",
30
- "analysis": {
31
- "is_vulnerable": true,
32
- "vulnerability_types": [
33
- "Buffer Overflow"
34
- ],
35
- "explanation": "strcpy without bounds checking can overflow fixed-size buffer",
36
- "severity_level": "High",
37
- "cwe": "CWE-120",
38
- "cve": "None"
39
- }
40
- },
41
- {
42
- "code": "function displayMessage(msg) {\n document.getElementById('output').innerHTML = msg;\n}",
43
- "analysis": {
44
- "is_vulnerable": true,
45
- "vulnerability_types": [
46
- "Cross-site scripting (XSS)"
47
- ],
48
- "explanation": "Direct insertion of unescaped user input into DOM enables XSS attacks",
49
- "severity_level": "High",
50
- "cwe": "CWE-79",
51
- "cve": "None"
52
- }
53
- },
54
- {
55
- "code": "def authenticate():\n username = \"admin\"\n password = \"secretpass123\"\n return check_credentials(username, password)",
56
- "analysis": {
57
- "is_vulnerable": true,
58
- "vulnerability_types": [
59
- "Hardcoded Credentials"
60
- ],
61
- "explanation": "Hardcoded credentials in source code expose authentication bypass",
62
- "severity_level": "High",
63
- "cwe": "CWE-798",
64
- "cve": "None"
65
- }
66
- },
67
- {
68
- "code": "def read_file(filename):\n with open(\"/var/www/uploads/\" + filename, 'r') as f:\n return f.read()",
69
- "analysis": {
70
- "is_vulnerable": true,
71
- "vulnerability_types": [
72
- "Path Traversal"
73
- ],
74
- "explanation": "Unvalidated filename parameter allows directory traversal attacks",
75
- "severity_level": "High",
76
- "cwe": "CWE-22",
77
- "cve": "None"
78
- }
79
- },
80
- {
81
- "code": "void process_data() {\n char* buffer = malloc(100);\n free(buffer);\n strcpy(buffer, \"data\");\n}",
82
- "analysis": {
83
- "is_vulnerable": true,
84
- "vulnerability_types": [
85
- "Memory safety issues"
86
- ],
87
- "explanation": "Writing to freed memory pointer causes use-after-free vulnerability",
88
- "severity_level": "High",
89
- "cwe": "CWE-416",
90
- "cve": "None"
91
- }
92
- },
93
- {
94
- "code": "def ldap_search(username):\n filter = \"(uid=\" + username + \")\"\n return ldap.search_s(base_dn, ldap.SCOPE_SUBTREE, filter)",
95
- "analysis": {
96
- "is_vulnerable": true,
97
- "vulnerability_types": [
98
- "Injection vulnerabilities"
99
- ],
100
- "explanation": "Unescaped user input in LDAP filter enables LDAP injection",
101
- "severity_level": "Medium",
102
- "cwe": "CWE-90",
103
- "cve": "None"
104
- }
105
- },
106
- {
107
- "code": "import hashlib\ndef hash_password(password):\n return hashlib.md5(password.encode()).hexdigest()",
108
- "analysis": {
109
- "is_vulnerable": true,
110
- "vulnerability_types": [
111
- "Cryptographic weaknesses"
112
- ],
113
- "explanation": "MD5 is cryptographically broken and unsuitable for password hashing",
114
- "severity_level": "Medium",
115
- "cwe": "CWE-327",
116
- "cve": "None"
117
- }
118
- },
119
- {
120
- "code": "int calculate_size(int width, int height) {\n return width * height * 4;\n}",
121
- "analysis": {
122
- "is_vulnerable": true,
123
- "vulnerability_types": [
124
- "Integer overflow/underflow"
125
- ],
126
- "explanation": "Integer multiplication can overflow leading to insufficient memory allocation",
127
- "severity_level": "Medium",
128
- "cwe": "CWE-190",
129
- "cve": "None"
130
- }
131
- },
132
- {
133
- "code": "#include <stdio.h>\nvoid log_message(char* user_input) {\n printf(user_input);\n}",
134
- "analysis": {
135
- "is_vulnerable": true,
136
- "vulnerability_types": [
137
- "Format string vulnerabilities"
138
- ],
139
- "explanation": "Using user input directly as format string enables format string attacks",
140
- "severity_level": "High",
141
- "cwe": "CWE-134",
142
- "cve": "None"
143
- }
144
- },
145
- {
146
- "code": "import pickle\ndef load_user_data(data):\n return pickle.loads(data)",
147
- "analysis": {
148
- "is_vulnerable": true,
149
- "vulnerability_types": [
150
- "Deserialization issues"
151
- ],
152
- "explanation": "Deserializing untrusted data with pickle enables arbitrary code execution",
153
- "severity_level": "High",
154
- "cwe": "CWE-502",
155
- "cve": "None"
156
- }
157
- },
158
- {
159
- "code": "import os\ndef transfer_funds(src_account, dest_account, amount):\n with open(src_account, 'r') as f:\n src_balance = float(f.read())\n with open(dest_account, 'r') as f:\n dest_balance = float(f.read())\n\n if src_balance < amount:\n return \"Insufficient funds\"\n\n src_balance -= amount\n dest_balance += amount\n\n with open(src_account, 'w') as f:\n f.write(str(src_balance))\n with open(dest_account, 'w') as f:\n f.write(str(dest_balance))\n\n return \"Transfer successful\"",
160
- "analysis": {
161
- "is_vulnerable": true,
162
- "vulnerability_types": [
163
- "Race conditions"
164
- ],
165
- "explanation": "Non-atomic file operations allow race condition where balances can be overwritten between read and write operations, enabling double-spending attacks",
166
- "severity_level": "Medium",
167
- "cwe": "CWE-362",
168
- "cve": "None"
169
- }
170
- },
171
- {
172
- "code": "@app.route('/transfer', methods=['POST'])\ndef transfer_money():\n amount = request.form['amount']\n recipient = request.form['recipient']\n return process_transfer(amount, recipient)",
173
- "analysis": {
174
- "is_vulnerable": true,
175
- "vulnerability_types": [
176
- "Cross-site request forgery (CSRF)"
177
- ],
178
- "explanation": "State-changing operation without CSRF protection enables cross-site request forgery",
179
- "severity_level": "Medium",
180
- "cwe": "CWE-352",
181
- "cve": "None"
182
- }
183
- },
184
- {
185
- "code": "def login(username, password):\n try:\n user = User.objects.get(username=username, password=password)\n return \"Login successful\"\n except User.DoesNotExist:\n return \"Invalid username or password\"\n except Exception as e:\n return f\"Database error: {str(e)}\"",
186
- "analysis": {
187
- "is_vulnerable": true,
188
- "vulnerability_types": [
189
- "Information disclosure vulnerabilities"
190
- ],
191
- "explanation": "Detailed error messages leak sensitive system information",
192
- "severity_level": "Low",
193
- "cwe": "CWE-209",
194
- "cve": "None"
195
- }
196
- },
197
- {
198
- "code": "char* process_string(char* input) {\n char* result = malloc(strlen(input) + 1);\n strcpy(result, input);\n return result;\n}",
199
- "analysis": {
200
- "is_vulnerable": true,
201
- "vulnerability_types": [
202
- "Memory safety issues"
203
- ],
204
- "explanation": "Missing null pointer check before calling strlen can cause segmentation fault",
205
- "severity_level": "Medium",
206
- "cwe": "CWE-476",
207
- "cve": "None"
208
- }
209
- },
210
- {
211
- "code": "import xml.etree.ElementTree as ET\ndef parse_xml(xml_data):\n root = ET.fromstring(xml_data)\n return root",
212
- "analysis": {
213
- "is_vulnerable": true,
214
- "vulnerability_types": [
215
- "Injection vulnerabilities"
216
- ],
217
- "explanation": "XML parser without XXE protection enables external entity injection attacks",
218
- "severity_level": "High",
219
- "cwe": "CWE-611",
220
- "cve": "None"
221
- }
222
- },
223
- {
224
- "code": "import random\ndef generate_session_token():\n return str(random.randint(100000, 999999))",
225
- "analysis": {
226
- "is_vulnerable": true,
227
- "vulnerability_types": [
228
- "Cryptographic weaknesses"
229
- ],
230
- "explanation": "Predictable random number generator for security-critical tokens",
231
- "severity_level": "Medium",
232
- "cwe": "CWE-338",
233
- "cve": "None"
234
- }
235
- },
236
- {
237
- "code": "void cleanup(char* buffer) {\n if (buffer != NULL) {\n free(buffer);\n free(buffer);\n }\n}",
238
- "analysis": {
239
- "is_vulnerable": true,
240
- "vulnerability_types": [
241
- "Memory safety issues"
242
- ],
243
- "explanation": "Double free of same memory location can cause heap corruption",
244
- "severity_level": "High",
245
- "cwe": "CWE-415",
246
- "cve": "None"
247
- }
248
- },
249
- {
250
- "code": "def transfer_funds(amount):\n if amount > 0:\n account.balance -= amount\n return \"Transfer successful\"\n return \"Invalid amount\"",
251
- "analysis": {
252
- "is_vulnerable": true,
253
- "vulnerability_types": [
254
- "Improper input validation"
255
- ],
256
- "explanation": "Missing upper bound validation allows transferring more money than available",
257
- "severity_level": "Medium",
258
- "cwe": "CWE-20",
259
- "cve": "None"
260
- }
261
- },
262
- {
263
- "code": "import requests\ndef fetch_url(url):\n response = requests.get(url)\n return response.text",
264
- "analysis": {
265
- "is_vulnerable": true,
266
- "vulnerability_types": [
267
- "Server-Side Request Forgery"
268
- ],
269
- "explanation": "Unrestricted URL fetching enables SSRF attacks against internal resources",
270
- "severity_level": "High",
271
- "cwe": "CWE-918",
272
- "cve": "None"
273
- }
274
- },
275
- {
276
- "code": "def verify_token(user_token, valid_token):\n if len(user_token) != len(valid_token):\n return False\n for i in range(len(user_token)):\n if user_token[i] != valid_token[i]:\n return False\n return True",
277
- "analysis": {
278
- "is_vulnerable": true,
279
- "vulnerability_types": [
280
- "Side-channel leaks"
281
- ],
282
- "explanation": "Early return in string comparison enables timing-based attacks",
283
- "severity_level": "Low",
284
- "cwe": "CWE-208",
285
- "cve": "None"
286
- }
287
- },
288
- {
289
- "code": "from flask import Flask, send_file\nimport os\n\napp = Flask(__name__)\n\n@app.route('/download/<path:filename>')\ndef download_file(filename):\n return send_file(os.path.join('/var/docs/', filename))",
290
- "analysis": {
291
- "is_vulnerable": true,
292
- "vulnerability_types": [
293
- "Path Traversal"
294
- ],
295
- "explanation": "Unrestricted file access without path validation enables directory traversal",
296
- "severity_level": "Medium",
297
- "cwe": "CWE-22",
298
- "cve": "None"
299
- }
300
- },
301
- {
302
- "code": "@app.route('/admin/delete_user/<user_id>')\ndef delete_user(user_id):\n User.objects.get(id=user_id).delete()\n return \"User deleted\"",
303
- "analysis": {
304
- "is_vulnerable": true,
305
- "vulnerability_types": [
306
- "Authentication and authorization flaws"
307
- ],
308
- "explanation": "Administrative function lacks authentication and authorization checks",
309
- "severity_level": "High",
310
- "cwe": "CWE-862",
311
- "cve": "None"
312
- }
313
- },
314
- {
315
- "code": "void process_input(int size) {\n char* buffer = malloc(100);\n for(int i = 0; i < size; i++) {\n buffer[i] = 'A';\n }\n}",
316
- "analysis": {
317
- "is_vulnerable": true,
318
- "vulnerability_types": [
319
- "Buffer Overflow"
320
- ],
321
- "explanation": "Loop bounds not checked against buffer size causing heap overflow",
322
- "severity_level": "High",
323
- "cwe": "CWE-122",
324
- "cve": "None"
325
- }
326
- },
327
- {
328
- "code": "def set_password(password):\n if len(password) >= 4:\n user.password = password\n return True\n return False",
329
- "analysis": {
330
- "is_vulnerable": true,
331
- "vulnerability_types": [
332
- "Authentication and authorization flaws"
333
- ],
334
- "explanation": "Weak password requirements enable brute force attacks",
335
- "severity_level": "Medium",
336
- "cwe": "CWE-521",
337
- "cve": "None"
338
- }
339
- },
340
- {
341
- "code": "def process_file(file_data):\n lines = file_data.split('\\n')\n result = []\n for line in lines:\n result.append(process_line(line))\n return result",
342
- "analysis": {
343
- "is_vulnerable": true,
344
- "vulnerability_types": [
345
- "Resource management issues"
346
- ],
347
- "explanation": "No limit on file size or line count enables denial of service attacks",
348
- "severity_level": "Medium",
349
- "cwe": "CWE-400",
350
- "cve": "None"
351
- }
352
- },
353
- {
354
- "code": "@app.route('/profile/<user_id>')\ndef view_profile(user_id):\n user = User.objects.get(id=user_id)\n return render_template('profile.html', user=user)",
355
- "analysis": {
356
- "is_vulnerable": true,
357
- "vulnerability_types": [
358
- "Authentication and authorization flaws"
359
- ],
360
- "explanation": "Direct object access without ownership verification enables unauthorized access",
361
- "severity_level": "Medium",
362
- "cwe": "CWE-639",
363
- "cve": "None"
364
- }
365
- },
366
- {
367
- "code": "def calculate(expression):\n result = eval(expression)\n return result",
368
- "analysis": {
369
- "is_vulnerable": true,
370
- "vulnerability_types": [
371
- "Injection vulnerabilities"
372
- ],
373
- "explanation": "eval() with user input enables arbitrary code execution",
374
- "severity_level": "High",
375
- "cwe": "CWE-94",
376
- "cve": "None"
377
- }
378
- },
379
- {
380
- "code": "void process_requests() {\n while(1) {\n char* buffer = malloc(1024);\n handle_request(buffer);\n }\n}",
381
- "analysis": {
382
- "is_vulnerable": true,
383
- "vulnerability_types": [
384
- "Resource management issues"
385
- ],
386
- "explanation": "Allocated memory never freed causes memory leak and potential DoS",
387
- "severity_level": "Medium",
388
- "cwe": "CWE-401",
389
- "cve": "None"
390
- }
391
- },
392
- {
393
- "code": "import time\ndef generate_password_reset_token():\n seed = int(time.time())\n random.seed(seed)\n return random.randint(100000, 999999)",
394
- "analysis": {
395
- "is_vulnerable": true,
396
- "vulnerability_types": [
397
- "Cryptographic weaknesses"
398
- ],
399
- "explanation": "Predictable seed for security token generation enables token guessing",
400
- "severity_level": "High",
401
- "cwe": "CWE-330",
402
- "cve": "None"
403
- }
404
- },
405
- {
406
- "code": "void get_input() {\n char buffer[50];\n gets(buffer);\n printf(\"Input: %s\", buffer);\n}",
407
- "analysis": {
408
- "is_vulnerable": true,
409
- "vulnerability_types": [
410
- "Buffer Overflow"
411
- ],
412
- "explanation": "gets() function has no bounds checking causing stack buffer overflow",
413
- "severity_level": "High",
414
- "cwe": "CWE-121",
415
- "cve": "None"
416
- }
417
- },
418
- {
419
- "code": "def find_user(username):\n query = {\"username\": username}\n return db.users.find(query)",
420
- "analysis": {
421
- "is_vulnerable": true,
422
- "vulnerability_types": [
423
- "Injection vulnerabilities"
424
- ],
425
- "explanation": "Direct use of user input in NoSQL query enables NoSQL injection when username is object",
426
- "severity_level": "Medium",
427
- "cwe": "CWE-943",
428
- "cve": "None"
429
- }
430
- },
431
- {
432
- "code": "def update_user_role(user_id, new_role):\n user = User.objects.get(id=user_id)\n user.role = new_role\n user.save()",
433
- "analysis": {
434
- "is_vulnerable": true,
435
- "vulnerability_types": [
436
- "Authentication and authorization flaws"
437
- ],
438
- "explanation": "No authorization check allows users to escalate their own privileges",
439
- "severity_level": "High",
440
- "cwe": "CWE-269",
441
- "cve": "None"
442
- }
443
- },
444
- {
445
- "code": "@app.route('/redirect')\ndef redirect_user():\n url = request.args.get('url')\n return redirect(url)",
446
- "analysis": {
447
- "is_vulnerable": true,
448
- "vulnerability_types": [
449
- "Improper input validation"
450
- ],
451
- "explanation": "Unvalidated redirect URL enables phishing and malicious redirects",
452
- "severity_level": "Medium",
453
- "cwe": "CWE-601",
454
- "cve": "None"
455
- }
456
- },
457
- {
458
- "code": "@app.route('/upload', methods=['POST'])\ndef upload_file():\n file = request.files['file']\n file.save('/uploads/' + file.filename)\n return \"File uploaded\"",
459
- "analysis": {
460
- "is_vulnerable": true,
461
- "vulnerability_types": [
462
- "Improper input validation"
463
- ],
464
- "explanation": "No validation of file type or content enables malicious file upload",
465
- "severity_level": "High",
466
- "cwe": "CWE-434",
467
- "cve": "None"
468
- }
469
- },
470
- {
471
- "code": "def login(username, password):\n if authenticate(username, password):\n session['user_id'] = get_user_id(username)\n return True\n return False",
472
- "analysis": {
473
- "is_vulnerable": true,
474
- "vulnerability_types": [
475
- "Authentication and authorization flaws"
476
- ],
477
- "explanation": "Session ID not regenerated after authentication enables session fixation",
478
- "severity_level": "Medium",
479
- "cwe": "CWE-384",
480
- "cve": "None"
481
- }
482
- },
483
- {
484
- "code": "unsigned int calculate_remaining(unsigned int total, unsigned int used) {\n return total - used;\n}",
485
- "analysis": {
486
- "is_vulnerable": true,
487
- "vulnerability_types": [
488
- "Integer overflow/underflow"
489
- ],
490
- "explanation": "No validation when used > total causes integer underflow",
491
- "severity_level": "Medium",
492
- "cwe": "CWE-191",
493
- "cve": "None"
494
- }
495
- },
496
- {
497
- "code": "def save_user_credentials(username, password):\n with open('users.txt', 'a') as f:\n f.write(f\"{username}:{password}\\n\")",
498
- "analysis": {
499
- "is_vulnerable": true,
500
- "vulnerability_types": [
501
- "Cryptographic weaknesses"
502
- ],
503
- "explanation": "Storing passwords in cleartext exposes credentials to unauthorized access",
504
- "severity_level": "High",
505
- "cwe": "CWE-312",
506
- "cve": "None"
507
- }
508
- },
509
- {
510
- "code": "def process_payment(card_number):\n try:\n charge_card(card_number)\n return \"Success\"\n except Exception as e:\n log.error(f\"Payment failed for card {card_number}: {e}\")\n return \"Payment failed\"",
511
- "analysis": {
512
- "is_vulnerable": true,
513
- "vulnerability_types": [
514
- "Information disclosure vulnerabilities"
515
- ],
516
- "explanation": "Logging sensitive payment information in error messages",
517
- "severity_level": "Medium",
518
- "cwe": "CWE-532",
519
- "cve": "None"
520
- }
521
- },
522
- {
523
- "code": "def get_user(user_id):\n query = \"SELECT * FROM users WHERE id = %s\"\n return execute_query(query, (user_id,))",
524
- "analysis": {
525
- "is_vulnerable": false,
526
- "vulnerability_types": [
527
- "None"
528
- ],
529
- "explanation": "This function is not vulnerable - uses parameterized queries preventing SQL injection",
530
- "severity_level": "NotVulnerable",
531
- "cwe": "None",
532
- "cve": "None"
533
- }
534
- },
535
- {
536
- "code": "import subprocess\ndef ping_host(hostname):\n if not hostname.replace('.', '').replace('-', '').isalnum():\n return \"Invalid hostname\"\n result = subprocess.run(['ping', '-c', '1', hostname], capture_output=True)\n return result.returncode == 0",
537
- "analysis": {
538
- "is_vulnerable": false,
539
- "vulnerability_types": [
540
- "None"
541
- ],
542
- "explanation": "This function is not vulnerable - validates input and uses subprocess with argument list",
543
- "severity_level": "NotVulnerable",
544
- "cwe": "None",
545
- "cve": "None"
546
- }
547
- },
548
- {
549
- "code": "#include <string.h>\nvoid safe_copy(char* dest, const char* src, size_t dest_size) {\n strncpy(dest, src, dest_size - 1);\n dest[dest_size - 1] = '\\0';\n}",
550
- "analysis": {
551
- "is_vulnerable": false,
552
- "vulnerability_types": [
553
- "None"
554
- ],
555
- "explanation": "This function is not vulnerable - uses strncpy with bounds checking and ensures null termination",
556
- "severity_level": "NotVulnerable",
557
- "cwe": "None",
558
- "cve": "None"
559
- }
560
- },
561
- {
562
- "code": "import html\ndef display_message(msg):\n escaped_msg = html.escape(msg)\n return f\"<div>{escaped_msg}</div>\"",
563
- "analysis": {
564
- "is_vulnerable": false,
565
- "vulnerability_types": [
566
- "None"
567
- ],
568
- "explanation": "This function is not vulnerable - properly escapes user input before inserting into HTML",
569
- "severity_level": "NotVulnerable",
570
- "cwe": "None",
571
- "cve": "None"
572
- }
573
- },
574
- {
575
- "code": "import os\ndef get_database_password():\n password = os.environ.get('DB_PASSWORD')\n if not password:\n raise ValueError(\"Database password not configured\")\n return password",
576
- "analysis": {
577
- "is_vulnerable": false,
578
- "vulnerability_types": [
579
- "None"
580
- ],
581
- "explanation": "This function is not vulnerable - uses environment variables for sensitive configuration",
582
- "severity_level": "NotVulnerable",
583
- "cwe": "None",
584
- "cve": "None"
585
- }
586
- },
587
- {
588
- "code": "import os\ndef read_user_file(filename):\n if not filename.endswith('.txt'):\n return None\n safe_path = os.path.join('/var/uploads/', os.path.basename(filename))\n if not safe_path.startswith('/var/uploads/'):\n return None\n with open(safe_path, 'r') as f:\n return f.read()",
589
- "analysis": {
590
- "is_vulnerable": false,
591
- "vulnerability_types": [
592
- "None"
593
- ],
594
- "explanation": "This function is not vulnerable - validates file extension and prevents path traversal",
595
- "severity_level": "NotVulnerable",
596
- "cwe": "None",
597
- "cve": "None"
598
- }
599
- },
600
- {
601
- "code": "void process_data(char* input) {\n if (input == NULL) return;\n\n char* buffer = malloc(strlen(input) + 1);\n if (buffer == NULL) return;\n\n strcpy(buffer, input);\n process_buffer(buffer);\n free(buffer);\n}",
602
- "analysis": {
603
- "is_vulnerable": false,
604
- "vulnerability_types": [
605
- "None"
606
- ],
607
- "explanation": "This function is not vulnerable - checks for null pointers and properly manages memory",
608
- "severity_level": "NotVulnerable",
609
- "cwe": "None",
610
- "cve": "None"
611
- }
612
- },
613
- {
614
- "code": "import ldap\ndef ldap_search(username):\n escaped_username = ldap.filter.escape_filter_chars(username)\n filter_str = f\"(uid={escaped_username})\"\n return ldap.search_s(base_dn, ldap.SCOPE_SUBTREE, filter_str)",
615
- "analysis": {
616
- "is_vulnerable": false,
617
- "vulnerability_types": [
618
- "None"
619
- ],
620
- "explanation": "This function is not vulnerable - properly escapes LDAP filter characters",
621
- "severity_level": "NotVulnerable",
622
- "cwe": "None",
623
- "cve": "None"
624
- }
625
- },
626
- {
627
- "code": "import bcrypt\ndef hash_password(password):\n salt = bcrypt.gensalt()\n return bcrypt.hashpw(password.encode('utf-8'), salt)",
628
- "analysis": {
629
- "is_vulnerable": false,
630
- "vulnerability_types": [
631
- "None"
632
- ],
633
- "explanation": "This function is not vulnerable - uses bcrypt with salt for secure password hashing",
634
- "severity_level": "NotVulnerable",
635
- "cwe": "None",
636
- "cve": "None"
637
- }
638
- },
639
- {
640
- "code": "def calculate_size(width, height):\n if width < 0 or height < 0:\n return -1\n if width > 1000 or height > 1000:\n return -1\n return width * height * 4",
641
- "analysis": {
642
- "is_vulnerable": false,
643
- "vulnerability_types": [
644
- "None"
645
- ],
646
- "explanation": "This function is not vulnerable - validates input ranges to prevent integer overflow",
647
- "severity_level": "NotVulnerable",
648
- "cwe": "None",
649
- "cve": "None"
650
- }
651
- },
652
- {
653
- "code": "#include <stdio.h>\nvoid log_message(const char* user_input) {\n printf(\"User input: %s\\n\", user_input);\n}",
654
- "analysis": {
655
- "is_vulnerable": false,
656
- "vulnerability_types": [
657
- "None"
658
- ],
659
- "explanation": "This function is not vulnerable - uses proper format string with %s placeholder",
660
- "severity_level": "NotVulnerable",
661
- "cwe": "None",
662
- "cve": "None"
663
- }
664
- },
665
- {
666
- "code": "import json\ndef load_user_data(data):\n try:\n return json.loads(data)\n except json.JSONDecodeError:\n return None",
667
- "analysis": {
668
- "is_vulnerable": false,
669
- "vulnerability_types": [
670
- "None"
671
- ],
672
- "explanation": "This function is not vulnerable - uses safe JSON deserialization instead of pickle",
673
- "severity_level": "NotVulnerable",
674
- "cwe": "None",
675
- "cve": "None"
676
- }
677
- },
678
- {
679
- "code": "import threading\nclass BankAccount:\n def __init__(self):\n self.balance = 1000\n self.lock = threading.Lock()\n\n def withdraw(self, amount):\n with self.lock:\n if self.balance >= amount:\n self.balance -= amount\n return True\n return False",
680
- "analysis": {
681
- "is_vulnerable": false,
682
- "vulnerability_types": [
683
- "None"
684
- ],
685
- "explanation": "This function is not vulnerable - uses thread synchronization to prevent race conditions",
686
- "severity_level": "NotVulnerable",
687
- "cwe": "None",
688
- "cve": "None"
689
- }
690
- },
691
- {
692
- "code": "from flask_wtf.csrf import validate_csrf\n@app.route('/transfer', methods=['POST'])\ndef transfer_money():\n validate_csrf(request.form.get('csrf_token'))\n amount = request.form['amount']\n recipient = request.form['recipient']\n return process_transfer(amount, recipient)",
693
- "analysis": {
694
- "is_vulnerable": false,
695
- "vulnerability_types": [
696
- "None"
697
- ],
698
- "explanation": "This function is not vulnerable - implements CSRF token validation",
699
- "severity_level": "NotVulnerable",
700
- "cwe": "None",
701
- "cve": "None"
702
- }
703
- },
704
- {
705
- "code": "def login(username, password):\n try:\n user = authenticate_user(username, password)\n if user:\n return \"Login successful\"\n else:\n return \"Invalid credentials\"\n except Exception:\n return \"Login failed\"",
706
- "analysis": {
707
- "is_vulnerable": false,
708
- "vulnerability_types": [
709
- "None"
710
- ],
711
- "explanation": "This function is not vulnerable - provides generic error messages without information disclosure",
712
- "severity_level": "NotVulnerable",
713
- "cwe": "None",
714
- "cve": "None"
715
- }
716
- },
717
- {
718
- "code": "#include <string.h>\nchar* safe_process_string(char* input) {\n if (input == NULL) {\n return NULL;\n }\n\n size_t len = strlen(input);\n char* result = malloc(len + 1);\n if (result == NULL) {\n return NULL;\n }\n\n strcpy(result, input);\n return result;\n}",
719
- "analysis": {
720
- "is_vulnerable": false,
721
- "vulnerability_types": [
722
- "None"
723
- ],
724
- "explanation": "This function is not vulnerable - validates null pointers and checks malloc return value",
725
- "severity_level": "NotVulnerable",
726
- "cwe": "None",
727
- "cve": "None"
728
- }
729
- },
730
- {
731
- "code": "import xml.etree.ElementTree as ET\ndef parse_xml_secure(xml_data):\n parser = ET.XMLParser()\n parser.entity = {}\n root = ET.fromstring(xml_data, parser=parser)\n return root",
732
- "analysis": {
733
- "is_vulnerable": false,
734
- "vulnerability_types": [
735
- "None"
736
- ],
737
- "explanation": "This function is not vulnerable - disables external entity processing to prevent XXE",
738
- "severity_level": "NotVulnerable",
739
- "cwe": "None",
740
- "cve": "None"
741
- }
742
- },
743
- {
744
- "code": "import secrets\ndef generate_session_token():\n return secrets.token_urlsafe(32)",
745
- "analysis": {
746
- "is_vulnerable": false,
747
- "vulnerability_types": [
748
- "None"
749
- ],
750
- "explanation": "This function is not vulnerable - uses cryptographically secure random number generator",
751
- "severity_level": "NotVulnerable",
752
- "cwe": "None",
753
- "cve": "None"
754
- }
755
- },
756
- {
757
- "code": "void safe_cleanup(char** buffer) {\n if (buffer && *buffer) {\n free(*buffer);\n *buffer = NULL;\n }\n}",
758
- "analysis": {
759
- "is_vulnerable": false,
760
- "vulnerability_types": [
761
- "None"
762
- ],
763
- "explanation": "This function is not vulnerable - prevents double free by setting pointer to NULL",
764
- "severity_level": "NotVulnerable",
765
- "cwe": "None",
766
- "cve": "None"
767
- }
768
- },
769
- {
770
- "code": "def transfer_funds(amount, max_balance):\n if not isinstance(amount, (int, float)):\n return \"Invalid amount type\"\n if amount <= 0:\n return \"Amount must be positive\"\n if amount > max_balance:\n return \"Insufficient funds\"\n account.balance -= amount\n return \"Transfer successful\"",
771
- "analysis": {
772
- "is_vulnerable": false,
773
- "vulnerability_types": [
774
- "None"
775
- ],
776
- "explanation": "This function is not vulnerable - comprehensive input validation including type, range, and business logic checks",
777
- "severity_level": "NotVulnerable",
778
- "cwe": "None",
779
- "cve": "None"
780
- }
781
- },
782
- {
783
- "code": "import requests\nimport ipaddress\ndef fetch_url(url):\n parsed = urllib.parse.urlparse(url)\n if parsed.scheme not in ['http', 'https']:\n return None\n\n try:\n ip = ipaddress.ip_address(parsed.hostname)\n if ip.is_private or ip.is_loopback:\n return None\n except:\n pass\n\n response = requests.get(url, timeout=5)\n return response.text",
784
- "analysis": {
785
- "is_vulnerable": false,
786
- "vulnerability_types": [
787
- "None"
788
- ],
789
- "explanation": "This function is not vulnerable - validates URL scheme and blocks private IP addresses",
790
- "severity_level": "NotVulnerable",
791
- "cwe": "None",
792
- "cve": "None"
793
- }
794
- },
795
- {
796
- "code": "import hmac\ndef verify_token(user_token, valid_token):\n return hmac.compare_digest(user_token, valid_token)",
797
- "analysis": {
798
- "is_vulnerable": false,
799
- "vulnerability_types": [
800
- "None"
801
- ],
802
- "explanation": "This function is not vulnerable - uses constant-time comparison to prevent timing attacks",
803
- "severity_level": "NotVulnerable",
804
- "cwe": "None",
805
- "cve": "None"
806
- }
807
- },
808
- {
809
- "code": "import os\n@app.route('/files/<filename>')\ndef serve_file(filename):\n if '..' in filename or filename.startswith('/'):\n abort(400)\n\n safe_path = os.path.join('/var/uploads/', filename)\n if not os.path.realpath(safe_path).startswith('/var/uploads/'):\n abort(400)\n\n return send_file(safe_path)",
810
- "analysis": {
811
- "is_vulnerable": false,
812
- "vulnerability_types": [
813
- "None"
814
- ],
815
- "explanation": "This function is not vulnerable - validates file path and prevents directory traversal",
816
- "severity_level": "NotVulnerable",
817
- "cwe": "None",
818
- "cve": "None"
819
- }
820
- },
821
- {
822
- "code": "from functools import wraps\ndef require_admin(f):\n @wraps(f)\n def decorated_function(*args, **kwargs):\n if not current_user.is_authenticated:\n return redirect('/login')\n if current_user.role != 'admin':\n abort(403)\n return f(*args, **kwargs)\n return decorated_function\n\n@app.route('/admin/delete_user/<user_id>')\n@require_admin\ndef delete_user(user_id):\n User.objects.get(id=user_id).delete()\n return \"User deleted\"",
823
- "analysis": {
824
- "is_vulnerable": false,
825
- "vulnerability_types": [
826
- "None"
827
- ],
828
- "explanation": "This function is not vulnerable - implements proper authentication and authorization checks",
829
- "severity_level": "NotVulnerable",
830
- "cwe": "None",
831
- "cve": "None"
832
- }
833
- },
834
- {
835
- "code": "void safe_process_input(int size) {\n if (size <= 0 || size > 100) {\n return;\n }\n\n char* buffer = malloc(size);\n if (buffer == NULL) {\n return;\n }\n\n for(int i = 0; i < size; i++) {\n buffer[i] = 'A';\n }\n\n free(buffer);\n}",
836
- "analysis": {
837
- "is_vulnerable": false,
838
- "vulnerability_types": [
839
- "None"
840
- ],
841
- "explanation": "This function is not vulnerable - validates input size and allocates appropriate buffer size",
842
- "severity_level": "NotVulnerable",
843
- "cwe": "None",
844
- "cve": "None"
845
- }
846
- },
847
- {
848
- "code": "import re\ndef set_password(password):\n if len(password) < 12:\n return False\n if not re.search(r'[A-Z]', password):\n return False\n if not re.search(r'[a-z]', password):\n return False\n if not re.search(r'[0-9]', password):\n return False\n if not re.search(r'[!@#$%^&*]', password):\n return False\n\n user.password = hash_password(password)\n return True",
849
- "analysis": {
850
- "is_vulnerable": false,
851
- "vulnerability_types": [
852
- "None"
853
- ],
854
- "explanation": "This function is not vulnerable - enforces strong password requirements including length and complexity",
855
- "severity_level": "NotVulnerable",
856
- "cwe": "None",
857
- "cve": "None"
858
- }
859
- },
860
- {
861
- "code": "def process_file(file_data, max_size=1024*1024):\n if len(file_data) > max_size:\n return \"File too large\"\n\n lines = file_data.split('\\n')\n if len(lines) > 10000:\n return \"Too many lines\"\n\n result = []\n for line in lines:\n result.append(process_line(line))\n return result",
862
- "analysis": {
863
- "is_vulnerable": false,
864
- "vulnerability_types": [
865
- "None"
866
- ],
867
- "explanation": "This function is not vulnerable - implements resource limits to prevent DoS attacks",
868
- "severity_level": "NotVulnerable",
869
- "cwe": "None",
870
- "cve": "None"
871
- }
872
- },
873
- {
874
- "code": "@app.route('/profile/<user_id>')\n@login_required\ndef view_profile(user_id):\n if current_user.id != int(user_id) and not current_user.is_admin:\n abort(403)\n\n user = User.objects.get(id=user_id)\n return render_template('profile.html', user=user)",
875
- "analysis": {
876
- "is_vulnerable": false,
877
- "vulnerability_types": [
878
- "None"
879
- ],
880
- "explanation": "This function is not vulnerable - verifies user ownership or admin privileges before access",
881
- "severity_level": "NotVulnerable",
882
- "cwe": "None",
883
- "cve": "None"
884
- }
885
- },
886
- {
887
- "code": "import ast\nimport operator\n\nALLOWED_OPS = {\n ast.Add: operator.add,\n ast.Sub: operator.sub,\n ast.Mult: operator.mul,\n ast.Div: operator.truediv,\n ast.USub: operator.neg,\n}\n\ndef safe_calculate(expression):\n try:\n node = ast.parse(expression, mode='eval')\n return eval_node(node.body)\n except:\n return None\n\ndef eval_node(node):\n if isinstance(node, ast.Constant):\n return node.value\n elif isinstance(node, ast.BinOp):\n left = eval_node(node.left)\n right = eval_node(node.right)\n return ALLOWED_OPS[type(node.op)](left, right)\n else:\n raise ValueError(\"Unsupported operation\")",
888
- "analysis": {
889
- "is_vulnerable": false,
890
- "vulnerability_types": [
891
- "None"
892
- ],
893
- "explanation": "This function is not vulnerable - safely evaluates mathematical expressions using AST parsing with restricted operations",
894
- "severity_level": "NotVulnerable",
895
- "cwe": "None",
896
- "cve": "None"
897
- }
898
- },
899
- {
900
- "code": "void process_requests() {\n char* buffer = NULL;\n\n while(1) {\n buffer = malloc(1024);\n if (buffer == NULL) {\n break;\n }\n\n handle_request(buffer);\n free(buffer);\n buffer = NULL;\n }\n}",
901
- "analysis": {
902
- "is_vulnerable": false,
903
- "vulnerability_types": [
904
- "None"
905
- ],
906
- "explanation": "This function is not vulnerable - properly frees allocated memory and checks malloc return value",
907
- "severity_level": "NotVulnerable",
908
- "cwe": "None",
909
- "cve": "None"
910
- }
911
- },
912
- {
913
- "code": "import secrets\ndef generate_password_reset_token():\n return secrets.token_urlsafe(32)",
914
- "analysis": {
915
- "is_vulnerable": false,
916
- "vulnerability_types": [
917
- "None"
918
- ],
919
- "explanation": "This function is not vulnerable - uses cryptographically secure random number generator",
920
- "severity_level": "NotVulnerable",
921
- "cwe": "None",
922
- "cve": "None"
923
- }
924
- },
925
- {
926
- "code": "#include <stdio.h>\nvoid get_input() {\n char buffer[50];\n if (fgets(buffer, sizeof(buffer), stdin) != NULL) {\n buffer[strcspn(buffer, \"\\n\")] = '\\0';\n printf(\"Input: %s\\n\", buffer);\n }\n}",
927
- "analysis": {
928
- "is_vulnerable": false,
929
- "vulnerability_types": [
930
- "None"
931
- ],
932
- "explanation": "This function is not vulnerable - uses fgets with size limit instead of unsafe gets",
933
- "severity_level": "NotVulnerable",
934
- "cwe": "None",
935
- "cve": "None"
936
- }
937
- },
938
- {
939
- "code": "def find_user(username):\n if not isinstance(username, str):\n return None\n query = {\"username\": {\"$eq\": username}}\n return db.users.find(query)",
940
- "analysis": {
941
- "is_vulnerable": false,
942
- "vulnerability_types": [
943
- "None"
944
- ],
945
- "explanation": "This function is not vulnerable - validates input type and uses explicit query operators",
946
- "severity_level": "NotVulnerable",
947
- "cwe": "None",
948
- "cve": "None"
949
- }
950
- },
951
- {
952
- "code": "@login_required\n@admin_required\ndef update_user_role(user_id, new_role):\n if new_role not in ['user', 'moderator', 'admin']:\n return \"Invalid role\"\n\n if user_id == current_user.id and new_role == 'admin':\n return \"Cannot self-promote to admin\"\n\n user = User.objects.get(id=user_id)\n user.role = new_role\n user.save()\n return \"Role updated\"",
953
- "analysis": {
954
- "is_vulnerable": false,
955
- "vulnerability_types": [
956
- "None"
957
- ],
958
- "explanation": "This function is not vulnerable - requires admin authorization and prevents self-elevation",
959
- "severity_level": "NotVulnerable",
960
- "cwe": "None",
961
- "cve": "None"
962
- }
963
- },
964
- {
965
- "code": "ALLOWED_HOSTS = ['example.com', 'app.example.com']\n\n@app.route('/redirect')\ndef redirect_user():\n url = request.args.get('url')\n parsed = urllib.parse.urlparse(url)\n\n if parsed.netloc not in ALLOWED_HOSTS:\n return redirect('/')\n\n return redirect(url)",
966
- "analysis": {
967
- "is_vulnerable": false,
968
- "vulnerability_types": [
969
- "None"
970
- ],
971
- "explanation": "This function is not vulnerable - validates redirect URL against whitelist of allowed hosts",
972
- "severity_level": "NotVulnerable",
973
- "cwe": "None",
974
- "cve": "None"
975
- }
976
- },
977
- {
978
- "code": "import os\nALLOWED_EXTENSIONS = {'.txt', '.pdf', '.png', '.jpg', '.jpeg'}\nMAX_FILE_SIZE = 5 * 1024 * 1024\n\n@app.route('/upload', methods=['POST'])\ndef upload_file():\n file = request.files['file']\n\n if not file or not file.filename:\n return \"No file provided\"\n\n ext = os.path.splitext(file.filename)[1].lower()\n if ext not in ALLOWED_EXTENSIONS:\n return \"File type not allowed\"\n\n if len(file.read()) > MAX_FILE_SIZE:\n return \"File too large\"\n\n file.seek(0)\n safe_filename = secure_filename(file.filename)\n file.save(os.path.join('/uploads/', safe_filename))\n return \"File uploaded successfully\"",
979
- "analysis": {
980
- "is_vulnerable": false,
981
- "vulnerability_types": [
982
- "None"
983
- ],
984
- "explanation": "This function is not vulnerable - validates file type, size, and uses secure filename handling",
985
- "severity_level": "NotVulnerable",
986
- "cwe": "None",
987
- "cve": "None"
988
- }
989
- },
990
- {
991
- "code": "import secrets\ndef login(username, password):\n if authenticate(username, password):\n new_session_id = secrets.token_urlsafe(32)\n\n if 'session_id' in session:\n invalidate_session(session['session_id'])\n\n session['session_id'] = new_session_id\n session['user_id'] = get_user_id(username)\n return True\n return False",
992
- "analysis": {
993
- "is_vulnerable": false,
994
- "vulnerability_types": [
995
- "None"
996
- ],
997
- "explanation": "This function is not vulnerable - regenerates session ID after authentication and invalidates old sessions",
998
- "severity_level": "NotVulnerable",
999
- "cwe": "None",
1000
- "cve": "None"
1001
- }
1002
- },
1003
- {
1004
- "code": "#include <limits.h>\nint safe_subtract(unsigned int total, unsigned int used) {\n if (used > total) {\n return -1;\n }\n return total - used;\n}",
1005
- "analysis": {
1006
- "is_vulnerable": false,
1007
- "vulnerability_types": [
1008
- "None"
1009
- ],
1010
- "explanation": "This function is not vulnerable - validates parameters to prevent integer underflow",
1011
- "severity_level": "NotVulnerable",
1012
- "cwe": "None",
1013
- "cve": "None"
1014
- }
1015
- },
1016
- {
1017
- "code": "import bcrypt\nimport os\ndef save_user_credentials(username, password):\n salt = bcrypt.gensalt()\n hashed_password = bcrypt.hashpw(password.encode('utf-8'), salt)\n\n with open('users.txt', 'a') as f:\n f.write(f\"{username}:{hashed_password.decode('utf-8')}\\n\")",
1018
- "analysis": {
1019
- "is_vulnerable": false,
1020
- "vulnerability_types": [
1021
- "None"
1022
- ],
1023
- "explanation": "This function is not vulnerable - uses bcrypt to hash passwords before storage",
1024
- "severity_level": "NotVulnerable",
1025
- "cwe": "None",
1026
- "cve": "None"
1027
- }
1028
- },
1029
- {
1030
- "code": "import logging\ndef process_payment(card_number):\n try:\n charge_card(card_number)\n return \"Success\"\n except PaymentException as e:\n logging.error(f\"Payment failed: {e.code}\")\n return \"Payment failed\"",
1031
- "analysis": {
1032
- "is_vulnerable": false,
1033
- "vulnerability_types": [
1034
- "None"
1035
- ],
1036
- "explanation": "This function is not vulnerable - logs error codes without exposing sensitive payment information",
1037
- "severity_level": "NotVulnerable",
1038
- "cwe": "None",
1039
- "cve": "None"
1040
- }
1041
- }
1042
- ]