@cclabsnz/sf-audit 1.3.0 → 1.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +101 -5
- package/lib/api/MetadataClient.d.ts +4 -0
- package/lib/api/MetadataClient.js +2 -0
- package/lib/api/MetadataClientImpl.d.ts +8 -0
- package/lib/api/MetadataClientImpl.js +22 -0
- package/lib/api/RestClient.d.ts +1 -0
- package/lib/api/RestClientImpl.d.ts +1 -0
- package/lib/api/RestClientImpl.js +6 -0
- package/lib/chains/CapabilityRegistry.js +19 -0
- package/lib/chains/namedChains.js +22 -0
- package/lib/checks/eventLogAccess.d.ts +14 -0
- package/lib/checks/eventLogAccess.js +33 -0
- package/lib/checks/impl/AuthProvidersCheck.d.ts +17 -0
- package/lib/checks/impl/AuthProvidersCheck.js +88 -0
- package/lib/checks/impl/ClassicSitesCheck.d.ts +17 -0
- package/lib/checks/impl/ClassicSitesCheck.js +65 -0
- package/lib/checks/impl/DataExportAccessCheck.d.ts +19 -0
- package/lib/checks/impl/DataExportAccessCheck.js +79 -0
- package/lib/checks/impl/EncryptionCoverageCheck.d.ts +19 -0
- package/lib/checks/impl/EncryptionCoverageCheck.js +108 -0
- package/lib/checks/impl/EventMonitoringCheck.js +8 -5
- package/lib/checks/impl/ExperienceCspCheck.d.ts +18 -0
- package/lib/checks/impl/ExperienceCspCheck.js +57 -0
- package/lib/checks/impl/ExternalCredentialsCheck.d.ts +17 -0
- package/lib/checks/impl/ExternalCredentialsCheck.js +74 -0
- package/lib/checks/impl/GuestApiAccessCheck.d.ts +19 -0
- package/lib/checks/impl/GuestApiAccessCheck.js +113 -0
- package/lib/checks/impl/GuestObjectExposureCheck.d.ts +44 -0
- package/lib/checks/impl/GuestObjectExposureCheck.js +241 -0
- package/lib/checks/impl/GuestRecordAccessPolicyCheck.d.ts +34 -0
- package/lib/checks/impl/GuestRecordAccessPolicyCheck.js +120 -0
- package/lib/checks/impl/GuestSiteOptionsCheck.d.ts +18 -0
- package/lib/checks/impl/GuestSiteOptionsCheck.js +92 -0
- package/lib/checks/impl/GuestTrafficAnomalyCheck.d.ts +23 -0
- package/lib/checks/impl/GuestTrafficAnomalyCheck.js +343 -0
- package/lib/checks/impl/LoginAccessPolicyCheck.d.ts +26 -0
- package/lib/checks/impl/LoginAccessPolicyCheck.js +117 -0
- package/lib/checks/impl/LoginAnomalyCheck.d.ts +17 -0
- package/lib/checks/impl/LoginAnomalyCheck.js +98 -0
- package/lib/checks/impl/SandboxDataMaskingCheck.d.ts +17 -0
- package/lib/checks/impl/SandboxDataMaskingCheck.js +85 -0
- package/lib/checks/impl/SessionHardeningCheck.d.ts +21 -0
- package/lib/checks/impl/SessionHardeningCheck.js +134 -0
- package/lib/checks/impl/ThreatDetectionCheck.d.ts +17 -0
- package/lib/checks/impl/ThreatDetectionCheck.js +91 -0
- package/lib/checks/registry.js +33 -0
- package/lib/commands/audit/diff.js +9 -5
- package/lib/commands/audit/events/pull.d.ts +17 -0
- package/lib/commands/audit/events/pull.js +88 -0
- package/lib/commands/audit/security.d.ts +4 -0
- package/lib/commands/audit/security.js +40 -16
- package/lib/compliance/mapping.js +27 -7
- package/lib/context/AuditCache.d.ts +3 -0
- package/lib/context/AuditContext.d.ts +2 -0
- package/lib/events/EventBaselineStore.d.ts +16 -0
- package/lib/events/EventBaselineStore.js +55 -0
- package/lib/events/eventLogQuery.d.ts +21 -0
- package/lib/events/eventLogQuery.js +34 -0
- package/lib/events/pullEventLogs.d.ts +51 -0
- package/lib/events/pullEventLogs.js +79 -0
- package/lib/findings/CheckMeta.js +16 -0
- package/lib/lib/wire.d.ts +2 -0
- package/lib/lib/wire.js +3 -0
- package/package.json +13 -2
package/README.md
CHANGED
|
@@ -2,12 +2,13 @@
|
|
|
2
2
|
|
|
3
3
|
A Salesforce CLI (`sf`) plugin that runs a complete, **read-only** security audit against any Salesforce org, risk-scores it with an A–F grade, and turns the result into a report your security team (or your client's) can act on.
|
|
4
4
|
|
|
5
|
-
- **
|
|
5
|
+
- **82 read-only checks** across identity, access, data, code, integrations, and monitoring
|
|
6
6
|
- **Attack-chain correlation:** links individual findings into named, multi-step attack scenarios
|
|
7
7
|
- **Compliance mapping:** every finding mapped to **source-verified** controls across 7 frameworks (OWASP, SOC 2, ISO/IEC 27001:2022, Security Benchmark for Salesforce, NZ Privacy Act, HISO 10029, NZISM)
|
|
8
8
|
- **Outputs:** a technical `html` / `md` / `json` report, or a branded, client-ready **executive report** (print-to-PDF) with priorities, remediation roadmap, and a compliance coverage matrix
|
|
9
9
|
- **History & diff:** archives each run and shows security-posture drift over time
|
|
10
|
-
-
|
|
10
|
+
- **Free event baseline:** `sf audit events pull` captures the org's free daily `EventLogFile` logs to local disk before the 1-day retention window drops them — no Event Monitoring / Shield add-on needed
|
|
11
|
+
- Strictly read-only (SOQL/Tooling/REST GETs + Metadata API reads); see [PERMISSIONS.md](PERMISSIONS.md) for the least-privilege access it needs
|
|
11
12
|
|
|
12
13
|
## Installation
|
|
13
14
|
|
|
@@ -31,7 +32,7 @@ sf plugins link .
|
|
|
31
32
|
sf audit security --target-org <orgAlias>
|
|
32
33
|
```
|
|
33
34
|
|
|
34
|
-
This runs all
|
|
35
|
+
This runs all 82 security checks against the target org and writes a report to the current directory.
|
|
35
36
|
|
|
36
37
|
### Options
|
|
37
38
|
|
|
@@ -41,7 +42,7 @@ This runs all 66 security checks against the target org and writes a report to t
|
|
|
41
42
|
| `--format` / `-f` | `html` | Output format(s), comma-separated: `html`, `md`, `json`, `executive` |
|
|
42
43
|
| `--output` / `-o` | `.` | Directory to write the report file |
|
|
43
44
|
| `--fail-on` | (none) | Exit with code 1 if any finding is at or above this severity: `CRITICAL`, `HIGH`, `MEDIUM`, `LOW` |
|
|
44
|
-
| `--checks` | *(all)* | Comma-separated check IDs to run instead of all
|
|
45
|
+
| `--checks` | *(all)* | Comma-separated check IDs to run instead of all 82 (e.g. `hardcoded-credentials,apex-sharing`) |
|
|
45
46
|
| `--scoring-config` | (none) | Path to a custom scoring config JSON file to override weights and grade thresholds |
|
|
46
47
|
| `--prepared-for` | (none) | Client name for the executive report cover line |
|
|
47
48
|
| `--branding` | (none) | Path to a `report-branding.json` to override CloudCounsel defaults (executive format) |
|
|
@@ -66,6 +67,10 @@ sf audit security --target-org myOrg --fail-on HIGH
|
|
|
66
67
|
# Run only specific checks
|
|
67
68
|
sf audit security --target-org myOrg --checks hardcoded-credentials,apex-sharing,guest-user-access
|
|
68
69
|
|
|
70
|
+
# Guest / Experience Cloud exposure sweep — the unauthenticated data-leak surface
|
|
71
|
+
# (bulk-read via UI API, guest-owned records defeating Private OWD, file access, self-reg, threat detection)
|
|
72
|
+
sf audit security --target-org myOrg --checks guest-user-access,guest-object-exposure,guest-site-options,guest-executable-apex,experience-cloud-site,threat-detection
|
|
73
|
+
|
|
69
74
|
# Use a custom scoring config (e.g. stricter weights for your org)
|
|
70
75
|
sf audit security --target-org myOrg --scoring-config ./my-scoring.json
|
|
71
76
|
```
|
|
@@ -97,7 +102,7 @@ The report file is written as `sf-audit-<orgId>-<timestamp>.<ext>` in the output
|
|
|
97
102
|
|
|
98
103
|
## What It Checks
|
|
99
104
|
|
|
100
|
-
The audit runs **
|
|
105
|
+
The audit runs **82 read-only checks**. Every finding is risk-rated (CRITICAL → INFO) and mapped to controls across the compliance frameworks (see [Compliance frameworks](#compliance-frameworks)). The checks are grouped into nine domains below.
|
|
101
106
|
|
|
102
107
|
### Org Health & Configuration
|
|
103
108
|
| Check | What it looks for |
|
|
@@ -122,6 +127,8 @@ The audit runs **66 read-only checks**. Every finding is risk-rated (CRITICAL
|
|
|
122
127
|
| Login IP Restrictions | Admin profiles missing IP ranges; connected apps with relaxed IP policy |
|
|
123
128
|
| Password & Session Policy | Password complexity, session timeout, and MFA gaps (from Health Check) |
|
|
124
129
|
| Certificate Expiry | Installed certificates nearing expiry (30 / 90 / 180-day thresholds) |
|
|
130
|
+
| Auth Providers & External IdPs | External Auth Providers and SAML SSO configs; flags social/JIT providers that can federate in or auto-provision users |
|
|
131
|
+
| Session & Clickjack Hardening | Clickjack, CSRF, XSS, and content-sniffing settings read authoritatively from SecuritySettings (Health Check cache fallback) with per-setting remediation |
|
|
125
132
|
|
|
126
133
|
### Users, Permissions & Privilege
|
|
127
134
|
| Check | What it looks for |
|
|
@@ -135,6 +142,8 @@ The audit runs **66 read-only checks**. Every finding is risk-rated (CRITICAL
|
|
|
135
142
|
| Separation of Duties | Toxic permission combinations a single user holds (e.g. Manage Users + Assign Permission Sets, Author Apex + Modify All Data) |
|
|
136
143
|
| Integration / Service Accounts | Non-human identity inventory and excess privilege |
|
|
137
144
|
| Inactive Users | Active licensed users with no login in 90+ days |
|
|
145
|
+
| Login-As & Delegated Administration | Delegated-admin groups (SOQL) and the "log in as any user" policy read from SecuritySettings — user-impersonation and scoped-escalation paths |
|
|
146
|
+
| Mass Data Export Access | Profiles/permission sets with Weekly Data Export, or API access combined with View/Modify All Data (bulk-exfil capability) |
|
|
138
147
|
|
|
139
148
|
### Data Access & Sharing
|
|
140
149
|
| Check | What it looks for |
|
|
@@ -145,6 +154,8 @@ The audit runs **66 read-only checks**. Every finding is risk-rated (CRITICAL
|
|
|
145
154
|
| Report Folder Public Access | Report folders any authenticated user can view |
|
|
146
155
|
| Field History Tracking | History tracking enabled on sensitive standard objects |
|
|
147
156
|
| Data Classification & Encryption | Field data classification usage and Shield Platform Encryption |
|
|
157
|
+
| Encryption Coverage for Sensitive Fields | Fields classified PII/PHI (ComplianceGroup) that are NOT encrypted at rest with Shield |
|
|
158
|
+
| Sandbox Data Masking | In sandboxes, populated PII fields (likely unmasked production data); advises running Data Mask |
|
|
148
159
|
| Flows Without Sharing | Active flows running in system context without sharing enforcement |
|
|
149
160
|
| Content Distribution Links | Public file links missing expiry or passwords, and stale records |
|
|
150
161
|
| Public Static Resources & Documents | Documents marked externally available (anonymous URL access) and static resources cached publicly |
|
|
@@ -153,8 +164,14 @@ The audit runs **66 read-only checks**. Every finding is risk-rated (CRITICAL
|
|
|
153
164
|
| Check | What it looks for |
|
|
154
165
|
|-------|------------------|
|
|
155
166
|
| Guest User Access | Object permissions and sharing rules granted to unauthenticated guests |
|
|
167
|
+
| Guest Object Exposure (Bulk Read via UI API) | Auto-discovers guest-readable objects (incl. records exposed by guest ownership despite a Private OWD), then grades them by actual UI-API reachability: objects the UI API models are CRITICAL (GraphQL-pullable), objects readable only in the sharing model but not UI-API-modelled (Calendar, AuthSession, etc.) are separated as MEDIUM, with UserRecordAccess as ground-truth read confirmation |
|
|
156
168
|
| Guest-Executable Apex | Apex that guest profiles can run, flagging `without sharing` classes |
|
|
157
169
|
| Experience Cloud Sites | Live sites with self-registration enabled and guest user presence |
|
|
170
|
+
| Experience Cloud Guest Site Options | Guest file access and guest member visibility on Experience Cloud sites |
|
|
171
|
+
| Secure Guest User Record Access | Verifies the "Secure guest user record access" enforcement is activated — the guardrail that stops guest-owned records defeating a Private OWD (complements Guest Object Exposure) |
|
|
172
|
+
| Guest API & Bulk Access | Guest users granted API Enabled or Bulk API Hard Delete — programmatic bulk read/delete for unauthenticated visitors |
|
|
173
|
+
| Classic Force.com Sites | Active classic (Visualforce) Sites and their guest users — an unauthenticated surface separate from Experience Cloud |
|
|
174
|
+
| Experience Cloud CSP & Lightning Web Security | Advises verifying Strict CSP and Lightning Web Security on live sites (not reliably API-readable) |
|
|
158
175
|
| CORS Allowlist | Wildcard or overly broad CORS allowlist origins |
|
|
159
176
|
| CSP Trusted Sites | Content Security Policy trusted sites with insecure HTTP (mixed-content) endpoints |
|
|
160
177
|
|
|
@@ -178,6 +195,7 @@ The audit runs **66 read-only checks**. Every finding is risk-rated (CRITICAL
|
|
|
178
195
|
| Connected App OAuth Scopes | Full OAuth-scope grants and infinite refresh-token policies |
|
|
179
196
|
| Inactive Connected Apps | Apps with no OAuth logins in the past 90 days |
|
|
180
197
|
| Named Credentials | Named credential inventory; credentials not referenced in Apex |
|
|
198
|
+
| External Credential Authentication | External Credentials using no authentication or a custom (non-standard) scheme |
|
|
181
199
|
| Remote Site Settings | Remote sites with protocol security disabled |
|
|
182
200
|
| Outbound Messages | Workflow outbound messages that include a session ID or post to cleartext (http://) endpoints |
|
|
183
201
|
| Email Security & Spoofing | Inbound email services accepting mail from any sender / running Apex unauthenticated, and org-wide send-as addresses open to all profiles |
|
|
@@ -199,8 +217,20 @@ The audit runs **66 read-only checks**. Every finding is risk-rated (CRITICAL
|
|
|
199
217
|
| Transaction Security Policies | Automated threat detection and response policies configured |
|
|
200
218
|
| Active Debug Log Traces | Active TraceFlag records capturing logs, including high-detail traces |
|
|
201
219
|
| Event Monitoring | Event Monitoring enabled with logs covering 30+ days |
|
|
220
|
+
| Threat Detection Event Storage | Guest User Anomaly / Threat Detection event storage enabled and retaining events |
|
|
221
|
+
| Guest Traffic Anomaly | Scans recent EventLogFile guest requests for anonymizer/hosting source IPs, single-IP bursts, and GraphQL `totalCount` reconnaissance sweeps |
|
|
222
|
+
| Anomalous Successful Logins | Accounts with successful logins from an unusually high number of distinct source IPs (credential-sharing / compromise signature) |
|
|
202
223
|
| SIEM Integration Signals | Evidence of SIEM or external monitoring integration |
|
|
203
224
|
|
|
225
|
+
### Known limitations (advisory-only checks)
|
|
226
|
+
|
|
227
|
+
A small number of checks emit an **advisory** rather than a pass/fail verdict because the underlying setting is not exposed to the read APIs this plugin uses (SOQL/Tooling/REST/Metadata read):
|
|
228
|
+
|
|
229
|
+
- **Experience Cloud CSP & Lightning Web Security** — the per-site LWR Content Security Policy level and the Lightning Web Security toggle live inside the site's `ExperienceBundle`, not in a `metadata.read`-able type. The check lists live Experience sites and asks for manual verification. A true detection would require retrieving and parsing the `ExperienceBundle` (retrieve → unzip → read `config/*.json`), which is a larger capability than the current read clients; it is tracked as a future enhancement.
|
|
230
|
+
- **"Administrators Can Log In as Any User"** is a true detection when SecuritySettings is readable; if the Metadata client is unavailable it degrades to a manual-verification advisory.
|
|
231
|
+
|
|
232
|
+
Advisory findings are surfaced as `INFO` and never inflate the health score.
|
|
233
|
+
|
|
204
234
|
## Compliance frameworks
|
|
205
235
|
|
|
206
236
|
Findings are mapped to controls across seven security and privacy frameworks. The mapping is built on a **sourced control catalog** (each control carries its framework, **pinned version**, official title, and a citation) so a finding's compliance reference ties to an exact, defensible requirement rather than a bare tag.
|
|
@@ -387,6 +417,72 @@ Diff report written: ./sf-audit-diff-00D000000000001-...-vs-....json
|
|
|
387
417
|
─────────────────────────────
|
|
388
418
|
```
|
|
389
419
|
|
|
420
|
+
## Free event baseline
|
|
421
|
+
|
|
422
|
+
Salesforce's free tier exposes **Daily-interval `EventLogFile` logs** (login, API, and error
|
|
423
|
+
activity) on Enterprise/Unlimited/Performance editions and Developer Edition — *without* the paid
|
|
424
|
+
Event Monitoring / Shield add-on. The catch: on the free tier those logs are retained for only
|
|
425
|
+
**~1 day**. Miss a day and that day's activity is gone.
|
|
426
|
+
|
|
427
|
+
`sf audit events pull` captures them to local disk before they expire, so a daily run builds a
|
|
428
|
+
rolling local baseline you own:
|
|
429
|
+
|
|
430
|
+
```bash
|
|
431
|
+
sf audit events pull --target-org myOrg
|
|
432
|
+
```
|
|
433
|
+
|
|
434
|
+
It queries whatever daily event types the org actually exposes, downloads each log's CSV body, and
|
|
435
|
+
saves it to `~/.sf/event-baseline/{orgId}/{EventType}/{LogDate}-{Id}.csv`, plus a per-run manifest.
|
|
436
|
+
It is **read-only** (GET only) and **idempotent**: any log already on disk is skipped, so it is safe
|
|
437
|
+
to run repeatedly. Run it once a day from cron or a scheduled GitHub Action and you beat the 1-day
|
|
438
|
+
retention window with a growing archive — no add-on required.
|
|
439
|
+
|
|
440
|
+
```bash
|
|
441
|
+
# Daily cron entry (07:15) — capture yesterday's logs
|
|
442
|
+
15 7 * * * sf audit events pull --target-org myOrg >> ~/.sf/event-baseline/pull.log 2>&1
|
|
443
|
+
```
|
|
444
|
+
|
|
445
|
+
**Flags:**
|
|
446
|
+
|
|
447
|
+
| Flag | Description | Default |
|
|
448
|
+
|------|-------------|---------|
|
|
449
|
+
| `--target-org` | Org alias or username | required |
|
|
450
|
+
| `--since` | Days of `LogDate` to request (`LAST_N_DAYS` window) | `1` |
|
|
451
|
+
| `--types` | Restrict to specific EventTypes, comma-separated (e.g. `Login,ApiTotalUsage`) | *(all available)* |
|
|
452
|
+
| `--output` / `-o` | Base directory to store logs under | `~/.sf/event-baseline` |
|
|
453
|
+
|
|
454
|
+
```bash
|
|
455
|
+
# Backfill the last 3 days (each still subject to the org's retention)
|
|
456
|
+
sf audit events pull --target-org myOrg --since 3
|
|
457
|
+
|
|
458
|
+
# Only pull login and API-usage logs
|
|
459
|
+
sf audit events pull --target-org myOrg --types Login,ApiTotalUsage
|
|
460
|
+
|
|
461
|
+
# Store under a project-local directory instead of ~/.sf
|
|
462
|
+
sf audit events pull --target-org myOrg --output ./event-baseline
|
|
463
|
+
```
|
|
464
|
+
|
|
465
|
+
> Reading `EventLogFile` requires the **View Event Log Files** permission on the running user (this
|
|
466
|
+
> is in addition to the minimum read-only audit permission set). If it is missing, or the edition
|
|
467
|
+
> does not expose free daily logs, the command exits cleanly with an explanation rather than failing.
|
|
468
|
+
|
|
469
|
+
**Example output:**
|
|
470
|
+
|
|
471
|
+
```
|
|
472
|
+
Pulling free EventLogFile logs for org: My Org (00D000000000001)
|
|
473
|
+
|
|
474
|
+
─────────────────────────────
|
|
475
|
+
Event Baseline Pull
|
|
476
|
+
─────────────────────────────
|
|
477
|
+
Found 7
|
|
478
|
+
Downloaded 7
|
|
479
|
+
Skipped 0 (already saved)
|
|
480
|
+
Total bytes 48213
|
|
481
|
+
─────────────────────────────
|
|
482
|
+
Saved to: ~/.sf/event-baseline/00D000000000001
|
|
483
|
+
Manifest: ~/.sf/event-baseline/00D000000000001/_manifests/manifest-...-....json
|
|
484
|
+
```
|
|
485
|
+
|
|
390
486
|
## Requirements
|
|
391
487
|
|
|
392
488
|
- Node.js 18+
|
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
import type { Connection } from '@salesforce/core';
|
|
2
|
+
import type { MetadataClient } from './MetadataClient.js';
|
|
3
|
+
export declare class MetadataClientImpl implements MetadataClient {
|
|
4
|
+
private readonly conn;
|
|
5
|
+
constructor(conn: Connection);
|
|
6
|
+
read<T = Record<string, unknown>>(type: string, fullName: string): Promise<T | null>;
|
|
7
|
+
}
|
|
8
|
+
//# sourceMappingURL=MetadataClientImpl.d.ts.map
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
export class MetadataClientImpl {
|
|
2
|
+
conn;
|
|
3
|
+
constructor(conn) {
|
|
4
|
+
this.conn = conn;
|
|
5
|
+
}
|
|
6
|
+
async read(type, fullName) {
|
|
7
|
+
// jsforce types `read` to a fixed MetadataType union; we pass through arbitrary
|
|
8
|
+
// type names (e.g. 'SecuritySettings'), so call via a loosened signature.
|
|
9
|
+
const read = this.conn.metadata.read.bind(this.conn.metadata);
|
|
10
|
+
const res = await read(type, fullName);
|
|
11
|
+
if (res == null)
|
|
12
|
+
return null;
|
|
13
|
+
const rec = Array.isArray(res) ? res[0] : res;
|
|
14
|
+
// Metadata.read returns an object with only `fullName`/empty fields when the
|
|
15
|
+
// component does not exist — treat that as "not present".
|
|
16
|
+
if (!rec || typeof rec !== 'object')
|
|
17
|
+
return null;
|
|
18
|
+
const keys = Object.keys(rec).filter((k) => k !== 'fullName');
|
|
19
|
+
return keys.length === 0 ? null : rec;
|
|
20
|
+
}
|
|
21
|
+
}
|
|
22
|
+
//# sourceMappingURL=MetadataClientImpl.js.map
|
package/lib/api/RestClient.d.ts
CHANGED
|
@@ -8,5 +8,11 @@ export class RestClientImpl {
|
|
|
8
8
|
const normalised = path.startsWith('/') ? path : `/${path}`;
|
|
9
9
|
return this.conn.request(`/services/data/v${version}${normalised}`);
|
|
10
10
|
}
|
|
11
|
+
async getRaw(path) {
|
|
12
|
+
const version = this.conn.getApiVersion();
|
|
13
|
+
const normalised = path.startsWith('/') ? path : `/${path}`;
|
|
14
|
+
// jsforce returns the raw body string for non-JSON content types (text/csv here).
|
|
15
|
+
return this.conn.request(`/services/data/v${version}${normalised}`);
|
|
16
|
+
}
|
|
11
17
|
}
|
|
12
18
|
//# sourceMappingURL=RestClientImpl.js.map
|
|
@@ -38,6 +38,25 @@ export const CAPABILITY_REGISTRY = {
|
|
|
38
38
|
'cors-wildcard-origin': { grants: ['credential-theft'] },
|
|
39
39
|
'cors-broad-origin': { grants: ['credential-theft'] },
|
|
40
40
|
'escalation-perms-found': { grants: ['priv-esc'] },
|
|
41
|
+
// Guest bulk-read surface (UI-API reachable) — the confirmed exfiltration sink
|
|
42
|
+
'guest-object-exposure-public-owd': { grants: ['unauth-foothold', 'data-read-bulk'] },
|
|
43
|
+
'guest-object-exposure-guest-owned': { grants: ['unauth-foothold', 'data-read-bulk'] },
|
|
44
|
+
// Observed guest recon in EventLogFile — an active unauthenticated foothold
|
|
45
|
+
'guest-traffic-anomaly-recon': { grants: ['unauth-foothold'] },
|
|
46
|
+
'guest-traffic-anomaly-anonymizer': { grants: ['unauth-foothold'] },
|
|
47
|
+
// Guest API/Bulk access — programmatic unauthenticated bulk read / destruction
|
|
48
|
+
'guest-api-access-enabled': { grants: ['unauth-foothold', 'data-read-bulk'] },
|
|
49
|
+
'guest-api-hard-delete': { grants: ['unauth-foothold', 'data-write'] },
|
|
50
|
+
// Classic Visualforce sites — a second unauthenticated foothold surface
|
|
51
|
+
'classic-sites-active': { grants: ['unauth-foothold'] },
|
|
52
|
+
// Mass data-export capability — a bulk-read sink for an authenticated actor
|
|
53
|
+
'data-export-weekly-export': { grants: ['data-read-bulk'] },
|
|
54
|
+
'data-export-bulk-api-viewall': { grants: ['data-read-bulk', 'data-write'] },
|
|
55
|
+
// Impersonation / delegated-admin escalation
|
|
56
|
+
'login-access-policy-delegated-admins': { grants: ['priv-esc'] },
|
|
57
|
+
'login-access-policy-login-as-enabled': { grants: ['priv-esc', 'data-read-bulk'] },
|
|
58
|
+
// External federation an attacker could ride in on
|
|
59
|
+
'auth-providers-social': { grants: ['low-trust-authenticated'] },
|
|
41
60
|
};
|
|
42
61
|
/** Resolve the effective capabilities for a finding (inline overrides registry; passed/inconclusive yield nothing). */
|
|
43
62
|
export function capabilitiesFor(finding) {
|
|
@@ -18,12 +18,33 @@ export const NAMED_CHAINS = [
|
|
|
18
18
|
const steps = byIds(active, [
|
|
19
19
|
'guest-user-read-access', 'guest-user-write-access', 'guest-user-sharing-exposure', 'guest-user-baseline',
|
|
20
20
|
'guest-executable-apex-unprotected', 'guest-executable-apex-exposed',
|
|
21
|
+
'guest-object-exposure-public-owd', 'guest-object-exposure-guest-owned',
|
|
22
|
+
'guest-api-access-enabled', 'guest-api-hard-delete', 'classic-sites-active',
|
|
21
23
|
'portal-exposed-apex-without-sharing', 'sharing-model-external-read', 'sharing-model-external-write',
|
|
22
24
|
'field-level-security-high', 'field-level-security-medium',
|
|
23
25
|
]);
|
|
24
26
|
return steps.length >= 2 ? steps : null;
|
|
25
27
|
},
|
|
26
28
|
},
|
|
29
|
+
{
|
|
30
|
+
id: 'active-guest-exfil',
|
|
31
|
+
title: 'Active guest reconnaissance against an exposed data surface',
|
|
32
|
+
severity: 'CRITICAL',
|
|
33
|
+
narrative: 'Live EventLogFile evidence shows unauthenticated guests probing from anonymizer/hosting IPs or ' +
|
|
34
|
+
'running GraphQL object-enumeration (totalCount) sweeps, AND the org exposes objects that are ' +
|
|
35
|
+
'bulk-readable by those same guests. This is not a theoretical exposure — it is reconnaissance ' +
|
|
36
|
+
'against a confirmed exfiltration surface, i.e. an incident likely already in progress.',
|
|
37
|
+
remediation: 'Treat as an active incident: block the source IPs at the WAF/CDN, close the guest bulk-read surface ' +
|
|
38
|
+
'(set external OWD to Private, strip guest object read, enforce "Secure guest user record access"), ' +
|
|
39
|
+
'and preserve/forward the event logs before the short EventLogFile retention window closes.',
|
|
40
|
+
match(_present, active) {
|
|
41
|
+
const traffic = byIds(active, ['guest-traffic-anomaly-recon', 'guest-traffic-anomaly-anonymizer']);
|
|
42
|
+
const exposure = byIds(active, ['guest-object-exposure-public-owd', 'guest-object-exposure-guest-owned']);
|
|
43
|
+
if (traffic.length === 0 || exposure.length === 0)
|
|
44
|
+
return null;
|
|
45
|
+
return [...traffic, ...exposure];
|
|
46
|
+
},
|
|
47
|
+
},
|
|
27
48
|
{
|
|
28
49
|
id: 'standard-to-takeover',
|
|
29
50
|
title: 'Standard user to org takeover',
|
|
@@ -39,6 +60,7 @@ export const NAMED_CHAINS = [
|
|
|
39
60
|
const steps = byIds(active, [
|
|
40
61
|
'sharing-model-external-read', 'sharing-model-external-write', 'guest-user-baseline',
|
|
41
62
|
'escalation-perms-found', 'users-author-apex', 'users-super-admin-combo',
|
|
63
|
+
'login-access-policy-delegated-admins', 'login-access-policy-login-as-enabled',
|
|
42
64
|
]);
|
|
43
65
|
return steps.length >= 2 ? steps : null;
|
|
44
66
|
},
|
|
@@ -0,0 +1,14 @@
|
|
|
1
|
+
import type { EventLogAccess } from '../context/AuditCache.js';
|
|
2
|
+
/**
|
|
3
|
+
* Classifies why an `EventLogFile` query failed so callers can tell the two very
|
|
4
|
+
* different "no data" causes apart:
|
|
5
|
+
* - 'not-enabled' : Event Monitoring is not licensed/enabled (EventLogFile is
|
|
6
|
+
* an unknown/blocked sObject) — the org captures nothing.
|
|
7
|
+
* - 'no-permission' : the feature is on, but the running audit user lacks the
|
|
8
|
+
* "View Event Log Files" permission — logs exist, we can't read them.
|
|
9
|
+
* - 'unknown' : could not be attributed to either.
|
|
10
|
+
* Both are BLIND for guest-traffic analysis, but the remediation differs (license
|
|
11
|
+
* vs. grant a permission), so the distinction is worth surfacing.
|
|
12
|
+
*/
|
|
13
|
+
export declare function classifyEventLogAccessError(err: unknown): EventLogAccess;
|
|
14
|
+
//# sourceMappingURL=eventLogAccess.d.ts.map
|
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
import { isApiError } from '../api/ApiError.js';
|
|
2
|
+
/**
|
|
3
|
+
* Classifies why an `EventLogFile` query failed so callers can tell the two very
|
|
4
|
+
* different "no data" causes apart:
|
|
5
|
+
* - 'not-enabled' : Event Monitoring is not licensed/enabled (EventLogFile is
|
|
6
|
+
* an unknown/blocked sObject) — the org captures nothing.
|
|
7
|
+
* - 'no-permission' : the feature is on, but the running audit user lacks the
|
|
8
|
+
* "View Event Log Files" permission — logs exist, we can't read them.
|
|
9
|
+
* - 'unknown' : could not be attributed to either.
|
|
10
|
+
* Both are BLIND for guest-traffic analysis, but the remediation differs (license
|
|
11
|
+
* vs. grant a permission), so the distinction is worth surfacing.
|
|
12
|
+
*/
|
|
13
|
+
export function classifyEventLogAccessError(err) {
|
|
14
|
+
if (isApiError(err)) {
|
|
15
|
+
if (err.statusCode === 403 || /ACCESS|INSUFFICIENT/i.test(err.errorCode))
|
|
16
|
+
return 'no-permission';
|
|
17
|
+
if (/INVALID_TYPE|NOT_FOUND|MALFORMED_QUERY/i.test(err.errorCode) || err.statusCode === 404 || err.statusCode === 400) {
|
|
18
|
+
return 'not-enabled';
|
|
19
|
+
}
|
|
20
|
+
}
|
|
21
|
+
const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
|
|
22
|
+
if (msg.includes('insufficient') || msg.includes('permission') || msg.includes('view event log'))
|
|
23
|
+
return 'no-permission';
|
|
24
|
+
if (msg.includes('not supported') ||
|
|
25
|
+
msg.includes('invalid type') ||
|
|
26
|
+
msg.includes("sobject type 'eventlogfile'") ||
|
|
27
|
+
msg.includes('not enabled') ||
|
|
28
|
+
msg.includes('licens')) {
|
|
29
|
+
return 'not-enabled';
|
|
30
|
+
}
|
|
31
|
+
return 'unknown';
|
|
32
|
+
}
|
|
33
|
+
//# sourceMappingURL=eventLogAccess.js.map
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
import type { AuditContext } from '../../context/AuditContext.js';
|
|
2
|
+
import type { SecurityCheck, CheckResult } from '../SecurityCheck.js';
|
|
3
|
+
/**
|
|
4
|
+
* Reviews external identity federation — Auth Providers and SAML SSO configs.
|
|
5
|
+
* Every configured provider is a way into the org that does not use a Salesforce
|
|
6
|
+
* password, so an unvetted or misconfigured provider (especially social login with
|
|
7
|
+
* just-in-time user creation) can let attackers federate in or auto-provision
|
|
8
|
+
* over-privileged users.
|
|
9
|
+
*/
|
|
10
|
+
export declare class AuthProvidersCheck implements SecurityCheck {
|
|
11
|
+
readonly id = "auth-providers";
|
|
12
|
+
readonly name = "Auth Providers & External IdPs";
|
|
13
|
+
readonly category = "Authentication";
|
|
14
|
+
readonly description = "Reviews configured Auth Providers and SAML SSO configurations \u2014 external login paths that bypass Salesforce credentials and can auto-provision users";
|
|
15
|
+
run(ctx: AuditContext): Promise<CheckResult>;
|
|
16
|
+
}
|
|
17
|
+
//# sourceMappingURL=AuthProvidersCheck.d.ts.map
|
|
@@ -0,0 +1,88 @@
|
|
|
1
|
+
// Consumer/social identity providers — higher risk when they can create users
|
|
2
|
+
// via just-in-time provisioning, because an attacker-controlled account at the
|
|
3
|
+
// provider becomes an org login.
|
|
4
|
+
const SOCIAL_TYPES = new Set(['Facebook', 'Google', 'Twitter', 'LinkedIn', 'GitHub', 'OpenIdConnect']);
|
|
5
|
+
/**
|
|
6
|
+
* Reviews external identity federation — Auth Providers and SAML SSO configs.
|
|
7
|
+
* Every configured provider is a way into the org that does not use a Salesforce
|
|
8
|
+
* password, so an unvetted or misconfigured provider (especially social login with
|
|
9
|
+
* just-in-time user creation) can let attackers federate in or auto-provision
|
|
10
|
+
* over-privileged users.
|
|
11
|
+
*/
|
|
12
|
+
export class AuthProvidersCheck {
|
|
13
|
+
id = 'auth-providers';
|
|
14
|
+
name = 'Auth Providers & External IdPs';
|
|
15
|
+
category = 'Authentication';
|
|
16
|
+
description = 'Reviews configured Auth Providers and SAML SSO configurations — external login paths that bypass Salesforce credentials and can auto-provision users';
|
|
17
|
+
async run(ctx) {
|
|
18
|
+
const findings = [];
|
|
19
|
+
const baseUrl = ctx.orgInfo.instanceUrl;
|
|
20
|
+
let providers = [];
|
|
21
|
+
let providersFailed = false;
|
|
22
|
+
try {
|
|
23
|
+
providers = await ctx.soql.queryAll('SELECT Id, DeveloperName, ProviderType, FriendlyName FROM AuthProvider');
|
|
24
|
+
}
|
|
25
|
+
catch {
|
|
26
|
+
providersFailed = true;
|
|
27
|
+
}
|
|
28
|
+
let saml = [];
|
|
29
|
+
try {
|
|
30
|
+
saml = await ctx.soql.queryAll('SELECT Id, DeveloperName, Issuer FROM SamlSsoConfig');
|
|
31
|
+
}
|
|
32
|
+
catch {
|
|
33
|
+
// SAML config not accessible / not configured — handled together with providers below.
|
|
34
|
+
}
|
|
35
|
+
if (providersFailed) {
|
|
36
|
+
findings.push({
|
|
37
|
+
id: 'auth-providers-inconclusive',
|
|
38
|
+
category: this.category,
|
|
39
|
+
riskLevel: 'INFO',
|
|
40
|
+
inconclusive: true,
|
|
41
|
+
title: 'Auth Providers could not be queried (insufficient access)',
|
|
42
|
+
detail: 'The AuthProvider object was not accessible, so external identity federation could not be evaluated.',
|
|
43
|
+
remediation: 'Grant the audit user View Setup and Configuration and re-run. Also review Setup → Auth. Providers and Single Sign-On Settings manually.',
|
|
44
|
+
});
|
|
45
|
+
return { findings };
|
|
46
|
+
}
|
|
47
|
+
const social = providers.filter((p) => SOCIAL_TYPES.has(p.ProviderType));
|
|
48
|
+
if (social.length > 0) {
|
|
49
|
+
findings.push({
|
|
50
|
+
id: 'auth-providers-social',
|
|
51
|
+
category: this.category,
|
|
52
|
+
riskLevel: 'MEDIUM',
|
|
53
|
+
title: `${social.length} social/consumer Auth Provider(s) configured`,
|
|
54
|
+
detail: 'Social and OpenID Connect auth providers let users authenticate with external consumer identities. If the registration handler provisions users just-in-time, an attacker who controls (or creates) an account at the provider may obtain an org login — potentially with a default profile that is more privileged than intended.',
|
|
55
|
+
remediation: 'Confirm each social provider is intentional, review its Apex registration handler for least-privilege user creation (and that it does not auto-activate high-privilege profiles), and disable providers that are not required.',
|
|
56
|
+
affectedItems: social.map((p) => ({ label: `${p.FriendlyName ?? p.DeveloperName} (${p.ProviderType})`, url: `${baseUrl}/lightning/setup/AuthProviders/home` })),
|
|
57
|
+
});
|
|
58
|
+
}
|
|
59
|
+
const nonSocial = providers.filter((p) => !SOCIAL_TYPES.has(p.ProviderType));
|
|
60
|
+
if (nonSocial.length > 0 || saml.length > 0) {
|
|
61
|
+
findings.push({
|
|
62
|
+
id: 'auth-providers-inventory',
|
|
63
|
+
category: this.category,
|
|
64
|
+
riskLevel: 'INFO',
|
|
65
|
+
title: `${nonSocial.length} other Auth Provider(s) and ${saml.length} SAML SSO config(s) configured`,
|
|
66
|
+
detail: 'These external identity paths let users sign in without a Salesforce password. Each SAML config and enterprise auth provider should be a known, trusted IdP with certificate validation and no stale/duplicate entries.',
|
|
67
|
+
remediation: 'Review each SAML SSO config (Issuer, signing certificate, and that "Just-in-time provisioning" creates least-privilege users) and each auth provider. Remove any that are unused or unrecognised.',
|
|
68
|
+
affectedItems: [
|
|
69
|
+
...nonSocial.map((p) => ({ label: `Auth Provider: ${p.FriendlyName ?? p.DeveloperName} (${p.ProviderType})`, url: `${baseUrl}/lightning/setup/AuthProviders/home` })),
|
|
70
|
+
...saml.map((s) => ({ label: `SAML: ${s.DeveloperName}${s.Issuer ? ` (${s.Issuer})` : ''}`, url: `${baseUrl}/lightning/setup/SingleSignOn/home` })),
|
|
71
|
+
].slice(0, 40),
|
|
72
|
+
});
|
|
73
|
+
}
|
|
74
|
+
if (providers.length === 0 && saml.length === 0) {
|
|
75
|
+
findings.push({
|
|
76
|
+
id: 'auth-providers-none',
|
|
77
|
+
category: this.category,
|
|
78
|
+
riskLevel: 'LOW',
|
|
79
|
+
passed: true,
|
|
80
|
+
title: 'No external Auth Providers or SAML SSO configured',
|
|
81
|
+
detail: 'No AuthProvider or SamlSsoConfig records exist, so there is no external federation surface to review.',
|
|
82
|
+
remediation: 'If external identity is added later, restrict just-in-time provisioning to least-privilege profiles and validate the IdP certificate.',
|
|
83
|
+
});
|
|
84
|
+
}
|
|
85
|
+
return { findings };
|
|
86
|
+
}
|
|
87
|
+
}
|
|
88
|
+
//# sourceMappingURL=AuthProvidersCheck.js.map
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
import type { AuditContext } from '../../context/AuditContext.js';
|
|
2
|
+
import type { SecurityCheck, CheckResult } from '../SecurityCheck.js';
|
|
3
|
+
/**
|
|
4
|
+
* Audits classic Force.com Sites (Visualforce sites), a public unauthenticated
|
|
5
|
+
* surface that runs in PARALLEL to Experience Cloud and is missed by the
|
|
6
|
+
* Network-based guest checks. Each active classic site has its own guest user
|
|
7
|
+
* whose profile can expose Apex, Visualforce pages, and objects to anonymous
|
|
8
|
+
* visitors (the vector behind classic `/apex/…` public pages).
|
|
9
|
+
*/
|
|
10
|
+
export declare class ClassicSitesCheck implements SecurityCheck {
|
|
11
|
+
readonly id = "classic-sites";
|
|
12
|
+
readonly name = "Classic Force.com Sites";
|
|
13
|
+
readonly category = "Access Control";
|
|
14
|
+
readonly description = "Flags active classic (Visualforce) Force.com Sites and their guest users \u2014 an unauthenticated public surface separate from Experience Cloud";
|
|
15
|
+
run(ctx: AuditContext): Promise<CheckResult>;
|
|
16
|
+
}
|
|
17
|
+
//# sourceMappingURL=ClassicSitesCheck.d.ts.map
|
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
// Classic (non-Experience-Builder) public site types. Siteforce = Experience
|
|
2
|
+
// Builder sites, which the Network-based guest checks already cover.
|
|
3
|
+
const CLASSIC_TYPES = new Set(['Visualforce', 'ChatterNetworkPicasso']);
|
|
4
|
+
/**
|
|
5
|
+
* Audits classic Force.com Sites (Visualforce sites), a public unauthenticated
|
|
6
|
+
* surface that runs in PARALLEL to Experience Cloud and is missed by the
|
|
7
|
+
* Network-based guest checks. Each active classic site has its own guest user
|
|
8
|
+
* whose profile can expose Apex, Visualforce pages, and objects to anonymous
|
|
9
|
+
* visitors (the vector behind classic `/apex/…` public pages).
|
|
10
|
+
*/
|
|
11
|
+
export class ClassicSitesCheck {
|
|
12
|
+
id = 'classic-sites';
|
|
13
|
+
name = 'Classic Force.com Sites';
|
|
14
|
+
category = 'Access Control';
|
|
15
|
+
description = 'Flags active classic (Visualforce) Force.com Sites and their guest users — an unauthenticated public surface separate from Experience Cloud';
|
|
16
|
+
async run(ctx) {
|
|
17
|
+
const findings = [];
|
|
18
|
+
const baseUrl = ctx.orgInfo.instanceUrl;
|
|
19
|
+
let sites;
|
|
20
|
+
try {
|
|
21
|
+
sites = await ctx.soql.queryAll('SELECT Id, Name, Status, SiteType, GuestUserId, MasterLabel FROM Site');
|
|
22
|
+
}
|
|
23
|
+
catch {
|
|
24
|
+
findings.push({
|
|
25
|
+
id: 'classic-sites-inconclusive',
|
|
26
|
+
category: this.category,
|
|
27
|
+
riskLevel: 'INFO',
|
|
28
|
+
inconclusive: true,
|
|
29
|
+
title: 'Force.com Sites could not be queried (insufficient access)',
|
|
30
|
+
detail: 'The Site object was not accessible, so classic public sites could not be evaluated. This may mean Sites is not enabled.',
|
|
31
|
+
remediation: 'Grant the audit user View Setup and Configuration and re-run. If Sites is not used, this check is not applicable.',
|
|
32
|
+
});
|
|
33
|
+
return { findings };
|
|
34
|
+
}
|
|
35
|
+
const classicActive = sites.filter((s) => CLASSIC_TYPES.has(s.SiteType) && s.Status === 'Active');
|
|
36
|
+
if (classicActive.length > 0) {
|
|
37
|
+
const withGuest = classicActive.filter((s) => s.GuestUserId);
|
|
38
|
+
findings.push({
|
|
39
|
+
id: 'classic-sites-active',
|
|
40
|
+
category: this.category,
|
|
41
|
+
riskLevel: 'HIGH',
|
|
42
|
+
title: `${classicActive.length} active classic (Visualforce) Force.com site(s)`,
|
|
43
|
+
detail: `Classic Force.com Sites serve pages to unauthenticated visitors through a dedicated guest user, separate from Experience Cloud. ${withGuest.length} of these have a guest user whose profile governs anonymous access to Apex, Visualforce pages, and objects. This surface is easy to forget because the guest/Experience-Cloud checks only inspect Experience (Network) sites.`,
|
|
44
|
+
remediation: 'For each active classic site, review the guest user profile (object/field permissions, guest-executable Apex, exposed VF pages) exactly as for Experience Cloud guests. Deactivate sites that are no longer needed. Re-run guest-object-exposure/guest-executable-apex to grade the exposure of these guest users.',
|
|
45
|
+
affectedItems: classicActive.slice(0, 30).map((s) => ({
|
|
46
|
+
label: `${s.MasterLabel ?? s.Name} (${s.SiteType}${s.GuestUserId ? ', guest user present' : ', no guest user'})`,
|
|
47
|
+
url: `${baseUrl}/lightning/setup/CustomDomains/home`,
|
|
48
|
+
})),
|
|
49
|
+
});
|
|
50
|
+
}
|
|
51
|
+
else {
|
|
52
|
+
findings.push({
|
|
53
|
+
id: 'classic-sites-ok',
|
|
54
|
+
category: this.category,
|
|
55
|
+
riskLevel: 'LOW',
|
|
56
|
+
passed: true,
|
|
57
|
+
title: 'No active classic Force.com sites',
|
|
58
|
+
detail: 'No active Visualforce Force.com Sites were found, so there is no classic unauthenticated site surface.',
|
|
59
|
+
remediation: 'If a classic site is activated later, review its guest user profile before it goes live.',
|
|
60
|
+
});
|
|
61
|
+
}
|
|
62
|
+
return { findings };
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
//# sourceMappingURL=ClassicSitesCheck.js.map
|
|
@@ -0,0 +1,19 @@
|
|
|
1
|
+
import type { AuditContext } from '../../context/AuditContext.js';
|
|
2
|
+
import type { SecurityCheck, CheckResult } from '../SecurityCheck.js';
|
|
3
|
+
/**
|
|
4
|
+
* Finds the profiles / permission sets that grant a bulk data-extraction
|
|
5
|
+
* capability — the mechanisms an attacker (or a departing insider) uses to
|
|
6
|
+
* exfiltrate en masse, which the report/sharing checks do not cover:
|
|
7
|
+
* - "Weekly Data Export" (PermissionsDataExport): full-org CSV export.
|
|
8
|
+
* - "API Enabled" combined with View/Modify All Data: unrestricted Bulk/REST pull
|
|
9
|
+
* of every record.
|
|
10
|
+
* The toxic combination (export or API + ViewAll) is graded highest.
|
|
11
|
+
*/
|
|
12
|
+
export declare class DataExportAccessCheck implements SecurityCheck {
|
|
13
|
+
readonly id = "data-export-access";
|
|
14
|
+
readonly name = "Mass Data Export Access";
|
|
15
|
+
readonly category = "Data Access Control";
|
|
16
|
+
readonly description = "Flags profiles/permission sets granting Weekly Data Export or API access combined with View/Modify All Data \u2014 the bulk data-exfiltration capability";
|
|
17
|
+
run(ctx: AuditContext): Promise<CheckResult>;
|
|
18
|
+
}
|
|
19
|
+
//# sourceMappingURL=DataExportAccessCheck.d.ts.map
|