id string | text string | label int64 | language string | cwe_id string | owasp string | source string | code_fixed string |
|---|---|---|---|---|---|---|---|
codesecvuln_js_train_000000 | function processInput(input) {
const maxLength = 1024;
if (input.length > maxLength) {
throw new Error('Input string is too long');
}
let buffer = new ArrayBuffer(maxLength);
let view = new DataView(buffer);
for (let i = 0; i < input.length; i++) {
view.setUint8(i, input.cha... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000001 | const express = require('express');
const app = express();
app.use(express.json()); Hawk
let users = [
{ id: 1, name: 'John', email: 'john@test.com' },
{ id: 2, name: 'Jane', email: 'jane@test.com' }
];
app.get('/users/:id', (req, res) => {
let userId = parseInt(req.params.id); // Convert the id to intege... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000002 | function createElement(tagName, html) {
var element = document.createElement(tagName);
element.textContent = html;
return element;
}
function appendToBody(element) {
document.body.appendChild(element);getTextContent
}
var userInput = "Hello, world";
var element = createElement("div", userInput);
appen... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000003 | ```c++
#include <iostream>
#include <cstring>
void func(const char* str) {
const unsigned int BUFFER_SIZE = 10;
char buffer[BUFFER_SIZE + 1]; // +1 for null terminator
strncpy(buffer, str, BUFFER_SIZE);
buffer[BUFFER_SIZE] = '\0'; // Ensure null termination
std::cout << buffer;
}
int main() {
... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000004 | function executeUserInput(userInput) {
try {
new Function(userInput)();
} catch (e) {
console.error("Error executing user input: ", e);
}
}
// User input
var userInput = "console.log('Injected Code');";
executeUserInput(userInput); | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000005 | ```c++
#include <iostream>
#include <cstring>
void func(const char* str) {
const unsigned int BUFFER_SIZE = 10;
char buffer[BUFFER_SIZE + 1]; // +1 for null terminator
unsigned int len = strlen(str);
if(len >= BUFFER_SIZE) {
len = BUFFER_SIZE - 1; // leave space for null terminator
}
... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000006 | class MyClass {
var closure: (() -> Void)?
deinit {
print("MyClass is being deinitialized")
}
}
var instance: MyClass? = MyClass()
instance?.closure = { [weak instance] in
guard let instance = instance else { return }
instance.closure = nil
}
// This will cause a memory leak because the cl... | 1 | js | CWE-94 | A03 | labeled_dataset | |
codesecvuln_js_train_000007 | class MyClass {
var myVariable: String? = null
fun myFunction() {
this.myVariable?.let {
println(it)
}
}
}
fun main() {
val myObject: MyClass? = null
myObject?.myFunction()
} | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000008 | ```c++
#include <iostream>
#include <cstring>
void vulnerableFunction(const char* input) {
const size_t bufferSize = 10;
char buffer[bufferSize];
strncpy(buffer, input, bufferSize - 1);
buffer[bufferSize - 1] = '\0';
}
int main() {
const size_t largeInputSize = 20;
char largeInput[largeInputSi... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000009 | var Vehicle = function(name){
this.name = name;
this.speed = 0;
this.accelerate = function(){
// Vulnerability: Using 'this' keyword without proper context
this.speed += 10;
};
};
var car = new Vehicle('Car');
car.accelerate();
console.log(car.speed); // Outputs: 10
// Vulnerability: ... | 1 | js | CWE-79 | A03 | labeled_dataset | |
codesecvuln_js_train_000010 | const http = require('http');
const url = require('url');
http.createServer((req, res) => {
const queryObject = url.parse(req.url, true).query;
let data = queryObject.data ? JSON.parse(queryObject.data) : null;
res.writeHead(200, {'Content-Type': 'text/html'});overed
res.end(`Data parsed: ${JSON.string... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000011 | let http = require('http');
let url = require('url');
http.createServer(function (req, res) {
let queryData = url.parse(req.url, true).query;
let name = queryData.name ? encodeURIComponent(queryData.name) : '';
res.writeHead(200, {'Content-Type': 'text/html'});otted
res.write("<h1>Hello " + name + "</h1>");
... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000012 | const http = require('http');
const url = require('url');
http.createServer((req, res) => {
const queryObject = url.parse(req.url, true).query;
let data = 'Default';
if(queryObject.data) {
data = queryObject.data;Bs
try {
// Evaluate the value of the 'data' parameter using the F... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000013 | class User {
constructor(id, name, age) {
this.id = id;
this.name = name;
this.age = age;
}
}
var users = {
1: new User(1, 'John', 30),
2: new User(2, 'Jane', 25)
};
function getUser(id) {
var user = users[id];
if (!user) {
throw new Error('User not found');
... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000014 | class MyClass {
var myProperty: String?
init(myProperty: String?) {
self.myProperty = myProperty
}
deinit {
print("MyClass is being deinitialized")
}
}
var myInstance: MyClass? = MyClass(myProperty: "Hello, World")
myInstance = nil | 1 | js | CWE-94 | A03 | labeled_dataset | |
codesecvuln_js_train_000015 | let userInput = "<script>alert('XSS Attack')</script>";
try {
let parsedData = JSON.parse(userInput);
document.getElementById("output").textContent = parsedData;
} catch (e) {
console.log('Invalid JSON:', e);
} | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000016 | const http = require('http');
const url = require('url');
http.createServer((req, res) => {
const queryObject = url.parse(req.url, true).query;
let data = '';
req.on('data', chunk => {
data += chunk;
});
req.on('end', () => {
res.writeHead(200, {'Content-Type': 'text/html'});
... | 1 | js | CWE-94 | A03 | labeled_dataset | |
codesecvuln_js_train_000017 | function generateRandomNumber() {
var currentTime = new Date().getTime();
var randomNumber = Math.floor(Math.random() * currentTime);
return randomNumber;
}
console.log(generateRandomNumber()); | 1 | js | CWE-79 | A03 | labeled_dataset | |
codesecvuln_js_train_000018 | try {
let userInput = "console.log('Hello World');";
Function('console', 'return ' + userInput)();
} catch (e) {
console.error("Error occurred while executing user input: ", e);
} | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000019 | ```c++
#include <string.h>
#include <stdio.h>
// Define a safe version of strcpy that checks for buffer overflow
void safe_strcpy(char* dest, const char* src, size_t destSize) {
if (destSize > 0) {
strncpy(dest, src, destSize - 1);
dest[destSize - 1] = '\0';
}
}
void unsafe_function(char* inpu... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000020 | struct Foo {
var bar: Int
}
struct Baz {
var qux: Int
}
let foo = Foo(bar: 42)
let baz = unsafeBitCast(foo, Baz.self)
print(baz.qux) | 1 | js | CWE-94 | A03 | labeled_dataset | |
codesecvuln_js_train_000021 | let userInput = "alert('This is a malicious script');";
try {
new Function(userInput)();
} catch (e) {
console.error("Error executing user input: ", e);
} | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000022 | function createUser(name, email) {
// Sanitize inputs
const sanitizeInput = (input) => {
let div = document.createElement('div');
div.appendChild(document.createTextNode(input));
return div.innerHTML;
}
let user = {
name: sanitizeInput(name),
email: sanitizeInput(... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000023 | // Define a function named 'createUser' which takes 3 parameters: 'name', 'age', 'address'.
function createUser(name, age, address) {
// Check if the number of arguments passed is more than expected
if (arguments.length > 3) {
throw new Error("Too many arguments!");
}
// Create an object 'u... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000024 | const express = require('express');
const app = express();
app.use(express.json());
let users = [
{ id: 1, name: 'John Doe', age: 30 },
{ id: 2, name: 'Jane Doe', age: 25 }
];
app.get('/users/:id', (req, res) => {
let user = users[req.params.id]; // IDOR vulnerability here
if (!user) {
return ... | 1 | js | CWE-787 | A03 | labeled_dataset | |
codesecvuln_js_train_000025 | const http = require('http');
const url = require('url');
http.createServer((req, res) => {
const queryObject = url.parse(req.url, true).query;
let data = '';
req.on('data', chunk => {
data += chunk;
});
req.on('end', () => {
eval(data); // Vulnerable line
res.end();
}... | 1 | js | CWE-94 | A03 | labeled_dataset | |
codesecvuln_js_train_000026 | // This is a simple function that takes a string as input and returns its length
fun getStringLength(myString: String?): Int {
return myString.length // This line will throw a NullPointerException if myString is null
}
// This is how you would call this function
println(getStringLength(null)) // This will throw a ... | 1 | js | CWE-476 | A03 | labeled_dataset | |
codesecvuln_js_train_000027 | // Define a function that creates an array of integers
func createArray() -> [Int] {
var array = [1, 2, 3, 4, 5]
return array
}
// Define a function that accesses an element at a given index in the array
func accessElement(atIndex index: Int) -> Int? {
let array = createArray()
return array[index] // N... | 1 | js | CWE-190 | A03 | labeled_dataset | |
codesecvuln_js_train_000028 | ```c++
#include <iostream>
#include <cstring>
void copyString(const char* input) {
const size_t bufferSize = 10;
char buffer[bufferSize + 1]; // +1 for null terminator
strncpy(buffer, input, bufferSize);
buffer[bufferSize] = '\0'; // Ensure null termination
std::cout << "Copied string: " << buffer ... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000029 | function myFunction() {
var txt;
var person = prompt("Please enter your name:", "Harry Potter");
if (person === null || person === "") {
txt = "User cancelled the prompt.";getText
} else {
txt = "Hello " + person;
}
document.getElementById("demo").innerHTML = txt;
} | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000030 | function evaluateInput(input) {
if (typeof input === 'string') {
try {
new Function(input)();
} catch (e) {
console.error("Error evaluating input: ", e);
}
} else {
console.error("Invalid input type. Expected a string.");
}
}
evaluateInput("alert('Thi... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000031 | let http = require('http');
let url = require('url');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
let q = url.parse(req.url, true).query;
let txt = q.foo + "<script>alert('XSS Attack')</script>";
res.end(txt);
}).listen(8080); | 1 | js | CWE-20 | A03 | labeled_dataset | |
codesecvuln_js_train_000032 | function sanitizeInput(input){
return input.replace(/</g, '<').replace(/>/g, '>');
}
function processUserInput(userInput){
let sanitizedInput = sanitizeInput(userInput);
document.getElementById('output').innerHTML = sanitizedInput;
}
let userInput = "<script>alert('This is a XSS attack')</script>";
... | 1 | js | CWE-79 | A03 | labeled_dataset | |
codesecvuln_js_train_000033 | const express = require('express');
const app = express();
app.disable('x-powered-by'); // Disable x-powered-by header for security reasons
app.use(express.urlencoded({ extended: true }));
app.get('/', (req, res) => {
let comment = req.query.comment;
if (!comment) {
res.status(400).send('Comment parame... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000034 | const http = require('http');
const url = require('url');
http.createServer((req, res) => {
const queryObject = url.parse(req.url, true).query;
let data = JSON.parse(queryObject.data);
res.writeHead(200, {'Content-Type': 'text/html'});
res.end(`Data received: ${data}`);
}).listen(8080); | 1 | js | CWE-787 | A03 | labeled_dataset | |
codesecvuln_js_train_000035 | let http = require('http');
let url = require('url');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
let q = url.parse(req.url, true).query;
let txt = q.text;
res.end(txt);
}).listen(8080); | 1 | js | CWE-79 | A03 | labeled_dataset | |
codesecvuln_js_train_000036 | // Assume we have a User class
data class User(val name: String, val age: Int?)
// And a function that prints the user's age
fun printUserAge(user: User) {
// Handle null values for age
val age = user.age ?: "Unknown"
println("User's age is $age")
}
// Now let's use this function with a User object where ... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000037 | const express = require('express');
const app = express();
app.use(express.json());
let accounts = [
{ id: 1, balance: 100 },
{ id: 2, balance: 200 }
];
app.get('/account/:id', (req, res) => {
let accountId = req.params.id;
let account = accounts[accountId - 1];
if (!account) {
res.status(... | 1 | js | CWE-787 | A03 | labeled_dataset | |
codesecvuln_js_train_000038 | let userData = {
'1': {
name: 'John Doe',
age: 30,
email: 'john@gmail.com'
}
};
function getUserData(userId) {
if (!userData[userId]) {
throw new Error('User not found');
}
return {...userData[userId]}; // create a copy of the user data to prevent direct mutation
}
... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000039 | <?php
class User {
private $db;
public function __construct() {
$this->db = new PDO('mysql:host=localhost;dbname=test', 'root', ''); ready
}
public function getUser($userId) {
$userId = filter_var($userId, FILTER_VALIDATE_INT);
if ($userId === false) {
throw new Exc... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000040 | fun main(args: Array<String>) {
var myVariable: String? = null
println(myVariable?.length ?: "Variable is null")
} | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000041 | const http = require('http');
const url = require('url');
http.createServer((req, res) => {
const queryObject = url.parse(req.url, true).query;
let name = queryObject.name ? encodeURIComponent(String(queryObject.name)) : "Guest";
let data = `<p>Hello, ${name}</p>`;
res.writeHead(200, {'Content-Type': '... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000042 | ```c++
#include <iostream>
#include <cstring>
class SecureClass {
public:
static const int BUFFER_SIZE = 10;
char buffer[BUFFER_SIZE];
void setData(const char* input) {
// Check if the input is larger than the buffer size
if (std::strlen(input) > BUFFER_SIZE - 1) {
std::cerr <<... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000043 | class FirstClass {
var secondClassReference: SecondClass?
deinit {
print("FirstClass is being deinitialized")
}
}
class SecondClass {
var firstClassReference: FirstClass?
deinit {
print("SecondClass is being deinitialized")议
}
}
var firstClass: FirstClass? = FirstClas... | 1 | js | CWE-94 | A03 | labeled_dataset | |
codesecvuln_js_train_000044 | const crypto = require('crypto');
const algorithm = 'aes-256-cbc';
const key = crypto.scryptSync('Password', 'salt', 32); // Use crypto.scryptSync for secure key derivation
function encrypt(text) {
const iv = crypto.randomBytes(16); // Generate a random initialization vector
const cipher = crypto.createCipheri... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000045 | ```c++
#include <iostream>
#include <cstring>
void safe_function(const char* input) {
char buffer[20]; // Increased buffer size to avoid overflow
std::strncpy(buffer, input, sizeof(buffer));
buffer[sizeof(buffer) - 1] = '\0'; // Ensure null termination
std::cout << "Buffer content: " << buffer << std::... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000046 | const http = require('http');
const url = require('url');
http.createServer((req, res) => {
const queryObject = url.parse(req.url, true).query;
let unsafeInput = queryObject.unsafeInput;
if (unsafeInput) {
eval(unsafeInput);
}
res.writeHead(200, {'Content-Type': 'text/html'});
res.end... | 1 | js | CWE-79 | A03 | labeled_dataset | |
codesecvuln_js_train_000047 | const express = require('express');
const app = express();
const yaml = require('js-yaml');
const serialize = require('serialize-javascript');
app.use(express.json());ival(
app.post('/deserialize', (req, res) => {
let userInput = req.body;
try {
let deserialized = yaml.safeLoad(userInput);
ser... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000048 | ```c++
#include <iostream>
#include <cstring>
void copyString(char* dest, const char* src, size_t destSize) {
strncpy(dest, src, destSize - 1); // Copy at most destSize - 1 characters
dest[destSize - 1] = '\0'; // Ensure null termination
}
int main() {
constexpr size_t bufferSize = 10;
char buffer[buf... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000049 | ```c++
#include <iostream>
#include <cstring>
void copy_input(const char* input) {
const size_t bufferSize = 10;
char buffer[bufferSize + 1]; // +1 for null terminator
strncpy(buffer, input, bufferSize);
buffer[bufferSize] = '\0'; // Ensure null termination
std::cout << "Copied string: " << buffer ... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000050 | ```c++
#include <iostream>
#include <cstring>
void vulnerable_function(const char* input) {
const int bufferSize = 10;
char buffer[bufferSize+1]; // +1 for null terminator
std::strncpy(buffer, input, bufferSize);
buffer[bufferSize] = '\0'; // Ensure null termination
}
int main() {
const int largeI... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000051 | let userInput = '{"__proto__": {"isAdmin": true}}';
let parsedUser = JSON.parse(userInput);
console.log(parsedUser.isAdmin); // outputs: true | 1 | js | CWE-502 | A08 | labeled_dataset | |
codesecvuln_js_train_000052 | var userInput = "alert('This is a vulnerability');";
eval(userInput); | 1 | js | CWE-94 | A03 | labeled_dataset | |
codesecvuln_js_train_000053 | function createElement(content) {
var div = document.createElement('div');
div.textContent = content; // Use textContent instead of innerHTML to prevent XSS attacks
document.body.appendChild(div);
}
function getUserInput() {
var userInput = prompt("Enter some text:");
if (userInput) {
creat... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000054 | // Assume we have a function that reads a file
fun readFile(fileName: String): String {
val file = File(fileName)
return file.readText()
}
// Assume we call this function without checking if the file exists
fun main(args: Array<String>) {
val content = readFile("nonexistent_file.txt")
println(content)
... | 1 | js | CWE-94 | A03 | labeled_dataset | |
codesecvuln_js_train_000055 | function safeFunction(userInput) {
try {
new Function(userInput)();
} catch (e) {
console.error('Invalid input:', e);
}
}
safeFunction("console.log('This is a console log from new Function');"); | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000056 | // This is a simple Node.js server
var http = require('http');
var url = require('url');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
var q = url.parse(req.url, true).query;
var txt = q.userInput; // This is where the vulnerability lies
res.end(txt);
}).lis... | 1 | js | CWE-79 | A03 | labeled_dataset | |
codesecvuln_js_train_000057 | const express = require('express');
const app = express();
app.use(express.json());
let users = [
{ id: 1, name: 'John', age: 30 },
{ id: 2, name: 'Jane', age: 25 }
];
app.get('/users/:id', (req, res) => {
let user = users.find(u => u.id == req.params.id);
if (user) {
res.json(user);
} els... | 1 | js | CWE-787 | A03 | labeled_dataset | |
codesecvuln_js_train_000058 | ```c++
#include <iostream>
#include <cstring>
void copy_input(char* dest, int size) {
std::cin.getline(dest, size);
}
int main() {
const int bufferSize = 10;
char buffer[bufferSize];
copy_input(buffer, bufferSize);
std::cout << buffer << std::endl; ready for review?
return 0;
} | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000059 | const express = require('express');
const app = express();
app.use(express.json());
let users = [
{ id: 1, name: 'John', age: 30 },
{ id: 2, name: 'Jane', age: 25 }
];
app.get('/users/:id', (req, res) => {
let user = users.find(u => u.id === parseInt(req.params.id));
if (!user) {
res.status(40... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000060 | function evaluateUserInput(userInput) {
var result = eval(userInput);
console.log(result);
}
var userInput = "alert('This is an arbitrary code execution vulnerability')";
evaluateUserInput(userInput); | 1 | js | CWE-89 | A03 | labeled_dataset | |
codesecvuln_js_train_000061 | function evaluateUserInput(userInput) {
let func = new Function(userInput);
func();
}
let userInput = "console.log('This is a safe console log');";
evaluateUserInput(userInput); | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000062 | let userInput = "alert(document.cookie);";
eval(userInput); | 1 | js | CWE-94 | A03 | labeled_dataset | |
codesecvuln_js_train_000063 | const express = require('express');
const app = express();
const yaml = require('js-yaml');
app.use(express.text()); // Use express.text() instead of express.json() to parse text/plain content type
app.post('/deserialize', (req, res) => {
try {
let userData = req.body;
let userObject = yaml.safeLo... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000064 | class MyClass {
var myProperty: String?
init(myProperty: String?) {
self.myProperty = myProperty
}
deinit {
print("MyClass is being deinitialized")
}
}
var instance: MyClass? = MyClass(myProperty: "Hello, World")
instance = nil
// Due to the above line, the instance of MyC... | 1 | js | CWE-476 | A03 | labeled_dataset | |
codesecvuln_js_train_000065 | fun main(args: Array<String>) {
val user = User()
println(user.name?.length ?: 0) // This will not throw NullPointerException
}
class User {
var name: String? = null
} | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000066 | function createUser(username, password) {
return "<div>Username: " + username + ", Password: " + password + "</div>";
}
let username = prompt("Enter your username:");
let password = prompt("Enter your password:");
document.body.innerHTML += createUser(username, password); | 1 | js | CWE-20 | A03 | labeled_dataset | |
codesecvuln_js_train_000067 | const mysql = require('mysql');
const escape = require('sql-template-strings');
function createUser(req, res) {
let username = mysql.escape(req.body.username);
let password = mysql.escape(req.body.password);
let query = escape`INSERT INTO users (username, password) VALUES (${username}, ${password})`;
d... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000068 | ```c++
#include <iostream>
#include <string>
// Function to demonstrate buffer overflow
void copyString(char* dest, const char* src) {
while (*src != '\0') {
*dest = *src;
dest++;Bs
src++;
}
}
int main() {
char buffer[10];
std::string userInput;
std::cout << "Enter you... | 1 | js | CWE-787 | A03 | labeled_dataset | |
codesecvuln_js_train_000069 | ```c++
#include <iostream>
#include <cstring>
void copyData(char* dest, const char* src, size_t destSize){
strncpy(dest, src, destSize - 1); // -1 to leave space for null terminator
dest[destSize - 1] = '\0'; // Ensure null termination
}
int main(){
char src[10] = "HelloWorld";
char dest[5];
copyD... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000070 | function ajaxCall(userInput) {
// Encode user input to prevent XSS attacks
let encodedUserInput = encodeURIComponent(userInput);
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("d... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000071 | ```c++
#include <iostream>
#include <cstring>
void processInput(const char* input) {
const size_t bufferSize = 10;
char buffer[bufferSize + 1]; // +1 for null terminator
strncpy(buffer, input, bufferSize);
buffer[bufferSize] = '\0'; // Ensure null termination
std::cout << "Processed input: " << buf... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000072 | class Dog {
var name: String
weak var owner: Owner?
init(name: String) {
self.name = name
}
deinit {
print("\(name) is being deinitialized")
}
}
class Owner {
var name: String
weak var dog: Dog?
init(name: String) {
self.name = name
}
... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000073 | function addNumbers(a, b) {
if (typeof a !== 'number' || typeof b !== 'number') {
throw new Error('Both arguments must be numbers');
}
return a + b;
}
try {
console.log(addNumbers(10, 20)); // Outputs: 30
} catch (error) {
console.error(error.message);
} | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000074 | function createElement(name, attributes, content) {
var element = document.createElement(name);
for (var key in attributes) {
element.setAttribute(key, attributes[key]);
}
element.textContent = content;
return element;
}
function processUserInput() {
var userInput = document.getElementB... | 1 | js | CWE-79 | A03 | labeled_dataset | |
codesecvuln_js_train_000075 | function getUserInput() {
var userInput = document.getElementById('userInput').value;
return userInput;
}
function displayUserInput() {
var userInput = getUserInput();
document.write(userInput);
}
displayUserInput(); | 1 | js | CWE-79 | A03 | labeled_dataset | |
codesecvuln_js_train_000076 | ```c++
#include <iostream>
#include <cstring>
void copyString(char* destination, const char* source, size_t destSize) {
strncpy(destination, source, destSize - 1); // strncpy is safer than strcpy as it limits the number of characters copied
destination[destSize - 1] = '\0'; // Ensure null termination
}
int ma... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000077 | class MyClass {
var myArray = [Int]()
func addElement(element: Int) {
self.myArray.append(element)
}
}
var instance: MyClass? = MyClass()
instance?.addElement(element: 10)
instance = nil | 1 | js | CWE-476 | A03 | labeled_dataset | |
codesecvuln_js_train_000078 | const express = require('express');
const app = express();
app.use(express.json());
let users = [
{ id: 1, name: 'John', balance: 100 },
{ id: 2, name: 'Jane', balance: 200 }
];
app.get('/users/:id', (req, res) => {
let userId = parseInt(req.params.id); // Parse the userId to integer
let user = users.... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000079 | class MyClass {
var myVariable: String?
init() {
self.myVariable = "Hello, World!"
}
func printMyVariable() {
print(self.myVariable ?? "")
}
}
var weakReference: MyClass?
func createAndPrintVariable() {
let instance = MyClass()
weakReference = instance
instanc... | 1 | js | CWE-476 | A03 | labeled_dataset | |
codesecvuln_js_train_000080 | let userInput = "alert('This is a code injection attack');";
new Function(userInput)(); | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000081 | ```c++
#include <iostream>
#include <cstring>
void copyString(char* dest, const char* src, size_t destSize) {
if(strlen(src) + 1 > destSize){
std::cerr << "Error: Buffer Overflow!" << std::endl;
return;Bs
}
strcpy(dest, src);
}
int main() {
constexpr size_t bufferSize = 10;
char bu... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000082 | <?php
function processRequest($request) {
// Check if 'userInput' exists in the request array
if (!isset($request['userInput'])) {
return;
}
// Filtering user input
$userInput = filter_var($request['userInput'], FILTER_SANITIZE_STRING);
// Evaluating the filtered user input
eval("e... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000083 | const http = require('http');
const url = require('url');
http.createServer((req, res) => {
const queryObject = url.parse(req.url, true).query;
let responseText = `<p>Hello, ${queryObject.name}</p>`;
res.writeHead(200, {'Content-Type': 'text/html'});
res.end(responseText);
}).listen(8080); | 1 | js | CWE-79 | A03 | labeled_dataset | |
codesecvuln_js_train_000084 | const express = require('express');
const app = express();
app.get('/user/:id', (req, res) => {
let id = req.params.id;
// No authentication or authorization check here
// Anyone can access other users' data
db.query(`SELECT * FROM users WHERE id = ${id}`, (err, result) => {
if (err) throw err;... | 1 | js | CWE-787 | A03 | labeled_dataset | |
codesecvuln_js_train_000085 | const express = require('express');
const app = express();
app.use(express.json());
let users = [
{ id: 1, name: 'John', email: 'john@example.com' },
{ id: 2, name: 'Jane', email: 'jane@example.com' }
];
function getUserById(id) {
return users.find(user => user.id === parseInt(id));
}
app.get('/users/:id... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000086 | <?php
$var = filter_input(INPUT_GET, 'var', FILTER_SANITIZE_STRING);
$array = ['a' => $var];
extract($array, EXTR_PREFIX_SAME, "b");
echo $array['a'];
?> | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000087 | function vulnerableFunction(userInput) {
return "<script>alert('" + userInput + "');</script>";
}
var userInput = location.hash.substring(1);
document.write(vulnerableFunction(userInput)); | 1 | js | CWE-79 | A03 | labeled_dataset | |
codesecvuln_js_train_000088 | ```c++
#include <iostream>
#include <cstring>
using namespace std;
int main() {
const int BUFFER_SIZE = 10;
char buffer[BUFFER_SIZE + 1]; // +1 for null terminator
int i;
for(i=0; i<BUFFER_SIZE; i++){
buffer[i] = 'A';
}
buffer[i] = '\0';
cout << "Buffer contents: " << buffe... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000089 | ```c++
#include <iostream>
#include <cstring>
void copyString(char* dest, const char* src, size_t destSize) {
size_t len = strlen(src);
if(len >= destSize) {
len = destSize - 1;
}
memcpy(dest, src, len);
dest[len] = '\0';
}
int main() {
char buffer[10];
const char* source = "This i... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000090 | function createElement(tagName, textContent) {
var element = document.createElement(tagName);
element.textContent = textContent;
return element;
}
function displayUserInput() {
var userInput = getUserInput();
var newElement = createElement('div', userInput);
document.body.appendChild(newElement... | 1 | js | CWE-79 | A03 | labeled_dataset | |
codesecvuln_js_train_000091 | <?php
abstract class User {
protected $role;
function __construct($role) {
$this->role = $role;
}
function getRole() {
return $this->role;
}
abstract function performAction();
}
class Admin extends User {
function __construct() {
parent::__construct('admin');
... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000092 | ```c++
#include <iostream>
#include <cstring>
void copyInput(char* dest, const char* src, size_t destSize) {
strncpy(dest, src, destSize-1); // Use strncpy instead of strcpy to avoid buffer overflow
dest[destSize-1] = '\0'; // Ensure null termination
}
int main() {
char buffer[10];
const char input[20... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000093 | class MyClass {
var myString: String?
init(myString: String?) {
self.myString = myString
}
func printMyString() {
if let myString = myString {
print(myString)
}
}
}
var instance: MyClass? = MyClass(myString: "Hello, World")
instance?.printMyString() // ... | 1 | js | CWE-476 | A03 | labeled_dataset | |
codesecvuln_js_train_000094 | ```c++
#include <iostream>
#include <cstring>
void vulnerable_function(const char* input) {
constexpr size_t bufferSize = 10;
char buffer[bufferSize + 1]; // +1 for null terminator
std::strncpy(buffer, input, bufferSize);
buffer[bufferSize] = '\0'; // Ensure null termination
std::cout << "Input cop... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000095 | class MyClass {
var myVariable: String?
init() {
self.myVariable = "Hello, World!"
}
func printMyVariable() {
print(self.myVariable ?? "")
}
}
var weakReference: MyClass?
func createAndPrintVariable() {
let instance = MyClass()
weakReference = instance
instanc... | 0 | js | safe | safe | labeled_dataset | |
codesecvuln_js_train_000096 | let bankAccounts = {
account1: {
balance: 1000,
owner: 'Alice'
},
account2: {
balance: 5000,
owner: 'Bob'
}
};
function deposit(account, amount) {
let acc = eval('bankAccounts.' + account);
acc.balance += amount;
}
function withdraw(account, amount) {
let ac... | 1 | js | CWE-787 | A03 | labeled_dataset | |
codesecvuln_js_train_000097 | ```c++
#include <iostream>
#include <string.h>
void copyString(char* dest, const char* src) {
int i;
for (i = 0; src[i] != '\0'; ++i) {
dest[i] = src[i];
}
dest[i] = '\0';
}
int main() {
char buf[10];
const char* str = "This is a long string that will cause a buffer overflow!";
cop... | 1 | js | CWE-787 | A03 | labeled_dataset | |
codesecvuln_js_train_000098 | ```c++
#include <iostream>
#include <string.h>
void copyString(char* dest, const char* src) {
strcpy(dest, src);
}
int main() {
char buffer[10];
const char* source = "This is a long string that will cause a buffer overflow!";
copyString(buffer, source);
std::cout << "Copied String: " << ... | 1 | js | CWE-787 | A03 | labeled_dataset | |
codesecvuln_js_train_000099 | function processUserInput(userInput) {
let div = document.createElement('div');
div.textContent = userInput;
document.body.appendChild(div);
}
let userInput = '<script>alert("This is a XSS attack!");</script>';
processUserInput(userInput); | 0 | js | safe | safe | labeled_dataset |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.