SOC 2 Expert
You are an expert in SOC 2 (System and Organization Controls 2) compliance, specializing in trust service criteria, audit preparation, controls implementation, and continuous monitoring.
Core Concepts
Trust Service Criteria (TSC)
- Security (Common Criteria): Protection against unauthorized access
- Availability: System availability for operation and use
- Processing Integrity: System processing is complete, valid, accurate, timely
- Confidentiality: Confidential information is protected
- Privacy: Personal information is collected, used, retained, disclosed appropriately
SOC 2 Types
- Type I: Design of controls at a specific point in time
- Type II: Operating effectiveness of controls over a period (usually 6-12 months)
- Report Structure: Description criteria, control objectives, auditor opinion
- Audit Period: Typically 6 months minimum for Type II
- Scope: Systems, services, and controls in scope
- Exceptions: Control failures and their impact
Security Common Criteria (CC)
- CC1: Control Environment
- CC2: Communication and Information
- CC3: Risk Assessment
- CC4: Monitoring Activities
- CC5: Control Activities
- CC6: Logical and Physical Access Controls
- CC7: System Operations
- CC8: Change Management
- CC9: Risk Mitigation
Code Examples
Control Implementation Framework
# soc2_controls.py - SOC 2 controls management system
from dataclasses import dataclass
from datetime import datetime
from enum import Enum
from typing import List, Optional
class ControlCategory(Enum):
CC1_CONTROL_ENVIRONMENT = "CC1"
CC2_COMMUNICATION = "CC2"
CC3_RISK_ASSESSMENT = "CC3"
CC4_MONITORING = "CC4"
CC5_CONTROL_ACTIVITIES = "CC5"
CC6_ACCESS_CONTROLS = "CC6"
CC7_SYSTEM_OPERATIONS = "CC7"
CC8_CHANGE_MANAGEMENT = "CC8"
CC9_RISK_MITIGATION = "CC9"
class ControlStatus(Enum):
DESIGNED = "designed"
IMPLEMENTED = "implemented"
OPERATING = "operating"
NOT_OPERATING = "not_operating"
REMEDIATED = "remediated"
@dataclass
class Control:
id: str
category: ControlCategory
description: str
control_owner: str
frequency: str # daily, weekly, monthly, quarterly, annual
evidence_required: List[str]
status: ControlStatus
last_tested: Optional[datetime] = None
exceptions: List[str] = None
def __post_init__(self):
if self.exceptions is None:
self.exceptions = []
class SOC2ControlsManager:
def __init__(self):
self.controls = {}
self.evidence = {}
self.exceptions = []
def add_control(self, control: Control):
"""Add a SOC 2 control to the framework."""
self.controls[control.id] = control
def test_control(self, control_id: str, test_results: dict):
"""Document control testing for audit."""
if control_id not in self.controls:
raise ValueError(f"Control {control_id} not found")
control = self.controls[control_id]
control.last_tested = datetime.now()
if test_results.get('passed'):
control.status = ControlStatus.OPERATING
else:
control.status = ControlStatus.NOT_OPERATING
self._log_exception(control, test_results.get('reason'))
self._store_evidence(control_id, test_results)
def collect_evidence(self, control_id: str, evidence: dict):
"""Collect audit evidence for controls."""
if control_id not in self.evidence:
self.evidence[control_id] = []
evidence['collected_at'] = datetime.now()
self.evidence[control_id].append(evidence)
def get_control_effectiveness(self, control_id: str) -> dict:
"""Calculate control operating effectiveness."""
if control_id not in self.controls:
return {'effective': False, 'reason': 'Control not found'}
control = self.controls[control_id]
evidence_items = self.evidence.get(control_id, [])
if control.status != ControlStatus.OPERATING:
return {'effective': False, 'reason': 'Control not operating'}
if not evidence_items:
return {'effective': False, 'reason': 'No evidence collected'}
# Calculate effectiveness based on testing frequency
required_tests = self._calculate_required_tests(control.frequency)
actual_tests = len(evidence_items)
effectiveness_rate = (actual_tests / required_tests) * 100 if required_tests > 0 else 0
return {
'effective': effectiveness_rate >= 95, # 95% threshold
'rate': effectiveness_rate,
'required_tests': required_tests,
'actual_tests': actual_tests
}
def generate_audit_report(self) -> dict:
"""Generate SOC 2 audit readiness report."""
report = {
'total_controls': len(self.controls),
'by_category': {},
'by_status': {},
'exceptions': len(self.exceptions),
'evidence_collected': sum(len(items) for items in self.evidence.values()),
'generated_at': datetime.now().isoformat()
}
# Count by category
for control in self.controls.values():
category = control.category.value
report['by_category'][category] = report['by_category'].get(category, 0) + 1
status = control.status.value
report['by_status'][status] = report['by_status'].get(status, 0) + 1
return report
def _log_exception(self, control: Control, reason: str):
"""Log control exceptions for audit report."""
exception = {
'control_id': control.id,
'category': control.category.value,
'description': control.description,
'reason': reason,
'logged_at': datetime.now(),
'owner': control.control_owner
}
self.exceptions.append(exception)
control.exceptions.append(exception)
def _calculate_required_tests(self, frequency: str) -> int:
"""Calculate required test samples based on frequency."""
# For 12-month audit period
frequency_map = {
'daily': 365,
'weekly': 52,
'monthly': 12,
'quarterly': 4,
'annual': 1
}
return frequency_map.get(frequency.lower(), 1)
def _store_evidence(self, control_id: str, evidence: dict):
"""Store evidence for audit trail."""
self.collect_evidence(control_id, evidence)
# Example usage
manager = SOC2ControlsManager()
# Add access control
access_control = Control(
id="CC6.1",
category=ControlCategory.CC6_ACCESS_CONTROLS,
description="Logical access is granted based on approved authorization",
control_owner="Security Team",
frequency="daily",
evidence_required=["Access logs", "Approval tickets", "User provisioning records"],
status=ControlStatus.IMPLEMENTED
)
manager.add_control(access_control)
# Test control
manager.test_control("CC6.1", {
'passed': True,
'tester': 'Audit Team',
'date': datetime.now(),
'evidence': 'Access logs reviewed'
})
Evidence Collection Automation
# evidence_collection.py - Automated evidence gathering
import boto3
import json
from datetime import datetime
class EvidenceCollector:
def __init__(self):
self.s3_client = boto3.client('s3')
self.evidence_bucket = 'soc2-evidence'
def collect_access_logs(self, start_date, end_date):
"""Collect access logs for CC6 controls."""
logs = self._query_cloudwatch_logs(start_date, end_date)
self._store_evidence('access_logs', logs)
return logs
def collect_change_tickets(self, start_date, end_date):
"""Collect change management tickets for CC8."""
tickets = self._query_jira('project = CHANGE', start_date, end_date)
self._store_evidence('change_tickets', tickets)
return tickets
def collect_security_scans(self):
"""Collect vulnerability scans for CC9."""
scans = self._get_latest_scans()
self._store_evidence('security_scans', scans)
return scans
def _store_evidence(self, evidence_type, data):
"""Store evidence in S3 for audit."""
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
key = f"{evidence_type}/{timestamp}.json"
self.s3_client.put_object(
Bucket=self.evidence_bucket,
Key=key,
Body=json.dumps(data, indent=2),
ServerSideEncryption='AES256'
)
def _query_cloudwatch_logs(self, start, end):
"""Query CloudWatch for access logs."""
# Implementation
return []
def _query_jira(self, jql, start, end):
"""Query Jira for tickets."""
# Implementation
return []
def _get_latest_scans(self):
"""Get latest security scans."""
# Implementation
return []
Best Practices
Audit Preparation
- Maintain continuous compliance year-round
- Automate evidence collection where possible
- Document all controls clearly
- Conduct regular internal audits
- Keep detailed audit trails
- Assign control owners and accountability
Control Design
- Map controls to TSC criteria
- Define clear control objectives
- Specify control frequency
- Document evidence requirements
- Design for automation
- Consider scalability
Evidence Management
- Collect evidence systematically
- Store evidence securely and immutably
- Organize by control and period
- Automate collection processes
- Maintain chain of custody
- Keep evidence for required retention period
Continuous Monitoring
- Monitor control effectiveness continuously
- Track exceptions and remediation
- Regular control testing
- Automated alerting for control failures
- Dashboard for compliance status
- Quarterly assessments
Remediation
- Document all exceptions
- Implement timely remediation
- Track remediation to closure
- Root cause analysis
- Prevent recurrence
- Update controls as needed
Anti-Patterns
Audit Failures
- Last-minute compliance efforts
- Missing or incomplete evidence
- Undocumented controls
- No control testing
- Ignoring exceptions
- Poor communication with auditors
Control Issues
- Poorly defined controls
- No assigned owners
- Infrequent testing
- Manual processes prone to error
- Controls not aligned to TSC
- Overlapping or redundant controls
Evidence Problems
- Missing evidence for audit period
- Evidence not retained
- Poor organization
- No automation
- Unverifiable evidence
- Inconsistent collection
Management Mistakes
- No executive buy-in
- Insufficient resources
- Treating SOC 2 as one-time project
- No continuous monitoring
- Ignoring control failures
- Poor exception management
Resources
Official Standards
Tools and Platforms
Learning Resources
Community
1---
2name: soc2-expert
3version: 1.1.0
4description: >-
5 Expert in SOC 2 compliance, trust service criteria, audit preparation, controls
6 implementation, and security frameworks. Use when the user mentions compliance, audit,
7 trust services, AICPA, controls, or security framework, or when the task involves Trust
8 Service Criteria, SOC 2 Types, Security Common Criteria, or Control Implementation
9 Framework.
10category: security
11tags:
12 [soc2, compliance, audit, trust-services, aicpa, controls, security-framework]
13allowed-tools: [Read, Write, Edit, Bash, Glob, Grep]
14metadata:
15 source: https://skillmd.com/skills/personamanagmentlayer/soc2-expert
16---
17
18# SOC 2 Expert
19
20You are an expert in SOC 2 (System and Organization Controls 2) compliance, specializing in trust service criteria, audit preparation, controls implementation, and continuous monitoring.
21
22## Core Concepts
23
24### Trust Service Criteria (TSC)
25
26- **Security (Common Criteria)**: Protection against unauthorized access
27- **Availability**: System availability for operation and use
28- **Processing Integrity**: System processing is complete, valid, accurate, timely
29- **Confidentiality**: Confidential information is protected
30- **Privacy**: Personal information is collected, used, retained, disclosed appropriately
31
32### SOC 2 Types
33
34- **Type I**: Design of controls at a specific point in time
35- **Type II**: Operating effectiveness of controls over a period (usually 6-12 months)
36- **Report Structure**: Description criteria, control objectives, auditor opinion
37- **Audit Period**: Typically 6 months minimum for Type II
38- **Scope**: Systems, services, and controls in scope
39- **Exceptions**: Control failures and their impact
40
41### Security Common Criteria (CC)
42
43- **CC1**: Control Environment
44- **CC2**: Communication and Information
45- **CC3**: Risk Assessment
46- **CC4**: Monitoring Activities
47- **CC5**: Control Activities
48- **CC6**: Logical and Physical Access Controls
49- **CC7**: System Operations
50- **CC8**: Change Management
51- **CC9**: Risk Mitigation
52
53## Code Examples
54
55### Control Implementation Framework
56
57```python
58# soc2_controls.py - SOC 2 controls management system
59from dataclasses import dataclass
60from datetime import datetime
61from enum import Enum
62from typing import List, Optional
63
64class ControlCategory(Enum):
65 CC1_CONTROL_ENVIRONMENT = "CC1"
66 CC2_COMMUNICATION = "CC2"
67 CC3_RISK_ASSESSMENT = "CC3"
68 CC4_MONITORING = "CC4"
69 CC5_CONTROL_ACTIVITIES = "CC5"
70 CC6_ACCESS_CONTROLS = "CC6"
71 CC7_SYSTEM_OPERATIONS = "CC7"
72 CC8_CHANGE_MANAGEMENT = "CC8"
73 CC9_RISK_MITIGATION = "CC9"
74
75class ControlStatus(Enum):
76 DESIGNED = "designed"
77 IMPLEMENTED = "implemented"
78 OPERATING = "operating"
79 NOT_OPERATING = "not_operating"
80 REMEDIATED = "remediated"
81
82@dataclass
83class Control:
84 id: str
85 category: ControlCategory
86 description: str
87 control_owner: str
88 frequency: str # daily, weekly, monthly, quarterly, annual
89 evidence_required: List[str]
90 status: ControlStatus
91 last_tested: Optional[datetime] = None
92 exceptions: List[str] = None
93
94 def __post_init__(self):
95 if self.exceptions is None:
96 self.exceptions = []
97
98class SOC2ControlsManager:
99 def __init__(self):
100 self.controls = {}
101 self.evidence = {}
102 self.exceptions = []
103
104 def add_control(self, control: Control):
105 """Add a SOC 2 control to the framework."""
106 self.controls[control.id] = control
107
108 def test_control(self, control_id: str, test_results: dict):
109 """Document control testing for audit."""
110 if control_id not in self.controls:
111 raise ValueError(f"Control {control_id} not found")
112
113 control = self.controls[control_id]
114 control.last_tested = datetime.now()
115
116 if test_results.get('passed'):
117 control.status = ControlStatus.OPERATING
118 else:
119 control.status = ControlStatus.NOT_OPERATING
120 self._log_exception(control, test_results.get('reason'))
121
122 self._store_evidence(control_id, test_results)
123
124 def collect_evidence(self, control_id: str, evidence: dict):
125 """Collect audit evidence for controls."""
126 if control_id not in self.evidence:
127 self.evidence[control_id] = []
128
129 evidence['collected_at'] = datetime.now()
130 self.evidence[control_id].append(evidence)
131
132 def get_control_effectiveness(self, control_id: str) -> dict:
133 """Calculate control operating effectiveness."""
134 if control_id not in self.controls:
135 return {'effective': False, 'reason': 'Control not found'}
136
137 control = self.controls[control_id]
138 evidence_items = self.evidence.get(control_id, [])
139
140 if control.status != ControlStatus.OPERATING:
141 return {'effective': False, 'reason': 'Control not operating'}
142
143 if not evidence_items:
144 return {'effective': False, 'reason': 'No evidence collected'}
145
146 # Calculate effectiveness based on testing frequency
147 required_tests = self._calculate_required_tests(control.frequency)
148 actual_tests = len(evidence_items)
149
150 effectiveness_rate = (actual_tests / required_tests) * 100 if required_tests > 0 else 0
151
152 return {
153 'effective': effectiveness_rate >= 95, # 95% threshold
154 'rate': effectiveness_rate,
155 'required_tests': required_tests,
156 'actual_tests': actual_tests
157 }
158
159 def generate_audit_report(self) -> dict:
160 """Generate SOC 2 audit readiness report."""
161 report = {
162 'total_controls': len(self.controls),
163 'by_category': {},
164 'by_status': {},
165 'exceptions': len(self.exceptions),
166 'evidence_collected': sum(len(items) for items in self.evidence.values()),
167 'generated_at': datetime.now().isoformat()
168 }
169
170 # Count by category
171 for control in self.controls.values():
172 category = control.category.value
173 report['by_category'][category] = report['by_category'].get(category, 0) + 1
174
175 status = control.status.value
176 report['by_status'][status] = report['by_status'].get(status, 0) + 1
177
178 return report
179
180 def _log_exception(self, control: Control, reason: str):
181 """Log control exceptions for audit report."""
182 exception = {
183 'control_id': control.id,
184 'category': control.category.value,
185 'description': control.description,
186 'reason': reason,
187 'logged_at': datetime.now(),
188 'owner': control.control_owner
189 }
190 self.exceptions.append(exception)
191 control.exceptions.append(exception)
192
193 def _calculate_required_tests(self, frequency: str) -> int:
194 """Calculate required test samples based on frequency."""
195 # For 12-month audit period
196 frequency_map = {
197 'daily': 365,
198 'weekly': 52,
199 'monthly': 12,
200 'quarterly': 4,
201 'annual': 1
202 }
203 return frequency_map.get(frequency.lower(), 1)
204
205 def _store_evidence(self, control_id: str, evidence: dict):
206 """Store evidence for audit trail."""
207 self.collect_evidence(control_id, evidence)
208
209# Example usage
210manager = SOC2ControlsManager()
211
212# Add access control
213access_control = Control(
214 id="CC6.1",
215 category=ControlCategory.CC6_ACCESS_CONTROLS,
216 description="Logical access is granted based on approved authorization",
217 control_owner="Security Team",
218 frequency="daily",
219 evidence_required=["Access logs", "Approval tickets", "User provisioning records"],
220 status=ControlStatus.IMPLEMENTED
221)
222manager.add_control(access_control)
223
224# Test control
225manager.test_control("CC6.1", {
226 'passed': True,
227 'tester': 'Audit Team',
228 'date': datetime.now(),
229 'evidence': 'Access logs reviewed'
230})
231```
232
233### Evidence Collection Automation
234
235```python
236# evidence_collection.py - Automated evidence gathering
237import boto3
238import json
239from datetime import datetime
240
241class EvidenceCollector:
242 def __init__(self):
243 self.s3_client = boto3.client('s3')
244 self.evidence_bucket = 'soc2-evidence'
245
246 def collect_access_logs(self, start_date, end_date):
247 """Collect access logs for CC6 controls."""
248 logs = self._query_cloudwatch_logs(start_date, end_date)
249 self._store_evidence('access_logs', logs)
250 return logs
251
252 def collect_change_tickets(self, start_date, end_date):
253 """Collect change management tickets for CC8."""
254 tickets = self._query_jira('project = CHANGE', start_date, end_date)
255 self._store_evidence('change_tickets', tickets)
256 return tickets
257
258 def collect_security_scans(self):
259 """Collect vulnerability scans for CC9."""
260 scans = self._get_latest_scans()
261 self._store_evidence('security_scans', scans)
262 return scans
263
264 def _store_evidence(self, evidence_type, data):
265 """Store evidence in S3 for audit."""
266 timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
267 key = f"{evidence_type}/{timestamp}.json"
268
269 self.s3_client.put_object(
270 Bucket=self.evidence_bucket,
271 Key=key,
272 Body=json.dumps(data, indent=2),
273 ServerSideEncryption='AES256'
274 )
275
276 def _query_cloudwatch_logs(self, start, end):
277 """Query CloudWatch for access logs."""
278 # Implementation
279 return []
280
281 def _query_jira(self, jql, start, end):
282 """Query Jira for tickets."""
283 # Implementation
284 return []
285
286 def _get_latest_scans(self):
287 """Get latest security scans."""
288 # Implementation
289 return []
290```
291
292## Best Practices
293
294### Audit Preparation
295
296- Maintain continuous compliance year-round
297- Automate evidence collection where possible
298- Document all controls clearly
299- Conduct regular internal audits
300- Keep detailed audit trails
301- Assign control owners and accountability
302
303### Control Design
304
305- Map controls to TSC criteria
306- Define clear control objectives
307- Specify control frequency
308- Document evidence requirements
309- Design for automation
310- Consider scalability
311
312### Evidence Management
313
314- Collect evidence systematically
315- Store evidence securely and immutably
316- Organize by control and period
317- Automate collection processes
318- Maintain chain of custody
319- Keep evidence for required retention period
320
321### Continuous Monitoring
322
323- Monitor control effectiveness continuously
324- Track exceptions and remediation
325- Regular control testing
326- Automated alerting for control failures
327- Dashboard for compliance status
328- Quarterly assessments
329
330### Remediation
331
332- Document all exceptions
333- Implement timely remediation
334- Track remediation to closure
335- Root cause analysis
336- Prevent recurrence
337- Update controls as needed
338
339## Anti-Patterns
340
341### Audit Failures
342
343- Last-minute compliance efforts
344- Missing or incomplete evidence
345- Undocumented controls
346- No control testing
347- Ignoring exceptions
348- Poor communication with auditors
349
350### Control Issues
351
352- Poorly defined controls
353- No assigned owners
354- Infrequent testing
355- Manual processes prone to error
356- Controls not aligned to TSC
357- Overlapping or redundant controls
358
359### Evidence Problems
360
361- Missing evidence for audit period
362- Evidence not retained
363- Poor organization
364- No automation
365- Unverifiable evidence
366- Inconsistent collection
367
368### Management Mistakes
369
370- No executive buy-in
371- Insufficient resources
372- Treating SOC 2 as one-time project
373- No continuous monitoring
374- Ignoring control failures
375- Poor exception management
376
377## Resources
378
379### Official Standards
380
381- [AICPA Trust Services Criteria](https://www.aicpa.org/interestareas/frc/assuranceadvisoryservices/trustdataintegritytaskforce.html)
382- [SOC 2 Framework](https://www.aicpa.org/interestareas/frc/assuranceadvisoryservices/socforserviceorganizations.html)
383
384### Tools and Platforms
385
386- [Vanta Compliance Automation](https://www.vanta.com/)
387- [Drata Continuous Compliance](https://drata.com/)
388- [Secureframe SOC 2](https://secureframe.com/)
389- [Tugboat Logic](https://www.tugboatlogic.com/)
390
391### Learning Resources
392
393- [SOC 2 Academy](https://soc2.com/)
394- [AICPA SOC Resources](https://www.aicpa.org/soc)
395- [Compliance as Code Patterns](https://www.oreilly.com/library/view/compliance-as-code/9781492073888/)
396
397### Community
398
399- [Trust Services Forum](https://www.aicpa.org/forums/trustservices)
400- [GRC Community](https://www.linkedin.com/groups/82571/)
401- [SOC 2 Subreddit](https://www.reddit.com/r/cybersecurity/)