记录最好的自己

谷歌的Gemini API 为开发者提供了具体的免费额度，允许将Gemini模型集成到自己的应用程序中。
模型可访问范围：开发者可以免费调用 Gemini 2.5 Pro 模型及其轻量级版本 Gemini 2.5 Flash 。
标准免费额度：通过在 Google AI Studio 获取 API 密钥，每位开发者可以获得慷慨的免费使用额度。这包括每天 300,000 个 Token（包括提示和响应）以及每分钟 60 个请求的速率限制 。

一、免费申请Gemini API密钥

注册google账号就可以免费申请Gemini API密钥。
申请地址 https://aistudio.google.com/

有了Gemini API密钥后就可以调用API使用Gemini 大模型的能力了。
国内上网环境无法直接使用Gemini API，本文介绍能够免代理使用Gemini的方法。

二、使用openai-gemini

1、在github上找到openai-gemini

openai-gemini 是一个 serverless 的代理项目，用于将 Gemini API 转换为 OpenAI API 。
项目地址：https://github.com/PublicAffairs/openai-gemini
Gemini API 是免费的， 但有许多工具专门与 OpenAI API 一起使用。该项目可以将Gemini API 转换为 OpenAI API ，并且通过serverless进行调用。我们可以找个国内可以访问的免费serverless服务进行中转满足国内调用使用需求。
这里介绍将openai-gemini部署到Netlify
Netlify 是一个领先的 Web 开发平台，它专门为构建、部署和管理现代高性能网站和 Web 应用程序提供了一站式解决方案。Netlify 的核心理念是支持 Jamstack 架构（JavaScript, APIs, Markup），该架构强调将网站内容预构建为静态文件，并通过 CDN 快速分发，然后通过 API 调用动态数据和执行后端逻辑。

2、将openai-gemini部署到Netlify

找到”Deploy to Netlify” 点击就可以一键部署到Netlify,部署完成后Netlify会自动分配一个地址用于访问刚部署的openai-gemini的serverless服务。并且这个地址是在过国内可以正常访问的。

3、在Cherry Studio中配置和使用gemini的模型

1）在Cherry Studio中配置gemini API

通过Netlify中转访问gemini API，我们可以直接在Cherry Studio中配置通过Netlify中转访问gemini API
配置API地址为通过netlify中转的地址
API密钥为google gemini 的API Key
模型可以配置你想使用的模型 如：gemini-2.5-pro

2）在Cherry Studio中使用gemini 的模型

在Cherry Studio中选择刚配置的gemini-2.5-pro并和它对话，可以看到gemini-2.5-pro可以流畅的输出。

4、在Dify中配置和使用gemini的模型

1) 在Dify中配置gemini API

通过openai-gemini将 Gemini API 转换为了 OpenAI API ，所以在dify中应该使用“OpenAI-API-compatible”的插件来配置模型。

如果没有安装“OpenAI-API-compatible”插件需先安装。在模型供应商中选择“OpenAI-API-compatible”,点击“添加模型”。
配置API地址为通过netlify中转的地址
API密钥为google gemini 的API Key
模型可以配置你想使用的模型 如：gemini 2.5 pro

2）在Dify中使用gemini的模型

在Dify中建一个对话应用，选择刚配置好的 Gemini 2.5 Pro 模型进行对话，可以看到对话成功的调用了gemini API使用Gemini 2.5 Pro的模型进行了回复。

5、如果自己有域名可以用自己的域名来中转netlify的地址进行访问

1) 在自己的DNS中配置域名解析到netlify的地址

以我的cloud flare域名服务配置为例，在DNS中配置一个netlifygemini的子域名，解析到目标为开始netlify给的服务地址。

2）在netlify中配置子域名

在netlify中可以配置自己的域名对gemini API进行访问。在netlify的项目中找到“domain you already own”

在自定义域名配置界面，输入自己的子域名，它会给出Host和Value的值，这两个值需要在自己的DNS域名服务器中配置校验。

接下来需要在自己的DNS服务中进行配置，我以自己的cloud flare域名服务配置为例，配置如下：

3）在 Cloudflare 中添加TXT记录用于校验

1. 登录你的 Cloudflare 账户，选择我的域名doai8.dpdns.org。
2. 进入左侧的 “DNS” 菜单。
3. 点击 “Add record” (添加记录) 按钮。
4. 根据下面的表格，准确填写每一个字段：

4）在netify中进行验证，验证通过就可以用自己的域名访问了

在netify中进行验证，验证通过就可以用自己的域名访问了，在图中可以看到自己的子域名和netlify给的子域名。两个域名都可以用，自己的子域名的好处就是自己容易记忆。

5）用自定义域名进行gemini API接口的测试

在Cherry Studio中将API地址配置程自定义域名的地址

可以看到和gemini 2.5 pro 对话同样也很丝滑。

作者博客：http://xiejava.ishareread.com/

作为一名程序员，在AI蓬勃发展的时代，一定要拥抱AI。Dify 是一款开源的大语言模型(LLM) 应用开发平台。它融合了后端即服务（Backend as Service）和 LLMOps 的理念，使开发者可以快速搭建生产级的生成式 AI 应用。即使你是非技术人员，也能参与到 AI 应用的定义和数据运营过程中。

由于 Dify 内置了构建 LLM 应用所需的关键技术栈，包括对数百个模型的支持、直观的 Prompt 编排界面、高质量的 RAG 引擎、稳健的 Agent 框架、灵活的流程编排，并同时提供了一套易用的界面和 API。这为开发者节省了许多重复造轮子的时间，使其可以专注在创新和业务需求上。

NAS作为私有化的个人数据中心，基本保持不停机的状态并且功耗小，比较适合作为私有化的开发平台载体。本文介绍如何在家庭飞牛NAS上本地化部署dify打造属于自己的私有化LLMOps平台，可以随时随地的通过Dify来构建自己的AI应用。

一、准备工作

1、环境介绍

我的NAS设备为零刻ME mini全闪小主机，CPU intel N200,内存12G，装了fnOS作为NAS用。这个配置如果仅仅只是存存相片、文件等还是有点过剩了，所以为了充分发挥迷你主机的效用决定把它打造为私有的LLMOps平台。

2、打开飞牛OS的SSH登录

登录到飞牛OS，在“系统设置”中找到“SSH”，打开SSH功能

3、通过SSH客户端连上NAS主机

打开SSH后就可以通过SSH的客户端工具连到fnOS

二、在飞牛NAS上安装Dify

1、找到Dify的安装源

在github或gitee上找到dify的项目地址
https://github.com/langgenius/dify/
https://gitee.com/dify_ai/dify
在国内访问github比较慢，可以访问gitee上的difyi项目地址。
这里有安装Dify的硬件要求和安装步骤。

2、在飞牛NAS上创建存储目录

在飞牛NAS上创建一个用户clone和安装dify的目录

右键点击dify文件夹，点击“详细信息”。

在详细信息中找到“复制原始路径”，这里复制的原始路径就是该文件夹在fnOS操作系统的实际路径。

3、开始安装Dify

安装Dify需要docker环境，fnOS本身就已经安装好了docker环境，所以可以直接clone后进行安装
通过sudo -i 切换到 root 用户，进入到开始复制的原始路径。

通过git clone https://gitee.com/dify_ai/dify 命令clone项目

进入到dify下的docker目录，将.env.example 复制成.env文件

1
2

cd dify/docker
cp .env.example .env

.env文件中配置的是dify的一些环境变量，dify默认的web端口是80，为了避免80端口冲突，我们把dify的默认端口改成8080，修改.env的配置文件，将docker输出的Nginx端口改成8080，Nginx的SSL端口改成8443。

1
2

EXPOSE_NGINX_PORT=8080
EXPOSE_NGINX_SSL_PORT=8080

然后执行 docker compose up -d 就可以完成dify的安装

安装完成后通过NAS的内网IP就可以访问到dify的初始化界面
http://192.168.0.18:8080/install
通过简单的配置，配置用户名、口令就可以正式使用dify了。

三、设置外网访问

为了随时随地的访问和使用dify我们要对dify进行端口映射，使用nas的ddns来进行外网访问。

1、外网端口映射

在路由器上添加一条映射规则，将内网的8080端口映射到外网的某个端口上。

2、在飞牛nas上进行ddns配置

如有域名就可以配置阿里云或Cloudflare的ddns服务

这样就可以通过域名+端口直接访问NAS上的dify应用，随时随地构建和调试自己的AI应用了。

作者博客：http://xiejava.ishareread.com/

一、什么是RACI

RACI矩阵是一种用于明确项目或任务中角色与责任的管理工具，通过定义不同人员在任务中的参与程度来避免职责不清的问题。以下是其核心要点：

1. ‌RACI的含义‌

• ‌R（Responsible）执行者‌：直接完成任务的具体负责人。
• ‌A（Accountable）批准者‌：对任务结果负最终责任，通常为决策者。
• ‌C（Consulted）被咨询者‌：提供专业意见的专家或利益相关方。
• ‌I（Informed）被通知者‌：需知悉进展但不直接参与的人员。

2. ‌典型应用场景‌

• ‌跨部门协作项目‌：例如新产品发布，需明确市场、研发、生产等部门的职责。
• ‌复杂流程优化‌：如企业ERP系统实施，区分流程设计、数据迁移等任务的责任人。
• ‌危机管理‌：如安全事故处理时明确指挥、执行、沟通等角色。
• ‌日常运营‌：适用于周期性工作（如财务审计）的职责划分。

3. ‌使用案例‌

• ‌软件开发项目‌：

4. 构建要点‌

• 每个任务确保‌仅1个A角色‌，避免多头领导
• 避免R角色过多导致执行分散（如单个任务超过3个R）
• 关键干系人必须纳入C或I，防止遗漏重要意见

5. 常见误区‌

• 混淆A和R角色（如误将部门领导设为所有任务的A）
• 过度咨询（C角色过多导致决策延迟）
• 忽略变更管理（未随项目进展更新矩阵）

二、如何适用RACI矩阵

结合不同场景的关键步骤与操作要点：

1. 前期准备‌

   • 分解任务清单‌
     基于项目目标，将工作拆解为具体任务（如软件开发中的需求收集、测试、部署等）‌。
     示例：在IT系统迁移项目中，任务可拆分为“制定迁移方案”“数据备份验证”等‌。
   • 识别参与角色‌
     列出所有相关角色或部门（如项目经理、开发团队、法务部等），避免仅使用个人姓名，需标注岗位或职能‌。

2. 构建矩阵‌

   • 分配RACI角色‌
     ○ 每个任务需指定 ‌1个A角色‌（唯一责任人）和若干R/C/I角色‌。
     示例：在需求确认阶段，产品经理为A，开发团队为R，法务部为I‌。
     ○ 避免单任务分配过多R角色（建议≤3个），防止执行分散‌。
   • 关键逻辑验证‌
     ○ ‌横向检查‌：每项任务需至少包含R和A角色，确保无遗漏‌。
     ○ ‌纵向检查‌：单个角色名下任务量需合理，避免过度集中（如某成员承担过多R角色）‌。

3. 应用中的关键技巧‌

   • 与项目工具结合‌
     ○ 将RACI矩阵与甘特图、WBS（工作分解结构）联动，识别关键路径任务并优先分配资源‌。
     示例：在部署阶段，明确运维团队为R角色并与甘特图中的时间节点对齐‌。
   • 动态更新机制‌
     ○ 项目变更时同步调整矩阵（如新增任务或角色变更）‌。
     ○ 定期向I角色推送进展（如周报同步），向C角色发起咨询（如需求评审会）‌。

4. 常见问题与规避策略‌

5. 扩展应用场景‌

• ‌RASCI矩阵‌：在RACI基础上增加S（Support）角色，标注辅助支持团队（如IT部门协助数据迁移）‌15。
• ‌多层级矩阵‌：针对复杂项目分层设计（如战略级、执行级），分别分配责任‌7。

总结：核心操作流程
1.‌分解任务 → 2. 定义角色 → 3. 填充矩阵 → 4. 验证逻辑 → 5. 动态维护‌
示例：某市政工程通过RACI矩阵将环评报告责任唯一分配给环保机构（A角色），施工执行由承包商（R角色）承担，社区代表仅需知悉（I角色）‌。
通过结构化分配与持续优化，RACI矩阵可显著提升跨团队协作效率，减少责任争议‌。

三、应用案例

1. IT系统升级项目‌
   ‌背景‌：某企业需将本地服务器迁移至云端，涉及IT部、安全部、财务部及外部供应商。
   ‌任务分解与角色分配‌：

‌关键点‌：

• 安全部需深度参与方案设计和测试（C/A角色），避免安全漏洞；
• 供应商负责具体执行（R），但需接受IT经理的最终审批（A）。

2. 日常运维（IT支持团队）‌
   ‌背景‌：某公司IT部门处理日常故障，需明确一线支持、二线专家及管理层职责。

‌注意事项‌：

• 一线支持直接处理简单问题（R），二线专家解决技术难点（R）；
• 用户部门仅需知悉进展（I），避免干扰技术处理。

从以上看出，RACI矩阵适用于‌任何需要明确角色分工的场景‌，尤其适合跨职能、多利益相关方的复杂任务。

作者博客：http://xiejava.ishareread.com/

一、定义与核心概念

1. ‌互联网暴露面‌

• 定义：指组织在互联网上公开可访问的数字化资产和服务，如服务器、开放端口、API、网站、云服务等。

暴露面指网络系统中对外界开放的可见部分，包括公开的接口、网络端口、服务或应用程序等。例如Web服务、API、数据库端口等，这些资源可直接被外部访问或识别‌。暴露面的大小直接影响潜在攻击机会‌。

• 核心特点：

  • 可见性：能被外部扫描或探测到（如通过IP、域名、端口）。
  • 入口点：是外部与内部系统交互的桥梁（如登录页面、文件上传接口）。

• 示例：

  • 公网IP地址、开放的SSH端口（22）、公开的Web应用、未加密的HTTP服务。

2. ‌攻击面

• 定义：指所有可能被攻击者利用的潜在漏洞和风险点，涵盖技术、人员、流程等多个维度。‌

攻击面指攻击者可能利用的所有潜在入口点和攻击路径，不仅包含暴露面中的可见部分，还涵盖漏洞、错误配置、权限问题、社会工程等动态风险因素。攻击面越大，系统被入侵的概率越高‌。

• 核心特点：

  • 全面性：不仅包括暴露面，还包含内部漏洞（如配置错误、弱密码、员工安全意识不足）。
  • 动态性：随系统更新、新漏洞披露、业务扩展而变化。

• 示例：

  • 暴露面中的漏洞（如SQL注入）、内部数据库弱口令、员工易受钓鱼攻击、过时的内部软件版本。

二、区别与关联

关系：从定义上看，攻击面包含暴露面，并且更加广泛。

区别：

三、防护侧重点

1. ‌暴露面管理‌

• ‌原则‌：遵循最小权限，仅开放必要端口或服务‌。
• ‌措施‌：网络隔离、访问控制、定期审查暴露资源‌。

2. ‌攻击面管理‌

• ‌原则‌：降低漏洞利用可能性，覆盖技术、流程、人为因素‌。
• ‌措施‌：渗透测试、安全评估、漏洞修复、权限管控‌。

四、总结

‌暴露面是攻击面的子集‌，两者区别在于：暴露面聚焦“对外可见性”，攻击面覆盖“可利用性”；前者是静态防御的基础，后者需动态应对综合风险‌。缩小暴露面可降低被攻击概率，而减少攻击面则能全面降低风险。

作者博客：http://xiejava.ishareread.com/

攻击面是网络安全防御的“第一道防线”，其管理能力直接决定企业的安全基线。

攻击面管理（Attack Surface Management，ASM）是一种新兴的网络安全策略和实践，旨在通过持续发现、分析、监控和评估组织内外部的所有资产，识别并管理潜在的安全风险。其核心是从攻击者的视角出发，主动识别企业网络资产的攻击面及脆弱性，包括已知和未知的资产、漏洞、配置缺陷以及泄露信息等。

一、什么是攻击面

要了解攻击面管理（ASM）首先需要了解什么是攻击面。攻击面指的是所有可能被攻击者利用的入口点，比如硬件、软件、云服务等等。攻击面（Attack Surface） 是网络安全领域的核心概念，指一个系统、网络或组织中可能被攻击者利用的所有潜在入口点和漏洞的集合。简单来说，它是攻击者可能发起攻击的“可触及范围”，范围越大，暴露的风险越高，防御难度也越大。

攻击面的核心组成部分

攻击面通常由以下要素构成：

1. 技术资产
   ○ 硬件：服务器、路由器、IoT设备、摄像头等。
   ○ 软件：操作系统、应用程序、API、开源组件等。
   ○ 网络服务：开放的端口（如HTTP 80端口、SSH 22端口）、云服务（如AWS S3存储桶）、域名等。
2. 配置缺陷
   ○ 默认密码未修改、权限设置错误、未加密的通信协议（如HTTP）、冗余服务（如未关闭的测试环境）等。
3. 数据暴露
   ○ 敏感数据泄露（如数据库备份文件被公开）、代码仓库中的密钥硬编码、日志文件中的用户信息等。
4. 人为因素
   ○ 员工的安全意识薄弱（如点击钓鱼链接）、第三方供应商的访问权限、社会工程攻击的潜在目标。
5. 供应链风险
   ○ 依赖的第三方软件漏洞（如Log4j）、开源库的未更新版本、外包开发引入的后门等。

攻击面扩大的原因

1. 数字化转型：云服务、微服务架构、远程办公导致资产分散化。
2. 影子IT：员工私自部署未授权的应用或设备（如个人NAS）。
3. 复杂供应链：第三方服务、开源组件的依赖增加。
4. 自动化攻击工具：攻击者可快速扫描全网暴露资产（如Shodan搜索引擎）

二、攻击面的分类

根据视角和范围，攻击面可分为以下两类：

1. 外部攻击面（External Attack Surface）
   ○ 定义：暴露在互联网上，能被外部攻击者直接访问的资产和漏洞。
   ○ 典型示例：
   ■ 面向公网的Web应用、API接口。
   ■ 云存储桶的错误配置（如公开可读）。
   ■ 员工在GitHub意外上传的数据库凭证。
   ○ 管理工具：EASM（外部攻击面管理）。
2. 内部攻击面（Internal Attack Surface）
   ○ 定义：仅限内部网络访问，但可能被已渗透的攻击者横向利用的弱点。
   ○ 典型示例：
   ■ 内网未修复的漏洞（如永恒之蓝漏洞）。
   ■ 域控制器权限滥用、共享文件夹过度开放。
   ■ 内部员工滥用权限窃取数据。
   ○ 管理工具：CAASM（网络资产攻击面管理）、内部漏洞扫描器。

三、网络资产攻击面管理(CAASM)

网络资产攻击面管理(CAASM)全称（Cyber Asset Attack Surface Management, CAASM）是一种网络安全技术或方法论，旨在帮助组织全面发现、识别、监控和管理其数字化资产（包括硬件、软件、云服务、API、物联网设备等）的潜在攻击面，从而降低安全风险并提升防御能力。CAASM通过整合现有安全工具（如漏洞扫描器、EDR、CMDB等）的数据，构建统一的资产视图，覆盖内部网络、云环境、第三方服务等所有资产。其核心目标是解决资产分散、数据孤岛和未知资产的问题，帮助安全团队识别安全控制中的漏洞与差距，并协调修复。

CAASM 的核心功能

1. 自动化资产发现
   ○ 通过主动扫描、被动流量分析、API集成等方式，自动发现企业内外的所有资产，包括未授权的“影子IT”（如员工私建的云实例、未知设备）。
   ○ 覆盖范围包括本地基础设施、云环境（AWS、Azure等）、第三方服务、物联网设备等。
2. 资产分类与优先级排序
   ○ 根据资产类型（服务器、数据库、API）、业务重要性、暴露程度（如是否面向公网）等，对资产进行分类和风险评估。
   ○ 帮助安全团队优先处理高风险资产（如暴露在互联网的敏感数据库）。
3. 攻击面可视化与实时监控
   ○ 通过仪表盘展示所有资产的拓扑关系和暴露路径，直观呈现攻击面。
   ○ 实时监控资产状态变化（如新开放的端口、新增的云服务），及时发现异常。
4. 与现有工具集成
   ○ 整合漏洞扫描工具（如Nessus）、EDR（端点检测与响应）、防火墙日志等，形成统一的资产视图。
   ○ 利用API打通数据孤岛，避免不同工具间的信息割裂。
5. 风险评估与缓解建议
   ○ 结合漏洞数据、威胁情报和资产上下文，生成风险评分。
   ○ 提供修复建议（如关闭不必要的端口、更新补丁）或临时缓解措施（如配置防火墙规则）。

网络资产攻击面管理(CAASM)与传统资产管理的区别

传统资产管理工具（如CMDB）通常依赖手动录入或静态数据，且缺乏对攻击面的动态分析。而CAASM的特点包括：
● 主动发现：自动识别资产，减少人为遗漏。
● 攻击面视角：不仅记录资产，还分析其暴露程度和潜在风险。
● 实时性：持续监控变化，适应动态环境（如云资源的弹性扩展）。
● 威胁关联：结合漏洞、配置错误和威胁情报进行综合分析。

四、外部攻击面管理（EASM）

外部攻击面管理（External Attack Surface Management, EASM） 是一种以攻击者视角为核心的安全管理方法，旨在持续发现、监控和评估组织暴露在互联网上的所有数字资产及其潜在风险。这些资产包括服务器、域名、云服务、API、物联网设备等，同时也涵盖影子资产（如未授权的云实例）、错误配置、开放端口、未修复漏洞以及敏感数据泄露等问题。EASM的关键在于通过外部视角模拟攻击者的行为，识别可能被利用的薄弱点，从而提前修复风险。

外部攻击面管理（EASM）的核心功能

外部攻击面管理（EASM）的核心功能主要包括以下几个方面：

1. 泛资产发现与监控
   通过分布式探测引擎，持续扫描和监控外部环境，识别和编目从互联网可访问的数字资产，包括域名、IP地址、网页应用程序、API、云服务、影子资产、仿冒资产等。这些功能为企业提供了全面的资产暴露面视图。
2. 攻击触点识别与评估
   在攻防视角下，依托指纹库和情报库，对发现的资产进行弱点检测，包括漏洞扫描、弱口令检测、敏感数据识别等。同时，结合供应链情报和攻防情报，评估资产被利用的风险。
3. 数据泄露监测
   覆盖全网（包括暗网、深网、代码托管平台、网盘、文库等）范围，监测敏感数据泄露情况，及时发现并处理潜在的数据泄露风险。
4. 攻击面分析
   基于弱点检测结果，综合分析资产的风险，识别可能的攻击路径和风险等级。评估一旦发生安全事件，业务可能受影响的范围，并提供风险收敛的优先级建议。
5. 风险评估与预警
   评估外部攻击面相关的风险，并根据威胁的潜在影响和可能性进行优先级排序。提供7×24小时的风险预警服务，包括暴露面变动提醒、数据泄露监测、网站篡改和黑链预警等。
6. 持续监控与适应
   定期对外部攻击面进行实时扫描和监控，结合威胁情报源和漏洞管理，检测新的或变化的资产、漏洞和威胁，并根据这些变化调整安全策略。

五、网络资产攻击面管理（CAASM）与外部攻击面管理（EASM）的联系与区别

EASM与CAASM的联系

1. 共同目标：两者均属于攻击面管理（ASM）的核心组成部分，旨在缩小攻击面、降低安全风险。
2. 互补性：EASM提供外部视角的资产发现和风险分析，而CAASM整合内外资产数据，形成全局视图。例如，EASM发现的外部暴露资产可输入到CAASM系统中进行关联分析。
3. 数据整合：CAASM依赖EASM和DRPS（数字风险保护服务）的数据源，实现更全面的资产清单管理。

EASM与CAASM的区别

典型应用场景对比

1. EASM：
   ○ 云安全治理：发现公有云上的错误配置或未授权实例。
   ○ 供应链风险：评估第三方服务商的暴露面，如合作伙伴的漏洞代码。
   ○ 敏感数据泄露：监控暗网或公共平台（如GitHub）上的数据泄露。
2. CAASM：
   ○ 影子资产管理：通过整合EDR、防火墙日志等，发现未登记的内部设备。
   ○ 漏洞优先级排序：结合资产业务价值与漏洞严重性，优化修复策略。
   ○ 合规性报告：生成统一的资产与安全控制报告，满足ISO 27001等合规要求。

● EASM更强调从外部攻击者的角度发现风险，适用于防御边界模糊的互联网暴露场景。
● CAASM则聚焦于内部资产的全面可见性，解决复杂IT环境下的数据孤岛问题。
● 协同作用：在实际应用中，两者需结合使用。例如，EASM发现的外部风险需通过CAASM与内部资产关联分析，形成闭环管理。

未来，随着攻击面管理技术的成熟，EASM与CAASM可能会进一步融合到统一平台中，实现更高效的风险收敛。

六、攻击面管理的优势与应用场景

随着技术的发展，攻击面正从传统IT向云、物联网、供应链等方向快速扩展，企业需借助自动化工具（如EASM、CAASM）和系统化策略，实现攻击面的持续收敛与风险控制。

攻击面管理的优势

● 主动防御：从传统的被动防御模式转变为积极主动地发现和管理潜在风险。
● 全面覆盖：不仅关注已知资产，还能发现未知的影子资产和泄露信息。
● 动态适应：能够适应云计算、物联网等复杂环境，并与现有安全工具（如SOC、SIEM）集成。
● 风险量化：提供更精细的风险评估和量化功能，帮助企业制定有效的安全策略。

应用场景

攻击面管理适用于多种场景，包括但不限于：
● 企业数字化转型：应对云计算、物联网等新技术带来的复杂攻击面。
● 供应链安全：评估和管理供应商基础设施中的安全风险。
● 安全运营：与安全运营中心（SOC）结合，提升整体安全管理水平。

随着技术的不断发展，攻击面管理正朝着自动化、智能化、云原生化的方向发展，并与企业的业务风险管理流程紧密结合。

博客文章：http://xiejava.ishareread.com/

一、网络安全挂图作战来源与定义

1、网络安全挂图作战的来源

网络安全挂图作战的概念源于传统军事作战中的“挂图作战”，即通过地图来指挥和协调作战行动。在网络空间安全领域，这一概念被引入并发展为一种新的网络安全管理和防御策略。其灵感来自于地理学中的“人地”关系理论，通过将网络空间的要素与地理空间相结合，构建网络空间地图。

在2020年7月，网络安全专家郭启全等在《中国科学院院刊》上发表了《发展网络空间可视化技术支撑网络安全综合防控体系建设》研究文章，论述了网络空间“挂图作战”的基本理念和发展愿景。

同年公安部印发《贯彻落实网络安全等保制度和关保制度的指导意见》（公网安[2020]1960号），明确提出“要加强网络新技术研究和应用，研究绘制网络空间地理信息图谱(网络地图)，实现挂图作战”。

2、网络安全挂图作战的定义

挂图作战： 按计划、按目标、按进度、按要求实施的一种作战方式或工作方法。
网络安全挂图作战的核心思想：将攻击者的攻击路径和影响范围以图形化方式展现，帮助防守方更直观、全面地理解攻击者的行为以及对组织资产的影响，从而更有效地进行威胁检测、分析、响应等动作。

网络安全挂图作战是一种通过可视化技术将网络安全态势、资产、威胁等信息以图形化方式展示出来的方法。其核心在于通过构建网络空间地图，实现对网络安全事件的全过程展示和管理，通过“看、管、防、控”一体化实现主动防御的工作模式。

其核心价值在于：
● 攻防视角可视化：将攻击者的路径、手段及影响范围图形化呈现，辅助防守方快速定位薄弱点。
● 全生命周期管理：覆盖威胁检测、分析、响应、复盘的全流程闭环。
● 协同作战能力：整合多部门、多工具数据，打破信息孤岛，提升响应效率。

具体来说，挂图作战包括以下几个方面：

1. 可视化展示：将网络环境中的各个要素（如资产、漏洞、威胁等）以图形化的方式呈现，提高网络安全的可视化程度。
2. 态势感知与分析：通过挂图作战平台，实时监测和感知网络安全态势，及时发现和分析安全威胁。
3. 决策支持：为安全决策提供直观的数据支持，帮助安全团队更好地研判和处置安全事件。
4. 协同作战：支持多方协同作战，整合不同安全工具和平台的信息，提高安全事件的响应速度和处理效率。

通过这些功能，网络安全挂图作战能够有效地提升网络安全防护的效率和准确性，帮助组织更好地应对复杂的网络安全挑战。

二、挂图作战关键技术

1. 网络空间测绘技术
   ● 资产指纹库：通过主动扫描（如端口探测、协议解析）和被动流量分析（如流量镜像），识别网络中的设备、服务、应用及版本信息。
   ● 拓扑自动发现：利用路由追踪、SNMP协议等，绘制网络节点间的连接关系和通信路径。
2. 动态可视化引擎
   ● 图数据库（Neo4j、GraphX）：存储复杂的资产关系与攻击链路，支持快速查询和路径分析。
   ● 威胁热力图：根据攻击频率、漏洞严重性等参数生成风险热区，直观标注高危区域。
3. 攻击链建模（Cyber Kill Chain）
   ● MITRE ATT&CK框架集成：将攻击者的TTPs（战术、技术、过程）映射到网络地图中，预判攻击路径。
   ● 攻击模拟推演：基于红队工具（如Cobalt Strike）模拟攻击行为，验证防御策略有效性。
4. 自动化响应编排（SOAR）
   ● 剧本（Playbook）驱动：当检测到攻击时，自动触发防火墙封禁、隔离主机、下发补丁等动作。
   ● 人机协同：高风险操作需人工确认，避免误拦截影响业务。
5. 多源数据融合
   ● 跨平台集成：对接EDR、SIEM、漏洞扫描器等工具，聚合日志、告警和资产数据。
   ● 威胁情报联动：接入外部威胁情报（如恶意IP库、漏洞库），实时更新攻击特征。

三、挂图作战与传统态势感知的差异

四、挂图作战主要场景

1. 关键基础设施防护
   ● 场景痛点：能源、交通等行业的OT系统（工控网络）存在大量老旧设备，难以实时监控。
   ● 挂图方案：
   ○ 绘制OT网络拓扑，标注PLC、SCADA系统的物理位置与逻辑连接。
   ○ 当检测到异常指令（如未授权的参数修改）时，地图自动定位受影响设备并隔离。
2. 重大活动安保
   ● 场景痛点：活动期间网络访问激增，需防范DDoS、网页篡改等针对性攻击。
   ● 挂图方案：
   ○ 构建“活动专属作战地图”，集成CDN节点、票务系统、直播平台等核心资产。
   ○ 实时标注攻击源IP（如来自特定国家的扫描行为），联动云WAF自动封禁。
3. 供应链攻击防御
   ● 场景痛点：第三方软件或服务漏洞可能成为攻击跳板（如SolarWinds事件）。
   ● 挂图方案：
   ○ 标注供应链厂商的接入点及权限范围，监控异常横向移动。
   ○ 当某供应商账号异常登录时，地图高亮关联资产并触发权限回收。
4. 红蓝对抗演练
   ● 场景痛点：传统攻防演练中防守方难以快速定位攻击入口。
   ● 挂图方案：
   ○ 红队攻击路径实时映射到地图，蓝队可追溯攻击者从外网渗透到内网提权的全过程。
   ○ 演练结束后生成攻击路径复盘报告，优化防御策略。
5. 零日漏洞应急响应
   ● 场景痛点：漏洞爆发后（如Log4j），企业需快速定位受影响资产。
   ● 挂图方案：
   ○ 输入漏洞特征（如JNDI调用），地图自动标记存在漏洞的服务实例。
   ○ 联动补丁管理系统，按业务优先级分批修复。

五、未来趋势

1. 数字孪生融合：结合数字孪生技术，实现网络空间与物理世界的1:1映射。
2. AI辅助决策：通过大语言模型（LLM）生成自然语言防御建议，降低操作门槛。
3. 跨域协同：与国土安全、城市应急系统联动，构建国家级网络空间地图。

结语

“挂图作战”标志着网络安全从“被动告警”迈向“主动防御”的范式转变。通过将虚拟攻击映射为可视化的“战场”，企业不仅能看清自身防御盲区，更能在攻防对抗中抢占先机。随着技术的演进，未来的网络安全指挥中心或许将如军事作战室一般，通过一张动态地图掌控全局。

博客文章：http://xiejava.ishareread.com/

目前，国际主流的网络安全架构模型主要有：
● 信息技术咨询公司Gartner的ASA（Adaptive Security Architecture自适应安全架构）
● 美国政府资助的非营利研究机构MITRE的ATT&CK（Adversarial Tactics Techniques & Common Knowledge 对抗战术技术和常识）
● 信息技术咨询公司Gartner的CSMA（Cybersecurity Mesh Architecture网络安全网格架构）

1. Gartner提出的ASA（Adaptive Security Architecture自适应安全架构）

2014年，针对于当时业界安全产品主要重在防御和边界，安全态势形成严重挑战的问题，Gartner公司首次提出ASA（Adaptive Security Architecture自适应安全架构），希望业界能从单纯被动防御和应急响应的思路中解放出来，通过加强持续监测和分析预测提升主动防御能力，1.0架构主要包括以下四个象限：

1) 预防Pretect，通过系统加固和隔离等手段来减少系统暴漏面积，比如采用黑名单；
2) 检测Detect，持续监视/检测事故的发生并对其进行评估，对检出的事故进行隔离，以防止其造成进一步的破坏；
3) 响应Response，事故发生之后需要对事故进行补救和溯源；
4) 预测Predict，根据以往已经存在的威胁，来预测潜在的威胁。

2017年，针对于高级攻击的防御架构，Gartner公司在1.0架构的基础上进行了相关的理论丰富，将自适应安全架构的外延扩大，自适应安全架构进入2.0时期：

1) “持续监控分析”改成“持续可视化和评估”，同时加入UEBA相关的内容（User& Entity behavior analytics用户和实体的行为分析）;
2) 引入每个象限的小循环体系，不仅仅是四个象限大循环；
3) 在大循环中加入了策略和合规要求，同时对大循环的每个步骤说明了循环的目的，到保护象限是实施动作、到检测象限是监测动作、到响应和预测象限都是调整动作。

2018年，Gartner公司正式确认了CARTA（Continuous Adaptive Risk and Trust Assessment持续自适应风险与信任评估）的安全趋势，即自适应安全架构3.0。相比2.0架构，3.0架构最大的变化是把2.0架构作为攻击的保护外环,增加关于访问的保护内环，原因在于：

1) 2.0架构未考虑认证问题，导致完整性有缺失，如黑客获取有效认证内容，如用户名密码，自适应架构对于此类事件是“可信”的，威胁无法感知；
2) 为加强云时代下的云服务的发现、访问、监控和管理，3.0架构将CASB（Cloud Access Security Broker云访问安全代理）作为原型挪到了这个总体架构中，解决了部分认证问题；
3) 如果认证体系只是一次性认证并没有持续的监控和审计，必须要有被窃取认证信息的心理预期，所以要持续的进行监控和分析以及响应，形成闭环。

3.0架构的适用场景变得更为广泛，包括了安全响应、数据保护、安全运营中心、开发安全运维、物联网、供应链安全、业务持续和灾难恢复等领域。

2. MITRE提出ATT&CK（Adversarial Tactics Techniques & Common Knowledge 对抗战术技术和常识）

ATT&CK（Adversarial Tactics Techniques & Common Knowledge 对抗战术技术和常识）是一个知识库，它从攻击者的角度看待问题，理顺了攻击者渗透网络、入侵主机、提升权限、隐秘移动和渗漏数据的攻击链，建立了网络攻击中使用的战术和技术的详尽列表，呈现了攻击者在攻击网络时所采用的行为，并且详细介绍了每一种技术的利用方式。

该模型被CISA（美国网络安全与基础设施安全局）和FBI以及超过80%的企业用于威胁调查，它对于政府或企业组织来说都非常有用，因为组织需要建立一个基于威胁的防御体系。

ATT&CK模型可以帮助网络事件响应团队(CERT)、安全运营中心(SOC)、红蓝队、威胁猎手、IT部门等安全团队，更好地测试、开发和排序其检测和响应机制，对公司的业务、行业和知识产权提供高效安全保障，具体可分为：

1) Detections and Analytics（检测和分析）：帮助网络防御者开发分析程序，以检测对手使用的技术。
2) Threat Intelligence（威胁情报）：为分析人员提供了一种通用语言来构造，比较和分析威胁情报。
3) Adversary Emulation and Red Teaming（攻击模拟）：提供了一种通用语言和框架，攻击模拟团队可以使用该语言和框架来模拟特定威胁并计划其行动。
4) Assessment and Engineering（评估与工程化）：可用于评估组织的能力并推动工程决策。

但是，安全公司McAfee与加州大学伯克利分校长期网络安全中心的联合调研项目发现，很多网络安全团队在框架应用方面仍然面临诸多挑战：

1) 大多数采用ATT&CK框架的安全团队都没有实现自动化。虽然91%的企业使用ATT&CK框架来标记网络安全事件，但只有不到一半的企业可以自动更改部分安全策略；
2) ATT&CK框架和安全产品之间的互操作性存在困难；
3) 难以将网络安全事件映射到安全策略更改，以及无法关联来自云、网络和端点的事件；
4) 企业使用的安全产品可能无法检测到ATT&CK矩阵中存在的所有技术。

2021年，MITRE发布了ATT&CK的第十个版本，该版本最大的变化是在企业矩阵（Enterprise ATT&CK）中添加了一组新的数据源和数据组件对象，以补充ATT&CK v9中发布的数据源名称更改。新版ATT&CK企业矩阵包含14个战术、188个技术、379个子技术、129个组和638个软件。

3. Gartner提出的CSMA（Cybersecurity Mesh Architecture网络安全网格架构）

随着更多的应用和数据迁移到云服务，传统网络边界已经消失，网络安全威胁形势日益复杂。同时，网络攻击手段也在快速演进，AI和大规模自动化技术驱动的新型威胁层出不穷，带来了快速增长的网络攻击数量。在这种形势下，传统安全手段已经无以为继，组织普遍存在网络安全技能短缺的困境。因此，Gartner在2021年一种全新的安全架构模式CSMA（Cybersecurity Mesh Architecture网络安全网格架构）。

CSMA架构是一种现代安全方法，包括在最需要的地方部署控制措施、构建身份化的零信任网络并以身份作为安全边界，通过提供基础安全服务以及集中式策略管理和编排功能，使诸多工具能够协同操作，而不是每个安全工具都在孤岛环境中使用。
通过CSMA架构，可以获得所有边缘的深度可见性、集中管理分布式解决方案、策略的一致执行、利用威胁情报、通过集成第三方能力以更好地防卫已知和未知攻击、跨混合环境自动执行可操作响应等优势。

CSMA架构希望通过搭建一个全面覆盖、深度集成、动态协同的“网络安全网格平台”，将不同厂商的安全工具整合为一个协同生态系统，让组织能够灵活地进行方案部署，同时从集成和融合的运营、可视化和安全性中受益，对于在当前不断扩展的网络中，降低复杂度和提高整体安全有效性至关重要。

博客文章：http://xiejava.ishareread.com/

在《django应用JWT(JSON Web Token)实战》介绍了如何通过django实现JWT，并以一个具体API接口实例的调用来说明JWT如何使用。本文介绍如何通过vue3的前端应用来使用JWT认证调用后端的API接口，实现一下的登录认证获取JWT进行接口认证。

一、账号密码登录获取JWT

通过Login.vue实现登录的用户名、密码表单信息收集，调用getToken()方法进行鉴权验证并获取jwt的token。
Login.vue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

<template>
    <div class="body">
        <el-form :model="form" :rules="rules" ref="loginForm" class="loginContainer">
            <h3 class="loginTitle">
            欢迎登录
            </h3>
            <el-form-item label="用户名" prop="username" :label-width="formLabelWidth"> 
                <el-input type="text" v-model="form.username" placeholder="请输入用户名"></el-input>
            </el-form-item>
            <el-form-item label="密码"  prop="password" :label-width="formLabelWidth"> 
                <el-input type="password" v-model="form.password" placeholder="请输入密码"></el-input>
            </el-form-item>
            <el-form-item :label-width="formLabelWidth"> 
                <el-button type="primary" :plain="true" @click="submitForm('form')">登录</el-button>
            </el-form-item>
        </el-form>
    </div>
</template>

<script>
import { useUserStore } from '@/stores/user'
import { ElMessage } from 'element-plus';
import {getToken} from '../api/user'
export default {
  data() {
    return {
      form: {
        username: '',
        password: '',
        err_username: "",
        err_password: "",
      },
      rules: {
        username: [
          { required: true, message: '请输入用户名', trigger: 'blur' }
        ],
        password: [
          { required: true, min:6, message: '请输入密码', trigger: 'blur' }
        ]
      },     
      formLabelWidth: '120px'
    };
  },
  methods: {
    submitForm(formName) {
        if (this.$refs.loginForm) {
            this.$refs.loginForm.validate(valid => {
            if (valid) {
                // 提交表单逻辑
                console.log('提交成功:', this.form);
                this.login();
            } else {
                console.log('验证失败');
                ElMessage.error('验证失败，请检查您的输入！');
            }
            });
      } else {
        console.error('表单未找到');
      }
    },
    login() {
      var that = this;
      this.message = "";
      // 用户名密码鉴权获取jwt的token
      getToken({
        'username': this.form.username,
        'password': this.form.password,
      }).then((Response) => {
          console.log(Response);
          if (Response && Response.access) {
            // //保存数据到本地存储
            this.username= that.form.username;
            useUserStore().login(this.username,Response.access,Response.refresh)
            this.username = "";
            this.password = "";
            this.$router.push({name:"home"}); //跳转到首页
          }
        })
        .catch(function (error) {
          console.log(error);
          if ("username" in error) {
            that.err_username = error.username[0];
          } else if ("password" in error) {
            that.err_password = error.password[0];
          } else {
            ElMessage.error('登录失败！');
          }
        });
    },

  }
};
</script>

<style scoped>
  .loginContainer{
        border-radius: 15px;
        background-clip: padding-box;
        text-align: left;
        margin: auto;
        margin-top: 180px;
        width: 450px;
        padding: 15px 35px 15px 35px;
        background: aliceblue;
        border:1px solid blueviolet;
        box-shadow: 0 0 25px #f885ff;
    }
    .loginTitle{
        margin: 0px auto 48px auto;
        text-align: center;
        font-size: 40px;
    }
    .loginRemember{
        text-align: left;
        margin: 0px 0px 15px 0px;
    }
    .loginbody{
        width: 100vw;
        height: 100vh;
        background-size:100%;
        overflow: hidden;
    }
</style>

在登录时调用getToken()方法获取jwt的token
getToken的封装方法如下：

1
2
3
4
5
6
7
8
9

import request from '@/utils/request'

export function getToken(data) {
    return request({
      url: 'token/',
      method: 'post',
      data
    })
  }

通过用户名和密码鉴权可以获得JWT的token，接口会返回access的token和refresh的token，需要将这两个token保存下来，access的token用来进行API接口的jwt认证，refresh的token用来刷新失效的access的token。

二、将JWT保存至本地

通过pinia将token保存至浏览器的本地存储，以便于后面请求API时带上访问的token

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

import { defineStore } from 'pinia'
import { refreshToken } from '../api/user'

export const useUserStore = defineStore('user', {
    persist: {
        enabled: true, //开启数据持久化
        strategies: [
            {
                key: "userState", //给一个要保存的名称
                storage: localStorage, //sessionStorage / localStorage 存储方式
            },
        ],
    },
    state: () => ({
        isLoggedIn: false,
        username: '',
        jwtAccessToken: null,
        jwtRefreshToken: null,
    }),
    actions: {
        login(username, accessToken,refreshToken) {
            this.username = username
            this.isLoggedIn = true
            this.setToken(accessToken, refreshToken)
        },
        logout() {
            this.username = ''
            this.jwtAccessToken = null
            this.isLoggedIn = false
        },
        setToken(accessToken, refreshToken) {
            this.jwtAccessToken = accessToken
            this.jwtRefreshToken = refreshToken
        },
        refreshToken() {
            return new Promise((resolve, reject) => {
                refreshToken({"refresh":this.jwtRefreshToken}).then((response) => {
                    this.setToken(response.access, this.jwtRefreshToken)
                    resolve(response.access)
                    console.log('return refreshToken-----------'+response.access)
                }).catch((error) => {
                    reject(error)
                })
            })
        }

    },
    getters: {
        getIsLoggedIn: (state) => state.isLoggedIn,
        getUsername: (state) => state.username,
        getUserAccessToken: (state) => state.jwtAccessToken,
        getRefreshToken: (state) => state.jwtRefreshToken,
    }
})

在登录的Login.vue组件中调用useUserStore().login(this.username,Response.access,Response.refresh)将用户名、access的token、refresh的token保存至浏览器的本地存储。

三、请求API带上JWT

将axios的调用封装成request.js在调用API接口时带上JWT

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

import axios from 'axios'
import Router from '@/components/tools/Router'
import { useUserStore } from '@/stores/user'
import { ElMessage } from 'element-plus'
import { refreshToken } from '../api/user'

const api_rul = import.meta.env.VITE_APP_API_URL

// create an axios instance
const service = axios.create({
    baseURL: api_rul,
    timeout: 5000, // request timeout
})

// request interceptor
service.interceptors.request.use(
    config => {
        // do something before request is sent
        const { url } = config
        // 指定页面访问需要JWT认证。
        if (url.indexOf('/login')!== -1) {
            return config
        }
        let jwt = useUserStore().getUserAccessToken
        config.headers.Authorization = `Bearer ${jwt}`
        return config
    },
    error => {
        // do something with request error
        console.log(error) // for debug
        return Promise.reject(error)
    }
)

export default service

主要是在请求头重带着jwt的信息

1
2

let jwt = useUserStore().getUserAccessToken
config.headers.Authorization = `Bearer ${jwt}`

四、在token失效时自动重新获取token

前面提到JWT基于安全考虑有两个token，一个是access token ,一个是refresh token 。access token的失效时间较短，可以有效降低泄露而造成的影响，两个token的区别和作用如下：

使用refresh token的逻辑如下：

以下通过拦截器实现token失效后重新获取access token

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

import axios from 'axios'
import Router from '@/components/tools/Router'
import { useUserStore } from '@/stores/user'
import { ElMessage } from 'element-plus'
import { refreshToken } from '../api/user'

const api_rul = import.meta.env.VITE_APP_API_URL

// create an axios instance
const service = axios.create({
    baseURL: api_rul,
    timeout: 5000, // request timeout
})

// request interceptor
service.interceptors.request.use(
    config => {
        // do something before request is sent
        const { url } = config
        // 指定页面访问需要JWT认证。
        if (url.indexOf('/login')!== -1) {
            return config
        }
        let jwt = useUserStore().getUserAccessToken
        config.headers.Authorization = `Bearer ${jwt}`
        return config
    },
    error => {
        // do something with request error
        console.log(error) // for debug
        return Promise.reject(error)
    }
)

// response interceptor
service.interceptors.response.use(
 
    response => {
        const res = response.data
        return res
    },
    async error => {
        console.log('err' + error) // for debug
        const originalRequest = error.config;
        // 授权验证失败
        if (error.response.status === 401 && originalRequest._retry!== true) {
            originalRequest._retry = true;
            // 刷新token
            let jwtRefreshToken=useUserStore().getRefreshToken
            await refreshToken({"refresh":jwtRefreshToken}).then((response) => {
                // 刷新token成功，重新请求
                let jwtToken=response.access
                useUserStore().setToken(jwtToken, jwtRefreshToken)
                console.log('return refreshToken-----------'+response.access)
                originalRequest.headers.Authorization = `Bearer ${jwtToken}`
                return service(originalRequest)                
            }).catch((error) => {
                // 刷新token失败，跳转到登录页面
                ElMessage.error('请重新登录！')
                Router.push({name:'login'})
            })

        }
        // 内部错误
        if (error.response.status === 500) {
            let errormsg=error.response.data.msg
            ElMessage.error('服务器内部错误！'+errormsg)
        }
        if (error.response.status === 400)
        {
            ElMessage.error('错误的请求！')
        }
        return Promise.reject(error)
    }
)

export default service

在判断error.response.status === 401时调用refreshToken重新获取jwttoken进行接口的调用。

博客地址：http://xiejava.ishareread.com/

在前后端分离的项目中，前后端进行身份验证通常用JWT来进行，JWT 提供了一个理想的认证解决方案，用来保护 RESTful API，确保只有经过认证的用户才能访问受保护的资源。基于前端框架（如React, Angular, Vue.js）的单页面应用 (SPA)，开发者通过使用 JWT可以获得一种简单、安全、高效的方式来处理用户认证和授权的问题。本文通过django项目的实战来说明如何应用和使用JWT。

一、什么是JWT

JWT（JSON Web Token）是一种开放标准（RFC 7519），用于在网络各方之间以安全且紧凑的形式传输信息。JWT 是一个小型的凭证，通常用于身份验证和授权场景。JWT 由三部分组成：头部 (Header)、负载 (Payload) 和签名 (Signature)。
JWT信息由3段构成，它们之间用圆点“.”连接，格式如下：

1

aaaaaa.bbbbbb.cccccc

一个典型的JWT如下所示：

1

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNzI2OTcyMDc2LCJpYXQiOjE3MjY5NzAyNzYsImp0aSI6IjMyMTFiZjdmZDlhZTRmNTBhMDNmOGM2NjcwNDM2NjFiIiwidXNlcl9pZCI6Mn0.Ej6US4Uk-sSNm9P8kTU_cDAzBpO4I-BLhPstp5sG00Q

• 头部 (Header)：包含了关于 JWT 类型的信息以及所使用的签名算法。
• 负载 (Payload)：是 JWT 的主体部分，包含了实际需要声明的数据。这些数据通常包括用户ID、用户名、角色等信息。
• 签名 (Signature)：用于验证 JWT 的发送者就是它声称的发送者，同时也确保了 JWT 在传输过程中没有被篡改。

二、为什么使用JWT

使用 JWT 的原因主要有以下几点：

• 安全性：JWT 通过签名来保证数据的完整性和防篡改性。如果有人试图修改 JWT 内容，签名会失效，接收方可以检测到这一行为。
• 无状态性：JWT 是自包含的，这意味着不需要在服务器上保存会话状态。每个 JWT 都包含了所有必要的信息，从而减少了对服务器端存储的需求。
• 跨域支持：JWT 可以轻松地在不同的域之间共享，这使得它非常适合微服务架构和分布式系统。
• 性能提升：由于 JWT 是自包含的，所以服务器可以快速地验证 JWT，而无需查询数据库来获取用户信息，这提高了应用的响应速度。
• 易于缓存和扩展：JWT 可以被缓存，并且因为它们是无状态的，所以可以很容易地扩展到多个服务器，而无需担心会话复制问题。
• CSRF 防护：使用 JWT 可以帮助缓解跨站请求伪造（CSRF）攻击的风险，因为 JWT 不依赖于 cookie，也就不会随同 HTTP 请求自动发送。

总的来说，JWT 提供了一种高效、安全的方式来处理用户认证和授权，尤其是在需要跨域操作或构建无状态服务的情况下。

三、在django项目中如何应用JWT

JWT（JSON Web Token）是一种用于在网络应用中安全地传输信息的令牌。它通常用于身份验证和授权，特别是在单页应用（SPA）和API服务中。在Django中应用JWT，可以使用 djangorestframework-simplejwt。

1、安装djangorestframework-simplejwt库：

1

pip install djangorestframework-simplejwt

2、在settings.py中配置JWT认证：

在INSTALLED_APPS中添加rest_framework_simplejwt的应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14

INSTALLED_APPS = [
    'blog',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'rest_framework_simplejwt',  # 添加 simplejwt 应用
    'django_filters',  # 注册条件查询
    'mdeditor',  # 注册markdown的应用
    'drf_yasg2',  # 接口文档
]

添加REST_FRAMEWORK的默认认证类为JWT认证

1
2
3
4
5

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework_simplejwt.authentication.JWTAuthentication',
    ],
}

添加SIMPLE_JWT的相关配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# JWT 相关设置
SIMPLE_JWT = {
    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=30),  # 访问令牌的有效时间
    'REFRESH_TOKEN_LIFETIME': timedelta(days=1),  # 刷新令牌的有效时间
    'ROTATE_REFRESH_TOKENS': False,  # 是否允许刷新令牌循环
    'BLACKLIST_AFTER_ROTATION': True,  # 刷新令牌后是否加入黑名单
    'UPDATE_LAST_LOGIN': False,  # 登录时是否更新最后登录时间

    'ALGORITHM': 'HS256',  # 签名算法
    'SIGNING_KEY': SECRET_KEY,  # 签名密钥
    'VERIFYING_KEY': None,  # 验证密钥
    'AUDIENCE': None,  # 观众
    'ISSUER': None,  # 发行人
    'JWK_URL': None,  # JWK URL
    'LEEWAY': 0,  # 宽限期

    'AUTH_HEADER_TYPES': ('Bearer',),  # 授权头类型
    'AUTH_HEADER_NAME': 'HTTP_AUTHORIZATION',  # 授权头名称
    'USER_ID_FIELD': 'id',  # 用户 ID 字段
    'USER_ID_CLAIM': 'user_id',  # 用户 ID 声明
    'USER_AUTHENTICATION_RULE': 'rest_framework_simplejwt.authentication.default_user_authentication_rule',

    'AUTH_TOKEN_CLASSES': ('rest_framework_simplejwt.tokens.AccessToken',),  # 认证令牌类
    'TOKEN_TYPE_CLAIM': 'token_type',  # 令牌类型声明
    'TOKEN_USER_CLASS': 'rest_framework_simplejwt.models.TokenUser',

    'SLIDING_TOKEN_REFRESH_EXP_CLAIM': 'refresh_exp',  # 滑动令牌刷新过期声明
    'SLIDING_TOKEN_LIFETIME': timedelta(minutes=5),  # 滑动令牌有效时间
    'SLIDING_TOKEN_REFRESH_LIFETIME': timedelta(days=1),  # 滑动令牌刷新有效时间
}

3、在urls.py中配置JWT的获取和刷新路由：

1
2
3
4
5
6
7

from django.urls import path
from rest_framework_simplejwt.views import (TokenObtainPairView, TokenRefreshView)
urlpatterns = [
    path('token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
    # 其他路由...
]

4、在视图中需要认证的地方使用JWT认证
如下modelviweset中使用，对于查询方法如list，retrieve不做鉴权，对于其他方法需要鉴权。

1
2
3
4
5
6
7
8
9
10
11

def get_permissions(self):
    """
    Instantiates and returns the list of permissions that this view requires.
    """
    if self.action in ['list', 'retrieve']:
        # 对于list方法，返回AllowAny权限类，表示不需要鉴权
        permission_classes = [AllowAny, ]
    else:
        # 对于其他方法，返回IsAuthenticated权限类，表示需要用户已认证
        permission_classes = [IsAuthenticated, ]
    return [permission() for permission in permission_classes]

四、JWT如何使用

通过上面的应用后，使用接口调用遇到需要鉴权的会提示需要认证。
如当我们调用删除接口时，如果没有获得鉴权，接口会返回需要认证的信息。

那如何通过JWT进行认证呢？

下面通过postman来应用JWT的使用过程。

1、调用生成JWT的接口获取JWT

2、客户端保存JWT在调用接口时带上获取的JWT

至此，本文介绍了什么时JWT，为什么要使用JWT，通过django实现JWT，介绍了JWT的使用流程，最后以一个具体API接口实例的调用来说明JWT如何使用。后续将介绍VUE从前端登录获取JWT到JWT认证的实例。

博客地址：http://xiejava.ishareread.com/

任何实际的软件项目中都要经过开发、测试、然后上生产的阶段，在开发、测试的过程中往往会要频繁的切换开发、测试、生产等不同的环境。每个环境的配置有可能不一样，本文介绍如何实现django项目配置环境变量实现开发、测试、生产灵活便捷的切换。

一、为什么要区分开发 (dev)、测试 (test) 和生产 (prod) 环境

在Django项目中区分开发、测试和生产环境是非常重要的，这主要是因为不同环境在多个方面存在显著差异。
● 开发环境：通常配置为易于开发和调试，比如开启调试模式（DEBUG = True），这样可以提供更详细的错误信息和页面跟踪，方便开发者定位问题。同时，开发环境可能使用本地数据库或内存数据库，以便快速启动和测试。
● 测试环境：配置为模拟生产环境，但用于自动化测试。测试环境需要确保测试的独立性和一致性，以便准确地评估应用程序在类似生产条件下的表现。测试环境通常使用与生产环境相同或相似的数据库设置，但数据是测试专用的。
● 生产环境：配置为高性能、高可用性和高安全性。关闭调试模式，优化数据库连接和缓存策略，确保应用程序能够处理大量并发请求和保障数据的安全。
通过区分这些环境，开发者可以更有效地管理django项目，确保每个环境都能满足其特定的需求，从而提高开发效率、保障数据安全和提升用户体验。

二、django项目如何通过配置实现环境配置的区分

对于django项目实现开发（dev）、测试(test)和生产(prod)环境的配置分离可以通过使用不同的设置文件实现。
下面，我们以一个实例来介绍在django的项目如何通过使用不同的设置文件的方式区分不同的环境。

1、针对不同的环境创建不同的设置文件settings.py

针对不同的环境创建不同的设置文件，如开发环境settings_dev.py ,测试环境setting_test.py，正式生产环境使用默认的setting.py，对于共性的配置可以抽取到base.py中，其他的设置文件可以继承base.py中的配置，只有实现各个环境特有的设置就可以了。
创建设置文件的目录结构如下图所示。

2、在设置文件中根据需要进行配置区分

典型的，如开发环境settings_dev.py用的本地数据库并开启debug模式、测试环境setting_test.py用sqlite3数据库开启debug模式。
注意：其他的设置文件要继承base.py中的配置，需要加入from .base import *
参考配置如下：
setting_test.py

1
2
3
4
5
6
7
8
9
10
11
12
13

from .base import *

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'test_db.sqlite3'),
    }
}

setting_dev.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

from .base import *

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = ['127.0.0.1', 'localhost','ishareblog.com']

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'ishareblog_test',
        'USER': 'ishareblog',
        'PASSWORD': 'yourpassword',
        'HOST': '127.0.0.1',
        'PORT': '3306',
        # 1、取消外键约束，否则多对多模型迁移报django.db.utils.IntegrityError: (1215, 'Cannot add foreign key constraint')；
        # 2、解决字符串4个字节的utf8编码的字符报错的问题
        'OPTIONS': {
            'charset': 'utf8mb4',"init_command": "SET foreign_key_checks = 0;",
        }
    }
}

3、根据不同的环境运行使用不同的设置文件

不同的环境有了不同的设置文件后，就可以在不同的环境运行和使用配置文件。
如生产环境使用的wsgi启动的服务，可以在wsgi.py文件中指定使用生产环境的配置文件

在开发环境中使用manage.py启动服务的，可以修改manage.py将设置文件改为setting_dev

也可以通过命令行指定设置文件 python manage.py runserver --settings=ishareblog.settings_dev
如果时通过IDE启动，可以在IDE中指定使用的环境设置文件。
如下图所示：

如要使用测试环境的设置文件，可以配置成ishareblog.settings_test，或通过命令行指定设置文件 python manage.py runserver --settings=ishareblog.settings_test

至此，本文详细的介绍了通过不同的设置文件来区分配置开发、测试、生产环境的配置及如何根据不同的环境使用不同的设置文件。解决不同环境去频繁修改settings.py环境设置的问题。

博客地址：http://xiejava.ishareread.com/