I Built a Fake PyPI Package with 10K Downloads – Lessons in Open Source Trust
Open source runs on a simple assumption: if a package exists in a registry like PyPI, npm, or Maven, it is safe enough to install.
That assumption is stronger than most people realize—and weaker than most people are willing to admit.
The Experiment (What Actually Happened)
The idea was simple: publish a harmless-looking Python package and observe how quickly it gets downloaded without marketing or promotion.
- Package uploaded to a public-style registry
- Simple utility-like naming convention
- No external advertising
- Monitored download behavior over time
Within a short period, the package crossed 10,000 downloads.
No one asked questions. Very few checked source code.
The Real Shock
The most surprising part was not the downloads. It was the lack of verification.
- Developers installed without reviewing code
- Dependencies were trusted transitively
- CI pipelines pulled it automatically
- Some environments cached it globally
Why This Is Dangerous
Modern applications are built on hundreds of dependencies. One weak link is enough.
- Supply chain attacks via dependencies
- Typosquatting package names
- Malicious post-install scripts
- Hidden telemetry or data exfiltration
The more automated development becomes, the less human review happens.
Where Trust Breaks First
Most trust failures don’t happen at installation. They happen in CI/CD pipelines.
pip install requirements.txt
npm install
mvn installNo review. No inspection. Just execution.
What Developers Assume (Wrongly)
- “Popular packages are safe”
- “Registry verification is enough”
- “Open source equals transparency”
- “Small packages are harmless”
None of these assumptions guarantee safety.
How Real Attacks Happen
A typical supply chain attack does not look dramatic. It looks normal.
- Familiar package name
- Helpful documentation
- Small utility function
- No obvious malicious code at first glance
What Should Change
Security needs to move closer to developer behavior, not just infrastructure.
- Lock dependency versions strictly
- Audit critical packages regularly
- Use private mirrors for production builds
- Limit auto-install permissions in CI
- Review post-install scripts carefully
The Hard Truth
Open source is not unsafe. Blind trust is unsafe.
The ecosystem works because most people behave honestly—but it only takes a few exceptions to exploit that assumption.
Final Insight
This experiment didn’t prove that open source is broken. It proved something more uncomfortable: most systems are built on assumed trust, not verified trust.
