当前位置：首页 > article >正文

ChatGPT 网络安全秘籍（三）

article 2024/11/30 17:55:35

第五章：安全意识和培训

在这一章中，我们将深入探讨网络安全培训和教育的迷人领域，强调了 OpenAI 的大型语言模型（LLMs）在增强和丰富这一关键过程中可以发挥的重要作用。我们将踏上一段旅程，发现 ChatGPT 如何作为一个交互式工具，促进网络安全意识的各个方面，从创建全面的员工培训材料到开发交互式网络安全评估，甚至将学习过程本身变成游戏化。

我们将首先演示如何利用 ChatGPT、Python 和 OpenAI API 自动生成员工网络安全意识培训内容。在一个人为错误经常导致安全漏洞的时代，您将学会利用这些强大的工具，创建符合您组织特定需求的引人入胜的培训材料。

随着我们的进展，我们将探讨如何使用 ChatGPT 创建交互式评估，帮助企业和机构测试员工对关键网络安全概念的理解和记忆。您将通过实践方法指导，定制这些评估，使您能够构建一个与您组织现有培训内容相一致的工具。到本节结束时，您将有能力生成、导出和集成这些评估到您的学习管理系统。

在我们继续旅程时，我们将注意力转向电子邮件钓鱼 - 这是网络犯罪分子采用的最普遍的策略之一。您将发现如何使用 ChatGPT 创建一个交互式电子邮件钓鱼培训工具，从而为您的组织营造一个更安全的网络环境。培训的交互性不仅确保了持续、引人入胜和高效的学习体验，还可以轻松地与现场课程或学习管理系统进行整合。

接下来，我们将看到 ChatGPT 如何协助准备网络安全认证考试。通过创建针对诸如 CISSP 等认证的学习指南，您将利用 ChatGPT 的能力与潜在的考试题目进行互动，收集有用的见解，并评估您对考试的准备程度。

最后，我们探索了网络安全教育中游戏化的令人兴奋和充满活力的世界。作为ThreatGEN® Red vs. Blue的创作者，这是世界上第一批教育性网络安全视频游戏之一，我相信游戏与教育的结合提供了一种独特而引人入胜的方式来传授网络安全技能，这是未来的发展方向。通过 ChatGPT 作为一个网络安全主题 角色扮演游戏中的游戏主持人，您将发现这个 AI 工具如何管理游戏进度，记分，并提供详细的改进报告，为学习体验增添了全新的维度。

通过本章，您不仅会欣赏 ChatGPT 在教育领域的多样化应用，还将获得在网络安全领域有效利用其能力所需的技能。

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

开发安全意识培训内容
评估网络安全意识
通过 ChatGPT 进行交互式邮箱网络钓鱼培训
ChatGPT 引导的网络安全认证学习
将网络安全培训变成游戏

技术要求

对于本章，您需要一个 web 浏览器 和一个稳定的 互联网连接 来访问 ChatGPT 平台并设置您的帐户。您还需要已经建立好您的 OpenAI 帐户并获得了您的 API 密钥。如果没有，请参阅 第一章 获取详细信息。您需要基本的 Python 编程语言知识并了解如何使用命令行，因为您将使用 Python 3.x 来与 OpenAI GPT API 进行交互并创建 Python 脚本。代码编辑器 也将是必不可少的，用于编写和编辑 Python 代码以及在本章中使用的命令提示文件。

本章的代码文件可以在此处找到：。

开发安全意识培训内容

在网络安全领域，员工教育至关重要。人为错误仍然是安全漏洞的主要原因之一，因此至关重要的是确保组织中的所有成员都了解他们在维护网络安全中的角色。然而，制作引人入胜和有效的培训材料可能是一个耗时的过程。

本文将指导您如何使用 Python 和 OpenAI API 自动生成员工网络安全意识培训内容。生成的内容可以用于幻灯片演示和讲义，您可以将其无缝集成到所选的幻灯片演示应用程序中。

通过利用 Python 脚本和 API 提示方法的能力，您将能够生成大量内容，远远超出 ChatGPT 中单个提示通常产生的量。

本文中生成的培训材料将重点放在常常面临高风险网络威胁的电力公用事业行业上。但是，本文中使用的技术是灵活的，允许您指定适合您需求的任何行业，并将生成适应您选择的行业的相应内容。开发的指导和程序将是教育员工维护组织网络安全角色的宝贵资源。

准备就绪

在开始本节内容之前，请确保您已经设置好您的 OpenAI 帐户并准备好您的 API 密钥。如果没有，请参考 第一章 获取所需的设置详细信息。您还需要 Python 3.10.x 或更高版本。

另外，请确认你已安装了以下 Python 库：

openai：这个库使你能够与 OpenAI API 进行交互。使用命令 pip install openai 安装它。
os：这是一个内置的 Python 库，它允许你与操作系统进行交互，特别是用于访问环境变量。
tqdm：这个库用于显示生成过程中的进度条。使用 pip install tqdm 安装它。

一旦这些要求都就绪，你就可以开始执行脚本了。

怎么做…

重要提示

在开始之前，应该注意，gpt-4 模型强烈建议用于本示例中的提示。即使经过了大量尝试，gpt-3.5-turbo 模型有时会在输出中提供不一致的格式。

在接下来的步骤中，我们将指导你创建一个 Python 脚本，自动化使用初始提示生成幻灯片列表的过程，为每个幻灯片生成详细信息，最后创建一个包含所有内容的文档，适合直接复制粘贴到你选择的幻灯片演示应用程序中。

导入必要的库。脚本从导入所需的 Python 库开始，包括 openai（用于 OpenAI API 调用）、os（用于环境变量）、threading（用于并行线程）、time（用于基于时间的函数）、datetime（用于日期和时间操作）和 tqdm（用于显示进度条）。
```
import openai
from openai import OpenAI
import os
import threading
import time
from datetime import datetime
from tqdm import tqdm
```
设置 OpenAI API 并准备文件输出。在这里，我们使用你的 API 密钥初始化 OpenAI API。我们还准备了一个输出文件，其中将存储生成的幻灯片内容。文件名基于当前日期和时间，确保它是唯一的。
```
# Set up the OpenAI API
openai.api_key = os.getenv("OPENAI_API_KEY")
current_datetime = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
output_file = f"Cybersecurity_Awareness_Training_{current_datetime}.txt"
```

content_to_text_file() 和 display_elapsed_time()，被定义用来处理将幻灯片内容写入文本文件以及在等待 API 调用时显示经过的时间。

def content_to_text_file(slide_content: str, file):
    try:
        file.write(f"{slide_content.strip()}\n\n---\n\n")
    except Exception as e:
        print(f"An error occurred while writing the slide content: {e}")
        return False
    return True
def display_elapsed_time(event):
    start_time = time.time()
    while not event.is_set():
        elapsed_time = time.time() - start_time
        print(f"\rElapsed time: {elapsed_time:.2f} seconds", end="")
        time.sleep(1)
def display_elapsed_time(event):
    #... function content here...

display_elapsed_time() 函数。

# Create an Event object
api_call_completed = threading.Event()
# Starting the thread for displaying elapsed time
elapsed_time_thread = threading.Thread(target=display_elapsed_time, args=(api_call_completed,))
elapsed_time_thread.start()

准备初始提示。 我们为模型设置了初始提示。系统角色描述了 AI 模型的角色，用户角色提供了指示，让模型生成网络安全培训大纲。

messages=[
    {
        "role": "system",
        "content": "You are a cybersecurity professional with more than 25 years of experience."
    },
    {
        "role": "user",
        "content": "Create a cybersecurity awareness training slide list that will be used for a PowerPoint slide based awareness training course, for company employees, for the electric utility industry. This should be a single level list and should not contain subsections or second-level bullets. Each item should represent a single slide."
    }
]

openai.ChatCompletion.create() 函数使用准备好的提示来生成培训大纲。如果在此过程中出现任何异常，它们会被捕获并打印到控制台。

print(f"\nGenerating training 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)

检索并打印培训大纲。 当模型生成培训大纲后，它会从响应中提取并打印到控制台，以供用户审核。
```
response.choices[0].message.content.strip()
print(outline + "\n")
```
\n）。这为它们做好了下一步更详细的内容生成的准备。
```
sections = outline.split("\n")
```

生成详细幻灯片内容。在此部分，脚本遍历大纲中的每个部分，并为每个部分生成详细的幻灯片内容。它打开输出文本文件，为模型准备一个新的提示，重置经过时间事件，再次调用模型，检索生成的幻灯片内容，并将其写入输出文件。

try:
    with open(output_file, 'w') as file:
        for i, section in tqdm(enumerate(sections, start=1), total=len(sections), leave=False):
            print(f"\nGenerating details for section {i}...")
            messages=[
                {
                    "role": "system",
                    "content": "You are a cybersecurity professional with more than 25 years of experience."
                },
                {
                    "role": "user",
                    "content": f"You are currently working on a PowerPoint presentation that will be used for a cybersecurity awareness training course, for end users, for the electric utility industry. The following outline is being used:\n\n{outline}\n\nCreate a single slide for the following section (and only this section) of the outline: {section}. The slides are for the employee's viewing, not the instructor, so use the appropriate voice and perspective. The employee will be using these slides as the primary source of information and lecture for the course. So, include the necessary lecture script in the speaker notes section. Do not write anything that should go in another section of the policy. Use the following format:\n\n[Title]\n\n[Content]\n\n---\n\n[Lecture]"
                }
            ]
            api_call_completed.clear()
            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)
                api_call_completed.set()
                exit(1)
            api_call_completed.set()
            slide_content = response.choices[0].message.content.strip()
            if not content_to_text_file(slide_content, file):
                print("Failed to generate slide content. Skipping to the next section...")
                continue

处理成功和不成功的运行。如果成功生成了输出文本文件，则会在控制台打印成功消息。如果在该过程中出现任何异常，它们会被捕获，并打印错误消息。
```
print(f"\nText file '{output_file}' generated successfully!")
except Exception as e:
    print(f"\nAn error occurred while generating the output text file: {e}")
```
elapsed_time_thread停止并将其加入到主进程中。这确保没有线程被不必要地运行。
```
api_call_completed.set()
elapsed_time_thread.join()
```

最终脚本应该如下所示：

import openai
from openai import OpenAI
import os
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')
output_file = f"Cybersecurity_Awareness_Training_{current_datetime}.txt"
def content_to_text_file(slide_content: str, file):
    try:
        file.write(f"{slide_content.strip()}\n\n---\n\n")
    except Exception as e:
        print(f"An error occurred while writing the slide content: {e}")
        return False
    return True
# Function to display elapsed time while waiting for the API call
def display_elapsed_time(event):
    start_time = time.time()
    while not event.is_set():
        elapsed_time = time.time() - start_time
        print(f"\rElapsed time: {elapsed_time:.2f} seconds", end="")
        time.sleep(1)
# Create an Event object
api_call_completed = threading.Event()
# Starting the thread for displaying elapsed time
elapsed_time_thread = threading.Thread(target=display_elapsed_time, args=(api_call_completed,))
elapsed_time_thread.start()
# Prepare initial prompt
messages=[
    {
        "role": "system",
        "content": "You are a cybersecurity professional with more than 25 years of experience."
    },
    {
        "role": "user",
        "content": "Create a cybersecurity awareness training slide list that will be used for a PowerPoint slide based awareness training course, for company employees, for the electric utility industry. This should be a single level list and should not contain subsections or second-level bullets. Each item should represent a single slide."
    }
]
print(f"\nGenerating training 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")
# Open the output text file
try:
    with open(output_file, 'w') as file:
        # 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 with more than 25 years of experience."
                },
                {
                    "role": "user",
                    "content": f"You are currently working on a PowerPoint presentation that will be used for a cybersecurity awareness training course, for end users, for the electric utility industry. The following outline is being used:\n\n{outline}\n\nCreate a single slide for the following section (and only this section) of the outline: {section}. The slides are for the employee's viewing, not the instructor, so use the appropriate voice and perspective. The employee will be using these slides as the primary source of information and lecture for the course. So, include the necessary lecture script in the speaker notes section. Do not write anything that should go in another section of the policy. Use the following format:\n\n[Title]\n\n[Content]\n\n---\n\n[Lecture]"
                }
            ]
            # Reset the Event before each API call
            api_call_completed.clear()
            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)
            # Set the Event to signal that the API call is complete
            api_call_completed.set()
            # Get detailed info
            slide_content = response.choices[0].message.content.strip()
            # Write the slide content to the output text file
            if not content_to_text_file(slide_content, file):
                print("Failed to generate slide content. Skipping to the next section...")
                continue
    print(f"\nText file '{output_file}' generated successfully!")
except Exception as e:
    print(f"\nAn error occurred while generating the output text file: {e}")
# At the end of the script, make sure to join the elapsed_time_thread
api_call_completed.set()
elapsed_time_thread.join()

结果是一个完整的网络安全意识培训课程的文本文件，可以转换成 PowerPoint 演示文稿。

它的运行方式…

该脚本利用了 OpenAI 模型的高级能力，为网络安全意识培训课程生成引人入胜、有启发性和结构良好的内容。整个过程分为几个阶段：

API 初始化：脚本通过初始化 OpenAI API 开始。它使用 API 密钥连接 OpenAI 的gpt-3.5-turbo模型，该模型经过对互联网文本的多样化培训。该模型旨在生成类似人类的文本，使其成为创建培训材料的独特和全面内容的理想选择。
日期-时间戳和文件命名：脚本创建一个唯一的时间戳，并将其附加到输出文件名。这确保了每次运行脚本都会创建一个独特的文本文件，避免了对先前输出的任何覆盖。
content_to_text_file()和display_elapsed_time()。前者用于将生成的幻灯片内容写入文本文件，并设置了错误处理。后者利用 Python 的线程功能，在 API 调用期间提供实时的经过时间显示。
生成大纲：脚本构建了一个反映课程要求的提示，并将其发送到 API。API 使用其上下文理解能力生成符合这些标准的大纲。
大纲分割：在生成大纲之后，脚本将其分成单独的部分。每个部分稍后将被开发成一个成熟的幻灯片。
生成详细内容：对于大纲中的每个部分，脚本准备了一个详细的提示，其中包括整个大纲和特定部分内容。然后将其发送到 API，API 返回详细的幻灯片内容，分为幻灯片内容和讲座笔记。
content_to_text_file()函数。如果幻灯片未能生成，脚本会跳过到下一部分，而不会中止整个过程。
线程管理和异常处理：脚本包括强大的线程管理和异常处理，以确保顺利运行。如果在写入输出文件时出现错误，脚本会报告问题并优雅地关闭线程，显示经过的时间。

通过使用 OpenAI API 和 gpt-3.5-turbo 模型，这个脚本高效地生成了一个结构化和全面的网络安全意识培训课程。该课程可以转换为 PowerPoint 演示文稿。生成的内容具有吸引力和教育性，为目标受众提供了宝贵的资源。

还有更多...

这个脚本的潜力不仅仅局限于文本输出。通过一些修改，你可以将其与 Python 库python-pptx集成，直接生成Microsoft PowerPoint演示文稿，从而进一步简化流程。

在撰写本文时，这种方法正处于发展阶段，正在积极探索改进和完善。对于富有冒险精神和好奇心的人，你可以在 GitHub 上访问修改后的脚本：github.com/PacktPublishing/ChatGPT-for-Cybersecurity-Cookbook。这个脚本承诺将自动化网络安全培训资料的创建迈出令人兴奋的一步。

要深入了解python-pptx库的工作原理和能力，该库允许你在 Python 中生成和操作 PowerPoint 演示文稿，你可以访问其详尽的文档：python-pptx.readthedocs.io/en/latest/。

随着技术的进步，人工智能和自动化与内容创建的整合是一个充满巨大潜力的不断发展的领域。这个脚本只是一个起点，定制和扩展的可能性是无穷无尽的！

评估网络安全意识

随着我们周围的网络威胁日益增多，网络安全意识变得前所未有的重要。这个教程将指导您使用 ChatGPT 创建一个互动的网络安全意识评估工具。我们正在开发的工具对于希望教育员工有关网络安全的企业和机构来说，可以成为一种重要的工具。这个测验可以作为网络安全意识培训课程的后续部分，测试员工对内容的理解和保持情况。此外，该评估工具可以根据您现有的网络安全培训内容进行定制，使其高度适应任何组织的特定需求。

最有趣的部分？在指南结束时，您将能够将评估问题和答案导出到文本文档中。这个功能可以轻松与现场课程或学习管理系统（LMS）集成。不管您是网络安全教练、企业领导还是爱好者，这个步骤将为您提供一个实用和创新的参与网络安全教育的方式。

准备工作

在开始这个步骤之前，请确保您的 OpenAI 账户已设置并保持 API 密钥可用。如果没有，请参阅第一章以获取所需的设置详细信息。您还需要Python 版本 3.10.x 或更高版本。

另外，请确认您已安装以下 Python 库：

openai：这个库可以让您与 OpenAI API 进行互动。使用命令 pip install openai 进行安装。
os：这是一个内置的 Python 库，允许您与操作系统进行交互，特别是用于访问环境变量。
tqdm：这个库用于在策略生成过程中显示进度条。使用 pip install tqdm 进行安装。
一个名为 trainingcontent.txt 的文本文件：该文件应包含您希望基于其进行评估的类别。每行应包含一个类别。该文件应与您的 Python 脚本在同一目录中。

如何做…

在开始之前，让我们注意一些事情。该评估将由 ChatGPT 生成的多项选择题组成。每个问题都会有四个选项，其中只有一个是正确的。您提供的答案将指导 ChatGPT 的互动，帮助它记分，提供解释并对您的表现进行反馈。让我们开始吧。

登录您的 OpenAI 账户并访问 ChatGPT 界面。 在网站 chat.openai.com 开始使用。

生成网络安全意识培训评估。 使用以下提示指导 ChatGPT 开始创建您的网络安全意识培训评估。

You are a cybersecurity professional and instructor with more than 25 years of experience. Create a cybersecurity awareness training (for employees) assessment test via this chat conversation. Provide no other response other than to ask me a cybersecurity awareness related question and provide 4 multiple choice options with only one being the correct answer. Provide no further generation or response until I answer the question. If I answer correctly, just respond with "Correct" and a short description to further explain the answer, and then repeat the process. If I answer incorrectly, respond with "Incorrect", then the correct answer, then a short description to further explain the answer. Then repeat the process.
Ask me only 10 questions in total throughout the process and remember my answer to them all. After the last question has been answered, and after your response, end the assessment and give me my total score, the areas/categories I did well in and where I need to improve.

生成特定内容的评估。 如果您想要一个特定的网络安全意识课程评估，比如在 开发安全意识培训内容的步骤中创建的评估，使用以下替代提示：

You are a cybersecurity professional and instructor with more than 25 years of experience. Create a cybersecurity awareness training (for employees) assessment test via this chat conversation. Provide no other response other than to ask me a cybersecurity awareness related question and provide 4 multiple choice options with only one being the correct answer. Provide no further generation or response until I answer the question. If I answer correctly, just respond with "Correct" and a short description to further explain the answer, and then repeat the process. If I answer incorrectly, respond with "Incorrect", then the correct answer, then a short description to further explain the answer. Then repeat the process.
Ask me only 10 questions in total throughout the process and remember my answer to them all. After the last question has been answered, and after your response, end the assessment and give me my total score, the areas/categories I did well in and where I need to improve.
Base the assessment on the following categories:
Introduction to Cybersecurity
Importance of Cybersecurity in the Electric Utility Industry
Understanding Cyber Threats: Definitions and Examples
Common Cyber Threats in the Electric Utility Industry
The Consequences of Cyber Attacks on Electric Utilities
Identifying Suspicious Emails and Phishing Attempts
The Dangers of Malware and How to Avoid Them
Safe Internet Browsing Practices
The Importance of Regular Software Updates and Patches
Securing Mobile Devices and Remote Workstations
The Role of Passwords in Cybersecurity: Creating Strong Passwords
Two-Factor Authentication and How It Protects You
Protecting Sensitive Information: Personal and Company Data
Understanding Firewalls and Encryption
Social Engineering: How to Recognize and Avoid
Handling and Reporting Suspected Cybersecurity Incidents
Role of Employees in Maintaining Cybersecurity
Best Practices for Cybersecurity in the Electric Utility Industry

提示

尝试问问题的数量和所问的类别，以获得最适合您需求的结果。

工作原理…

这个步骤的成功在于提示的复杂设计以及它们引导 ChatGPT 行为的方式，提供互动、基于问答的评估体验。提示中的每条指令对应于 ChatGPT 能够执行的任务。OpenAI 模型已经在各种数据上进行了训练，并且可以根据提供的输入生成相关的问题。

提示的初始部分将 ChatGPT 定位为一名经验丰富的网络安全专业人员和教师，为我们期望的响应类型设置了上下文。这对于指导模型生成与网络安全意识相关的内容至关重要。

我们进一步指示模型保持标准评估的流程：提出问题，等待回答，然后给出反馈。我们明确声明，AI 应该提出问题并提供四个选择项，明确给出清晰的结构以供遵循。反馈，无论是正确还是错误，都旨在包含简短的解释，以补充学习者的理解。

提示设计的一个独特方面是其内置的记忆管理。我们指示模型在整个对话过程中记住所有的回应。这样，我们就得到了一个累积的评分机制，为互动增添了一个渐进和连续性的元素。虽然这并不完美，因为 AI 模型的记忆有限，不能跟踪超出一定限制的上下文，但对于这个应用的范围来说是有效的。

重要的是，我们限制模型的响应以保持评估的上下文。提示明确表示，模型除了问题和反馈循环外不应提供任何其他回应。这种限制对于确保模型不偏离预期的对话流程至关重要。

对于定制的评估，我们提供了一个基于特定主题的问题列表，利用模型理解和生成给定主题的问题的能力。这样，模型可以根据网络安全意识课程的特定需求定制评估。

本质上，提示的结构和创造性有助于挖掘 ChatGPT 的能力，将其转化为一种用于网络安全意识评估的互动工具。

重要提示

虽然这些模型擅长理解和生成类似于人类的文本，但它们不以人类的方式了解事物。它们无法记住除对话上下文中可用的内容之外的具体细节。

不同的模型可能具有不同的优势和劣势，您可能希望考虑这一点。GPT-4具有处理更长上下文（更多的评估问题）的能力，但速度稍慢，并且在 3 小时内只能提交 25 个提示（截至目前为止）。GPT-3.5速度较快，没有任何提示限制。但是，在长时间的评估中可能会丢失上下文，并在评估结束时提供不准确的结果。

简而言之，这个方案利用 OpenAI 模型的能力创建了一个高度互动和信息丰富的网络安全意识评估。

还有更多……

如果你正在使用 LMS，你可能更喜欢一个问题集文档，而不是像 ChatGPT 这样的交互式方法。在这种情况下，Python 脚本提供了一个方便的替代方法，创建一个静态的问题集，然后你可以将其导入到你的 LMS 中，或者在面对面的培训课程中使用。

提示

不同的模型有不同的上下文记忆窗口。脚本生成的问题越多，模型失去上下文并提供不一致或脱离上下文的结果的机会就越大。对于更多的问题，尝试使用gpt-4模型，它的上下文窗口是gpt-3.5-turbo的两倍，甚至是新的gpt-3.5-turbo-16k，它的上下文窗口是gpt-3.5-turbo的四倍。

下面是做这件事的步骤：

导入必要的库。对于这个脚本，我们需要导入openai，os，threading，time，datetime和tqdm。这些库将允许我们与 OpenAI API 交互，管理文件，并创建多线程。
```
import openai
from openai import OpenAI
import os
import threading
import time
from datetime import datetime
from tqdm import tqdm
```
设置 OpenAI API。 你需要提供你的 OpenAI API 密钥，你可以将其存储为环境变量以确保安全。
```
openai.api_key = os.getenv("OPENAI_API_KEY")
```

设置评估的文件名。 我们使用当前日期和时间来创建每个评估的唯一名称。

current_datetime = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
assessment_name = f"Cybersecurity_Assessment_{current_datetime}.txt"

定义生成问题的函数。 这个函数创建一个与 AI 模型的对话，使用了与交互会话类似的方法。它包括了类别的函数参数。

def generate_question(categories: str) -> str:
    messages = [
        {"role": "system", "content": 'You are a cybersecurity professional and instructor with more than 25 years of experience.'},
        {"role": "user", "content": f'Create a cybersecurity awareness training (for employees) assessment test. Provide no other response other than to create a question set of 10 cybersecurity awareness questions. Provide 4 multiple choice options with only one being the correct answer. After the question and answer choices, provide the correct answer and then provide a short contextual description. Provide no further generation or response.\n\nBase the assessment on the following categories:\n\n{categories}'},
    ]
    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()

重要提示

你可以在这里调整问题的数量以满足你的需求。你还可以修改提示，告诉它你想要每个类别至少 x 个问题。

显示经过的时间。 这个功能用于提供一个用户友好的显示，显示 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)

准备并执行 API 调用。 我们从文件中读取内容类别，并启动一个线程来显示经过的时间。然后调用生成问题的函数。

try:
    with open("trainingcontent.txt") as file:
        content_categories = ', '.join([line.strip() for line in file.readlines()])
except FileNotFoundError:
    content_categories = ''
api_call_completed = False
elapsed_time_thread = threading.Thread(target=display_elapsed_time)
elapsed_time_thread.start()
try:
    questions = generate_question(content_categories)
except Exception as e:
    print(f"\nAn error occurred during the API call: {e}")
    exit()
api_call_completed = True
elapsed_time_thread.join()

保存生成的问题。 一旦问题生成了，我们就把它们写入到一个文件中，使用之前定义的文件名。

try:
    with open(assessment_name, 'w') as file:
        file.write(questions)
    print("\nAssessment generated successfully!")
except Exception as e:
    print(f"\nAn error occurred during the assessment generation: {e}")

这是完整脚本的样子：

import openai
from openai import OpenAI
import os
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"Cybersecurity_Assessment_{current_datetime}.txt"
def generate_question(categories: str) -> str:
    # Define the conversation messages
    messages = [
        {"role": "system", "content": 'You are a cybersecurity professional and instructor with more than 25 years of experience.'},
        {"role": "user", "content": f'Create a cybersecurity awareness training (for employees) assessment test. Provide no other response other than to create a question set of 10 cybersecurity awareness questions. Provide 4 multiple choice options with only one being the correct answer. After the question and answer choices, provide the correct answer and then provide a short contextual description. Provide no further generation or response.\n\nBase the assessment on the following categories:\n\n{categories}'},
    ]
    # 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 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 content categories from the file
try:
    with open("trainingcontent.txt") as file:
        content_categories = ', '.join([line.strip() for line in file.readlines()])
except FileNotFoundError:
    content_categories = ''
api_call_completed = False
elapsed_time_thread = threading.Thread(target=display_elapsed_time)
elapsed_time_thread.start()
# Generate the report using the OpenAI API
try:
    # Generate the question
    questions = generate_question(content_categories)
except Exception as e:
    print(f"\nAn error occurred during the API call: {e}")
    api_call_completed = True
    exit()
api_call_completed = True
elapsed_time_thread.join()
# Save the questions into a text file
try:
    with open(assessment_name, 'w') as file:
        file.write(questions)
    print("\nAssessment generated successfully!")
except Exception as e:
    print(f"\nAn error occurred during the assessment generation: {e}")

经过这些步骤，你将拥有一个文本文件，其中包含模型生成的一组问题，供你在网络安全意识培训中使用！

这就是它的运行方式：

这个 Python 脚本旨在生成一套网络安全意识培训的问题。它通过使用 OpenAI trainingcontent.txt来实现，其中每行被认为是一个单独的类别。

该脚本首先导入必要的库，包括openai与gpt-3.5-turbo模型交互，os 用于操作系统相关功能，例如读取环境变量（在本例中是 API 密钥），threading和time 用于创建一个单独的线程，在 API 调用期间显示经过的时间，datetime 获取当前日期和时间为输出文件命名，以及tqdm 提供进度条。

一旦设置了 API 密钥，脚本就会构造输出评估文件的文件名。它会将当前日期和时间附加到基本名称上，以确保每次运行脚本时输出文件都有唯一的名称。

接下来，定义了generate_question函数，它与 ChatGPT 模型建立了一次对话。它首先设置了系统角色消息，确立了用户（网络安全专业人员）的视角，然后请求创建网络安全意识培训评估测试。它使用用户消息中的类别参数传递给模型。稍后此参数将被实际从文件中读取的类别替换。

display_elapsed_time函数旨在显示自 API 调用开始到完成所经过的时间。该函数在单独的线程上运行，以在不阻塞主线程（API 调用所在的线程）的情况下更新控制台上的经过时间。

内容类别从文件trainingcontent.txt中读取，并创建一个新的线程来显示经过的时间。然后通过调用generate_question函数并传递内容类别进行 API 调用。如果在 API 调用期间发生异常（例如，网络连接有问题），脚本将停止执行并报告错误。

最后，一旦 API 调用完成并接收到生成的问题，它们就会被写入输出文件。如果在写入过程中发生任何异常（例如，写入权限有问题），错误将被报告到控制台。

总的来说，该脚本提供了一种实用的方式，使用 OpenAI gpt-3.5-turbo 模型为网络安全意识培训生成一套问题。在 API 调用中使用的提示结构和特定参数有助于确保输出符合培训的特定需求。

与 ChatGPT 互动的电子邮件钓鱼培训

随着网络威胁的增加，各种规模的组织越来越意识到培训员工识别电子邮件钓鱼的重要性，这是网络犯罪分子常用且潜在危险的策略。在这个教程中，我们将使用 ChatGPT 创建一个交互式电子邮件钓鱼培训工具。

这个教程将引导您完成为 ChatGPT 制作专业提示的过程，将其转变成钓鱼攻击意识模拟工具。通过这种方法，您可以使用 ChatGPT 培训用户识别潜在的钓鱼电子邮件，从而提高他们的意识，并帮助保护您的组织免受潜在的安全威胁。

使其真正强大的是其交互性质。ChatGPT 将向用户展示一系列电子邮件场景。然后用户将决定该电子邮件是钓鱼尝试还是合法邮件，甚至可以要求更多详细信息，比如电子邮件中链接的 URL 或标题信息等。ChatGPT 将提供反馈，确保持续、引人入胜且高效的学习体验。

此外，我们还将介绍如何将 Python 与这些提示结合使用，以创建可导出的电子邮件模拟场景。在您可能希望在 ChatGPT 之外使用生成的场景的情况下，这个功能可能会很有益，比如在现场课程或 LMS 中使用。

准备工作

在深入研究这个配方之前，请确保你已经设置好了你的 OpenAI 账户，并且有你的 API 密钥在手。如果没有，你应该参考第一章获取必要的设置详细信息。你还需要Python 版本 3.10.x 或更高版本。

此外，请确认你已经安装了以下 Python 库：

openai：此库使您能够与 OpenAI API 进行交互。使用命令 pip install openai 进行安装。
os：这是一个内置的 Python 库，允许您与操作系统进行交互，特别是用于访问环境变量。
tqdm：此库用于在策略生成过程中显示进度条。使用 pip install tqdm 进行安装。

如何操作...

在这一部分中，我们将带领您完成使用 ChatGPT 创建交互式电子邮件钓鱼训练模拟的过程。指南被分解为步骤，从登录到您的 OpenAI 账户开始，到生成钓鱼训练模拟结束。

访问 ChatGPT 界面。 登录到您的 OpenAI 账户，然后转到 chat.openai.com ChatGPT 界面。

通过输入专门的提示来初始化模拟。 以下提示经过精心设计，指导 ChatGPT 充当钓鱼训练模拟器。将提示输入到文本框中，然后按 Enter 键。

"You are a cybersecurity professional and expert in adversarial social engineering tactics, techniques, and procedures, with 25 years of experience. Create an interactive email phishing training simulation (for employees). Provide no other response other than to ask the question, "Is the following email real or a phishing attempt? (You may ask clarification questions such as URL information, header information, etc.)" followed by simulated email, using markdown language formatting. The email you present can represent a legitimate email or a phishing attempt, which can use one or more various techniques. Provide no further generation or response until I answer the question. If I answer correctly, just respond with "Correct" and a short description to further explain the answer, and then restart the process from the beginning. If I answer incorrectly, respond with "Incorrect", then the correct answer, then a short description to further explain the answer. Then repeat the process from the beginning.
Present me with only 3 simulations in total throughout the process and remember my answer to them all. At least one of the simulations should simulate a real email. After the last question has been answered, and after your response, end the assessment and give me my total score, the areas I did well in and where I need to improve."

小贴士

请务必更改 ChatGPT 提供的模拟次数，以满足您的需求。

现在，ChatGPT 将根据您的指示生成交互式电子邮件钓鱼场景。请像您正在接受培训的员工一样回应每个场景。在第三个场景和您的最终回应之后，ChatGPT 将计算并提供您的总分、优势领域和改进领域。

工作原理...

这个配方的核心在于专门的提示。该提示被构建为指导 ChatGPT 充当交互式钓鱼训练工具，传递一系列电子邮件钓鱼场景。该提示遵循某些设计原则，这些原则对其有效性和与 OpenAI 模型的交互至关重要。在这里，我们将剖析这些原则：

确定角色： 提示通过设置 AI 模型的角色开始，即网络安全专家，精通对抗性社会工程战术、技术和程序，拥有 25 年的经验。通过定义 AI 的角色，我们引导模型使用从这种角色期望的知识和专业知识生成回应。
详细说明和模拟： 提示中给出的说明非常详细，正是由于这种精确性，ChatGPT 才能创建有效和真实的网络钓鱼模拟。提示要求 AI 模型生成一个网络钓鱼邮件场景，然后是问题：“以下的邮件是真实的还是网络钓鱼企图？”值得注意的是，AI 模型有自由提出额外的澄清问题，比如询问 URL 信息、头部信息等，从而赋予它生成更复杂和细致的场景的自由。

通过要求模型使用标记语言格式来生成这些邮件，我们确保模拟邮件具有真实邮件的结构和外观，增强了模拟的真实感。模型也被指示呈现既可以代表合法通信，也可以是网络钓鱼企图的邮件，确保用户评估的场景多样化。

ChatGPT 如何生动地模拟网络钓鱼邮件呢？嗯，ChatGPT 的优势来自于它的广泛文本输入，包括（但不限于）无数电子邮件往来的例子，也可能包括一些网络钓鱼企图或讨论。通过这种广泛的训练，该模型已经对合法和网络钓鱼邮件中使用的格式、语气和常用短语有了深入的理解。因此，当提示模拟网络钓鱼邮件时，它可以借助这些知识生成一个逼真的邮件，反映出真实世界网络钓鱼行为的特征。

由于模型在收到问题的回答之前不生成回应，它保证了交互式用户体验。根据用户的回复，模型提供相关的反馈（正确或不正确），如果用户回答错误，还提供正确答案和简要解释。这种详细的及时反馈有助于学习过程，并帮助巩固每个模拟场景所获得的知识。

值得注意的是，虽然该模型经过训练生成类似人类的文本，但它并不像人类那样理解内容。它没有信念、观点，也不会获得实时、与世界相关的信息或个人数据，除非在对话中明确提供。它的回应仅仅是基于训练数据的预测。精心设计的提示和结构是引导模型生成有用、上下文相关内容的指南。
反馈机制： 提示指示 AI 根据用户的答案提供反馈，并进一步解释答案。这创建了一个增强学习体验的迭代反馈循环。
跟踪进度： 提示指示 AI 总共呈现三个模拟，并记住用户对所有模拟的答案。这确保了培训的连续性，并使用户的进度可以被跟踪。
评分和改进领域： 在最终模拟和回答后，提示指示 AI 结束评估，并提供总分数以及优势和改进领域。这有助于用户了解他们的熟练程度以及需要专注改进的领域。

ChatGPT 的模型是在广泛范围的互联网文本上训练的。然而，重要的是要注意，它并不知道其训练集中有哪些具体文档，也没有访问任何私人、机密或专有信息。它通过识别模式并产生与其训练数据中观察到的模式统计上一致的文本，来对提示生成响应。

通过以清晰地定义互动评估背景和预期行为的方式构建我们的提示，我们能够利用这种模式识别来创建一个高度专业化的互动工具。OpenAI 模型处理如此复杂和互动的用例的能力表明了它们的强大能力和灵活性。

还有更多……

如果你在使用 LMS 或进行实时课程，你可能更喜欢列出情景和细节，而不是像 ChatGPT 这样的互动方法。在这些情境下，向学习者提供特定的情景让他们思考并在小组讨论是更加实际的。这份清单也可用于评估或培训材料，为学员提供一个静态参考点，学员可以根据需要回顾，或者作为钓鱼模拟系统的内容。

通过修改上一个配方中的脚本，你可以指示 ChatGPT 模型生成一组完整的钓鱼邮件模拟，并包含所有必要的细节。生成的文本可以保存到文件中，以便在你的培训环境中轻松分发和使用。

由于这个脚本与上一个脚本非常相似，我们只会覆盖修改，而不会再次逐步介绍整个脚本。

让我们逐步了解必要的修改：

将generate_question重命名为generate_email_simulations，并更新其参数列表和主体以反映其新目的。现在它将生成钓鱼邮件模拟，而不是网络安全意识问题。这是通过更新传递给此函数的消息来完成的。

def generate_email_simulations() -> str:
    # Define the conversation messages
    messages = [
        {"role": "system", "content": 'You are a cybersecurity professional and expert in adversarial social engineering tactics, techniques, and procedures, with 25 years of experience.'},
        {"role": "user", "content": 'Create a list of fictitious emails for an interactive email phishing training. The emails can represent a legitimate email or a phishing attempt, using one or more various techniques. After each email, provide the answer, contextual descriptions, and details for any other relevant information such as the URL for any links in the email, header information. Generate all necessary information in the email and supporting details. Present 3 simulations in total. At least one of the simulations should simulate a real email.'},
    ]
    ...

重要提示

你可以调整这里的情景数量以适应你的需求。在这个例子中，我们请求 3 个情景。

删除不必要的代码： 脚本不再从输入文件中读取内容类别，因为在您的用例中不需要。
更新变量和函数名称： 所有涉及“questions”或“assessment”的变量和函数名称被重命名，改为“email simulations”，以便在新目的的上下文中更易于理解脚本。
与其调用generate_question函数，而是调用generate_email_simulations函数。该函数启动生成电子邮件模拟的过程。
```
# Generate the email simulations
email_simulations = generate_email_simulations()
```

小贴士

与之前的方法一样，更多的场景将需要支持更大上下文窗口的模型。然而，对于这个配方来说，gpt-4模型似乎在准确性、深度和生成结果的一致性方面提供了更好的结果。

整个脚本应该看起来像这样：

import openai
from openai import OpenAI
import os
import threading
import time
from datetime import datetime
# 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"Email_Simulations_{current_datetime}.txt"
def generate_email_simulations() -> str:
    # Define the conversation messages
    messages = [
        {"role": "system", "content": 'You are a cybersecurity professional and expert in adversarial social engineering tactics, techniques, and procedures, with 25 years of experience.'},
        {"role": "user", "content": 'Create a list of fictitious emails for an interactive email phishing training. The emails can represent a legitimate email or a phishing attempt, using one or more various techniques. After each email, provide the answer, contextual descriptions, and details for any other relevant information such as the URL for any links in the email, header information. Generate all necessary information in the email and supporting details. Present 3 simulations in total. At least one of the simulations should simulate a real email.'},
    ]
    # 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 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
try:
    # Generate the email simulations
    email_simulations = generate_email_simulations()
except Exception as e:
    print(f"\nAn error occurred during the API call: {e}")
    api_call_completed = True
    exit()
api_call_completed = True
elapsed_time_thread.join()
# Save the email simulations into a text file
try:
    with open(assessment_name, 'w') as file:
        file.write(email_simulations)
    print("\nEmail simulations generated successfully!")
except Exception as e:
    print(f"\nAn error occurred during the email simulations generation: {e}")

运行此修改后的脚本，ChatGPT 模型将生成一系列交互式的电子邮件钓鱼训练场景。然后，脚本将收集生成的场景，检查其中的错误，并将其写入文本文件。这为您提供了一份现成的培训资源，可以分发给学习者，或将其整合到您的学习管理系统（LMS）或现场培训课程中。

ChatGPT 引导的网络安全认证学习

此配方将指导您使用 ChatGPT 创建一个交互式的认证学习指南，专门针对像CISSP这样的网络安全认证。该方法将利用 ChatGPT 的对话能力模拟出一系列问题，这些问题通常可在指定的认证考试中找到。此外，ChatGPT 还将在每个问题之后提供额外的上下文，提供有用的见解和解释。为了完成学习会话，ChatGPT 还将评估您的表现，强调需要改进的领域，并提供适当的学习资源建议。该配方可以作为准备网络安全认证考试的任何人的强大学习工具。

准备工作

在详细解释此配方之前，请确保您已设置好 OpenAI 帐户并掌握您的 API 密钥。如果还没有，请参考第一章获取所需的设置详细信息。您还需要Python 版本 3.10.x或更高版本。

另外，请确保您已安装了以下 Python 库：

openai：该库使您能够与 OpenAI API 进行交互。使用命令pip install openai进行安装。
os：这是一个内置的 Python 库，允许您与操作系统进行交互，特别是用于访问环境变量。
tqdm：该库用于在策略生成过程中显示进度条。使用pip install tqdm进行安装。

如何实施...

这个交互式的认证学习指南将直接在 OpenAI 平台上创建，特别是在 ChatGPT 界面上。该过程简单直接。

访问 ChatGPT 界面。 登录你的 OpenAI 账户，然后转到 https://chat.openai.com 的 ChatGPT 界面。

通过输入专门的提示初始化会话。 以下提示经过精心设计，指示 ChatGPT 充当网络钓鱼培训模拟器。将提示输入到文本框中，然后按 Enter 键。

You are a cybersecurity professional and training instructor with more than 25 years of experience. Help me study for the CISSP exam. Generate 5 questions, one at a time, just as they will appear on the exam or practice exams. Present the question and options and nothing else and wait for my answer. If I answer correctly, say, "Correct" and move on to the next question. If I answer incorrectly, say, "Incorrect", present me with the correct answer, and any context for clarification, and then move on to the next question. After all questions have been answered, tally my results, present me with my score, tell me what areas I need to improve on, and present me with appropriate resources to help me study for the areas I need to improve in.

重要说明

提示中提到的认证考试可以替换为你感兴趣的认证。但是，请记住，ChatGPT 的训练数据仅延伸到2021 年 9 月，因此它将不会包含更新或引入的认证信息。

提示

本书稍后将介绍另一种配方，介绍如何使 ChatGPT 和/或 OpenAI 访问更多最新信息，以获取更及时的考试练习。

工作原理…

这个配方利用 AI 的角色扮演和互动对话能力创建一个引人入胜的学习环境。当 ChatGPT 扮演经验丰富的网络安全专业人员和讲师的角色时，它会生成一系列逼真的认证考试问题，验证你的答案，提供纠正性反馈，并在需要时提供额外的上下文或解释。提示结构确保 AI 保持对手头任务的关注，引导互动以创建一个有效的学习环境。

这种方法依赖于 ChatGPT 根据提供的指令理解和生成类似人类的文本的能力。在这个配方的背景下，AI 模型利用其底层语言理解能力生成相关的网络安全认证考试题目，并提供信息丰富的回答。

重要说明

正如本书中一直提到的那样，所选择的模型决定了你将面临的限制。GPT-4提供了一个显著更大的上下文窗口（允许更多问题在潜在偏离之前），比GPT-3.5更大。如果你可以访问OpenAI Playground，你可以使用gpt-3.5-turbo-16k模型，这是迄今为止上下文窗口最大的模型。

图 5.1 – 在 OpenAI Playground 中使用 gpt-3.5-turbo-16k 模型

游戏化网络安全培训

游戏化，即在非游戏环境中应用游戏设计元素，已经改变了许多领域的教育和培训，网络安全也不例外。作为全球首款教育网络安全视频游戏 ThreatGEN® 红对蓝 的创作者，我可能有点偏见。但是，我坚信游戏化是未来的教育媒介。

令人兴奋的游戏化世界已经越来越成为许多形式的教育和培训的首选方法。游戏化的核心是创建一个类似游戏的环境，使个人保持参与，从而增强学习过程。 ChatGPT 和 OpenAI 的 LLMs 最引人注目和有前途的应用之一，是将网络安全教育游戏化的能力。

从 X 世代及更年轻的人开始，大多数人都在游戏文化中长大。这一趋势，加上过去几年游戏化和基于游戏的学习的爆炸式增长，已经导致教育和培训的交付方式发生了重大变化。在网络安全领域，游戏和教育的结合为学习复杂概念提供了一种引人入胜、互动和有趣的方式。

本文将向您展示如何将 ChatGPT 变为一个网络安全主题的 游戏主持人 (GM)，进行 角色扮演游戏 (RPG)。我们将进行的游戏是“找到内部威胁”，这是一个“谁做了这件事”的谜题。游戏的目标是通过访谈员工和调查系统，在 50 轮或更少的时间内找到内部威胁。 ChatGPT 将管理游戏，记录分数并跟踪您的轮次。甚至在游戏结束后会提供详细的报告，概述您的成功、失败和改进的方面。

准备就绪

本教程的先决条件很简单。您只需一个网络浏览器和一个 OpenAI 账户。如果您还没有创建账户或者需要关于如何使用 ChatGPT 界面的详细指南，请参考第一章。

如何操作…

访问 ChatGPT 界面。登录您的 OpenAI 账户，并转到 https://chat.openai.com 上的 ChatGPT 界面。

通过输入专门的提示来初始化游戏 以下提示经过精心设计，指示 ChatGPT 充当钓鱼训练模拟器。将提示输入到文本框中并按 Enter 键。

"You are a cybersecurity professional with more than 25 years of experience and an expert in gamification and game-based training. You will be the game master for a cybersecurity themed role-playing game (RPG). The game is "Find the Insider Threat", a "who did it" mystery. The object is to interview staff and investigate systems to find the insider threat. I must do it in 50 turns or less. Keep score by adding and subtracting points as you see fit, as I go. If I find the culprit (I win) or after turn 50 the game is over (I lose). At that time, present me with my score, the game summary, my successes, my failures, and where I can improve (keeping in mind this is meant to be cybersecurity educational). When the game starts, present me with the scenario, setting, and game rules. Stay in character as the game master, keep track of each turn (every prompt after you present the game scenario, setting, and rules, is a game turn). At the end of each of your responses after the game starts, you will remind me of the turn and my current score (score starts at 0). Use markdown language in your prompts, to make the presentation more interesting and more readable.
If you understand, start the game."

图 5.2 – 示例游戏初始化输出

重要提示

在这个配方中，由于可能存在长篇上下文提示，模型的限制将起到重要作用。GPT-4 将为您提供最长的上下文窗口，但您将被限制在 3 小时内使用 25 个提示，包括初始提示。因此，您可能希望将使用 GPT-4 的游戏限制在 20 回合内。GPT-3.5 没有提示限制，但上下文窗口较小。因此，在游戏的某个时刻之后，ChatGPT 可能会丢失上下文并忘记游戏早期的细节。它应该会记得回合和得分，因为每回合都会重述，但来自早期提示的细节，特别是在初始化时和初始化后的提示，都会丢失。这包括整个设置。但是，ChatGPT 会尝试尽其所能地保持上下文，从它可以访问的内容中获得上下文。有时，这可能已经足够了。

小贴士

尝试（双关语）调整回合限制，甚至主题或游戏风格，以找到适合您兴趣和需求的设置。

工作原理...

这个配方本质上将 ChatGPT 转化为角色扮演游戏的游戏主持人。RPG 通常涉及玩家在虚构环境中扮演角色的叙事体验。游戏主持人（或 GM）是运行游戏、创作故事和背景、并裁决规则的人。

通过提供一个将 ChatGPT 视为游戏主持人的提示，指示模型构建叙事并引导玩家进行游戏。提示还指示模型跟踪游戏进度，记录得分，并在游戏结束时提供详细报告。

这个配方的有效性在于 ChatGPT 能够生成连贯且上下文相关的回复。它需要保持游戏叙事的连续性，同时追踪得分和回合数。这通过确保 ChatGPT 的每个回复都包含对回合和当前得分的提醒来实现。

但值得再次提到的是，模型记忆上下文的能力存在限制。GPT-3.5 的上下文窗口比 GPT-4 小，这可能会影响游戏的连贯性，特别是如果游戏跨越了多个回合。

还有更多...

这个配方只是介绍了游戏化网络安全培训这个激动人心且充满活力的世界的一瞥。通过操纵提示、游戏范围和 AI 的角色，您可以创建完全不同的情景，满足不同的网络安全技能或兴趣领域。

例如，在我们的配方中，我们使用了“谁做了这件事”之谜来确定内部威胁。然而，您可能会根据自己的特定兴趣或需求调整此方法。如果您更倾向于技术方面，您可以围绕更技术性的任务主题，比如在单一系统上进行威胁猎捕练习...像 RPG 一样！这种学习与娱乐的独特融合提供了定制的教育体验，使学习过程更具吸引力和乐趣。

此外，游戏化的网络安全培训并不局限于单人游戏。它是团队建设练习、展会活动甚至与朋友进行游戏之夜的绝妙工具。通过营造互动学习环境，您可以提升教育体验，使其更加深刻和有效。

第六章：红队与渗透测试

渗透测试和红队测试是网络安全评估的专业方法。渗透测试通常被称为“道德黑客”，涉及对系统、网络或应用程序进行模拟的网络攻击，以发现恶意行为者可能利用的漏洞。另一方面，红队测试是一种更全面和对抗性的评估，模拟了一次全面的攻击，以评估组织的检测和响应能力。使用这些方法模拟对抗策略对于评估组织的安全姿态至关重要。

通过模拟真实对手的策略和技术，这些授权模拟可揭示漏洞和攻击向量，防止恶意行为者利用。本章将探讨利用人工智能增强红队和渗透测试运营的配方。

首先，我们将使用 MITRE ATT&CK 框架、OpenAI API 和 Python 快速生成逼真的红队情景。通过将精心策划的对抗知识与庞大的语言模型(Large Language Models, LLMs)相结合，此技术允许我们创建与现实攻击密切相关的威胁叙事。

接下来，我们将利用 ChatGPT 的自然语言能力指导我们进行 OSINT 侦察。从挖掘社交媒体到分析职位发布，这些配方演示如何从公开数据源自动提取可执行的情报。

为了加速发现意外暴露的资产，我们将使用 Python 自动化 ChatGPT 生成的 Google Dorks。这些技术共同实现了对组织数字足迹的系统方法。

最后介绍一种独特的配方，在 Kali Linux 终端加入 OpenAI API 的能力。通过将自然语言请求转化为操作系统命令，这种 AI-enabled 的终端提供了一种直观的方式来导航复杂的渗透测试工具和工作流程。

完成本章后，你将掌握由人工智能驱动的一系列策略，这些策略可以增强红队和渗透测试的参与度。在道德和授权的前提下使用这些技术可以发现疏忽，简化测试，最终加强组织的安全姿态。

本章主要介绍以下内容：

利用 MITRE ATT&CK 和 OpenAI API 创建红队情景
利用 ChatGPT 进行社交媒体和公开数据的开放情报
利用 ChatGPT 和 Python 自动化 Google Dork
利用 ChatGPT 进行职位发布 OSINT 分析
利用 GPT 动力的 Kali Linux 终端

技术要求

对于本章，您需要一个网络浏览器和稳定的互联网连接以访问 ChatGPT 平台并设置账户。您还需要设置 OpenAI 账户并获得 API 密钥。如果没有，请参考第一章获取详细信息。基本了解 Python 编程语言和使用命令行的能力是必要的，因为您将使用Python 3.x，需要在系统上安装它，以使用 OpenAI GPT API 并创建 Python 脚本。一个代码编辑器也将是必不可少的，因为您将需要在本章的配方中编写和编辑 Python 代码和提示文件。最后，由于许多渗透测试用例严重依赖 Linux 操作系统，推荐您熟悉并了解 Linux 发行版（最好是 Kali Linux）。

Kali Linux 可以在这里找到：

www.kali.org/get-kali/#kali-platforms

本章的代码文件可以在这里找到：

github.com/PacktPublishing/ChatGPT-for-Cybersecurity-Cookbook

使用 MITRE ATT&CK 和 OpenAI API 创建红队场景

红队演练在评估组织对真实世界网络安全威胁的准备情况中起着关键作用。打造真实而有影响力的红队场景对于这些演练至关重要，但设计这样的场景通常会很复杂。这篇文章通过将Mitre ATT&CK框架与 ChatGPT 在 OpenAI API 上的认知能力进行协同，展示了一种精细的场景生成方法。不仅能够迅速创建场景，还将获得排名最相关技术的列表，包括摘要描述和示例 TTP 链，确保您的红队演练尽可能真实和有效。

准备工作

在阅读本篇内容之前，请确保您已经设置了 OpenAI 账户并掌握了您的 API 密钥。如果没有，请参阅第一章获取必要的设置细节。您还需要Python 3.10.x或更高版本。

另外，请确认您已安装以下 Python 库：

openai：此库使您能够与 OpenAI API 进行交互。使用pip install openai命令安装它。
os：这是一个内置的 Python 库，允许您与操作系统进行交互，特别是用于访问环境变量。
Mitreattack.stix20：此库用于在本地计算机上搜索 Mitre ATT&CK 数据集。使用pip install mitreattack-python进行安装。

最后，您将需要一个 MITRE ATT&CK 数据集：

对于本篇文章，我们将使用enterprise-attack.json。您可以在github.com/mitre/cti获取 MITRE ATT&CK 数据集。
本配方中使用的数据集，具体来说，位于github.com/mitre/cti/tree/master/enterprise-attack。

一旦这些要求就位，你就可以开始执行脚本了。

如何实现…

按照以下步骤进行：

设置环境：在深入脚本之前，请确保您具有必要的库和 API 密钥：

import openai
from openai import OpenAI
import os
from mitreattack.stix20 import MitreAttackData
openai.api_key = os.getenv("OPENAI_API_KEY")

使用MitreAttackData类加载数据集以便轻松访问：

mitre_attack_data = MitreAttackData("enterprise-attack.json")

从描述中提取关键词：此函数集成了 ChatGPT 以从提供的描述中提取相关关键词，稍后将用于搜索 MITRE ATT&CK 数据集：

def extract_keywords_from_description(description):
    # Define the merged prompt
    prompt = (f"Given the cybersecurity scenario description: '{description}', identify and list the key terms, "
              "techniques, or technologies relevant to MITRE ATT&CK. Extract TTPs from the scenario. "
              "If the description is too basic, expand upon it with additional details, applicable campaign, "
              "or attack types based on dataset knowledge. Then, extract the TTPs from the revised description.")
    # Set up the messages for the OpenAI API
    messages = [
        {
            "role": "system",
            "content": "You are a cybersecurity professional with more than 25 years of experience."
        },
        {
            "role": "user",
            "content": prompt
        }
    ]
    # Make the API call
    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
        )
        response_content = response.choices[0].message.content.strip()
        keywords = response_content.split(', ')
        return keywords
    except Exception as e:
        print("An error occurred while connecting to the OpenAI API:", e)
        return []

search_dataset_for_matches 函数搜索数据集以寻找潜在的匹配项。然后，score_matches 函数对结果进行评分：

def score_matches(matches, keywords):
    scores = []
    for match in matches:
        score = sum([keyword in match['name'] for keyword in keywords]) + \
                sum([keyword in match['description'] for keyword in keywords])
        scores.append((match, score))
    return scores
def search_dataset_for_matches(keywords):
    matches = []
    for item in mitre_attack_data.get_techniques():
        if any(keyword in item['name'] for keyword in keywords):
            matches.append(item)
        elif 'description' in item and any(keyword in item['description'] for keyword in keywords):
            matches.append(item)
    return matches

使用 ChatGPT 生成全面的场景：此功能利用 OpenAI API 生成每个匹配技术的摘要描述和示例 TTP 链：

def generate_ttp_chain(match):
    # Create a prompt for GPT-3 to generate a TTP chain for the provided match
    prompt = (f"Given the MITRE ATT&CK technique '{match['name']}' and its description '{match['description']}', "
              "generate an example scenario and TTP chain demonstrating its use.")
    # Set up the messages for the OpenAI API
    messages = [
        {
            "role": "system",
            "content": "You are a cybersecurity professional with expertise in MITRE ATT&CK techniques."
        },
        {
            "role": "user",
            "content": prompt
        }
    ]
    # Make the API call
    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
        )
        response_content = response.choices[0].message.content.strip()
        return response_content
    except Exception as e:
        print("An error occurred while generating the TTP chain:", e)
        return "Unable to generate TTP chain."

将所有内容整合在一起：现在，将所有函数整合起来，提取关键词，在数据集中查找匹配项，并生成具有 TTP 链的全面场景：

description = input("Enter your scenario description: ")
keywords = extract_keywords_from_description(description)
matches = search_dataset_for_matches(keywords)
scored_matches = score_matches(matches, keywords)
# Sort by score in descending order and take the top 3
top_matches = sorted(scored_matches, key=lambda x: x[1], reverse=True)[:3]
print("Top 3 matches from the MITRE ATT&CK dataset:")
for match, score in top_matches:
    print("Name:", match['name'])
    print("Summary:", match['description'])
    ttp_chain = generate_ttp_chain(match)
    print("Example Scenario and TTP Chain:", ttp_chain)
    print("-" * 50)

通过遵循上述步骤，您将拥有一个强大的工具，可以使用 MITRE ATT&CK 框架生成逼真的红队场景，所有这些都得益于 ChatGPT 的能力。

下面是完成的脚本应该是什么样子的：

import openai
from openai import OpenAI
import os
from mitreattack.stix20 import MitreAttackData
openai.api_key = os.getenv("OPENAI_API_KEY")
# Load the MITRE ATT&CK dataset using MitreAttackData
mitre_attack_data = MitreAttackData("enterprise-attack.json")
def extract_keywords_from_description(description):
    # Define the merged prompt
    prompt = (f"Given the cybersecurity scenario description: '{description}', identify and list the key terms, "
              "techniques, or technologies relevant to MITRE ATT&CK. Extract TTPs from the scenario. "
              "If the description is too basic, expand upon it with additional details, applicable campaign, "
              "or attack types based on dataset knowledge. Then, extract the TTPs from the revised description.")
    # Set up the messages for the OpenAI API
    messages = [
        {
            "role": "system",
            "content": "You are a cybersecurity professional with more than 25 years of experience."
        },
        {
            "role": "user",
            "content": prompt
        }
    ]
    # Make the API call
    try:
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=messages,
            max_tokens=2048,
            n=1,
            stop=None,
            temperature=0.7
        )
        response_content = response.choices[0].message.content.strip()
        keywords = response_content.split(', ')
        return keywords
    except Exception as e:
        print("An error occurred while connecting to the OpenAI API:", e)
        return []
def score_matches(matches, keywords):
    scores = []
    for match in matches:
        score = sum([keyword in match['name'] for keyword in keywords]) + \
                sum([keyword in match['description'] for keyword in keywords])
        scores.append((match, score))
    return scores
def search_dataset_for_matches(keywords):
    matches = []
    for item in mitre_attack_data.get_techniques():
        if any(keyword in item['name'] for keyword in keywords):
            matches.append(item)
        elif 'description' in item and any(keyword in item['description'] for keyword in keywords):
            matches.append(item)
    return matches
def generate_ttp_chain(match):
    # Create a prompt for GPT-3 to generate a TTP chain for the provided match
    prompt = (f"Given the MITRE ATT&CK technique '{match['name']}' and its description '{match['description']}', "
              "generate an example scenario and TTP chain demonstrating its use.")
    # Set up the messages for the OpenAI API
    messages = [
        {
            "role": "system",
            "content": "You are a cybersecurity professional with expertise in MITRE ATT&CK techniques."
        },
        {
            "role": "user",
            "content": prompt
        }
    ]
    # Make the API call
    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
        )
        response_content = response.choices[0].message.content.strip()
        return response_content
    except Exception as e:
        print("An error occurred while generating the TTP chain:", e)
        return "Unable to generate TTP chain."
# Sample usage:
description = input("Enter your scenario description: ")
keywords = extract_keywords_from_description(description)
matches = search_dataset_for_matches(keywords)
scored_matches = score_matches(matches, keywords)
# Sort by score in descending order and take the top 3
top_matches = sorted(scored_matches, key=lambda x: x[1], reverse=True)[:3]
print("Top 3 matches from the MITRE ATT&CK dataset:")
for match, score in top_matches:
    print("Name:", match['name'])
    print("Summary:", match['description'])
    ttp_chain = generate_ttp_chain(match)
    print("Example Scenario and TTP Chain:", ttp_chain)
    print("-" * 50)

本质上，这个配方通过结合结构化的网络安全数据和 ChatGPT 的灵活和广泛的知识。Python 脚本充当桥梁，引导信息流，并确保用户根据其初始输入接收详细、相关且可操作的红队场景。

它是如何工作的…

这个配方将 MITRE ATT&CK 框架的力量与 ChatGPT 的自然语言处理能力相结合。通过这样做，它提供了一种独特且高效的方式，根据简要描述生成详细的红队场景。让我们深入了解这个合并过程的复杂性：

使用mitreattack.stix20库与 MITRE ATT&CK 数据集进行交互。该数据集提供了一个全面的列表。MitreAttackData("enterprise-attack.json") 方法调用初始化一个对象，提供一个查询 MITRE ATT&CK 数据集的接口。这确保了我们的脚本具有结构化和高效访问数据的方式。
extract_keywords_from_description 函数。此函数向 ChatGPT 发送提示，以从给定的情景描述中提取相关关键词。生成的提示旨在指导模型不仅盲目地提取关键词，而且思考并扩展所提供的描述。通过这样做，它可以考虑到网络安全领域的更广泛方面，并提取更微妙和相关的关键词。
搜索 MITRE ATT&CK 数据集：一旦关键词被提取出来，它们就被用来搜索 MITRE ATT&CK 数据集。这种搜索不仅仅是简单的字符串匹配。脚本会查看数据集中每个技术的名称和描述，检查是否存在任何提取出来的关键词。这种双重检查增加了获取相关结果的可能性。
generate_ttp_chain 函数负责此任务。它向 ChatGPT 发送提示，指示其总结技术并为其提供一个示例 TTP 链场景。在这里使用 ChatGPT 的原因至关重要。虽然 MITRE ATT&CK 数据集提供了技术的详细描述，但它并不一定以易于非专家理解的格式提供。通过使用 ChatGPT，我们可以将这些技术描述转换为更加用户友好的摘要和场景，使它们更易于获取和可操作。
排名和选择：脚本不仅返回所有匹配的技术。它根据它们描述的长度（作为相关性和详细程度的代理）对它们进行排名，然后选择前三个。这确保用户不会被太多结果淹没，而是收到一个精选的最相关技术列表。

还有更多…

当前脚本会直接将详细的红队场景打印到控制台上。然而，在真实环境中，您可能希望将这些场景存储以备将来参考，与团队成员分享，甚至将它们用作报告的基础。实现这一目标的一种简单方法是将输出写入文本文件。

这就是我们如何将输出写入文本文件的方式：

修改 Python 脚本：

我们需要稍微修改脚本以将结果写入文本文件。以下是您可以实现这一目标的方法。

首先，添加一个将结果写入文件的函数：

def write_to_file(matches):
    with open("red_team_scenarios.txt", "w") as file:
        for match in matches:
            file.write("Name: " + match['name'] + "\n")
            file.write("Summary: " + match['summary'] + "\n")
            file.write("Example Scenario: " + match['scenario'] + "\n")
            file.write("-" * 50 + "\n")
write_to_file(top_matches)

red_team_scenarios.txt 与您的脚本在同一目录中。该文件将包含排名前三的匹配场景，格式化便于阅读。

这样做有三个主要好处：
- 可移植性：文本文件是普遍可访问的，易于分享或在系统之间移动。
- 文档：通过保存场景，您创建了一个潜在威胁模式的记录，以供注意。
- 与其他工具集成：输出文件可以被其他网络安全工具摄取，进行进一步的分析或操作。

此增强功能不仅允许您交互式查看红队场景，还可以保持对其的持久记录，增强了脚本在多样化的网络安全环境中的实用性和适用性。

社交媒体和公共数据 OSINT 与 ChatGPT

开放源情报（OSINT）技术允许我们从公开可用的来源收集信息，以支持诸如渗透测试之类的网络安全操作。这可以包括搜索社交媒体网站、公开记录、招聘启事等。在本配方中，我们将利用 ChatGPT 的自然语言能力来指导我们完成一项完整的 OSINT 项目，重点是从社交媒体和其他公开数据源中收集情报。

ChatGPT 可以作为一个 AI OSINT 专家，指导我们完成从头到尾的有效在线侦察。这个过程的对话性质帮助我们边走边学，获得新的技能和想法。到最后，您将拥有一个可以为现实世界的任务复制的详细计划和方法。OSINT 是道德黑客、社会工程师和网络防御者的重要技能。

准备工作

这个配方的前提条件很简单。您只需要一个网络浏览器和一个 OpenAI 帐户。如果您还没有创建帐户或需要了解如何使用 ChatGPT 界面，请参考第一章以获取全面的指南。

如何做...

让我们开始，让 ChatGPT 概述涉及社交媒体和公开数据源的 OSINT 操作的高级步骤：

确定系统角色并创建 OSINT 流程列表：

You are a cybersecurity professional with 25 years of experience, specializing in red team tactics. Think step-by-step and create a detailed list of steps to perform OSINT, as part of a cyber penetration test.

图 6.1 – ChatGPT 输出的示例 OSINT 过程步骤

接下来，我们将扩展 ChatGPT 识别的第一步：

"You are a cybersecurity professional with 25 years of experience, specializing in red team tactics. Think step-by-step and provide more detail on how I achieve the following. Include any applicable tools, apps, and resources.
Identify the Target: Identify the target organization or individual you will be focusing on during the OSINT phase. Gather as much information as possible about the target, such as the organization's name, website, key personnel, or any other relevant details."

图 6.2 – ChatGPT 输出的示例 OSINT 详细信息

对于原始提供的 OSINT 大纲中的每个剩余步骤，请重复第二提示。这将把每个高级步骤扩展为具有来自 ChatGPT 的工具和战术建议的详细过程。

一旦所有步骤都被扩展了，您将拥有一个全面的方法来执行以社交媒体和公开数据为重点的 OSINT 操作。

它是如何工作的...

这种技术的关键在于从一开始就将 ChatGPT 定位为一位经验丰富的 OSINT 专家。这样的框架使对话提示变得有序，指导模型提供关于进行在线侦察的详细、实用的响应。

要求 ChatGPT“逐步思考”进一步调整输出，从而得到有序、逻辑清晰的流程。我们首先让它概述整体工作流程，提供高级步骤。

然后，通过将每个步骤提供回 ChatGPT 作为一个提示，要求获取更多细节，我们基本上进入了如何执行每个阶段的具体细节。

这利用了 ChatGPT 在 OSINT 技艺方面的知识库，并利用其自然语言处理能力提供定制的建议。结果是一个根据我们的目标定制的专家指导的 OSINT 方法。

还有更多...

这种技术的美妙之处在于，“递归”可以进一步进行。如果 ChatGPT 的任何单个步骤解释中包含额外的高级任务，那么可以通过重复这一过程来进一步扩展这些任务。

例如，ChatGPT 可能会提到“使用 Google Dorks 查找公共记录。”这可以作为另一个提示返回给 ChatGPT，要求更多关于使用哪些运算符和策略的细节。

通过这种递归地“放大”细节的方式，您可以从 ChatGPT 中提取大量实用的建议，构建一个全面的指南。该模型还可以建议您可能从未考虑过的工具、技术和思想！

使用 ChatGPT 和 Python 进行 Google Dork 自动化

Google Dorks 是渗透测试人员、道德黑客甚至恶意行为者武器库中的强大工具。这些特殊设计的搜索查询利用了高级 Google 搜索运算符，以发现在网上无意中暴露的信息或漏洞。从查找开放目录到暴露的配置文件，Google Dorks 可以揭示一大堆信息，通常是无意中发布的。

然而，制作有效的 Google Dorks 需要专业知识，手动搜索每个 dork 可能会耗费时间。这就是 ChatGPT 和 Python 结合的优势所在。通过利用 ChatGPT 的语言能力，我们可以自动化生成符合特定要求的 Google Dorks。然后 Python 接管，使用这些 dorks 发起搜索并组织结果以进行进一步分析。

在这个配方中，我们利用 ChatGPT 生成一系列旨在在渗透测试期间发现有价值数据的 Google Dorks。然后我们使用 Python 有序地应用这些 dorks，产生一个关于目标的潜在漏洞或暴露信息的综合视图。这种方法不仅增加了渗透测试过程的效率，而且确保了对目标数字足迹的全面扫描。无论您是经验丰富的渗透测试人员，希望简化您的侦察阶段，还是热衷于探索 Google Dorks 的网络安全爱好者，这个配方都提供了一个实用的、自动化的方法，利用 Google 搜索引擎的力量进行安全评估。

准备工作

在深入研究本配方之前，请确保您已设置好 OpenAI 帐户并掌握了您的 API 密钥。如果没有，请参考 第一章 中的必要设置细节。您还需要 Python 版本 3.10.x 或更高版本，以及以下库：

openai：这个库使您能够与 OpenAI API 进行交互。使用 pip install openai 命令安装它。
requests：这个库对于进行 HTTP 请求是必不可少的。使用 pip install requests 安装它。
time：这是一个内置的 Python 库，用于各种与时间相关的任务。

另外，您需要设置一个谷歌 API 密钥和一个自定义搜索引擎 ID，可以在 console.cloud.google.com/ 和 cse.google.com/cse/all 上完成。

有了这些要求，您就可以开始深入了解脚本了。

如何做…

谷歌 Dorks 在揭示网络上暴露的数据或漏洞方面具有极大的潜力。虽然它们可以手动运行，但自动化此过程可以显著提高效率和全面性。在本节中，我们将指导您通过使用 Python 自动化应用 Google Dorks、获取搜索结果并保存它们进行进一步分析的步骤。

首先，让我们生成一个谷歌 Dorks 列表：

生成一系列 Google Dorks：为此，给 ChatGPT 一个明确的目标。使用以下提示与 ChatGPT：

"You are a cybersecurity professional specializing in red team tactics. I am a cybersecurity professional and I have a scenario where I need to find exposed documents on a my own domain. Please provide a list of example Google dorks that I can use to discover such vulnerabilities as part of an authorized exercise on my own authorized domain."

通过给 ChatGPT 提供场景和目的，ChatGPT 更不可能拒绝提示，认为它被要求提供一些不道德的东西。

这是一个示例输出：

图 6.3 – Google Dorks 列表的示例 ChatGPT 输出

接下来，让我们生成 Python 脚本来自动执行 Google Dork。

requests 和 time：
```
import requests
import time
```
设置先决条件：要使用谷歌的自定义搜索 JSON API，您需要设置它并获取必要的凭据：
```
API_KEY = 'YOUR_GOOGLE_API_KEY'
CSE_ID = 'YOUR_CUSTOM_SEARCH_ENGINE_ID'
SEARCH_URL = "https://www.googleapis.com/customsearch/v1?q={query}&key={api_key}&cx={cse_id}"
```
将'YOUR_GOOGLE_API_KEY'替换为您的 API 密钥，将'YOUR_CUSTOM_SEARCH_ENGINE_ID'替换为您的自定义搜索引擎 ID。这些对于您的脚本与谷歌的 API 通信至关重要。

'example.com'：

dorks = [
    'site:example.com filetype:pdf',
    'intitle:"index of" site:example.com',
    'inurl:admin site:example.com',
    'filetype:sql site:example.com',
    # ... add other dorks here ...
]

您可以使用与您的渗透测试目标相关的任何其他 Dorks 扩展此列表。

获取搜索结果：创建一个函数来使用提供的 Dork 获取谷歌搜索结果：

def get_search_results(query):
    """Fetch the Google search results."""
    response = requests.get(SEARCH_URL.format(query=query, api_key=API_KEY, cse_id=CSE_ID))
    if response.status_code == 200:
        return response.json()
    else:
        print("Error:", response.status_code)
        return {}

这个函数向谷歌自定义搜索 API发送一个带有 Dork 作为查询的请求，并返回搜索结果。

遍历 Dorks 并获取并保存结果：这是您自动化的核心。在这里，我们循环遍历每个 Google Dork，获取其结果，并将其保存在文本文件中：

def main():
    with open("dork_results.txt", "a") as outfile:
        for dork in dorks:
            print(f"Running dork: {dork}")
            results = get_search_results(dork)
            if 'items' in results:
                for item in results['items']:
                    print(item['title'])
                    print(item['link'])
                    outfile.write(item['title'] + "\n")
                    outfile.write(item['link'] + "\n")
                    outfile.write("-" * 50 + "\n")
            else:
                print("No results found or reached API limit!")
            # To not hit the rate limit, introduce a delay between requests
            time.sleep(20)

这个简单的代码片段确保当你运行脚本时，包含我们核心逻辑的 main 函数会被执行。

重要说明

请记住，谷歌的 API 可能有速率限制。我们在循环中引入了一个延迟，以防止过快地达到这些限制。根据您的 API 的具体速率限制，可能需要进行调整。

下面是完成的脚本应该是这样的：

import requests
import time
# Google Custom Search JSON API configuration
API_KEY = 'YOUR_GOOGLE_API_KEY'
CSE_ID = 'YOUR_CUSTOM_SEARCH_ENGINE_ID'
SEARCH_URL = "https://www.googleapis.com/customsearch/v1?q={query}&key={api_key}&cx={cse_id}"
# List of Google dorks
dorks = [
    'site:example.com filetype:pdf',
    'intitle:"index of" site:example.com',
    'inurl:admin site:example.com',
    'filetype:sql site:example.com',
    # ... add other dorks here ...
]
def get_search_results(query):
    """Fetch the Google search results."""
    response = requests.get(SEARCH_URL.format(query=query, api_key=API_KEY, cse_id=CSE_ID))
    if response.status_code == 200:
        return response.json()
    else:
        print("Error:", response.status_code)
        return {}
def main():
    with open("dork_results.txt", "a") as outfile:
        for dork in dorks:
            print(f"Running dork: {dork}")
            results = get_search_results(dork)
            if 'items' in results:
                for item in results['items']:
                    print(item['title'])
                    print(item['link'])
                    outfile.write(item['title'] + "\n")
                    outfile.write(item['link'] + "\n")
                    outfile.write("-" * 50 + "\n")
            else:
                print("No results found or reached API limit!")
            # To not hit the rate limit, introduce a delay between requests
            time.sleep(20)
if __name__ == '__main__':
    main()

这个脚本利用了 Python（用于自动化）和 ChatGPT（用于创建列表的初始专业知识）的力量，创建了一个高效而全面的 Google Dorking 工具，这是渗透测试人员工具库中的一个宝贵方法。

工作原理…

了解此脚本背后的机制将使您能够根据您的要求对其进行调整和优化。让我们深入研究这个自动 Google Dorking 脚本的运行机制：

Python 脚本：

API 和 URL 配置：
```
API_KEY = 'YOUR_GOOGLE_API_KEY'
CSE_ID = 'YOUR_CUSTOM_SEARCH_ENGINE_ID'
SEARCH_URL = https://www.googleapis.com/customsearch/v1?q={query}&key={api_key}&cx={cse_id}
```
脚本首先定义了用于向 Google 进行身份验证 API 调用并检索搜索结果的 Google API 密钥、自定义搜索引擎 ID 和搜索请求的 URL 端点的常量。这些常量对于获取认证的 Google API 调用并检索搜索结果至关重要。
get_search_results 函数使用 requests.get() 方法向 Google 自定义搜索 JSON API 发送 GET 请求。通过使用查询（Google Dork）、API 密钥和自定义搜索引擎 ID 格式化 URL，该函数检索指定 Dork 的搜索结果。然后将结果解析为 JSON。
main 函数是脚本在列表中迭代每个 Google Dork 的地方。对于每个 Dork，它使用前面提到的函数获取搜索结果，并将每个结果的标题和链接写入控制台和一个 dork_results.txt 文本文件。这样可以确保您有对您的发现的持久记录。
time.sleep(20) 语句，介绍了连续 API 调用之间的 20 秒延迟。这一点至关重要，因为在短时间内发送过多请求可能导致临时 IP 封禁或 API 限制。

GPT 提示：

制定提示：初始步骤涉及创建一个提示，指示 GPT 模型生成 Google Dorks 列表。该提示专门设计为向模型提供明确而简洁的指令，以及一个目的和场景，以便 ChatGPT 不会拒绝提示（由于安全措施阻止不道德的活动）。

还有更多...

虽然核心配方提供了利用 Google Dorks 进行渗透测试的基本方法，但真正掌握这个领域需要深入到更深层次的复杂性和细微差别。本节提供的附加增强和建议可能需要对渗透测试和编程有更高级的理解。超出此基本配方范围的探索可以为更深入的漏洞发现和分析提供丰富的可能性。如果您希望提升您的渗透测试能力，请使用这些附加组件扩展此配方，这样可以提供更全面的见解、更精细的结果和更高程度的自动化。但是，始终要谨慎行事，确保在探测系统和网络时保持道德实践，并获得必要的权限：

Dorks 的细化：虽然初始提示提供了一个基本的 Dorks 列表，但根据您正在处理的特定目标或领域，定制和细化这些查询总是一个好主意。例如，如果您特别关注 SQL 漏洞，您可能希望使用更多的 SQL 特定的 Dorks 扩展您的列表。
与其他搜索引擎集成: Google 不是唯一的搜索引擎。考虑扩展脚本以与其他搜索引擎如必应或 DuckDuckGo 合作。每个搜索引擎可能以不同的方式索引网站，为您带来更广泛的潜在漏洞范围。
自动化分析: 一旦您得到了结果，您可能想要实施后处理步骤。这可能包括检查漏洞的合法性，根据潜在影响对它们进行排序，甚至集成能够自动利用发现的漏洞的工具。
通知: 根据您的渗透测试范围，您可能会运行许多 Dorks，并且分析它们可能会耗费时间。考虑添加一个功能，当检测到特别高价值的漏洞时发送通知(可能通过电子邮件或者一个 Messenger bot)。
可视化仪表盘：以更直观的方式呈现结果，比如仪表盘，可能会有益，特别是当向利益相关者汇报时。有一些 Python 库，比如 Dash，甚至可以与工具如 Grafana 集成，可以帮助以更易消化的方式呈现您的发现。
速率限制和代理: 如果您发送了大量请求，不仅可能会触发 API 速率限制，还可能被封禁 IP。考虑在脚本中集成代理轮换，以在不同的 IP 地址之间分发请求。
道德考量: 始终要谨慎和合乎伦理地使用 Google Dorks。不要将它们用于利用您无权测试的系统上的漏洞。此外，要了解 Google 和 Google Cloud API 的服务条款。过度依赖或滥用可能导致 API 密钥被暂停或其他惩罚。

使用 ChatGPT 分析职位发布 OSINT

OSINT 指的是收集和分析公开可获得的信息的做法。在网络安全领域，OSINT 是一种宝贵的工具，可以提供有关组织内潜在漏洞、威胁和目标的见解。在众多的 OSINT 来源中，公司的职位招聘信息被认为是一种尤为丰富的数据宝库。乍一看，职位招聘信息似乎无害，旨在通过详细描述职位的职责、资格和福利来吸引潜在候选人。但是，这些描述通常无意中透露了远远超出预期的信息。

例如，一个寻找特定软件版本专家的工作列表可能会透露公司使用的确切技术，可能突出该软件的已知漏洞。同样，提到专有技术或内部工具的列表可能会提示公司独特的技术格局。工作广告还可能详细说明团队结构，揭示层次和关键角色，这可以用于社会工程攻击。此外，地理位置，部门间互动甚至工作列表的语气都可以为敏锐的观察者提供关于公司文化，规模和运营重点的见解。

理解这些细微差别，本方法指导您如何利用 ChatGPT 的功能来详细分析工作列表。通过这样做，您可以提取有价值的 OSINT 数据，然后将其结构化并以综合报告格式呈现。

准备就绪

这个方法的先决条件很简单。您只需要一个网页浏览器和一个 OpenAI 帐户。如果您还没有创建帐户或需要关于如何使用 ChatGPT 接口的提示，请参考 第一章 获取全面的指南。

如何做…

在深入逐步说明之前，理解 OSINT 数据的质量和深度会因工作描述的丰富程度而变化至关重要。请记住，虽然这种方法提供了有价值的见解，但请务必确保您被授权执行任何情报收集或渗透测试。

首先，我们需要分析工作描述：

准备初始 OSINT 分析的提示：

You are a cybersecurity professional with more than 25 years of experience, specializing in red team tactics. As part of an authorized penetration test, and using your knowledge of OSINT and social engineering tactics, analyze the following sample job description for useful OSINT data. Be sure to include any correlations and conclusions you might draw.

提供工作描述数据。将工作描述附加到提示中，确保清晰分隔：

图 6.4 – 示例提示与工作发布内容附加

分析结果。将组合的提示和数据发送到 ChatGPT 并审查衍生的 OSINT 数据：

图 6.5 – 示例 ChatGPT 输出分析

现在我们已经分析了结果，我们可以生成结构化的 OSINT 报告。

为报告生成准备下一个提示：

You are a cybersecurity professional with more than 25 years of experience, specializing in red team tactics. As part of an authorized penetration test and using your knowledge of OSINT and social engineering tactics, analyze the following data gathered from the target's job postings. Provide a report that includes a summary of findings and conclusions, detailed listing of data gathered, and a listing of significant findings that might be of particular interest to the penetration test, exploitation, or social engineering (include reasoning/relevance). Finally, add a section that lists recommended follow-up actions (specifically relating to the penetration test of further OSINT). Use markdown language formatting. Use the following report format:
#OSINT Report Title
##Summary
##Details
##Significant Findings
##Recommended Follow-up Actions

提供 OSINT 分析数据。将上一步的摘要 OSINT 结果附加到提示中：

图 6.6 – 示例提示与第一个工作数据分析附加

现在，我们可以生成报告了。将组合的提示和 OSINT 分析数据提交给 ChatGPT，以获取 Markdown 格式的结构化报告：

图 6.7 – 示例 ChatGPT 输出带有结构化格式

工作原理如下…

过程分为两个主要步骤 – 从工作列表中提取 OSINT 和生成结构化报告：

工作描述分析：第一个提示指导 ChatGPT 专注于从工作列表中提取 OSINT 数据。关键在于角色分配，这确保了模型采用了经验丰富的网络安全专业人员的视角，从而实现更深入的分析。
报告生成：第二个提示将 OSINT 发现结果结构化为详细报告。同样，角色分配至关重要。它确保 ChatGPT 理解上下文，并以适合网络安全专业人员的方式交付报告。使用 Markdown 格式确保报告结构化、清晰易读。

在两个步骤中，提示被设计为为 ChatGPT 提供正确的上下文。通过明确地向模型说明期望的结果和应该扮演的角色，我们确保结果符合网络安全 OSINT 分析的需求。

总之，这个方法展示了 ChatGPT 如何成为网络安全专业人员的宝贵工具，简化了从工作列表中提取 OSINT 和生成报告的过程。

还有更多…

从工作列表中进行 OSINT 分析只是了解公司数字足迹的冰山一角。以下是进一步增强和扩展此方法的一些额外方式：

多源数据：虽然工作列表可以提供丰富的信息，但考虑其他公开文档（如新闻发布、年度报告和官方博客）可以获得更多的 OSINT 数据。汇总和交叉引用来自多个来源的数据可以导致更全面的见解。
自动化数据收集：与其手动收集工作列表，不如考虑构建一个网络爬虫或使用 API（如果可用）来自动获取目标公司的新工作列表。这样可以进行持续监控和及时分析。

重要说明

我们没有包括自动化网络抓取在内，因为当前有关 LLMs 和网络抓取的争议。只要您有权限进行，这些技术在经过授权的渗透测试中是可以接受的。

时间分析：随时间分析工作列表可以提供关于公司增长领域、技术栈变化或扩展到新领域的见解。例如，云安全专业人员招聘的突然增加可能表示转移到云平台。
与其他 OSINT 工具集成：有许多可用的 OSINT 工具和平台可以补充从工作列表中获得的见解。将这种方法与其他工具集成可以提供更全面的目标视图。
伦理考量：始终确保任何 OSINT 收集活动都是在道德和合法的基础上进行的。请记住，尽管信息可能是公开可用的，但其使用可能具有法律和道德意义。

总之，虽然分析工作列表是 OSINT 工具包中一种有效的方法，但将其与其他技术和数据源结合起来可以显著增强其价值。一如既往，关键在于要彻底和道德，并及时了解 OSINT 领域的最新趋势和工具。

由 GPT 驱动的 Kali Linux 终端

导航和掌握任何Linux发行版的命令行，特别是像 Kali Linux 这样的以安全为重点的发行版，可能是一项艰巨的任务。对于初学者来说，他们需要记住各种命令、开关和语法，甚至完成基本任务都需要花费很大精力。对于经验丰富的专业人士来说，虽然他们可能熟悉许多命令，但即使是在行动中构建复杂的命令字符串有时也会耗费时间。这就是自然语言处理（NLP）和 OpenAI 的 GPT 模型的能力的威力所在。

在这个配方中，我们介绍了一种与 Linux 终端交互的创新方法：一个由自然语言处理驱动的终端界面。这个脚本利用了 OpenAI 的 GPT 模型的能力，允许用户用自然语言输入请求。作为回应，模型会解析意图，并将其转换为 Linux 操作系统的适当命令。例如，用户不需要记住某些操作的复杂语法，只需输入Show me all the files modified in the last 24 hours，模型就会生成并执行相应的find命令。

这种方法提供了许多好处：

用户友好：初学者可以在不需要深入了解命令行的情况下开始执行复杂操作。它降低了进入门槛并加速了学习曲线。
高效性：即使对于经验丰富的用户，这也可以加快工作流程。不需要记住特定的标志或语法，一个简单的句子就能生成所需的命令。
灵活性：不仅仅局限于操作系统命令。这种方法可以扩展到操作系统内的应用程序，从网络工具到诸如 Kali Linux 等发行版中的网络安全工具。
日志记录：模型生成的每个命令都有记录，提供审计轨迹和随着时间学习实际命令的方式。

在本配方结束时，你将拥有一个更像是与 Linux 专家对话的终端界面，它会指导你并代表你执行任务，由 GPT 模型的高级 NLP 功能提供支持。

准备就绪

在深入了解这个配方之前，请确保你已经设置好你的 OpenAI 账户并且拥有你的 API 密钥。如果没有，请参考第一章获取必要的设置详细信息。你还需要Python 版本 3.10.x 或更新版本。

另外，请确认你已经安装了以下 Python 库：

openai：这个库使你能够与 OpenAI API 交互。使用pip install openai命令安装它。
os：这是 Python 的内置库，允许您与操作系统交互，特别是用于访问环境变量。
subprocess：这个库是 Python 的内置库，允许你生成新的进程，连接到它们的输入/输出/错误管道，并获取它们的返回代码。

一旦这些要求满足，您就可以开始深入了解脚本了。

如何做...

要构建一个由 GPT 驱动的终端，我们将利用 OpenAI API 解释自然语言输入并生成相应的 Linux 命令。这种先进的 NLP 与操作系统功能的融合为用户提供了独特和增强的用户体验，特别是对于那些可能不熟悉复杂 Linux 命令的用户。按照这个分步指南将这个功能集成到您的 Linux 系统中：

pip：

import openai
from openai import OpenAI
import os
import subprocess

openai-key.txt：

def open_file(filepath): #Open and read a file
    with open(filepath, 'r', encoding='UTF-8') as infile:
        return infile.read()

此函数读取文件的内容。在我们的情况下，它从openai-key.txt中检索 API 密钥。

向 OpenAI API 发送请求：

创建一个函数来设置对 OpenAI API 的请求并检索输出：

def gpt_3(prompt):
    try:
        client = OpenAI()
        response = client.chat.completions.create(
            model="gpt-3.5-turbo", 
            prompt=prompt,
            temperature=0.1,
            max_tokens=600,
        )
        text = response.choices[0].message.content.strip()
        return text
    except openai.error.APIError as e:
        print(f"\nError communicating with the API.")
        print(f"\nError: {e}")
        print("\nRetrying...")
        return gpt_3(prompt)

此函数向 OpenAI GPT 模型发送提示并获取相应的输出。

使用subprocess库在您的 Linux 系统上执行 OpenAI API 生成的命令：
```
process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, bufsize=1, universal_newlines=True)
```
这段代码初始化一个新的子进程，运行命令，并向用户提供实时反馈。

while循环：

while True:
    request = input("\nEnter request: ")
    if not request:
        break
    if request == "quit":
        break
    prompt = open_file("prompt4.txt").replace('{INPUT}', request)
    command = gpt_3(prompt)
    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, bufsize=1, universal_newlines=True)
    print("\n" + command + "\n")
    with process:
        for line in process.stdout:
            print(line, end='', flush=True)
    exit_code = process.wait()

此循环确保脚本持续监听用户输入，处理它，并执行相应的命令，直到用户决定退出。

记录命令：为了将来的参考和审计目的，记录每个生成的命令：
```
append_file("command-log.txt", "Request: " + request + "\nCommand: " + command + "\n\n")
```
此代码将每个用户请求和相应生成的命令追加到名为command-log.txt的文件中。

prompt4.txt：

Provide me with the Windows CLI command necessary to complete the following request:
{INPUT}
Assume I have all necessary apps, tools, and commands necessary to complete the request. Provide me with the command only and do not generate anything further. Do not provide any explanation. Provide the simplest form of the command possible unless I ask for special options, considerations, output, etc.. If the request does require a compound command, provide all necessary operators, options, pipes, etc.. as a single one-line command. Do not provide me more than one variation or more than one line.

这就是完成的脚本应该看起来的样子：

import openai
from openai import OpenAI
import os
import subprocess
def open_file(filepath): #Open and read a file
    with open(filepath, 'r', encoding='UTF-8') as infile:
        return infile.read()
def save_file(filepath, content): #Create a new file or overwrite an existing one.
    with open(filepath, 'w', encoding='UTF-8') as outfile:
        outfile.write(content)
def append_file(filepath, content): #Create a new file or append an existing one.
    with open(filepath, 'a', encoding='UTF-8') as outfile:
        outfile.write(content)
#openai.api_key = os.getenv("OPENAI_API_KEY") #Use this if you prefer to use the key in an environment variable.
openai.api_key = open_file('openai-key.txt') #Grabs your OpenAI key from a file
def gpt_3(prompt): #Sets up and runs the request to the OpenAI API
    try:
        client = OpenAI()
        response = client.chat.completions.create(
            model="gpt-3.5-turbo", 
            prompt=prompt,
            temperature=0.1,
            max_tokens=600,
        )
        text = response['choices'].message.content.strip()
        return text
    except openai.error.APIError as e: #Returns and error and retries if there is an issue communicating with the API
        print(f"\nError communicating with the API.")
        print(f"\nError: {e}") #More detailed error output
        print("\nRetrying...")
        return gpt_3(prompt)
while True: #Keeps the script running until we issue the "quit" command at the request prompt
    request = input("\nEnter request: ")
    if not request:
        break
    if request == "quit":
        break
    prompt = open_file("prompt4.txt").replace('{INPUT}', request) #Merges our request input with the pre-written prompt file
    command = gpt_3(prompt)
    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, bufsize=1, universal_newlines=True) #Prepares the API response to run in an OS as a command
    print("\n" + command + "\n")
    with process: #Runs the command in the OS and gives real-time feedback
        for line in process.stdout:
            print(line, end='', flush=True)
    exit_code = process.wait()
    append_file("command-log.txt", "Request: " + request + "\nCommand: " + command + "\n\n") #Write the request and GPT generated command to a log

这个脚本提供了一个完全可操作的，由 GPT 驱动的，基于 NLP 的终端界面，为您与 Linux 系统交互提供了强大且用户友好的方式。

工作原理...

本质上，这个脚本弥合了 NLP 与 Linux 操作系统之间的差距。让我们分解一下组件，以了解这种集成的复杂性：

列出当前目录中的所有文件，脚本将此查询发送给 GPT-3 模型。然后模型对其进行处理，并用相应的 Linux 命令作出响应——在这种情况下是ls。
subprocess库是允许脚本在操作系统上执行命令的关键，该库提供了一个接口来生成和与子进程交互，模拟脚本中的命令行行为。

由 GPT-3 返回的命令使用subprocess.Popen()执行。使用Popen而不是其他方法的优势在于其灵活性。它生成一个新进程，让您与其输入/输出/错误管道进行交互，并获取其返回代码。
使用while循环使终端连续运行，允许用户输入多个请求而无需重新启动脚本。这模拟了典型终端的行为，用户可以连续运行命令。
日志记录机制：维护所有执行命令的日志对多个方面至关重要。首先，它有助于故障排除；如果一个命令表现出意外行为，你可以追溯到执行了什么。此外，从安全的角度来看，拥有命令的审计跟踪是非常宝贵的。
安全措施：将诸如 API 密钥之类的敏感信息以明文形式存储在脚本中是潜在的安全风险。这个脚本通过从一个单独的文件中读取 API 密钥来绕过这个问题，确保即使脚本被共享或暴露，API 密钥也能得到保护。始终确保包含 API 密钥的文件具有适当的文件权限，以限制未经授权的访问。
GPT-3 提示设计：提示的设计至关重要。一个精心制作的提示将引导模型提供更准确的结果。在这个脚本中，一个预定义的提示与用户的输入合并，生成一个更全面的 GPT-3 查询。这确保了模型具有正确的上下文来解释请求并返回适当的命令。

总之，这个脚本体现了先进的 NLP 能力与 Linux 操作系统的强大功能的无缝融合。通过将自然语言转化为复杂的命令，它为初学者和经验丰富的用户提供了一个增强的、直观的、高效的与系统交互的接口。

还有更多……

当涉及利用 NLP 与操作系统的强大功能时，这个脚本只是冰山一角。以下是一些你可以考虑的增强和扩展：

os.name 或 platform.system()），你可以动态调整 GPT-3 提示，以请求特定于操作系统的命令。
命令验证：在执行任何命令之前，实施一个安全层，将命令与安全命令列表进行验证。这可以防止意外执行可能有害的命令。
交互式命令执行：一些命令，尤其是安装或系统配置命令，可能需要用户交互（例如，确认或选择）。增强脚本以处理这些交互式命令将是非常有价值的。
给我获取与勒索软件相关的最新威胁可以从这些源获取实时数据。
增强日志记录：当前的日志记录机制记录命令。考虑扩展此功能以记录日期、时间，也许还有用户，特别是在部署在多用户系统上时。这提供了更好的审计能力。
用户配置文件：如果你打算使这个工具可供多个人使用，考虑用户配置文件。每个配置文件都可以有自己的命令集、权限，甚至可能有自己的 API 密钥。
命令历史记录：就像传统终端保留命令历史记录一样，拥有一个用户可以调取和重新运行以前命令的机制可以提升用户体验。

记住，虽然潜在的应用很广泛，但始终要注意安全。确保不会暴露敏感信息，并始终验证和清理输入和输出。

提示

使用 ChatGPT 和 OpenAI API 提供红队支持可能会比较棘手，因为 OpenAI 的安全机制在不断演化。虽然我们不赞同不道德或恶意行为，但有时候为了真正评估我们自身的漏洞和相应的风险水平，模仿攻击者的策略和行动是必要的。这些方法显然只能在授权的系统上执行。话虽如此，当我们能够让 OpenAI 的模型在这一努力中支持我们时，这将具有巨大的价值并且能节省大量时间。

我发现 OpenAI API 在涉及红队对抗策略时往往比 ChatGPT 网页界面更宽容。在你的提示中加入你被授权执行与 ChatGPT 协助相关的操作，并告诉 ChatGPT 你正在寻找示例（就像我们在前面的示例中做的那样），这在许多情况下都是有帮助的。

在本书的后面，我们将提供更多使用红队方法从 ChatGPT 中获得所需结果的策略，同时介绍更高级的技术。

第七章：威胁监控和检测

在动态和不断发展的网络安全领域，对威胁进行及时检测、分析和响应的作用至关重要。现代挑战需要创新解决方案，利用技术、人工智能和人类专业知识的力量。本章深入探讨了积极的网络安全领域，探讨了各种方法和工具，以保持对潜在威胁的领先地位。

在我们探索的前沿是威胁情报分析的概念。随着网络威胁的复杂性和数量不断增长，有效和高效的威胁情报的需求变得不可或缺。本章介绍了 ChatGPT 在分析原始威胁数据、提取关键威胁指标和为每个识别的威胁生成详细叙述方面的潜力。虽然传统平台提供了宝贵的见解，但 ChatGPT 的集成为快速初始分析提供了独特的机会，提供即时见解，并增强现有系统的能力。

更深入地探讨，本章阐明了实时日志分析的重要性。随着越来越多的设备、应用程序和系统生成日志，实时分析这些数据的能力变得至关重要。通过利用 OpenAI API 作为智能过滤器，我们可以突出潜在的安全事件，提供宝贵的上下文，并使事件响应者能够精确迅速地采取行动。

特别关注高级持续性威胁（APTs）的隐秘和持久性特征。这些威胁常常潜伏在阴影中，由于它们的闪烁策略而带来重大挑战。通过利用 ChatGPT 的分析能力结合本地 Windows 实用工具，本章提供了一种新颖的方法来检测这种复杂的威胁，为那些希望将人工智能驱动的见解融入其威胁搜索工具包的人提供了入门。

认识到每个组织的网络安全格局的独特性，本章深入探讨了构建自定义威胁检测规则的艺术和科学。通用规则往往无法捕捉特定威胁格局的复杂性，本节作为一个指南，指导制定与组织独特网络安全需求契合的规则。

最后，本章探讨了网络流量分析的重要性，强调了监视和分析网络数据的重要性。通过实际案例和场景，您将学习如何利用 OpenAI API 和 Python 的 SCAPY 库，为检测异常和加强网络安全提供新的视角。

本质上，本章作为传统网络安全实践与现代 AI 工具的融合的见证。无论您是刚开始您的网络安全之旅还是一个经验丰富的专家，本章都承诺提供理论、动手实践和见解的混合，将丰富您的网络安全工具箱。

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

威胁情报分析
实时日志分析
使用 ChatGPT 侦测 Windows 系统的 APT
构建自定义威胁检测规则
使用 PCAP 分析器进行网络流量分析和异常检测

技术要求

对于本章，您将需要一个网络浏览器和一个稳定的互联网连接来访问 ChatGPT 平台并设置您的账户。您还需要设置您的 OpenAI 账户并获取您的 API 密钥。如果没有，请参阅第一章获取详细信息。对 Python 编程语言的基本熟悉以及使用命令行的经验是必要的，因为您将使用Python 3.x，它需要安装在您的系统上，用于使用 OpenAI GPT API 和创建 Python 脚本。一个代码编辑器也是写作和编辑 Python 代码和提示文件的必要工具，因为您将在本章的配方中使用它。由于我们将专门讨论 Windows 系统的 APT，因此访问 Windows 环境（最好是 Windows Server）是必要的。

对以下主题的熟悉可能会有所帮助：

威胁情报平台：熟悉常见的威胁情报源和威胁迹象（IoCs）将会有所帮助。
日志分析工具：用于实时日志分析的工具或平台，如 ELK Stack（Elasticsearch、Logstash、Kibana）或 Splunk。
规则创建：对威胁检测规则的结构以及其背后的逻辑有基本的理解是必要的。熟悉像 YARA 这样的平台可能会有所帮助。
网络监控工具：像 Wireshark 或 Suricata 这样的工具，用于分析网络流量并检测异常。

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

威胁情报分析

在动态的网络安全领域，保持对威胁的领先地位的重要性不言而喻。这种主动方法的支柱之一是有效的威胁情报分析。本文提供了一个使用 ChatGPT 分析原始威胁情报数据的实用指南。在本练习结束时，您将拥有一个能够从各种来源收集未经结构化的威胁情报数据的工作脚本，利用 ChatGPT 识别和分类潜在威胁，提取指示妥协的工具，如 IP 地址、URL 和哈希，最后，为每个识别出的威胁生成一个上下文叙述。虽然 ChatGPT 并非专门设计用于替代专业的威胁情报平台，但它可以作为快速初步分析和洞察的宝贵工具。

本文旨在为任何现代网络安全专业人员提供一套关键技能。您将学习如何设置工作环境以与 OpenAI 的 GPT 模型进行交互。您还将了解如何构建查询，以便 ChatGPT 筛选原始数据以识别潜在威胁。此外，该文将教您如何使用 ChatGPT 从未经结构化的威胁数据中提取妥协指标。最后，您将了解如何理解您发现的威胁背后的上下文或叙述，从而丰富您的威胁分析能力。

准备工作

在深入本文之前，请确保您已经设置好了您的 OpenAI 账户并准备好了您的 API 密钥。如果没有，请参考第一章获取必要的设置详情。您还需要Python 版本 3.10.x 或更高版本。

另外，请确认您已安装了以下 Python 库：

openai: 这个库使您能够与 OpenAI API 进行交互。使用命令 pip install openai 安装它。
原始威胁数据：准备一个包含您希望分析的原始威胁情报数据的文本文件。这可以从各种论坛、安全公告或威胁情报订阅中收集到。

通过完成这些步骤，您将为运行脚本并分析原始威胁情报数据做好充分准备。

如何做…

在本节中，我们将通过 ChatGPT 步骤来分析原始威胁情报数据。由于本文的主要重点是使用 ChatGPT 提示，因此这些步骤旨在有效查询模型。

收集原始威胁数据。从收集未经结构化的威胁情报数据开始。这些数据可以来自各种地方，如论坛、博客和安全公告/警报。将这些数据存储在文本文件中以便轻松访问。
查询 ChatGPT 以识别威胁。打开您最喜欢的文本编辑器或 IDE 并启动 ChatGPT 会话。输入以下提示以在原始数据中识别潜在威胁：
```
Analyze the following threat data and identify potential threats: [Your Raw Threat Data Here]
```
ChatGPT 将分析数据并提供其识别出的潜在威胁列表。
提取威胁迹象（IoCs）。现在，使用第二个提示让 ChatGPT 突出显示特定的威胁迹象。输入以下内容：
```
Extract all indicators of compromise (IoCs) from the following threat data: [Your Raw Threat Data Here]
```
ChatGPT 将筛选数据并列出诸如 IP 地址、URL 和哈希值等 IoC。
开始上下文分析。要了解每个已识别威胁背后的上下文或叙述，请使用第三个提示：
```
Provide a detailed context or narrative behind the identified threats in this data: [Your Raw Threat Data Here]
```
ChatGPT 将为您提供详细的分析，解释每个威胁的起源、目标和潜在影响。
存储和共享。一旦您获得了所有这些信息，请将其存储在一个集中式数据库中，并将调查结果分发给相关利益相关者以进一步采取行动。

工作原理...

在这个示例中，我们利用了 ChatGPT 的自然语言处理能力进行威胁情报分析。让我们分解一下每个部分的工作原理：

收集原始威胁数据. 第一步涉及从各种来源收集非结构化数据。虽然 ChatGPT 并非设计用于抓取或收集数据，但您可以手动将来自多个来源的信息编译成文本文件。目标是获得一组可能包含隐藏威胁的全面数据。
查询 ChatGPT 进行威胁识别. ChatGPT 使用自然语言理解处理原始数据以识别潜在威胁。虽然不是专门的威胁情报软件的替代品，但 ChatGPT 可以提供有用的快速见解，用于初步评估。
提取 IoC. IoC 是指示恶意活动的数据元素。这些可以从 IP 地址到文件哈希值等。ChatGPT 利用其文本分析能力识别并列出这些 IoC，帮助安全专业人员更快地做出决策。
上下文分析. 了解威胁背后的背景对于评估其严重性和潜在影响至关重要。ChatGPT 基于其处理的数据提供叙事或上下文分析。这可以为您提供有关涉及威胁行为者的起源和目标的宝贵见解。
存储和共享. 最后一步涉及存储分析数据并与相关利益相关者共享。虽然 ChatGPT 不处理数据库交互或数据分发，但其输出可以轻松集成到现有工作流程中进行这些任务。

通过结合这些步骤，您可以利用 ChatGPT 的力量为您的威胁情报工作增加额外的分析层，所有这些只需几分钟。

还有更多...

虽然我们的主要重点是通过提示使用 ChatGPT，但您也可以通过使用 Python 中的 OpenAI API 自动化此过程。通过这种方式，您可以将 ChatGPT 的分析集成到您现有的网络安全工作流程中。在这个扩展部分中，我们将指导您通过 Python 代码来自动化 ChatGPT 威胁分析过程。

导入 OpenAI 库。首先，导入 OpenAI 库以与 OpenAI API 交互。
```
import openai
from openai import OpenAI
```
初始化 OpenAI API 客户端。设置你的 OpenAI API 密钥以初始化客户端。使用前面示例中演示的环境变量方法。
```
openai.api_key = os.getenv("OPENAI_API_KEY")
```

call_gpt，用于处理向 ChatGPT 发送提示并接收其响应。

def call_gpt(prompt):
    messages = [
        {
            "role": "system",
            "content": "You are a cybersecurity SOC
       analyst with more than 25 years of experience."
        },
        {
            "role": "user",
            "content": prompt
        }
    ]
    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

analyze_threat_data，它接受文件路径作为参数，并使用 call_gpt 分析威胁数据。

def analyze_threat_data(file_path):
    # Read the raw threat data from the provided file
    with open(file_path, 'r') as file:
        raw_data = file.read()

通过添加代码来查询 ChatGPT 进行威胁识别、IoC 提取和情境分析的 analyze_threat_data 函数。

    # Query ChatGPT to identify and categorize potential threats
    identified_threats = call_gpt(f"Analyze the
      following threat data and identify potential
        threats: {raw_data}")
    # Extract IoCs from the threat data
    extracted_iocs = call_gpt(f"Extract all indicators
      of compromise (IoCs) from the following threat
        data: {raw_data}")
    # Obtain a detailed context or narrative behind
      the identified threats
    threat_context = call_gpt(f"Provide a detailed
      context or narrative behind the identified
        threats in this data: {raw_data}")
    # Print the results
    print("Identified Threats:", identified_threats)
    print("\nExtracted IoCs:", extracted_iocs)
    print("\nThreat Context:", threat_context)

运行脚本。最后，将所有内容放在一起并运行主脚本。

if __name__ == "__main__":
    file_path = input("Enter the path to the raw
      threat data .txt file: ")
    analyze_threat_data(file_path)

正确的脚本应该粘贴在这里：

import openai
from openai import OpenAI
import os
# Initialize the OpenAI API client
openai.api_key = os.getenv("OPENAI_API_KEY")
def call_gpt(prompt):
    messages = [
        {
            "role": "system",
            "content": "You are a cybersecurity SOC analyst with more than 25 years of experience."
        },
        {
            "role": "user",
            "content": prompt
        }
    ]
    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
def analyze_threat_data(file_path):
    # Read the raw threat data from the provided file
    with open(file_path, 'r') as file:
        raw_data = file.read()
    # Query ChatGPT to identify and categorize potential threats
    identified_threats = call_gpt(f"Analyze the following threat data and identify potential threats: {raw_data}")
    # Extract IoCs from the threat data
    extracted_iocs = call_gpt(f"Extract all indicators of compromise (IoCs) from the following threat data: {raw_data}")
    # Obtain a detailed context or narrative behind the identified threats
    threat_context = call_gpt(f"Provide a detailed context or narrative behind the identified threats in this data: {raw_data}")
    # Print the results
    print("Identified Threats:", identified_threats)
    print("\nExtracted IoCs:", extracted_iocs)
    print("\nThreat Context:", threat_context)
if __name__ == "__main__":
    file_path = input("Enter the path to the raw threat data .txt file: ")
    analyze_threat_data(file_path)

该示例不仅演示了 ChatGPT 在增强威胁情报分析方面的实际应用，还强调了 AI 在网络安全中不断发展的作用。通过将 ChatGPT 集成到流程中，我们开启了威胁数据分析的效率和深度的新维度，使其成为网络安全专业人员在不断变化的威胁环境中加固防御的不可或缺的工具。

脚本的工作原理

让我们来看看脚本的运行步骤：

import openai 语句允许你的脚本使用 OpenAI Python 包，使其所有类和函数都可用。这对于向 ChatGPT 发送威胁分析的 API 调用至关重要。
'openai.api_key = os.getenv("OPENAI_API_KEY")' 通过设置你的个人 API 密钥来初始化 OpenAI API 客户端。这个 API 密钥验证你的请求，允许你与 ChatGPT 模型交互。确保使用实际从 OpenAI 获得的 API 密钥设置 'YOUR_OPENAI_API_KEY' 环境变量。
call_gpt(prompt) 函数是一个实用函数，旨在将你的查询发送到 ChatGPT 模型并检索响应。它使用预定义的系统消息来设置 ChatGPT 的角色，确保模型的输出与手头的任务相一致。openai.ChatCompletion.create() 函数是 API 调用发生的地方，使用诸如 model、messages 和 max_tokens 等参数来自定义查询。
analyze_threat_data(file_path) 作为威胁分析过程的核心。它首先从由 file_path 指定的文件中读取原始威胁数据。这些原始数据将在后续步骤中处理。
通过利用之前定义的 call_gpt 实用程序函数来使用 analyze_threat_data 函数。它向 ChatGPT 发送三个不同的查询：一个用于识别威胁，另一个用于提取威胁指示，最后一个用于情境分析。然后将结果打印到控制台进行审查。
if __name__ == "__main__": 块确保脚本只在直接执行时运行（不作为模块导入）。它要求用户输入原始威胁数据的文件路径，然后调用 analyze_threat_data 函数开始分析。

实时日志分析

在复杂且不断变化的网络安全世界中，实时威胁监控和检测至关重要。本文介绍了一种使用 OpenAI API 进行实时日志分析并生成潜在威胁警报的前沿方法。通过将来自防火墙、入侵检测系统（IDS）和各种日志等多种来源的数据引导到一个集中的监控平台，OpenAI API 充当智能过滤器。它分析传入的数据以突出可能的安全事件，为每个警报提供宝贵的上下文，从而使事件响应者能够更有效地设置优先级。本文不仅指导您完成设置这些警报机制的过程，还向您展示了如何建立一个反馈循环，实现持续的系统改进，并使其适应不断发展的威胁格局。

准备工作

在深入研究本文之前，请确保您已经设置了您的 OpenAI 账户并准备好了您的 API 密钥。如果没有，请参考 第一章 中的设置详细信息。您还需要 Python 版本 3.10.x 或更新版本。

此外，请确认你已安装了以下 Python 库：

openai: 此库使您能够与 OpenAI API 进行交互。使用命令 pip install openai 安装它。

除了 OpenAI 包外，您还需要 asyncio 库进行异步编程，以及 watchdog 库用于监视文件系统事件：pip installasyncio watchdog。

如何做…

要使用 OpenAI API 实现实时日志分析，请按照以下步骤设置您的系统以进行监控、威胁检测和警报生成。这种方法将使您能够在潜在的安全事件发生时对其进行分析和响应。

导入所需库. 第一步是导入您将在脚本中使用的所有库。

import asyncio
import openai
from openai import OpenAI
import os
import socket
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

初始化 OpenAI API 客户端. 在您可以开始发送日志进行分析之前，初始化 OpenAI API 客户端。

# Initialize the OpenAI API client
#openai.api_key = 'YOUR_OPENAI_API_KEY'  # Replace with your actual API key if you choose not to use a system environment variable
openai.api_key = os.getenv("OPENAI_API_KEY")

创建调用 GPT 的函数. 创建一个函数，该函数将与 GPT-3.5 Turbo 模型进行交互，以分析日志条目。

def call_gpt(prompt):
    messages = [
        {
            "role": "system",
            "content": "You are a cybersecurity SOC
              analyst with more than 25 years of
                experience."
        },
        {
            "role": "user",
            "content": prompt
        }
    ]
    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()

为 Syslog 设置异步函数. 设置一个异步函数来处理传入的 syslog 消息。我们在这个示例中使用 UDP 协议。

async def handle_syslog():
    UDP_IP = "0.0.0.0"
    UDP_PORT = 514
    sock = socket.socket(socket.AF_INET,
      socket.SOCK_DGRAM)
    sock.bind((UDP_IP, UDP_PORT))
    while True:
        data, addr = sock.recvfrom(1024)
        log_entry = data.decode('utf-8')
        analysis_result = call_gpt(f"Analyze the following log entry for potential threats: {log_entry} \n\nIf you believe there may be suspicious activity, start your response with 'Suspicious Activity: ' and then your analysis. Provide nothing else.")
        if "Suspicious Activity" in analysis_result:
            print(f"Alert: {analysis_result}")
        await asyncio.sleep(0.1)

使用 watchdog 库监视特定目录以获取新的日志文件。

class Watcher:
    DIRECTORY_TO_WATCH = "/path/to/log/directory"
    def __init__(self):
        self.observer = Observer()
    def run(self):
        event_handler = Handler()
        self.observer.schedule(event_handler,
          self.DIRECTORY_TO_WATCH, recursive=False)
        self.observer.start()
        try:
            while True:
                pass
        except:
            self.observer.stop()
            print("Observer stopped")

Handler 类将处理正在观察的目录中新创建的文件。

class Handler(FileSystemEventHandler):
    def process(self, event):
        if event.is_directory:
            return
        elif event.event_type == 'created':
            print(f"Received file: {event.src_path}")
            with open(event.src_path, 'r') as file:
                for line in file:
                    analysis_result = call_gpt(f"Analyze the following log entry for potential threats: {line.strip()} \n\nIf you believe there may be suspicious activity, start your response with 'Suspicious Activity: ' and then your analysis. Provide nothing else.")
        if "Suspicious Activity" in analysis_result:
            print(f"Alert: {analysis_result}")
    def on_created(self, event):
        self.process(event)

运行系统. 最后，将所有内容组合在一起并运行您的系统。

if __name__ == "__main__":
    asyncio.run(handle_syslog())
    w = Watcher()
    w.run()

这是完成的脚本应该是这样的：

import asyncio
import openai
from openai import OpenAI
import os
import socket
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
# Initialize the OpenAI API client
#openai.api_key = 'YOUR_OPENAI_API_KEY'  # Replace with your actual API key if you choose not to use a system environment variable
openai.api_key = os.getenv("OPENAI_API_KEY")
# Function to interact with ChatGPT
def call_gpt(prompt):
    messages = [
        {
            "role": "system",
            "content": "You are a cybersecurity SOC analyst
              with more than 25 years of experience."
        },
        {
            "role": "user",
            "content": prompt
        }
    ]
    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()
# Asynchronous function to handle incoming syslog messages
async def handle_syslog():
    UDP_IP = "0.0.0.0"
    UDP_PORT = 514
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.bind((UDP_IP, UDP_PORT))
    while True:
        data, addr = sock.recvfrom(1024)
        log_entry = data.decode('utf-8')
        analysis_result = call_gpt(f"Analyze the following log entry for potential threats: {log_entry} \n\nIf you believe there may be suspicious activity, start your response with 'Suspicious Activity: ' and then your analysis. Provide nothing else.")
        if "Suspicious Activity" in analysis_result:
            print(f"Alert: {analysis_result}")
        await asyncio.sleep(0.1)  # A small delay to allow
          other tasks to run
# Class to handle file system events
class Watcher:
    DIRECTORY_TO_WATCH = "/path/to/log/directory"
    def __init__(self):
        self.observer = Observer()
    def run(self):
        event_handler = Handler()
        self.observer.schedule(event_handler,
          self.DIRECTORY_TO_WATCH, recursive=False)
        self.observer.start()
        try:
            while True:
                pass
        except:
            self.observer.stop()
            print("Observer stopped")
class Handler(FileSystemEventHandler):
    def process(self, event):
        if event.is_directory:
            return
        elif event.event_type == 'created':
            print(f"Received file: {event.src_path}")
            with open(event.src_path, 'r') as file:
                for line in file:
                    analysis_result = call_gpt(f"Analyze the following log entry for potential threats: {line.strip()} \n\nIf you believe there may be suspicious activity, start your response with 'Suspicious Activity: ' and then your analysis. Provide nothing else.")
        if "Suspicious Activity" in analysis_result:
            print(f"Alert: {analysis_result}")
    def on_created(self, event):
        self.process(event)
if __name__ == "__main__":
    # Start the syslog handler
    asyncio.run(handle_syslog())
    # Start the directory watcher
    w = Watcher()
    w.run()

通过遵循本文，您已为您的网络安全工具包配备了一个先进的实时日志分析系统，利用 OpenAI API 进行高效的威胁检测和警报。这个设置不仅增强了您的监控能力，还确保了您的安全姿态对网络威胁动态特性的应对能力。

工作原理…

理解代码如何工作对于调整以适应特定需求或进行故障排除至关重要。让我们分解一下关键要素：

asyncio用于异步编程，openai用于与 OpenAI API 交互，os用于环境变量，以及socket和watchdog用于网络和文件系统操作。
使用环境变量初始化openai.api_key。此密钥允许脚本通过 OpenAI API 与 GPT-3.5 Turbo 模型进行交互。
call_gpt()函数作为 OpenAI API 调用的包装器。它以日志条目作为提示，并返回分析结果。该函数配置为以经验丰富的网络安全 SOC 分析员的身份与系统进行交互，这有助于生成更具上下文感知性的响应。
handle_syslog()函数是异步的，允许它处理多个传入的 syslog 消息而不阻塞。它调用call_gpt()函数，并检查日志条目中的关键字可疑活动以生成警报。
Watcher类使用watchdog库监视目录以查找新的日志文件。每当创建新文件时，它会触发Handler类。
Handler类逐行读取新的日志文件，并将每一行发送到call_gpt()函数进行分析。类似于 syslog 处理，它还会检查分析结果中是否存在关键字“可疑活动”，以生成警报。
警报机制. 如果分析中发现可疑活动，则 syslog 处理程序和文件系统事件处理程序都会将警报打印到控制台。这可以很容易地扩展为通过电子邮件、Slack 或任何其他警报机制发送警报。
主执行. 脚本的主执行开始异步 syslog 处理程序和文件系统监视器，使系统准备好进行实时日志分析。

通过以这种方式构建代码，您可以获得一个模块化且易于扩展的实时日志分析系统，由 OpenAI API 提供支持。

还有更多...

在这个示例中呈现的代码作为使用 OpenAI API 进行实时日志分析的基础层。虽然它展示了核心功能，但它是一个基本的实现，应该扩展以最大化其在生产环境中的效用。以下是一些扩展的途径：

可扩展性. 当前的设置很基本，可能无法很好地处理大规模、高吞吐量的环境。考虑使用更先进的网络设置和分布式系统来扩展解决方案。
警报机制. 虽然代码会将警报打印到控制台，但在生产环境中，您可能希望集成现有的监控和警报解决方案，如 Prometheus、Grafana，或者甚至是一个简单的电子邮件警报系统。
数据丰富化. 脚本当前将原始日志条目发送到 OpenAI API。添加数据丰富化步骤以添加上下文或关联条目可以提高分析质量。
机器学习反馈循环。随着更多的数据和结果，机器学习模型可以被训练来减少误报，并随时间提高准确性。
用户界面。可以开发交互式仪表板来可视化警报，并可能实时控制系统的行为。

注意事项

需要注意的是，将实际敏感数据发送到 OpenAI API 可能会暴露它。虽然 OpenAI API 是安全的，但它并不是为处理敏感或机密信息而设计的。但是，在本书的后续章节中，我们将讨论使用本地模型来分析敏感日志的方法，将您的数据保留在本地并保持私密。

使用 ChatGPT 在 Windows 系统上检测 APTs

APTs 是一类网络攻击，入侵者通过未经授权的方式获取对系统的访问权限，并在一段时间内保持未被发现。这些攻击通常针对拥有高价值信息的组织，包括金融数据、知识产权或国家安全细节。由于其低速操作策略和使用先进技术规避传统安全措施的技巧，APTs 特别难以检测。本步骤旨在利用 ChatGPT 的分析能力来协助在 Windows 系统上主动监控和检测此类威胁。通过将原生 Windows 实用程序与 ChatGPT 的自然语言处理能力相结合，您可以创建一个基本但具有洞察力的威胁搜索工具。虽然这种方法不能替代专门的威胁搜索软件或专家，但它可以作为了解 AI 如何为网络安全做出贡献的教育或概念验证方法。

准备工作

在深入了解这个步骤之前，请确保你已经设置好了你的 OpenAI 账户，并且有你的 API 密钥在手。如果没有，你应该回顾第一章中的必要设置细节。你还需要 Python 版本 3.10.x 或更高版本。

另外，请确认您已安装了以下 Python 库：

Openai：这个库使你能够与 OpenAI API 进行交互。使用命令 pip install openai 安装它。

最后，脚本使用了本地 Windows 命令行实用程序，如 reg query、tasklist、netstat、schtasks 和 wevtutil。这些命令在大多数 Windows 系统上预先安装，因此不需要为它们安装额外的软件。

重要提示

此脚本必须以管理员权限在 Windows 机器上执行，以访问特定系统信息。确保您具有管理员访问权限，或者如果您在一个组织中，请咨询您的系统管理员。

怎样做…

要在 Windows 系统上检测 高级持续威胁 (APTs)，请按照以下步骤收集系统数据，并使用 ChatGPT 分析可能的安全威胁。

导入所需模块。首先，导入所需的 Python 模块。您将需要subprocess模块来运行 Windows 命令，os来获取环境变量，以及openai来与 ChatGPT 交互。
```
import subprocess
import os
import openai
from openai import OpenAI
```
初始化 OpenAI API 客户端。接下来，使用您的 API 密钥初始化 OpenAI API 客户端。您可以直接编码 API 密钥，也可以从环境变量中检索它。
```
# Initialize the OpenAI API client
#openai.api_key = 'YOUR_OPENAI_API_KEY'
openai.api_key = os.getenv("OPENAI_API_KEY")
```

定义与 ChatGPT 交互的函数。创建一个函数，该函数将使用给定的提示与 ChatGPT 进行交互。此函数负责向 ChatGPT 发送提示和消息，并返回其响应。

def call_gpt(prompt):
    messages = [
        {
            "role": "system",
            "content": "You are a cybersecurity SOC
              analyst with more than 25 years of
                experience."
        },
        {
            "role": "user",
            "content": prompt
        }
    ]
    client = OpenAI()
    response = client.chat.completions.creat(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=2048,
        n=1,
        stop=None,
        temperature=0.7
    )
    response.choices[0].message.content.strip()

重要提示

如果数据收集产生超出模型限制的令牌数量的错误，则可能需要使用模型gpt-4-turbo-preview。

定义命令执行函数。此函数将运行给定的 Windows 命令并返回其输出。

# Function to run a command and return its output
def run_command(command):
    result = subprocess.run(command, stdout=
      subprocess.PIPE, stderr=subprocess.PIPE,
        text=True, shell=True)
    return result.stdout

收集和分析数据。现在，函数已设置好，下一步是从 Windows 系统中收集数据，并使用 ChatGPT 进行分析。数据收集使用本机 Windows 命令。

# Gather data from key locations
# registry_data = run_command('reg query HKLM /s')  # This produces MASSIVE data. Replace with specific registry keys if needed
# print(registry_data)
process_data = run_command('tasklist /v')
print(process_data)
network_data = run_command('netstat -an')
print(network_data)
scheduled_tasks = run_command('schtasks /query /fo LIST')
print(scheduled_tasks)
security_logs = run_command('wevtutil qe Security /c:10 /rd:true /f:text')  # Last 10 security events. Adjust as needed
print(security_logs)
# Analyze the gathered data using ChatGPT
analysis_result = call_gpt(f"Analyze the following Windows system data for signs of APTs:\nProcess Data:\n{process_data}\n\nNetwork Data:\n{network_data}\n\nScheduled Tasks:\n{scheduled_tasks}\n\nSecurity Logs:\n{security_logs}") # Add Registry Data:\n{#registry_data}\n\n if used
# Display the analysis result
print(f"Analysis Result:\n{analysis_result}")

完成的脚本应如下所示：

import subprocess
import os
import openai
from openai import OpenAI
# Initialize the OpenAI API client
#openai.api_key = 'YOUR_OPENAI_API_KEY'  # Replace with your actual API key or use a system environment variable as shown below
openai.api_key = os.getenv("OPENAI_API_KEY")
# Function to interact with ChatGPT
def call_gpt(prompt):
    messages = [
        {
            "role": "system",
            "content": "You are a cybersecurity SOC analyst
              with more than 25 years of experience."
        },
        {
            "role": "user",
            "content": prompt
        }
    ]
    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()
# Function to run a command and return its output
def run_command(command):
    result = subprocess.run(command,
    stdout=subprocess.PIPE, stderr=subprocess.PIPE,
      text=True, shell=True)
    return result.stdout
# Gather data from key locations
# registry_data = run_command('reg query HKLM /s')  # This produces MASSIVE data. Replace with specific registry keys if needed
# print(registry_data)
process_data = run_command('tasklist /v')
print(process_data)
network_data = run_command('netstat -an')
print(network_data)
scheduled_tasks = run_command('schtasks /query /fo LIST')
print(scheduled_tasks)
security_logs = run_command('wevtutil qe Security /c:10 /rd:true /f:text')  # Last 10 security events. Adjust as needed
print(security_logs)
# Analyze the gathered data using ChatGPT
analysis_result = call_gpt(f"Analyze the following Windows system data for signs of APTs:\nProcess Data:\n{process_data}\n\nNetwork Data:\n{network_data}\n\nScheduled Tasks:\n{scheduled_tasks}\n\nSecurity Logs:\n{security_logs}") # Add Registry Data:\n{#registry_data}\n\n if used
# Display the analysis result
print(f"Analysis Result:\n{analysis_result}")

在本教程中，我们通过利用 ChatGPT 的分析能力，探索了一种新颖的 APT 检测方法。利用本机 Windows 命令行工具进行数据收集，并将这些信息传递给 ChatGPT，我们创建了一个基础但有洞察力的威胁搜索工具。这种方法提供了一种独特的方式来实时识别和理解 APT，有助于及时制定响应策略。

工作原理...

本教程采用了独特的方法，将 Python 脚本与 ChatGPT 的自然语言处理能力相结合，为 Windows 系统创建了一个基本的 APT 检测工具。让我们分析每个部分，以了解其复杂性。

使用本机 Windows 命令进行数据收集。Python 脚本使用一系列本机 Windows 命令行工具来收集相关系统数据。像reg query这样的命令会获取注册表条目，其中可能包含 APT 设置的配置。同样，tasklist列举正在运行的进程，netstat -an则给出当前网络连接的快照，等等。

这些命令是 Windows 操作系统的一部分，并使用 Python 的subprocess模块执行，该模块允许您生成新进程，连接到它们的输入/输出/错误管道，并获取它们的返回代码。
call_gpt函数充当 Python 脚本和 ChatGPT 之间的桥梁。它利用 OpenAI API 将提示以及收集到的系统数据发送到 ChatGPT。

OpenAI API 需要 API 密钥进行身份验证，该密钥可从 OpenAI 的官方网站获取。此 API 密钥用于在脚本中初始化 OpenAI API 客户端。
ChatGPT 的分析和背景. ChatGPT 收到系统数据和引导其寻找异常或高级持久性威胁活动指标的提示。提示被设计为特定于任务，利用 ChatGPT 理解和分析文本的能力。

ChatGPT 的分析旨在发现数据中的异常或异常行为。它试图识别异常的注册表项，可疑的运行进程或奇怪的网络连接，这可能表明存在高级持久性威胁。
输出和结果解读. 分析完成后，ChatGPT 的发现以文本输出返回。然后通过 Python 脚本打印到控制台。

输出应被视为进一步调查的起点。它提供线索和潜在指标，可以指导您的响应策略。
需要管理特权. 需要注意的是，该脚本必须以管理员权限运行，以访问特定受保护系统信息。这确保脚本可以探测通常受限制的系统区域，为分析提供更全面的数据集。

通过架构 Python 与 ChatGPT 在系统级细节交互的能力，以及 ChatGPT 在自然语言理解方面的才能，这个方案为实时威胁检测和分析提供了一个基础但深思熟虑的工具。

还有更多…

我们刚刚介绍的方法提供了一个识别 Windows 系统上潜在高级持久性威胁活动的基本且有效方法。然而，值得注意的是，这只是冰山一角，有几种方法可以扩展此功能以进行更全面的威胁搜索和监测：

机器学习集成. 虽然 ChatGPT 为异常检测提供了一个良好的起点，但集成机器学习算法进行模式识别可以使系统更加强大。
自动响应. 目前，该脚本提供可用于手动响应规划的分析。您可以通过自动化某些响应方式，如根据威胁的严重性隔离网络段或禁用用户帐户，进一步扩展功能。
纵向分析. 该脚本执行一种即时分析。然而，高级持久性威胁往往通过随时间变化的行为显露出来。存储数据并运行趋势分析可以提供更准确的检测。
与安全信息和事件管理（SIEM）解决方案集成. SIEM 解决方案可以提供对组织安全状况的更全面视图。将脚本的输出集成到 SIEM 中可以与其他安全事件进行关联，增强整体检测能力。
多系统分析. 当前脚本专注于单个 Windows 系统。将其扩展到从网络中多个系统收集数据，可以提供更全面的潜在威胁视图。
用户行为分析 (UBA). 结合 UBA 可以增加另一层复杂性。通过理解正常用户行为，系统可以更准确地识别可能表示威胁的异常活动。
定期运行. 与手动运行脚本相比，您可以安排它定期运行，提供更连续的监控解决方案。
警报机制. 实施实时通知系统管理员或安全团队的警报机制可以加速响应过程。
可定制威胁指标. 允许在脚本中进行自定义，运营商可以根据不断变化的威胁环境定义其威胁指标。
文档和报告. 增强脚本以生成详细报告可以帮助进行事后分析和合规报告。

通过考虑这些扩展，您可以将这个初级工具转变为更全面、动态和响应灵活的威胁监控系统。

建立自定义威胁检测规则

在网络安全不断发展的背景下，通用的威胁检测规则通常效果不佳。每个组织网络和系统的细微差别需要为特定的威胁环境量身定制的自定义规则。本配方旨在为您提供识别独特威胁并撰写自定义检测规则的技能，特别是使用 ChatGPT 的 YARA 规则。通过手把手的样本场景，从威胁识别到规则部署的全面指南，本配方为增强您的组织的威胁监控和检测能力提供了一站式服务。

准备就绪

本配方的先决条件很简单。您只需要一个 Web 浏览器和一个 OpenAI 账户。如果您还没有创建账户或需要关于如何使用 ChatGPT 界面的刷新，请参阅第一章以获取全面指南。

您还应清楚了解您的组织环境。这包括部署的系统类型清单、使用的软件以及需要保护的最关键资产。

确保您具备：

一个可以安全部署和测试规则的测试环境。这可以是一个虚拟化网络或一个隔离的实验室设置。
具有使用 YARA 规则或类似规则进行测试的现有威胁检测系统。

对于不熟悉 YARA 规则的人，您可能需要了解一些基础知识，因为本配方将需要一些关于它们在威胁检测环境中的工作方式的理解。

如何做…

重要提示

本书的官方 GitHub 存储库中可以找到两个样本威胁场景。这些场景可用于测试本配方中的提示，还可提供有关创建自己的实践场景的指导。

使用 ChatGPT 建立自定义威胁检测规则的过程涉及一系列步骤。这些步骤将带您从识别独特威胁到部署有效规则。

识别独特威胁。
- 子步骤 1：进行内部评估或咨询您的网络安全团队，以确定与您的环境最相关的具体威胁。
- 子步骤 2：审查任何最近的事件、日志或威胁情报报告，以查找模式或指标。

重要说明

这里的目标是找到特定的东西——一个独特的文件，一个不寻常的系统行为，或者一个特定的网络模式——这些都不在通用检测规则范围内。

使用 ChatGPT 起草规则。
- - 子步骤 1：打开您的网络浏览器并导航至 ChatGPT 网页界面。
- 子步骤 2：与 ChatGPT 开始一次对话。尽可能具体地描述威胁特征。例如，如果您正在处理一种留下独特文件的恶意软件，请明确说明。
示例提示：
```
I've noticed suspicious network activity where an unknown external IP is making multiple failed SSH login attempts on one of our critical servers. The IP is 192.168.1.101 and it's targeting Server-XYZ on SSH port 22\. Can you help me draft a YARA rule to detect this specific activity?
```
- 子步骤 3：审查 ChatGPT 为您起草的 YARA 规则。确保它包括您已识别威胁的特征。
测试规则。
- 子步骤 2：通过将其添加到您的威胁检测系统中，部署 YARA 规则。如果您对此还不熟悉，大多数系统都有用于新规则的导入或上传功能。
- 子步骤 3：运行初始扫描以检查误报和规则的整体效果。

重要说明

如有引起干扰的规则变更，请准备回退更改或禁用规则。

细化。

子步骤 1：评估测试结果。记录任何误报或遗漏。
子步骤 2：使用这些数据返回 ChatGPT 进行细化。

用于细化的示例提示：

The YARA rule for detecting the suspicious SSH activity is generating some false positives. It's alerting on failed SSH attempts that are part of routine network scans. Can you help me refine it to focus only on the pattern described in the initial scenario?

部署。
- 子步骤 1：一旦您对规则的性能感到满意，准备部署。
- 子步骤 2：使用系统的规则管理界面将优化后的规则集成到您的生产威胁检测系统中。

工作原理……

理解每个步骤背后的机制将为您提供适应这个方法到其他威胁场景所需的洞察力。让我们分解发生的事情：

识别独特威胁。在这个阶段，您基本上正在进行威胁狩猎。您正在超越警报和日志，寻找在您环境中不寻常且特定的模式或行为。
使用 ChatGPT 起草规则。ChatGPT 使用其训练模型理解您提供的威胁特征。基于这种理解，它起草了一个旨在检测描述的威胁的 YARA 规则。这是一种自动化规则生成的形式，为您节省了编写规则所需的时间和精力。
测试规则。在任何网络安全任务中，测试都至关重要。在这里，你不仅要检查规则是否有效，还要确保它不会导致中断或误报。一个设计不良的规则可能会与没有规则一样问题重重。
细化。这一步是关于迭代的。网络威胁并不是静态的，它们在不断演变。你创建的规则可能需要随着时间的推移进行调整，要么是因为威胁已经改变，要么是因为初始规则并不完美。
部署。一旦规则经过测试和完善，就可以部署到生产环境中。这是你努力的最终验证。然而，持续监控对确保规则对其设计用于检测的威胁仍然有效至关重要。

通过理解每个步骤的工作原理，你可以将这种方法应用于各种威胁类型和场景，使你的威胁检测系统更加健壮和响应灵活。

还有更多……

现在你已经学会了如何使用 ChatGPT 创建自定义威胁检测规则，你可能对深入研究相关主题和高级功能感兴趣。以下是一些值得探索的领域：

高级 YARA 功能。一旦你对基本的 YARA 规则创建感到满意，考虑深入了解其高级功能。YARA 提供条件语句和外部变量等功能，可以使你的自定义规则更加有效。
持续监控和调整。网络威胁不断变化，你的检测规则也应该如此。定期审查和更新你的自定义规则，以适应新的威胁环境并微调其性能。
与 SIEM 解决方案集成。可以将自定义 YARA 规则集成到现有的 SIEM 解决方案中。这种集成可以实现更全面的监控方法，将规则警报与其他安全事件相关联。
社区资源。为了进一步探索和支持，可以查看专门用于 YARA 和威胁检测的在线论坛、博客或 GitHub 仓库。这些平台可以是学习和故障排除的绝佳资源。
威胁检测中的 AI 未来。威胁检测领域的格局不断变化，机器学习和人工智能发挥着越来越关键的作用。像 ChatGPT 这样的工具可以极大地简化规则创建过程，在现代网络安全工作中充当宝贵的资产。

使用 PCAP 分析器进行网络流量分析和异常检测

在网络安全不断发展的领域，跟踪网络流量至关重要。传统方法通常涉及使用专业的网络监控工具和大量手动工作。本配方采用了与 Python 的 SCAPY 库结合使用 OpenAI API 的不同方法。通过本配方，你将学会如何分析包含捕获的网络流量的 PCAP 文件，并识别潜在的异常或威胁，而无需实时 API 调用。这不仅使分析具有见地，而且成本效益高。无论你是网络安全的新手还是经验丰富的专业人士，本配方都为增强你的网络安全措施提供了一种新颖的方式。

准备工作

在深入本配方之前，请确保已设置好你的 OpenAI 账户并准备好你的 API 密钥。如果没有，请参考第一章获取必要的设置详情。你还需要 Python 版本 3.10.x 或更高版本。

另外，请确认你已安装以下 Python 库：

openai：这个库使你能够与 OpenAI API 进行交互。使用命令 pip install openai 进行安装。
SCAPY 库：安装 SCAPY Python 库，该库将用于读取和分析 PCAP 文件。你可以使用 pip 进行安装：pip install scapy。
PCAP 文件：准备好一个 PCAP 文件进行分析。你可以使用 Wireshark 或 Tcpdump 等工具捕获网络流量，或者使用可在wiki.wireshark.org/SampleCaptures找到的示例文件。GitHub 存储库中也提供了一个名为 example.pcap 的示例文件。
libpcap（Linux 和 MacOS）或 Ncap（Windows）：你需要安装适当的库以使 SCAPY 能够读取 PCAP 文件。libpcap 可以在www.tcpdump.org/找到，Ncap 可以在npcap.com/找到。

操作方法…

这个配方将指导你通过逐步过程使用 ChatGPT 和 Python 的 SCAPY 库来分析网络流量并检测异常。

用你的实际 API 密钥替换YOUR_OPENAI_API_KEY。

import openai
from openai import OpenAI
import os
#openai.api_key = 'YOUR_OPENAI_API_KEY'  # Replace with your actual API key or set the OPENAI_API_KEY environment variable
openai.api_key = os.getenv("OPENAI_API_KEY")

chat_with_gpt，它接受提示并将其发送到 API 进行分析。

# Function to interact with the OpenAI API
def chat_with_gpt(prompt):
    messages = [
        {
            "role": "system",
            "content": "You are a cybersecurity SOC
       analyst with more than 25 years of experience."
        },
        {
            "role": "user",
            "content": prompt
        }
    ]
    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()

读取并预处理 PCAP 文件。利用 SCAPY 库读取捕获的 PCAP 文件并总结网络流量。
```
from scapy.all import rdpcap, IP, TCP
# Read PCAP file
packets = rdpcap('example.pcap')
```

总结流量。处理 PCAP 文件以总结关键的流量方面，如唯一的 IP 地址、端口和使用的协议。

# Continue from previous code snippet
ip_summary = {}
port_summary = {}
protocol_summary = {}
for packet in packets:
    if packet.haslayer(IP):
        ip_src = packet[IP].src
        ip_dst = packet[IP].dst
        ip_summary[f"{ip_src} to {ip_dst}"] =
        ip_summary.get(f"{ip_src} to {ip_dst}", 0) + 1
    if packet.haslayer(TCP):
        port_summary[packet[TCP].sport] =
          port_summary.get(packet[TCP].sport, 0) + 1
    if packet.haslayer(IP):
        protocol_summary[packet[IP].proto] =
        protocol_summary.get(packet[IP].proto, 0) + 1

将总结的数据提供给 ChatGPT。将总结的数据发送到 OpenAI API 进行分析。使用 OpenAI 的 API 查找异常或可疑模式。

# Continue from previous code snippet
analysis_result = chat_with_gpt(f"Analyze the following summarized network traffic for anomalies or potential threats:\n{total_summary}")

审查分析和警报。检查 LLM 提供的分析。如果检测到任何异常或潜在威胁，请警告安全团队进行进一步调查。
```
# Continue from previous code snippet
print(f"Analysis Result:\n{analysis_result}")
```

这是完成的脚本应该是这样的：

from scapy.all import rdpcap, IP, TCP
import os
import openai
from openai import OpenAI
# Initialize the OpenAI API client
#openai.api_key = 'YOUR_OPENAI_API_KEY'  # Replace with your actual API key or set the OPENAI_API_KEY environment variable
openai.api_key = os.getenv("OPENAI_API_KEY")
# Function to interact with ChatGPT
def chat_with_gpt(prompt):
    messages = [
        {
            "role": "system",
            "content": "You are a cybersecurity SOC analyst
              with more than 25 years of experience."
        },
        {
            "role": "user",
            "content": prompt
        }
    ]
    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()
# Read PCAP file
packets = rdpcap('example.pcap')
# Summarize the traffic (simplified example)
ip_summary = {}
port_summary = {}
protocol_summary = {}
for packet in packets:
    if packet.haslayer(IP):
        ip_src = packet[IP].src
        ip_dst = packet[IP].dst
        ip_summary[f"{ip_src} to {ip_dst}"] =
          ip_summary.get(f"{ip_src} to {ip_dst}", 0) + 1
    if packet.haslayer(TCP):
        port_summary[packet[TCP].sport] =
          port_summary.get(packet[TCP].sport, 0) + 1
    if packet.haslayer(IP):
        protocol_summary[packet[IP].proto] =
          protocol_summary.get(packet[IP].proto, 0) + 1
# Create summary strings
ip_summary_str = "\n".join(f"{k}: {v} packets" for k,
  v in ip_summary.items())
port_summary_str = "\n".join(f"Port {k}: {v} packets"
  for k, v in port_summary.items())
protocol_summary_str = "\n".join(f"Protocol {k}:
  {v} packets" for k, v in protocol_summary.items())
# Combine summaries
total_summary = f"IP Summary:\n{ip_summary_str}\n\nPort Summary:\n{port_summary_str}\n\nProtocol Summary:\n{protocol_summary_str}"
# Analyze using ChatGPT
analysis_result = chat_with_gpt(f"Analyze the following summarized network traffic for anomalies or potential threats:\n{total_summary}")
# Print the analysis result
print(f"Analysis Result:\n{analysis_result}")

通过完成此方法，您已经迈出了利用 AI 进行网络流量分析和异常检测的重要一步。通过将 Python 的 SCAPY 库与 ChatGPT 的分析能力集成，您打造了一个不仅简化了潜在网络威胁识别，而且丰富了您的网络安全武器库的工具，使您的网络监视工作既高效又有深度。

工作原理…

此方法旨在将网络流量分析的复杂性分解为一组可管理的任务，这些任务利用 Python 编程和 OpenAI API。让我们深入了解每个方面：

使用 rdpcap 函数读取 PCAP 文件，它本质上是保存到文件中的网络数据包捕获。在读取此文件后，我们循环遍历每个数据包，收集有关 IP 地址、端口和协议的数据，并将其总结为字典。
初始化 OpenAI API 客户端。OpenAI API 提供对诸如 GPT-3 等强大的机器学习模型的编程访问。要开始使用该 API，您需要使用 API 密钥进行初始化，您可以从 OpenAI 的网站上获取。此密钥用于验证您的请求。
interact_with_openai_api，它以文本提示作为参数并将其发送到 OpenAI API。该函数构造了一个消息结构，其中包括系统角色，定义了 AI 的上下文（在我们的情况下，是网络安全 SOC 分析员），以及用户角色，提供了实际的查询或提示。然后调用 OpenAI 的 ChatCompletion.create 方法获取分析结果。
OpenAI 异常检测 API。一旦摘要数据准备好，就会将其作为提示发送到 OpenAI API 进行分析。API 的模型会扫描这个摘要并输出其分析，其中可能包括基于接收到的数据对异常或可疑活动的检测。
print 函数。此输出可能包括潜在的异常，并可能触发进一步的调查或在您的网络安全框架中发出警报。

通过理解每个组件，您将能够将此方法调整到特定的网络安全任务中，即使您对 Python 或 OpenAI 的产品相对新。

还有更多…

虽然本方法中概述的步骤为网络流量分析和异常检测提供了坚实的基础，但有各种方法可以建立和扩展这些知识。

扩展代码进行高级分析。此方法中的 Python 脚本提供了对网络流量和潜在异常的基本概述。您可以扩展此代码以执行更详细的分析，例如标记特定类型的网络行为或集成机器学习算法进行异常检测。
与监控工具集成。尽管这个示例专注于独立的 Python 脚本，但这种逻辑很容易集成到现有的网络监控工具或 SIEM 系统中，以提供实时分析和警报功能。

查看全文

http://www.kler.cn/a/415929.html