aiwaf 0.1.9.3.0__py3-none-any.whl → 0.1.9.3.1__py3-none-any.whl

aiwaf/__init__.py

@@ -1,6 +1,6 @@
 default_app_config = "aiwaf.apps.AiwafConfig"
 
-__version__ = "0.1.9.3.0"
+__version__ = "0.1.9.3.1"
 
 # Note: Middleware classes are available from aiwaf.middleware
 # Import them only when needed to avoid circular imports during Django app loading

aiwaf/management/commands/aiwaf_list.py

@@ -10,7 +10,8 @@ def _sort(items, order):
                   reverse=reverse)
 
 def _filter_since(items, seconds):
-    if not seconds: return items
+    if not seconds:
+        return items
     cutoff = timezone.now() - timedelta(seconds=seconds)
     return [it for it in items if it.get("created_at") and it["created_at"] >= cutoff]
 
@@ -25,57 +26,79 @@ def _print_table(rows, headers):
         print(" | ".join(str(cell).ljust(widths[i]) for i, cell in enumerate(r)))
 
 class Command(BaseCommand):
-    help = "Lister les données AIWAF (IPs bloquées, exemptions, mots-clés dynamiques)."
+    help = "AIWAF list (v2): blocked IPs, exempted IPs, monitored keywords."
 
     def add_arguments(self, parser):
         grp = parser.add_mutually_exclusive_group()
-        grp.add_argument("--ips", action="store_true", help="Lister les IPs bloquées (défaut).")
-        grp.add_argument("--exemptions", action="store_true", help="Lister les IPs exemptées.")
-        grp.add_argument("--keywords", action="store_true", help="Lister les mots-clés dynamiques.")
-        grp.add_argument("--all", action="store_true", help="Tout lister.")
-        parser.add_argument("--format", choices=["table", "json"], default="table")
-        parser.add_argument("--limit", type=int, default=100)
-        parser.add_argument("--order", choices=["newest", "oldest"], default="newest")
-        parser.add_argument("--since", type=int, help="Fenêtre en secondes (ex: 86400 = 24h).")
+        grp.add_argument("--ips-blocked", action="store_true", help="List blocked IPs (blacklist).")
+        grp.add_argument("--ips-exempted", action="store_true", help="List exempted IPs (whitelist).")
+        grp.add_argument("--keywords-monitored", action="store_true", help="List monitored dynamic keywords.")
+        grp.add_argument("--all", action="store_true", help="List everything.")
+
+        parser.add_argument("--format", choices=["table", "json"], default="table", help="Output format.")
+        parser.add_argument("--limit", type=int, default=100, help="Max items to display.")
+        parser.add_argument("--order", choices=["newest", "oldest"], default="newest", help="Sort order for IP entries.")
+        parser.add_argument("--since", type=int, help="Time window in seconds (e.g. 86400 = last 24h) for IP entries.")
+        parser.add_argument("--only-ip", action="store_true", help="For IP lists: print only the IP column.")
+
+    def handle(self, *args, **options):
+        # default: show blocked IPs if nothing specific is requested
+        if not any([options["ips_blocked"], options["ips_exempted"], options["keywords_monitored"], options["all"]]):
+            options["ips_blocked"] = True
 
-    def handle(self, *args, **o):
-        if not any([o["exemptions"], o["keywords"], o["all"]]):  # défaut = ips
-            o["ips"] = True
         payload = {}
 
-        if o["all"] or o["ips"]:
-            data = get_blacklist_store().get_all()
-            data = _filter_since(data, o.get("since"))
-            data = _sort(data, o["order"])[:o["limit"]]
-            payload["ips"] = data
+        if options["all"] or options["ips_blocked"]:
+            data = get_blacklist_store().get_all()  # [{ip_address, reason, created_at}]
+            data = _filter_since(data, options.get("since"))
+            data = _sort(data, options["order"])[: options["limit"]]
+            payload["ips_blocked"] = data
 
-        if o["all"] or o["exemptions"]:
-            data = get_exemption_store().get_all()
-            data = _filter_since(data, o.get("since"))
-            data = _sort(data, o["order"])[:o["limit"]]
-            payload["exemptions"] = data
+        if options["all"] or options["ips_exempted"]:
+            data = get_exemption_store().get_all()  # [{ip_address, reason, created_at}]
+            data = _filter_since(data, options.get("since"))
+            data = _sort(data, options["order"])[: options["limit"]]
+            payload["ips_exempted"] = data
 
-        if o["all"] or o["keywords"]:
-            kws = get_keyword_store().get_top_keywords(o["limit"])
-            payload["keywords"] = [{"keyword": k} for k in kws]
+        if options["all"] or options["keywords_monitored"]:
+            kws = get_keyword_store().get_top_keywords(options["limit"])  # [str]
+            payload["keywords_monitored"] = [{"keyword": k} for k in kws]
 
-        if o["format"] == "json":
+        if options["format"] == "json":
             def _default(v):
-                try: return v.isoformat()
-                except Exception: return str(v)
+                try:
+                    return v.isoformat()
+                except Exception:
+                    return str(v)
             self.stdout.write(json.dumps(payload, ensure_ascii=False, indent=2, default=_default))
-        else:
-            if "ips" in payload:
-                print("\n== IPs bloquées ==")
-                rows = [[r.get("ip_address",""), r.get("reason",""), r.get("created_at","")]
-                        for r in payload["ips"]]
-                _print_table(rows, ["ip_address", "reason", "created_at"])
-            if "exemptions" in payload:
-                print("\n== Exemptions ==")
-                rows = [[r.get("ip_address",""), r.get("reason",""), r.get("created_at","")]
-                        for r in payload["exemptions"]]
-                _print_table(rows, ["ip_address", "reason", "created_at"])
-            if "keywords" in payload:
-                print("\n== Mots-clés dynamiques ==")
-                rows = [[r["keyword"]] for r in payload["keywords"]]
-                _print_table(rows, ["keyword"])
+            return
+
+        # table output
+        if "ips_blocked" in payload:
+            print("\n== IPs blocked ==")
+            rows = payload["ips_blocked"]
+            if options["only_ip"]:
+                for r in rows:
+                    print(r.get("ip_address", ""))
+            else:
+                _print_table(
+                    [[r.get("ip_address",""), r.get("reason",""), r.get("created_at","")] for r in rows],
+                    ["ip_address", "reason", "created_at"],
+                )
+
+        if "ips_exempted" in payload:
+            print("\n== IPs exempted ==")
+            rows = payload["ips_exempted"]
+            if options["only_ip"]:
+                for r in rows:
+                    print(r.get("ip_address", ""))
+            else:
+                _print_table(
+                    [[r.get("ip_address",""), r.get("reason",""), r.get("created_at","")] for r in rows],
+                    ["ip_address", "reason", "created_at"],
+                )
+
+        if "keywords_monitored" in payload:
+            print("\n== Keywords monitored ==")
+            rows = payload["keywords_monitored"]
+            _print_table([[r["keyword"]] for r in rows], ["keyword"])

aiwaf/middleware.py

@@ -4,17 +4,30 @@ import time
 import re
 import os
 import warnings
-import numpy as np
-import joblib
-from django.db.models import UUIDField
 from collections import defaultdict
 from django.utils.deprecation import MiddlewareMixin
 from django.http import JsonResponse
 from django.conf import settings
 from django.core.cache import cache
-from django.db.models import F
+from django.db.models import F, UUIDField
 from django.apps import apps
 from django.urls import get_resolver
+
+# Optional dependencies with graceful fallbacks
+try:
+    import numpy as np
+    NUMPY_AVAILABLE = True
+except ImportError:
+    np = None
+    NUMPY_AVAILABLE = False
+
+try:
+    import joblib
+    JOBLIB_AVAILABLE = True
+except ImportError:
+    joblib = None
+    JOBLIB_AVAILABLE = False
+
 from .trainer import STATIC_KW, STATUS_IDX, path_exists_in_django
 from .blacklist_manager import BlacklistManager
 from .models import IPExemption
@@ -30,12 +43,22 @@ MODEL_PATH = getattr(
 def load_model_safely():
     """Load the AI model with version compatibility checking."""
     import warnings
-    import sklearn
     
     # Check if AI is disabled globally
     ai_disabled = getattr(settings, "AIWAF_DISABLE_AI", False)
     if ai_disabled:
-        print("AI functionality disabled via AIWAF_DISABLE_AI setting")
+        print("ℹ️  AI functionality disabled via AIWAF_DISABLE_AI setting")
+        return None
+    
+    # Check if required dependencies are available
+    if not JOBLIB_AVAILABLE:
+        print("ℹ️  joblib not available, AI functionality disabled")
+        return None
+    
+    try:
+        import sklearn
+    except ImportError:
+        print("ℹ️  sklearn not available, AI functionality disabled")
         return None
     
     try:
@@ -52,13 +75,13 @@ def load_model_safely():
                 current_version = sklearn.__version__
                 
                 if stored_version != current_version:
-                    print(f"Model was trained with sklearn v{stored_version}, current v{current_version}")
+                    print(f"ℹ️  Model was trained with sklearn v{stored_version}, current v{current_version}")
                     print("   Run 'python manage.py detect_and_train' to update model if needed.")
                 
                 return model
             else:
                 # Old format - direct model object
-                print("Using legacy model format. Consider retraining for better compatibility.")
+                print("ℹ️  Using legacy model format. Consider retraining for better compatibility.")
                 return model_data
                 
     except Exception as e:
@@ -66,6 +89,7 @@ def load_model_safely():
         print("AI anomaly detection will be disabled until model is retrained.")
         print("Run 'python manage.py detect_and_train' to regenerate the model.")
         return None
+        return None
 
 # Load model with safety checks
 MODEL = load_model_safely()
@@ -529,20 +553,22 @@ class AIAnomalyMiddleware(MiddlewareMixin):
         burst_count = sum(1 for (t, _, _, _) in data if now - t <= 10)
         total_404 = sum(1 for (_, _, st, _) in data if st == 404)
         feats = [path_len, kw_hits, resp_time, status_idx, burst_count, total_404]
-        X = np.array(feats, dtype=float).reshape(1, -1)
         
-        # Only use AI model if it's available
-        if self.model is not None and self.model.predict(X)[0] == -1:
-            # AI detected anomaly - but analyze patterns before blocking (like trainer.py)
-            
-            # Get recent behavior data for this IP to make intelligent blocking decision
-            recent_data = [d for d in data if now - d[0] <= 300]  # Last 5 minutes
+        # Only use AI model if it's available and numpy is available
+        if self.model is not None and NUMPY_AVAILABLE:
+            X = np.array(feats, dtype=float).reshape(1, -1)
             
-            if recent_data:
-                # Calculate behavior metrics similar to trainer.py
-                recent_kw_hits = []
-                recent_404s = 0
-                recent_burst_counts = []
+            if self.model.predict(X)[0] == -1:
+                # AI detected anomaly - but analyze patterns before blocking (like trainer.py)
+                
+                # Get recent behavior data for this IP to make intelligent blocking decision
+                recent_data = [d for d in data if now - d[0] <= 300]  # Last 5 minutes
+                
+                if recent_data:
+                    # Calculate behavior metrics similar to trainer.py
+                    recent_kw_hits = []
+                    recent_404s = 0
+                    recent_burst_counts = []
                 
                 for entry_time, entry_path, entry_status, entry_resp_time in recent_data:
                     # Calculate keyword hits for this entry
@@ -615,6 +641,110 @@ class AIAnomalyMiddleware(MiddlewareMixin):
 
 class HoneypotTimingMiddleware(MiddlewareMixin):
     MIN_FORM_TIME = getattr(settings, "AIWAF_MIN_FORM_TIME", 1.0)  # seconds
+    MAX_PAGE_TIME = getattr(settings, "AIWAF_MAX_PAGE_TIME", 240)  # 4 minutes default
+    
+    def _view_accepts_method(self, request, method):
+        """Check if the current view/URL pattern accepts the specified HTTP method"""
+        try:
+            from django.urls import resolve
+            from django.urls.resolvers import URLResolver, URLPattern
+            
+            # Resolve the current URL to get the view
+            resolved = resolve(request.path)
+            view_func = resolved.func
+            
+            # Handle class-based views
+            if hasattr(view_func, 'cls'):
+                view_class = view_func.cls
+                
+                # Check http_method_names attribute (most reliable)
+                if hasattr(view_class, 'http_method_names'):
+                    allowed_methods = [m.upper() for m in view_class.http_method_names]
+                    return method.upper() in allowed_methods
+                
+                # Check for method-handling methods
+                method_handlers = {
+                    'GET': ['get'],
+                    'POST': ['post', 'form_valid', 'form_invalid'],
+                    'PUT': ['put'],
+                    'PATCH': ['patch'],
+                    'DELETE': ['delete']
+                }
+                
+                if method.upper() in method_handlers:
+                    handlers = method_handlers[method.upper()]
+                    has_handler = any(hasattr(view_class, handler) for handler in handlers)
+                    if has_handler:
+                        return True
+                    
+                    # If no handler found, check if it's a common method that should be rejected
+                    if method.upper() in ['GET', 'POST', 'PUT', 'DELETE', 'PATCH']:
+                        return False
+                
+                # Default: assume method is allowed for class-based views
+                return True
+            
+            # Handle function-based views
+            else:
+                # Check if view has explicit allowed methods
+                if hasattr(view_func, 'http_method_names'):
+                    allowed_methods = [m.upper() for m in view_func.http_method_names]
+                    return method.upper() in allowed_methods
+                
+                # For function-based views, inspect the source code
+                import inspect
+                try:
+                    source = inspect.getsource(view_func)
+                    method_upper = method.upper()
+                    
+                    # Look for method handling in the source
+                    if f'request.method' in source and method_upper in source:
+                        return True
+                    
+                    # Look for method-specific patterns
+                    method_patterns = {
+                        'GET': ['request.GET', 'GET'],
+                        'POST': ['request.POST', 'POST', 'form.is_valid()'],
+                        'PUT': ['PUT', 'request.PUT'],
+                        'DELETE': ['DELETE', 'request.DELETE']
+                    }
+                    
+                    if method.upper() in method_patterns:
+                        patterns = method_patterns[method.upper()]
+                        if any(pattern in source for pattern in patterns):
+                            return True
+                            
+                except (OSError, TypeError):
+                    # Can't get source, make educated guess
+                    pass
+                
+                # Check URL pattern name for method-specific endpoints
+                if resolved.url_name:
+                    url_name_lower = resolved.url_name.lower()
+                    
+                    # POST-only patterns
+                    post_only_patterns = ['create', 'submit', 'upload', 'process']
+                    # GET-only patterns  
+                    get_only_patterns = ['list', 'detail', 'view', 'display']
+                    
+                    if method.upper() == 'POST':
+                        if any(pattern in url_name_lower for pattern in post_only_patterns):
+                            return True
+                        if any(pattern in url_name_lower for pattern in get_only_patterns):
+                            return False
+                    elif method.upper() == 'GET':
+                        if any(pattern in url_name_lower for pattern in get_only_patterns):
+                            return True
+                        if any(pattern in url_name_lower for pattern in post_only_patterns):
+                            return False
+                
+                # Default: assume function-based views accept common methods
+                return method.upper() in ['GET', 'POST', 'HEAD', 'OPTIONS']
+                
+        except Exception as e:
+            # If we can't determine, err on the side of caution and allow
+            print(f"AIWAF: Could not determine {method} capability for {request.path}: {e}")
+            return True
     
     def process_request(self, request):
         if is_exempt(request):
@@ -629,11 +759,33 @@ class HoneypotTimingMiddleware(MiddlewareMixin):
             return None
             
         if request.method == "GET":
+            # ENHANCEMENT: Check if this view accepts GET requests
+            if not self._view_accepts_method(request, 'GET'):
+                # This view is POST-only, but received a GET - likely scanning/probing
+                if not exemption_store.is_exempted(ip):
+                    BlacklistManager.block(ip, f"GET to POST-only view: {request.path}")
+                    if BlacklistManager.is_blocked(ip):
+                        return JsonResponse({
+                            "error": "blocked", 
+                            "message": f"GET not allowed for {request.path}"
+                        }, status=405)  # Method Not Allowed
+            
             # Store timestamp for this IP's GET request  
             # Use a general key for the IP, not path-specific
             cache.set(f"honeypot_get:{ip}", time.time(), timeout=300)  # 5 min timeout
         
         elif request.method == "POST":
+            # ENHANCEMENT: Check if this view actually accepts POST requests
+            if not self._view_accepts_method(request, 'POST'):
+                # This view is GET-only, but received a POST - likely malicious
+                if not exemption_store.is_exempted(ip):
+                    BlacklistManager.block(ip, f"POST to GET-only view: {request.path}")
+                    if BlacklistManager.is_blocked(ip):
+                        return JsonResponse({
+                            "error": "blocked", 
+                            "message": f"POST not allowed for {request.path}"
+                        }, status=405)  # Method Not Allowed
+            
             # Check if there was a preceding GET request
             get_time = cache.get(f"honeypot_get:{ip}")
             
@@ -654,6 +806,17 @@ class HoneypotTimingMiddleware(MiddlewareMixin):
                 time_diff = time.time() - get_time
                 min_time = self.MIN_FORM_TIME
                 
+                # ENHANCEMENT 2: Check for page timeout (4+ minutes)
+                if time_diff > self.MAX_PAGE_TIME:
+                    # Page has been open too long - suspicious or stale session
+                    # Don't block immediately, but require a fresh page load
+                    cache.delete(f"honeypot_get:{ip}")  # Force fresh GET
+                    return JsonResponse({
+                        "error": "page_expired", 
+                        "message": "Page has expired. Please reload and try again.",
+                        "reload_required": True
+                    }, status=409)  # 409 Conflict - client should reload
+                
                 # Use shorter time threshold for login paths (users can login quickly)
                 if any(request.path.lower().startswith(login_path) for login_path in [
                     "/admin/login/", "/login/", "/accounts/login/", "/auth/login/", "/signin/"
@@ -668,6 +831,19 @@ class HoneypotTimingMiddleware(MiddlewareMixin):
                         if BlacklistManager.is_blocked(ip):
                             return JsonResponse({"error": "blocked"}, status=403)
         
+        else:
+            # Handle other HTTP methods (PUT, DELETE, PATCH, etc.)
+            if request.method not in ['GET', 'POST', 'HEAD', 'OPTIONS']:
+                # Check if this view supports the requested method
+                if not self._view_accepts_method(request, request.method):
+                    if not exemption_store.is_exempted(ip):
+                        BlacklistManager.block(ip, f"{request.method} to view that doesn't support it: {request.path}")
+                        if BlacklistManager.is_blocked(ip):
+                            return JsonResponse({
+                                "error": "blocked", 
+                                "message": f"{request.method} not allowed for {request.path}"
+                            }, status=405)  # Method Not Allowed
+        
         return None
 
 

{aiwaf-0.1.9.3.0.dist-info → aiwaf-0.1.9.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiwaf
-Version: 0.1.9.3.0
+Version: 0.1.9.3.1
 Summary: AI-powered Web Application Firewall
 Home-page: https://github.com/aayushgauba/aiwaf
 Author: Aayush Gauba
@@ -32,6 +32,8 @@ Dynamic: requires-python
 - ✅ **Granular Reset Commands** - Clear specific data types (`--blacklist`, `--keywords`, `--exemptions`)
 - ✅ **Context-Aware Learning** - Only learns from suspicious requests, not legitimate site functionality
 - ✅ **Enhanced Configuration** - `AIWAF_ALLOWED_PATH_KEYWORDS` and `AIWAF_EXEMPT_KEYWORDS`
+- ✅ **Comprehensive HTTP Method Validation** - Blocks GET→POST-only, POST→GET-only, unsupported REST methods
+- ✅ **Enhanced Honeypot Protection** - POST validation & 4-minute page timeout with smart reload detection
 
 ---
 
@@ -111,10 +113,16 @@ aiwaf/
 - **File‑Extension Probing Detection**  
   Tracks repeated 404s on common extensions (e.g. `.php`, `.asp`) and blocks IPs.
 
-- **Timing-Based Honeypot**  
-  Tracks GET→POST timing patterns. Blocks IPs that:
+- **Enhanced Timing-Based Honeypot**  
+  Advanced GET→POST timing analysis with comprehensive HTTP method validation:
   - POST directly without a preceding GET request
   - Submit forms faster than `AIWAF_MIN_FORM_TIME` seconds (default: 1 second)
+  - **🆕 Smart HTTP Method Validation** - Comprehensive protection against method misuse:
+    - Blocks GET requests to POST-only views (form endpoints, API creates)
+    - Blocks POST requests to GET-only views (list pages, read-only content)
+    - Blocks unsupported REST methods (PUT/DELETE to non-REST views)
+    - Uses Django view analysis: class-based views, method handlers, URL patterns
+  - **🆕 Page expiration** after `AIWAF_MAX_PAGE_TIME` (4 minutes) with smart reload
 
 - **UUID Tampering Protection**  
   Blocks guessed or invalid UUIDs that don't resolve to real models.
@@ -509,6 +517,7 @@ python manage.py aiwaf_logging --clear     # Clear log files
 ```python
 AIWAF_MODEL_PATH         = BASE_DIR / "aiwaf" / "resources" / "model.pkl"
 AIWAF_MIN_FORM_TIME      = 1.0        # minimum seconds between GET and POST
+AIWAF_MAX_PAGE_TIME      = 240        # maximum page age before requiring reload (4 minutes)
 AIWAF_AI_CONTAMINATION   = 0.05       # AI anomaly detection sensitivity (5%)
 AIWAF_RATE_WINDOW        = 10         # seconds
 AIWAF_RATE_MAX           = 20         # max requests per window
@@ -801,9 +810,36 @@ python manage.py aiwaf_reset --blacklist --confirm
 | IPAndKeywordBlockMiddleware        | Blocks requests from known blacklisted IPs and Keywords         |
 | RateLimitMiddleware                | Enforces burst & flood thresholds                               |
 | AIAnomalyMiddleware                | ML‑driven behavior analysis + block on anomaly                  |
-| HoneypotTimingMiddleware           | Detects bots via GET→POST timing analysis                       |
+| HoneypotTimingMiddleware           | Enhanced bot detection: GET→POST timing, POST validation, page timeouts |
 | UUIDTamperMiddleware               | Blocks guessed/nonexistent UUIDs across all models in an app    |
 
+### 🍯 Enhanced Honeypot Protection
+
+The **HoneypotTimingMiddleware** now includes advanced bot detection capabilities:
+
+#### 🚫 Smart POST Request Validation
+- **Analyzes Django views** to determine actual allowed HTTP methods
+- **Intelligent detection** of GET-only vs POST-capable views
+- **Example**: `POST` to view with `http_method_names = ['get']` → `403 Blocked`
+
+#### ⏰ Page Timeout with Smart Reload
+- **4-minute page expiration** prevents stale session attacks
+- **HTTP 409 response** with reload instructions instead of immediate blocking
+- **CSRF protection** by forcing fresh page loads for old sessions
+
+```python
+# Configuration
+AIWAF_MIN_FORM_TIME = 1.0     # Minimum form submission time
+AIWAF_MAX_PAGE_TIME = 240     # Page timeout (4 minutes)
+```
+
+**Timeline Example**:
+```
+12:00:00 - GET /contact/   ✅ Page loaded
+12:02:00 - POST /contact/  ✅ Valid submission (2 minutes)
+12:04:30 - POST /contact/  ❌ 409 Conflict (page expired, reload required)
+```
+
 ---
 
 ## Sponsors

{aiwaf-0.1.9.3.0.dist-info → aiwaf-0.1.9.3.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
-aiwaf/__init__.py,sha256=WP3mllfac0SjosCM1zXVVzv8UFzeD3o2rvtOl29Km4E,220
+aiwaf/__init__.py,sha256=VlFbI8uqJmi1V0hsKasasV1BFglekVX0R5jvEOwXGzE,220
 aiwaf/apps.py,sha256=nCez-Ptlv2kaEk5HenA8b1pATz1VfhrHP1344gwcY1A,142
 aiwaf/blacklist_manager.py,sha256=LYCeKFB-7e_C6Bg2WeFJWFIIQlrfRMPuGp30ivrnhQY,1196
 aiwaf/decorators.py,sha256=IUKOdM_gdroffImRZep1g1wT6gNqD10zGwcp28hsJCs,825
-aiwaf/middleware.py,sha256=Bo8xcrRugp9audWNKp2nkrfYC34E4523tgWarEdlb2A,32256
+aiwaf/middleware.py,sha256=BnVdA4g2YTDo5g_H1Q8EE-ctVR4JF_yV3PaLHMgYZ-E,40804
 aiwaf/middleware_logger.py,sha256=LWZVDAnjh6CGESirA8eMbhGgJKB7lVDGRQqVroH95Lo,4742
 aiwaf/models.py,sha256=vQxgY19BDVMjoO903UNrTZC1pNoLltMU6wbyWPoAEns,2719
 aiwaf/storage.py,sha256=pUXE3bm7aRrABh_B6jTOBUQOYK67oQmHaR9EqyOasis,14038
@@ -13,7 +13,7 @@ aiwaf/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 aiwaf/management/commands/add_exemption.py,sha256=U_ByfJw1EstAZ8DaSoRb97IGwYzXs0DBJkVAqeN4Wak,1128
 aiwaf/management/commands/add_ipexemption.py,sha256=sSf3d9hGK9RqqlBYkCrnrd8KZWGT-derSpoWnEY4H60,952
 aiwaf/management/commands/aiwaf_diagnose.py,sha256=nXFRhq66N4QC3e4scYJ2sUngJce-0yDxtBO3R2BllRM,6134
-aiwaf/management/commands/aiwaf_list.py,sha256=tZK3FugApmPxxvmoB4-nLY9fpZJgiRtD137Bre5hEp8,3839
+aiwaf/management/commands/aiwaf_list.py,sha256=DVuhrQ4OUKWlzcQERadhedSRBhedt6OGJrrUkKFIoG0,4821
 aiwaf/management/commands/aiwaf_logging.py,sha256=FCIqULn2tii2vD9VxL7vk3PV4k4vr7kaA00KyaCExYY,7692
 aiwaf/management/commands/aiwaf_reset.py,sha256=pcF0zOYDSqjpCwDtk2HYJZLgr76td8OFRENtl20c1dQ,7472
 aiwaf/management/commands/check_dependencies.py,sha256=GOZl00pDwW2cJjDvIaCeB3yWxmeYcJDRTIpmOTLvy2c,37204
@@ -29,8 +29,8 @@ aiwaf/management/commands/test_exemption_fix.py,sha256=ngyGaHUCmQQ6y--6j4q1viZJt
 aiwaf/resources/model.pkl,sha256=5t6h9BX8yoh2xct85MXOO60jdlWyg1APskUOW0jZE1Y,1288265
 aiwaf/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiwaf/templatetags/aiwaf_tags.py,sha256=XXfb7Tl4DjU3Sc40GbqdaqOEtKTUKELBEk58u83wBNw,357
-aiwaf-0.1.9.3.0.dist-info/licenses/LICENSE,sha256=Ir8PX4dxgAcdB0wqNPIkw84fzIIRKE75NoUil9RX0QU,1069
-aiwaf-0.1.9.3.0.dist-info/METADATA,sha256=VlEUQCrOdf1uJI5cUYc8piuTCQgbYG6WT6-tajYCDQA,27208
-aiwaf-0.1.9.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiwaf-0.1.9.3.0.dist-info/top_level.txt,sha256=kU6EyjobT6UPCxuWpI_BvcHDG0I2tMgKaPlWzVxe2xI,6
-aiwaf-0.1.9.3.0.dist-info/RECORD,,
+aiwaf-0.1.9.3.1.dist-info/licenses/LICENSE,sha256=Ir8PX4dxgAcdB0wqNPIkw84fzIIRKE75NoUil9RX0QU,1069
+aiwaf-0.1.9.3.1.dist-info/METADATA,sha256=TQO1y9t5sRQY7zBNyJc6dvTfJ1JXC1vBTf1RjH8O8m0,29037
+aiwaf-0.1.9.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiwaf-0.1.9.3.1.dist-info/top_level.txt,sha256=kU6EyjobT6UPCxuWpI_BvcHDG0I2tMgKaPlWzVxe2xI,6
+aiwaf-0.1.9.3.1.dist-info/RECORD,,