Download src/utils/security.py from umarwaqar/phase-iii: direct link, hf CLI and curl.
- Browser
- Download file 5.79 kB
-
https://huggingface.co/spaces/umarwaqar/phase-iii/resolve/main/src/utils/security.py
- Command line
-
hf download hf://spaces/umarwaqar/phase-iii/src/utils/security.py
-
curl -L -o security.py https://huggingface.co/spaces/umarwaqar/phase-iii/resolve/main/src/utils/security.py
5.79 kB
| """ | |
| Security utilities for the Todo application | |
| """ | |
| import re | |
| from typing import Optional | |
| from fastapi import HTTPException, status | |
| class SecurityValidator: | |
| """Security validation utilities""" | |
| # Password requirements | |
| MIN_PASSWORD_LENGTH = 8 | |
| MAX_PASSWORD_LENGTH = 128 | |
| # Username requirements | |
| MIN_USERNAME_LENGTH = 3 | |
| MAX_USERNAME_LENGTH = 30 | |
| USERNAME_PATTERN = re.compile(r'^[a-zA-Z0-9_-]+$') | |
| # Email validation | |
| EMAIL_PATTERN = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$') | |
| # SQL injection patterns to detect | |
| SQL_INJECTION_PATTERNS = [ | |
| r"(\bUNION\b.*\bSELECT\b)", | |
| r"(\bDROP\b.*\bTABLE\b)", | |
| r"(\bINSERT\b.*\bINTO\b)", | |
| r"(\bDELETE\b.*\bFROM\b)", | |
| r"(--)", | |
| r"(;.*--)", | |
| r"(\bOR\b.*=.*)", | |
| r"('.*OR.*'.*=.*')" | |
| ] | |
| def validate_password(cls, password: str) -> tuple[bool, Optional[str]]: | |
| """ | |
| Validate password strength | |
| Returns: (is_valid, error_message) | |
| """ | |
| if len(password) < cls.MIN_PASSWORD_LENGTH: | |
| return False, f"Password must be at least {cls.MIN_PASSWORD_LENGTH} characters" | |
| if len(password) > cls.MAX_PASSWORD_LENGTH: | |
| return False, f"Password must be at most {cls.MAX_PASSWORD_LENGTH} characters" | |
| # Check for at least one uppercase letter | |
| if not re.search(r'[A-Z]', password): | |
| return False, "Password must contain at least one uppercase letter" | |
| # Check for at least one lowercase letter | |
| if not re.search(r'[a-z]', password): | |
| return False, "Password must contain at least one lowercase letter" | |
| # Check for at least one digit | |
| if not re.search(r'\d', password): | |
| return False, "Password must contain at least one digit" | |
| # Check for at least one special character | |
| if not re.search(r'[!@#$%^&*(),.?":{}|<>]', password): | |
| return False, "Password must contain at least one special character" | |
| return True, None | |
| def validate_username(cls, username: str) -> tuple[bool, Optional[str]]: | |
| """ | |
| Validate username format | |
| Returns: (is_valid, error_message) | |
| """ | |
| if len(username) < cls.MIN_USERNAME_LENGTH: | |
| return False, f"Username must be at least {cls.MIN_USERNAME_LENGTH} characters" | |
| if len(username) > cls.MAX_USERNAME_LENGTH: | |
| return False, f"Username must be at most {cls.MAX_USERNAME_LENGTH} characters" | |
| if not cls.USERNAME_PATTERN.match(username): | |
| return False, "Username can only contain letters, numbers, hyphens, and underscores" | |
| return True, None | |
| def validate_email(cls, email: str) -> tuple[bool, Optional[str]]: | |
| """ | |
| Validate email format | |
| Returns: (is_valid, error_message) | |
| """ | |
| if not cls.EMAIL_PATTERN.match(email): | |
| return False, "Invalid email format" | |
| if len(email) > 254: # RFC 5321 | |
| return False, "Email address is too long" | |
| return True, None | |
| def check_sql_injection(cls, input_string: str) -> bool: | |
| """ | |
| Check if input contains potential SQL injection patterns | |
| Returns: True if suspicious pattern detected | |
| """ | |
| input_upper = input_string.upper() | |
| for pattern in cls.SQL_INJECTION_PATTERNS: | |
| if re.search(pattern, input_upper, re.IGNORECASE): | |
| return True | |
| return False | |
| def sanitize_input(cls, input_string: str, max_length: int = 1000) -> str: | |
| """ | |
| Sanitize user input by removing potentially dangerous characters | |
| """ | |
| if cls.check_sql_injection(input_string): | |
| raise HTTPException( | |
| status_code=status.HTTP_400_BAD_REQUEST, | |
| detail="Invalid input detected" | |
| ) | |
| # Truncate to max length | |
| sanitized = input_string[:max_length] | |
| # Remove null bytes | |
| sanitized = sanitized.replace('\x00', '') | |
| return sanitized.strip() | |
| def validate_task_title(cls, title: str) -> tuple[bool, Optional[str]]: | |
| """ | |
| Validate task title | |
| Returns: (is_valid, error_message) | |
| """ | |
| if not title or len(title.strip()) == 0: | |
| return False, "Title cannot be empty" | |
| if len(title) > 200: | |
| return False, "Title must be 200 characters or less" | |
| if cls.check_sql_injection(title): | |
| return False, "Invalid characters in title" | |
| return True, None | |
| def validate_task_description(cls, description: Optional[str]) -> tuple[bool, Optional[str]]: | |
| """ | |
| Validate task description | |
| Returns: (is_valid, error_message) | |
| """ | |
| if description is None: | |
| return True, None | |
| if len(description) > 1000: | |
| return False, "Description must be 1000 characters or less" | |
| if cls.check_sql_injection(description): | |
| return False, "Invalid characters in description" | |
| return True, None | |
| def validate_content_type(content_type: str, allowed_types: list[str]) -> bool: | |
| """ | |
| Validate content type against allowed types | |
| """ | |
| return content_type in allowed_types | |
| def generate_secure_headers() -> dict: | |
| """ | |
| Generate secure HTTP headers | |
| """ | |
| return { | |
| "X-Content-Type-Options": "nosniff", | |
| "X-Frame-Options": "DENY", | |
| "X-XSS-Protection": "1; mode=block", | |
| "Strict-Transport-Security": "max-age=31536000; includeSubDomains", | |
| "Content-Security-Policy": "default-src 'self'", | |
| "Referrer-Policy": "strict-origin-when-cross-origin" | |
| } | |