trappsec 0.1.0__tar.gz

trappsec-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: trappsec
+Version: 0.1.0
+Summary: deception as a developer tool
+Author-email: Nikhil Salgaonkar <nikhil@ftfy.co>
+Project-URL: Homepage, https://trappsec.dev
+Project-URL: Repository, https://github.com/trappsec-dev/trappsec
+Project-URL: Bug Tracker, https://github.com/trappsec-dev/trappsec/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: webhooks
+Requires-Dist: requests; extra == "webhooks"
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api; extra == "otel"

trappsec-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "trappsec"
+version = "0.1.0"
+authors = [
+  { name="Nikhil Salgaonkar", email="nikhil@ftfy.co" },
+]
+description = "deception as a developer tool"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://trappsec.dev"
+"Repository" = "https://github.com/trappsec-dev/trappsec"
+"Bug Tracker" = "https://github.com/trappsec-dev/trappsec/issues"
+
+[project.optional-dependencies]
+webhooks = ["requests"]
+otel = ["opentelemetry-api"]

trappsec-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

trappsec-0.1.0/src/trappsec/__init__.py

@@ -0,0 +1,5 @@
+from .core import Sentry
+
+__all__ = [
+    "Sentry",
+]

trappsec-0.1.0/src/trappsec/builders.py

@@ -0,0 +1,78 @@
+import typing
+import copy
+
+NO_DEFAULT = object()
+
+class TrapBuilder:
+    def __init__(self, ts, path):
+        self.ts = ts
+        self.config = {
+            "path": path, 
+            "methods": ["GET", "POST"],
+            "intent": None,
+            "response.authenticated": copy.deepcopy(self.ts.default_responses["authenticated"]),
+            "response.unauthenticated": copy.deepcopy(self.ts.default_responses["unauthenticated"]),
+        }
+
+    def methods(self, *args):
+        self.config["methods"] = list(args)
+        return self
+
+    def intent(self, intent: str):
+        self.config["intent"] = intent
+        return self
+    
+    def _respond(self, key: str, status: int = None, body: typing.Union[dict, typing.Callable] = None, mime_type: str = None, template: str = None):
+        key = "response." + key
+        if template:
+            if any(arg is not None for arg in (status, body, mime_type)):
+                raise TypeError("response_builder: `template` cannot be used together with `status`, `body`, or `mime_type`.")
+        
+            tmpl = self.ts._templates.get(template)
+            if not tmpl: 
+                raise ValueError(f"response_builder: template '{template}' not found.")
+            
+            self.config[key] = copy.deepcopy(tmpl)
+        else:
+            if status: 
+                self.config[key]["status_code"] = status
+            
+            if body: 
+                self.config[key]["response_body"] = body
+            
+            if mime_type: 
+                self.config[key]["mime_type"] = mime_type
+        
+        return self
+
+    def respond(self, status: int = None, body: typing.Union[dict, typing.Callable] = None, mime_type: str = None, template: str = None):
+        self._respond("authenticated", status, body, mime_type, template)
+        return self
+
+    def if_unauthenticated(self, status: int = None, body: typing.Union[dict, typing.Callable] = None, mime_type: str = None, template: str = None):
+        self._respond("unauthenticated", status, body, mime_type, template)
+        return self
+
+    def build(self):
+        return self.config
+
+class WatchBuilder:
+    def __init__(self, path):
+        self.path = path
+        self._query = {}
+        self._body = {}
+    
+    def query(self, name: str, default: typing.Any = NO_DEFAULT, intent: str = None):
+        self._query[name] = {"default": default, "intent": intent}
+        return self
+
+    def body(self, name: str, default: typing.Any = NO_DEFAULT, intent: str = None):
+        self._body[name] = {"default": default, "intent": intent}
+        return self
+    
+    def build(self):
+        return {
+            "path": self.path,
+            "query_fields": self._query,
+            "body_fields": self._body
+        }

trappsec-0.1.0/src/trappsec/core.py

@@ -0,0 +1,257 @@
+import time
+import json
+import typing
+import socket
+import logging
+
+from .handlers import LogHandler
+from .builders import TrapBuilder, WatchBuilder, NO_DEFAULT
+
+class IdentityContext:
+    def __init__(self):
+        self.ip = None
+        self.auth = None
+
+    def get_context(self, request_obj):
+        u, r = None, None
+        
+        if self.auth:
+            auth_context = self.auth(request_obj)
+            if isinstance(auth_context, dict):
+                u, r = auth_context.get("user"), auth_context.get("role")
+
+        return {
+            "user": u,
+            "role": r,
+            "ip": self.ip(request_obj) if self.ip else None
+        }
+
+class RequestContext:
+    def __init__(self):
+        self.path = lambda r: None
+        self.user_agent = lambda r: None
+        self.method = lambda r: None
+
+    def get_context(self, request_obj):
+        return {
+            "path": self.path(request_obj),
+            "user_agent": self.user_agent(request_obj),
+            "method": self.method(request_obj)
+        }
+
+class Sentry:
+    def __init__(self, app, service: str, environment: str):
+        self.logger = logging.getLogger("trappsec")
+        if not self.logger.handlers:
+            logging.basicConfig(format="%(message)s", level=logging.WARNING)
+        
+        self.hostname = socket.gethostname()
+        self.service = service
+        self.environment = environment
+
+        self.integration = None
+        
+        self.identity = IdentityContext()
+        self.request = RequestContext()
+        
+        self._traps = []
+        self._watches = []
+        self._templates = {}
+        self._handlers = [LogHandler(self.logger)]
+
+        self.default_responses = {
+            "authenticated": {
+                "status_code": 200,
+                "response_body": {},
+                "mime_type": "application/json"
+            },
+            "unauthenticated": {
+                "status_code": 401,
+                "response_body": {},
+                "mime_type": "application/json"
+            }
+        }
+
+        self._register(app)
+    
+    def template(self, name: str, status_code: int, response_body: dict, mime_type: str = "application/json"):
+        self._templates[name] = {"status_code": status_code, "response_body": response_body, "mime_type": mime_type}
+        return self
+
+    def trap(self, path: str):
+        builder = TrapBuilder(self, path)
+        self._traps.append(builder)
+        return builder
+
+    def watch(self, path: str):
+        builder = WatchBuilder(path)
+        self._watches.append(builder)
+        return builder
+
+    def add_webhook(self, url: str, secret: str = None, headers: dict = None, heartbeat_interval: int = None, template: typing.Callable = None):
+        from .handlers import WebhookHandler
+        handler = WebhookHandler(
+            url=url, 
+            secret=secret, 
+            headers=headers, 
+            service=self.service, 
+            environment=self.environment,
+            heartbeat_interval=heartbeat_interval,
+            template=template
+        )
+        self._handlers.append(handler)
+        return self
+
+    def add_otel(self):
+        from .handlers import OTELHandler
+        self._handlers.append(OTELHandler())
+        return self
+
+    def identify_user(self, callback: typing.Callable):
+        self.identity.auth = callback
+        return self
+
+    def override_source_ip(self, callback: typing.Callable):
+        self.identity.ip = callback
+        return self
+
+    @property
+    def traps(self):
+        return [d.build() if hasattr(d, "build") else d for d in self._traps]
+
+    @property
+    def watches(self):
+        return [r.build() if hasattr(r, "build") else r for r in self._watches]
+
+    def trigger(self, req, reason: str, intent: str = None, metadata: dict = None):
+        identity_ctx = self.identity.get_context(req)
+        request_ctx = self.request.get_context(req)
+
+        trigger_ctx = {
+            "timestamp": time.time(),
+            "event": "trappsec.rule_hit",
+            "type": "signal",
+            "reason": reason,
+            "intent": intent,
+            "path": request_ctx["path"],
+            "method": request_ctx["method"],
+            "user_agent": request_ctx["user_agent"],
+            "ip": identity_ctx["ip"],
+            "metadata": metadata,
+        }
+
+        if identity_ctx["user"]:
+            trigger_ctx["type"] = "alert"
+            trigger_ctx["user"] = identity_ctx["user"]
+            trigger_ctx["role"] = identity_ctx["role"]
+
+        self._trigger(trigger_ctx)
+
+    def _trigger(self, trigger_ctx):
+        trigger_ctx["app"] = {
+            "service": self.service,
+            "environment": self.environment,
+            "hostname": self.hostname
+        }
+
+        for h in self._handlers: 
+            try: 
+                h.emit(trigger_ctx)
+            except Exception as e:
+                self.logger.error("error invoking log handler: ", e)
+
+    def _trigger_watch_event(self, req, found_fields):
+        identity_ctx = self.identity.get_context(req)
+        request_ctx = self.request.get_context(req)
+
+        trigger_ctx = {
+            "timestamp": time.time(),
+            "event": "trappsec.watch_hit",
+            "type": "signal",
+            "path": request_ctx["path"],
+            "method": request_ctx["method"],
+            "user_agent": request_ctx["user_agent"],
+            "ip": identity_ctx["ip"],
+            "found_fields": found_fields
+        }
+
+        if identity_ctx["user"]:
+            trigger_ctx["type"] = "alert"
+            trigger_ctx["user"] = identity_ctx["user"]
+            trigger_ctx["role"] = identity_ctx["role"]
+        
+        self._trigger(trigger_ctx)
+
+    def _trigger_trap_event(self, req, trap):
+        identity_ctx = self.identity.get_context(req)
+        request_ctx = self.request.get_context(req)
+        
+        trigger_ctx = {
+            "timestamp": time.time(),
+            "event": "trappsec.trap_hit",
+            "type": "signal",
+            "path": request_ctx["path"],
+            "method": request_ctx["method"],
+            "user_agent": request_ctx["user_agent"],
+            "ip": identity_ctx["ip"],
+            "intent": trap.get("intent"),
+        }
+
+        response_key = "response.unauthenticated"
+
+        if identity_ctx["user"]:
+            trigger_ctx["type"] = "alert"
+            trigger_ctx["user"] = identity_ctx["user"]
+            trigger_ctx["role"] = identity_ctx["role"]
+            response_key = "response.authenticated"
+        
+        self._trigger(trigger_ctx)
+
+        response_config = trap[response_key]
+        response_body = response_config["response_body"]
+
+        if callable(response_body):
+            response_body = response_body(req)
+        
+        if response_config["mime_type"] == "application/json":
+            response_body = json.dumps(response_body)
+        
+        return response_body, response_config
+    
+    def _detect_honey_fields(self, data, rules, request_obj=None):
+        found_fields = []
+
+        for key in list(data.keys()):
+            if key in rules:
+                rule_definition = rules[key]
+                expected = rule_definition.get("default", NO_DEFAULT)
+                
+                try:
+                    if callable(expected):
+                        expected = expected(request_obj)
+                    
+                    if expected is NO_DEFAULT or data[key] != expected:
+                        found_fields.append({
+                            "type": "body",
+                            "field": key,
+                            "value": data[key],
+                            "intent": rule_definition.get("intent", None),
+                        })
+                except Exception as e:
+                    self.logger.error(f"failed to evaluate callable expected value for body field `{key}`: ", e)            
+
+                del data[key]
+        return data, found_fields
+
+    def _register(self, app):
+        name = app.__class__.__name__
+        module = app.__class__.__module__
+
+        if name == "FastAPI" or module.startswith("fastapi"):
+            from .integrations.fastapi import FastAPIIntegration
+            self.integration = FastAPIIntegration(self, app)
+        elif name == "Flask" or module.startswith("flask"):
+            from .integrations.flask import FlaskIntegration
+            self.integration = FlaskIntegration(self, app)
+        else:
+            raise Exception("trappsec error: unknown framework.")

trappsec-0.1.0/src/trappsec/handlers.py

@@ -0,0 +1,121 @@
+import logging
+import json
+import hmac
+import hashlib
+import threading
+import time
+
+try:
+    import requests
+    from requests.adapters import HTTPAdapter
+    from urllib3.util.retry import Retry
+except ImportError:
+    requests = None
+
+
+class BaseHandler:
+    def emit(self, event: dict): raise NotImplementedError
+
+class LogHandler(BaseHandler):
+    def __init__(self, logger: logging.Logger):
+        self.logger = logger
+    def emit(self, event: dict):
+        self.logger.warning(json.dumps(event))
+
+class WebhookHandler(BaseHandler):
+    def __init__(self, url: str, secret: str = None, headers: dict = None, service: str = None, environment: str = None, heartbeat_interval: int = None, template: callable = None):
+        if requests is None: 
+            raise ImportError("requests library required for WebhookHandler")
+        
+        self.url = url
+        self.secret = secret
+        self.service = service
+        self.environment = environment
+        self.template = template
+        self.logger = logging.getLogger("trappsec")
+        
+        self.headers = {"Content-Type": "application/json"}
+        self.headers.update(headers or {})
+        
+        self.session = requests.Session()
+        self.session.mount("https://", HTTPAdapter(max_retries=Retry(total=3, backoff_factor=1)))
+
+        if heartbeat_interval:
+            threading.Thread(target=self._heartbeat_loop, args=(heartbeat_interval,), daemon=True).start()
+    
+    def emit(self, event: dict):
+        if self.template:
+            try:
+                event = self.template(event)
+            except Exception as e:
+                self.logger.error(f"Failed to apply webhook template: {e}")
+        
+        payload = json.dumps(event)
+        self._send(payload)
+
+    def _heartbeat_loop(self, interval: int):
+        while True:
+            time.sleep(interval)
+            payload = json.dumps({
+                "timestamp": time.time(),
+                "event": "trappsec.heartbeat",
+                "service": self.service,
+                "environment": self.environment,
+            })
+            self._send(payload)
+
+    def _send(self, payload: str):
+        headers = self.headers.copy()
+        if self.secret:
+            headers["x-trappsec-signature"] = hmac.new(
+                self.secret.encode(), payload.encode(), hashlib.sha256).hexdigest()
+        
+        try:
+            self.session.post(self.url, data=payload, headers=headers, timeout=5)
+        except Exception as e: 
+            self.logger.error(f"Failed to send webhook: {e}")
+
+try:
+    from opentelemetry import trace
+except ImportError:
+    trace = None
+
+class OTELHandler(BaseHandler):
+    def __init__(self):
+        if trace is None: 
+            raise ImportError("opentelemetry-api library required for OTELHandler")
+
+    def emit(self, event: dict):
+        current_span = trace.get_current_span()
+        if current_span.is_recording():
+            current_span.set_attribute("trappsec.detected", True)
+            current_span.set_attribute("trappsec.event", event["event"])
+            current_span.set_attribute("trappsec.type", event["type"])
+            
+            if event.get("user"):
+                current_span.set_attribute("trappsec.user", event["user"])
+            if event.get("role"):
+                current_span.set_attribute("trappsec.role", event["role"])
+            
+            if event.get("ip"):
+                current_span.set_attribute("trappsec.ip", event["ip"])
+            
+            if event["event"] == "trappsec.watch_hit":
+                for field_info in event["found_fields"]:
+                    current_span.add_event("watch_hit", field_info)
+            
+            if event["event"] == "trappsec.trap_hit":
+                if event.get("intent"):
+                    current_span.set_attribute("trappsec.intent", event["intent"])
+            
+            if event["event"] == "trappsec.rule_hit":
+                if event.get("intent"):
+                    current_span.set_attribute("trappsec.intent", event["intent"])
+                if event.get("reason"):
+                    current_span.set_attribute("trappsec.reason", event["reason"])
+            
+            if event.get("metadata"):
+                metadata = event["metadata"]
+                if isinstance(metadata, dict):
+                    attrs = {f"metadata.{k}": v for k, v in metadata.items()}
+                    current_span.set_attributes(attrs)

trappsec-0.1.0/src/trappsec/integrations/fastapi.py

@@ -0,0 +1,118 @@
+from functools import partial
+
+class FastAPIIntegration:
+    def __init__(self, ts, app):
+        self.ts = ts
+        self.app = app
+        self.watch_map = None
+
+        if not self.ts.identity.ip: 
+            self.ts.identity.ip = lambda r: r.client.host if r.client else "0.0.0.0"
+
+        self.ts.request.path = lambda r: str(r.url.path)
+        self.ts.request.user_agent = lambda r: r.headers.get("user-agent", "unknown")
+        self.ts.request.method = lambda r: r.method
+        
+        self.setup_middleware()
+        self._patch_startup()
+
+    def inject_traps(self):
+        from fastapi import Request, Response
+        from fastapi.routing import APIRoute
+
+        async def endpoint(req: Request, trap):
+            response_body, response_config = self.ts._trigger_trap_event(req, trap)
+
+            return Response(response_body, 
+                status_code=response_config["status_code"], 
+                media_type=response_config["mime_type"])
+
+        new_routes = []
+        for idx, trap in enumerate(self.ts.traps):
+            new_routes.append(APIRoute(trap["path"], partial(endpoint, trap=trap), 
+                methods=trap["methods"], name=f"trappsec_{idx}", include_in_schema=False))
+    
+        self.app.router.routes = new_routes + self.app.router.routes
+
+    def setup_watches(self):
+        watch_map = dict()
+        for watch in self.ts.watches:
+            watch_map[watch["path"]] = watch
+        self.watch_map = watch_map
+    
+    def setup_middleware(self):        
+        from fastapi import Request, Depends
+        from starlette.datastructures import FormData
+        from starlette.middleware.base import BaseHTTPMiddleware
+        from urllib.parse import parse_qs, urlencode
+
+        async def trappsec_watcher(request: Request):
+            route = request.scope.get("route")
+            if route is None:
+                return
+
+            if route.path not in self.watch_map:
+                return
+            
+            matched_rule = self.watch_map[route.path]
+            query_fields = matched_rule["query_fields"]
+            body_fields = matched_rule["body_fields"]
+            found_fields = []
+            
+            if query_fields:
+                qs = request.scope.get("query_string", b"").decode("utf-8")
+                if qs:
+                    q_dict = parse_qs(qs).to_dict(flat=False)                    
+                    q_dict, mod = self.ts._detect_honey_fields(q_dict, query_fields, request)
+                    
+                    if mod:
+                        found_fields.extend(mod)
+                        request.scope["query_string"] = urlencode(q_dict, doseq=True).encode("utf-8")
+                        if hasattr(request, "_query_params"):
+                            del request._query_params
+                
+            if body_fields:
+                ctype = request.headers.get("content-type", "")
+                if "application/json" in ctype:
+                    try:
+                        body = await request.json()
+                        b, mod = self.ts._detect_honey_fields(body, body_fields, request)
+                        if mod:
+                            found_fields.extend(mod)
+                            request._json = b
+                    except Exception as e: 
+                        self.ts.logger.error("error reading json body: %s", e)
+                elif "application/x-www-form-urlencoded" in ctype or "multipart/form-data" in ctype:
+                    try:
+                        form_data = await request.form()
+                        data = dict(form_data)
+                        b, mod = self.ts._detect_honey_fields(data, body_fields, request)
+                        if mod:
+                            found_fields.extend(mod)
+                            request._form = FormData(b)
+                    except Exception as e: 
+                        self.ts.logger.error("error reading form body: %s", e)
+            
+            if found_fields:
+                self.ts._trigger_watch_event(request, found_fields)
+
+        if self.app.router.dependencies is None:
+            self.app.router.dependencies = []
+
+        self.app.router.dependencies.append(Depends(trappsec_watcher))
+    
+    def _patch_startup(self):
+        from contextlib import asynccontextmanager
+        original_lifespan = self.app.router.lifespan_context
+
+        @asynccontextmanager
+        async def wrapped_lifespan(app_instance):
+            self.inject_traps()
+            self.setup_watches()
+
+            async with original_lifespan(app_instance) as state:
+                yield state
+
+        self.app.router.lifespan_context = wrapped_lifespan
+        
+    

trappsec-0.1.0/src/trappsec/integrations/flask.py

@@ -0,0 +1,98 @@
+
+class FlaskIntegration:
+    def __init__(self, ts, app):
+        self.ts = ts
+        self.app = app
+
+        if not self.ts.identity.ip: 
+            self.ts.identity.ip = lambda r: r.remote_addr or "0.0.0.0"
+        
+        self.ts.request.path = lambda r: r.path
+        self.ts.request.user_agent = lambda r: str(r.user_agent)
+        self.ts.request.method = lambda r: r.method
+
+        self._patch_startup()
+
+    def inject_traps(self):
+        from flask import request, Response
+
+        for idx, decoy in enumerate(self.ts.traps):
+            def endpoint(d=decoy):
+                response_body, response_config = self.ts._trigger_trap_event(request, d)
+                
+                return Response(
+                    response_body,
+                    status=response_config["status_code"], 
+                    mimetype=response_config["mime_type"])
+            
+            endpoint.__name__ = f"trappsec_{idx}"
+            self.app.add_url_rule(decoy["path"], endpoint.__name__, endpoint, methods=decoy["methods"])
+    
+    def setup_watches(self):
+        if not self.ts.watches:
+            return
+        
+        from flask import request
+        from werkzeug.datastructures import ImmutableMultiDict
+
+        watch_map = dict()
+        for watch in self.ts.watches:
+            watch_map[watch["path"]] = watch
+
+        @self.app.before_request
+        def trappsec_watcher():
+            if request.url_rule is None:
+                return
+            
+            matched_rule = request.url_rule.rule
+            if matched_rule not in watch_map:
+                return
+
+            query_fields = watch_map[matched_rule]["query_fields"]
+            body_fields = watch_map[matched_rule]["body_fields"]
+                
+            found_fields = []
+            if request.args and query_fields:
+                q_dict = request.args.to_dict(flat=False)
+                q_dict, mod = self.ts._detect_honey_fields(q_dict, query_fields, request)
+                if mod: 
+                    found_fields.extend(mod)
+                    request.args = ImmutableMultiDict(q_dict)
+
+            if request.is_json and body_fields:
+                data = request.get_json(silent=True)
+                if data:
+                    data, mod = self.ts._detect_honey_fields(data, body_fields, request)
+                    if mod:
+                        found_fields.extend(mod)
+                        current = getattr(request, '_cached_json', None)
+                        if isinstance(current, tuple): 
+                            request._cached_json = (data, current[1])
+                        else: 
+                            request._cached_json = data
+
+            if request.form and body_fields:
+                form_copy = request.form.to_dict(flat=True)
+                form, mod = self.ts._detect_honey_fields(form_copy, body_fields, request)
+                if mod: 
+                    found_fields.extend(mod)
+                    request.form = ImmutableMultiDict(form)
+            
+            if found_fields:
+                self.ts._trigger_watch_event(request, found_fields)
+
+    
+    def _patch_startup(self):
+        original_wsgi_app = self.app.wsgi_app
+
+        def trappsec_wrapper(environ, start_response):
+            self.inject_traps()
+            self.setup_watches()
+
+            # un-patch after first request
+            self.app.wsgi_app = original_wsgi_app
+
+            return original_wsgi_app(environ, start_response)
+
+        self.app.wsgi_app = trappsec_wrapper
+

trappsec-0.1.0/src/trappsec.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: trappsec
+Version: 0.1.0
+Summary: deception as a developer tool
+Author-email: Nikhil Salgaonkar <nikhil@ftfy.co>
+Project-URL: Homepage, https://trappsec.dev
+Project-URL: Repository, https://github.com/trappsec-dev/trappsec
+Project-URL: Bug Tracker, https://github.com/trappsec-dev/trappsec/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: webhooks
+Requires-Dist: requests; extra == "webhooks"
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api; extra == "otel"

trappsec-0.1.0/src/trappsec.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+pyproject.toml
+src/trappsec/__init__.py
+src/trappsec/builders.py
+src/trappsec/core.py
+src/trappsec/handlers.py
+src/trappsec.egg-info/PKG-INFO
+src/trappsec.egg-info/SOURCES.txt
+src/trappsec.egg-info/dependency_links.txt
+src/trappsec.egg-info/requires.txt
+src/trappsec.egg-info/top_level.txt
+src/trappsec/integrations/__init__.py
+src/trappsec/integrations/fastapi.py
+src/trappsec/integrations/flask.py

trappsec-0.1.0/src/trappsec.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

trappsec-0.1.0/src/trappsec.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[otel]
+opentelemetry-api
+
+[webhooks]
+requests

trappsec-0.1.0/src/trappsec.egg-info/top_level.txt

@@ -0,0 +1 @@
+trappsec