# Sicherheitshinweise

[← Zurück: Datenbank-Schema](09-database-schema.md) | [Weiter: Testing →](11-testing.md)

## ⚠️ WICHTIG: Query-Validierung

Die aktuelle Implementierung erlaubt die Ausführung von **rohen SQL-Queries**. Für Produktion sollten Sie:

1. **Query-Whitelisting**: Nur erlaubte Queries zulassen
2. **Nur SELECT**: Nur SELECT-Statements erlauben (keine INSERT/UPDATE/DELETE)
3. **Parameterized Queries**: Immer Parameterized Queries verwenden
4. **Query-Parsing**: SQL-Parser verwenden zur Validierung
5. **Rate Limiting**: Strikte Rate Limits setzen (bereits implementiert)

## Beispiel für Query-Validierung:

```python
def validateQuery(queryText: str) -> bool:
    """
    Validate that query is safe to execute.
    Only allows SELECT statements on Real Estate data model tables.
    """
    query_lower = queryText.strip().lower()
    
    # Only allow SELECT statements
    if not query_lower.startswith('select'):
        return False
    
    # Block dangerous keywords
    dangerous_keywords = [
        'drop', 'delete', 'insert', 'update', 'alter', 'create', 
        'truncate', 'grant', 'revoke', 'exec', 'execute', 'call'
    ]
    for keyword in dangerous_keywords:
        if keyword in query_lower:
            return False
    
    # Only allow queries on Real Estate data model tables
    allowed_tables = [
        'projekt', 'parzelle', 'dokument', 'kontext',
        'geopolylinie', 'geopunkt', 'land', 'kanton', 'gemeinde'
    ]
    
    # Check if query references allowed tables
    # Simple check - in production, use SQL parser
    query_contains_allowed_table = any(
        f'from {table}' in query_lower or f'join {table}' in query_lower
        for table in allowed_tables
    )
    
    if not query_contains_allowed_table:
        # Allow queries that don't specify table explicitly (might be subqueries)
        # But log for review
        logger.warning(f"Query does not reference known Real Estate tables: {queryText[:100]}")
    
    return True
```

## Erweiterte Validierung mit SQL-Parser:

Für Produktion sollten Sie einen SQL-Parser verwenden:

```python
from sqlparse import parse, tokens

def validateQueryAdvanced(queryText: str) -> bool:
    """Advanced query validation using SQL parser."""
    try:
        parsed = parse(queryText)[0]
        
        # Check statement type
        if parsed.get_type() != 'SELECT':
            return False
        
        # Extract table names and validate
        # Implementation depends on SQL parser library
        # ...
        
        return True
    except Exception as e:
        logger.error(f"Query parsing failed: {e}")
        return False
```

---

[← Zurück: Datenbank-Schema](09-database-schema.md) | [Weiter: Testing →](11-testing.md)