npm package.json Security Best Practices in 2026: Lifecycle Scripts, Lockfile Integrity, Overrides & Provenance GuideMeilleures Pratiques de Sécurité package.json npm en 2026 : Scripts Lifecycle, Intégrité Lockfile, Overrides & Guide Provenance

On March 31, 2026, the official axios package — present in roughly 80% of cloud environments and downloaded over 100 million times per week — was hijacked. The attacker had compromised the lead maintainer's npm account and published two malicious versions. The payload? A postinstall hook in package.json that silently installed a cross-platform remote access trojan. No CVE was issued before the attack. No audit tool caught it ahead of time. The attack vector was a single lifecycle script field in a manifest file that developers generate with npm init and rarely scrutinize after that.

Le 31 mars 2026, le package officiel axios — présent dans environ 80% des environnements cloud et téléchargé plus de 100 millions de fois par semaine — a été piraté. L'attaquant avait compromis le compte npm du mainteneur principal et publié deux versions malveillantes. La charge utile ? Un hook postinstall dans package.json qui installait silencieusement un cheval de Troie d'accès à distance multiplateforme. Aucun CVE n'avait été émis avant l'attaque. Aucun outil d'audit ne l'a détecté à l'avance. Le vecteur d'attaque était un seul champ de script lifecycle dans un fichier manifeste que les développeurs génèrent avec npm init et examinent rarement ensuite.

That incident was not isolated. The Bitwarden CLI was backdoored via a preinstall hook on April 22, 2026 — the malicious version lived on the registry for 93 minutes before removal, harvesting cloud credentials and propagating via the victim's npm publishing access. Three weeks later, 84 malicious packages were published across the entire @tanstack scope in six minutes, exploiting a hijacked GitHub Actions OIDC token to push malicious package.json files through TanStack's own trusted release pipeline. Your package.json is not just configuration — it is the primary attack surface for the most active threat ecosystem in open source. This guide covers every field and practice that matters for security in 2026.

Cet incident n'était pas isolé. Le CLI Bitwarden a été backdooré via un hook preinstall le 22 avril 2026 — la version malveillante a vécu sur le registre pendant 93 minutes avant d'être retirée, récoltant des identifiants cloud et se propageant via l'accès de publication npm de la victime. Trois semaines plus tard, 84 packages malveillants ont été publiés dans l'ensemble du périmètre @tanstack en six minutes, exploitant un token OIDC GitHub Actions piraté pour pousser des fichiers package.json malveillants via le propre pipeline de release fiable de TanStack. Votre package.json n'est pas seulement de la configuration — c'est la principale surface d'attaque de l'écosystème de menaces le plus actif en open source. Ce guide couvre chaque champ et pratique important pour la sécurité en 2026.

The Lifecycle Scripts Trap: postinstall, preinstall, prepare

Le Piège des Scripts Lifecycle : postinstall, preinstall, prepare

npm executes lifecycle scripts automatically when you install a package. The sequence is preinstall → install → postinstall → prepare. Every script in this chain runs with your full user privileges — meaning access to ~/.ssh, ~/.aws/credentials, ~/.npmrc tokens, every environment variable in your shell, and your entire filesystem. When a malicious package lands in your node_modules (whether direct or transitive), its lifecycle scripts execute with the same trust as your own shell commands.

npm exécute les scripts lifecycle automatiquement lors de l'installation d'un package. La séquence est preinstall → install → postinstall → prepare. Chaque script de cette chaîne s'exécute avec vos privilèges utilisateur complets — soit l'accès à ~/.ssh, ~/.aws/credentials, les tokens ~/.npmrc, toutes les variables d'environnement de votre shell, et tout votre système de fichiers. Quand un package malveillant atterrit dans vos node_modules (direct ou transitif), ses scripts lifecycle s'exécutent avec la même confiance que vos propres commandes shell.

The dominant payload pattern across the Axios, Bitwarden CLI, and TanStack attacks followed identical logic: step 1 — compromise a trusted maintainer account or CI/CD pipeline; step 2 — publish a new version with a malicious postinstall or preinstall script; step 3 — wait for developers to run npm install. The attack completes before any vulnerability scanner can generate an advisory.

Le schéma dominant de charge utile dans les attaques Axios, Bitwarden CLI et TanStack suivait une logique identique : étape 1 — compromettre un compte mainteneur de confiance ou un pipeline CI/CD ; étape 2 — publier une nouvelle version avec un script postinstall ou preinstall malveillant ; étape 3 — attendre que les développeurs exécutent npm install. L'attaque est terminée avant qu'un scanner de vulnérabilités puisse générer un advisory.

The primary defense is a single .npmrc setting: ignore-scripts=true. This blocks all lifecycle scripts from running during installation. The tradeoff is real: some legitimate packages require lifecycle scripts (native bindings compiled with node-gyp, for instance). The pragmatic approach is to set ignore-scripts=true in CI/CD (where credentials are most sensitive) and review any package whose scripts you need to explicitly allow. pnpm went further: since late 2025, strictDepBuilds: true is the default in new pnpm projects, blocking all build scripts unless whitelisted in pnpm-workspace.yaml.

La défense principale est un seul paramètre .npmrc : ignore-scripts=true. Cela bloque l'exécution de tous les scripts lifecycle lors de l'installation. Le compromis est réel : certains packages légitimes nécessitent des scripts lifecycle (les liaisons natives compilées avec node-gyp, par exemple). L'approche pragmatique est de définir ignore-scripts=true en CI/CD (là où les identifiants sont les plus sensibles) et d'examiner tout package dont vous devez autoriser explicitement les scripts. pnpm est allé plus loin : depuis fin 2025, strictDepBuilds: true est la valeur par défaut dans les nouveaux projets pnpm, bloquant tous les scripts de build sauf ceux en liste blanche dans pnpm-workspace.yaml.

# .npmrc — lifecycle script hardening
ignore-scripts=true

# For CI/CD where you need to allow specific packages:
# npm install --ignore-scripts
# npm rebuild [specific-package] # only rebuild what you trust

Lockfile Integrity: Your package-lock.json Is an Attack Surface Too

Intégrité du Lockfile : Votre package-lock.json est Aussi une Surface d'Attaque

The lockfile is your dependency snapshot. But it is also a vector. An attacker with write access to your repository can modify package-lock.json to alter the resolved field of any dependency — pointing it to a malicious mirror — while updating the integrity hash to match, making the substitution completely invisible to standard tooling. This technique, known as lockfile poisoning, was documented as an active attack pattern in 2026.

Le lockfile est votre instantané de dépendances. Mais c'est aussi un vecteur. Un attaquant avec accès en écriture à votre dépôt peut modifier package-lock.json pour altérer le champ resolved de n'importe quelle dépendance — le faisant pointer vers un miroir malveillant — tout en mettant à jour le hash integrity pour correspondre, rendant la substitution complètement invisible aux outils standard. Cette technique, connue sous le nom de lockfile poisoning, a été documentée comme schéma d'attaque actif en 2026.

Three practices close this gap. First, always commit your lockfile and protect the package-lock.json branch rule so it requires review on changes. Second, use npm ci in CI/CD, not npm install: npm ci fails fast if the lockfile is inconsistent with package.json, rather than silently updating it. Third, run lockfile-lint in CI: it validates that every resolved URL in your lockfile points to an allowlisted registry (e.g., https://registry.npmjs.org), blocking any attempt to redirect a dependency to an attacker-controlled server.

Trois pratiques comblent cette lacune. Premièrement, committez toujours votre lockfile et protégez la règle de branche package-lock.json pour exiger une revue lors des modifications. Deuxièmement, utilisez npm ci en CI/CD, pas npm install : npm ci échoue immédiatement si le lockfile est incohérent avec package.json, plutôt que de le mettre à jour silencieusement. Troisièmement, exécutez lockfile-lint en CI : il valide que chaque URL resolved dans votre lockfile pointe vers un registre autorisé (ex. : https://registry.npmjs.org), bloquant toute tentative de redirection d'une dépendance vers un serveur contrôlé par un attaquant.

# Install lockfile-lint
npm install --save-dev lockfile-lint

# Validate your lockfile in CI
npx lockfile-lint --path package-lock.json \
  --type npm \
  --allowed-hosts registry.npmjs.org \
  --validate-https

One frequent oversight: developers run npm install locally (which updates the lockfile) and commit the result without reviewing it. A supply chain attacker who has access to the CI system does not need to touch package.json at all if they can silently modify the lockfile. Treat any unexpected change to package-lock.json — especially to the resolved or integrity fields of existing packages — as a security event requiring manual review.

Un oubli fréquent : les développeurs exécutent npm install localement (ce qui met à jour le lockfile) et committent le résultat sans le passer en revue. Un attaquant supply chain qui a accès au système CI n'a pas besoin de toucher package.json du tout s'il peut modifier silencieusement le lockfile. Traitez tout changement inattendu de package-lock.json — notamment dans les champs resolved ou integrity de packages existants — comme un événement de sécurité nécessitant une revue manuelle.

npm overrides & resolutions: Patching Transitive CVEs Without Waiting for Upstream

npm overrides & resolutions : Corriger les CVE Transitives Sans Attendre l’Upstream

A large share of npm CVEs live in transitive dependencies — packages your direct dependencies depend on. When a vulnerability is discovered in a transitive package, you often cannot upgrade it directly: the path is your-app → some-lib → vulnerable-package, and some-lib may not have released a fix yet. The overrides field in package.json (npm v8.3.0+, improved in February 2025) lets you force a specific version of any transitive package, regardless of what the upstream library requests.

Une grande partie des CVE npm se trouvent dans les dépendances transitives — les packages dont dépendent vos dépendances directes. Quand une vulnérabilité est découverte dans un package transitif, vous ne pouvez souvent pas le mettre à jour directement : le chemin est votre-app → some-lib → vulnerable-package, et some-lib n'a peut-être pas encore publié de correctif. Le champ overrides dans package.json (npm v8.3.0+, amélioré en février 2025) vous permet de forcer une version spécifique de n'importe quel package transitif, quelle que soit la demande de la bibliothèque upstream.

// package.json — force patched versions for transitive CVEs
{
  "overrides": {
    "nth-check": ">=2.0.1",
    "semver": ">=7.5.2",
    "word-wrap": ">=1.2.4",
    "tough-cookie": ">=4.1.3"
  }
}

// Yarn equivalent (resolutions field):
{
  "resolutions": {
    "nth-check": ">=2.0.1",
    "semver": ">=7.5.2"
  }
}

A critical caveat: overrides are blunt instruments. Forcing a breaking major version upgrade on a transitive package can introduce runtime incompatibilities that are hard to debug. The workflow should be: 1) npm audit identifies the transitive CVE; 2) you verify the patched version is semver-compatible with the consuming library; 3) you run your full test suite after adding the override; 4) you add a code comment explaining which CVE the override addresses and a link to the advisory, so future developers understand why it exists. Overrides left without documentation become technical debt that nobody dares to remove.

Une mise en garde cruciale : les overrides sont des instruments contondants. Forcer une mise à jour de version majeure cassante sur un package transitif peut introduire des incompatibilités d'exécution difficiles à déboguer. Le workflow devrait être : 1) npm audit identifie le CVE transitif ; 2) vous vérifiez que la version corrigée est compatible semver avec la bibliothèque consommatrice ; 3) vous exécutez votre suite de tests complète après l'ajout de l'override ; 4) vous ajoutez un commentaire de code expliquant quel CVE l'override adresse et un lien vers l'advisory, pour que les développeurs futurs comprennent pourquoi il existe. Les overrides laissés sans documentation deviennent une dette technique que personne n'ose supprimer.

Private Registry & .npmrc Token Security

Registre Privé & Sécurité des Tokens .npmrc

If you use a private npm registry (GitHub Packages, Verdaccio, Artifactory, or npm Teams/Org scopes), your authentication token configuration directly determines your blast radius in the event of a compromise. The single most dangerous mistake is committing a .npmrc file that contains a hardcoded token. Any developer with read access to your repository — including contributors, forks, and CI environments — can extract and use that token to publish malicious packages under your account or access private packages they should not see.

Si vous utilisez un registre npm privé (GitHub Packages, Verdaccio, Artifactory, ou les scopes npm Teams/Org), la configuration de votre token d'authentification détermine directement votre rayon d'impact en cas de compromission. L'erreur la plus dangereuse est de committer un fichier .npmrc contenant un token en dur. Tout développeur ayant accès en lecture à votre dépôt — y compris les contributeurs, les forks, et les environnements CI — peut extraire et utiliser ce token pour publier des packages malveillants sous votre compte ou accéder à des packages privés qu'il ne devrait pas voir.

# .npmrc — SAFE: use an environment variable, never a literal token
//registry.npmjs.org/:_authToken=${NPM_TOKEN}

# For scoped packages on GitHub Packages:
@your-org:registry=https://npm.pkg.github.com
//npm.pkg.github.com/:_authToken=${GITHUB_TOKEN}

# DANGEROUS — never do this:
# //registry.npmjs.org/:_authToken=npm_abc123...  ← hardcoded token in repo

Beyond token hygiene, configure granular access tokens with the minimum necessary permissions and short expiration dates. For publishing from CI/CD workflows, use npm's OIDC trusted publishing: it generates short-lived, workflow-scoped credentials tied to a specific repository and action run, with no stored secret anywhere. Each publish operation is cryptographically linked to its source pipeline, producing verifiable provenance attestations automatically. This is what TanStack's pipeline used — and what the attacker hijacked. Combining trusted publishing with locked Action versions (uses: actions/setup-node@v4.1.0 pinned to a specific commit SHA, not a floating tag) significantly reduces that hijack surface.

Au-delà de l'hygiène des tokens, configurez des tokens d'accès granulaires avec les permissions minimales nécessaires et des dates d'expiration courtes. Pour la publication depuis les workflows CI/CD, utilisez le trusted publishing OIDC de npm : il génère des identifiants de courte durée, limités au workflow et liés à un dépôt et une exécution d'action spécifiques, sans secret stocké nulle part. Chaque opération de publication est cryptographiquement liée à son pipeline source, produisant automatiquement des attestations de provenance vérifiables. C'est ce que le pipeline de TanStack utilisait — et ce que l'attaquant a piraté. Combiner le trusted publishing avec des versions d'Action verrouillées (uses: actions/setup-node@v4.1.0 épinglé à un SHA de commit spécifique, pas un tag flottant) réduit considérablement cette surface de piratage.

Namespace confusion — where a package published on the public registry under the same name as your private scoped package takes precedence depending on registry configuration — remains an active attack class. Prevent it by setting an explicit registry entry for every @scope you own in your .npmrc, so npm never falls back to the public registry for those scopes.

La confusion de namespace — où un package publié sur le registre public sous le même nom que votre package privé scopé prend la priorité selon la configuration du registre — reste une classe d'attaque active. Prévenez-la en définissant une entrée registry explicite pour chaque @scope que vous possédez dans votre .npmrc, de sorte que npm ne revienne jamais au registre public pour ces scopes.

npm Provenance Attestation: The Standard 88% of Packages Still Ignore

Attestations de Provenance npm : Le Standard que 88% des Packages Ignorent Encore

npm introduced provenance attestations in May 2023. By April 2026 — three years later — an audit of the top 50 most-downloaded packages found that only 12% ship with supply-chain attestations. Over 16,000 packages across the ecosystem have published with provenance, but this represents a small fraction of the total registry. Yet provenance is the only control that can definitively answer the question: was this package version built from the public source code in that repository, or was it built from something else?

npm a introduit les attestations de provenance en mai 2023. En avril 2026 — trois ans plus tard — un audit des 50 packages les plus téléchargés a révélé que seulement 12% embarquent des attestations de supply chain. Plus de 16 000 packages dans l'écosystème ont publié avec provenance, mais cela représente une petite fraction du registre total. Pourtant, la provenance est le seul contrôle qui peut répondre définitivement à la question : cette version de package a-t-elle été construite à partir du code source public dans ce dépôt, ou à partir d'autre chose ?

When you publish with provenance from GitHub Actions, npm signs the package using Sigstore's public good servers and logs the signature in a public transparency ledger. Anyone can run npm audit signatures to verify that the installed version of a package was built from the claimed source commit in the claimed repository. A backdoored release — like the Axios or Bitwarden CLI attack — would still pass provenance verification if the attacker published from the compromised maintainer's account using the legitimate pipeline. But a supply chain attack that tampers with the build artifact after compilation (build artifact substitution) would fail provenance verification.

Quand vous publiez avec provenance depuis GitHub Actions, npm signe le package en utilisant les serveurs publics de Sigstore et enregistre la signature dans un registre de transparence public. N'importe qui peut exécuter npm audit signatures pour vérifier que la version installée d'un package a été construite à partir du commit source revendiqué dans le dépôt revendiqué. Une version backdoorée — comme l'attaque Axios ou Bitwarden CLI — passerait quand même la vérification de provenance si l'attaquant a publié depuis le compte du mainteneur compromis en utilisant le pipeline légitime. Mais une attaque supply chain qui altère l'artefact de build après compilation (échange d'artefact de build) échouerait la vérification de provenance.

# Verify provenance of installed packages
npm audit signatures

# When publishing — provenance is automatic with Trusted Publishing
# Or use the flag explicitly:
npm publish --provenance

The Complete .npmrc Security Configuration for 2026

La Configuration de Sécurité .npmrc Complète pour 2026

Security research in 2026 demonstrated that four lines in .npmrc block approximately 80% of npm supply chain attack payloads. Here is the full hardened configuration with annotations for what each line does and why it matters.

La recherche en sécurité en 2026 a démontré que quatre lignes dans .npmrc bloquent environ 80% des charges utiles d'attaques supply chain npm. Voici la configuration durcie complète avec des annotations sur ce que chaque ligne fait et pourquoi c'est important.

# .npmrc — 2026 hardened configuration

# 1. Block all lifecycle scripts (postinstall, preinstall, prepare, etc.)
#    This is the single most impactful control. pnpm defaults to this since late 2025.
ignore-scripts=true

# 2. Require exact lockfile matching — fail-fast on inconsistencies
save-exact=true

# 3. Enforce HTTPS for all registry communication
strict-ssl=true

# 4. Block HTTP (non-TLS) registry connections entirely
registry=https://registry.npmjs.org/

# 5. Audit automatically on install (surface CVEs immediately)
audit=true

# 6. Prevent lockfile modifications during CI installs
# (Use this in CI via: npm ci, which already enforces this)
package-lock=true

# 7. Private scope — always use your private registry, never fall back to public
@your-org:registry=https://your-private-registry.example.com/
//your-private-registry.example.com/:_authToken=${PRIVATE_NPM_TOKEN}

A companion setting for package.json worth adding to any private or internal project is the private: true flag. This field prevents accidental publication of your application to the public npm registry via a mistyped npm publish. It is a single-line addition that prevents source code, API keys embedded in config files, and internal architecture from leaking to the public registry.

Un paramètre complémentaire pour package.json qui vaut la peine d'être ajouté à tout projet privé ou interne est le flag private: true. Ce champ empêche la publication accidentelle de votre application sur le registre npm public via un npm publish mal tapé. C'est un ajout d'une seule ligne qui empêche le code source, les clés API embarquées dans les fichiers de configuration et l'architecture interne de fuiter vers le registre public.

// package.json — prevent accidental publication
{
  "name": "my-internal-app",
  "private": true,
  "engines": {
    "node": ">=20.0.0",
    "npm": ">=10.0.0"
  }
}

The engines field is security-relevant for a less obvious reason: it locks down the Node.js and npm runtime versions used to install your dependencies. An attacker who tricks a developer into using an older npm version may bypass protections that were introduced in a later release. Specifying minimum versions ensures your lockfile format, audit behaviors, and access token security features are consistent across all environments.

Le champ engines est pertinent pour la sécurité pour une raison moins évidente : il verrouille les versions de runtime Node.js et npm utilisées pour installer vos dépendances. Un attaquant qui piège un développeur pour utiliser une ancienne version de npm peut contourner les protections introduites dans une version ultérieure. Spécifier des versions minimales garantit que votre format de lockfile, les comportements d'audit et les fonctionnalités de sécurité des tokens d'accès sont cohérents dans tous les environnements.

CI/CD Security Checklist for npm in 2026

Checklist Sécurité CI/CD pour npm en 2026

The following practices harden your npm-based CI/CD pipeline against the attack patterns documented in 2025–2026. Each is a direct response to a real incident or published attack technique.

Les pratiques suivantes durcissent votre pipeline CI/CD basé sur npm contre les schémas d'attaques documentés en 2025–2026. Chacune est une réponse directe à un incident réel ou une technique d'attaque publiée.

• Use npm ci, not npm install — guarantees reproducible installs from the lockfile, fails on mismatch, and never modifies the lockfile.
• Utilisez npm ci, pas npm install — garantit des installations reproductibles depuis le lockfile, échoue en cas d'incohérence, et ne modifie jamais le lockfile.
• Add --ignore-scripts to npm ci in CI — npm ci --ignore-scripts blocks lifecycle scripts even if .npmrc is not present or is overridden.
• Ajoutez --ignore-scripts à npm ci en CI — npm ci --ignore-scripts bloque les scripts lifecycle même si .npmrc n'est pas présent ou est surchargé.
• Run npm audit --audit-level=high as a CI gate — fail the build on high or critical CVEs before any artifact is produced.
• Exécutez npm audit --audit-level=high comme porte CI — faites échouer le build sur les CVE high ou critical avant qu'un artefact ne soit produit.
• Run lockfile-lint to validate that all resolved URLs point to your approved registries only.
• Exécutez lockfile-lint pour valider que toutes les URLs resolved pointent uniquement vers vos registres approuvés.
• Run npm audit signatures to verify provenance attestations — flags packages built outside their claimed source repository.
• Exécutez npm audit signatures pour vérifier les attestations de provenance — signale les packages construits en dehors de leur dépôt source revendiqué.
• Pin GitHub Action versions to commit SHAs, not floating tags — prevents dependency confusion in your own CI pipeline (uses: actions/setup-node@a1b2c3d).
• Épingle les versions GitHub Actions à des SHA de commit, pas des tags flottants — prévient la confusion de dépendances dans votre propre pipeline CI (uses: actions/setup-node@a1b2c3d).
• Store tokens in CI secrets, never in .npmrc — use ${NPM_TOKEN} as a variable reference, inject the value via your CI platform's secrets manager.
• Stockez les tokens dans les secrets CI, jamais dans .npmrc — utilisez ${NPM_TOKEN} comme référence de variable, injectez la valeur via le gestionnaire de secrets de votre plateforme CI.

Frequently Asked Questions

Questions fréquentes