GuardianUnivalle-Benito-Yucra 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

GuardianUnivalle_Benito_Yucra/__init__.py

@@ -1,10 +1,17 @@
 """ Funciones principales """
 # GuardianUnivalle_Benito_Yucra/__init__.py
 
-from .encryption import encrypt_data, decrypt_data
-from .web_protection import sanitize_input, check_csrf
-from .dos_protection import rate_limiter
-from .malware_check import scan_malware
+"""
+Paquete principal de GuardianUnivalle.
+Incluye módulos de criptografía, detección de ataques, mitigación, auditoría y puntuación de amenazas.
+"""
+from . import criptografia
+from . import detectores
+from . import mitigacion
+from . import auditoria
+from . import puntuacion
+from . import middleware_web
+from . import utilidades
 
 def protect_app():
     """

GuardianUnivalle_Benito_Yucra/auditoria/registro_auditoria.py

@@ -0,0 +1,9 @@
+import datetime
+
+def registrar_evento(tipo: str, mensaje: str):
+    with open("auditoria_guardian.log", "a", encoding="utf-8") as f:
+        f.write(f"[{datetime.datetime.now()}] {tipo}: {mensaje}\n")
+
+def generar_reporte() -> str:
+    with open("auditoria_guardian.log", "r", encoding="utf-8") as f:
+        return f.read()

GuardianUnivalle_Benito_Yucra/criptografia/cifrado_aead.py

@@ -0,0 +1,25 @@
+"""
+Cifrado simétrico autenticado: AES-GCM y ChaCha20-Poly1305
+"""
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM, ChaCha20Poly1305
+import os
+
+def cifrar_aes_gcm(mensaje: bytes, clave: bytes) -> dict:
+    aes = AESGCM(clave)
+    nonce = os.urandom(12)
+    ciphertext = aes.encrypt(nonce, mensaje, None)
+    return {"nonce": nonce, "ciphertext": ciphertext}
+
+def descifrar_aes_gcm(cipher: dict, clave: bytes) -> bytes:
+    aes = AESGCM(clave)
+    return aes.decrypt(cipher["nonce"], cipher["ciphertext"], None)
+
+def cifrar_chacha20(mensaje: bytes, clave: bytes) -> dict:
+    cipher = ChaCha20Poly1305(clave)
+    nonce = os.urandom(12)
+    ciphertext = cipher.encrypt(nonce, mensaje, None)
+    return {"nonce": nonce, "ciphertext": ciphertext}
+
+def descifrar_chacha20(cipher: dict, clave: bytes) -> bytes:
+    cipher_obj = ChaCha20Poly1305(clave)
+    return cipher_obj.decrypt(cipher["nonce"], cipher["ciphertext"], None)

GuardianUnivalle_Benito_Yucra/criptografia/intercambio_claves.py

@@ -0,0 +1,23 @@
+"""
+Gestión de intercambio de claves con ECDH y derivación HKDF.
+"""
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+from cryptography.hazmat.primitives import hashes
+
+def generar_claves_ecdh():
+    """Genera clave privada y pública ECDH"""
+    clave_privada = ec.generate_private_key(ec.SECP384R1())
+    clave_publica = clave_privada.public_key()
+    return clave_privada, clave_publica
+
+def derivar_clave_secreta(clave_privada, clave_publica):
+    """Deriva una clave compartida usando HKDF"""
+    shared_key = clave_privada.exchange(ec.ECDH(), clave_publica)
+    derived_key = HKDF(
+        algorithm=hashes.SHA256(),
+        length=32,
+        salt=None,
+        info=b'guardianclave'
+    ).derive(shared_key)
+    return derived_key

GuardianUnivalle_Benito_Yucra/criptografia/kdf.py

@@ -0,0 +1,23 @@
+"""
+Wrappers para derivación de claves segura: PBKDF2 y Argon2
+"""
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from argon2 import PasswordHasher
+from cryptography.hazmat.primitives import hashes
+import os
+
+def pbkdf2_derivar_clave(password: str, salt: bytes = None) -> bytes:
+    """Deriva clave usando PBKDF2"""
+    salt = salt or os.urandom(16)
+    kdf = PBKDF2HMAC(
+        algorithm=hashes.SHA256(),
+        length=32,
+        salt=salt,
+        iterations=100_000,
+    )
+    return kdf.derive(password.encode()), salt
+
+def argon2_derivar_clave(password: str) -> str:
+    """Deriva clave usando Argon2"""
+    ph = PasswordHasher()
+    return ph.hash(password)

GuardianUnivalle_Benito_Yucra/detectores/detector_csrf.py

@@ -0,0 +1,21 @@
+import secrets
+from ..auditoria.registro_auditoria import registrar_evento
+
+def generar_token_csrf() -> str:
+    return secrets.token_hex(32)
+
+def validar_token_csrf(token: str, token_sesion: str) -> bool:
+    valido = token == token_sesion
+    if not valido:
+        registrar_evento("CSRF", "Intento de CSRF detectado")
+    return valido
+
+""" 
+Algoritmos relacionados:
+    *Uso de secreto aleatorio criptográfico.
+    *Opcionalmente derivación con PBKDF2 / Argon2 para reforzar token.
+Contribución a fórmula de amenaza S:
+S_csrf = w_csrf * intentos_csrf
+S_csrf = 0.2 * 1
+donde w_csrf es peso asignado a CSRF y intentos_csrf es la cantidad de intentos detectados.
+"""

GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py

@@ -0,0 +1,17 @@
+from ..mitigacion.limitador_peticion import limitar_peticion
+from ..auditoria.registro_auditoria import registrar_evento
+
+def detectar_dos(tasa_peticion: int, limite: int = 100) -> bool:
+    if tasa_peticion > limite:
+        registrar_evento("DoS", f"Tasa de petición elevada: {tasa_peticion}")
+        return True
+    return False
+""" 
+Algoritmos relacionados:
+    *Rate Limiting, listas de bloqueo.
+    *Opcional: cifrado de logs con ChaCha20-Poly1305.
+Contribución a fórmula de amenaza S:
+S_dos = w_dos * (tasa_peticion / limite)
+S_dos = 0.6 * (150 / 100)
+donde w_dos es peso asignado a DoS y tasa_peticion / limite es la proporción de la tasa actual sobre el límite.
+"""

GuardianUnivalle_Benito_Yucra/detectores/detector_keylogger.py

@@ -0,0 +1,21 @@
+import psutil
+from ..auditoria.registro_auditoria import registrar_evento
+
+def detectar_keylogger():
+    sospechosos = []
+    for proc in psutil.process_iter(['pid', 'name']):
+        if "keylogger" in proc.info['name'].lower():
+            sospechosos.append(proc.info)
+            registrar_evento("Keylogger", f"Proceso sospechoso: {proc.info}")
+    return sospechosos
+
+
+""" 
+Algoritmos relacionados:
+    *Guardar registros con AES-256 + hash SHA-512 para integridad.
+Contribución a fórmula de amenaza S:
+S_keylogger = w_keylogger * numero_procesos_sospechosos
+S_keylogger = 0.4 * 2
+donde w_keylogger es peso asignado a keyloggers y numero_procesos_sospechosos es la cantidad de procesos detectados.
+
+"""

GuardianUnivalle_Benito_Yucra/detectores/detector_sql.py

@@ -0,0 +1,192 @@
+# middleware_sql_defense.py
+import re
+import json
+import time
+from typing import Tuple
+from django.conf import settings
+from django.http import JsonResponse
+from django.utils.deprecation import MiddlewareMixin
+import redis
+
+# ---------- CONFIGURABLES (poner en settings.py preferiblemente) ----------
+W_SQL = getattr(settings, "SQL_DEFENSE_W_SQL", 1.0)
+THRESHOLD = getattr(settings, "SQL_DEFENSE_THRESHOLD", 0.8)  # score normalizado 0..1
+WINDOW_SEC = getattr(
+    settings, "SQL_DEFENSE_WINDOW_SEC", 300
+)  # ventana para conteo (ej. 5min)
+MAX_EXPECTED_DETECTIONS = getattr(settings, "SQL_DEFENSE_MAX_EXPECTED_DETECTIONS", 10)
+BLOCK_TTL = getattr(
+    settings, "SQL_DEFENSE_BLOCK_TTL", 600
+)  # bloqueo por IP en segundos (ej. 10min)
+
+REDIS_URL = getattr(settings, "SQL_DEFENSE_REDIS_URL", "redis://localhost:6379/0")
+redis_client = redis.from_url(REDIS_URL, decode_responses=True)
+
+# ---------- Patrones y normalización ----------
+_literal_single = re.compile(r"'([^'\\]|\\.)*'")
+_literal_double = re.compile(r'"([^"\\]|\\.)*"')
+_comment_sql = re.compile(r"(--[^\n]*|/\*.*?\*/)", re.S)
+
+PATTERNS = [
+    (re.compile(r"\bunion\b\s+(all\s+)?\bselect\b", re.I), 0.95),
+    (re.compile(r"(?<!\w)or(?=\s+1=1)", re.I), 0.99),
+    (re.compile(r"\b(select\b.*\bfrom\b.*\bwhere\b.*\b(or|and)\b.*=)", re.I), 0.7),
+    (re.compile(r"\b(drop|truncate|delete|insert|update)\b", re.I), 0.8),
+    (re.compile(r"(--|#|;)", re.I), 0.4),
+]
+
+
+# ---------- Helpers ----------
+def get_client_ip(request) -> str:
+    """Obtiene la IP real (si hay proxies, usa X-Forwarded-For)"""
+    xff = request.META.get("HTTP_X_FORWARDED_FOR")
+    if xff:
+        # X-Forwarded-For puede contener lista de IPs
+        ip = xff.split(",")[0].strip()
+        return ip
+    return request.META.get("REMOTE_ADDR", "")
+
+
+def normalize_text(s: str) -> str:
+    """Quita literales y comentarios para reducir falsos positivos"""
+    if not s:
+        return ""
+    s = _comment_sql.sub(" ", s)
+    s = _literal_single.sub("''", s)
+    s = _literal_double.sub('""', s)
+    s = re.sub(r"\s+", " ", s).strip()
+    return s
+
+
+def extract_payload_text(request) -> str:
+    """
+    Extrae texto potencialmente peligroso del request:
+    - query string
+    - body (JSON o form)
+    - headers sospechosos (User-Agent, Referer)
+    """
+    parts = []
+    try:
+        # query params
+        if request.META.get("QUERY_STRING"):
+            parts.append(request.META.get("QUERY_STRING"))
+        # body: intenta json, si no, raw text
+        content_type = request.META.get("CONTENT_TYPE", "")
+        if "application/json" in content_type:
+            try:
+                body_json = json.loads(request.body.decode("utf-8") or "{}")
+                parts.append(json.dumps(body_json))
+            except Exception:
+                parts.append((request.body or b"").decode("utf-8", errors="ignore"))
+        else:
+            # form-encoded or other text
+            try:
+                parts.append(request.body.decode("utf-8", errors="ignore"))
+            except Exception:
+                pass
+        # headers
+        parts.append(request.META.get("HTTP_USER_AGENT", ""))
+        parts.append(request.META.get("HTTP_REFERER", ""))
+    except Exception:
+        pass
+    return " ".join([p for p in parts if p])
+
+
+def detect_sqli_text(text: str) -> Tuple[bool, list]:
+    """Detecta patrones en un texto normalizado; devuelve matches con severidad."""
+    q = normalize_text(text)
+    matches = []
+    for patt, sev in PATTERNS:
+        if patt.search(q):
+            matches.append((patt.pattern, float(sev)))
+    return (len(matches) > 0, matches)
+
+
+# ---------- Redis keys ----------
+def redis_count_key(ip: str) -> str:
+    return f"sqli:count:{ip}"
+
+
+def redis_block_key(ip: str) -> str:
+    return f"sqli:block:{ip}"
+
+
+# ---------- Cálculo de score S_sql/ip ----------
+def compute_s_sql_ip(detections_count: int) -> float:
+    """
+    Convertir conteo a una puntuación normalizada 0..1.
+    Usamos saturación en MAX_EXPECTED_DETECTIONS.
+    """
+    norm = min(float(detections_count) / float(MAX_EXPECTED_DETECTIONS), 1.0)
+    score = float(W_SQL) * norm
+    # Normalizamos a 0..1 si W_SQL puede ser mayor que 1
+    return min(score, 1.0)
+
+
+# ---------- Middleware ----------
+class SQLIDefenseMiddleware(MiddlewareMixin):
+    def process_request(self, request):
+        # 1) obtener IP y comprobar si está bloqueada
+        ip = get_client_ip(request)
+        if not ip:
+            return None  # no podemos hacer mucho sin IP
+
+        # comprobar bloqueo en Redis
+        block_key = redis_block_key(ip)
+        if redis_client.exists(block_key):
+            ttl = redis_client.ttl(block_key)
+            return JsonResponse(
+                {
+                    "detail": "Acceso denegado (bloqueado por actividad sospechosa)",
+                    "block_ttl_s": ttl,
+                },
+                status=403,
+            )
+
+        # 2) extraer texto y detectar patrones
+        text = extract_payload_text(request)
+        if not text:
+            return None
+
+        flagged, matches = detect_sqli_text(text)
+        if flagged:
+            # incrementar contador con TTL (ventana)
+            count_key = redis_count_key(ip)
+            # INCR y asegurar expiration
+            new_count = redis_client.incr(count_key)
+            # establecer TTL si fue creado de nuevo
+            if redis_client.ttl(count_key) == -1:
+                redis_client.expire(count_key, WINDOW_SEC)
+
+            # calcular score
+            current_count = int(new_count)
+            s_sql_ip = compute_s_sql_ip(current_count)
+
+            # registrar evento (puedes ampliar con logging o envío a SIEM)
+            # guardamos metadata mínima
+            event = {
+                "time": int(time.time()),
+                "ip": ip,
+                "count": current_count,
+                "score": s_sql_ip,
+                "matches": matches,
+            }
+            # Puedes push a lista en Redis o a un logger
+            redis_client.lpush("sqli:events", json.dumps(event))
+            redis_client.ltrim("sqli:events", 0, 999)  # mantener últimos 1000 eventos
+
+            # Si supera THRESHOLD -> bloquear ip
+            if s_sql_ip >= float(THRESHOLD):
+                redis_client.set(redis_block_key(ip), "1", ex=BLOCK_TTL)
+                # opcional: publicar alerta en canal pubsub o webhook
+                return JsonResponse(
+                    {"detail": "IP bloqueada por actividad sospechosa", "ip": ip},
+                    status=403,
+                )
+            else:
+                # no bloqueo todavía: permitir continuar pero devolver alerta en header (opcional)
+                # Puedes añadir header para que la vista/log lo capture
+                request.META["X-SQLI-ALERT"] = json.dumps(event)
+                return None
+
+        return None

GuardianUnivalle_Benito_Yucra/detectores/detector_xss.py

@@ -0,0 +1,21 @@
+import html
+from ..auditoria.registro_auditoria import registrar_evento
+
+def sanitizar_xss(entrada: str) -> str:
+    return html.escape(entrada)
+
+def detectar_xss(entrada: str) -> bool:
+    patrones = ["<script", "javascript:", "onerror", "onload"]
+    if any(p in entrada.lower() for p in patrones):
+        registrar_evento("XSS", f"Ataque detectado: {entrada}")
+        return True
+    return False
+""" 
+Algoritmos relacionados:
+    *Guardar entradas sospechosas con AES-GCM para confidencialidad y autenticidad.
+Contribución a fórmula de amenaza S:
+S_xss = w_xss * detecciones_xss
+S_xss = 0.3 * 2
+donde w_xss es peso asignado a XSS y detecciones_xss es la cantidad de patrones detectados.
+
+"""

GuardianUnivalle_Benito_Yucra/middleware_web/middleware_web.py

@@ -0,0 +1,13 @@
+"""
+Middleware base para frameworks web (Django/Flask/FastAPI)
+"""
+from ..detectores.detector_sql import detectar_inyeccion_sql
+from ..detectores.detector_xss import detectar_xss
+
+def middleware_proteccion(request):
+    # Simulación de protección de entrada
+    if detectar_inyeccion_sql(request.get("query", "")):
+        return {"error": "SQL Injection detectado"}
+    if detectar_xss(request.get("input", "")):
+        return {"error": "XSS detectado"}
+    return {"ok": True}

GuardianUnivalle_Benito_Yucra/mitigacion/limitador_peticion.py

@@ -0,0 +1,7 @@
+"""
+Limitador de peticiones para prevenir DoS
+"""
+def limitar_peticion(usuario_id: str, max_peticion: int = 100) -> bool:
+    # Simulación de limitador: True si excede
+    print(f"✅ Limitador activo para {usuario_id}")
+    return False

GuardianUnivalle_Benito_Yucra/mitigacion/lista_bloqueo.py

@@ -0,0 +1,10 @@
+"""
+Manejo de lista de bloqueo
+"""
+lista_bloqueo = set()
+
+def agregar_bloqueo(ip: str):
+    lista_bloqueo.add(ip)
+
+def esta_bloqueado(ip: str) -> bool:
+    return ip in lista_bloqueo

GuardianUnivalle_Benito_Yucra/puntuacion/puntuacion_amenaza.py

@@ -0,0 +1,15 @@
+"""
+Fórmula compuesta S para puntuar la amenaza global
+"""
+def calcular_puntuacion(detecciones_sql=0, detecciones_xss=0, intentos_csrf=0,
+                        procesos_keylogger=0, tasa_dos=0,
+                        w_sql=1.5, w_xss=1.2, w_csrf=1.0, w_keylogger=2.0, w_dos=2.5,
+                        limite_dos=100) -> float:
+    S = (
+        w_sql * detecciones_sql +
+        w_xss * detecciones_xss +
+        w_csrf * intentos_csrf +
+        w_keylogger * procesos_keylogger +
+        w_dos * (tasa_dos / limite_dos)
+    )
+    return S

GuardianUnivalle_Benito_Yucra/utilidades.py

@@ -0,0 +1,7 @@
+"""
+Funciones auxiliares generales
+"""
+import os
+
+def generar_id_unico() -> str:
+    return os.urandom(16).hex()

guardianunivalle_benito_yucra-0.1.1.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: GuardianUnivalle-Benito-Yucra
+Version: 0.1.1
+Summary: Librería de seguridad automática para aplicaciones frontend y backend
+Author-email: Andres Benito Calle Yucra <benitoandrescalle035@gmail.com>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<!-- Información de la librería -->
+
+🔐 Algoritmos de cifrado simétrico
+AES (Rijndael) → AES-128, AES-192, AES-256
+RC6
+ChaCha20
+
+🔀 Modos de operación de cifrado simétrico
+CTR (Counter Mode)
+CFB (Cipher Feedback Mode)
+OFB (Output Feedback Mode)
+CCM (Counter with CBC-MAC)
+EAX
+GCM (Galois/Counter Mode)
+XTS
+
+🔑 Algoritmos de cifrado asimétrico
+RSA (Rivest–Shamir–Adleman)
+ECC (Elliptic Curve Cryptography)
+🧮 Algoritmos relacionados con factorización y logaritmos
+CGCN (Criba General del Cuerpo de Números / General Number Field Sieve, GNFS)
+Algoritmo de Shor (para computación cuántica)
+Multiplicación por tentativa (método básico de exponenciación para logaritmos discretos)
+
+🔑 Funciones de derivación de claves (KDF)
+PBKDF2
+scrypt
+Argon2
+
+📝 Funciones hash
+Serie MD: MD2, MD4, MD5, MD6
+SHA (Secure Hash Algorithm): SHA-0, SHA-1, SHA-2 (SHA-224, SHA-256, SHA-384, SHA-512)
+
+

guardianunivalle_benito_yucra-0.1.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+GuardianUnivalle_Benito_Yucra/__init__.py,sha256=lbIRb8fCFYfAdyJV6NsYVZJ5pKYSJZKhhK-En9g_1M8,762
+GuardianUnivalle_Benito_Yucra/utilidades.py,sha256=lFNVnlyTSYmQ1CqtmHx6aefK5uNw0wsMdHRQyxAIZy0,120
+GuardianUnivalle_Benito_Yucra/auditoria/registro_auditoria.py,sha256=YxEtF6ZJj8MXhZ_kWPn9ijmXyJzpbu3UQDD3_BdOSqs,334
+GuardianUnivalle_Benito_Yucra/criptografia/cifrado_aead.py,sha256=wfoRpaKvOqPbollNQsDNUNWClYJlXYTKTYvv0qcR6aI,962
+GuardianUnivalle_Benito_Yucra/criptografia/intercambio_claves.py,sha256=9djnlzb022hUhrDbQyWz7lWLbkn_vQZ4K7qar1FXYmo,829
+GuardianUnivalle_Benito_Yucra/criptografia/kdf.py,sha256=_sbepEY1qHEKga0ExrX2WRg1HeCPY5MC5CfXZWYyl-A,709
+GuardianUnivalle_Benito_Yucra/detectores/detector_csrf.py,sha256=EAYfLkHuxGC5rXSu4mZJ4yZDCbwBpTX8xZWGKz7i5wA,692
+GuardianUnivalle_Benito_Yucra/detectores/detector_dos.py,sha256=lMWmCw6nccCEnek53nVjpoBCeiBqLdrSXxqRuI7VP2I,696
+GuardianUnivalle_Benito_Yucra/detectores/detector_keylogger.py,sha256=rEDG-Q_R56OsG2ypfHVBK7erolYjdvATnAxB3yvPXts,729
+GuardianUnivalle_Benito_Yucra/detectores/detector_sql.py,sha256=F1GItlntAQT0MqxiAnrQItS-Jc_t--LYfdSz9wo3ZMc,7039
+GuardianUnivalle_Benito_Yucra/detectores/detector_xss.py,sha256=66V_xuxNOZEwluvWOT4-6pk5MJ3zWE1IwcVkBl7MZSg,719
+GuardianUnivalle_Benito_Yucra/middleware_web/middleware_web.py,sha256=23pLLYqliUoMrIC6ZEwz3hKXeDjWfHSm9vYPWGmDDik,495
+GuardianUnivalle_Benito_Yucra/mitigacion/limitador_peticion.py,sha256=ipMOebYhql-6mSyHs0ddYXOcXq9w8P_IXLlpiIqGncw,246
+GuardianUnivalle_Benito_Yucra/mitigacion/lista_bloqueo.py,sha256=6AYWII4mrmwCLHCvGTyoBxR4Oasr4raSHpFbVjqn7d8,193
+GuardianUnivalle_Benito_Yucra/puntuacion/puntuacion_amenaza.py,sha256=Wx5XfcII4oweLvZsTBEJ7kUc9pMpP5-36RfI5C5KJXo,561
+guardianunivalle_benito_yucra-0.1.1.dist-info/licenses/LICENSE,sha256=5e4IdL542v1E8Ft0A24GZjrxZeTsVK7XrS3mZEUhPtM,37
+guardianunivalle_benito_yucra-0.1.1.dist-info/METADATA,sha256=qctbyoDFKu13d6hwyGuavjeQg_6Z83vvrEKfXr0lfOk,1303
+guardianunivalle_benito_yucra-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+guardianunivalle_benito_yucra-0.1.1.dist-info/top_level.txt,sha256=HTWfZM64WAV_QYr5cnXnLuabQt92dvlxqlR3pCwpbDQ,30
+guardianunivalle_benito_yucra-0.1.1.dist-info/RECORD,,

GuardianUnivalle_Benito_Yucra/dos_protection.py

@@ -1,6 +0,0 @@
-""" Protección DoS """
-# GuardianUnivalle_Benito_Yucra/dos_protection.py
-
-def rate_limiter():
-    """Simulación de limitador de peticiones"""
-    print("✅ Rate limiter activo")

GuardianUnivalle_Benito_Yucra/encryption.py

@@ -1,10 +0,0 @@
-""" Funciones de cifrado """
-# GuardianUnivalle_Benito_Yucra/encryption.py
-
-def encrypt_data(data: str) -> str:
-    """Simulación de cifrado sencillo"""
-    return "".join(chr(ord(c)+3) for c in data)
-
-def decrypt_data(data: str) -> str:
-    """Simulación de descifrado sencillo"""
-    return "".join(chr(ord(c)-3) for c in data)

GuardianUnivalle_Benito_Yucra/malware_check.py

@@ -1,6 +0,0 @@
-""" Escaneo de apps maliciosas """
-# GuardianUnivalle_Benito_Yucra/malware_check.py
-
-def scan_malware():
-    """Simulación de escaneo de malware"""
-    print("✅ Escaneo de malware completado")

GuardianUnivalle_Benito_Yucra/utils.py

@@ -1 +0,0 @@
-""" Funciones auxiliares """

GuardianUnivalle_Benito_Yucra/web_protection.py

@@ -1,9 +0,0 @@
-# GuardianUnivalle_Benito_Yucra/web_protection.py
-
-def sanitize_input(user_input: str) -> str:
-    """Elimina caracteres peligrosos (simulación)"""
-    return user_input.replace("<", "&lt;").replace(">", "&gt;")
-
-def check_csrf():
-    """Simulación de protección CSRF"""
-    print("✅ CSRF check passed")

guardianunivalle_benito_yucra-0.1.0.dist-info/METADATA

@@ -1,12 +0,0 @@
-Metadata-Version: 2.4
-Name: GuardianUnivalle-Benito-Yucra
-Version: 0.1.0
-Summary: Librería de seguridad automática para aplicaciones frontend y backend
-Author-email: Benito Yucra <tu_email@dominio.com>
-License: MIT
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-<!-- Información de la librería -->

guardianunivalle_benito_yucra-0.1.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-GuardianUnivalle_Benito_Yucra/__init__.py,sha256=oy-mVZKVEud0LQL5QMoKh7ts9XrWYbiZtlCcpiOXBTk,606
-GuardianUnivalle_Benito_Yucra/dos_protection.py,sha256=JAY2D8LGOBKshyYWwKabB7p5HfaQi-zolwWpDURu93g,187
-GuardianUnivalle_Benito_Yucra/encryption.py,sha256=1pSEDwp5bTe9lol7MJmObRMr_fLZ83PFv9kQ7-Pk6lM,342
-GuardianUnivalle_Benito_Yucra/malware_check.py,sha256=lnUdx3hkLmQ4ZUgkqrqcP2dAELi0xGgQCIn-SZvQ8KE,202
-GuardianUnivalle_Benito_Yucra/utils.py,sha256=7mriluJY8ygJR-j0xyhqrp8BUzu96c1mY75XGtKMzho,28
-GuardianUnivalle_Benito_Yucra/web_protection.py,sha256=M-GyIkTNowhJwhXzZX7embU4BoJxOsHViSLGSJTT-ko,318
-guardianunivalle_benito_yucra-0.1.0.dist-info/licenses/LICENSE,sha256=5e4IdL542v1E8Ft0A24GZjrxZeTsVK7XrS3mZEUhPtM,37
-guardianunivalle_benito_yucra-0.1.0.dist-info/METADATA,sha256=vYtJs612u-DUDWDIHAWrHwr-MWVoFTI3iqlTvXL_fFA,375
-guardianunivalle_benito_yucra-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-guardianunivalle_benito_yucra-0.1.0.dist-info/top_level.txt,sha256=HTWfZM64WAV_QYr5cnXnLuabQt92dvlxqlR3pCwpbDQ,30
-guardianunivalle_benito_yucra-0.1.0.dist-info/RECORD,,