wafaHell 0.2.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

wafaHell/model.py

@@ -1,23 +1,100 @@
 from datetime import datetime
-from sqlalchemy import create_engine, Column, Integer, String
+from sqlalchemy import (
+    DateTime, Text, create_engine,
+    Column, Integer, String, UniqueConstraint
+)
 from sqlalchemy.orm import declarative_base, sessionmaker, scoped_session
 
+# =========================
+# CONFIGURAÇÃO GLOBAL
+# =========================
+
+DATABASE_URL = "sqlite:///wafaHell.db"
+
+engine = create_engine(
+    DATABASE_URL,
+    echo=False,
+    future=True
+)
+
+SessionLocal = scoped_session(
+    sessionmaker(
+        bind=engine,
+        autocommit=False,
+        autoflush=False
+    )
+)
+
 Base = declarative_base()
 
+# =========================
+# MODELS
+# =========================
+
 class Blocked(Base):
     __tablename__ = "blocks"
     
     id = Column(Integer, primary_key=True, autoincrement=True)
     ip = Column(String, nullable=True)
     user_agent = Column(String, nullable=True)
-    blocked_at = Column(String, nullable=False, default=lambda: datetime.now().strftime("%H:%M:%S"))
+    blocked_at = Column(
+        String,
+        nullable=False,
+        default=lambda: datetime.now().strftime("%H:%M:%S")
+    )
+    blocked_until = Column(DateTime, nullable=False)
 
     def __repr__(self):
-        return f"<Blocked(ip='{self.ip}', user_agent='{self.user_agent}', blocked_at='{self.blocked_at}')>"
-
-def get_session(db_url="sqlite:///wafaHell.db"):
-    engine = create_engine(db_url, echo=False)
-    Base.metadata.create_all(engine)
-    session_factory = sessionmaker(bind=engine)
-    Session = scoped_session(session_factory)
-    return Session
+        return (
+            f"<Blocked(ip='{self.ip}', "
+            f"user_agent='{self.user_agent}', "
+            f"blocked_at='{self.blocked_at}', "
+            f"blocked_until='{self.blocked_until}')>"
+        )
+
+
+class WafLog(Base):
+    __tablename__ = "waf_logs"
+
+    id = Column(Integer, primary_key=True)
+    timestamp = Column(DateTime, default=datetime.utcnow)
+    
+    time_bucket = Column(String(20), index=True) 
+    
+    attack_type = Column(String(50))
+    ip = Column(String(50))
+    path = Column(String(200))
+    method = Column(String(10))
+    payload = Column(Text)
+    attack_local = Column(String(50))
+    level = Column(String(20))
+
+    __table_args__ = (
+        UniqueConstraint('ip', 'attack_type', 'time_bucket', name='uix_ip_attack_time'),
+    )
+
+
+class AdminUser(Base):
+    __tablename__ = "admin_user"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    login = Column(String(50), nullable=False, unique=True)
+    password = Column(String(255), nullable=False)
+
+    def __repr__(self):
+        return f"<AdminUser(login='{self.login}')>"
+
+
+# =========================
+# DB INIT / SESSION
+# =========================
+
+def init_db():
+    """Cria as tabelas uma única vez"""
+    Base.metadata.create_all(bind=engine)
+
+
+def get_session():
+    """Retorna uma sessão reutilizável"""
+    return SessionLocal()
+

wafaHell/panel.py

@@ -0,0 +1,192 @@
+from datetime import datetime, timedelta, timezone
+from flask import render_template_string, request, jsonify, make_response, flash, session, redirect, render_template
+from model import AdminUser, WafLog, get_session, Blocked
+from sqlalchemy import func
+import csv
+import io
+from utils import Admin, Dashboard, admin
+from werkzeug.security import check_password_hash
+dashboard = Dashboard()
+
+def get_logs_and_stats(ip_filter=None, type_filter=None, limit=100):
+    session = get_session()
+    try:
+        log_query = session.query(WafLog).order_by(WafLog.id.desc())
+        stat_query = session.query(func.count(WafLog.id))
+
+        if ip_filter:
+            log_query = log_query.filter(WafLog.ip == ip_filter)
+            stat_query = stat_query.filter(WafLog.ip == ip_filter)
+        if type_filter:
+            log_query = log_query.filter(WafLog.attack_type == type_filter)
+            stat_query = stat_query.filter(WafLog.attack_type == type_filter)
+
+        db_logs = log_query.limit(limit).all()
+        
+        # Estatísticas Dinâmicas
+        stats = {
+            "total": stat_query.scalar() or 0,
+            # Agora attacks conta tudo que não é 'Info' ou 'System'
+            "attacks": stat_query.filter(WafLog.attack_type.in_(['SQLI', 'XSS', 'RATE LIMIT'])).scalar() or 0,
+            "sqli": stat_query.filter(WafLog.attack_type == 'SQLI').scalar() or 0,
+            "xss": stat_query.filter(WafLog.attack_type == 'XSS').scalar() or 0,
+            "rate_limit": stat_query.filter(WafLog.attack_type == 'RATE LIMIT').scalar() or 0,
+            "blocks": stat_query.filter(WafLog.attack_type == 'IP BLOCK').scalar() or 0
+            }
+
+        formatted_logs = []
+        for log in db_logs:
+            # Determinamos o "Tipo" visual para o HTML
+            display_type = "INFO"
+            if log.attack_type in ['SQLI', 'XSS', 'RATE LIMIT']:
+                display_type = "ATTACK"
+            elif log.attack_type == 'IP BLOCK':
+                display_type = "BLOCKED" # Mudança aqui para o dashboard
+
+            formatted_logs.append({
+                "timestamp": log.timestamp.strftime("%H:%M:%S - %d/%m/%Y"),
+                "type": display_type,
+                "details": {
+                    "attack_type": log.attack_type,
+                    "ip": log.ip or "---",
+                    "path": log.path or "---",
+                    "method": log.method or "---",
+                    "payload": log.payload or "---",
+                    "attack_local": log.attack_local or "---"
+                }
+            })
+        return formatted_logs, stats
+    finally:
+        session.close()
+
+def setup_dashboard(app, custom_path=None):
+    target_path = custom_path or '/admin/dashboard'
+
+    @app.route(target_path + "/login", methods=["GET", "POST"])
+    def login():
+        if request.method == "POST":
+            username = request.form.get("user")
+            password = request.form.get("password")
+            db = get_session()
+            try:
+                admin = db.query(AdminUser).filter(AdminUser.login == username).first()
+
+                # 3. Valida (Aqui você deveria usar hash, mas vamos focar na lógica)
+                if admin and check_password_hash(admin.password, password):
+                    session["logged_in"] = True
+                    next_page = request.args.get("next", target_path)
+                    return redirect(next_page)
+                else:
+                    flash("Acesso Negado: Credenciais Inválidas", "error")
+                    return redirect(request.url)
+            finally:
+                db.close()
+
+        return render_template("login.html")
+    
+    @app.route(target_path + '/data')
+    @admin
+    def wafahell_data():
+        ip_f = request.args.get('ip')
+        type_f = request.args.get('type')
+        logs, stats = get_logs_and_stats(ip_filter=ip_f, type_filter=type_f)
+        return jsonify({"logs": logs, "stats": stats})
+
+    # Rota 2: Retorna o HTML inicial
+    @app.route(target_path)
+    @admin
+    def wafahell_dashboard():
+        ip_f = request.args.get('ip')
+        type_f = request.args.get('type')
+        logs, stats = get_logs_and_stats(ip_filter=ip_f, type_filter=type_f)
+        return render_template('dashboard.html', logs=logs, stats=stats, filters={'ip': ip_f, 'type': type_f})
+    
+    @app.route(target_path + '/export/csv')
+    @admin
+    def export_csv():
+
+        ip_filter = request.args.get('ip')
+        type_filter = request.args.get('type')
+        
+        session = get_session()
+        query = session.query(WafLog)
+        
+        if ip_filter:
+            query = query.filter(WafLog.ip == ip_filter)
+        if type_filter:
+            query = query.filter(WafLog.attack_type == type_filter)
+            
+        logs = query.order_by(WafLog.timestamp.desc()).all()
+        session.close()
+
+        # Criamos o CSV em memória
+        output = io.StringIO()
+        writer = csv.writer(output)
+        
+        # Cabeçalho
+        writer.writerow(['Data/Hora', 'Tipo', 'IP', 'Endpoint', 'Metodo', 'Payload'])
+        
+        for log in logs:
+            writer.writerow([
+                log.timestamp,
+                log.attack_type,
+                log.ip,
+                log.path,
+                log.method,
+                log.payload
+            ])
+
+        response = make_response(output.getvalue())
+        response.headers["Content-Disposition"] = f"attachment; filename=waf_logs_{datetime.now().strftime('%Y%m%d_%H%M')}.csv"
+        response.headers["Content-type"] = "text/csv"
+        return response
+
+    @app.route(target_path + '/block_ip', methods=['POST'])
+    @admin
+    def block_ip() -> bool:
+        data = request.get_json()
+        ip = data.get('ip')
+        block_time = data.get('block_time_minutes', 5) # Pega do JSON ou assume 5
+
+        if not ip:
+            return jsonify({"status": "error", "message": "IP ausente"}), 400
+
+        session = get_session()
+
+        try:
+            exists = session.query(Blocked).filter_by(ip=ip, user_agent="MANUAL_BLOCK").first()
+            if exists:
+                exists.blocked_until = datetime.now(timezone.utc) + timedelta(minutes=int(block_time))
+                session.commit()
+                return jsonify({"status": "success", "message": "Tempo de bloqueio atualizado"})
+
+            now = datetime.now(timezone.utc)
+            until = now + timedelta(minutes=int(block_time))
+
+            new_block = Blocked(
+                ip=ip,
+                user_agent="MANUAL_BLOCK",
+                blocked_until=until
+            )
+            
+            session.add(new_block)
+            session.commit()
+            return jsonify({"status": "success", "message": "IP bloqueado com sucesso"})
+        except Exception as e:
+            session.rollback()
+            return jsonify({"status": "error", "message": str(e)}), 500
+        finally:
+            session.close()
+
+    @app.route(target_path + '/graphs', methods=['GET'])
+    @admin
+    def graphs():
+        return render_template('graphs.html')
+    
+    @app.route(target_path + '/stats', methods=['GET'])
+    @admin
+    def api_stats():
+        return jsonify(dashboard.dashboard_setup())
+
+    print(f" * [WafaHell] Dashboard e API de dados prontos em: {target_path}")
+

wafaHell/rateLimiter.py

@@ -17,5 +17,4 @@ class RateLimiter:
             self.requests_log[key].popleft()
 
         self.requests_log[key].append(now)
-
         return len(self.requests_log[key]) >= self.limit

wafaHell/utils.py

@@ -1,10 +1,312 @@
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
+import secrets
+import string
+import time
+from werkzeug.security import generate_password_hash
+from sqlalchemy.orm import Session
+from sqlalchemy import text, func, case
+from model import WafLog, Blocked
+from model import AdminUser
+from functools import wraps
+from flask import session, redirect, url_for, request
+from model import get_session
+from globals import waf_cache
+import geoip2.database
+import os
 
-def is_block_expired(blocked_time_str: str) -> bool:
-    blocked_time = datetime.strptime(blocked_time_str, "%H:%M:%S")
-    now = datetime.now()
-    blocked_time = blocked_time.replace(year=now.year, month=now.month, day=now.day)
+class Admin:
+    @staticmethod
+    def generate_secure_password(length=64):
+        alphabet = string.ascii_letters + string.digits + string.punctuation
+        return ''.join(secrets.choice(alphabet) for _ in range(length))
 
-    diff = now - blocked_time
-    return diff >= timedelta(minutes=1)
+    @staticmethod
+    def create_admin_user(session: Session):
+        admin = session.query(AdminUser).filter_by(login="admin").first()
+        if admin:
+            return
+        raw_password = "admin" #Admin.generate_secure_password(64)
+        hashed_password = generate_password_hash(raw_password)
 
+        admin = AdminUser(
+            login="admin",
+            password=hashed_password
+        )
+
+        session.add(admin)
+        session.commit()
+
+        print("* [WafaHell] Usuario admin criado com sucesso.")
+        print("* [WafaHell] Salve essa senha em um lugar seguro, não será mostrada novamente")
+        print("Senha: ", raw_password)
+
+def admin(fn):
+    @wraps(fn)
+    def wrapper(*args, **kwargs):
+        print(f"DEBUG: Session logged_in status: {session.get('logged_in')}") # Adicione isso
+        if not session.get("logged_in"):
+            print("DEBUG: Redirecting to login...")
+            return redirect(url_for("login", next=request.path))
+        return fn(*args, **kwargs)
+    return wrapper
+
+class Dashboard:
+    def __init__(self):
+        self.db_session = get_session()
+        self.geo_db_path = os.path.join(os.path.dirname(__file__), 'GeoLite2-Country.mmdb')
+        
+    def dashboard_setup(self):
+        json = {}
+        def get_server_info():
+            server_time = datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z')
+            node_id = "WAF-01"
+            avg_latency = waf_cache.get('latency_avg', default=0.0)
+            system_status = "critical" if avg_latency > 500 else "degraded" if avg_latency > 200 else "healthy"
+            return {
+                "server_time": server_time,
+                "node_id": node_id,
+                "average_latency_ms": round(float(avg_latency), 2),
+                "system_status": system_status
+            }
+        
+        def get_kpis():
+            now = datetime.now(timezone.utc)
+            last_24h = now - timedelta(hours=24)
+            prev_24h = now - timedelta(hours=48)
+
+            # --- TOTAIS DE HOJE ---
+            total_today = self.db_session.query(func.count(WafLog.id)).filter(WafLog.timestamp >= last_24h).scalar() or 0
+            blocked_today = self.db_session.query(func.count(WafLog.id)).filter(
+                WafLog.timestamp >= last_24h, 
+                WafLog.attack_type != 'INFO'
+            ).scalar() or 0
+
+            # --- TOTAIS DE ONTEM (Para Tendência) ---
+            total_yesterday = self.db_session.query(func.count(WafLog.id)).filter(
+                WafLog.timestamp >= prev_24h, 
+                WafLog.timestamp < last_24h
+            ).scalar() or 0
+            
+            blocked_yesterday = self.db_session.query(func.count(WafLog.id)).filter(
+                WafLog.timestamp >= prev_24h, 
+                WafLog.timestamp < last_24h,
+                WafLog.attack_type != 'INFO'
+            ).scalar() or 0
+
+            # --- CÁLCULO DE TENDÊNCIA (%) ---
+            def calc_trend(current, previous):
+                if previous == 0:
+                    return 100.0 if current > 0 else 0.0
+                return round(((current - previous) / previous * 100), 1)
+
+            trend_total = calc_trend(total_today, total_yesterday)
+            trend_attacks = calc_trend(blocked_today, blocked_yesterday)
+
+            # --- INFOS COMPLEMENTARES ---
+            from globals import waf_cache
+            # Latência e RPS vindos do Cache Global
+            last_second_timestamp = int(time.time()) - 1
+            rps_key = f"rps_{last_second_timestamp}"
+
+            # 2. Lê o valor real do cache para esse segundo específico
+            current_rps = waf_cache.get(rps_key, default=0)
+
+            # 3. Lógica do Pico (Peak)
+            # Aqui continuamos usando uma chave fixa 'rps_peak_hour' para guardar o recorde
+            peak_rps = waf_cache.get('rps_peak_hour', default=0)
+
+            if current_rps > peak_rps:
+                peak_rps = current_rps
+                # Atualiza o recorde no cache por 1 hora
+                waf_cache.set('rps_peak_hour', peak_rps, expire=3600)
+            
+            # Dados da Blacklist
+            total_blacklist = self.db_session.query(func.count(Blocked.id)).scalar() or 0
+            # Como blocked_at é String formatada no seu modelo, comparamos com o horário
+            added_today = self.db_session.query(func.count(Blocked.id)).filter(
+                Blocked.blocked_until >= now # Um IP "adicionado hoje" é tecnicamente um ainda bloqueado
+            ).scalar() or 0
+
+            return {
+                "total_requests_24h": {
+                    "value": total_today,
+                    "trend_percent": trend_total
+                },
+                "attacks_mitigated_24h": {
+                    "value": blocked_today,
+                    "trend_percent": trend_attacks # Adicionado aqui
+                },
+                "throughput": {
+                    "current_req_per_sec": current_rps,
+                    "peak_last_hour": peak_rps
+                },
+                "blacklist_count": {
+                    "total_ips": total_blacklist,
+                    "added_today": added_today
+                }
+            }
+        
+        def get_traffic_chart():
+            now = datetime.now(timezone.utc)
+            start_time = now - timedelta(minutes=40)
+
+            # Query para agrupar por minuto
+            # No SQLite usamos strftime, no Postgres/MySQL seria date_format ou similar
+            query = self.db_session.query(
+                func.strftime('%H:%M', WafLog.timestamp).label('minute'),
+                func.count(WafLog.id).label('total'),
+                func.sum(case({WafLog.attack_type == 'INFO': 1}, else_=0)).label('legit'),
+                func.sum(case({WafLog.attack_type != 'INFO': 1}, else_=0)).label('attacks')
+            ).filter(WafLog.timestamp >= start_time)\
+            .group_by('minute')\
+            .order_by('minute').all()
+
+            labels = []
+            series_legit = []
+            series_attacks = []
+
+            # Preenche os arrays para o gráfico
+            for row in query:
+                labels.append(row.minute)
+                series_legit.append(row.legit or 0)
+                series_attacks.append(row.attacks or 0)
+
+            # Caso não existam dados nos últimos 40 min, retorna arrays vazios para não quebrar o front
+            return {
+                "labels": labels,
+                "series_legit": series_legit,
+                "series_attacks": series_attacks
+            }
+
+        def get_distribution_vectors():
+            now = datetime.now(timezone.utc)
+            last_24h = now - timedelta(hours=24)
+
+            # 1. Buscamos a contagem agrupada por tipo de ataque
+            # Filtramos para não incluir tráfego legítimo (INFO)
+            query = self.db_session.query(
+                WafLog.attack_type,
+                func.count(WafLog.id).label('count')
+            ).filter(
+                WafLog.timestamp >= last_24h,
+                WafLog.attack_type != 'INFO'
+            ).group_by(WafLog.attack_type).all()
+
+            # 2. Calculamos o total de ataques para obter a porcentagem
+            total_attacks = sum(row.count for row in query)
+            
+            distribution = []
+            
+            for row in query:
+                percentage = round((row.count / total_attacks * 100), 1) if total_attacks > 0 else 0
+                distribution.append({
+                    "label": row.attack_type,
+                    "count": row.count,
+                    "percentage": percentage
+                })
+
+            # Caso não haja ataques, retornamos uma lista vazia ou um placeholder
+            return distribution
+
+        def get_top_geo():
+            def resolve_ip(ip):
+                try:         
+                    if not os.path.exists(self.geo_db_path):
+                        print("ERRO: Arquivo GeoLite2-Country.mmdb não encontrado!")
+                        return "XX", "Unknown"
+                        
+                    with geoip2.database.Reader(self.geo_db_path) as reader:
+                        response = reader.country(ip)
+                        return response.country.iso_code, response.country.name
+                except Exception as e:
+                    print(f"Erro na consulta GeoIP: {e}") # Isso vai te dizer se o banco está corrompido ou o IP é inválido
+                    return "XX", "Unknown"
+                
+            now = datetime.now(timezone.utc)
+            last_24h = now - timedelta(hours=24)
+
+            # 1. Busca todos os ataques agrupados por IP
+            query = self.db_session.query(
+                WafLog.ip,
+                func.count(WafLog.id).label('count')
+            ).filter(
+                WafLog.timestamp >= last_24h,
+                WafLog.attack_type != 'INFO'
+            ).group_by(WafLog.ip).all()
+
+            geo_stats = {}
+            total_attacks = 0
+
+            # 2. Processa cada IP real usando o GeoIP2
+            for row in query:
+                code, name = resolve_ip(row.ip)
+                
+                if code not in geo_stats:
+                    geo_stats[code] = {"name": name, "count": 0}
+                
+                geo_stats[code]["count"] += row.count
+                total_attacks += row.count
+
+            # 3. Formata o Top 5
+            top_geo = []
+            sorted_geo = sorted(geo_stats.items(), key=lambda x: x[1]['count'], reverse=True)[:5]
+
+            for code, data in sorted_geo:
+                percentage = round((data["count"] / total_attacks * 100), 1) if total_attacks > 0 else 0
+                top_geo.append({
+                    "country_code": code,
+                    "country_name": data["name"],
+                    "count": data["count"],
+                    "percentage": percentage
+                })
+
+            return top_geo
+        
+        def get_top_offenders():
+            now = datetime.now(timezone.utc)
+            last_24h = now - timedelta(hours=24)
+
+            # 1. Agrupamos por IP e contamos os hits e os tipos de ataques diferentes
+            # Ignoramos tráfego INFO
+            query = self.db_session.query(
+                WafLog.ip,
+                func.count(WafLog.id).label('hits_count'),
+                func.count(func.distinct(WafLog.attack_type)).label('unique_vectors')
+            ).filter(
+                WafLog.timestamp >= last_24h,
+                WafLog.attack_type != 'INFO'
+            ).group_by(WafLog.ip).order_by(text('hits_count DESC')).limit(5).all()
+
+            offenders = []
+            for row in query:
+                # 2. Lógica de Risk Score (0 a 100)
+                # Baseada em volume e diversidade de ataques
+                # Ex: Cada vetor único vale 20 pontos + 1 ponto para cada 50 hits (até o teto de 100)
+                vector_points = row.unique_vectors * 20
+                hit_points = row.hits_count // 50
+                risk_score = min(100, vector_points + hit_points)
+
+                offenders.append({
+                    "ip": row.ip,
+                    "risk_score": int(risk_score),
+                    "hits_count": row.hits_count
+                })
+
+            return offenders
+
+        try:
+            json['meta'] = get_server_info()
+            json['kpis'] = get_kpis()
+            json['traffic_chart'] = get_traffic_chart()
+            json['distribution_vectors'] = get_distribution_vectors()
+            json['top_geo'] = get_top_geo()
+            json['top_offenders'] = get_top_offenders()
+            
+            return json
+
+        except Exception as e:
+            print(f"Erro no Dashboard: {e}")
+            return {"error": str(e)}
+            
+        finally:
+            self.db_session.close()

{wafahell-0.2.0.dist-info → wafahell-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafaHell
-Version: 0.2.0
+Version: 1.0.0
 Summary: Middleware WAF to Flask
 Author-email: Yago Martins <yagomartins30@gmail.com>
 License: MIT License
@@ -33,6 +33,10 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: Flask>=2.0
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: requests
+Requires-Dist: diskcache
+Requires-Dist: geoip2
 Dynamic: license-file
 
 # WafHell

wafahell-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+wafaHell/__init__.py,sha256=bdafr3LRK7_frr-V6umEJZUqt8RMrOiLJy72DSQfs2o,60
+wafaHell/app.py,sha256=mXUCyOVrbU2Cdugh-UIDSQf-6zqvT2aazZtJQp_KKJI,980
+wafaHell/globals.py,sha256=keIe0YCNsb5si0yUhUjd6nlk1s0YgfH5G7lH5-05Zws,160
+wafaHell/logger.py,sha256=keT-Iw6g9w1dtrk0GhldxhgKtmNUVClgFGkSkAWXS5Y,5686
+wafaHell/middleware.py,sha256=cse81wj9ocUV11MPfrmvleD5nYq6asjDx6dqXToIcIs,14348
+wafaHell/mock.py,sha256=EgfSCKYV3rUTerKoEyFQPSf47wrOo-E0yqe7JpQUe3w,2105
+wafaHell/model.py,sha256=OB4sEucMSgO-DBLgLhqh0oBx5fZRug23MDnRc8vS5w4,2501
+wafaHell/panel.py,sha256=NpbvgXy5Regm4dQDoMapr-otW27TvC7Q-vdPrZDD-5k,7465
+wafaHell/rateLimiter.py,sha256=p4IDxha-ZrRPROFf8Fa1gRTbbUTQdbD9TgBTmyMR2hQ,664
+wafaHell/utils.py,sha256=v9NXo94AQiHjjCOgC38vwrlLoQOCZqp_qOjZVz00NEI,12750
+wafahell-1.0.0.dist-info/licenses/LICENSE,sha256=6bv9v4HamenV3rqm3mhaGOecwGFrgxtVTW7JPfFDmeY,1086
+wafahell-1.0.0.dist-info/METADATA,sha256=2EA_4vTwwoXimX_etFdZo_x_Z2_qijnbSjuIHfwE10Q,2087
+wafahell-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+wafahell-1.0.0.dist-info/top_level.txt,sha256=VGBo2g3pOeTH2qIXfZDJCSblJgijemMHUHmI0bBgrls,9
+wafahell-1.0.0.dist-info/RECORD,,

{wafahell-0.2.0.dist-info → wafahell-1.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

wafaHell/teste.py

@@ -1,16 +0,0 @@
-from middleware import WafaHell
-from flask import Flask
-import logging
-
-app = Flask(__name__)
-waf = WafaHell(app, monitor_mode=True, block_ip=True, rate_limit=True)
-
-# log = logging.getLogger('werkzeug')
-# log.setLevel(logging.ERROR) 
-
-@app.route('/')
-def home():
-    return "Bem-vindo ao site seguro!"
-
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=5000, debug=False)