Gestion proactive et continue des vulnérabilités AppSec pour les développeurs et les équipes de sécurité

Quels sont les risques croissants en matière de cybersécurité dans le paysage du développement logiciel moderne qui occupent les RSSI ?

Les développeurs et les équipes de sécurité sont confrontés à un éventail toujours croissant de menaces, allant des attaques sophistiquées de la chaîne d'approvisionnement open source et contrôlées par les fournisseurs aux vulnérabilités introduites par le code généré par l'IA, comme l'injection rapide et la mauvaise sécurité du code par GitHub Copilot. La complexité des applications modernes, qui s'appuient souvent fortement sur des composants open source (tels que ceux que l'on trouve sur npm, PyPI ou RubyGems) et des déploiements conteneurisés, ajoute au défi. 

Compte tenu de l’ampleur et de la complexité de ces risques, automatiser la gestion des vulnérabilités est devenu incontournable. Les processus manuels de cybersécurité ne peuvent tout simplement pas suivre le volume et la vitesse des vulnérabilités potentielles et du développement de logiciels. L'automatisation accélère non seulement l'identification et la résolution des problèmes de sécurité, mais garantit également que ces processus, suivis régulièrement par les équipes de sécurité, sont appliqués de manière cohérente à toutes les étapes du cycle de vie du développement logiciel.

L’importance d’une gestion continue des vulnérabilités dans des domaines spécifiques

• Dépendance croissante à l'égard des composants open source : les composants open source sont devenus omniprésents dans le développement de logiciels modernes. Si ces composants accélèrent le développement pour les développeurs d’applications et contribuent à réduire les coûts, ils introduisent également des risques de sécurité importants. Des attaques très médiatisées sur la chaîne d'approvisionnement, comme la porte dérobée XZ et la violation de SolarWinds, ont mis en évidence le potentiel de dommages étendus lorsque les vulnérabilités des dépendances open source et des composants fermés contrôlés par les fournisseurs sont exploitées.
• Utilisation croissante du code généré par l'IA dans le développement : l'essor de l'IA générative (GenAI) dans le développement de logiciels apporte à la fois des opportunités et des défis. GenAI peut accélérer considérablement les tâches de codage, mais il peut également introduire de nouvelles vulnérabilités. Le code généré par l’IA peut ne pas tenir compte des considérations de sécurité que les développeurs expérimentés incluent généralement, ce qui entraîne des failles de sécurité potentielles. Un exemple de ceci est GitHub Copilot qui introduit un XSS dans React.
• Croissance rapide des applications conteneurisées : les applications conteneurisées sont devenues la norme pour le déploiement de logiciels modernes. Les conteneurs offrent de nombreux avantages, notamment la cohérence entre les environnements et la facilité de mise à l'échelle. Cependant, ils introduisent également de nouveaux défis en matière de sécurité, notamment dans la gestion des vulnérabilités des images de conteneurs. En tant que tels, les développeurs pourraient avoir besoin d'aide pour les expliquer sur la façon de choisir la meilleure image de conteneur et des conseils généraux de pro sur les conteneurs, mais l'automatisation des vulnérabilités de l'image de conteneur Docker est indispensable.

Décomposons-les un peu plus... Un autre exemple d'attaque de grande envergure dans la chaîne d'approvisionnement est l'attaque contre Codecov, où les attaquants ont accédé à des données sensibles en exploitant les vulnérabilités d'un outil de couverture de code populaire. La routine d’un développeur comprend la gestion des risques associés aux dépendances open source. Les dépendances open source peuvent introduire des vulnérabilités à la fois directes et transitives dans votre base de code. Des vulnérabilités directes se trouvent dans les bibliothèques que vous incluez explicitement, tandis que des vulnérabilités transitives existent dans les dépendances de ces bibliothèques. La gestion manuelle de ces risques est intimidante, ce qui fait de l'automatisation un élément essentiel d'une stratégie de sécurité robuste.

Avec GenAI, les assistants de code IA comme GitHub Copilot ou ChatGPT introduisent des vulnérabilités réelles et potentielles. GenAI peut introduire par inadvertance des pratiques de codage non sécurisées ou ne pas reconnaître les exigences de sécurité spécifiques au contexte. Par exemple, un modèle d’IA peut générer du code vulnérable aux attaques par injection SQL ou par cross-site scripting (XSS). La surveillance et la sécurisation du code généré par l’IA sont donc cruciales pour maintenir la sécurité des applications. 

La complexité de suivre les nouvelles vulnérabilités des conteneurs n’échappe pas non plus aux équipes de sécurité. Le rythme rapide des nouvelles vulnérabilités des conteneurs peut être accablant. Chaque nouvelle vulnérabilité nécessite une identification et une correction rapides pour prévenir les exploits potentiels. Cette complexité nécessite des solutions automatisées dotées d'une expertise en sécurité pour gérer efficacement la sécurité des conteneurs.

Les vulnérabilités des conteneurs peuvent avoir un impact significatif sur la sécurité globale de vos applications. Une seule image de conteneur vulnérable peut compromettre l’ensemble de la pile d’applications. Des outils tels que Snyk Container automatisent le processus d'identification et de correction des vulnérabilités dans les images de conteneurs. Snyk Container peut suggérer de nouvelles balises d'image de base qui minimisent le nombre de vulnérabilités et automatisent les demandes d'extraction pour mettre à jour vos référentiels de code.

Comment pouvons-nous atténuer toutes ces menaces de cybersécurité AppSec ?

Snyk によるプロアクティブな AppSec と継続的な脆弱性管理

AI が生成したコードに関連するリスクを軽減するには、Snyk Code などのツールの使用を検討してください。 Snyk DeepCode AI を活用したこの高速 SAST ツールは、プラグインを通じて開発者の IDE に直接統合できます。セキュリティ固有のデータ トレーニングを使用して脆弱で安全でないコードを認識し、開発の早い段階で問題を特定して対処します。

Snyk DeepCode AI を使い始めるのは簡単です。このプラグインは、Visual Studio Code、IntelliJ IDEA、VS Code、PyCharm などの一般的な IDE をサポートします。 

Snyk DeepCode AI を Visual Studio Code にインストールして統合するためのクイック ガイド

1. Snyk 拡張機能をインストールします:

• Visual Studio コードを開きます。
• ウィンドウの横にあるアクティビティ バーの拡張機能アイコンをクリックして、拡張機能ビューに移動します。
• 「Snyk」を検索し、Snyk 拡張機能の「インストール」をクリックします。

1. Snyk で認証します:

• インストール後、Snyk アカウントで認証するように求められます。
• 画面上の指示に従ってログインするか、ここでサインアップしてください。

1. Snyk DeepCode AI を有効にする:

• 認証されたら、アクティビティ バーの Snyk ビューに移動します。
• Snyk DeepCode AI を有効にして、コードの脆弱性のスキャンを開始します。

インストールすると、サイドバーの Snyk ロゴに、オープンソースの依存関係、独自のコード (または GenAI で生成されたコード)、および IaC の問題で見つかった脆弱性とセキュリティの問題が表示されます。

開発者にとって、IDE 内で安全でないコード パターンを特定できる SAST ツールの利点

1. リアルタイム フィードバック: コードを作成すると、Snyk DeepCode AI がそれをリアルタイムで分析し、潜在的なセキュリティ問題について即座にフィードバックを提供します。これにより、開発者はコードベースに脆弱性が根付く前に脆弱性に対処できるようになります。
2. AI 主導の洞察: AI モデルは、セキュリティ固有のデータの膨大なデータセットでトレーニングされ、GenAI や不適切なプログラミング手法によって導入されたものであっても、安全でないコーディング パターンを認識できるようになります。
3. シームレスな統合: IDE に直接統合することで、Snyk DeepCode AI は開発者のワークフローに自然に適合し、中断を最小限に抑え、生産性を最大化します。

GenAI によって導入された脆弱性を軽減する例を見てみましょう。このプロジェクトでは GitHub Copilot を使用して、OpenAI API をクエリする Express POST エンドポイント ルートを作成するコードをオートコンプリートし、res.send() を使用してブラウザに応答を送信しました。

しかし、このペイロード内の応答がブラウザーで直接レンダリングされたらどうなるでしょうか?このリクエストの送信にデフォルトの text/html コンテンツ タイプ ヘッダーが使用された場合、クロスサイト スクリプティングの脆弱性が実行中のアプリケーションに影響を与える可能性があります。これについて私たちは何ができるでしょうか?

31 行目上の注釈でわかるように、Snyk はこのセキュリティ問題を修正することを提案しています。それをクリックすると、数秒以内に、Snyk DeepCode AI 拡張機能が、次のように res.send() を res.json に置き換える軽減策を提案しました。

res.json(response.choices[0].message.content);

この変更により、Express アプリケーションは応答の content-type を強制的に application/json にすることになります。これは汎用テキストであり、alert() などのテキストを許可できます。

IDE で Snyk を活用することで、開発者は基盤となる Snyk DeepCode AI エンジンを使用して脆弱性を積極的に特定して軽減し、最初からコードの安全性を確保できます。アプリケーション セキュリティに対するこの積極的なアプローチは、オープンソースのサプライ チェーンと GenAI が生成したコードに関連するリスクが常に存在する今日の環境では不可欠です。

Snyk オープンソースによる依存関係管理の自動化

Snyk Open Source は、開発者とセキュリティ チームがオープンソースの依存関係に関連するリスクを管理できるように設計された強力なツールです。オープンソース ライブラリへの依存が高まるにつれ、堅牢で自動化された依存関係管理の必要性がかつてないほど重要になっています。 Snyk オープンソースは、包括的な脆弱性スキャンおよび修復機能を提供し、プロジェクトの安全性と準拠性を確保します。

以前の Node.js アプリケーションでは SQLite 依存関係も使用しており、Snyk は次のようにセキュリティ上の問題を警告します。

This vulnerability information is helpful to understand which transitive dependency is introducing the security risk and how to mitigate it, if at all possible. In this case, the transitive dependency inflight is detected to have a medium vulnerability.

Snyk detects that my lockfile and dependency is potentially out of date and so it can’t find a remediation path. However, let’s see the automation in practice when we import the GitHub code repository to Snyk. Doing so, shows the following information on the Snyk application:

From this point on, Snyk will automatically open new Pull Requests to suggest dependency upgrades when security vulnerabilities are detected in my package manifest.

Managing dependencies is not just about the libraries you directly include in your project. Transitive dependencies—those pulled in by your direct dependencies—can also introduce vulnerabilities. Snyk excels at identifying and remediating vulnerabilities in both direct and transitive dependencies.

Consider the following scenario:

{
  "dependencies": {
    "express": "^4.17.1",
    "lodash": "^4.17.20"
  }
}

In this example, express and lodash are direct dependencies. However, express might have its own set of dependencies, which in turn might have their own dependencies. Snyk will traverse this entire dependency tree, identifying and addressing vulnerabilities at every level.

When it comes to managing container vulnerabilities, Snyk Container helps remove the burden of keeping base image tags up-to-date with security patches.

Snyk Container is a comprehensive solution designed to help developers and security teams manage container vulnerabilities effectively. Containerized application workloads is prevalent at the Enterprise and as is the need to secure these environments. Snyk Container integrates seamlessly into your CI/CD pipeline, providing continuous monitoring and proactive remediation of vulnerabilities in your container images.

One of the standout features of Snyk Container is its ability to automate the creation of Pull Requests to address vulnerabilities in your container images. This automation is a game-changer for both developers and security teams, as it significantly reduces the manual effort required to keep container images secure.

Here's an example of how Snyk Container might automate a PR to update a vulnerable package in a Dockerfile:

FROM node:14.1.0
RUN npm install express
COPY . /app
CMD ["node", "/app/index.js"]

When Snyk Container detects a vulnerability, it automatically generates a PR with the necessary changes to mitigate the issue. This could include updating a vulnerable package or applying a security patch. By automating this process, Snyk Container ensures that vulnerabilities are addressed promptly, reducing the window of exposure.

By following these recommended base images, you can significantly reduce the number of vulnerabilities in your container images, enhancing the overall security of your applications.

Snyk Container identified multiple vulnerabilities in this base image and automatically generated PRs to update the image and associated dependencies. The team was able to review and merge these PRs quickly, reducing their vulnerability count by over 30% within seconds by merging the Pull Request and ensuring the CI/CD pipeline tests pass with flying colors.

This proactive approach not only improved the security posture of their applications but also freed up valuable time for developers to focus on building new features rather than managing vulnerabilities.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!