Table of Contents

Funzioni Python rischiose e alternative

Python è un linguaggio versatile e diffuso, con strumenti per numerose attività. Alcune funzioni, però, comportano rischi e conseguenze impreviste se usate senza attenzione. Questa sezione presenta le funzioni Python rischiose, i pericoli associati e alternative più sicure con capacità equivalenti, per rafforzare sicurezza e stabilità.

Introduzione: proteggi i tuoi progetti Python

Python è apprezzato per l’ampia libreria e la sintassi intuitiva. Se gestite male, alcune funzioni compromettono sicurezza e affidabilità. Conoscere i rischi e adottare altri metodi aiuta a creare codice più resistente.


Funzioni Python rischiose e relativi pericoli

Esecuzione dinamica di codice con eval()

eval() esegue dinamicamente codice Python contenuto in una stringa. Può favorire attacchi di code injection se i dati inseriti dagli utenti non vengono ripuliti correttamente. Valuta ast.literal_eval() o exec() per un’esecuzione controllata e sicura.

Esecuzione dinamica con eval():

# Unsafe: Using eval() for dynamic code execution
user_input = input("Enter a Python expression: ")
result = eval(user_input)
print("Result:", result)

Alternativa più sicura con 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.")

Concatenare stringhe con dati non ripuliti

Concatenare stringhe con input non ripuliti può causare vulnerabilità di SQL injection o cross-site scripting (XSS). Usa f-string o str.format() insieme alla convalida dell’input.

Concatenazione rischiosa di stringhe:

user_input = input("Enter your name: ")
message = "Hello, " + user_input + "!"
print(message)

Uso di f-string (stringhe letterali formattate):

user_input = input("Enter your name: ")
message = f"Hello, {user_input}!"
print(message)

Pickle per serializzare oggetti

Il modulo pickle serializza e deserializza oggetti Python, ma non è sicuro contro dati errati o costruiti in modo malevolo. Per serializzare in modo più sicuro, scegli librerie come json o marshal.

Uso non sicuro di pickle:

import pickle

data = {'user': 'admin', 'role': 'admin'}
serialized_data = pickle.dumps(data)
# Store or send serialized_data

Alternativa più sicura con json:

import json

data = {'user': 'admin', 'role': 'admin'}
serialized_data = json.dumps(data)
# Store or send serialized_data

Escape HTML insufficiente con mark_safe()

La funzione Django mark_safe() contrassegna una stringa come HTML sicuro, esponendo potenzialmente le applicazioni ad attacchi XSS. Usa invece l’escape dei template e il filtro safe per visualizzare HTML in modo sicuro.

Uso rischioso di mark_safe() in un template Django:

from django.utils.safestring import mark_safe

input_data = input("Enter some HTML content: ")
safe_html = mark_safe(input_data)

Approccio più sicuro con escape del template:

from django.utils.html import escape

input_data = input("Enter some HTML content: ")
escaped_html = escape(input_data)

Usare os.system() per comandi di sistema

os.system() esegue comandi di sistema, ma è vulnerabile all’iniezione di comandi. Usa il modulo subprocess per eseguire comandi in modo più sicuro e gestirne i risultati.

Uso rischioso di os.system():

command = input("Enter a command: ")
os.system(command)

Alternativa più sicura con subprocess:

import subprocess

command = input("Enter a command: ")
result = subprocess.run(command, shell=True, capture_output=True, text=True)
print("Output:", result.stdout)

Hash delle password inadeguato con hash()

La velocità di hash() e la sua vulnerabilità agli attacchi brute force lo rendono inadatto alla protezione delle password. Usa librerie robuste come bcrypt o Argon2.

Hash non sicuro con hash():

password = input("Enter your password: ")
hashed_password = hash(password)
# Store hashed_password in the database

Approccio più sicuro con bcrypt:

import bcrypt

password = input("Enter your password: ")
hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
# Store hashed_password in the database

Alternative più sicure e buone pratiche

Preferisci requests a urllib

Per le richieste HTTP, preferisci requests al superato urllib. Offre un’interfaccia più semplice e sicura per inviare richieste e gestire risposte.

Richieste HTTP con requests:

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.")

Gestire i file in sicurezza con with

Usa l’istruzione with con i file per evitare perdite di risorse e gestire correttamente l’apertura e la chiusura. Riduce il rischio di errori e vulnerabilità.

Gestione dei file con 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()

Ripulire gli input con html.escape()

Per prevenire gli attacchi XSS, ripulisci l’input con html.escape(), che esegue l’escape dell’HTML potenzialmente dannoso prima di mostrarlo.

Ripulire l’input per prevenire XSS:

import html

user_input = input("Enter some text: ")
sanitized_input = html.escape(user_input)
print("Sanitized input:", sanitized_input)

Query parametrizzate con sqlite3

Usa query parametrizzate di sqlite3 quando interagisci con database. Aiutano a prevenire SQL injection passando i dati degli utenti come valori della query.

Query parametrizzate con 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()

Gestire le variabili d’ambiente in modo sicuro

Non esporre informazioni sensibili direttamente nel codice. Usa variabili d’ambiente con os.environ o un pacchetto come python-decouple.

Variabili d’ambiente con 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.")

Variabili d’ambiente con python-decouple:

from decouple import config

api_key = config("API_KEY")
print("API Key:", api_key)

Valori casuali robusti con secrets

Per generare valori casuali crittograficamente sicuri, usa secrets anziché random. È indicato per le operazioni sensibili alla sicurezza.

Generare token sicuri con secrets:

import secrets

token = secrets.token_hex(16)
print("Secure Token:", token)

Conclusione

L’ecosistema Python consente di sviluppare applicazioni ricche di funzionalità. L’uso imprudente di alcune funzioni può introdurre vulnerabilità e compromettere l’integrità del codice. Buone pratiche e alternative più sicure aiutano a realizzare software affidabile.


Riferimenti