Veilig programmeren in Python

Table of Contents
Onveilige Python-functies en alternatieven
Python is veelzijdig en wordt veel gebruikt. Het biedt functies voor allerlei taken, maar sommige functies brengen beveiligingsrisico’s en onverwachte gevolgen mee als je ze onvoorzichtig gebruikt. Dit artikel bespreekt onveilige Python-functies, hun risico’s en veiligere alternatieven met vergelijkbare functionaliteit, zodat je de beveiliging en stabiliteit van je code verbetert.
Inleiding: bescherm je Python-projecten
Python is populair door de uitgebreide bibliotheek en intuïtieve syntaxis. Verkeerd gebruik van sommige functies kan de beveiliging en betrouwbaarheid ondermijnen. Leer de risico’s herkennen en kies andere methoden om code te bouwen die beter tegen aanvallen bestand is.
Onveilige Python-functies en hun risico’s
Dynamische code-uitvoering met eval()
eval() voert Python-code uit een tekenreeks dynamisch uit. De functie is krachtig, maar kan code-injectieaanvallen mogelijk maken als invoer niet goed wordt opgeschoond. Kies ast.literal_eval() of exec() voor gecontroleerde en veilige code-uitvoering.
Dynamische code-uitvoering met eval():
# Unsafe: Using eval() for dynamic code execution
user_input = input("Enter a Python expression: ")
result = eval(user_input)
print("Result:", result)
Veiliger alternatief met ast.literal_eval():
import ast
user_input = input("Enter a literal value: ")
try:
parsed_value = ast.literal_eval(user_input)
print("Parsed value:", parsed_value)
except (ValueError, SyntaxError):
print("Invalid input.")
Tekenreeksen samenvoegen met onbewerkte invoer
Tekenreeksen samenvoegen met niet-opgeschoonde gebruikersinvoer kan leiden tot SQL-injectie of cross-site scripting (XSS). Gebruik f-strings of str.format() in combinatie met invoervalidatie.
Onveilige samenvoeging van tekenreeksen:
user_input = input("Enter your name: ")
message = "Hello, " + user_input + "!"
print(message)
f-strings gebruiken (opgemaakte tekenreeksliteralen):
user_input = input("Enter your name: ")
message = f"Hello, {user_input}!"
print(message)
Pickle voor objectserialisatie
De module pickle kan Python-objecten serialiseren en deserialiseren, maar is niet veilig voor foutieve of kwaadwillig samengestelde gegevens. Gebruik voor veiligere serialisatie bibliotheken zoals json of marshal.
Onveilig gebruik van pickle:
import pickle
data = {'user': 'admin', 'role': 'admin'}
serialized_data = pickle.dumps(data)
# Store or send serialized_data
Veiliger alternatief met json:
import json
data = {'user': 'admin', 'role': 'admin'}
serialized_data = json.dumps(data)
# Store or send serialized_data
HTML onvoldoende escapen met mark_safe()
Django’s functie mark_safe() markeert een tekenreeks als veilige HTML, waardoor toepassingen mogelijk kwetsbaar zijn voor XSS-aanvallen. Gebruik template-escaping en het filter safe om HTML veilig weer te geven.
Onveilig gebruik van mark_safe() in een Django-template:
from django.utils.safestring import mark_safe
input_data = input("Enter some HTML content: ")
safe_html = mark_safe(input_data)
Veiliger aanpak met template-escaping:
from django.utils.html import escape
input_data = input("Enter some HTML content: ")
escaped_html = escape(input_data)
os.system() voor systeemopdrachten
os.system() voert systeemopdrachten uit, maar is gevoelig voor opdrachtinjectie. Gebruik subprocess om opdrachten veiliger uit te voeren en de uitvoer af te handelen.
Onveilig gebruik van os.system():
command = input("Enter a command: ")
os.system(command)
Veiliger alternatief met subprocess:
import subprocess
command = input("Enter a command: ")
result = subprocess.run(command, shell=True, capture_output=True, text=True)
print("Output:", result.stdout)
Onvoldoende wachtwoordhashing met hash()
hash() is door zijn snelheid en kwetsbaarheid voor bruteforceaanvallen ongeschikt voor het veilig hashen van wachtwoorden. Gebruik robuuste bibliotheken zoals bcrypt of Argon2.
Onveilige wachtwoordhashing met hash():
password = input("Enter your password: ")
hashed_password = hash(password)
# Store hashed_password in the database
Veiliger aanpak met bcrypt:
import bcrypt
password = input("Enter your password: ")
hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
# Store hashed_password in the database
Veiligere alternatieven en goede praktijken
Gebruik requests in plaats van urllib
Geef voor HTTP-verzoeken de voorkeur aan requests boven het verouderde urllib. requests biedt een gebruiksvriendelijkere en veiligere interface om verzoeken te versturen en reacties te verwerken.
HTTP-verzoeken met de requests-bibliotheek:
import requests
url = "https://api.example.com/data"
response = requests.get(url)
if response.status_code == 200:
data = response.json()
print(data)
else:
print("Request failed.")
Bestanden veilig verwerken met de with-instructie
Gebruik with voor bestandsbewerkingen om resourcelekken te voorkomen en bestanden goed af te handelen. De instructie sluit bestanden automatisch en vermindert het risico op fouten en kwetsbaarheden.
Bestandsverwerking met with:
filename = "example.txt"
# Unsafe: Without using `with`
file = open(filename, "r")
content = file.read()
file.close()
# Safer: Using `with` statement
with open(filename, "r") as file:
content = file.read()
Invoer opschonen met html.escape()
Voorkom XSS-aanvallen door invoer op te schonen met html.escape(). Deze functie escaped mogelijk schadelijke HTML voordat je die weergeeft.
Gebruikersinvoer opschonen tegen XSS:
import html
user_input = input("Enter some text: ")
sanitized_input = html.escape(user_input)
print("Sanitized input:", sanitized_input)
Geparametriseerde query’s met sqlite3
Gebruik bij databasebewerkingen geparametriseerde query’s met sqlite3. Ze helpen SQL-injectieaanvallen voorkomen door invoer als querywaarden door te geven.
Geparametriseerde query’s met sqlite3:
import sqlite3
db_connection = sqlite3.connect("database.db")
cursor = db_connection.cursor()
name = input("Enter a name: ")
age = input("Enter an age: ")
query = "INSERT INTO users (name, age) VALUES (?, ?)"
cursor.execute(query, (name, age))
db_connection.commit()
db_connection.close()
Omgevingsvariabelen veilig beheren
Zet gevoelige informatie niet rechtstreeks in code. Gebruik omgevingsvariabelen via os.environ of een pakket zoals python-decouple voor veiliger configuratiebeheer.
Omgevingsvariabelen beheren met os.environ:
import os
api_key = os.environ.get("API_KEY")
if api_key:
print("API Key:", api_key)
else:
print("API Key not set.")
Omgevingsvariabelen beheren met python-decouple:
from decouple import config
api_key = config("API_KEY")
print("API Key:", api_key)
Sterke willekeur met secrets
Gebruik secrets in plaats van random om cryptografisch veilige willekeurige waarden te genereren. Dit past bij beveiligingsgevoelige taken.
Veilige tokens genereren met secrets:
import secrets
token = secrets.token_hex(16)
print("Secure Token:", token)
Conclusie
Het Python-ecosysteem helpt ontwikkelaars krachtige toepassingen te bouwen. Onzorgvuldig gebruik van bepaalde functies kan echter kwetsbaarheden veroorzaken en de integriteit van code aantasten. Met goede praktijken en veiligere alternatieven bouw je betrouwbaardere software.
Bronnen
- Python-documentatie: https://docs.python.org
- Django-documentatie: https://docs.djangoproject.com
- OWASP-gids voor preventie van cross-site scripting (XSS): https://owasp.org/www-project-cheat-sheets/cheatsheets/Cross_Site_Scripting_Prevention_Cheat_Sheet.html
- OWASP-gids voor preventie van SQL-injectie: https://owasp.org/www-project-cheat-sheets/cheatsheets/SQL_Injection_Prevention_Cheat_Sheet.html
- Python Requests-bibliotheek: https://docs.python-requests.org
- SQLite3-documentatie: https://docs.python.org/3/library/sqlite3.html
- Python-module
secrets: https://docs.python.org/3/library/secrets.html - python-decouple-pakket: https://pypi.org/project/python-decouple/







