FP&A Platform — Security Specification

Version: 1.0
Last Updated: 2026-02-03
Document ID: SEC-001
Classification: Confidential

1. Executive Summary

This document defines the security architecture, controls, and requirements for the FP&A Platform. The platform handles sensitive financial data for regulated industries and must comply with SOX, HIPAA, FDA 21 CFR Part 11, and LGPD requirements.

Security Principles

Defense in Depth: Multiple security layers at network, application, and data levels
Zero Trust: Never trust, always verify; authenticate and authorize every request
Least Privilege: Grant minimum permissions necessary for function
Secure by Default: Security controls enabled by default, opt-out requires justification
Auditability: All security-relevant actions logged immutably

2. Threat Model

2.1 Threat Actors

Actor	Motivation	Capability	Likelihood	Impact
External Opportunistic	Financial gain	Low-Medium	High	Medium
External Targeted	IP theft, competitive advantage	Medium-High	Medium	High
Malicious Insider	Financial gain, revenge	High (privileged access)	Low	Critical
Negligent Insider	None (accident)	High	High	Medium
Nation-State	Espionage	Very High	Low	Critical
Supply Chain	Financial gain	Medium	Medium	High

2.2 Attack Vectors

OWASP Top 10 (Web Application)

Risk	Threat	Mitigation
A01 Broken Access Control	Unauthorized data access	OpenFGA RBAC, RLS, API authorization
A02 Cryptographic Failures	Data exposure	TLS 1.3, AES-256, field encryption
A03 Injection	SQL/command injection	Parameterized queries, input validation
A04 Insecure Design	Architectural flaws	Threat modeling, security reviews
A05 Security Misconfiguration	Default credentials, open ports	IaC scanning, hardening guides
A06 Vulnerable Components	Dependency exploits	Snyk scanning, auto-updates
A07 Auth Failures	Credential stuffing, session hijack	MFA, rate limiting, secure sessions
A08 Data Integrity Failures	Unsigned updates, CI/CD attacks	Signed artifacts, SLSA compliance
A09 Logging Failures	Undetected breaches	Comprehensive logging, SIEM
A10 SSRF	Internal network access	Egress filtering, URL validation

AI/ML-Specific Threats

Threat	Description	Mitigation
Prompt Injection	Malicious input manipulates LLM	Input sanitization, guardrails, output validation
Data Poisoning	Corrupted training data	Training data validation, provenance tracking
Model Extraction	Stealing model weights	Access controls, rate limiting, watermarking
Membership Inference	Determining training data	Differential privacy, access controls
Output Manipulation	Exploiting model outputs	Output validation, human review

2.3 Assets at Risk

Asset	Classification	Threat Impact
Financial Data (GL, forecasts)	Confidential	Financial fraud, competitive harm
User Credentials	Restricted	Account takeover, data breach
PII (names, SSN, addresses)	Restricted	Regulatory fines, reputation
PHI (healthcare customers)	Restricted	HIPAA violations, lawsuits
AI Model Weights	Confidential	Competitive harm
Audit Logs	Restricted	Compliance violations
API Keys / Secrets	Restricted	Full system compromise

3. Security Architecture

3.1 Network Security

┌─────────────────────────────────────────────────────────────────────┐
│                         INTERNET                                     │
└───────────────────────────────┬─────────────────────────────────────┘
                                │
                    ┌───────────▼───────────┐
                    │   Cloud Armor (WAF)   │
                    │   DDoS Protection     │
                    └───────────┬───────────┘
                                │
                    ┌───────────▼───────────┐
                    │   Cloud Load Balancer │
                    │   TLS Termination     │
                    └───────────┬───────────┘
                                │
┌───────────────────────────────▼─────────────────────────────────────┐
│                      VPC (10.0.0.0/16)                               │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │              PUBLIC SUBNET (10.0.1.0/24)                     │   │
│  │                    (NAT Gateway only)                        │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                      │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │              PRIVATE SUBNET (10.0.10.0/24)                   │   │
│  │   ┌───────────────────────────────────────────────────┐     │   │
│  │   │              GKE CLUSTER (Private)                │     │   │
│  │   │   • Workload Identity                             │     │   │
│  │   │   • Network Policies (Calico)                     │     │   │
│  │   │   • Binary Authorization                          │     │   │
│  │   └───────────────────────────────────────────────────┘     │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                      │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │              DATA SUBNET (10.0.20.0/24)                      │   │
│  │   ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │   │
│  │   │  Cloud SQL  │  │    Redis    │  │   immudb    │        │   │
│  │   │  (Private)  │  │    (HA)     │  │  (Audit)    │        │   │
│  │   └─────────────┘  └─────────────┘  └─────────────┘        │   │
│  └─────────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────────┘

Network Controls:

Private GKE cluster (no public IPs on nodes)
VPC Service Controls for data exfiltration prevention
Cloud NAT for egress with logging
Private Service Connect for GCP services
Network policies restricting pod-to-pod communication

3.2 Defense in Depth Layers

Layer 1: PERIMETER
├── Cloud Armor WAF
├── DDoS protection
├── Geographic restrictions
└── Rate limiting

Layer 2: NETWORK  
├── VPC isolation
├── Private subnets
├── Network policies
└── Service mesh (mTLS)

Layer 3: APPLICATION
├── API Gateway authentication
├── Input validation
├── Output encoding
└── CSRF/XSS protection

Layer 4: DATA
├── Encryption at rest (AES-256)
├── Encryption in transit (TLS 1.3)
├── Field-level encryption (PII/PHI)
└── Row-level security

Layer 5: IDENTITY
├── OAuth2/OIDC
├── MFA requirement
├── OpenFGA authorization
└── Session management

Layer 6: MONITORING
├── Security event logging
├── SIEM integration
├── Anomaly detection
└── Incident alerting

4. Authentication & Authorization

4.1 Authentication Architecture

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Client    │────▶│  Identity   │────▶│   FP&A      │
│   (Browser) │     │  Provider   │     │   Platform  │
└─────────────┘     │  (Okta/     │     └─────────────┘
                    │  Azure AD)  │
                    └─────────────┘
                          │
           ┌──────────────┼──────────────┐
           ▼              ▼              ▼
    ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
    │    OIDC     │ │    SAML     │ │   Social    │
    │    Flow     │ │    Flow     │ │   Login     │
    └─────────────┘ └─────────────┘ └─────────────┘

Authentication Methods:

Method	Use Case	Configuration
OIDC/OAuth2	Primary web/API auth	Authorization Code + PKCE
SAML 2.0	Enterprise SSO	SP-initiated, signed assertions
API Keys	Service-to-service	Hashed storage, rotation required
mTLS	Internal services	Cert-based, auto-rotation

MFA Requirements:

Role	MFA Required	Allowed Methods
Admin	Always	TOTP, WebAuthn, Push
Finance Manager	Always	TOTP, WebAuthn, Push
FP&A Analyst	Sensitive actions	TOTP, Push
Viewer	Optional	Any

4.2 Authorization (OpenFGA)

Authorization Model:

# OpenFGA authorization model
model:
  schema: "1.1"

types:
  - type: user
    relations:
      define tenant_member: [tenant]
      
  - type: tenant
    relations:
      define admin: [user]
      define member: [user]
      
  - type: legal_entity
    relations:
      define parent: [tenant]
      define admin: [user] or admin from parent
      define finance_manager: [user]
      define analyst: [user]
      define viewer: [user] or analyst or finance_manager or admin
      
  - type: journal_entry
    relations:
      define entity: [legal_entity]
      define author: [user]
      define can_view: viewer from entity
      define can_edit: author or finance_manager from entity
      define can_approve: finance_manager from entity but not author
      define can_post: admin from entity
      
  - type: reconciliation
    relations:
      define entity: [legal_entity]
      define preparer: [user]
      define can_view: viewer from entity
      define can_prepare: analyst from entity or finance_manager from entity
      define can_review: finance_manager from entity but not preparer

Segregation of Duties:

Action	Creator Cannot	Reason
Approve journal entry	Approve own entry	Maker-checker control
Review reconciliation	Review own work	Independent verification
Approve budget	Approve own budget	Financial control
Close period	Reopen period	Separation of duties

4.3 Session Management

session:
  storage: redis_cluster
  encryption: AES-256-GCM
  
  timeouts:
    idle: 30m  # Inactive session timeout
    absolute: 8h  # Maximum session duration
    
  security:
    httponly: true
    secure: true
    samesite: strict
    
  concurrent_sessions:
    max_per_user: 5
    force_logout_oldest: true
    
  rotation:
    on_privilege_change: true
    on_authentication: true

5. Data Protection

5.1 Encryption Standards

At Rest:

Data Type	Encryption	Key Management
Database (PostgreSQL)	AES-256 (CMEK)	Cloud KMS
Object Storage	AES-256 (CSEK)	Cloud KMS
Backups	AES-256	Separate key
PII/PHI Fields	AES-256-GCM	Field-level keys

In Transit:

Channel	Encryption	Configuration
External API	TLS 1.3	Strong cipher suites only
Internal Service	mTLS	Auto-rotated certs
Database	TLS 1.3	Certificate verification
Redis	TLS 1.2+	AUTH + TLS

Key Rotation Schedule:

Key Type	Rotation Period	Method
Master encryption keys	90 days	Automatic
Service account keys	90 days	Automatic
API keys	180 days	Manual + notification
TLS certificates	90 days	Automatic (Let's Encrypt)

5.2 Field-Level Encryption

# Encryption service for sensitive fields
class FieldEncryption:
    SENSITIVE_FIELDS = {
        'users': ['ssn', 'tax_id', 'bank_account'],
        'legal_entities': ['tax_id', 'bank_account'],
        'connections': ['credentials'],
    }
    
    def encrypt(self, table: str, field: str, value: str) -> str:
        """Encrypt sensitive field with table-specific key."""
        if field not in self.SENSITIVE_FIELDS.get(table, []):
            return value
        
        key = self.kms.get_key(f"{table}_{field}")
        iv = os.urandom(12)
        cipher = Cipher(algorithms.AES(key), modes.GCM(iv))
        encryptor = cipher.encryptor()
        ciphertext = encryptor.update(value.encode()) + encryptor.finalize()
        
        return base64.b64encode(iv + encryptor.tag + ciphertext).decode()

5.3 Data Masking

Non-Production Environments:

Field Type	Masking Method
Email	faker email
SSN	XXX-XX-{last4}
Bank Account	*****{last4}
Name	faker name
Address	faker address
Phone	(XXX) XXX-{last4}

6. Application Security

6.1 Secure Coding Standards

Input Validation:

from pydantic import BaseModel, validator, constr
from typing import Decimal

class JournalEntryCreate(BaseModel):
    entity_id: constr(regex=r'^ent_[a-z0-9]{8,20}$')
    date: date
    description: constr(min_length=1, max_length=500)
    lines: List[JournalLineCreate]
    
    @validator('date')
    def date_not_future(cls, v):
        if v > date.today() + timedelta(days=365):
            raise ValueError('Date cannot be more than 1 year in future')
        return v
    
    @validator('lines')
    def lines_balanced(cls, v):
        total_debit = sum(l.debit or 0 for l in v)
        total_credit = sum(l.credit or 0 for l in v)
        if abs(total_debit - total_credit) > Decimal('0.01'):
            raise ValueError('Entry must be balanced')
        return v

SQL Injection Prevention:

# NEVER do this:
# query = f"SELECT * FROM users WHERE id = '{user_id}'"

# ALWAYS use parameterized queries:
async def get_user(user_id: str) -> User:
    query = "SELECT * FROM users WHERE id = $1 AND tenant_id = $2"
    return await db.fetchone(query, user_id, current_tenant_id)

6.2 API Security

Rate Limiting:

Endpoint Type	Limit	Window	Action
Authentication	5	1 min	Block IP
API (authenticated)	1000	1 min	429 response
API (unauthenticated)	100	1 min	429 response
AI Agent	10	1 min	Queue

Request Validation:

# Kong API Gateway configuration
plugins:
  - name: request-validator
    config:
      body_schema: |
        {
          "type": "object",
          "required": ["entity_id", "period"],
          "properties": {
            "entity_id": {"type": "string", "pattern": "^ent_"},
            "period": {"type": "string", "format": "date"}
          }
        }
  
  - name: rate-limiting
    config:
      minute: 1000
      policy: redis
      
  - name: cors
    config:
      origins: ["https://app.fpa-platform.com"]
      methods: ["GET", "POST", "PUT", "DELETE"]
      credentials: true

7. AI/ML Security

7.1 Prompt Injection Prevention

class PromptGuardrail:
    BLOCKED_PATTERNS = [
        r"ignore.*previous.*instructions",
        r"pretend.*you.*are",
        r"system.*prompt",
        r"reveal.*your.*instructions",
        r"<script>",
        r"javascript:",
    ]
    
    def sanitize_input(self, user_input: str) -> str:
        # Check for blocked patterns
        for pattern in self.BLOCKED_PATTERNS:
            if re.search(pattern, user_input, re.IGNORECASE):
                raise SecurityException("Potentially malicious input detected")
        
        # Escape special characters
        sanitized = html.escape(user_input)
        
        # Length limit
        if len(sanitized) > 10000:
            raise ValidationException("Input too long")
        
        return sanitized
    
    def validate_output(self, output: str, context: dict) -> str:
        # Verify numbers are grounded in context
        numbers = re.findall(r'\$?[\d,]+\.?\d*', output)
        for num in numbers:
            if not self.verify_number_source(num, context):
                raise HallucinationException(f"Ungrounded number: {num}")
        
        return output

7.2 Model Access Control

model_access:
  deepseek-r1-32b:
    allowed_services:
      - orchestrator-agent
      - reconciliation-agent
      - variance-agent
      - forecast-agent
      - compliance-agent
    rate_limits:
      tokens_per_minute: 100000
      requests_per_minute: 60
    audit:
      log_all_requests: true
      log_outputs: true
      retention_days: 90

8. Compliance Controls Mapping

8.1 SOX Section 404

Control	Requirement	Implementation
ITGC-01	Access Control	OpenFGA + MFA + access reviews
ITGC-02	Change Management	Git + PR reviews + CI/CD
ITGC-03	Computer Operations	Automated monitoring + alerting
ITGC-04	Program Development	SDLC + security reviews
AC-01	Journal Entry Controls	Segregation of duties, approval workflows
AC-02	Period Close Controls	Checklist automation, audit trail

8.2 HIPAA Technical Safeguards

Safeguard	Requirement	Implementation
164.312(a)(1)	Access Control	OpenFGA, RLS, MFA
164.312(b)	Audit Controls	immudb, comprehensive logging
164.312(c)(1)	Integrity	Checksums, digital signatures
164.312(d)	Authentication	OIDC + MFA
164.312(e)(1)	Transmission Security	TLS 1.3, mTLS

8.3 FDA 21 CFR Part 11

Requirement	Section	Implementation
System Validation	11.10(a)	Automated testing, validation docs
Record Integrity	11.10(c)	Immutable audit trail (immudb)
Audit Trails	11.10(e)	Timestamped, tamper-evident logs
Electronic Signatures	11.50	Digital signatures with meaning
Signature Linking	11.70	Cryptographic binding

9. Security Testing

9.1 Testing Schedule

Test Type	Frequency	Scope	Owner
SAST	Every PR	All code	CI/CD
DAST	Weekly	Staging	Security
Dependency Scan	Daily	All dependencies	CI/CD
Container Scan	Every build	All images	CI/CD
Penetration Test	Annual	Full platform	External
Red Team	Annual	Full org	External

9.2 Vulnerability Management

Severity	SLA	Action
Critical	24 hours	Immediate patch, incident process
High	7 days	Priority patch
Medium	30 days	Scheduled patch
Low	90 days	Backlog

10. Incident Response

10.1 Incident Classification

Level	Description	Response Time	Escalation
P1	Active breach, data exfiltration	15 min	CEO, Legal, Board
P2	Vulnerability exploitation	1 hour	CISO, Engineering Lead
P3	Suspicious activity	4 hours	Security Team
P4	Policy violation	24 hours	Manager

10.2 Breach Notification Timelines

Regulation	Timeline	Notify
GDPR	72 hours	Supervisory authority
HIPAA	60 days	HHS, affected individuals
LGPD	"reasonable time"	ANPD, affected individuals
SOX	Immediately	Audit committee
State laws	Varies (24h-90d)	State AG, affected individuals

Security Specification v1.0 — FP&A Platform Document ID: SEC-001 Classification: Confidential

1. Executive Summary​

Security Principles​

2. Threat Model​

2.1 Threat Actors​

2.2 Attack Vectors​

OWASP Top 10 (Web Application)​

AI/ML-Specific Threats​

2.3 Assets at Risk​

3. Security Architecture​

3.1 Network Security​

3.2 Defense in Depth Layers​

4. Authentication & Authorization​

4.1 Authentication Architecture​

4.2 Authorization (OpenFGA)​

4.3 Session Management​

5. Data Protection​

5.1 Encryption Standards​

5.2 Field-Level Encryption​

5.3 Data Masking​

6. Application Security​

6.1 Secure Coding Standards​

6.2 API Security​

7. AI/ML Security​

7.1 Prompt Injection Prevention​

7.2 Model Access Control​

8. Compliance Controls Mapping​

8.1 SOX Section 404​

8.2 HIPAA Technical Safeguards​

8.3 FDA 21 CFR Part 11​

9. Security Testing​

9.1 Testing Schedule​

9.2 Vulnerability Management​

10. Incident Response​

10.1 Incident Classification​

10.2 Breach Notification Timelines​