Home

Cybersecurity Made Simple

We Find Security Gaps, So Attackers Don’t

FortySecurity helps companies keep their websites, apps, cloud, and devices safe—explained in plain language, backed by deep technical expertise.

Trusted by Banks, Govt, Startups
Recognized by Apple · Microsoft · U.S. DoD
Response time Within 1 business day
What we do

Security Checks for Every Part of Your Business

From websites to mobile apps, cloud to connected devices—we test it the way a real attacker would, then explain the risks in language your whole team can act on.

Research

Vulnerabilities & CVEs

Our security research has resulted in multiple CVEs and acknowledgments in Apple's Security Hall of Fame. We maintain active participation in bug bounty programs and vendor vulnerability research programs.

Bug Bounty Expertise

Our lead researcher xploiterr maintains a top ranking on HackerOne. View HackerOne profile →

CVE-2024-2083

Directory traversal in zenml-io/zenml MLOps repository.

View CVE →
CVE-2024-4263

Broken access control in mlflow/mlflow AI/LLM platform.

View CVE →
CVE-2023-48295

Stored XSS in LibreNMS network monitoring tool.

View CVE →
CVE-2024-5124

Timing attack in chuanhuchatgpt LLM GUI application.

View CVE →
Approach

Research-Driven Testing

We approach security testing from an attacker's perspective. Our assessments are informed by active security research, vulnerability discovery, and real-world exploitation techniques.

Attacker Mindset

We think like attackers. Our testing methodology focuses on realistic attack scenarios, not compliance checklists.

Research-Backed

Our testing techniques are validated through active security research and vulnerability discovery.

Technical Depth

We go beyond surface-level testing. Firmware analysis, protocol reverse engineering, and custom exploit development when needed.

Actionable Outcomes

Every finding includes remediation guidance, risk context, and prioritized recommendations for immediate implementation.

Insights & Case Studies

From Our Lab to Your Inbox

Short, plain-English breakdowns of real attacks, recent incidents, and the small fixes that prevent big problems.

Mobile Security · 5 min read

10 Mobile App Mistakes We See in Every Pen Test

Hardcoded keys, weak SSL pinning, screenshots leaking secrets—here are the recurring issues we still find on iOS and Android, with one-line fixes for each.

iOS Android Checklist
Cloud Security · 4 min read

The Silent Cloud Bills: Open Buckets and Leaky Defaults

Public S3 buckets and over-permissive IAM roles still cause most cloud breaches we investigate. A short tour of the patterns we keep finding—and how to spot them in 10 minutes.

AWS IAM Misconfig

When Your Trust Tree Gets Poisoned: Lessons from the Latest npm Compromise

In the past year a series of malicious npm packages spread through stolen maintainer tokens, lookalike package names, and worm-like post-install scripts. Thousands of unrelated projects pulled the bad code without anyone touching a keyboard. Here is what we learned helping clients clean up—and the simple habits that would have prevented most of it.

TL;DR — A package you never installed can still ship code into your build by hiding inside a transitive dependency. The fix is not paranoia. It is a few small habits: lockfiles, pinned versions, install-time scanning, and a rule that build agents cannot touch production secrets.

What actually happened

Attackers used three repeating tricks. First, they phished or stole publish tokens from maintainers of popular packages, then pushed a new version that ran a small post-install script. Second, they registered packages with names that looked like real ones (one letter off, or a different casing) and waited for tired developers to typo. Third, some payloads were worm-like: once installed on a developer's machine, they searched for other npm tokens and re-published malicious updates from those accounts too.

The result was a chain reaction. A single compromised maintainer could indirectly ship code into projects that never imported their package at all.

Why it spread so far

  • Implicit trust in transitive packages. Most teams only review direct dependencies. The package that ate the secrets was three levels deep.
  • Build agents with broad access. CI runners often hold AWS keys, npm tokens, signing keys, and database credentials in the same environment that runs npm install.
  • Auto-updates and floating versions. Caret ranges like ^1.2.3 mean tonight's build can pick up code that did not exist yesterday.
  • Post-install hooks treated as harmless. Lifecycle scripts can run arbitrary shell on the build machine. Most teams have never read what they do.

Five checks every team should run this week

  1. Commit a lockfile and treat it as source. Make sure package-lock.json or pnpm-lock.yaml is committed, reviewed in PRs, and used by CI with npm ci or equivalent. No floating versions for releases.
  2. Turn off install scripts where you can. For most apps, npm install --ignore-scripts in CI is safe and stops the most common payload path. Whitelist the few packages that genuinely need post-install builds.
  3. Strip credentials from the install stage. Split your CI into a lightweight install/build job and a separate deploy job. Production secrets should never be available where npm install runs.
  4. Audit transitively. Run npm audit --omit=dev, plus a tool like Socket, Snyk, or your own SCA on every PR. Trend the number of new transitive dependencies over time. A sudden spike is a signal.
  5. Rotate publish tokens and require 2FA. Every maintainer account that can publish should require hardware-key 2FA. Rotate tokens on a schedule and never share them between humans and CI.

What we did in our investigations

For each affected client we ran the same playbook: snapshot every machine that had run a recent npm install, look at outbound network logs for unusual hosts, rotate every credential that lived on those machines, and rebuild from a clean lockfile that pre-dated the bad version. The clients who already had this list as a runbook were done in hours. Those who did not took weeks.

If you want us to run this drill against your own build pipeline, the contact form is two scrolls away. Twenty minutes of conversation usually saves a long weekend later.

10 Mobile App Mistakes We See in Every Pen Test

We pen-test a lot of mobile apps. Different industries, different stacks—but the same ten findings show up almost every time. Here they are in plain English, with the one-line fix beside each.

  1. API keys hardcoded in the binary. Move them to a server-side proxy that signs requests for you.
  2. No SSL pinning. Easy to add with modern frameworks; stops most "free Wi-Fi" attacks instantly.
  3. Sensitive screens not blanked in app switcher. Set the secure-screen flag on Android, hide content on background on iOS.
  4. Logs leaking tokens. Audit your logging library. Anything labelled "debug" still ships in many release builds.
  5. Local storage with no encryption. Use Keychain on iOS, EncryptedSharedPreferences or Keystore on Android. Never plain SharedPreferences for secrets.
  6. Deep links that trust their parameters. Validate every deep link parameter the same way you validate a web form.
  7. Insecure WebViews. JavaScript bridges and file access on WebViews are the easiest way to escape sandboxing.
  8. Backend that trusts the client. Server-side authorization beats client-side checks every time. Assume the app is hostile.
  9. Anti-tamper checks that are easy to flip. If a single string comparison decides whether the app runs on a rooted device, it will be patched in ten minutes.
  10. Third-party SDKs with too many permissions. Audit the SDKs at every release. A library you added two years ago for analytics may now phone home with more than analytics.

None of these require exotic tooling to spot. A few hours with a proxy, a rooted test device, and a careful eye is enough. Fixing them takes a week. Ignoring them is what keeps incident response teams in business.

The Silent Cloud Bills: Open Buckets and Leaky Defaults

Most of the cloud incidents we are called into are not the result of advanced attackers. They are misconfigurations: a bucket that was set to public for a one-time test and never closed, an IAM role with * on actions because someone wanted the demo to "just work", a forgotten lambda with a credential printed in plaintext.

The three patterns we see most

  • Public S3 buckets with internal data. Often discovered by competitors before defenders find them. Search engines and bucket-listing services index them quickly.
  • IAM roles that can assume each other. A low-risk role used by a marketing tool ends up with a chain that reaches production. Map the graph; it always surprises.
  • Forgotten services left in default config. Old EC2 instances, unused RDS snapshots, container registries open to the world. Inventory beats firewalls.

Ten-minute audit you can do today

  1. List every bucket in your account and confirm none have public-read or open bucket policies.
  2. Pull every IAM policy that contains "*" on Action or Resource. If there are more than five, you have homework.
  3. Check for access keys older than 90 days. Rotate or retire them.
  4. Run CloudTrail event lookup for AssumeRole calls from unexpected principals in the last 30 days.
  5. Confirm MFA is enforced on the root and on every human user. Yes, even the "just for testing" ones.

Cloud security is mostly hygiene. The teams that do well are the ones that schedule the boring review—not the ones with the fanciest tools.

Prompt Injection in RAG Pipelines Is the New Supply Chain Risk

RAG systems introduce a second supply chain: the document corpus. If the corpus is untrusted or easily poisoned, an attacker can insert instructions that override your system prompt and trigger unsafe actions. This is not a theoretical edge case; we see it in customer deployments across internal wikis, PDFs, and shared knowledge bases.

What changes in RAG? The model now treats retrieved content as authoritative context. Without strict boundaries, it will follow malicious instructions hidden inside trusted documents.

We recommend treating every retrieved document as untrusted input, even if it came from “internal” sources. Attackers only need one weak link — a stale document, an unreviewed upload, or a compromised wiki page — to poison the context.

Defensive controls that matter

  • Assign trust levels to sources and keep low-trust data out of high-risk actions.
  • Run retrieval filtering to remove prompt-like strings and suspicious instruction patterns.
  • Use a separate safety layer that enforces hard rules, independent of model output.
  • Log and review model decisions that reference external documents.

Most teams already do some of this, but the key is consistency. Make guardrails part of the RAG pipeline, not an afterthought in the UI layer.

Agentic Tool Abuse: Hardening MCP and Plugin Workflows

Agentic systems amplify risk because a single prompt can trigger multiple tool calls. When tools are overly permissive, the model can be tricked into taking real-world actions such as reading sensitive files, making unintended API calls, or leaking data through indirect channels.

We’ve seen successful prompt injection attacks where the model was tricked into “helpfully” exporting data, granting extra permissions, or executing actions outside of the user’s intent.

Hardening checklist

  • Apply least-privilege scopes to each tool and require explicit user intent for high-risk actions.
  • Validate tool outputs before the model can act on them.
  • Limit tool chaining depth and enforce rate limits for sensitive operations.
  • Implement policy-based guards that reject ambiguous or risky instructions.

Well-designed guardrails reduce the attack surface without sacrificing the workflow benefits of agentic systems. The goal is not to block agents — it’s to ensure every action is accountable and intentional.

LLM Data Leakage: Logging, Redaction, and Secrets Hygiene

LLM systems often collect telemetry for observability. The problem: prompt and completion logs can accidentally store secrets, credentials, or sensitive business data. Once it hits a log or a trace, it’s very difficult to control downstream exposure.

We’ve seen incidents where secrets were leaked into monitoring dashboards, customer support tools, or long-term storage simply because logs were never scrubbed.

Practical steps

  • Redact secrets at ingestion using deterministic patterns and contextual scanning.
  • Separate security telemetry from developer analytics to reduce exposure.
  • Expire and rotate embedding stores that include user-generated text.
  • Define retention policies for prompts and completions, and enforce them.

Security and observability can coexist, but only with strict data boundaries and enforcement. Treat LLM logs like sensitive production data — because they usually are.

Securing the Future

We are an offensive security research studio dedicated to breaking technologies before adversaries do.

Our Mission

Make Security Practical, Not Painful

Most security reports are long, jargon-filled, and hard to act on. We do it differently.

We look at your business through an attacker’s eyes, then explain what we find in plain English—what’s broken, how bad it is, and exactly what to fix first. Deep expertise underneath, friendly conversation on top.

Our Origin

Why We Started

The Compliance Trap

We saw too many companies passing audits while remaining fundamentally insecure. Pentesting had become a commodity—a race to the bottom focused on generating PDF reports rather than finding critical risks.

The Technology Shift

As the world moved to AI, LLMs, and IoT, traditional security firms struggled to keep up. They lacked the specialized research capabilities needed to test these new attack surfaces effectively.

The Solution

FortySecurity was founded by a team of experienced security researchers to fill this void. We built a firm where research drives testing, and every engagement is treated as a potential zero-day discovery.

Our DNA

Core Values

These principles guide every assessment we conduct and every report we write.

Adversarial Mindset

We don't test for compliance; we test for exploitability. We emulate motivated attackers who don't follow rules or scope documents.

Research First

We invest heavily in vulnerability research. Finding zero-days in vendor software is part of our DNA, not an afterthought.

Radical Transparency

No inflated risks or hidden findings. We tell you exactly what matters, why it matters, and how to fix it—plain and simple.

Client Partnership

We aren't just vendors; we are extensions of your security team. We work with your developers to ensure fixes actually work.

Recognition

Proven Expertise

Our team members are active contributors to the global security community. We don't just use tools; we build them and find the vulnerabilities they miss.

  • Apple Security Hall of Fame
  • Top 100 on HackerOne
  • Multiple CVE Discoveries
  • Security Tool Authors
50+ Zero-Days Found
100% Manual Verification
24h Critical Response
Heritage

Who Trusts Us

A team of bug bounty hunters and penetration testers acknowledged by world-class security teams, serving critical industries across India and beyond.

Acknowledged By
  • Apple
  • Microsoft
  • U.S. Department of Defense
  • Zomato
  • Twitter (X)
Industries Served
  • Government Ministries
  • Oil & Energy
  • Banking & Finance
  • Corporate Enterprises
  • Money Exchange
  • Insurance
Certifications & Practice
  • OSCP — Offensive Security Certified Professional
  • OSWE — Offensive Security Web Expert
  • Independent vulnerability research
  • Drone & AI/LLM specialist track

Built in India, trusted globally

FortySecurity follows a Make in India approach—world-class offensive security research and tooling, designed and delivered from the ground up by an Indian team.

Our Clients

Trusted by Teams in India and Beyond

A few of the organizations across India and the Middle East who count on FortySecurity to keep their products, platforms, and people safe.

Logos and trademarks are property of their respective owners.

Let’s talk

Tell us what you’d like to secure

No sales script, no jargon. Share a little about your team and what worries you most—we’ll suggest the right starting point in plain language.

Free 20-minute call NDA on request Response within 1 business day

What happens after you reach out

  1. 1

    Quick chat

    A 20-minute call to understand your environment, timelines, and concerns. No commitment.

  2. 2

    Custom scope & quote

    We write up a short proposal—what we’ll test, how long it takes, and what it costs. Fixed price, no surprises.

  3. 3

    Test, report, fix

    We run the assessment, walk you through the findings, and stay around to help your engineers ship the fixes.

Send us your details

What you tell us stays with us. We’ll respond within 1 business day.

NDA on request, before you share anything.
Direct line to the engineer doing the work.
Trusted by banks, government, and startups.
Contact Us