aiwaf 0.1.9.2.0__py3-none-any.whl → 0.1.9.2.2__py3-none-any.whl

aiwaf/__init__.py

@@ -1,6 +1,6 @@
 default_app_config = "aiwaf.apps.AiwafConfig"
 
-__version__ = "0.1.9.2.0"
+__version__ = "0.1.9.2.2"
 
 # 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

@@ -0,0 +1,81 @@
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+from aiwaf.storage import get_blacklist_store, get_exemption_store, get_keyword_store
+from datetime import timedelta
+import json
+
+def _sort(items, order):
+    reverse = (order == "newest")
+    return sorted(items, key=lambda x: x.get("created_at") or timezone.make_aware(timezone.datetime.min),
+                  reverse=reverse)
+
+def _filter_since(items, seconds):
+    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]
+
+def _print_table(rows, headers):
+    widths = [len(h) for h in headers]
+    for r in rows:
+        for i, cell in enumerate(r):
+            widths[i] = max(widths[i], len(str(cell)))
+    print(" | ".join(h.ljust(widths[i]) for i, h in enumerate(headers)))
+    print("-+-".join("-" * w for w in widths))
+    for r in rows:
+        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)."
+
+    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).")
+
+    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 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 o["all"] or o["keywords"]:
+            kws = get_keyword_store().get_top_keywords(o["limit"])
+            payload["keywords"] = [{"keyword": k} for k in kws]
+
+        if o["format"] == "json":
+            def _default(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"])

aiwaf/middleware.py

@@ -103,47 +103,131 @@ class IPAndKeywordBlockMiddleware:
         return exempt_tokens
 
     def _get_legitimate_path_keywords(self):
-        """Get keywords that are legitimate in URL paths"""
-        # Extract from Django URL patterns
-        legitimate_keywords = set()
+        """Get keywords that are legitimate in URL paths - uses same logic as trainer"""
+        # Import the enhanced function from trainer to ensure consistency
+        try:
+            from .trainer import get_legitimate_keywords
+            return get_legitimate_keywords()
+        except ImportError:
+            # Fallback to local implementation if trainer import fails
+            return self._get_legitimate_keywords_fallback()
+    
+    def _get_legitimate_keywords_fallback(self):
+        """Fallback implementation matching trainer.py logic"""
+        legitimate = set()
         
-        # Add common legitimate path segments
+        # Common legitimate path segments - matches trainer.py
         default_legitimate = {
-            "profile", "user", "account", "settings", "dashboard", 
-            "home", "about", "contact", "help", "search", "list",
-            "view", "edit", "create", "update", "delete", "detail",
-            "api", "auth", "login", "logout", "register", "signup",
-            "reset", "confirm", "activate", "verify", "page",
-            "category", "tag", "post", "article", "blog", "news"
+            "profile", "user", "users", "account", "accounts", "settings", "dashboard", 
+            "home", "about", "contact", "help", "search", "list", "lists",
+            "view", "views", "edit", "create", "update", "delete", "detail", "details",
+            "api", "auth", "login", "logout", "register", "signup", "signin",
+            "reset", "confirm", "activate", "verify", "page", "pages",
+            "category", "categories", "tag", "tags", "post", "posts",
+            "article", "articles", "blog", "blogs", "news", "item", "items",
+            "admin", "administration", "manage", "manager", "control", "panel",
+            "config", "configuration", "option", "options", "preference", "preferences"
         }
-        legitimate_keywords.update(default_legitimate)
+        legitimate.update(default_legitimate)
+        
+        # Extract keywords from Django URL patterns and app names - matches trainer.py
+        legitimate.update(self._extract_django_route_keywords())
         
         # Add from Django settings
         allowed_path_keywords = getattr(settings, "AIWAF_ALLOWED_PATH_KEYWORDS", [])
-        legitimate_keywords.update(allowed_path_keywords)
+        legitimate.update(allowed_path_keywords)
         
-        # Extract from actual Django URL patterns
-        resolver = get_resolver()
-        self._extract_path_keywords_from_urls(resolver.url_patterns, legitimate_keywords)
+        # Add exempt keywords
+        exempt_keywords = getattr(settings, "AIWAF_EXEMPT_KEYWORDS", [])
+        legitimate.update(exempt_keywords)
         
-        return legitimate_keywords
+        return legitimate
 
-    def _extract_path_keywords_from_urls(self, url_patterns, keywords, prefix=""):
-        """Extract legitimate keywords from Django URL patterns"""
-        for pattern in url_patterns:
-            if hasattr(pattern, 'url_patterns'):  # include()
-                new_prefix = prefix + str(pattern.pattern).strip('^$/')
-                self._extract_path_keywords_from_urls(pattern.url_patterns, keywords, new_prefix)
-            else:
-                # Extract static path segments from URL pattern
-                pattern_str = str(pattern.pattern).strip('^$/')
-                full_path = (prefix + '/' + pattern_str).strip('/')
+    def _extract_django_route_keywords(self):
+        """Extract legitimate keywords from Django URL patterns, app names, and model names - matches trainer.py"""
+        keywords = set()
+        
+        try:
+            from django.urls.resolvers import URLResolver, URLPattern
+            
+            # Extract from app names and labels
+            for app_config in apps.get_app_configs():
+                # Add app name and label
+                if app_config.name:
+                    for segment in re.split(r'[._-]', app_config.name.lower()):
+                        if len(segment) > 2:
+                            keywords.add(segment)
+                
+                if app_config.label and app_config.label != app_config.name:
+                    for segment in re.split(r'[._-]', app_config.label.lower()):
+                        if len(segment) > 2:
+                            keywords.add(segment)
+                
+                # Extract from model names in the app
+                try:
+                    for model in app_config.get_models():
+                        model_name = model._meta.model_name.lower()
+                        if len(model_name) > 2:
+                            keywords.add(model_name)
+                        # Add plural form
+                        if not model_name.endswith('s'):
+                            keywords.add(f"{model_name}s")
+                except Exception:
+                    continue
+            
+            # Extract from URL patterns
+            def extract_from_pattern(pattern, prefix=""):
+                try:
+                    if isinstance(pattern, URLResolver):
+                        # Handle include() patterns
+                        namespace = getattr(pattern, 'namespace', None)
+                        if namespace:
+                            for segment in re.split(r'[._-]', namespace.lower()):
+                                if len(segment) > 2:
+                                    keywords.add(segment)
+                        
+                        # Extract from the pattern itself
+                        pattern_str = str(pattern.pattern)
+                        for segment in re.findall(r'([a-zA-Z]\w{2,})', pattern_str):
+                            keywords.add(segment.lower())
+                        
+                        # Recurse into nested patterns
+                        for nested_pattern in pattern.url_patterns:
+                            extract_from_pattern(nested_pattern, prefix)
+                    
+                    elif isinstance(pattern, URLPattern):
+                        # Extract from URL pattern
+                        pattern_str = str(pattern.pattern)
+                        for segment in re.findall(r'([a-zA-Z]\w{2,})', pattern_str):
+                            keywords.add(segment.lower())
+                        
+                        # Extract from view name if available
+                        if hasattr(pattern.callback, '__name__'):
+                            view_name = pattern.callback.__name__.lower()
+                            for segment in re.split(r'[._-]', view_name):
+                                if len(segment) > 2 and segment != 'view':
+                                    keywords.add(segment)
+                
+                except Exception:
+                    pass
+            
+            # Process all URL patterns
+            root_resolver = get_resolver()
+            for pattern in root_resolver.url_patterns:
+                extract_from_pattern(pattern)
                 
-                # Extract meaningful segments (not regex patterns)
-                segments = re.findall(r'[a-zA-Z]{3,}', full_path)
-                for seg in segments:
-                    if seg.lower() not in {'http', 'https', 'www'}:
-                        keywords.add(seg.lower())
+        except Exception as e:
+            # Silently continue if extraction fails
+            pass
+        
+        # Filter out very common/generic words that might be suspicious
+        filtered_keywords = set()
+        for keyword in keywords:
+            if (len(keyword) >= 3 and 
+                keyword not in ['www', 'com', 'org', 'net', 'int', 'str', 'obj', 'get', 'set', 'put', 'del']):
+                filtered_keywords.add(keyword)
+        
+        return filtered_keywords
 
     def _is_malicious_context(self, request, segment):
         """Determine if a keyword appears in a malicious context"""
@@ -243,12 +327,29 @@ class IPAndKeywordBlockMiddleware:
         
         # Check segments against suspicious keywords
         for seg in segments:
+            is_suspicious = False
+            block_reason = ""
+            
+            # Check if segment is in learned suspicious keywords
             if seg in suspicious_kw:
+                is_suspicious = True
+                block_reason = f"Learned keyword: {seg}"
+            
+            # Also check if segment appears to be inherently malicious
+            elif (not path_exists and 
+                  seg not in self.legitimate_path_keywords and 
+                  (self._is_malicious_context(request, seg) or 
+                   any(malicious_pattern in seg for malicious_pattern in 
+                       ['hack', 'exploit', 'attack', 'malicious', 'evil', 'backdoor', 'inject', 'xss']))):
+                is_suspicious = True
+                block_reason = f"Inherently suspicious: {seg}"
+            
+            if is_suspicious:
                 # Additional context check before blocking
                 if self._is_malicious_context(request, seg) or not path_exists:
                     # Double-check exemption before blocking
                     if not exemption_store.is_exempted(ip):
-                        BlacklistManager.block(ip, f"Keyword block: {seg} (context: malicious)")
+                        BlacklistManager.block(ip, f"Keyword block: {block_reason}")
                         # Check again after blocking attempt (exempted IPs won't be blocked)
                         if BlacklistManager.is_blocked(ip):
                             return JsonResponse({"error": "blocked"}, status=403)

aiwaf/trainer.py

@@ -34,19 +34,34 @@ def path_exists_in_django(path: str) -> bool:
     from django.urls import get_resolver
     from django.urls.resolvers import URLResolver
 
-    candidate = path.split("?")[0].lstrip("/")
+    candidate = path.split("?")[0].strip("/")  # Remove query params and normalize slashes
+    
+    # Try exact resolution first - this is the most reliable method
     try:
         get_resolver().resolve(f"/{candidate}")
         return True
     except:
         pass
-
-    root = get_resolver()
-    for p in root.url_patterns:
-        if isinstance(p, URLResolver):
-            prefix = p.pattern.describe().strip("^/")
-            if prefix and candidate.startswith(prefix):
-                return True
+    
+    # Also try with trailing slash if it doesn't have one
+    if not candidate.endswith("/"):
+        try:
+            get_resolver().resolve(f"/{candidate}/")
+            return True
+        except:
+            pass
+    
+    # Try without trailing slash if it has one
+    if candidate.endswith("/"):
+        try:
+            get_resolver().resolve(f"/{candidate.rstrip('/')}")
+            return True
+        except:
+            pass
+
+    # If direct resolution fails, be conservative
+    # Only do basic prefix matching for known include patterns
+    # but don't assume sub-paths exist just because the prefix exists
     return False
 
 
@@ -95,6 +110,9 @@ def get_legitimate_keywords() -> set:
     }
     legitimate.update(default_legitimate)
     
+    # Extract keywords from Django URL patterns and app names
+    legitimate.update(_extract_django_route_keywords())
+    
     # Add from Django settings
     allowed_path_keywords = getattr(settings, "AIWAF_ALLOWED_PATH_KEYWORDS", [])
     legitimate.update(allowed_path_keywords)
@@ -106,6 +124,97 @@ def get_legitimate_keywords() -> set:
     return legitimate
 
 
+def _extract_django_route_keywords() -> set:
+    """Extract legitimate keywords from Django URL patterns, app names, and model names"""
+    keywords = set()
+    
+    try:
+        from django.urls import get_resolver
+        from django.urls.resolvers import URLResolver, URLPattern
+        from django.apps import apps
+        
+        # Extract from app names and labels
+        for app_config in apps.get_app_configs():
+            # Add app name and label
+            if app_config.name:
+                for segment in re.split(r'[._-]', app_config.name.lower()):
+                    if len(segment) > 2:
+                        keywords.add(segment)
+            
+            if app_config.label and app_config.label != app_config.name:
+                for segment in re.split(r'[._-]', app_config.label.lower()):
+                    if len(segment) > 2:
+                        keywords.add(segment)
+            
+            # Extract from model names in the app
+            try:
+                for model in app_config.get_models():
+                    model_name = model._meta.model_name.lower()
+                    if len(model_name) > 2:
+                        keywords.add(model_name)
+                    # Add plural form
+                    if not model_name.endswith('s'):
+                        keywords.add(f"{model_name}s")
+            except Exception:
+                continue
+        
+        # Extract from URL patterns
+        def extract_from_pattern(pattern, prefix=""):
+            try:
+                if isinstance(pattern, URLResolver):
+                    # Handle include() patterns
+                    namespace = getattr(pattern, 'namespace', None)
+                    if namespace:
+                        for segment in re.split(r'[._-]', namespace.lower()):
+                            if len(segment) > 2:
+                                keywords.add(segment)
+                    
+                    # Extract from the pattern itself
+                    pattern_str = str(pattern.pattern)
+                    for segment in re.findall(r'([a-zA-Z]\w{2,})', pattern_str):
+                        keywords.add(segment.lower())
+                    
+                    # Recurse into nested patterns
+                    for nested_pattern in pattern.url_patterns:
+                        extract_from_pattern(nested_pattern, prefix)
+                
+                elif isinstance(pattern, URLPattern):
+                    # Extract from URL pattern
+                    pattern_str = str(pattern.pattern)
+                    for segment in re.findall(r'([a-zA-Z]\w{2,})', pattern_str):
+                        keywords.add(segment.lower())
+                    
+                    # Extract from view name if available
+                    if hasattr(pattern.callback, '__name__'):
+                        view_name = pattern.callback.__name__.lower()
+                        for segment in re.split(r'[._-]', view_name):
+                            if len(segment) > 2 and segment != 'view':
+                                keywords.add(segment)
+            
+            except Exception:
+                pass
+        
+        # Process all URL patterns
+        root_resolver = get_resolver()
+        for pattern in root_resolver.url_patterns:
+            extract_from_pattern(pattern)
+            
+    except Exception as e:
+        print(f"Warning: Could not extract Django route keywords: {e}")
+    
+    # Filter out very common/generic words that might be suspicious
+    filtered_keywords = set()
+    for keyword in keywords:
+        if (len(keyword) >= 3 and 
+            keyword not in ['www', 'com', 'org', 'net', 'int', 'str', 'obj', 'get', 'set', 'put', 'del']):
+            filtered_keywords.add(keyword)
+    
+    if filtered_keywords:
+        print(f"🔗 Extracted {len(filtered_keywords)} legitimate keywords from Django routes and apps")
+    
+    return filtered_keywords
+
+
 def _read_all_logs() -> list[str]:
     lines = []
     

{aiwaf-0.1.9.2.0.dist-info → aiwaf-0.1.9.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiwaf
-Version: 0.1.9.2.0
+Version: 0.1.9.2.2
 Summary: AI-powered Web Application Firewall
 Home-page: https://github.com/aayushgauba/aiwaf
 Author: Aayush Gauba
@@ -94,14 +94,19 @@ aiwaf/
   - Burst count  
   - Total 404s  
 
-- **Enhanced Dynamic Keyword Learning**  
+- **Enhanced Dynamic Keyword Learning with Django Route Protection**  
   - **Smart Context-Aware Learning**: Only learns keywords from suspicious requests on non-existent paths
-  - **Legitimate Path Protection**: Automatically excludes keywords from valid Django URLs (like `/profile/`, `/admin/`)
+  - **Automatic Django Route Extraction**: Automatically excludes keywords from:
+    - Valid Django URL patterns (`/profile/`, `/admin/`, `/api/`, etc.)
+    - Django app names and model names (users, posts, categories)
+    - View function names and URL namespaces
+  - **Unified Logic**: Both trainer and middleware use identical legitimate keyword detection
   - **Configuration Options**: 
     - `AIWAF_ALLOWED_PATH_KEYWORDS` - Explicitly allow certain keywords in legitimate paths
     - `AIWAF_EXEMPT_KEYWORDS` - Keywords that should never trigger blocking
   - **Automatic Cleanup**: Keywords from `AIWAF_EXEMPT_PATHS` are automatically removed from the database
   - **False Positive Prevention**: Stops learning legitimate site functionality as "malicious"
+  - **Inherent Malicious Detection**: Middleware also blocks obviously malicious keywords (`hack`, `exploit`, `attack`) even if not yet learned
 
 - **File‑Extension Probing Detection**  
   Tracks repeated 404s on common extensions (e.g. `.php`, `.asp`) and blocks IPs.

{aiwaf-0.1.9.2.0.dist-info → aiwaf-0.1.9.2.2.dist-info}/RECORD

@@ -1,18 +1,19 @@
-aiwaf/__init__.py,sha256=Bn2DcnLiYvx-vkOUfIbQtnKUDidKK1rAUNuXuPa36MM,220
+aiwaf/__init__.py,sha256=EwzM3mRDf7i5IVX0-pTMpVFRf51lpIIbh6ZzkzOw10M,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=D1HavBGJbpPneOtkkCVFddlOQwCdoWcugmHOvn5THDU,22614
+aiwaf/middleware.py,sha256=8EC4AKfUjHhmVSKpquimkMUebBekr92pqyVF97wlbx0,27408
 aiwaf/middleware_logger.py,sha256=LWZVDAnjh6CGESirA8eMbhGgJKB7lVDGRQqVroH95Lo,4742
 aiwaf/models.py,sha256=vQxgY19BDVMjoO903UNrTZC1pNoLltMU6wbyWPoAEns,2719
 aiwaf/storage.py,sha256=5ImrZMRn3u7HNsPH0fDjWhDrD2tgG2IHVnOXtLz0fk4,10253
-aiwaf/trainer.py,sha256=UHkfrbJI47bGJPCz0Vws6r23WvGpemMHf5ScHWG_I1I,14568
+aiwaf/trainer.py,sha256=U-X79nFhSTEbVexFHo3IXFf1HgvXrFnQ__WqTar0o4M,19118
 aiwaf/utils.py,sha256=BJk5vJCYdGPl_4QQiknjhCbkzv5HZCXgFcBJDMJpHok,3390
 aiwaf/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiwaf/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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_logging.py,sha256=FCIqULn2tii2vD9VxL7vk3PV4k4vr7kaA00KyaCExYY,7692
 aiwaf/management/commands/aiwaf_reset.py,sha256=pcF0zOYDSqjpCwDtk2HYJZLgr76td8OFRENtl20c1dQ,7472
 aiwaf/management/commands/check_dependencies.py,sha256=GOZl00pDwW2cJjDvIaCeB3yWxmeYcJDRTIpmOTLvy2c,37204
@@ -28,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.2.0.dist-info/licenses/LICENSE,sha256=Ir8PX4dxgAcdB0wqNPIkw84fzIIRKE75NoUil9RX0QU,1069
-aiwaf-0.1.9.2.0.dist-info/METADATA,sha256=HM_8Dh89XWhMKtLDkqrvA7fxzR97F9Ph1sY2bYOk9Mc,26414
-aiwaf-0.1.9.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiwaf-0.1.9.2.0.dist-info/top_level.txt,sha256=kU6EyjobT6UPCxuWpI_BvcHDG0I2tMgKaPlWzVxe2xI,6
-aiwaf-0.1.9.2.0.dist-info/RECORD,,
+aiwaf-0.1.9.2.2.dist-info/licenses/LICENSE,sha256=Ir8PX4dxgAcdB0wqNPIkw84fzIIRKE75NoUil9RX0QU,1069
+aiwaf-0.1.9.2.2.dist-info/METADATA,sha256=NFu9QZWsGPcmAJaHeJroSXZL_PstDr33NbSffV94bLQ,26824
+aiwaf-0.1.9.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiwaf-0.1.9.2.2.dist-info/top_level.txt,sha256=kU6EyjobT6UPCxuWpI_BvcHDG0I2tMgKaPlWzVxe2xI,6
+aiwaf-0.1.9.2.2.dist-info/RECORD,,