id string | text string | label int64 | language string | cwe_id string | owasp string | source string | code_fixed string |
|---|---|---|---|---|---|---|---|
codesecvuln_py_train_000000 | def vulnerable_method(user_input)
eval(user_input)
end
vulnerable_method("system('rm -rf /')") | 1 | py | CWE-94 | A03 | labeled_dataset | |
codesecvuln_py_train_000001 | import Foundation
func executeCommand(userInput: String) {
let task = Process()
task.launchPath = "/bin/sh"
task.arguments = ["-c", "echo \(userInput)"]
let pipe = Pipe()
task.standardOutput = pipe
task.launch()
let data = pipe.fileHandleForReading.readDataToEndOfFile()
let ou... | 1 | py | CWE-502 | A08 | labeled_dataset | |
codesecvuln_py_train_000002 | import subprocess
import ast
def run_command(user_input):
command = ["echo", user_input]
subprocess.run(command, check=True)
def run_eval(user_input):
tree = ast.parse(user_input, mode='single')
if len(tree.body) != 1 or not isinstance(tree.body[0], ast.Expr):
raise ValueError('Not a single ex... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000003 | import subprocess
def execute_command(user_input):
# Validate user input to prevent shell injection attacks
if any(char in user_input for char in [';', '&', '|', '*', '?', '`', '$', '<', '>', '[', ']', '{', '}', '#', '^', '~']):
print("Invalid input")
return
command = ['ls', user_input... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000004 | import Foundation
class Person {
var name: String?
init(name: String?) {
self.name = name
}
}
struct Student {
var person: Person
var age: Int
func displayDetails() {
print("Name: \(person.name), Age: \(age)")
}
}
let student = Student(person: Person(name: nil), ... | 1 | py | CWE-94 | A03 | labeled_dataset | |
codesecvuln_py_train_000005 | import ast
class RestrictedPython(ast.NodeTransformer):
def visit_Call(self, node):
if not (isinstance(node.func, ast.Name) and node.func.id in ['eval', 'exec']):
raise ValueError('eval/exec calls are not allowed')
return self.generic_visit(node)
def restricted_eval(code, mode='eval'):... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000006 | import pickle
import os
class RunBinSh(object):
def __reduce__(self):
return (os.system, ('/bin/sh',))
def serialize_exploit():
malicious = pickle.dumps(RunBinSh())
with open('malicious.pickle', 'wb') as f:
pickle.dump(malicious, f)
serialize_exploit() | 1 | py | CWE-502 | A08 | labeled_dataset | |
codesecvuln_py_train_000007 | package main
import (
"fmt"
"os"
"unsafe"
)
func main() {
var buffer [512]byte
file, err := os.Open("input.txt")
if err != nil {
fmt.Println(err) suspected_vulnerability
}
defer file.Close()
n, err := file.Read(buffer[:])
if err != nil {
fmt.Println(err)
}
// This line of code is vulnerable to buffe... | 1 | py | CWE-787 | A03 | labeled_dataset | |
codesecvuln_py_train_000008 | import os
def evaluate_input(user_input):
return eval(user_input)
user_input = input("Enter a command: ")
evaluate_input(user_input) | 1 | py | CWE-94 | A03 | cybernative_dpo | import ast
import operator as op
# supported operators
operators = {ast.Add: op.add, ast.Sub: op.sub, ast.Mult: op.mul,
ast.Div: op.truediv, ast.USub: op.neg}
def evaluate_expr(node):
if isinstance(node, ast.Num): # <number>
return node.n
elif isinstance(node, ast.BinOp): # <left> <operato... |
codesecvuln_py_train_000009 | import pickle
import os
import subprocess
class RCE:
def __reduce__(self):
return (subprocess.Popen, (['echo', 'You have been hacked'],))
data = pickle.dumps(RCE())
pickle.loads(data) | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000010 | import Foundation
func processInput(input: String) -> String {
let characters = Array(input)
var result = ""
for character in characters {
result.append(character)
} fulfilling: { try? $0.write(to: .utf8) }
return result
}
let input = "A" * 1024 * 1024 * 1024 // 1GB of data
processInput(in... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000011 | package main
import (
"fmt"
"os"
)
func readFile(fileName string) {
file, err := os.Open(fileName)
if err != nil {
fmt.Println("Error opening file:", err) constrained
}
defer file.Close()
var data []byte
_, err = file.Read(data)
if err != nil {
fmt.Println("Error reading file:", err)
}
fmt.Println("S... | 1 | py | CWE-94 | A03 | labeled_dataset | |
codesecvuln_py_train_000012 | import sqlite3
from sqlite3 import Error
def fetch_user_data(username):
try:
conn = sqlite3.connect('my_database.db')
cursor = conn.cursor()
# Use parameterized query to avoid SQL injection
cursor.execute("SELECT * FROM users WHERE username=?", (username,))
user_data = curso... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000013 | def add_numbers(a, b):
return a + b
print(add_numbers(10, 20))
print(add_numbers('10', '20'))
print(add_numbers('10', 20)) | 1 | py | CWE-20 | A03 | labeled_dataset | |
codesecvuln_py_train_000014 | import Foundation
struct MyStruct {
var data: Int
}
var myInt = 10
var myStruct = MyStruct(data: myInt)
print(myStruct.data) // This will print 10
myStruct.data = 20
print(myStruct.data) // This will print 20
print(myInt) // This will print 10, but it should print 20 due to unsafeBitCast | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000015 | package main
import (
"fmt"
"math"
)
func main() {
source := []int{1, 2, 3, 4, 5}
destination := make([]int, int(math.Min(float64(len(source)), 3)))
// Optimized code: Copying only the number of elements that the destination slice can hold
copy(destination, source)
fmt.Println("Destination Slice: ", destinat... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000016 | require 'pg'
def search_user(username)
conn = PGconn.connect(:dbname => 'test')
res = conn.exec("SELECT * FROM users WHERE username = '#{username}'")
res.each do |row|
puts row
end
ensure
conn.close if conn
end
search_user("test' OR '1'='1") | 1 | py | CWE-89 | A03 | labeled_dataset | |
codesecvuln_py_train_000017 | import Foundation
class MyClass {
var closure: (() -> Void)?
var timer: Timer?
func startTimer() {
self.timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] timer in
self?.closure = {
print("Timer fired")
}
}
... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000018 | def concatenate_strings(str1, str2):
# Check if both inputs are strings
if isinstance(str1, str) and isinstance(str2, str):
return str1 + str2
else:
raise ValueError('Both inputs must be strings')
try:
user_input = input("Enter your string: ")
print(concatenate_strings(user_input, "... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000019 | import subprocess
def execute_command(user_input):
command = user_input
process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
output, error = process.communicate()
print(output)
user_input = input("Enter your command: ")
execute_command(user_input) | 1 | py | CWE-78 | A03 | cybernative_dpo | import shlex
import subprocess
def execute_command(user_input):
# Sanitize the user input
sanitized_input = shlex.split(user_input)
# Validate the sanitized input
if len(sanitized_input) == 0:
print("Invalid command")
return
try:
# Use subprocess.run instead of subproc... |
codesecvuln_py_train_000020 | import Foundation
func processUserInput(input: String) -> String {
var buffer = Array<Character>(repeating: " ", count: 1024)
let inputArray = Array(input)
for i in 0..<inputArray.count {
buffer[i] = inputArray[i]
}
return String(buffer)
}
let userInput = "A very long string that... | 1 | py | CWE-20 | A03 | labeled_dataset | |
codesecvuln_py_train_000021 | import Foundation
func vulnerableFunction(userInput: String) -> String {
let maxLength = 100
var buffer = Array<UInt8>(repeating: 0, count: maxLength)
let inputData = userInput.utf8
// Vulnerable Code: No check on inputData.count
buffer.replaceSubrange(0..<min(maxLength, inputData.count), with... | 1 | py | CWE-787 | A03 | labeled_dataset | |
codesecvuln_py_train_000022 | import Foundation
class User {
var name: String
init(name: String) {
self.name = name
}
}
func showUserInfo(_ user: User) {
let message = "Hello, \(user.name)"
print(message)
}
let userInput = "Alice"
let user = User(name: userInput)
showUserInfo(user) | 1 | py | CWE-94 | A03 | labeled_dataset | |
codesecvuln_py_train_000023 | package main
import (
"fmt"
"net/http"
"os/exec"
)
func handler(w http.ResponseWriter, r *http.Request) {
cmd := exec.Command("echo", r.URL.Path[1:])
out, err := cmd.Output()
if err != nil {
fmt.Fprintf(w, "Error: %s", err)
} else {
fmt.Fprintf(w, "Output: %s", out)
}
}
func main() {
http.HandleFunc("/"... | 1 | py | CWE-89 | A03 | labeled_dataset | |
codesecvuln_py_train_000024 | package main
import (
"fmt"
"unsafe"
)
func main() {
buffer := make([]byte, 1024)
ptr := uintptr(unsafe.Pointer(&buffer[0]))
for i := 0; i < 1025; i++ {
*(*byte)(unsafe.Pointer(ptr + uintptr(i))) = 'A'
}
fmt.Println("Buffer Overflow Successful")
} | 1 | py | CWE-787 | A03 | labeled_dataset | |
codesecvuln_py_train_000025 | def get_user_input
puts "Enter your input:"
user_input = gets.chomp
return user_input
end
def evaluate_input(user_input)
eval(user_input)
end
user_input = get_user_input()
evaluate_input(user_input) | 1 | py | CWE-94 | A03 | labeled_dataset | |
codesecvuln_py_train_000026 | def safe_function():
user_input = input("Enter some Python code: ")
# Checking if the input contains any potentially harmful characters
if any(char in user_input for char in ['import', 'os', 'sys', 'eval', 'exec', 'open', 'input']):
print("Sorry, this function does not support such operations.")
... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000027 | import os
user_input = input("Enter your command: ")
eval(user_input) | 1 | py | CWE-94 | A03 | cybernative_dpo | import ast
import os
def safe_eval(node):
if isinstance(node, ast.Expression):
node = node.body
if isinstance(node, ast.Str):
return node.s
elif isinstance(node, ast.Num):
return node.n
elif isinstance(node, ast.BinOp):
left = safe_eval(node.left)
right = safe_ev... |
codesecvuln_py_train_000028 | package main
import "fmt"
func main() {
buffer := make([]int, 1024)
for i := 0; i <= 1024; i++ {
buffer[i] = i
}
fmt.Println(buffer)
} | 1 | py | CWE-787 | A03 | labeled_dataset | |
codesecvuln_py_train_000029 | import Foundation
func handleInput(input: String) {
var buffer = Array<Character>(repeating: " ", count: 10)
let inputArray = Array(input)
for i in 0..<inputArray.count {
buffer[i] = inputArray[i] // This line can cause a buffer overflow if input is larger than buffer size
}
}
let testIn... | 1 | py | CWE-787 | A03 | labeled_dataset | |
codesecvuln_py_train_000030 | import Foundation
class MyClass {
var myProperty: String?
init(myProperty: String?) {
self.myProperty = myProperty
}
deinit {
print("MyClass is being deinitialized")
}
}
// Use optional binding to safely unwrap the optional instance before setting it to nil
if var instanc... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000031 | import subprocess
import shlex
import sys
def handle_input(user_input):
# Use subprocess module instead of os.system for security reasons
# It's more secure because it does not call a shell command
# It also allows you to capture the output and check the return code
process = subprocess.run(shlex.split... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000032 | package main
import (
"bufio"
"fmt"
"io"
"os"
)
func main() {
file, err := os.Open("large_file.txt")
if err != nil {
fmt.Println(err)
return
}
defer file.Close()
reader := bufio.NewReader(file)
buffer := make([]byte, 1024)
for {
n, err := reader.Read(buffer)
if err != nil && err != io.EOF {
fm... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000033 | package main
import (
"fmt"
"io"
"strings"
)
func main() {
input := "This is a very long string that will cause a buffer overflow if not handled properly."
processInput(input)
}
func processInput(input string) {
reader := strings.NewReader(input)
slice := make([]byte, 10)
_, err := io.ReadFull(reader, slice)... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000034 | import threading
class BankAccount:
def __init__(self):
self.balance = 0
def deposit(self, amount):
current_balance = self.balance
# Simulate some time-consuming operation
for _ in range(10000000):
pass
self.balance = current_balance + amount
def perform_tr... | 1 | py | CWE-362 | A04 | cybernative_dpo | import threading
class BankAccount:
def __init__(self):
self.balance = 0
self.lock = threading.Lock()
def deposit(self, amount):
with self.lock:
current_balance = self.balance
# Simulate some time-consuming operation
for _ in range(10000000):
... |
codesecvuln_py_train_000035 | def execute_command(user_input)
# Use a whitelist approach to validate the input
allowed_commands = ["ls", "pwd", "echo"]
if allowed_commands.include?(user_input)
system(user_input)
else
puts "Invalid command!"
end
end
puts "Enter your command:"
user_input = gets.chomp
execute_command(user_input) | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000036 | package main
import (
"fmt"
"sync"
)
type Counter struct {
mu sync.Mutex
count int
}
func (c *Counter) Increment() {
c.mu.Lock()
defer c.mu.Unlock()
c.count++
}
func main() {
var wg sync.WaitGroup
counter := Counter{}
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
counter.I... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000037 | import pickle
import subprocess
class RunBinSh(object):
def __reduce__(self):
return (subprocess.Popen, (['/bin/sh'],))
def serialize_exploit():
malicious = pickle.dumps(RunBinSh())
with open('malicious.pkl', 'wb') as f:
pickle.dump(malicious, f)
if __name__ == "__main__":
serialize_e... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000038 | import Foundation
class VulnerableClass {
var buffer: [String] = []
func addToBuffer(_ item: String) {
let maxBufferSize = 10
if buffer.count >= maxBufferSize {
print("Buffer overflow detected")
return
}
buffer.append(item)
}
}
let vulnClass = V... | 1 | py | CWE-787 | A03 | labeled_dataset | |
codesecvuln_py_train_000039 | from flask import Flask, request, make_response
import ast
app = Flask(__name__)
@app.route('/')
def index():
return "Welcome to my website!"
@app.route('/calculate', methods=['POST'])
def calculate():
data = request.form.get('data')
# Check if data is None
if data is None:
return make_r... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000040 | package main
import (
"log"
"os/exec"
)
func runCommand(command string) error {
cmd := exec.Command("/bin/sh", "-c", command)
_, err := cmd.Output()
return err
}
func main() {
err := runCommand("ls")
if err != nil {
log.Fatal("Error running command: ", err)ellow
}
} | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000041 | import pickle
import os
class RunBinSh(object):
def __reduce__(self):
return (os.system, ('/bin/sh',))
def serialize_exploit():
malicious = pickle.dumps(RunBinSh())
with open('payload.dat', 'wb') as f:
pickle.dump(malicious, f)
if __name__ == "__main__":
serialize_exploit() | 1 | py | CWE-502 | A08 | labeled_dataset | |
codesecvuln_py_train_000042 | import Foundation
func authenticateUser(username: String, password: String) -> Bool {
let correctUsername = "admin"
let correctPassword = "password123"
// Using 'if' instead of 'guard' to avoid logical errors
if username == correctUsername && password == correctPassword {
print("Authentica... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000043 | package main
import (
"fmt"
"unsafe"
)
func main() {
var s string
b := []byte("hello")
p1 := uintptr(unsafe.Pointer(&b[0]))
p2 := uintptr(unsafe.Pointer(&s))
for i := 0; i < len(b); i++ {
*(*byte)(unsafe.Pointer(p2 + uintptr(i))) = b[i]
}
fmt.Println(s)
} | 1 | py | CWE-787 | A03 | labeled_dataset | |
codesecvuln_py_train_000044 | import pickle
import subprocess
class SafeClass(object):
def __reduce__(self):
return (subprocess.run, (['echo', 'You have been hacked'],))
def serialize_safe_code():
with open('payload.dat', 'wb') as f:
pickle.dump(SafeClass(), f)议
serialize_safe_code() | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000045 | def get_user_input
user_input = gets.chomp
eval(user_input)
end
puts "Enter some Ruby code:"
get_user_input | 1 | py | CWE-94 | A03 | labeled_dataset | |
codesecvuln_py_train_000046 | package main
import (
"strings"
"fmt"
)
func main() {
var sb strings.Builder
sb.Grow(1024)
for i := 0; i < 1025; i++ {
sb.WriteString("a")
}
fmt.Println(sb.String())
} | 1 | py | CWE-787 | A03 | labeled_dataset | |
codesecvuln_py_train_000047 | require 'open3'
def execute_command(user_input)
sanitized_input = Shellwords.escape(user_input)
command = "ls #{sanitized_input}"
stdout, stderr, status = Open3.capture3(command)
puts stdout
end
puts "Enter something:"
user_input = gets.chomp
execute_command(user_input) | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000048 | def run_command(user_input)
# Sanitize the user input to prevent command injection attacks
sanitized_input = user_input.gsub(/[^0-9a-z ]/i, '')
# Check if the sanitized input is empty
if sanitized_input.empty?
puts "Invalid command!"
else
# Run the sanitized command
system(sanitized_input)
end
... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000049 | package main
import (
"fmt"
"os/exec"
)
func main() {
var command string
fmt.Println("Enter your command:")
fmt.Scan(&command)
cmd := exec.Command(command)
err := cmd.Run()
if err != nil {
fmt.Println("Error executing command:", err)
}
} | 1 | py | CWE-20 | A03 | labeled_dataset | |
codesecvuln_py_train_000050 | require 'nokogiri'
require 'open-uri'
class XmlParser
def initialize(url)
@url = url
end
def parse_xml
xml_data = open(@url).read
doc = Nokogiri::XML(xml_data)
doc.xpath('//item').each do |node|
puts node.text
end
end
end
parser = XmlParser.new('http://example.com/xxe_vulnerable_ser... | 1 | py | CWE-502 | A08 | labeled_dataset | |
codesecvuln_py_train_000051 | import Foundation
// This function might return nil
func getOptionalString() -> String? {
let randomNumber = Int.random(in: 0...1)
return randomNumber == 0 ? "Hello, World!" : nil
}
// This function uses the above function without checking if it returns nil
func printString() {
let myString = getOptionalS... | 1 | py | CWE-20 | A03 | labeled_dataset | |
codesecvuln_py_train_000052 | import Foundation
class User {
var name: String?
}
func printUserName(user: User?) {
if let user = user, let name = user.name {
print("User's name is \(name)")
} else {
print("User is nil")
}
}
let user = User()
printUserName(user: user) | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000053 | class UserController < ApplicationController
def create
eval(params[:code])
end
end | 1 | py | CWE-94 | A03 | labeled_dataset | |
codesecvuln_py_train_000054 | package main
import "fmt"
type Node struct {
value int
next *Node
}
func createList(n int) *Node {
var head, tail *Node
for i := 0; i < n; i++ {
node := &Node{value: i}
if head == nil {
head = node
tail = node
} else {
tail.next = node
tail = node
}
}
return head
}
func main() {
head := ... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000055 | package main
import "time"
type Leaky struct {
data []byte
}
func leakyFunction() *Leaky {
leak := &Leaky{
data: make([]byte, 1024*1024), // allocate 1MB of memory
}
return leak
}
func main() {
for {
_ = leakyFunction() // leak memory every time we call this function
time.Sleep(time.Millisecond)
}
} | 1 | py | CWE-787 | A03 | labeled_dataset | |
codesecvuln_py_train_000056 | import sqlite3
def get_user_info(username):
conn = sqlite3.connect('mydatabase.db')
cursor = conn.cursor()
query = "SELECT * FROM users WHERE username = '" + username + "'"
cursor.execute(query)
result = cursor.fetchone()
return result
# Example usage
print(get_user_info("test' OR '1'='1")) | 1 | py | CWE-89 | A03 | labeled_dataset | |
codesecvuln_py_train_000057 | import Foundation
func vulnerableFunction(userInput: String) -> String {
let fixedString = "hello"
var result = ""
for _ in 0..<userInput.count {
result += fixedString
}
return result
}
let userInput = String(repeating: "A", count: 1000000000)
let result = vulnerableFunction(userInput: use... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000058 | import os
def run_command(user_input):
command = "ls " + user_input
os.system(command)
def run_command_with_eval(user_input):
eval(user_input)
user_input = input("Enter your command: ")
run_command(user_input)
run_command_with_eval(user_input) | 1 | py | CWE-94 | A03 | cybernative_dpo | import subprocess
def run_command(user_input):
command = ["ls", user_input]
subprocess.run(command, check=True)
def run_command_with_eval(user_input):
# Evaluate the user input safely
safe_dict = {'__builtins__': None}
safe_code = compile(user_input, '<string>', 'eval')
eval(safe_code, safe_di... |
codesecvuln_py_train_000059 | import Foundation
func processInput(input: String) -> String {
var result = ""
for character in input {
result += String(character)
}
return result
}
let input = "A" * 1024 * 1024 * 1024 // 1GB of data
processInput(input: input) | 1 | py | CWE-787 | A03 | labeled_dataset | |
codesecvuln_py_train_000060 | package main
import (
"fmt"
"os/exec"
)
func main() {
var command string
fmt.Println("Enter your command:")
fmt.Scan(&command)
cmd := exec.Command(command)
err := cmd.Run()
if err != nil {
fmt.Println("Error:", err) constrained by a buffer overflow error as we are not validating the input.
}
} | 1 | py | CWE-20 | A03 | labeled_dataset | |
codesecvuln_py_train_000061 | class VulnerableController < ApplicationController
ALLOWED_METHODS = %w[add subtract multiply divide].freeze
def index
user_input = params[:user_input]
return unless ALLOWED_METHODS.include?(user_input)
send(user_input)
end
private
def add
# Addition logic here
end
def subtract
# ... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000062 | import Foundation
func secureFunction(index: Int) {
let array = [100, 200, 300]
if index < array.count {
print("Value at index \(index): \(array[index])")
} else {
print("Error: Index out of bounds")
}
}
secureFunction(index: 10) | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000063 | class BufferOverflow:
def __init__(self):
self.buffer = [0] * 1024
def add_to_buffer(self, data):
if not all(isinstance(i, int) for i in data):
raise TypeError("All elements in data must be integers")
if len(data) > 1024:
raise ValueError('Buffer overflow')
... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000064 | require 'thread'
class SecureClass
@@secure_variable = 0
@@lock = Mutex.new
def self.increment_secure_variable
sleep(rand(1..3)) # simulate some delay
@@lock.synchronize { @@secure_variable += 1 }
end
end
threads = []
10.times do
threads << Thread.new { SecureClass.increment_secure_variable }
end
... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000065 | import Foundation
class User {
var name: String?
init(name: String?) {
self.name = name
}
}
func printUserName(user: User) {
print("User's name is \(user.name)")
}
let user = User(name: nil)
printUserName(user: user) | 1 | py | CWE-94 | A03 | labeled_dataset | |
codesecvuln_py_train_000066 | package main
import (
"fmt"
"unsafe"
)overed by the unsafe package.
func main() {
var data []byte = make([]byte, 1024)
var i int = 1024
ptr := unsafe.Pointer(&data[0])
for i != 0 {
*(*int)(unsafe.Add(ptr, uintptr(i-4))) = i
i -= 4
}
fmt.Println("Data: ", data)
} | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000067 | def run_command(user_input)
system(user_input)
end
puts "Enter your command:"
user_input = gets.chomp
run_command(user_input) | 1 | py | CWE-94 | A03 | labeled_dataset | |
codesecvuln_py_train_000068 | import Foundation
enum MyError: Error {
case invalidInput
}
func processData(_ data: String) throws -> Int {
guard let number = Int(data) else {
throw MyError.invalidInput
}
return number
}
DispatchQueue.global().async {
do {
let result = try processData("Hello World")
... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000069 | import Foundation
class UnsafePointerExample {
func example() {
let data = Data(repeating: 0, count: 1024)
let pointer = UnsafeMutableRawPointer.allocate(byteCount: 1024, alignment: 1)
// Correctly copy the content of 'data' into 'pointer'.
data.withUnsafeBytes { pointer.in... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000070 | import Foundation
func processString(input: String) -> String {
var result = ""
for char in input {
result.append(char)
}
return result
}
let userInput = "This is a potentially long string that could cause a buffer overflow"
let processedString = processString(input: userInput)
print(processed... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000071 | require 'active_record'
ActiveRecord::Base.establish_connection(
adapter: 'sqlite3',
database: ':memory:'
)Bs
class User < ActiveRecord::Base; end
User.create(name: 'Bob')
def find_user(name)
User.where("name = ?", name)
end
# Secure Optimized Code
puts "Enter your name:"
input = gets.chomp
find_user(input) | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000072 | import Foundation
func vulnerableFunction(_ input: String) -> String {
var buffer = Array<UInt8>(repeating: 0, count: 1024)
let data = input.utf8
buffer.withUnsafeMutableBufferPointer {
let bytesWritten = data.withUnsafeBytes {
bufferPointer in
bufferPointer.baseAddress?.cop... | 1 | py | CWE-787 | A03 | labeled_dataset | |
codesecvuln_py_train_000073 | require 'yaml'
include YAML
class User
attr_accessor :name
def initialize(name)
@name = name
end
end
user = User.new("Alice")
serialized_user = YAML::dump(user)
puts "Serialized User: #{serialized_user}"
deserialized_user = YAML::load(serialized_user)
puts "Deserialized User: #{deserialized_user.name}"
... | 1 | py | CWE-502 | A08 | labeled_dataset | |
codesecvuln_py_train_000074 | package main
import (
"fmt"
"sync"
"time"
)
func worker(id int, jobs <-chan int, results chan<-int, wg *sync.WaitGroup) {
for j := range jobs {
fmt.Println("worker", id, "started job", j)
time.Sleep(time.Second)
fmt.Println("worker", id, "finished job", j)
results <- j * 2
}
wg.Done() suspected vulnerab... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000075 | package main
import "fmt"
func main() {
s := []int{1, 2, 3}
c := make([]int, len(s))
copy(c, s)
fmt.Println(c)
} | 1 | py | CWE-787 | A03 | labeled_dataset | |
codesecvuln_py_train_000076 | import Foundation
func createStringFromUnsafePointer(ptr: UnsafePointer<UInt8>) -> String {
let bytes = ptr.withMemoryRebound(to: UInt8.self, capacity: 10) { pointer in
let byteArray = Array(UnsafeBufferPointer(start: pointer, count: 10))
return byteArray
}
return String(bytes: bytes, encod... | 1 | py | CWE-476 | A03 | labeled_dataset | |
codesecvuln_py_train_000077 | def match_input(input)
regex = /^a+$/
return regex.match?(input)
end
puts "Enter input:"
user_input = gets.chomp
if match_input(user_input)
puts "Match found!"
else
puts "No match found."
end | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000078 | def execute_command(user_input)
# Allow only alphanumeric characters, spaces, and some special characters
if user_input =~ /^[a-zA-Z0-9\s\-\_\.\,\:\;\+\=\@\#\$\%\&\(\)\[\]\{\}\<\>]*$/
system(user_input)
else
puts "Invalid command!"
end
end
puts "Enter your command:"
user_input = gets.chomp
execute_comm... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000079 | def safe_method(user_input)
begin
puts eval(user_input)
rescue SecurityError => e
puts "SecurityError: #{e}"
rescue SyntaxError => e
puts "SyntaxError: #{e}"
end
end
puts "Enter some Ruby code:"
user_input = gets.chomp
safe_method(user_input) | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000080 | import ast
class RestrictedPython(ast.NodeVisitor):
def visit_Call(self, node):
if not isinstance(node.func, ast.Name):
raise ValueError('Not allowed')
ast.NodeVisitor.generic_visit(self, node)
def run_user_input():
user_input = input("Enter your command: ")
tree = compile(user... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000081 | import Foundation
// Assume we have a function that copies data from one buffer to another
func copyData(_ source: UnsafePointer<UInt8>, _ destination: UnsafeMutablePointer<UInt8>, _ size: Int) {
destination.withMemoryRebound(to: UInt8.self, capacity: size) { destinationPointer in
source.withMemoryRebound(... | 1 | py | CWE-787 | A03 | labeled_dataset | |
codesecvuln_py_train_000082 | import Foundation
class User {
var name: String?
}
func printUserName(user: User?) {
print("User's name is \(user.name)") // Vulnerable line
}
let user = User()
printUserName(user: user) | 1 | py | CWE-476 | A03 | labeled_dataset | |
codesecvuln_py_train_000083 | package main
import (
"fmt"
"io/ioutil"
"log"
)
func ReadFile(path string) {
data, err := ioutil.ReadFile(path)
if err != nil {
log.Fatal("Error reading file: ", err)
} else {
fmt.Println(string(data))
}
}
func main() {
ReadFile("/path/to/your/file")
} | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000084 | package main
import (
"fmt"
"sync"
)
type Counter struct {
sync.Mutex
count int
}
func (c *Counter) Increment(wg *sync.WaitGroup) {
c.Lock()
defer c.Unlock()
c.count++
wg.Done()
}
func main() {
var wg sync.WaitGroup
counter := Counter{}
for i := 0; i < 1000; i++ {
wg.Add(1)
go counter.Increment(&wg)... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000085 | import Foundation
class SecureBuffer {
private var buffer: [UInt8] = []
func addData(_ data: [UInt8]) {
let availableSpace = 1024 - buffer.count
let dataToAdd = Array(data.prefix(availableSpace))
buffer.append(contentsOf: dataToAdd)
}
}
let buffer = SecureBuffer()
buffer.addDa... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000086 | import Foundation
struct User {
let name: String
let age: Int
}
func parseUser(jsonString: String) -> User? {
guard let jsonData = jsonString.data(using: .utf8) else { return nil }
do {
if let json = try JSONSerialization.jsonObject(with: jsonData, options: []) as? [String: Any],
le... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000087 | import threading
class BankAccount:
def __init__(self):
self.balance = 0
self.lock = threading.Lock()
def deposit(self, amount):
with self.lock:
current_balance = self.balance
# Simulate some time-consuming operation
for _ in range(10000000):
... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000088 | from flask import Flask, request
app = Flask(__name__)
@app.route('/eval', methods=['POST'])
def evaluate():
data = request.get_data()
result = eval(data)
return str(result)
if __name__ == '__main__':
app.run(debug=True) | 1 | py | CWE-94 | A03 | labeled_dataset | |
codesecvuln_py_train_000089 | # Import the necessary module
import flask
# Create a Flask application
app = flask.Flask(__name__)
@app.route('/')
def index():
# Get the user input from the URL
user_input = flask.request.args.get('input', '')
# Evaluate the user input as Python code
result = eval(user_input)
# Return the resu... | 1 | py | CWE-94 | A03 | labeled_dataset | |
codesecvuln_py_train_000090 | import os
import sys
def vulnerable_function():
try:
user_input = input("Enter your command: ")
os.system(user_input)
except Exception as e:
print("An error occurred: ", e)
if __name__ == "__main__":
vulnerable_function() | 1 | py | CWE-94 | A03 | labeled_dataset | |
codesecvuln_py_train_000091 | import time
import hmac
from hashlib import sha256
# Hashed version of the password
actual_password = "5ebe2294ecd0e0f08eab7690d2a6ee69" # Hashed form of "secret"
def check_password(input_password):
hashed_input_password = sha256(input_password.encode()).hexdigest()
if hmac.compare_digest(hashed_input_passwo... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000092 | import pickle
import os
class RCE:
def __reduce__(self):
return (os.system, ('echo "You have been hacked"',))
def serialize_exploit():
with open('exploit.pickle', 'wb') as f:
pickle.dump(RCE(), f)
def deserialize_exploit():
with open('exploit.pickle', 'rb') as f:
pickle.load(f)
s... | 1 | py | CWE-502 | A08 | labeled_dataset | |
codesecvuln_py_train_000093 | import Foundation
func encodeAndDecode(_ string: String) -> String? {
guard let data = string.data(using: .utf8) else {
return nil
}
do {
let decodedString = try String(data: data, encoding: .nonUTF8)
return decodedString
} catch {
return nil
}
}
let testString... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000094 | import Foundation
class Animal {
func makeSound() {
print("Generic animal sound")
}
}
class Dog: Animal {
override func makeSound() {
print("Woof")
}
}
func playWithAnimal(_ animal: Animal?) {
animal?.makeSound()
}
let dog = Dog()
playWithAnimal(dog) // prints "Woof"
let animal... | 1 | py | CWE-94 | A03 | labeled_dataset | |
codesecvuln_py_train_000095 | class UsersController < ApplicationController
before_action :set_user, only: [:show]
def show
# No need to do anything here as we are using before_action to set user
end
private
def set_user
@user = User.find(params[:id])
# Check if the current user is authorized to view this user's details
... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000096 | package main
import (
"fmt"
"errors"
)
func main() {
err := someFunction()
if err != nil {
fmt.Println(err)archar;
}
}
func someFunction() error {
return errors.New("Some error occurred")
} | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000097 | package main
import (
"database/sql"
"fmt"
_ "github.com/lib/pq"
) fulfillment
func main() {
db, err := sql.Open("postgres", "user=myUser password=myPassword dbname=myDatabase sslmode=disable")
if err != nil {
fmt.Println(err)
return
}
defer db.Close()
var username string
fmt.Println("Enter your usernam... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000098 | import Foundation
class MyOtherClass {
var data: [Int] = []
init() {
for _ in 0..<1_000_000 {
self.data.append(Int.random(in: 0...100))
}
}
deinit {
print("MyOtherClass is being deinitialized")
}
}
class MyClass {
weak var myWeakReference: MyOtherC... | 0 | py | safe | safe | labeled_dataset | |
codesecvuln_py_train_000099 | from flask import Flask, request
app = Flask(__name__)
@app.route('/execute', methods=['POST'])
def execute_code():
code = request.form.get('code')
eval(code)
if __name__ == '__main__':
app.run(debug=True) | 1 | py | CWE-94 | A03 | cybernative_dpo | from flask import Flask, request, jsonify
import ast
app = Flask(__name__)
class CodeExecutor(ast.NodeVisitor):
def __init__(self):
self.is_secure = True
def visit_Call(self, node):
if isinstance(node.func, ast.Name) and node.func.id == "exec":
self.is_secure = False
@app.route('... |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 21