PyPI Security

Episode Deep Dive

Guests Introduction and Background

Mike Fiedler is the full-time PyPI Safety & Security Engineer at the Python Software Foundation (PSF). With over 30 years of software and systems engineering experience at companies like Datadog, Warby Parker, and MongoDB, Mike focuses on strengthening PyPI's security to protect the Python ecosystem from malicious packages and other supply chain threats. He also coordinates with many of the PSF’s security partners to ensure PyPI can respond rapidly to emerging issues.

What to Know If You’re New to Python

If you're new to Python and want to understand this conversation about securing packages, here are a few essentials:

• It’s common to install Python libraries with tools like pip, which download code from PyPI.org.
• Take a moment to double-check the library names to avoid installing lookalike or typo-squatted packages.
• Learn how virtual environments (via venv or other tools) help isolate and manage project dependencies safely.

Key Points and Takeaways

1) PyPI’s Upcoming 2FA Mandate

PyPI is requiring all publishers to enable two-factor authentication (2FA) by the end of 2023. This move helps safeguard package uploads from account hijacking and password reuse vulnerabilities. While 2FA won’t block every kind of phishing attack, it significantly raises the bar for attackers who rely on leaked or stolen credentials.

• Links and Tools:
  • PyPI.org
  • TOTP Authenticator Apps (example)
  • Security Keys (e.g., YubiKey)

2) Role of the PSF and Funding for Security

Mike explained how the PSF’s small full-time staff, aided by grants from AWS and others, can now focus directly on PyPI security issues. This includes continuous monitoring, rapid response to malicious packages, and building new features like organizations and enhanced malware reporting.

• Links and Tools:
  • Python Software Foundation

3) PyPI's Scale and Usage Stats

PyPI hosts nearly half a million projects and over 4 million releases, with over 740,000 user accounts. Mike noted that PyPI’s sheer size means any popular Python library can quickly reach millions of developers, making secure operations essential.

• Links and Tools:
  • Libraries.io – A resource for statistics on packages across ecosystems

4) Supply Chain Attacks and Typo-Squatting

A big risk in open-source ecosystems is malicious actors uploading “typo-squatted” or misleading packages (e.g., misspelling something like “Django” as “Dangu”). Attackers aim to trick users into installing malware by making package names look familiar or only slightly changed.

• Links and Tools:
  • XcodeGhost (example of supply chain attack)

5) Trusted Publishers with GitHub Actions

PyPI rolled out “trusted publishers,” using OpenID Connect to grant short-lived tokens to CI/CD services (like GitHub Actions) instead of manually storing long-lived API keys. This eliminates a large class of token-leak vulnerabilities and automatically verifies where the package build originates.

• Links and Tools:
  • GitHub Actions
  • PyPI Trusted Publisher Docs

6) Collaborating with Security Researchers

Mike highlighted how PyPI depends on security firms and volunteer researchers who constantly scan new packages, looking for suspicious patterns. Quick removal of newly flagged malicious uploads is a top priority, with PyPI often acting within an hour of a verified report.

• Links and Tools:
  • Report Inbound Malware Proposal – Mike’s blog post on shaping a new reporting standard

7) Human Factor in Security

Both Mike and Michael emphasized that “you, the human, are the best defender.” Phishing, domain expiration takeovers, and reusing passwords all remain major sources of compromise. Using password managers, scanning logs for suspicious activity, and employing mindful security practices go a long way to preventing attacks.

• Links and Tools:
  • 1Password
  • Bitwarden

8) Testing and Essential Tools

On the testing side, libraries like pytest remain central to Python’s developer culture. Plugins such as pytest-icdiff can improve clarity when comparing large data structures. The conversation also mentioned how scanning Python packages and checking for vulnerabilities should be part of standard development and testing workflows.

• Links and Tools:
  • pytest
  • pytest-icdiff
  • icdiff

Interesting Quotes and Stories

• On security trade-offs: “The most secure computer is one that’s powered off and buried in concrete—useless, but perfectly safe.”
• Human vigilance: “You, the human, are the best defender. Use your logic—don’t just click at things mindlessly.”
• Typo-squatting hazard: “I can’t prevent anyone from making a typo. But I can help remove packages once we know they’re malicious.”

Key Definitions and Terms

• 2FA (Two-Factor Authentication): Adds a second layer of identity verification, often using a one-time passcode or security key, in addition to a password.
• Typo-Squatting: Uploading malicious packages under names resembling popular packages (e.g., reqests for requests) to trick users who make spelling errors.
• Trusted Publishers (PyPI): A mechanism allowing short-lived CI/CD tokens to publish packages without storing permanent credentials.
• OpenID Connect: An identity layer on top of OAuth 2.0 used by PyPI for its trusted publisher feature, verifying a build environment’s identity.

Learning Resources

Below are a few in-depth learning materials to deepen your Python skills and better manage dependencies and security:

• Managing Python Dependencies: Learn how to handle Python dependencies effectively, avoid version conflicts, and understand best practices for safe package usage.

• Modern Python Projects: Covers the entire Python project lifecycle, from setting up a project structure to CI/CD, testing, and deployment—excellent for building secure, well-managed applications.

Overall Takeaway

Python’s ecosystem is thriving due to PyPI’s ease of publishing and installing packages. However, with so many packages and contributors, security can’t be taken for granted. The PSF and dedicated engineers like Mike Fiedler are working diligently—through 2FA, rapid malware takedowns, and features like trusted publishers—to protect the Python community. Staying vigilant yourself is key: use secure practices, enable 2FA, and always double-check what you’re installing.