不正经

这个屌丝很懒，什么也没留下！

热门标签

ChatGPT 网络安全秘籍（二）

作者：不正经 | 2024-05-01 20:52:14

踩

ChatGPT 网络安全秘籍（二）

原文：zh.annas-archive.org/md5/6b2705e0d6d24d8c113752f67b42d7d8

译者：飞龙

协议：CC BY-NC-SA 4.0

第三章：代码分析和安全开发

这一章深入探讨软件开发的复杂过程，关注当今数字世界中的一个关键问题：确保软件系统的安全。随着技术的不断复杂和威胁的不断演变，采用融合了安全考虑的安全软件开发生命周期（SSDLC）变得至关重要，以确保在每个阶段都能整合安全措施。在这里，我们演示如何使用人工智能，特别是 ChatGPT 模型，来帮助简化这个过程。

您将学习如何应用 ChatGPT 来计划和概述全面的 SSDLC，考虑从概念创建到维护的每个开发阶段。强调在每个步骤中安全性的重要性，我们展示了如何利用 ChatGPT 来制定详细的安全需求文档和安全编码指南。本章阐明了这些可交付成果的生成，演示了如何将它们整合并与您的开发团队和利益相关方共享，以促进项目安全期望的共同理解。

本章进一步探讨了 ChatGPT 在 SSDLC 更技术方面的潜力。我们将研究如何利用 ChatGPT 帮助识别代码中可能存在的安全漏洞并生成安全测试的自定义脚本。这种人工智能的实际应用展示了主动和被动措施的融合，以增强软件的安全性。

最后，我们进入 SSDLC 的最后阶段——部署和维护。由于清晰、简明的文档常常被忽视的重要性，因此我们展示了 ChatGPT 可用于为您的代码生成全面的注释和详尽的文档。通过本章末尾，您将了解如何使软件更易于理解和维护，从而提高整个软件的生命周期。

在整个本章中，核心主题是利用生成式人工智能创建安全、高效和可维护的软件系统。它展示了人类专业知识和人工智能之间的协同效应，为您提供了有效运用 ChatGPT 和 OpenAI API 来进行安全软件开发的工具和技术。

在本章中，我们将涵盖以下内容：

安全软件开发生命周期（SSDLC 规划（规划阶段）
安全要求生成（需求阶段）
生成安全编码指南（设计阶段）
分析代码以发现安全漏洞并生成自定义安全测试脚本（测试阶段）
生成代码注释和文档（部署/维护阶段）

技术要求

对于本章，您需要一个Web 浏览器和一个稳定的互联网连接，以访问 ChatGPT 平台并设置您的帐户。您还需要设置您的 OpenAI 帐户并获取您的 API 密钥。如果没有，请查看第一章了解详情。需要基本的 Python 编程语言知识和工作于命令行，因为您将使用Python 3.x，需要在您的系统上安装 OpenAI GPT API 并创建 Python 脚本。在本章的配方中，需要使用代码编辑器编写和编辑 Python 代码和提示文件。

本章的代码文件可在此处找到：github.com/PacktPublishing/ChatGPT-for-Cybersecurity-Cookbook。

安全软件开发生命周期（SSDLC）规划（规划阶段）

在本配方中，您将使用 ChatGPT 来协助您制定 SSDLC 的大纲。这个配方对于软件开发人员、项目经理、安全专家或任何参与创建安全软件系统的人都是必不可少的工具。

使用在第一章中介绍的 ChatGPT 的基础技能，并在第二章中进一步扩展，本配方将指导您制定一个全面的SSDLC计划。这个计划包括各种阶段，如初始概念开发、需求收集、系统设计、编码、测试、部署和维护。在整个过程中，我们将说明如何使用 ChatGPT 详细描述每个阶段，强调安全注意事项。

您将学习如何有效地构建提示，以获取有关 SSDLC 的高质量、信息丰富的输出。在前一章中展示的技术，例如使用模板增强输出和将输出格式化为表格，将在这里非常有用，使您能够设计生成每个 SSDLC 阶段所需的输出格式的提示。

这个配方涉及使用 ChatGPT 来生成输出，但是你也可以将这些输出手动编译成一个结构良好、易于理解的 SSDLC 计划文档，然后与您的开发团队和其他利益相关者共享，促进对 SSDLC 规划过程的全面理解。

准备工作

在开始本配方之前，您应该对 ChatGPT 用于提示生成有一个良好的理解，如第一章中所解释的。本配方不需要额外的设置。

有了这些先决条件，您现在可以使用 ChatGPT 的帮助开始规划安全开发生命周期。

操作步骤：

让我们通过为 ChatGPT 设置系统角色，然后按照后续提示来为特定项目创建一个 SSDLC 计划开始这个方案。对于我们的示例，我们将使用开发安全在线银行系统，但您可以根据需要更改系统类型：

首先，登录到您的 ChatGPT 帐户，并导航到 ChatGPT Web UI。
通过单击新对话按钮，开始与 ChatGPT 进行新的对话。

输入以下提示以确定系统角色：

You are an experienced software development manager with expertise in secure software development and the Secure Software Development Lifecycle (SSDLC).
1

接下来，我们将用以下提示来创建SSDLC 的概览：

Provide a detailed overview of the Secure Software Development Lifecycle (SSDLC), highlighting the main phases and their significance.
1

通过讨论特定项目的初始概念和可行性来启动规划。在本例中，我们使用的是一个银行系统（同样，根据需要更改提示中的系统类型）：
```
Considering a project for developing a secure online banking system, detail the key considerations for the initial concept and feasibility phase.
1
```

接下来，我们需要使用这个提示为特定项目创建需求收集过程：

Outline a checklist for gathering and analyzing requirements for the online banking system project during the requirements phase of the SSDLC.
1

了解在线银行系统的设计考虑和步骤：

Highlight important considerations when designing a secure online banking system during the system design phase of the SSDLC.
1

现在我们可以深入了解与我们系统相关的安全编码实践：

Discuss secure coding best practices to follow when developing an online banking system during the development phase of the SSDLC.
1

理解应该进行的关键测试是开发的关键部分。使用此提示来创建一个测试清单：

Enumerate the key types of testing that should be conducted on an online banking system during the testing phase of the SSDLC.
1

在部署在线银行系统时，获得最佳实践指导：

List some best practices for deploying an online banking system during the deployment phase of the SSDLC.
1

结束时，了解在线银行系统维护阶段的活动：

Describe the main activities during the maintenance phase of an online banking system and how they can be managed effectively.
1

每个提示都将导致 ChatGPT 的输出，协助制定特定系统的 SSDLC 计划。

它是如何运作的…

在整个方案中，提示被设计为从 ChatGPT 获取最佳可能的输出。语言清晰具体，这有助于生成详细和集中的响应。此外，通过定义一个具体项目，我们指导 ChatGPT 提供具体且适用的见解。因此，ChatGPT 提供了一个彻底的 SSDLC 规划指南。以下是每个步骤的工作原理的分解（特别是步骤 3-11）：

系统角色：通过定义 ChatGPT 的角色为经验丰富的软件开发经理，在安全软件开发和 SSDLC 方面具有专业知识，我们为我们的 AI 伙伴设置了上下文。这有助于 ChatGPT 生成更相关、准确和知识渊博的响应。
理解 SSDLC：这个提示帮助读者全面了解 SSDLC。通过要求 ChatGPT 详细说明主要阶段及其重要性，我们获得了一个为后续步骤铺平道路的 SSDLC 的高层概述。
初始概念/可行性：在这一步中，我们让 ChatGPT 深入研究了特定项目的初始概念和可行性。这有助于确定这个初始阶段的关键考虑因素，这对于为 SSDLC 的其余部分确定方向至关重要。
需求收集：SSDLC 的需求阶段对于项目的成功至关重要。通过让 ChatGPT 为我们的特定项目概述一个需求收集清单，我们确保覆盖了所有必要的方面，这将进一步指导设计和开发过程。
系统设计：在这里，ChatGPT 概述了 SSDLC 系统设计阶段的重要考虑因素，重点关注我们项目的具体内容。这提供了在设计在线银行系统时需要考虑的重要元素的指导。
编码/开发：通过询问 ChatGPT 在开发阶段讨论安全编码的最佳实践，我们可以得到一个详细的指南，指导我们遵循哪些实践，以创建在线银行系统的安全代码库。
测试：在这一步中，我们让 ChatGPT 列举了在测试阶段应该进行的关键测试类型。这确保了开发的在线银行系统在发布之前经过了彻底的测试。
部署：安全地部署系统与安全地开发系统同样重要。在这一步中，ChatGPT 列出了部署阶段的最佳实践，确保从开发到实际运行环境的过渡平稳且安全。
维护：最后，我们让 ChatGPT 描述了维护阶段的主要活动。这提供了关于如何在部署后管理系统，以确保其持续安全性和性能的见解。

还有更多…

这个配方为你提供了一个详细的指南，用于规划开发项目的 SSDLC（以在线银行系统为例），但这只是一个开始。你还可以做一些其他事情来定制这个配方并加深你的理解：

为不同项目定制：本配方中概述的原则可适用于在线银行系统之外的各种项目。你可以以此为基础并修改项目细节，以适应不同类型的软件开发项目。只需确保提供足够的项目背景，以便 ChatGPT 提供相关和具体的响应。

提示

你可以使用在 第二章 学到的输出格式化技巧，指定你偏好的输出格式，以便转换为正式文档。

详细探讨每个 SSDLC 阶段：我们在这个配方中对 SSDLC 的每个阶段进行了高层次的介绍。但是，你可以通过向 ChatGPT 提出更具体的问题来深入探讨每个阶段。例如，在系统设计阶段，你可以请 ChatGPT 解释不同的设计方法论，或者更详细地介绍设计用户界面或数据库的最佳实践。

记住，ChatGPT 的力量在于它能够根据您给出的提示提供详细和有信息量的回应。因此，不要害怕尝试不同的提示和问题，以从中提取最大的价值。

安全需求生成（需求阶段）

在本节中，您将使用 ChatGPT 来帮助您创建开发项目的全面的安全需求集。这对软件开发人员、项目经理、安全专业人员或任何涉及创建安全软件系统的人来说都是一份宝贵的指南。

运用 ChatGPT 介绍的基本技能 第一章 中介绍，并在 第二章 进一步拓展，本节将指导您生成详细的安全需求清单。这些需求将根据您的具体项目定制，并遵循安全开发的最佳实践。

您将学习如何设计能够引出高质量、信息丰富输出的有效提示。在先前章节介绍的技巧，比如使用模板增强输出和将输出格式化为表格，将在这里发挥作用，因为它们将使您能够设计出能够为每个安全需求生成所需输出格式的提示。

本节将不仅演示 ChatGPT 如何用于生成输出，而且就像先前的示例一样，您将能够汇编这些输出成一份全面的安全需求文档，然后与您的开发团队和利益相关者分享，确保他们清楚了解项目的安全期望。

准备工作

在开始本节之前，请确保您已清楚了解 ChatGPT 用于提示生成的用法，如 第一章 中所述。本节不需要额外的设置。

在准备好这些先决条件后，您现在可以开始使用 ChatGPT 的帮助为您的开发项目生成安全要求。

如何做…

让我们通过为 ChatGPT 设置系统角色并随后跟随提示为特定项目创建一套全面的安全需求的方法开始这一节。

对于我们的示例，我们将使用开发安全的医疗记录管理系统：

首先登录到您的 ChatGPT 帐户并转到 ChatGPT Web 用户界面。
点击新对话按钮开始与 ChatGPT 进行新对话。

输入以下提示来确定一个系统角色：

You are an experienced cybersecurity consultant specializing in secure software development.
1

现在，我们需要告知 ChatGPT 有关项目，我们为其生成安全要求：

Describe a project for developing a secure medical record management system. Include details about the type of software, its purpose, intended users, and the environments in which it will be deployed.
1

在我们告知 ChatGPT 有关项目之后，我们将要求它识别潜在的安全威胁 和漏洞：

Given the project description, list potential security threats and vulnerabilities that should be considered.
1

现在我们已经确定了潜在的威胁和漏洞，我们可以生成直接解决这些问题的安全要求：

Based on the identified threats and vulnerabilities, generate a list of security requirements that the software must meet to mitigate these threats.
1

除了项目特定的安全需求外，几乎所有软件项目都适用于一些通用的安全最佳实践。我们将使用这些来基于最佳实践生成通用的安全需求：
```
Provide additional security requirements that follow general best practices in secure software development, regardless of the specific project details.
1
```

最后，我们将根据其对项目的影响来优先考虑这些需求：

Prioritize the generated security requirements based on their impact on the security of the software and the consequences of not meeting them.
1

通过遵循这些提示，您将与 ChatGPT 进行有意义的对话，制定您特定项目的全面和优先级排序的安全需求列表。当然，您可以用您自己项目的具体内容来取代安全医疗记录管理系统。

它的工作原理…

此配方中的提示旨在清晰、具体和详细，引导 ChatGPT 提供富有洞察力、相关性强和全面的响应。在提示中的项目特定性确保了 ChatGPT 的输出不仅在理论上合理，而且在实践中可行。因此，这个配方提供了一个生成安全需求的广泛指南，借助 ChatGPT 的帮助。以下是每个步骤的工作原理（特别是步骤 3-8）：

系统角色：通过将网络安全顾问的角色分配给 ChatGPT，我们为其提供了上下文。这个上下文有助于 ChatGPT 生成与安全专业人员的专业知识一致的响应。
项目描述：在这一步中，ChatGPT 会得到软件项目的描述。这很重要，因为软件项目的安全需求主要由项目本身的具体情况决定，如其目的、用户和部署环境等。
识别威胁和漏洞：此阶段的提示引导 ChatGPT 识别项目可能的安全威胁和漏洞。这是生成安全需求的关键步骤，因为这些需求将被设计用来解决潜在的威胁和漏洞。
生成项目特定的安全需求：基于识别出的威胁和漏洞，ChatGPT 生成了一个特定于项目的安全需求列表。这些需求将解决项目描述和威胁识别中确定的具体问题。
生成通用安全需求：除了项目特定的安全需求外，一些通用的安全原则适用于所有软件项目。通过促使 ChatGPT 提供这些信息，我们确保不仅解决了识别出的具体威胁，还遵循了安全软件开发的最佳实践。
优先考虑安全需求：最后，ChatGPT 被要求优先考虑这些需求。这很重要，因为资源通常是有限的，了解哪些需求最关键可以指导资源和工作的分配。

还有更多内容…

本方案为您提供了一种结构化方法，利用 ChatGPT 为特定软件项目生成安全需求。然而，还有许多扩展和适应该方案的途径：

为不同项目定制：本方案中概述的策略不仅适用于在线支付网关，还可适用于各种类型的项目。您可以根据不同类型的软件开发项目的具体情况定制提示。只需确保为 ChatGPT 提供足够的项目上下文，以便它提供精确和相关的响应。

提示

您可以使用在第二章中学到的输出格式化技术来指定您喜欢的输出格式，以便转换为正式文档。

对已识别威胁的详细分析：本方案提供了一个识别威胁并生成安全需求的高层次过程。但是，您可以通过向 ChatGPT 提出更具体的问题，例如威胁的潜在影响、缓解策略，甚至是探索这类威胁的现实实例，来更深入地了解每个已识别的威胁。
优化安全需求：您可以通过要求 ChatGPT 进一步详细说明每个需求，考虑风险水平、实施成本和潜在权衡等因素，来增强生成安全需求的过程。

记住，ChatGPT 的力量在于它能够根据收到的提示提供详细和信息丰富的响应。请不要犹豫，尝试各种提示和问题，以最大化 ChatGPT 在您的软件开发项目中的价值。

生成安全编码指南（设计阶段）

在这个方案中，您将利用 ChatGPT 的力量来创建健壮的安全编码指南，旨在满足您项目的特定安全要求。这是一份对软件开发人员、项目经理、安全专业人士或任何涉及安全软件系统开发的人来说都是无价的指南。

利用在第一章中介绍的 ChatGPT 的基础知识，并在第二章中扩展，本方案将带您了解生成详细安全编码指南的过程。这些指南将根据您的具体项目进行定制，并将包含安全开发的最佳实践，例如安全会话管理、错误处理和输入验证。

在整个方案中，您将学会制定有效的提示，以引出与安全编码实践相关的高质量、信息丰富的输出。在此处，前几章介绍的增强输出的技巧，如使用模板增强输出和将输出格式化为表格，将会派上用场。它们将允许您设计出产生所需输出格式的提示，以涵盖安全编码的每个方面。

与前两个提示一样，此提示的输出可以编译为一份全面的安全编码指南文档。

准备就绪

在深入研究本文之前，请确保您已经完全掌握了使用 ChatGPT 进行提示生成，正如第一章所述。本文不需要额外的设置。

有了这些先决条件，现在您已经准备好借助 ChatGPT 的帮助，着手生成您的开发项目的安全编码指南之旅。

如何操作…

在本文中，我们将为 ChatGPT 设置系统角色，然后深入研究一系列提示，以创建一套针对特定项目量身定制的全面的安全编码指南。对于我们的实际应用，让我们假设我们正在开发一款安全的医疗应用程序，涉及敏感患者数据。

首先登录到您的 ChatGPT 帐户，并转到 ChatGPTWeb 用户界面。
点击新聊天按钮，与 ChatGPT 开始新对话。

输入以下提示以建立系统角色：

You are a veteran software engineer with extensive experience in secure coding practices, particularly in the healthcare sector.
1

接下来，我们将深入了解特定于我们项目的安全编码的一般理解：

Provide a general overview of secure coding and why it's important in healthcare software development.
1

生成特定语言的安全编码指南。对于我们的医疗应用程序，让我们假设它是用 Python 开发的：
```
What are the key secure coding practices to follow when developing healthcare software in Python?
1
```

接下来，请求有关安全输入验证的指南，这对于防止无效或有害数据至关重要：

What guidelines should be followed for secure input validation when developing a healthcare application?
1

正确处理错误和异常可以预防许多安全漏洞。让我们请求关于特定于我们项目的安全错误和异常处理的信息：
```
What are the best practices for secure error and exception handling in healthcare software development?
1
```
会话管理对于处理患者健康记录等敏感数据的应用程序特别重要。让我们询问特定于我们项目的安全会话管理最佳实践：
```
What are the best practices for secure session management in healthcare web application development?
1
```

询问处理数据库操作的安全编码实践，特别是考虑到医疗数据的敏感性：

What are the best practices to ensure secure coding when a healthcare application interacts with databases?
1

由于医疗应用程序通常需要与其他系统进行通信，网络通信安全至关重要。让我们深入了解特定于我们应用程序的网络通信安全编码实践：
```
What secure coding practices should be followed when managing network communications in healthcare software development?
1
```

最后，询问有关审查和测试代码安全性的指南，这对于发现任何安全漏洞至关重要：

What approach should be taken to review code for security issues in a healthcare application, and what types of tests should be conducted to ensure security?
1

跟随 ChatGPT 的提示将为医疗软件开发背景下的安全编码实践提供全面指南。始终记得调整这些提示以适应您自己项目或行业的具体情况。

工作原理…

在整个流程中，提示语经过精心构造，旨在从 ChatGPT 中引出详细、准确和全面的安全编码指南。所获得的回应将特定于医疗软件开发领域，为开发人员提供了创建安全医疗应用程序的宝贵资源。这展示了 ChatGPT 根据行业特定考虑来协助生成安全编码指南的能力。以下是每个步骤的工作方式的详细说明（特别是第 3-11 步）。

系统角色：通过定义 ChatGPT 作为经验丰富的软件工程师的角色，专门擅长医疗领域的安全编码实践，我们为生成专注、知情和行业特定的建议设置了正确的上下文。
理解安全编码：此步骤通过获取安全编码实践的高级概览来发起对话。ChatGPT 在这里提供的见解奠定了理解安全编码重要性的基础，特别是在医疗这样敏感的领域。
特定语言的安全编码：此提示邀请特定语言的安全编码指南。由于安全编码实践在编程语言之间可能有所不同，这对于在 Python 中开发安全的医疗软件至关重要。
输入验证：通过请求有关安全输入验证的指南，我们确保生成的编码指南将涵盖安全编码的一个关键方面，即防止有害或格式错误的输入数据。
错误和异常处理：正确的错误和异常处理是安全编码的基石。该提示旨在挖掘最佳实践，帮助创建稳健和安全的医疗软件。
安全会话管理：该提示旨在收集关于安全会话管理的信息，对于处理敏感数据的应用程序，如医疗应用程序中的患者记录，这是至关重要的。
安全编码中的数据库操作：与数据库的安全交互是安全编码的关键方面，特别是在数据敏感性至关重要的医疗行业。该提示针对此领域，以确保生成的编码指南是全面的。
网络通信中的安全编码：通过询问网络通信的安全编码实践，指南还涵盖了在数据传输过程中安全处理数据的内容，在医疗软件中是一个常见的漏洞区域。
代码审查和安全测试：最后一个提示确保安全编码指南包括对代码进行审查和测试以发现安全漏洞的过程，这是创建安全软件的必不可少的部分。

还有更多…

该方法为使用 Python 对医疗软件项目特别创建安全编码指南提供了一个有用的框架（您可以针对任何其他特定的应用程序或项目进行自定义）。但是，ChatGPT 的适应能力允许进行更多自定义和更深入的理解：

为不同项目或语言进行自定义：本方法中概述的原则和结构可以针对各种项目和编程语言进行定制。例如，如果您正在使用 JavaScript 开发电子商务平台，您可以调整提示中的上下文以适应该场景。
对每个安全编码主题进行详细探索：该方法提供了安全编码指南的广泛视图。要更深入地了解任何给定主题，您可以询问 ChatGPT 更具体的问题。例如，对于安全输入验证，您可以询问有关验证不同类型的输入数据（如电子邮件、URL 或文本字段）的最佳实践。

记住，ChatGPT 的力量不仅在于其生成详细和有见地的回复的能力，还在于其灵活性。鼓励您尝试不同的提示、上下文和问题，以从这个生成式 AI 工具中获取最大的价值。

分析代码中的安全缺陷并生成定制的安全测试脚本（测试阶段）

在这个方法中，您将使用 ChatGPT 来识别代码中潜在的安全漏洞，并生成用于安全测试的定制脚本。这种方法对软件开发人员、质量保证工程师、安全工程师以及所有参与创建和维护安全软件系统的人员都是一项宝贵的工具。

利用之前章节对 ChatGPT 和 OpenAI API 的基础知识，此方法指导您完成对代码的初步安全审查，并开发针对性的安全测试。ChatGPT 可以通过审查提供的代码片段，识别潜在的安全漏洞，然后帮助您根据这些潜在漏洞创建定制的测试脚本。

您将学会制定有效的提示，以引出关于代码潜在安全问题的高质量、有深刻见解的回复。之前章节中的技术，如使用模板完善输出并以特定格式呈现输出，将会证明很有用，使您能够设计出既用于代码分析又用于测试脚本创建的期望输出的提示。

此外，您将了解如何使用OpenAI API 和 Python来促进审查您的代码和生成测试脚本的过程。这种方法可以导致更高效、全面的安全测试过程，并可以与您的开发和质量保证团队共享。

准备就绪

在深入研究本篇文章之前，请确保您的 OpenAI 账户已设置并且您可以访问您的 API 密钥。如果您还没有设置好这个或者需要恢复，请参考前几章。

另外，您需要在开发环境中安装某些 Python 库。这些库对于成功运行本篇文章中的脚本至关重要。以下是这些库及其安装命令：

openai：这是官方的 OpenAI API 客户端库，我们将使用它来与 OpenAI API 交互。使用pip install openai命令来安装它。
os：这是一个内置的 Python 库，因此不需要安装。我们将使用它与操作系统交互，特别是从您的环境变量中获取 OpenAI API 密钥。
ast：这是另一个内置的 Python 库。我们将使用它来将我们的 Python 源代码解析成抽象语法树，这将使我们更好地理解代码的结构。
NodeVisitor：这是来自ast库的一个辅助类，我们将用它来访问我们抽象语法树的节点。
threading：这是一个内置的 Python 多线程库。我们将使用它来创建一个显示与 OpenAI API 通信时已经过的时间的新线程。
time：这也是一个内置的 Python 库。我们将使用它来在循环的每一次迭代中暂停我们的已经过的时间线程一秒钟。

有了这些先决条件的满足，您就可以使用 ChatGPT 和 OpenAI API 的帮助，为您的 Python 脚本生成有意义的评论并创建全面的文档。

如何做…

在本节中，我们将利用 ChatGPT 的专业知识来识别简单代码片段中的潜在安全漏洞。这些示例涵盖常见的安全漏洞，但请记住，在现实场景中，您分析的代码可能复杂得多。以下是步骤：

重要提示

这些都是仅供教育目的的简化代码片段。当您将这种方法应用到您自己的代码时，请记住根据您的代码的复杂性和语言来调整提示。如果您的代码段太大，您可能需要将其分解成较小的部分以适应 ChatGPT 的输入限制。

首先，请登录到您的 ChatGPT 账户并导航到 ChatGPT 网络用户界面。
点击新建聊天按钮，与 ChatGPT 开始新的对话。

输入以下提示来建立一个系统角色：

You are a seasoned security engineer with extensive experience in reviewing code for potential security vulnerabilities.
1

审查 SQL 注入漏洞的代码片段：引导 ChatGPT 分析一个与数据库交互的基本 PHP 代码片段，并要求它识别任何潜在的安全漏洞。

Please review the following PHP code snippet that interacts with a database. Identify any potential security flaws and suggest fixes:
$username = $_POST['username'];
$password = $_POST['password'];
$sql = "SELECT * FROM users WHERE username = '$username' AND password = '$password'";
$result = mysqli_query($conn, $sql);
1
2
3
4
5

审查跨站脚本（XSS）漏洞的代码片段：现在，请 ChatGPT 分析一个基本的 JavaScript 代码片段，以查找潜在的 XSS 漏洞。

Please review the following JavaScript code snippet for a web application. Identify any potential security flaws and suggest fixes:
let userContent = document.location.hash.substring(1);
document.write("<div>" + userContent + "</div>");
1
2
3

审查代码片段以识别不安全的直接对象引用（IDOR）漏洞：最后，请 ChatGPT 分析一个 Python 代码片段，以识别潜在的 IDOR 漏洞：

Please review the following Python code snippet for a web application. Identify any potential security flaws and suggest fixes:
@app.route('/file', methods=['GET'])
def file():
    file_name = request.args.get('file_name')
    return send_from_directory(APP_ROOT, file_name)
1
2
3
4
5

在该步骤的 还有更多… 部分，我们将探讨如何使用 OpenAI API 根据 ChatGPT 发现的潜在安全漏洞生成自定义脚本进行安全测试。

工作原理…

在整个步骤中，提示被设计得清晰而简洁，引导 ChatGPT 提供详细和专注的回答。每个步骤都建立在前一个步骤的基础上，利用 AI 的分析能力不仅可以识别代码中的潜在缺陷，还可以提出解决方案并帮助生成测试脚本。因此，该步骤提供了一个全面的指南，教你如何分析代码中的安全漏洞，并利用 ChatGPT 的帮助创建自定义安全测试脚本。以下是每个步骤的工作原理（特别是 步骤 3-6）的详细说明：

系统角色：ChatGPT 的系统角色被设定为有经验的软件工程师，具有安全编码实践经验。这为 AI 模型奠定了基础，使其能够为潜在的安全漏洞提供准确和相关的代码分析。
安全漏洞代码分析：我们首先向 ChatGPT 提供一个代码片段样本，并要求其分析其中的潜在安全漏洞。在这里，ChatGPT 像一名经验丰富的软件工程师一样审查代码，检查典型的安全问题，如 SQL 注入漏洞、密码管理薄弱、缺乏输入验证等等。这使我们能够在短时间内获得对代码的专业审查。
识别潜在缺陷：在分析代码之后，ChatGPT 提供了对代码片段中发现的潜在安全漏洞的摘要。这包括漏洞的性质、其潜在影响以及发现漏洞的代码部分。这些详细信息的具体性使我们能够更深入地理解漏洞。
为已识别的漏洞提供修复建议：一旦识别出潜在的漏洞，ChatGPT 就会提出可能的解决方案。这是安全编码中的关键步骤，因为它不仅有助于改进现有的代码，还能教育如何预防未来代码中出现类似问题的最佳实践。

还有更多…

您可以通过使用 Python 脚本与 OpenAI API 扩展此步骤的功能和灵活性，以审查您的源代码并生成测试脚本。以下是如何实现的：

首先导入必要的库：

import openai
from openai import OpenAI
import os
import ast
from ast import NodeVisitor
import threading
import time
1
2
3
4
5
6
7

设置 OpenAI API 的方式与我们在 设置 OpenAI API 密钥为环境变量 一节中所做的一样，详情请参见 第一章 中的内容：

openai.api_key = os.getenv("OPENAI_API_KEY")
1

定义一个 Python 抽象语法树（AST）访问者，以访问源代码的每个节点：
```
class CodeVisitor(NodeVisitor):
    ...
1
2
```
此类将访问 Python 源代码的每个节点。它是 Python 的ast模块的NodeVisitor类的子类。
定义一个函数来审查源代码：
```
def review_code(source_code: str) -> str:
    ...
    return response['choices'][0]['message']['content'].strip()
1
2
3
```
此函数将 Python 源代码的字符串作为输入，并将其作为提示的一部分发送到 OpenAI API，要求其识别潜在的安全漏洞并提供测试步骤。它从 API 响应中返回生成的测试步骤。
定义一个函数，将生成的测试步骤转换为 Python 测试脚本：
```
def generate_test_script(testing_steps: str, output_file: str):
    with open(output_file, 'w') as file:
        file.write(testing_steps)
1
2
3
```
此函数接受生成的测试步骤和输出文件名，然后将测试步骤保存到输出文件中作为 Python 测试脚本。

从文件加载源代码并在其上运行CodeVisitor：

# Change the name of the file to match your source
with open('source_code.py', 'r') as file:
    source_code = file.read()
    visitor = CodeVisitor()
    visitor.visit(ast.parse(source_code))
1
2
3
4
5

重要提示

在为每个部分生成内容时，请注意输入长度和令牌限制。如果您的部分内容或代码太大，则可能需要将其拆分为较小的部分。

使用 OpenAI API 审查代码并生成测试步骤：
```
testing_steps = review_code(source_code)
1
```

将生成的测试步骤保存为 Python 测试脚本：

test_script_output_file = "test_script.py"
generate_test_script(testing_steps, test_script_output_file)
1
2

显示等待 API 调用完成的经过的时间：
```
def display_elapsed_time():
    ...
1
2
```
此函数显示等待 API 调用完成的时间（以秒为单位）。

完成的脚本如下所示：

import openai
from openai import OpenAI
import os
import ast
from ast import NodeVisitor
import threading
import time
# Set up the OpenAI API
openai.api_key = os.getenv("OPENAI_API_KEY")
class CodeVisitor(NodeVisitor):
    def __init__(self):
        self.function_defs = []
    def visit_FunctionDef(self, node):
        self.function_defs.append(node.name)
        self.generic_visit(node)
def review_code(source_code: str) -> str:
    messages = [
        {"role": "system", "content": "You are a seasoned security engineer with extensive experience in reviewing code for potential security vulnerabilities."},
        {"role": "user", "content": f"Please review the following Python code snippet. Identify any potential security flaws and then provide testing steps:\n\n{source_code}"}
    ]

    client = OpenAI()

    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=2048,
        n=1,
        stop=None,
        temperature=0.7,
    )
    return response.choices[0].message.content.strip()
def generate_test_script(testing_steps: str, output_file: str):
    with open(output_file, 'w') as file:
        file.write(testing_steps)
def display_elapsed_time():
    start_time = time.time()
    while not api_call_completed:
        elapsed_time = time.time() - start_time
        print(f"\rCommunicating with the API - Elapsed time: {elapsed_time:.2f} seconds", end="")
        time.sleep(1)
# Load the source code
# Change the name of the file to match your source
with open('source_code.py', 'r') as file:
    source_code = file.read()
visitor = CodeVisitor()
visitor.visit(ast.parse(source_code))
api_call_completed = False
elapsed_time_thread = threading.Thread(target=display_elapsed_time)
elapsed_time_thread.start()
# Handle exceptions during the API call
try:
    testing_steps = review_code(source_code)
    api_call_completed = True
    elapsed_time_thread.join()
except Exception as e:
    api_call_completed = True
    elapsed_time_thread.join()
    print(f"\nAn error occurred during the API call: {e}")
    exit()
# Save the testing steps as a Python test script
test_script_output_file = "test_script.py"
# Handle exceptions during the test script generation
try:
    generate_test_script(testing_steps, test_script_output_file)
    print("\nTest script generated successfully!")
except Exception as e:
    print(f"\nAn error occurred during the test script generation: {e}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

此示例演示了 OpenAI API 如何在 Python 脚本中使用，以自动化识别代码中的漏洞并生成测试脚本的过程。

此脚本首先通过导入必要的模块来启动，即openai、os和docx。导入模块后，使用从环境变量中获取的 API 密钥设置了 OpenAI API。

在此之后，定义了两种类型文档的结构——设计文档和用户指南。这些结构只是包含最终文档中将构成的各节标题的列表。

接下来定义了generate_section_content()函数，它用于为文档的每个部分创建内容。它使用了 ChatGPT，通过一个针对给定文档某个部分的声明来生成内容，给定一些 Python 源代码。然后将响应作为字符串返回。

write_to_word_document()函数随后，利用了python-docx库中的Document类。此函数为每个部分标题添加一个标题，为该部分内容添加一个段落，并将其写入指定的文档中。

然后从名为source_code.py的文件中加载要分析的源代码，借助 Python 的内置open()函数。

现在开始创建设计文档。创建一个新的文档实例，并使用循环遍历design_doc_structure中定义的每个部分标题。在每次迭代中，循环使用generate_section_content()函数为部分生成内容，并使用write_to_word_document()函数将此内容写入设计文档。

重复这个过程以用于用户指南，而不是遍历user_guide_structure。

最后，脚本使用Document类的save()方法保存创建的文件。结果，您将获得一个基于提供的源代码由 ChatGPT 生成的设计文档和用户指南。

提示

如果您是 ChatGPT Plus 的订阅者，您可以将gpt-3.5-turbo模型替换为GPT-4模型，通常会获得改进的结果。只需记住GPT-4模型的价格比gpt-3.5-turbo模型稍贵一些。通过降低温度值，您还可以提高准确性并获得更一致的输出。

该脚本将是您增强 Python 代码安全性的有力工具。通过自动化审查和测试过程，您可以确保更一致、更彻底的结果，节省时间，并提高项目的整体安全性。

生成代码注释和文档（部署/维护阶段）

在本示例中，我们将利用 ChatGPT 的力量使我们的 Python 脚本栩栩如生，通过生成全面的注释。作为软件开发人员，我们认识到为代码加注释可以增强其可读性，澄清不同代码段的目的和功能，并促进更容易的维护和调试。此外，注释还是指导未来可能会使用或开发我们代码的开发人员的重要路标。

在本示例的第一部分中，我们将提示 ChatGPT 为我们的 Python 脚本的每个部分提供注释。为了实现这一点，我们将展示 ChatGPT 扮演一位精通为 Python 代码撰写有意义注释的经验丰富的软件工程师的角色。

在本示例的第二部分中，我们将超越生成注释，创建深入的文档。在这里，我们将看到如何利用 ChatGPT 根据相同的 Python 脚本生成设计文档和用户指南。这些文档涵盖了大量信息，从软件架构和功能描述到安装和使用指南，对于确保我们的软件对其他开发人员和用户来说是可理解和可维护的至关重要。

准备就绪

在深入研究本示例之前，请确保您的 OpenAI 账户已设置并且您可以访问您的 API 密钥。如果您尚未设置或需要恢复，可以参考之前的章节。

此外，您需要在开发环境中安装某些 Python 库。这些库对于成功运行本示例中的脚本至关重要。以下是这些库及其安装命令：

openai: 这是官方 OpenAI API 客户端库，我们将使用它与 OpenAI API 进行交互。使用命令 pip install openai 安装它。
docx: 这是用于创建 Microsoft Word 文档的 Python 库。使用命令 pip install docx 安装它。

在满足这些先决条件后，您就可以准备利用 ChatGPT 和 OpenAI API 为您的 Python 脚本生成有意义的注释并创建全面的文档。

如何做…

在本节中，我们将使用 ChatGPT 为提供的 Python 脚本生成注释。在代码中添加注释有助于提高其可读性，有助于理解不同部分的功能和目的，并便于维护和调试。以下是步骤：

重要提示

请记住，要根据您的代码的复杂性和语言来调整提示内容。如果您的代码片段太大，您可能需要将其分解成较小的部分，以适应 ChatGPT 的输入限制。

**设置环境：**确保您的环境中安装了 OpenAI Python 包。这对于与 OpenAI API 进行交互至关重要。
```
import openai
from openai import OpenAI
import os
import re
1
2
3
4
```
初始化 OpenAI 客户端：创建一个 OpenAI 客户端实例并设置您的 API 密钥。这个密钥对于验证您对 OpenAI API 的请求是必需的。
```
client = OpenAI()
openai.api_key = os.getenv("OPENAI_API_KEY")
1
2
```
读取源代码：打开并读取您打算审核的 Python 源代码文件。确保文件与您的脚本在同一目录中或提供正确的路径。
```
with open('source_code.py', 'r') as file:
    source_code = file.read()
1
2
```

review_code，以源代码作为输入，并构建一个请求到 OpenAI API，要求它为代码添加有意义的注释。

def review_code(source_code: str) -> str:
    print("Reviewing the source code and adding comments.\n")
    messages = [
        {"role": "system", "content": "You are a seasoned security engineer with extensive experience in reviewing code for potential security vulnerabilities."},
        {"role": "user", "content": f"Please review the following Python source code. Recreate it with helpful and meaningful comments... Souce code:\n\n{source_code}"}
    ]
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=2048,
        n=1,
        stop=None,
        temperature=0.7,
    )
    return response.choices[0].message.content.strip()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

使用读取的源代码来获取已审核和已注释的代码。
```
reviewed_code = review_code(source_code)
1
```

输出已审核的代码：将添加了注释的已审核代码写入一个新文件，确保清除 API 响应引入的任何格式。

with open('source_code_commented.py', 'w') as file:
    reviewed_code = re.sub(r'^```.*\n', '', reviewed_code)  # 清理

reviewed_code = re.sub(r'```py$', '', reviewed_code)  # Cleanup
    file.write(reviewed_code)
1
2
3
4
5

完成信息：打印一条消息，指示审核过程的完成以及已创建有注释的代码文件。

print("The source code has been reviewed and the comments have been added to the file source_code_commented.py")
Here's how the complete script should look.
import openai
from openai import OpenAI 
import os
import re
client = OpenAI()
openai.api_key = os.getenv("OPENAI_API_KEY")
# open a souce code file to provide a souce code file as the source_code parameter
with open('source_code.py', 'r') as file:
    source_code = file.read()
def review_code(source_code: str) -> str:
    print(f"Reviewing the source code and adding comments.\n")
    messages = [
        {"role": "system", "content": "You are a seasoned security engineer with extensive experience in reviewing code for potential security vulnerabilities."},
        {"role": "user", "content": f"Please review the following Python source code. Recreate it with helpful and meaningful comments that will help others identify what the code does. Be sure to also include comments for code/lines inside of the functions, where the use/functionality might be more complex Use the hashtag form of comments and not triple quotes. For comments inside of a function place the comments at the end of the corresponding line. For function comments, place them on the line before the function. Souce code:\n\n{source_code}"}
    ]
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=2048,
        n=1,
        stop=None,
        temperature=0.7,
    )
    return response.choices[0].message.content.strip()
reviewed_code = review_code(source_code)
# Output the reviewed code to a file called source_code_commented.py
with open('source_code_commented.py', 'w') as file:
    # Remove the initial code block markdown from the response
    reviewed_code = re.sub(r'^```.*\n', '', reviewed_code)

# 从响应中删除最终的代码块标记

reviewed_code = re.sub(r'```py$', '', reviewed_code)
    file.write(reviewed_code)
print("The source code has been reviewed and the comments have been added to the file source_code_commented.py")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

该脚本展示了人工智能在自动增强源代码文档中的实际应用。通过利用 OpenAI API，它为代码添加了有价值的注释，使其更易于理解和维护，特别是对于需要彻底文档的团队和项目。

运作原理…

该脚本演示了如何利用 OpenAI API 为 Python 源代码文件增加有意义的注释，从而提高代码的可读性和可维护性。脚本的每个部分在实现这一目标中扮演着至关重要的角色：

库导入和 OpenAI 客户端初始化：该脚本从导入必要的 Python 库开始：openai 用于与 OpenAI API 交互，os 用于访问环境变量（如 API 密钥），re 用于处理 AI 响应中使用的正则表达式。创建并使用存储在环境变量中的 API 密钥的 OpenAI 客户端实例进行身份验证。这个设置对于安全地向 OpenAI 服务发出请求至关重要。
source_code.py）。该文件预计包含需要注释但最初不包含任何注释的代码。该脚本使用 Python 的内置文件处理将文件内容读入字符串变量中。
review_code函数是核心功能所在。它构建描述 AI 模型任务的提示，包括审查提供的源代码并添加有意义的注释。提示通过使用chat.completions.create方法发送到 OpenAI API，指定要使用的模型（gpt-3.5-turbo）和其他参数，如max_tokens以控制生成输出的长度。该函数返回 AI 生成的内容，其中包括原始源代码和添加的注释。
source_code_commented.py）。这一步使增强的代码可以进一步审查或使用。

这还不是全部…

在*如何操作…*章节中，我们利用 ChatGPT 生成了代码注释。这是确保我们的软件可维护且容易理解的重要步骤。然而，我们可以进一步使用 ChatGPT 生成更全面的文档，如设计文档和用户指南。以下是执行此操作的步骤：

设置环境：类似于前面的章节，你需要先导入必要的模块并设置 OpenAI API：

import openai
from openai import OpenAI
import os
from docx import Document
openai.api_key = os.getenv("OPENAI_API_KEY")
1
2
3
4
5

定义设计文档和用户指南的结构：设计文档和用户指南的结构可能如下所示：

design_doc_structure = [
    "Introduction",
    "Software Architecture",
    "Function Descriptions",
    "Flow Diagrams"
]
user_guide_structure = [
    "Introduction",
    "Installation Guide",
    "Usage Guide",
    "Troubleshooting"
]
1
2
3
4
5
6
7
8
9
10
11
12

为每个章节生成内容：然后我们可以使用 ChatGPT 为每个章节生成内容。以下是生成设计文档中“软件架构”章节的示例：

def generate_section_content(section_title: str, source_code: str) -> str:
    messages = [
        {"role": "system", "content": f"You are an experienced software engineer with extensive knowledge in writing {section_title} sections for design documents."},
        {"role": "user", "content": f"Please generate a {section_title} section for the following Python code:\n\n{source_code}"}
    ]
    client = OpenAI()

    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=2048,
        n=1,
        stop=None,
        temperature=0.7,
    )
    return response.choices[0].message.content.strip()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

重要提示

在为每个章节生成内容时要注意输入长度和令牌限制。如果章节内容或代码太长，可能需要将其拆分为较小的部分。

加载源代码：我们需要加载作为提示和 GPT 引用的源代码文件：

with open('source_code.py', 'r') as file:
    source_code = file.read()
1
2

python-docx库：

def write_to_word_document(document: Document, title: str, content: str):
    document.add_heading(title, level=1)
    document.add_paragraph(content)
1
2
3

为每个章节和文档重复这个过程：然后我们可以为设计文档和用户指南的每个章节重复这个过程。以下是创建设计文档的示例：

design_document = Document()
for section in design_doc_structure:
    section_content = generate_section_content(section, source_code)
    write_to_word_document(design_document, section, section_content)
design_document.save('DesignDocument.docx')
1
2
3
4
5

下面是完成后的代码样式：

import openai
from openai import OpenAI 
import os
from docx import Document
# Set up the OpenAI API
openai.api_key = os.getenv("OPENAI_API_KEY")
# Define the structure of the documents
design_doc_structure = [
    "Introduction",
    "Software Architecture",
    "Function Descriptions",
    "Flow Diagrams"
]
user_guide_structure = [
    "Introduction",
    "Installation Guide",
    "Usage Guide",
    "Troubleshooting"
]
def generate_section_content(section_title: str, source_code: str) -> str:
    messages = [
        {"role": "system", "content": f"You are an experienced software engineer with extensive knowledge in writing {section_title} sections for design documents."},
        {"role": "user", "content": f"Please generate a {section_title} section for the following Python code:\n\n{source_code}"}
    ]
    client = OpenAI()

    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=2048,
        n=1,
        stop=None,
        temperature=0.7,
    )
    return response.choices[0].message.content.strip()
def write_to_word_document(document: Document, title: str, content: str):
    document.add_heading(title, level=1)
    document.add_paragraph(content)
# Load the source code
with open('source_code.py', 'r') as file:
    source_code = file.read()
# Create the design document
design_document = Document()
for section in design_doc_structure:
    section_content = generate_section_content(section, source_code)
    write_to_word_document(design_document, section, section_content)
design_document.save('DesignDocument.docx')
# Create the user guide
user_guide = Document()
for section in user_guide_structure:
    section_content = generate_section_content(section, source_code)
    write_to_word_document(user_guide, section, section_content)
user_guide.save('UserGuide.docx')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

该脚本首先导入必要的模块，包括openai、os和docx。导入模块后，使用来自环境变量的 API 密钥设置 OpenAI API。

接下来，脚本概述了设计文档和用户指南的结构。这些结构只是包含将构成最终文档的章节标题的数组。

随后定义了generate_section_content()函数。该函数使用 ChatGPT，给定一些 Python 源代码，提示生成指定章节的内容。然后将生成的响应作为字符串返回。

随后，要记录的 Python 源代码将通过 Python 的内置open()函数从名为source_code.py的文件中加载。

一旦加载了源代码，将启动设计文档的创建。创建了Document类的一个实例，并使用循环来迭代design_doc_structure中概述的每个部分标题。在每次迭代中，循环使用generate_section_content()函数为部分生成内容，并借助write_to_word_document()函数将此内容写入设计文档。

同样的过程也适用于用户指南，这次是在user_guide_structure上进行迭代。

最后，脚本利用Document类的save()方法保存创建的文档。因此，您将收到由 ChatGPT 根据提供的源代码自动生成的设计文档和用户指南两个。

一个需要记住的要点是，在为每个部分生成内容时，需要仔细注意输入长度和令牌限制。如果你的部分内容或代码过大，可能需要将其拆分为较小的部分。

这个脚本提供了一个强大的工具，可以简化您的软件文档编写过程。借助 ChatGPT 和 OpenAI API，您可以自动生成精确和全面的文档，从而增强了对 Python 代码的可理解性和可维护性。

第四章：治理、风险和合规性（GRC）

随着数字化景观变得越来越紧密和复杂，管理网络安全风险和保持合规性变得越来越具有挑战性。本章通过展示如何利用 ChatGPT 搭配 OpenAI API 的力量，极大地提高了网络安全基础设施的效率和效果，提供了富有洞见的解决方案。

在整章中，您将发现如何利用 ChatGPT 的能力生成全面的网络安全政策，简化政策制定的复杂任务。我们将带您走过一种创新方法，允许对政策文件的每个部分进行细粒度控制，提供了一个符合您特定业务需求的健壮的网络安全框架。

在此基础上，我们将深入探讨解读复杂的网络安全标准的微妙之处。ChatGPT 充当向导，将复杂的合规要求分解为可管理、清晰的步骤，从而为确保合规提供了简化的路径。

此外，我们将探讨网络风险评估的关键领域，揭示自动化如何革新这一重要流程。您将深入了解如何识别潜在威胁，评估漏洞，并推荐合适的控制措施，从而大幅提升您的组织管理网络安全风险的能力。

在风险评估之后，焦点转向有效地对这些风险进行优先排序。您将学习如何使用 ChatGPT 辅助创建基于各种风险相关因素的客观评分算法，从而使您能够战略性地分配资源来管理最高优先级的风险。

最后，我们将解决风险报告生成这一重要任务。详细的风险评估报告不仅作为确定的风险和缓解策略的宝贵记录，还确保了各利益相关者之间的清晰沟通。我们将演示如何使用 ChatGPT 自动创建这些报告，节省时间并确保所有文档的一致性。

在本章中，我们将涵盖以下内容：

安全政策和程序生成
ChatGPT 辅助的网络安全标准合规
创建风险评估流程
ChatGPT 辅助风险排名和优先级排序
构建风险评估报告

技术要求

对于本章，你将需要一个网络浏览器和稳定的互联网连接来访问 ChatGPT 平台并设置你的账户。你还需要设置好你的 OpenAI 账户并获取你的 API 密钥。如果没有，请参考第一章中的详细信息。对 Python 编程语言的基本熟悉以及使用命令行工作的经验是必要的，因为你将使用Python 3.x，它需要安装在你的系统上，用于与 OpenAI GPT API 交互和创建 Python 脚本。一个代码编辑器也是必不可少的，用于编写和编辑 Python 代码和提示文件，因为你将在本章的示例中使用它们。

本章的代码文件可以在这里找到：github.com/PacktPublishing/ChatGPT-for-Cybersecurity-Cookbook。

安全策略与程序生成

在本篇中，你将利用 ChatGPT 和 OpenAI API 的能力为你的组织生成一份全面的网络安全策略。对于希望创建符合其特定业务要求的健壮网络安全框架的 IT 管理员、**首席信息安全官（CISO）**和网络安全专业人员来说，这个过程是非常宝贵的。

基于前几章学到的知识，你将确立 ChatGPT 作为一名经验丰富的网络安全专业人员的角色，专注于治理、风险和合规（GRC）。你将学习如何使用 ChatGPT 生成一个组织良好的策略大纲，然后使用后续提示逐步填写每个部分的上下文。这种方法使你能够在 ChatGPT 的令牌限制和上下文窗口的情况下，对每个部分进行精细控制地生成综合文档。

另外，本篇将介绍如何使用 OpenAI API 和 Python 自动化策略生成过程，并随后生成一份网络安全策略作为 Microsoft Word 文档。这一步骤指南将为使用 ChatGPT 和 OpenAI API 生成详细和定制化的网络安全策略提供实用框架。

准备工作

在深入本篇之前，请确保你已经设置好你的 OpenAI 账户并准备好你的 API 密钥。如果没有，请参考第一章中的设置细节。你还需要确认你已安装以下 Python 库：

openai：这个库使你能够与 OpenAI API 进行交互。使用pip install openai命令安装它。
os：这是一个内置的 Python 库，允许你与操作系统进行交互，特别是用于访问环境变量。
docx：这个库用于生成 Microsoft Word 文档。使用pip install python-docx安装它。
markdown：此库用于将 Markdown 转换为 HTML，这对于生成格式化文档很有用。使用 pip install markdown 进行安装。
tqdm：此库用于在策略生成过程中显示进度条。使用 pip install tqdm 进行安装。

一旦您确认所有这些要求都已满足，您就可以开始使用 ChatGPT 和 OpenAI API 生成网络安全策略。

如何操作…

在本节中，我们将指导您使用 ChatGPT 生成与您组织需求一致的详细网络安全政策的过程。通过提供必要的细节并使用给定的系统角色和提示，您将能够生成一个结构良好的网络安全政策文档：

首先登录到您的 OpenAI 帐户，并导航到 ChatGPT Web UI。
通过单击新建聊天按钮与 ChatGPT 开始新对话。

输入以下系统角色以设置 ChatGPT 的上下文：

You are a cybersecurity professional specializing in governance, risk, and compliance (GRC) with more than 25 years of experience.
1

然后，输入以下消息文本，根据您组织的需求替换 { } 括号中的占位符。您可以将此提示与系统角色结合，也可以分开输入，如下所示（用您自己的公司名称和类型替换）：

Write a detailed cybersecurity policy outline for my company, {company name}, which is credit union. Provide the outline only, with no context or narrative. Use markdown language to denote the proper headings, lists, formatting, etc.
1

查看 ChatGPT 的输出。如果满意且符合您的要求，则可以继续下一步。如果不符合，您可以选择修改您的提示或重新运行对话以生成不同的输出。

从大纲中生成策略。对于大纲的每个部分，请使用以下内容提示 ChatGPT，将 {section} 替换为大纲中相应的部分标题：

You are currently writing a cybersecurity policy. Write the narrative, context, and details for the following section (and only this section): {section}. Use as much detail and explanation as possible. Do not write anything that should go in another section of the policy.
1

一旦您获得所需的输出，您可以直接将生成的响应复制并粘贴到 Word 文档或您选择的编辑器中，以创建一个全面的网络安全政策文档。

工作原理…

这种 GPT 辅助的网络安全政策创建配方利用了自然语言处理（NLP）和机器学习算法的力量，产生了一个定制的、全面的网络安全政策，以满足您组织的需求。通过扮演特定的系统角色并利用详细的用户请求作为提示，ChatGPT 能够调整其输出以满足网络安全专业人士的要求，这些人负责生成详细的政策。以下是这个过程如何运作的更深入的解释：

系统角色和详细提示：系统角色将 ChatGPT 描绘为一位经验丰富的网络安全专业人士，专业于 GRC。提示作为用户请求，详细描述了政策大纲的特定内容，从公司性质到网络安全政策的要求都有涉及。这些输入提供了上下文，并引导 ChatGPT 的响应，确保其满足政策创建任务的复杂性和要求。
自然语言处理和机器学习：NLP 和机器学习是 ChatGPT 能力的基础。它使用这些技术来理解用户请求的复杂性，学习模式，并生成详细、具体、全面的结构良好的网络安全政策。
知识和语言理解能力：ChatGPT 利用其广泛的知识库和语言理解能力，遵循行业标准方法和最佳实践。这在网络安全迅速发展的领域至关重要，确保生成的网络安全政策是最新的并符合公认标准。
迭代式政策生成：从生成的大纲中创建详细政策的过程涉及到逐步提示 ChatGPT 每个政策部分。这样做可以更精细地控制每个部分的内容，有助于确保政策结构良好、有条理。
简化政策创建流程：利用这个 GPT 辅助的网络安全政策创建配方的整体好处在于，它简化了创建全面网络安全政策的流程。它减少了政策制定所需的时间，允许生成符合行业标准和您组织特定需求的专业级政策。

通过采用这些详细的输入，您将 ChatGPT 转变为一个潜在的宝贵工具，可以帮助创建详尽、量身定制的网络安全政策。这不仅增强了您的网络安全姿态，还确保您的资源得到有效利用，保护您的组织。

还有更多…

在 ChatGPT 配方的基础上，您可以通过使用 OpenAI 的 API 来增强功能，不仅可以生成网络安全政策大纲，还可以填写每个部分的详细信息。当您想要即时创建详细文件或为具有不同要求的多家公司生成政策时，这种方法很有帮助。

此 Python 脚本采用与我们 ChatGPT 版本相同的思想，但 OpenAI API 提供的附加功能更多地控制了内容生成过程的灵活性。我们现在将讨论 OpenAI API 版本网络安全政策生成配方涉及的不同步骤：

导入必要的库并设置 OpenAI API：

import os
import openai
from openai import OpenAI
import docx
from markdown import markdown
from tqdm import tqdm
# get the OpenAI API key from environment variable
openai.api_key = os.getenv('OPENAI_API_KEY')
1
2
3
4
5
6
7
8

在这一步中，我们导入所需的库，如 openai、os、docx、markdown 和 tqdm。我们通过提供 API 密钥来设置 OpenAI API。

为网络安全政策大纲准备初始提示：

# prepare initial prompt
messages=[
    {
        "role": "system",
        "content": "You are a cybersecurity
            professional specializing in governance,
            risk, and compliance (GRC) with more than
            25 years of experience."
    },
    {
        "role": "user",
        "content": "Write a detailed cybersecurity
            policy outline for my company,
            {company name}, which is a credit union.
            Provide the outline only, with no context
            or narrative. Use markdown language to
            denote the proper headings, lists,
            formatting, etc."
    }
]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

使用两个角色的对话构建初始提示：系统和用户。系统消息设置上下文，告知 AI 模型其作为经验丰富的网络安全专业人员的角色。用户消息指导 AI 模型为信用联盟创建网络安全政策大纲，指定需要 Markdown 格式。

使用 OpenAI API 生成网络安全政策大纲：

print("Generating policy outline...")
try:
    client = OpenAI()
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=2048,
        n=1,
        stop=None,
        temperature=0.7,
    )
except Exception as e:
    print("An error occurred while connecting to the
        OpenAI API:", e)
    exit(1)
# get outline
outline =
    response.choices[0].message.content.strip()
print(outline + "\n")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

本部分将请求发送到 OpenAI API，成功后检索生成的政策大纲。

将大纲分成不同的部分，准备 Word 文档：
```
# split outline into sections
sections = outline.split("\n\n")
# prepare Word document
doc = docx.Document()
html_text = ""
1
2
3
4
5
```
在此我们将大纲分成不同的部分，每个部分都包含 Markdown 格式的标题或副标题。使用 docx.Document()函数初始化一个新的 Word 文档。

循环处理大纲的每个部分，生成详细信息：

# for each section in the outline
for i, section in tqdm(enumerate(sections, start=1),
total=len(sections), leave=False):
    print(f"\nGenerating details for section {i}...")
1
2
3
4

在此我们循环处理大纲的每个部分。使用tqdm函数显示进度条。

准备 AI 模型生成当前部分详细信息的提示：

    # prepare prompt for detailed info
    messages=[
        {
            "role": "system",
            "content": "You are a cybersecurity
                professional specializing in
                governance, risk, and compliance (GRC)
                with more than 25 years of
                experience."
        },
        {
            "role": "user",
            "content": f"You are currently writing a
                cybersecurity policy. Write the
                narrative, context, and details for
                the following section (and only this
                section): {section}. Use as much
                detail and explanation as possible. Do
                not write anything that should go in
                another section of the policy."
        }
    ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

准备 AI 模型生成当前部分详细信息的提示。

生成当前部分的详细信息并将其添加到 Word 文档中：

    try:
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=messages,
            max_tokens=2048,
            n=1,
            stop=None,
            temperature=0.7,
        )
    except Exception as e:
        print("An error occurred while connecting to
            the OpenAI API:", e)
        exit(1)
    # get detailed info
    detailed_info =
        response.choices[0].message.content.strip()
    # convert markdown to Word formatting
    doc.add_paragraph(detailed_info)
    doc.add_paragraph("\n")  # add extra line break
                               for readability
    # convert markdown to HTML and add to the
      html_text string
    html_text += markdown(detailed_info)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在此我们使用 OpenAI API 为当前部分生成详细信息。Markdown 格式的文本转换成 Word 格式，并添加到 Word 文档中。还将其转换为 HTML，并添加到 html_text 字符串中。

保存当前 Word 和 HTML 文档的状态：

    # save Word document
    print("Saving sections...")
    doc.save("Cybersecurity_Policy.docx")
    # save HTML document
    with open("Cybersecurity_Policy.html", 'w') as f:
        f.write(html_text)
1
2
3
4
5
6

每处理完一个部分，都会保存 Word 文档和 HTML 文档的当前状态。这样，即使脚本中断，也不会丢失任何进度。

处理完所有部分后，打印完成消息：
```
print("\nDone.")
1
```

这是脚本的完整样子：

import os
import openai
from openai import OpenAI
import docx
from markdown import markdown
from tqdm import tqdm
# get the OpenAI API key from environment variable
openai.api_key = os.getenv('OPENAI_API_KEY')
# prepare initial prompt
messages=[
    {
        "role": "system",
        "content": "You are a cybersecurity professional
            specializing in governance, risk, and
            compliance (GRC) with more than 25 years of
            experience."
    },
    {
        "role": "user",
        "content": "Write a detailed cybersecurity policy
            outline for my company, XYZ Corp., which is a
            credit union. Provide the outline only, with no
            context or narrative. Use markdown language to
            denote the proper headings, lists, formatting,
            etc."
    }
]
print("Generating policy outline...")
try:
    client = OpenAI()
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=2048,
        n=1,
        stop=None,
        temperature=0.7,
    )
except Exception as e:
    print("An error occurred while connecting to the OpenAI
        API:", e)
    exit(1)
# get outline
outline =
    response.choices[0].message.content.strip()
print(outline + "\n")
# split outline into sections
sections = outline.split("\n\n")
# prepare Word document
doc = docx.Document()
html_text = ""
# for each section in the outline
for i, section in tqdm(enumerate(sections, start=1),
total=len(sections), leave=False):
    print(f"\nGenerating details for section {i}...")
    # prepare prompt for detailed info
    messages=[
        {
            "role": "system",
            "content": "You are a cybersecurity
                professional specializing in governance,
                risk, and compliance (GRC) with more than
                25 years of experience."
        },
        {
            "role": "user",
            "content": f"You are currently writing a
                cybersecurity policy. Write the narrative,
                context, and details for the following
                section (and only this section): {section}.
                Use as much detail and explanation as
                possible. Do not write anything that should
                go in another section of the policy."
        }
    ]
    try:
        response = client.chat.completions.createcreate(
            model="gpt-3.5-turbo",
            messages=messages,
            max_tokens=2048,
            n=1,
            stop=None,
            temperature=0.7,
        )
    except Exception as e:
        print("An error occurred while connecting to the
            OpenAI API:", e)
        exit(1)
    # get detailed info
    detailed_info =
        response.choices[0].message.content.strip()
    # convert markdown to Word formatting
    doc.add_paragraph(detailed_info)
    doc.add_paragraph("\n")  # add extra line break for
                               readability
    # convert markdown to HTML and add to the html_text
      string
    html_text += markdown(detailed_info)
    # save Word document
    print("Saving sections...")
    doc.save("Cybersecurity_Policy.docx")
    # save HTML document
    with open("Cybersecurity_Policy.html", 'w') as f:
        f.write(html_text)
print("\nDone.")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

此 Python 脚本自动化生成针对特定公司 XYZ Corp.（一家信用联盟）的详细网络安全政策大纲的过程。首先导入必要的库，设置 OpenAI API 密钥以及为 AI 模型准备初始提示，指示其生成政策大纲。

收到 OpenAI API 的成功响应后，脚本将策略大纲拆分为单独的部分以进一步详细描述。然后启动 Word 文档以记录这些详细信息。接着，脚本循环浏览策略大纲的每个部分，从 OpenAI API 中生成并附加详细信息到 Word 文档和 HTML 字符串中，有效地在 Word 和 HTML 格式中创建了一份详细的政策文件。

每次迭代之后，脚本都会确保文档已保存，以防中断导致数据丢失。一旦所有部分都被覆盖并且文档已保存，脚本就会表示其成功完成。因此，一个高级政策概要被扩展为一个详细的、全面的网络安全政策，在使用 OpenAI API 和 Python 完全自动化的过程中。

ChatGPT 辅助网络安全标准合规性

在这个食谱中，我们将指导您如何使用 ChatGPT 辅助网络安全标准合规性。本食谱建立在前几章获得的技能基础之上。理解网络安全标准的要求可能是复杂的，这是因为它们通常的书写方式。使用 ChatGPT，您可以简化这个任务。通过用网络安全标准的摘录提示 ChatGPT，模型可以帮助分解这些要求为更简单的术语，帮助您确定是否符合要求，以及如果不符合要采取哪些步骤来达到合规性。

准备工作

确保您可以通过登录您的 OpenAI 账户访问 ChatGPT 界面。随手准备一份网络安全标准文档，您可以从中引用摘录。

如何操作…

要利用 ChatGPT 来理解和检查网络安全标准的合规性，请按照以下步骤操作：

通过以下提示为 ChatGPT 分配一个角色：

You are a cybersecurity professional and CISO with 30 years of experience in the industrial cybersecurity industry.
1

您应该用您所在行业替换industrial。

然后提供 ChatGPT 您的提示：

"I need your help understanding the requirements of the NIST SP 800-82 revision 2 standard. I will give you the requirement ID, specifications, and any other supplemental information I have that is associated with the requirement. You will then explain the requirement to me in way that is easier to understand, and form a question based on the requirement to help me determine whether or not I comply with that requirement or not. You will follow up by asking me if I have any further questions about that requirement or if I'm ready to move to the next requirement. If I have another question regarding that requirement, we will continue discussing the requirement in this manner. If I tell you I'm ready to move on to the next requirement, we will start this process again with the next requirement."
1

记得用您正在处理的网络安全标准替换'NIST SP 800-82 revision 2 standard'。

提供 ChatGPT 第一个需求 ID、规范以及任何补充信息：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图 4.1 – ChatGPT 对标准要求查询的响应示例

通过与 ChatGPT 进行对话来深入了解特定需求或继续下一步：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图 4.2 – ChatGPT 对标准要求对话的响应示例

它是如何工作的…

当您为 ChatGPT 分配一个角色时，您为模型提供一个特定的上下文或角色，以便模型处理。这有助于模型生成符合给定角色的响应，从而产生更准确、相关和详细的内容。

在理解和检查与网络安全标准的合规性相关的情境中，ChatGPT 使用其训练数据来解释标准摘录，并将其分解为更简单、更易于理解的术语。然后形成一个问题，帮助您确定您是否符合标准。

在整个过程中，您要与模型进行对话，要么深入了解特定要求，要么根据您的需求转移到下一个要求。

还有更多内容……

一旦您对此过程感到满意，您可以扩展它以涵盖各个行业中的不同标准。

以下是一些额外要考虑的要点：

ChatGPT 作为培训辅助工具：您也可以将其用作教学工具，利用 ChatGPT 提供的简化解释来教育组织内其他人有关不同网络安全标准的要求。使用模型生成对复杂标准易于理解的解释可以作为对更传统的培训形式的有用补充。
定期检查的重要性：定期使用 ChatGPT 来了解并检查网络安全标准的合规性可能更加有效。网络安全形势变化迅速，组织曾经合规的要求可能发生变化。定期检查能够帮助您的组织保持最新。
潜在的限制：值得指出的是，虽然 ChatGPT 是一个强大的工具，但它确实有局限性。其响应基于截至 2021 年 9 月的培训数据。因此，对于非常最新的标准或自那时以来已经显著更新的标准，其响应可能不完全准确。始终验证最新版本标准的信息是非常重要的。

重要说明

我们将在本书的后面讨论更多提供更新文档作为知识库的高级方法。

专业指导的重要性：虽然这种方法在理解网络安全标准的要求方面可以起到很大作用，但它并不能替代专业的法律或网络安全指导。合规这些标准往往具有法律意义，因此专业建议是必不可少的。在确定组织是否符合任何网络安全标准时，请始终咨询专业人士。
反馈和迭代：与任何 AI 工具一样，您使用 ChatGPT 越多，提供的反馈越多，它就能够更好地帮助您。反馈循环使模型能够随时间调整并提供更适合您需求的响应。

创建风险评估流程

网络风险评估是组织风险管理战略中必不可少的一部分。该过程涉及识别潜在威胁，评估这些威胁可能利用的漏洞，评估此类利用对组织可能产生的影响，并建议适当的控制措施来减轻风险。了解进行风险评估涉及的步骤可以极大增强组织管理网络安全风险的能力。

在此方案中，我们将指导您使用 Python 和 OpenAI API 创建一个网络风险评估过程。通过自动化风险评估过程，您可以简化工作流程，使安全操作更加高效。这种方法还可以提供进行风险评估的标准化格式，从而提高组织的一致性。

准备工作

在继续之前，您将需要以下内容：

Python。此方案与 Python 3.6 或更高版本兼容。
OpenAI API 密钥。如果您还没有，可以在注册后从 OpenAI 网站获取。
pip install openai。
Python docx 库用于创建 Word 文档。您可以使用 pip 安装它：pip install python-docx。
Python tqdm 库用于显示进度。您可以使用 pip 安装它：pip install tqdm。
Python threading 和 os 库通常可用于 Python。
熟悉 Python 编程和基本的网络安全概念。

如何实施…

让我们通过构建一个使用 OpenAI API 为我们的风险评估计划中的每个部分生成内容的脚本来开始创建我们的风险评估过程。该脚本将要求 ChatGPT 扮演一名专业从事 GRC 的网络安全专业人士的角色，为我们提供风险评估过程每个部分的详细叙述、上下文和细节：

导入必要的库：
```
import openai 
from openai import OpenAI
import os
from docx import Document
import threading
import time
from datetime import datetime
from tqdm import tqdm
1
2
3
4
5
6
7
8
```
此代码块导入了我们脚本所需的所有库：openai 用于与 OpenAI API 交互，os 用于环境变量，Document 从 docx 中用于创建 Word 文档，threading 和 time 用于管理 API 调用期间的时间显示，datetime 用于时间戳我们的报告，以及 tqdm 用于进度可视化。
设置 OpenAI API 密钥：
```
openai.api_key = os.getenv("OPENAI_API_KEY")
1
```
此代码设置了存储为环境变量的 OpenAI API 密钥。此密钥用于验证我们程序对 OpenAI API 的请求。
确定评估报告的唯一标识符：
```
current_datetime =
    datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
assessment_name =
    f"Risk_Assessment_Plan_{current_datetime}"
1
2
3
4
```
我们使用当前日期和时间为每个评估报告创建一个唯一名称，确保不会覆盖任何以前的报告。名称格式为 Risk_Assessment_Plan_{current_datetime}，其中 current_datetime 是运行脚本时的确切日期和时间。

定义风险评估的大纲：

# Risk Assessment Outline
risk_assessment_outline = [
    "Define Business Objectives",
    "Asset Discovery/Identification",
    "System Characterization/Classification",
    "Network Diagrams and Data Flow Review",
    "Risk Pre-Screening",
    "Security Policy & Procedures Review",
    "Cybersecurity Standards Selection and Gap
         Assessment/Audit",
    "Vulnerability Assessment",
    "Threat Assessment",
    "Attack Vector Assessment",
    "Risk Scenario Creation (using the Mitre ATT&CK
        Framework)",
    "Validate Findings with Penetration Testing/Red
        Teaming",
    "Risk Analysis (Aggregate Findings & Calculate
        Risk Scores)",
    "Prioritize Risks",
    "Assign Mitigation Methods and Tasks",
    "Create Risk Report",
]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在这里，我们定义了风险评估的大纲。大纲包含了要包括在风险评估过程中的所有部分的列表。

提示

您可以修改流程步骤以包括您认为合适的任何部分，模型将为您提供的任何部分填充上下文。

实现一个使用 OpenAI API 生成部分内容的函数：

def generate_section_content(section: str) -> str:
    # Define the conversation messages
    messages = [
        {
            "role": "system",
            "content": 'You are a cybersecurity
                professional specializing in
                governance, risk, and compliance (GRC)
                with more than 25 years of
                experience.'},
        {
            "role": "user",
            "content": f'You are
                currently writing a cyber risk
                assessment policy. Write the
                narrative, context, and details for
                the following section (and only
                this section): {section}. Use as much
                detail and explanation as possible. Do
                not write anything that should go in
                another section of the policy.'
        },
    ]
    # Call the OpenAI API
    client = OpenAI()
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=2048,
        n=1,
        stop=None,
        temperature=0.7,
    )
    # Return the generated text
    Return
        response.choices[0].message.content.strip()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

此函数以风险评估大纲中的部分标题作为输入，并使用 OpenAI API 为该部分生成详细内容。

实现将 Markdown 文本转换为 Word 文档的函数：

def markdown_to_docx(markdown_text: str, output_file: str):
    document = Document()
    # Iterate through the lines of the markdown text
    for line in markdown_text.split('\n'):
        # Add headings based on the markdown heading
          levels
        if line.startswith('# '):
            document.add_heading(line[2:], level=1)
        elif line.startswith('## '):
            document.add_heading(line[3:], level=2)
        elif line.startswith('### '):
            document.add_heading(line[4:], level=3)
        elif line.startswith('#### '):
            document.add_heading(line[5:], level=4)
        # Add paragraphs for other text
        else:
            document.add_paragraph(line)
    # Save the Word document
    document.save(output_file)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

此函数接受每个部分的生成的 Markdown 文本和所需的输出文件名作为输入，并使用相同的内容创建一个 Word 文档。

实现一个函数来显示等待 API 调用时经过的时间：

def display_elapsed_time():
    start_time = time.time()
    while not api_call_completed:
        elapsed_time = time.time() - start_time
        print(f"\rElapsed time: {elapsed_time:.2f}
            seconds", end="")
        time.sleep(1)
1
2
3
4
5
6
7

此函数负责在等待 API 调用完成时显示经过的时间。这对于跟踪过程花费的时间很有用。

开始生成报告的过程：
```
api_call_completed = False
elapsed_time_thread =
    threading.Thread(target=display_elapsed_time)
elapsed_time_thread.start()
1
2
3
4
```
在此处，我们启动一个单独的线程来显示经过的时间。这与执行 API 调用的主进程同时运行。

遍历风险评估大纲中的每个部分，生成部分内容，并将其附加到报告中：

# Generate the report using the OpenAI API
report = []
pbar = tqdm(total=len(risk_assessment_outline),
    desc="Generating sections")
for section in risk_assessment_outline:
    try:
        # Generate the section content
        content = generate_section_content(section)
        # Append the section content to the report
        report.append(f"## {section}\n{content}")
    except Exception as e:
        print(f"\nAn error occurred during the API
            call: {e}")
        exit()
    pbar.update(1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

此代码块循环遍历我们的风险评估大纲中的每个部分，在使用 OpenAI API 生成该部分的内容后，将生成的内容附加到我们的报告中。

当所有部分都已生成时，完成进度和经过的时间显示：
```
api_call_completed = True
elapsed_time_thread.join()
pbar.close()
1
2
3
```
将 api_call_completed 变量设置为 True 以指示所有 API 调用已完成。然后，我们停止经过的时间显示线程，并关闭进度条，以表示进程已结束。
最后，将生成的报告保存为 Word 文档：
```
# Save the report as a Word document
docx_output_file = f"{assessment_name}_report.docx"
# Handle exceptions during the report generation
try:
    markdown_to_docx('\n'.join(report),
        docx_output_file)
    print("\nReport generated successfully!")
except Exception as e:
    print(f"\nAn error occurred during the report
        generation: {e}")
1
2
3
4
5
6
7
8
9
10
```
在此最终步骤中，调用markdown_to_docx函数，并将生成的报告（以 Markdown 格式）和所需的输出文件名作为参数，以创建一个 Word 文档。文件名包含时间戳以确保其唯一性。此过程包装在 try-except 块中以处理此转换期间可能发生的任何异常。如果成功，我们打印出成功消息；如果发生错误，则打印异常以帮助排查问题。

最终脚本应如下所示：

import openai 
from openai import OpenAI
import os
from docx import Document
import threading
import time
from datetime import datetime
from tqdm import tqdm
# Set up the OpenAI API
openai.api_key = os.getenv("OPENAI_API_KEY")
current_datetime = datetime.now()
    .strftime('%Y-%m-%d_%H-%M-%S')
assessment_name =
    f"Risk_Assessment_Plan_{current_datetime}"
# Risk Assessment Outline
risk_assessment_outline = [
    "Define Business Objectives",
    "Asset Discovery/Identification",
    "System Characterization/Classification",
    "Network Diagrams and Data Flow Review",
    "Risk Pre-Screening",
    "Security Policy & Procedures Review",
    "Cybersecurity Standards Selection and Gap
        Assessment/Audit",
    "Vulnerability Assessment",
    "Threat Assessment",
    "Attack Vector Assessment",
    "Risk Scenario Creation (using the Mitre ATT&CK
        Framework)",
    "Validate Findings with Penetration Testing/Red
        Teaming",
    "Risk Analysis (Aggregate Findings & Calculate Risk
        Scores)",
    "Prioritize Risks",
    "Assign Mitigation Methods and Tasks",
    "Create Risk Report",
]
# Function to generate a section content using the OpenAI
  API
def generate_section_content(section: str) -> str:
    # Define the conversation messages
    messages = [
        {
            "role": "system",
            "content": 'You are a cybersecurity
                professional specializing in governance,
                risk, and compliance (GRC) with more than
                25 years of experience.'
        },
        {
            "role": "user",
            "content": f'You are currently writing a cyber
                risk assessment policy. Write the
                narrative, context, and details for the
                following section (and only this section):
                {section}. Use as much detail and
                explanation as possible.
                Do not write anything that should go in
                another section of the policy.'
        },
    ]
    # Call the OpenAI API
    client = OpenAI()
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=2048,
        n=1,
        stop=None,
        temperature=0.7,
    )
    # Return the generated text
    return response['choices'][0]['message']['content']
        .strip()
# Function to convert markdown text to a Word document
def markdown_to_docx(markdown_text: str, output_file: str):
    document = Document()
    # Iterate through the lines of the markdown text
    for line in markdown_text.split('\n'):
        # Add headings based on the markdown heading levels
        if line.startswith('# '):
            document.add_heading(line[2:], level=1)
        elif line.startswith('## '):
            document.add_heading(line[3:], level=2)
        elif line.startswith('### '):
            document.add_heading(line[4:], level=3)
        elif line.startswith('#### '):
            document.add_heading(line[5:], level=4)
        # Add paragraphs for other text
        else:
            document.add_paragraph(line)
    # Save the Word document
    document.save(output_file)
# Function to display elapsed time while waiting for the
  API call
def display_elapsed_time():
    start_time = time.time()
    while not api_call_completed:
        elapsed_time = time.time() - start_time
        print(f"\rElapsed time: {elapsed_time:.2f}
            seconds", end="")
        time.sleep(1)
api_call_completed = False
elapsed_time_thread =
    threading.Thread(target=display_elapsed_time)
elapsed_time_thread.start()
# Generate the report using the OpenAI API
report = []
pbar = tqdm(total=len(risk_assessment_outline),
    desc="Generating sections")
for section in risk_assessment_outline:
    try:
        # Generate the section content
        content = generate_section_content(section)
        # Append the section content to the report
        report.append(f"## {section}\n{content}")
    except Exception as e:
        print(f"\nAn error occurred during the API call:
            {e}")
        api_call_completed = True
        exit()
    pbar.update(1)
api_call_completed = True
elapsed_time_thread.join()
pbar.close()
# Save the report as a Word document
docx_output_file = f"{assessment_name}_report.docx"
# Handle exceptions during the report generation
try:
    markdown_to_docx('\n'.join(report), docx_output_file)
    print("\nReport generated successfully!")
except Exception as e:
    print(f"\nAn error occurred during the report
        generation: {e}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

现在，让我们看看它是如何工作的。

工作原理…

Python 脚本通过与 OpenAI API 交互来为风险评估过程的每个部分生成详细内容。内容是通过模拟用户和系统（ChatGPT）之间的对话生成的，其中系统扮演网络安全专业人士的角色。提供给 API 的对话消息描述了上下文，而 ChatGPT 根据该上下文生成了全面的响应。

在 OpenAI 聊天模型中，提供了一系列消息，每个消息都有一个角色和内容。角色可以是 system、user 或 assistant。system 角色通常用于设置 assistant 的行为，而 user 角色用于指示 assistant。

在此脚本中，我们首先使用消息 '您是一位专门从事治理、风险和合规（GRC）的网络安全专业人员，拥有超过 25 年的经验。' 来设置系统角色。这是为了告知模型上下文，使其以网络安全领域的经验丰富专业人士的身份进行响应。模型使用此上下文信息生成适当且特定于情景的响应。

用户角色的消息'您当前正在撰写一份网络风险评估政策。为以下部分编写叙述、上下文和详情（仅限于这一部分）：{section}。请尽可能详细和解释。不要写任何应该放在政策的其他部分中的内容。'，作为模型的具体提示。该提示指导模型为风险评估政策的特定部分生成详细叙述。它指示模型专注于当前部分，不要陷入属于其他部分的细节。通过这样做，我们确保生成的内容相关和准确，符合风险评估流程的结构。

因此，系统角色建立了助手的上下文和专业知识，而用户角色提供了助手执行的指令任务。这种方法有助于从 AI 中获取结构化和相关的内容。

该脚本被设计为单独处理风险评估流程的每个部分，对每个部分进行单独的 API 调用。它利用多线程显示 API 调用正在处理时的经过时间，以便给出进展的感知。

每个部分的生成内容以 Markdown 格式附加到报告中，然后使用 Python 的docx库将其转换为 Word 文档。这创造了一个结构良好、详细的风险评估计划，可用作组织进行风险评估的起点。

还有更多…

由该方案创建的风险评估流程具有灵活性。您可以尝试使用 ChatGPT 为不同部分编写内容，然后将这些概述部分插入脚本中，以实验生成自己的风险评估流程。这使您能够创建一个符合组织特定需求和风险配置文件的风险评估流程。请记住，最佳的风险评估流程是根据反馈和新见解不断更新和改进的流程。

ChatGPT 辅助风险排名和优先级排序

在这个方案中，我们将利用 ChatGPT 的能力，基于给定数据来优先和排名网络安全风险。在网络安全中，对风险进行优先排名是一个关键任务，它帮助组织将资源集中在最重要的地方。通过使用 ChatGPT，您可以使这项任务变得更加可管理和客观。

在给定场景中，我们有一个包括不同资产或系统的一系列与风险相关因素的数据集。这些因素包括资产类型、其重要性评级、所服务的业务功能、其攻击面的大小和评级、攻击向量的评级以及所采取的缓解和补救措施。

ChatGPT 将协助我们根据此数据创建评分算法来确定风险的优先级。由评分算法计算出的最高优先级风险将列在新表格的顶部。我们将使用样本数据指导您完成此过程，但您将来可以将同样的过程应用于自己的数据。

准备工作

确保你能够访问 ChatGPT 界面，方法是登录你的 OpenAI 账户。你还需要一个包含系统列表及其相关漏洞和风险数据的数据集。关于这个数据集的更多说明包含在本示例中。

如果你没有可用的数据集，可以使用本示例提供的数据集，可从github.com/PacktPublishing/ChatGPT-for-Cybersecurity-Cookbook下载。

如何做…

要开始风险排名和优先级确定，让我们向 ChatGPT 发送一个详细的提示。提示应清楚地说明任务，并提供必要的上下文和数据：

提示

你可以提供任何系统数据，只要它被分隔或标识出来，并且具有标头名称和可辨识的值，表示系统和漏洞的风险级别、严重程度、价值等，ChatGPT 可以使用这些值来创建适当的算法。

通过输入以下提示来确定系统角色：

You are a cybersecurity professional with 25 years of experience.
1

指示 ChatGPT 使用以下提示基于你的数据创建一个评分算法：

Based on the following dataset, categories, and values, create a suitable risk scoring algorithm to help me prioritize the risks and mitigation efforts. Provide me with the calculation algorithm and then create a new table using the same columns, but now ordered by highest priority to lowest (highest being on top) and with a new column all the way to the left containing the row number.
Data:
Asset/System Type    Criticality Rating    Business Function    Attack Surface Size    Attack Surface Rating    Attack Vector Rating    Mitigations and Remediations
Web Server 1    High    Sales    120    Critical    High    Firewall updates, SSL/TLS upgrades
Email Server    High    Communication    80    High    High    Spam filter updates, User training
File Server    Medium    HR    30    Medium    Medium    Apply software patches, Improve password policy
Print Server    Low    All    15    Low    Low    Apply firmware updates
Database Server 1    High    Sales    200    Critical    High    Update DB software, Enforce strong access control
Workstation 1    Low    Engineering    10    Low    Low    Install Antivirus, Apply OS patches
CRM Software    High    Sales    50    Medium    Medium    Update CRM software, Implement 2FA
ERP System    High    All    150    Critical    High    Update ERP software, Implement access control
IoT Device 1    Low    Maintenance    20    Medium    Low    Apply firmware updates, Change default passwords
Web Server 2    Medium    Marketing    60    Medium    Medium    SSL/TLS upgrades, Implement WAF
Virtual Machine 1    Low    Development    20    Low    Low    Apply OS patches, Enforce strong access control
Networking Switch    High    All    30    Medium    High    Firmware updates, Change default credentials
Mobile Device 1    Medium    Sales    25    Medium    Medium    Implement MDM, Enforce device encryption
Firewall    High    All    70    High    High    Firmware updates, Tighten rule sets
Cloud Storage    High    All    100    High    High    Apply cloud security best practices, Implement 2FA
VOIP Server    Medium    All    45    Medium    Medium    Apply patches, Implement strong access control
Payment Gateway    High    Sales    180    Critical    High    Implement PCI DSS, SSL/TLS upgrades
Router    High    All    30    Medium    High    Firmware updates, Change default credentials
WiFi AP    Medium    All    40    Medium    Medium    Firmware updates, Implement strong WiFi encryption
SAN Storage    High    All    60    High    High    Update SAN software, Implement access control
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

下图展示了由 ChatGPT 创建的评分算法输出示例：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图 4.3 – 评分算法输出示例

下面的代码是由 ChatGPT 生成的示例评分算法代码输出：

def calculate_risk_score(criticality_rating,
attack_surface_rating, attack_vector_rating):
    ratings = {"High": 3, "Medium": 2, "Low": 1}
    return ratings[criticality_rating] +
        ratings[attack_surface_rating] +
            ratings[attack_vector_rating]
1
2
3
4
5
6

下图展示了 ChatGPT 格式化输出的示例，列出了按算法创建的风险评分进行优先排序的资产：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图 4.4 – 优先级输出示例

提示

提供的提示中的数据是用制表符分隔的。你可以提供任何系统数据，只要它被分隔或标识出来，并且具有标头名称和可辨识的值，表示系统和漏洞的风险级别、严重程度、价值等，ChatGPT 可以使用这些值来创建适当的算法。

提示

本示例中使用的样本数据是使用以下提示生成的：

"生成我将用于假设风险评估示例的样本数据表。表格应至少包含 20 行，并包含以下列：

资产/系统类型，关键性评级，业务功能，攻击面大小（根据系统发现的漏洞数量衍生的值），攻击面评级（通过计算高危和严重程度评级与总攻击面的比率衍生的值），攻击向量评级（其他系统可接触到此系统的数量衍生的值，具有面向互联网的自动最高数量），需要针对此系统进行的缓解和修复措施清单（这通常将根据漏洞扫描结果的建议而产生，但对于此测试/样本数据，只是虚构了一些假设的）数据。"

如何运作…

ChatGPT 基于一种称为transformer的机器学习模型，具体来说是一种称为生成预训练变换器（Generative Pretrained Transformer，GPT）的变体。该模型已在各种互联网文本上进行了训练，已学习了语言模式和事实信息，并从这个广泛的语料库中具有某些推理能力。

在面临创建风险评分算法的任务时，ChatGPT 并不依赖于对网络安全或风险管理的固有理解。相反，它利用在训练阶段学到的模式。在训练过程中，它可能遇到了与风险评分算法、风险优先级排定和网络安全相关的文本。通过识别训练数据中这些信息的结构和上下文，当受到提示时，它能够生成相关连贯的回答。

创建风险评分算法时，ChatGPT 首先理解了数据中呈现的各种因素，如关键性评级、业务功能、攻击面大小、攻击面评级、攻击向量评级和缓解和修复措施。它明白到这些因素对确定每个资产相关的整体风险是重要的。然后，ChatGPT 制定了一个算法，考虑到了这些因素，为每个因素分配不同的权重和分数，根据它们在整体风险评估中的认知重要性。

接着，生成的算法被应用到数据中，为每一个风险得分，创建了一个新的按照这些分数进行排序的表格。这个排序过程有助于风险优先级排定 – 得分更高的风险被视为更加关键，并列在表格的顶部。

ChatGPT 的令人印象深刻之处在于，虽然它并不真正理解网络安全或人类意义上的风险评估，但基于它学到的模式，它可以相当令人信服地模仿这样的理解。它能够基于这些模式生成有创意和连贯的文本，使其成为一种用于各种任务的多功能工具，包括在本文档中生成风险评分算法。

还有更多…

这种方法受 ChatGPT 的令牌限制所限制。由于此限制，只能粘贴这么多数据。但是，在本书的后面，我们将提供使用更高级技术如何绕过此限制的配方。

提示

不同的模型有不同的令牌限制。如果您是 OpenAI Plus 的订阅者，可以在 GPT-3.5 和 GPT-4 模型之间选择。GPT-4 的令牌限制大小是 GPT-3.5 的两倍。此外，如果您使用 OpenAI Playground 而不是 ChatGPT UI，您可以使用新的 gpt-3.5-turbo-16k 模型，该模型的令牌限制是 GPT-3.5 的四倍。

构建风险评估报告

网络安全涉及管理和缓解风险，这个过程的一个重要部分是创建详细的风险评估报告。这些报告不仅记录了识别的风险、漏洞和威胁，还阐明了采取的措施，以便与各方清晰沟通。自动创建风险评估报告可以节省大量时间，并确保报告的一致性。

在这个配方中，我们将创建一个 Python 脚本，使用 OpenAI 的 ChatGPT 自动生成网络风险评估报告。我们将使用用户提供的数据，重点关注我们在ChatGPT 辅助风险排名和优先级配方中使用的数据。但是，脚本和提示已经设计为可以处理任何相关的用户提供的数据。通过本配方结束时，您将能够使用 Python、ChatGPT 和您自己的数据生成详细和连贯的风险评估报告。

准备工作

在开始之前，请确保您有以下内容：

Python。
已安装了openaiPython 库。您可以使用 pip 安装它：pip install openai。
已安装了python-docx库。您可以使用 pip 安装它：pip install python-docx。
已安装了tqdm库。您可以使用 pip 安装它：pip install tqdm。
一枚来自 OpenAI 的 API 密钥。

怎么做…

在开始之前，请记住您需要在systemdata.txt文件中提供系统数据。这些数据可以是任何东西，只要它们是分隔或分隔的，并且包含可辨识的值，表示系统和漏洞的风险、严重程度、价值等级等。这些信息将被 ChatGPT 用于创建适当的算法，并生成上下文准确的报告部分：

导入所需的库：
```
import openai 
from openai import OpenAI
import os
from docx import Document
import threading
import time
from datetime import datetime
from tqdm import tqdm
1
2
3
4
5
6
7
8
```
这些是脚本正常运行所必需的库。openai用于与 OpenAI API 交互，os用于访问环境变量，docx中的Document用于创建 Word 文档，threading和time用于多线程和跟踪经过的时间，datetime用于为每次运行生成唯一的文件名，tqdm用于在控制台中显示进度条。

设置 OpenAI API 密钥并生成评估名称：

openai.api_key = os.getenv("OPENAI_API_KEY")
current_datetime = datetime.now()
    .strftime('%Y-%m-%d_%H-%M-%S')
assessment_name =
    f"Risk_Assessment_Plan_{current_datetime}"
1
2
3
4
5

OpenAI API 密钥从环境变量中读取，并且当前日期和时间用于为风险评估报告创建唯一的文件名。

创建风险评估报告大纲：

risk_assessment_outline = [
    "Executive Summary",
    "Introduction",
    # More sections...
]
1
2
3
4
5

这是风险评估报告的结构，用于指导 AI 模型生成每个部分的内容。

定义生成部分内容的函数：

def generate_section_content(section: str,
system_data: str) -> str:
    messages = [
        {
            "role": "system",
            "content": 'You are a cybersecurity
                professional...'
        },
        {
            "role": "user",
            "content": f'You are currently
                writing a cyber risk assessment
                report...{system_data}'
        },
    ]
    # Call the OpenAI API
client = OpenAI()
response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=2048,
        n=1,
        stop=None,
        temperature=0.7,
    )
    Return
        response.choices[0].message.content.strip()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

此函数构造一个对话提示，将其发送到 OpenAI API，并检索模型的响应。它接受部分名称和系统数据作为参数，并返回指定部分的生成内容。

定义将 Markdown 文本转换为 Word 文档的函数：
```
def markdown_to_docx(markdown_text: str, output_file: str):
    document = Document()
    # Parsing and conversion logic...
    document.save(output_file)
1
2
3
4
```
此函数接受 Markdown 文本和文件路径，根据 Markdown 内容创建 Word 文档，并将文档保存到指定的文件路径。

定义显示经过的时间的函数：

def display_elapsed_time():
    start_time = time.time()
    while not api_call_completed:
        elapsed_time = time.time() - start_time
        print(f"\rElapsed time: {elapsed_time:.2f}
            seconds", end="")
        time.sleep(1)
1
2
3
4
5
6
7

此函数用于在等待 API 调用完成时在控制台中显示经过的时间。它被实现为一个单独的线程，以允许主线程继续执行脚本的其余部分。

读取系统数据并启动经过的时间线程：

with open("systemdata.txt") as file:
    system_data = file.read()
api_call_completed = False
elapsed_time_thread =
    threading.Thread(target=display_elapsed_time)
elapsed_time_thread.start()
1
2
3
4
5
6

脚本从文本文件中读取系统数据，并启动一个新线程在控制台中显示经过的时间。

使用 OpenAI API 生成报告：

report = []
pbar = tqdm(total=len(risk_assessment_outline),
    desc="Generating sections")
for section in risk_assessment_outline:
    try:
        content = generate_section_content(section,
            system_data)
        report.append(f"## {section}\n{content}")
    except Exception as e:
        print(f"\nAn error occurred during the API
            call: {e}")
        api_call_completed = True
        exit()
    pbar.update(1)
api_call_completed = True
elapsed_time_thread.join()
pbar.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

脚本创建一个进度条，遍历风险评估报告大纲中的各个部分，使用 OpenAI API 为每个部分生成内容，并将内容附加到报告中。然后停止经过的时间线程并关闭进度条。

将报告保存为 Word 文档：

docx_output_file = f"{assessment_name}_report.docx"
try:
    markdown_to_docx('\n'.join(report),
        docx_output_file)
    print("\nReport generated successfully!")
except Exception as e:
    print(f"\nAn error occurred during the report
        generation: {e}")
1
2
3
4
5
6
7
8

最后，脚本将生成的报告从 Markdown 转换为 Word 文档并保存文档。如果在此过程中抛出异常，则会捕获并在控制台上打印消息。

完整的脚本应如下所示：

import openai 
from openai import OpenAI
import os
from docx import Document
import threading
import time
from datetime import datetime
from tqdm import tqdm
# Set up the OpenAI API
openai.api_key = os.getenv("OPENAI_API_KEY")
current_datetime = datetime.now()
    .strftime('%Y-%m-%d_%H-%M-%S')
assessment_name =
    f"Risk_Assessment_Plan_{current_datetime}"
# Cyber Risk Assessment Report Outline
risk_assessment_outline = [
    "Executive Summary",
    "Introduction",
    "Asset Discovery/Identification",
    "System Characterization/Classification",
    "Network Diagrams and Data Flow Review",
    "Risk Pre-Screening",
    "Security Policy & Procedures Review",
    "Cybersecurity Standards Selection and Gap
        Assessment/Audit",
    "Vulnerability Assessment",
    "Threat Assessment",
    "Attack Vector Assessment",
    "Risk Scenario Creation (using the Mitre ATT&CK
        Framework)",
    "Validate Findings with Penetration Testing/Red
        Teaming",
    "Risk Analysis (Aggregate Findings & Calculate Risk
        Scores)",
    "Prioritize Risks",
    "Assign Mitigation Methods and Tasks",
    "Conclusion and Recommendations",
    "Appendix",
]
# Function to generate a section content using the OpenAI
  API
def generate_section_content(section: str, system_data:
str) -> str:
    # Define the conversation messages
    messages = [
        {
            "role": "system",
            "content": 'You are a cybersecurity
                professional specializing in governance,
                risk, and compliance (GRC) with more than
                25 years of experience.'
        },
        {
            "role": "user",
            "content": f'You are currently writing a
                cyber risk assessment report. Write the
                context/details for the following section
                (and only this section): {section}, based
                on the context specific that section, the
                process that was followed, and the
                resulting system data provided below. In
                the absense of user provided context or
                information about the process followed,
                provide placeholder context that aligns
                with industry standard context for that
                section. Use as much detail and explanation
                as possible. Do not write
                anything that should go in another section
                of the policy.\n\n{system_data}'
        },
    ]
    # Call the OpenAI API
    client = OpenAI()
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=2048,
        n=1,
        stop=None,
        temperature=0.7,
    )
    # Return the generated text
    response.choices[0].message.content.strip()
# Function to convert markdown text to a Word document
def markdown_to_docx(markdown_text: str, output_file: str):
    document = Document()
    # Iterate through the lines of the markdown text
    for line in markdown_text.split('\n'):
        # Add headings based on the markdown heading levels
        if line.startswith('# '):
            document.add_heading(line[2:], level=1)
        elif line.startswith('## '):
            document.add_heading(line[3:], level=2)
        elif line.startswith('### '):
            document.add_heading(line[4:], level=3)
        elif line.startswith('#### '):
            document.add_heading(line[5:], level=4)
        # Add paragraphs for other text
        else:
            document.add_paragraph(line)
    # Save the Word document
    document.save(output_file)
# Function to display elapsed time while waiting for the
  API call
def display_elapsed_time():
    start_time = time.time()
    while not api_call_completed:
        elapsed_time = time.time() - start_time
        print(f"\rElapsed time: {elapsed_time:.2f}
            seconds", end="")
        time.sleep(1)
# Read system data from the file
with open("systemdata.txt") as file:
    system_data = file.read()
api_call_completed = False
elapsed_time_thread =
    threading.Thread(target=display_elapsed_time)
elapsed_time_thread.start()
# Generate the report using the OpenAI API
report = []
pbar = tqdm(total=len(risk_assessment_outline),
    desc="Generating sections")
for section in risk_assessment_outline:
    try:
        # Generate the section content
        content = generate_section_content(section,
            system_data)
        # Append the section content to the report
        report.append(f"## {section}\n{content}")
    except Exception as e:
        print(f"\nAn error occurred during the API call:
            {e}")
        exit()
    pbar.update(1)
api_call_completed = True
elapsed_time_thread.join()
pbar.close()
# Save the report as a Word document
docx_output_file = f"{assessment_name}_report.docx"
# Handle exceptions during the report generation
try:
    markdown_to_docx('\n'.join(report), docx_output_file)
    print("\nReport generated successfully!")
except Exception as e:
    print(f"\nAn error occurred during the report
        generation: {e}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

现在，让我们看看它是如何工作的。

它的工作原理…

此脚本的关键功能是基于系统数据和评估过程自动化生成详细的风险评估报告。脚本通过将过程分成一系列定义好的部分，并在每个部分中使用 OpenAI API 生成特定的、详细的内容来工作。

从文件加载的系统数据为 gpt-3.5-turbo 模型提供了生成每个部分内容的上下文。我们定义了一个概要，将风险评估报告分解为各种部分，每个部分代表风险评估过程中的一个阶段。这些部分与 创建风险评估流程 配方中概述的步骤相匹配。

我们在脚本中使用以下提示来构建报告模板：

You are a cybersecurity professional and CISO with more than 25 years of experience. Create a detailed cyber risk assessment report outline that would be in line with the following risk assessment process outline:
1\. Define Business Objectives
2\. Asset Discovery/Identification
3\. System Characterization/Classification
4\. Network Diagrams and Data Flow Review
5\. Risk Pre-Screening
6\. Security Policy & Procedures Review
7\. Cybersecurity Standards Selection and Gap Assessment/Audit
8\. Vulnerability Assessment
9\. Threat Assessment
10\. Attack Vector Assessment
11\. Risk Scenario Creation (using the Mitre ATT&CK Framework)
12\. Validate Findings with Penetration Testing/Red Teaming
13\. Risk Analysis (Aggregate Findings & Calculate Risk Scores)
14\. Prioritize Risks
15\. Assign Mitigation Methods and Tasks"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这种方法指导模型生成与报告每个部分匹配的内容。

在每个章节中，脚本都会调用generate_section_content()函数。这个函数向 OpenAI API 发送一个聊天消息，其中包括模型的角色（经验丰富的网络安全专业人员）、当前任务（编写指定的章节）和提供的系统数据。该函数返回的模型响应，也就是指定章节的内容，将被添加到report列表中。

markdown_to_docx()函数将report列表中的 Markdown 文本转换成 Word 文档。它通过迭代 Markdown 文本中的每一行，检查是否以 Markdown 标题标签（如#、##等）开头，并相应地将其添加到文档中作为标题或段落。

一旦所有章节都生成并追加到report列表中，该列表就会被合并成一个字符串，并使用markdown_to_docx()函数转换成 Word 文档。

还有更多…

每个描述流程某些方面的章节的上下文是占位文本，用户可以并且可能应该对其进行修改。我们之所以采用这种方法是为了简单起见，但在后面的示例中，我们将展示如何使用更高级的技术，将实际的风险评估流程作为报告的真实上下文。

我们鼓励您尝试使用不同的评估流程概要和数据集。了解如何调整提示和数据以获得最有效的结果，以满足您的需求，是充分利用 gpt-3.5-turbo 和 gpt-4 等人工智能模型的重要部分。

重要提示

请谨记，与上一个示例类似，这种方法受所选模型的标记限制的限制。gpt-3.5-turbo 模型的标记限制为 4,096，这限制了可以从系统数据文件中传递的数据量。然而，我们将在本书的后面探讨高级技术，以绕过这个限制。通过这些技术，您将能够处理更大的数据集并生成更全面的报告。

提示

与本书中大多数示例一样，本章节的示例中使用了 gpt-3.5-turbo 模型，因此可以以最具成本效益的模型作为基准。还使用了 GPT-3.5 ChatGPT 模型，以便将基准设定为最高效的无限制模型。然而，我们鼓励您尝试使用不同的模型，比如 gpt-3.5-turbo、gpt-4 和新发布的 gpt-3.5-turbo-16k，以找到最适合您需求的结果。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/520693