Table of Contents

Funcții Python riscante și alternativele lor

Python este un limbaj versatil și răspândit, cu funcții pentru multe sarcini. Unele funcții prezintă riscuri de securitate și pot produce efecte neașteptate dacă sunt folosite fără grijă. Această secțiune prezintă funcții Python riscante, pericolele asociate și alternative mai sigure cu utilizare similară, pentru a consolida securitatea și stabilitatea.

Introducere: protejează-ți proiectele Python

Python este apreciat pentru biblioteca extinsă și sintaxa intuitivă. Folosirea greșită a unor funcții poate afecta securitatea și fiabilitatea. Înțelegerea riscurilor și alegerea altor metode ajută la scrierea unui cod mai rezistent.


Funcții Python riscante și pericolele lor

Executarea dinamică a codului cu eval()

eval() execută dinamic cod Python dintr-un șir. Poate permite atacuri prin injectare de cod dacă intrările utilizatorilor nu sunt curățate corespunzător. Ia în considerare ast.literal_eval() sau exec() pentru executare controlată și sigură.

Executarea dinamică a codului cu eval():

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

Alternativă mai sigură cu 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.")

Concatenarea șirurilor cu date necurățate

Concatenarea șirurilor cu intrări necurățate poate produce injecții SQL sau vulnerabilități de cross-site scripting (XSS). Folosește f-string-uri sau str.format() împreună cu validarea intrărilor.

Concatenare nesigură a șirurilor:

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

Folosirea f-string-urilor (șiruri formatate literale):

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

Pickle pentru serializarea obiectelor

Modulul pickle serializează și deserialează obiecte Python, dar nu este sigur împotriva datelor greșite sau construite cu intenții malițioase. Pentru o serializare mai sigură, alege biblioteci precum json sau marshal.

Folosirea nesigură a pickle:

import pickle

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

Alternativă mai sigură cu json:

import json

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

Escaparea insuficientă a HTML cu mark_safe()

Funcția Django mark_safe() marchează un șir drept HTML sigur și poate expune aplicațiile la atacuri XSS. Folosește escaparea șabloanelor și filtrul safe pentru afișarea sigură a conținutului HTML.

Folosirea nesigură a mark_safe() într-un șablon Django:

from django.utils.safestring import mark_safe

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

Abordare mai sigură cu escaparea șablonului:

from django.utils.html import escape

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

Folosirea os.system() pentru comenzi de sistem

os.system() execută comenzi de sistem, dar este vulnerabilă la injectarea comenzilor. Folosește modulul subprocess pentru executarea mai sigură a comenzilor și gestionarea rezultatelor.

Folosirea nesigură a os.system():

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

Alternativă mai sigură cu subprocess:

import subprocess

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

Hashing insuficient al parolelor cu hash()

hash() nu este potrivită pentru protejarea parolelor din cauza vitezei și vulnerabilității la atacuri prin forță brută. Folosește biblioteci robuste precum bcrypt sau Argon2.

Hashing nesigur al parolei cu hash():

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

Abordare mai sigură cu 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 mai sigure și bune practici

Folosește requests în loc de urllib

Pentru solicitări HTTP, preferă requests în locul bibliotecii învechite urllib. Oferă o interfață mai comodă și mai sigură pentru trimiterea solicitărilor și procesarea răspunsurilor.

Solicitări HTTP cu biblioteca 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.")

Gestionarea sigură a fișierelor cu instrucțiunea with

Folosește with când lucrezi cu fișiere pentru a evita pierderile de resurse și a le gestiona corect. Instrucțiunea închide automat fișierele și reduce riscul de erori și vulnerabilități.

Gestionarea fișierelor cu 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()

Curățarea intrărilor cu html.escape()

Pentru a preveni atacurile XSS, curăță intrările utilizatorilor cu html.escape(). Funcția escapează HTML-ul potențial periculos înainte de afișare.

Curățarea intrării utilizatorului pentru prevenirea XSS:

import html

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

Interogări parametrizate cu sqlite3

Folosește interogări parametrizate sqlite3 pentru operațiile cu baze de date. Acestea ajută la prevenirea injecțiilor SQL, transmițând intrările drept valori ale interogării.

Interogări parametrizate cu 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()

Gestionarea sigură a variabilelor de mediu

Nu expune informații sensibile direct în cod. Folosește variabile de mediu prin dicționarul os.environ sau un pachet precum python-decouple.

Gestionarea variabilelor cu 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.")

Gestionarea variabilelor cu python-decouple:

from decouple import config

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

Valori aleatoare puternice cu secrets

Folosește secrets în loc de random pentru valori aleatoare sigure criptografic. Modulul este potrivit pentru operații sensibile la securitate.

Generarea de tokenuri sigure cu secrets:

import secrets

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

Concluzie

Ecosistemul Python ajută dezvoltatorii să creeze aplicații puternice și complexe. Folosirea neatentă a unor funcții poate introduce vulnerabilități și compromite integritatea codului. Bunele practici și alternativele mai sigure ajută la crearea unui software mai fiabil.


Referințe