Spaces:
Configuration error
Configuration error
| import base64 | |
| import logging | |
| from typing import Optional | |
| from urllib.parse import urlparse | |
| logger = logging.getLogger(__name__) | |
| def is_base64_url(url: str) -> bool: | |
| """ | |
| Check if a URL appears to be base64 encoded. | |
| Args: | |
| url (str): The URL to check. | |
| Returns: | |
| bool: True if the URL appears to be base64 encoded, False otherwise. | |
| """ | |
| # Check if the URL doesn't start with http/https and contains base64-like characters | |
| if url.startswith(("http://", "https://", "ftp://", "ftps://")): | |
| return False | |
| # Base64 URLs typically contain only alphanumeric characters, +, /, and = | |
| # and don't contain typical URL characters like :// | |
| base64_chars = set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=") | |
| url_chars = set(url) | |
| # If the URL contains characters not in base64 charset, it's likely not base64 | |
| if not url_chars.issubset(base64_chars): | |
| return False | |
| # Additional heuristic: base64 strings are typically longer and don't contain common URL patterns | |
| if len(url) < 10: # Too short to be a meaningful base64 encoded URL | |
| return False | |
| return True | |
| def decode_base64_url(encoded_url: str) -> Optional[str]: | |
| """ | |
| Decode a base64 encoded URL. | |
| Args: | |
| encoded_url (str): The base64 encoded URL string. | |
| Returns: | |
| Optional[str]: The decoded URL if successful, None if decoding fails. | |
| """ | |
| try: | |
| # Handle URL-safe base64 encoding (replace - with + and _ with /) | |
| url_safe_encoded = encoded_url.replace("-", "+").replace("_", "/") | |
| # Add padding if necessary | |
| missing_padding = len(url_safe_encoded) % 4 | |
| if missing_padding: | |
| url_safe_encoded += "=" * (4 - missing_padding) | |
| # Decode the base64 string | |
| decoded_bytes = base64.b64decode(url_safe_encoded) | |
| decoded_url = decoded_bytes.decode("utf-8") | |
| # Validate that the decoded string is a valid URL | |
| parsed = urlparse(decoded_url) | |
| if parsed.scheme and parsed.netloc: | |
| logger.info(f"Successfully decoded base64 URL: {encoded_url[:50]}... -> {decoded_url}") | |
| return decoded_url | |
| else: | |
| logger.warning(f"Decoded string is not a valid URL: {decoded_url}") | |
| return None | |
| except (base64.binascii.Error, UnicodeDecodeError, ValueError) as e: | |
| logger.debug(f"Failed to decode base64 URL '{encoded_url[:50]}...': {e}") | |
| return None | |
| def encode_url_to_base64(url: str, url_safe: bool = True) -> str: | |
| """ | |
| Encode a URL to base64. | |
| Args: | |
| url (str): The URL to encode. | |
| url_safe (bool): Whether to use URL-safe base64 encoding (default: True). | |
| Returns: | |
| str: The base64 encoded URL. | |
| """ | |
| try: | |
| url_bytes = url.encode("utf-8") | |
| if url_safe: | |
| # Use URL-safe base64 encoding (replace + with - and / with _) | |
| encoded = base64.urlsafe_b64encode(url_bytes).decode("utf-8") | |
| # Remove padding for cleaner URLs | |
| encoded = encoded.rstrip("=") | |
| else: | |
| encoded = base64.b64encode(url_bytes).decode("utf-8") | |
| logger.debug(f"Encoded URL to base64: {url} -> {encoded}") | |
| return encoded | |
| except Exception as e: | |
| logger.error(f"Failed to encode URL to base64: {e}") | |
| raise | |
| def process_potential_base64_url(url: str) -> str: | |
| """ | |
| Process a URL that might be base64 encoded. If it's base64 encoded, decode it. | |
| Otherwise, return the original URL. | |
| Args: | |
| url (str): The URL to process. | |
| Returns: | |
| str: The processed URL (decoded if it was base64, original otherwise). | |
| """ | |
| if is_base64_url(url): | |
| decoded_url = decode_base64_url(url) | |
| if decoded_url: | |
| return decoded_url | |
| else: | |
| logger.warning(f"URL appears to be base64 but failed to decode: {url[:50]}...") | |
| return url | |