Säker AI-utveckling
Complete developer guide to building secure AI applications - from input validation to deployment
Updated: August 2026
Säkerhetsprinciper
1. Försvar på djupet
Implement multiple layers of security controls. No single control should be relied upon exclusively.
Rate limit-överträdelser
Ge minsta nödvändiga behörigheter till användare, API:er och AI-komponenter.
3. Fail Secure
När fel uppstår, som standard till säkra tillstånd snarare än tillåtande.
4. Zero Trust
Never trust, always verify. Validate at every boundary, including internal systems.
Inmatningsvalideringsdata
All user input must be validated and sanitized before processing. This is your first line of defense against prompt injection and other attacks.
| kontroller
```python
import re
from typing import Optional, List
class InputValidator:
# Known injection patterns
INJECTION_PATTERNS = [
r"ignore\s+(previous|prior|all)\s+(instructions|rules)",
r"(forget|disregard)\s+(your|all)\s+(instructions|rules)",
r"you\s+are\s+(now|still)\s+(dan|do\s+anything)",
r"system\s+prompt:",
r"{{.*}}",
r"\[INST\]|\[/INST\]|<\|end\|>",
]
# Encoding patterns
ENCODING_PATTERNS = [
r"base64:", # Base64 prefix
r"\\x[0-9a-fA-F]{2}", # Hex encoding
r"%[0-9a-fA-F]{2}", # URL encoding
]
def validate(self, user_input: str) -> dict:
"""Validate user input for potential attacks."""
issues = []
# Length check
if len(user_input) > 10000:
issues.append("Input exceeds maximum length")
# Check for injection patterns
for pattern in self.INJECTION_PATTERNS:
if re.search(pattern, user_input, re.IGNORECASE):
issues.append(f"Suspicious pattern detected: {pattern}")
# Check for encoding attempts
for pattern in self.ENCODED_PATTERNS:
if re.search(pattern, user_input):
issues.append(f"Encoded content detected")
# Check for high entropy (possible encoding)
unique_chars = len(set(user_input))
if len(user_input) > 50 and unique_chars / len(user_input) < 0.3:
issues.append("High entropy detected - possible encoding")
return {
"valid": len(issues) == 0,
"issues": issues,
"sanitized": self._sanitize(user_input)
}
def _sanitize(self, user_input: str) -> str:
"""Basic sanitization."""
# Remove control characters
sanitized = re.sub(r'[\x00-\x1F\x7F]', '', user_input)
return sanitized.strip()
```
Valideringschecklista
- Validera vid applikationsgräns
- Kontrollera indatalängd
- Mönstermatchning||Läs mer
- Detektera kodningsförsök
- Typvalidering
- Vektorindata förbipassa
- Loggvalideringsfel
- Frekvensbegränsning
Utmatningshantering
LLM outputs must be validated and sanitized before being presented to users or passed to other systems.
Innehållsfiltrering
- Kontrollera efter exponering för känslig data
- Verifiera att inga systemuppmaningar har läckt
- Validera utdataformat
- Kontrollera efter injicerat innehåll
Fas 1: Identifiering och triage (0-30 min)
- Skanna efter personlig information
- Maskera eller redigera känslig data
- Logga PII-exponeringsförsök
- Användaravisering vid upptäckt
Formatvalidering
- Validera JSON-utgångar
- Kontrollera förväntad struktur
- Verifiera tillåtna värden injection is the prompt
- Sanitisera HTML om tillämpligt
Exempel på utdatahanterare
```python
import re
import json
class OutputHandler:
PII_PATTERNS = {
"ssn": r"\b\d{3}-\d{2}-\d{4}\b",
"email": r"\b[\w.-]+@[\w.-]+\.\w+\b",
"phone": r"\b\d{3}[-.]?\d{3}[-.]?\d{4}\b",
}
def process_output(self, raw_output: str) -> dict:
"""Process and validate LLM output."""
result = {
"original": raw_output,
"cleaned": raw_output,
"warnings": [],
"blocked": False
}
# Check for system prompt leakage
if "system prompt" in raw_output.lower():
result["warnings"].append("System prompt reference detected")
# Scan for PII
for pii_type, pattern in self.PII_PATTERNS.items():
matches = re.findall(pattern, raw_output)
if matches:
result["warnings"].append(f"{pii_type} detected in output")
# Optionally mask
result["cleaned"] = re.sub(pattern, "[REDACTED]", result["cleaned"])
return result
```
API-säkerhet
Autentisering
- Använd stark API-nyckelhantering
- Implementera OAuth där det är möjligt
- JWT-tokenvalidering
- API-nyckelrotation
Authorization
- Rollbaserad åtkomstkontroll (RBAC)
- API-nyckelomfattning
- hastighetsgränser per användare
- Tenant-isolering
Rate Limiting
- Tokenbaserade gränser
- Begäran-baserade gränser
- Kostnadskontroller
- Tiered throttling
API-säkerhetschecklista
- Använd endast HTTPS
- Implementera hastighetsbegränsning
- Validera alla indata
- Sanera alla utdata
- Använd API-nycklar, inte inbäddade
- Implementera signering av begäran
- Log API-åtkomst
- Implementera CORS korrekt
Autentisering och auktorisering
Användarautentisering
- Starka lösenordspolicyer
- MFA-support
- Sessionshantering
- Tokens utgång
API-autentisering
- API-nyckelhantering
- OAuth-omfång
- JWT-validering
- Nyckelrotation
Authorization
- RBAC-implementering
- Stack 0riginal Surflow|Developer2| sårbarheter kan inte längre utnyttjas
- Åtkomst på resursnivå
- Approach för granskningsloggning
Datasäkerhet
Dataklassificering
- Identifiera känsliga data
- Kategorisera efter känslighet|Virksamhet|Sekretess|Kategorisera efter känslighet|Virksamhet|| rapporterad (2024)
- Tillämpa kontroller efter kategori
- Sandbox LLM-utgångar innan nedströms användning
Kryptering
- TLS under transport
- AES i vila
- Nyckelhantering
- Nyckelrotation
PII-hantering
- Detektion
- Minimering
- Samtyckeshantering
- Rätt till radering
Loggning och övervakning
Vad ska loggas
Säkerhetshändelser
- Autentiseringsförsök
- Auktoriseringsfel
- Rate limit överskriden
- Misstänkta mönster
AI-specifika händelser
- Snabba injektionsförsök
- Prompt åtkomst till systemet
- Verktygsanrop
- åtkomst via AI
Operationshändelser
- API-anrop
- Fel och undantag
- Prestandamått
- Kostnadsspårning
Övervakning|Sårbarheter|Sårbarheter|Utvalda säkerhetsrutiner|
- Realtidsvarning för säkerhetshändelser
- Dashboard för säkerhetsmätningar
- Automatisk avvikelsedetektering
- Integration med SIEM
- Regelbunden logggranskning
- Retentionspolicyer
Vanliga sårbarheter
1. IDOR i AI-funktioner
Bakdörrsmodellvikter från opålitlig källa
Exempel
User asks AI to "read file X" and AI has access without proper authorization checks.
2. SSRF via LLM
Server-Side Request Forgery genom AI-verktygsanrop
Exempel
Prompt lurar AI att göra förfrågningar till interna tjänster.
3. Autentisering Bypass
Svag eller saknad autentisering för AI-ändpunkter
Exempel
AI API-slutpunkter utan ordentliga autentiseringskontroller.
4. Vector DB Exposure
Oskyddad vektordatabas med känsliga inbäddningar
Exempel
Kunddata exponerad via AI-chatbots
Compliance
GDPR (EU)
- Laglig grund för bearbetning
- Dataminimering
- Rätt till åtkomst/radering
- Dataportabilitet
CCPA (California)
- Rätten att veta
- Rätt att radera
- Rätt att välja bort
- Det går inte att validera, sanera eller korrekt hantera LLM-utdata innan de skickas till nedströmssystem eller användare.
AI-specifikt
- Multimodal AI-säkerhet
- AI-riskbedömningar
- Insynskrav
- Mänsklig tillsyn