Security scanning for
GitHub and GitLab repositories.

Strata scans your source code for hardcoded secrets, sensitive files committed to version control, SAST vulnerability patterns, and dependencies with known CVEs — across GitHub, GitLab, and ZIP archives. Findings are severity-ranked with file-level evidence, OWASP mapping, and actionable remediation guidance.

GitHub & GitLab
Public and private repos
35 secret rules
Entropy-filtered detection
OWASP Top 10 2021
SAST + dep vulnerability mapping

Four passes. One scan.

Source code analysis that covers the whole attack surface

Repository security issues fall into four distinct categories that traditional code review rarely catches systematically: secrets that should never have been committed, sensitive files that were added accidentally, vulnerability patterns in application code, and third-party dependencies with known CVEs.

Strata runs all four passes on every scan. For GitHub and GitLab, it performs a depth-1 shallow clone, so only the current files are scanned and no repository history is stored. For private repositories, the token from your connected account is handed to git through a temporary askpass helper and never appears in process arguments or logs.

SAST results are regex-based heuristics that flag suspicious patterns for human review. They are not semantic analysis and do not perform data-flow or taint tracking. Confidence levels and evidence snippets are included so reviewers can triage quickly.

GitHub, GitLab, and ZIP archive sources
Private repos via a connected GitHub or GitLab account (OAuth), never logged
Up to 5,000 files per scan, 256 KB per file
node_modules, vendor, build artifacts automatically skipped
acme-corp/payments — scan results
CRITICAL
src/aws/client.py:14
aws access key id
CRITICAL
deploy/certs/server.pem:1
private key material
CRITICAL
infra/terraform.tfstate
terraform state
CRITICAL
config/settings.js:31
stripe live secret key
HIGH
.env.production
env file
HIGH
app/database.py:8
database url with credentials
CRITICAL
scripts/deploy.sh:5
github personal access token
+ SAST findings · dependency CVEs

What Strata finds in real repositories

These are the most frequently discovered security issues in source code repositories — each detectable by Strata without running the application.

HIGH

.env files committed to the repository

Environment files committed to a repository expose every credential in them to everyone with access, and deleting the file later does not remove it from git history. Strata detects .env and .env.* files in the current tree and flags them as High severity findings.

CRITICAL

Cloud credentials hardcoded in source files

AWS access keys, GCP service account JSON, Azure connection strings, and GitHub tokens hardcoded in source files are detectable by anyone who can read the repository. Strata uses 35 targeted rules with Shannon entropy filtering to minimize false positives.

CRITICAL

Terraform state files committed

Terraform .tfstate files contain the complete configuration of deployed infrastructure in plaintext — including all resource attributes, database passwords, and access tokens written by providers. Strata flags these as Critical regardless of content.

HIGH

SQL injection patterns in application code

String concatenation and f-strings inside SQL execute() calls are a reliable injection indicator across Python, JavaScript, and Java codebases. Strata's SAST rules detect these patterns at the file and line level — results are heuristic and require human review to confirm.

HIGH

Dependencies with known CVEs

npm, PyPI, and Maven packages are cross-referenced against the OSV.dev vulnerability database. Each finding includes the CVE or advisory ID, severity, and the version to upgrade to when the advisory lists one.

HIGH

Weak cryptography in application code

MD5 and SHA-1 hashing, DES/RC4 cipher usage, ECB mode, and java.util.Random are all detectable from source. Strata maps each to OWASP A02:2021 (Cryptographic Failures) and CWE.

What Strata checks

Every check runs automatically on every repository scan.

🔑

Secret scanning

35 rules · entropy filtering · placeholder detection
AWS access key IDs (AKIA/ASIA/AROA) and secret access keys
Azure storage keys, client secrets, and Service Bus connection strings
GCP API keys, OAuth client secrets, and service account private key JSON
GitHub PATs (ghp_, github_pat_) and OAuth tokens
GitLab PATs (glpat-) and OAuth tokens
Stripe live and test secret and restricted keys
Slack bot, app, and user tokens
SendGrid, Twilio, Mailgun, and npm tokens
Private key material (RSA, EC, DSA, OPENSSH, PGP)
JWT signing secrets and JWT tokens
Database URLs with embedded credentials (Postgres, MySQL, MongoDB, Redis)
Generic API keys, tokens, and hardcoded passwords
🗂

Sensitive files

22 file patterns · current files only
.env and .env.* files committed to the repository
SSH private keys: id_rsa, id_ecdsa, id_ed25519, id_dsa
Terraform state files (.tfstate) — contain all infrastructure secrets
Terraform variable files (.tfvars)
GCP service account key files (service_account*.json)
PEM certificate and key files
Java keystores (.jks, .p12, .pfx)
Database config files and WordPress wp-config.php
.htpasswd, .pgpass, .netrc credential files
credentials.json, secrets.yml, secrets.json
Shell history files (.bash_history, .zsh_history)
🛡

SAST — injection & execution

Python · JavaScript · TypeScript · Java · Kotlin
SQL injection — f-strings and .format() in Python execute()
SQL injection — template literals and concatenation in JS/TS query()
SQL injection — Statement (not PreparedStatement) in Java/Kotlin
Command injection — os.system(), subprocess(shell=True), os.popen()
Command injection — exec()/execSync() with dynamic strings in JS/TS
Command injection — Runtime.exec() and ProcessBuilder with concatenation
SSRF — requests/urllib with user-controlled URLs (Python)
SSRF — fetch()/axios() with request-derived URLs (JS/TS)
SSRF — new URL(getParameter()) in Java servlets
⚠️

SAST — code quality & crypto

Python · JavaScript · TypeScript · Java · Kotlin · Swift
XSS — innerHTML/outerHTML assignment in JavaScript/TypeScript
XSS — eval() with external data, document.write(), dangerouslySetInnerHTML
XSS — mark_safe()/Markup() bypass in Python templates
XSS — unescaped getParameter() write in Java servlets
Insecure deserialization — pickle.loads(), yaml.load() without SafeLoader, marshal
Insecure deserialization — Java ObjectInputStream and XMLDecoder
Weak cryptography — MD5/SHA-1/DES/RC4/ECB across Python, JS, Java, Swift
Weak randomness: java.util.Random use in Java and Kotlin
Hardcoded Basic Auth, JDBC credentials, and Swift Keychain literals
📦

Dependency vulnerabilities

OSV.dev · CVEs · advisories
npm: package-lock.json, yarn.lock, pnpm-lock.yaml, and package.json
PyPI: requirements.txt, poetry.lock, Pipfile.lock
Maven: pom.xml and build.gradle / build.gradle.kts
Cross-references up to 5,000 packages per scan against the OSV.dev database
Returns CVE IDs, advisory IDs, severity, and the fixed version when the advisory lists one
No API key required — open vulnerability database
🏗️

IaC misconfiguration checks

Dockerfile · Docker Compose · GitHub Actions
Dockerfile — container running as root, unpinned base images, secrets in build inputs
Dockerfile — remote content piped to a shell, disabled TLS verification, remote ADD URLs
Docker Compose — privileged containers, mounted Docker socket, host network namespace
Docker Compose — dangerous Linux capabilities, hardcoded credentials, exposed database ports
GitHub Actions — pull_request_target workflows that check out pull-request head code
GitHub Actions — unsafe event data in shell steps, unpinned actions, secrets printed to logs
16 rules today — Terraform, CloudFormation, and Kubernetes are not yet covered
🌐

Language detection

20+ languages detected across the repository
Python, JavaScript, TypeScript, Java, Kotlin, Go, Rust
Ruby, PHP, C#, C++, C, Swift, Objective-C, Dart
Shell, PowerShell, SQL, HTML, CSS/SCSS
Configuration formats: JSON, YAML, TOML, Terraform
File count and language breakdown reported with every scan
Up to 5,000 files scanned, 256 KB per file

From repository to remediation

Paste a URL, get findings. Track them to resolution.

01

Connect or upload

Paste a public GitHub or GitLab URL, or pick a private repository from your connected GitHub or GitLab account (OAuth). The token is handed to git through a temporary askpass helper so it never appears in process arguments. Or upload a ZIP archive of up to 20 MB.

02

Shallow clone & scan

Strata performs a depth-1 shallow clone, walks up to 5,000 files (skipping node_modules, vendor, build artifacts, and binaries), and runs the scan passes in sequence: secrets, sensitive files, SAST, and dependency analysis.

03

Review ranked findings

Findings are ranked by severity — Critical through Low — with file path, line number, evidence snippet, OWASP category, CWE reference, and specific remediation guidance. SAST results note that patterns are heuristic and require human confirmation.

04

Triage with lifecycle

Move findings through Open, Confirmed, Fixed, Accepted Risk, False Positive or Suppressed. Add notes, mark false positives, and record the rationale for accepted risks. History is preserved across rescans.

05

Export and report

On Pro and Team, generate a PDF report with executive summary, severity breakdown, OWASP Top 10 coverage, and per-finding evidence, suitable for engineering handoff, compliance documentation, or client delivery.

Works where your code lives

GitHub, GitLab, and your CI/CD pipeline

Strata connects directly to GitHub and GitLab, public and private repositories. Public repositories need only a URL. For private repositories, connect your GitHub or GitLab account once through OAuth, then pick the repository and scan.

For teams that want scanning as part of the development lifecycle, Strata's CI/CD API (Team plan) triggers scans from your pipeline, and scheduled scans (Pro and Team) rerun a repository daily, weekly or monthly. Every run lands in the same risk dashboard with full findings history. See CI/CD security scanning for GitHub Actions and GitLab CI setup.

The risk dashboard gives you a cross-project view of findings by severity, status, and project. Track which projects have unresolved Critical or High findings and measure remediation progress over time.

GitHub.com and GitLab.com — public and private repositories
API-triggered scans for CI/CD pipeline integration
Scheduled scans: daily, weekly, or monthly
Risk dashboard: cross-project findings overview
Findings lifecycle tracks remediation status across scans
Source
🐙
GitHub
github.com repos, public and private
🦊
GitLab
gitlab.com repos, public and private
📦
ZIP archive
Upload a source code ZIP up to 20 MB
Triggers
⚡
On demand
Scan any time via UI or API
🔄
Scheduled
Daily, weekly or monthly automated scans
🔗
CI/CD triggered
API integration for PR pipelines

Common Questions

No. Strata performs a depth-1 shallow clone to run the scan, and no repository history is stored. For private repositories, the access token is handed to git through a temporary askpass helper, so it never appears in process arguments or logs.
No. SAST results are regex-based heuristics that flag suspicious patterns for human review — they are not semantic analysis and do not perform data-flow or taint tracking. Each finding includes confidence level and evidence so a reviewer can triage quickly.
Yes, on the Pro and Team plans. Connect your GitHub or GitLab account once (OAuth), and Strata uses that connection to clone private repositories. The token is handed to git through a temporary askpass helper, so it never appears in process arguments, logs, or stored scan data.
Yes. On the Team plan, repository scans can trigger automatically from GitHub Actions or GitLab CI on push and pull request events, and on Pro and Team you can schedule daily, weekly or monthly scans, in addition to running manually from the dashboard. See CI/CD security scanning for setup details.

See Strata in action

Watch a walkthrough of the platform — from upload to full security report.

Demo video coming soon

Get a personalized walkthrough of Strata — we will cover your specific workflow live.

Request a Demo →

Scan your first repository
in under 60 seconds.

Free to start: paste a public GitHub or GitLab URL and get a full security report. Upgrade to Pro for 25 scans a day, private repositories, and scheduled scans, or to Team for unlimited scans and CI/CD integration.

Review your own repository controls: try the Repository Security Review.
Need deeper manual review? Strata also offers an Application Security Assessment — expert-led engagements that complement automated scanning.