How to Write Secure Python Code: A Step-by-Step Guide

Ensuring code security is a critical task for every Python developer. In this step-by-step guide, we’ll explore best practices and techniques to help you write secure code that is resilient to common vulnerabilities and attacks.

Step 1: Using Virtual Environments

Virtual environments in Python allow you to isolate project dependencies, reducing the risk of conflicts and vulnerabilities. They provide:

  1. Dependency isolation: Each virtual environment has its own set of dependencies, independent from other projects or the global environment.
  2. Version control: You can control the versions of all packages used, ensuring compatibility and security of your code.
  3. Reduced risk: Accidental installation of a malicious package only affects the virtual environment, not the entire system.

Example of creating a virtual environment:

python3 -m venv env
source env/bin/activate

These commands will create and activate a virtual environment named env. Now all Python packages will be installed and run in isolation within env, without affecting the global environment or other projects.

Step 2: Limiting Variable and Function Scope

The next step to secure Python code is limiting the scope of variables and functions. Here are a few tips:

  • Avoid using global variables, as they increase the risk of accidental modification or unauthorized access to data.
  • Prefer local variables protected by function scope, making them inaccessible to the rest of the code.

Consider this example with a global variable:

secret = "my super secret password"
def print_secret():
# Accessing global variable


In this case, the secret variable is accessible to all functions in the code, making it potentially vulnerable.

Now let’s compare it with an example using a local variable:

def print_secret():
    secret = "my super secret password"


Here, the secret variable is protected by the scope of the print_secret function, making it inaccessible to the rest of the code and enhancing security.

Step 3: Modularizing Code

Modularity is key to writing secure and maintainable Python code. By splitting your code into separate, independent blocks (modules), each performing its unique function, you:

  1. Improve code organization and reusability.
  2. Simplify testing, debugging, and ensure better error isolation.
  3. Reduce the risk of introducing vulnerabilities, as each module is independent and can be audited separately.

Let’s consider two examples: a bad one (everything in one file) and a good one (split into modules).

Bad example:

def do_something():
# Too many different tasks in one function

def do_something_else():
# Dependent code that is hard to debug

Good example:

def do_part_one():
    print("Part one")

def do_part_two():
    print("Part two")

from module_a import do_part_one
from module_b import do_part_two

def main():

This separation makes each part of the code independent, simplifying testing, debugging, and ensuring better error isolation.

Step 4: Protecting Against Code Injection

Code injection is one of the most serious threats to any application. Here’s how you can protect your Python code:

  1. Use parameterized queries instead of string formatting to prevent the execution of malicious code.
  2. Thoroughly validate and sanitize all input data before using it.

Consider this example of vulnerable code:

def get_user(user_id):
    query = f"SELECT * FROM users WHERE id = {user_id}"
    return execute_query(query)

If user_id contains SQL code, it can be executed by the database, leading to SQL injection.

Now, a secure version:

def get_user(user_id):
    query = "SELECT * FROM users WHERE id = ?"
    return execute_query(query, (user_id,))

Using parameterized queries helps prevent the execution of malicious code, as input data is treated as a string, not as part of the SQL command.

Step 5: Secure Serialization and Deserialization

Serialization and deserialization can be a source of vulnerabilities if an attacker can tamper with the data. Here are a few tips:

  • Avoid using unsafe modules like pickle, which can execute arbitrary code during deserialization.
  • Prefer secure alternatives, such as the json module, which only works with simple data types.

Example of vulnerable code using the pickle module:

import pickle

def unsafe_deserialization(data):
    return pickle.loads(data)

Now a secure example using the json module:

import json

def safe_deserialization(data):
    return json.loads(data)

Step 6: Following the Principle of Least Privilege

Limiting the permissions of programs and processes to the bare minimum can significantly reduce the potential damage from vulnerabilities.

def process_user_data(user_data):
# Code here processes user data without unnecessary privileges

In this example, the process_user_data function only works with user data and does not require elevated permissions, reducing risks in case it is compromised.

Step 7: Authentication and Authorization Security

Weak authentication and authorization mechanisms can lead to unauthorized access. Here’s an example of protecting passwords using hashing:

import bcrypt

password = b"super secret password"
hashed = bcrypt.hashpw(password, bcrypt.gensalt())

Using the bcrypt library for password hashing ensures that even in the event of a data breach, an attacker won’t be able to easily recover the original password.

Step 8: Proper Session Management

Proper session management in web applications plays a key role in securing user data and interactions. Here are a few tips:

  1. Set Secure and HttpOnly flags on session cookies to protect against interception and XSS attacks.
  2. Regenerate the session ID on each important user interaction, especially after authentication.
  3. Set a reasonable session lifetime to reduce the risks associated with session hijacking.

Example code using Flask:

from flask import Flask, session
from datetime import timedelta

app = Flask(__name__)
    SESSION_COOKIE_HTTPONLY=True, # Prevent access to cookies via JS
    SESSION_COOKIE_SAMESITE='Lax' # Restrict cookie sending to third-party site requests
app.permanent_session_lifetime = timedelta(minutes=15) # 15-minute session timeout

@app.route('/login', methods=['POST'])
def login():
# Check credentials
    session.regenerate() # Regenerate session ID after successful login
    return "Logged in successfully!"

Step 9: Caution with eval() and exec()

The eval() and exec() functions allow the execution of arbitrary code, which can be dangerous. Use these functions with extreme caution and only after thoroughly sanitizing and validating all input data.

Example of potentially dangerous use of eval():

eval('os.system("rm -rf /")')

Such code would allow the execution of any OS command, potentially leading to catastrophic consequences.


Writing secure Python code requires constant vigilance, adherence to best practices, and regular updates to your knowledge of cybersecurity. By applying the techniques described in this step-by-step guide, you can significantly enhance the protection of your Python applications against common vulnerabilities and attacks.

Remember that security is an ongoing process that requires continuous attention and adaptation to new threats. Regularly review and update your code, stay informed about the latest security recommendations, and always be ready to learn and improve in this critically important area of software development.

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.