# 安全的本质
### 1. 安全的本质
- **安全的本质是保护数据被合法地使用**。用户使用产品的过程就是与企业进行数据交换的过程，因此保护数据的合法使用是安全的核心。
- 数据安全涉及三个方面：**机密性（Confidentiality）**、**完整性（Integrity）**、**可用性（Availability）**，简称**CIA三元组**。

### 2. CIA三元组
- **机密性（Confidentiality）**：确保数据只被授权的主体访问，不被未授权的主体访问。核心是“不可见”。
  - 保护技术包括加密、隔离、混淆、隐藏等。
  - 常见的攻击形式包括破解加密算法、权限滥用、弱密钥等。
  
- **完整性（Integrity）**：确保数据只被授权的主体进行授权的修改，核心是“不可改”。
  - 强调对修改行为的日志记录和审计。
  - 保护技术包括加密、签名等。
  - 常见的攻击形式包括恶意篡改、误删除、程序bug等。

- **可用性（Availability）**：确保数据能够被授权的主体访问到，核心是“可读”。
  - 可用性不仅仅是安全问题，也是工程上的挑战。
  - 常见的挑战包括DDoS攻击、系统扩容、资源冗余等。

### 3. 安全原则的优先级
- 不同的企业在不同的发展阶段，CIA三元组的优先级会有所不同：
  - **互联网企业初期**：可用性优先级较高。
  - **涉及金钱的业务**：完整性优先级较高。
  - **涉及个人隐私的业务**：机密性优先级较高。
- 随着业务的发展，完整性和机密性的重要性会逐渐增加。



# 安全原则


### 1. 黄金法则
- **黄金法则**是解决安全问题的主要思路，包含三个核心部分：**认证（Authentication）**、**授权（Authorization）**、**审计（Audit）**。
- 这三个部分描述了用户在使用应用程序过程中的生命周期：先进行登录（认证），再进行操作（授权），最后留下记录（审计）。

### 2. 认证（Authentication）
- **认证**包括**身份识别**和**身份认证**：
  - **身份识别**：确定“你是谁”，通常通过用户名、指纹、人脸等方式声明身份。
  - **身份认证**：证明“你是你”，通常通过密码、指纹、人脸识别等方式验证身份的合法性。
- 认证的强度可以分为三类：
  1. **你知道什么**（如密码、密保问题）。
  2. **你拥有什么**（如门禁卡、安全令牌）。
  3. **你是什么**（如生物特征：指纹、人脸、虹膜）。
- **多因素认证**：结合多种认证方式（如密码+手机验证码）来增强安全性。

### 3. 授权（Authorization）
- **授权**解决的是“你能做什么”的问题，即对用户的操作进行限制。
  - 授权机制可以是手动的（如签证审批）或自动的（如免签政策）。
  - 常见的授权策略包括**自主访问控制**和**强制访问控制**。
- 授权机制需要在**可用性**和**安全性**之间找到平衡，避免过度限制用户操作。

### 4. 审计（Audit）
- **审计**解决的是“你做了什么”的问题，通过日志记录用户的操作历史，确保操作的可追溯性。
  - 审计的核心是**日志记录**，确保日志的完整性，防止篡改。
  - **问责**是审计的延伸，确保用户无法否认自己的操作，提供法律保护。
- 审计是**事后防御**的重要手段，能够发现授权机制无法覆盖的安全漏洞。

### 5. 安全建设管理
- 安全建设是一个长期过程，需要**自上而下**的推动，企业高层需要理解安全的重要性。
- 安全建设可以分为三个层次的计划：
  1. **战略计划**：长期安全目标，与企业长期发展方向结合。
  2. **战术计划**：基于战略目标，拆解出详细的任务计划（如项目列表、安全预算等）。
  3. **操作计划**：具体实现战术计划，包括人员分配、资源投入等。

### 6. 总结
- **黄金法则**是安全解决方案的核心，涵盖了用户操作的各个环节。
- 安全是**木桶原理**的领域，不能只专注于某一个方向，必须全面发展。
- **安全没有“银弹”**，不能追求100%的安全，而是要在可用性和安全性之间找到平衡。


# 密码学基础
这份PDF文件是《安全攻防技能30讲》课程的第三讲，主题是“密码学基础：如何让你的密码变得‘不可见’？”。以下是核心知识点的总结和扩展：

### 1. 密码学的重要性
- **密码学**是安全的基础技术支撑，保护数据的**机密性**、**完整性**和**可用性**（CIA三元组）。
- 密码学广泛应用于认证、授权、审计等安全机制中，确保数据在传输和存储过程中的安全性。

### 2. 对称加密算法
- **对称加密**：加密和解密使用**同一个密钥**。
  - **优点**：加密速度快，适合大量数据的加密。
  - **缺点**：密钥分发困难，密钥管理复杂。
  - **常见算法**：
    - **DES**：56位密钥，已过时，不推荐使用。
    - **IDEA**：128位密钥，无专利限制，广泛使用。
    - **AES**：128/192/256位密钥，国际标准，安全性高，性能好。
    - **国密SM1/SM4**：中国自主研发的对称加密算法，SM1保密，SM4公开。
  - **应用场景**：HTTPS、VPN、数据库加密、Cookie加密等。

### 3. 非对称加密算法
- **非对称加密**：加密和解密使用**不同的密钥**（公钥和私钥）。
  - **优点**：解决了密钥分发问题，适合一对多的通信场景。
  - **缺点**：加密速度慢，适合小数据量的加密。
  - **常见算法**：
    - **RSA**：基于大质数分解的数学难题，密钥长度较长，性能较好。
    - **ECC**：基于椭圆曲线数学难题，密钥长度短，安全性高。
    - **国密SM2**：中国自主研发的非对称加密算法，基于椭圆曲线，安全性高。
  - **应用场景**：SSH登录、Git上传、数字签名等。

### 4. 散列算法
- **散列算法**：将任意长度的输入转换为固定长度的输出（哈希值），具有**不可逆性**。
  - **特点**：
    - **鲁棒性**：相同的输入生成相同的输出。
    - **唯一性**：不同的输入生成不同的输出（理想情况下）。
  - **常见算法**：
    - **MD5**：128位哈希值，已被破解，不推荐使用。
    - **SHA**：160/256位哈希值，SHA-256安全性高，推荐使用。
    - **国密SM3**：中国自主研发的散列算法，安全性高。
  - **应用场景**：密码存储、文件完整性校验、Git提交记录等。
  - **加盐**：在散列计算前加入随机字符串（盐），增加安全性，防止彩虹表攻击。

### 5. 密码学的应用场景
- **对称加密**：适合大量数据的加密，如HTTPS、数据库加密等。
- **非对称加密**：适合密钥分发和数字签名，如SSH登录、Git上传等。
- **散列算法**：适合密码存储和完整性校验，如用户密码存储、文件校验等。

### 6. 总结与推荐
- **对称加密**：优先使用**AES-CTR**，性能好，安全性高。
- **非对称加密**：优先使用**ECC**，密钥短，安全性高。
- **散列算法**：优先使用**SHA256加盐**，安全性高，适合密码存储。

### 7. 扩展思考
- **密钥管理**：对称加密的密钥分发是非对称加密的主要应用场景之一。非对称加密解决了密钥分发的难题，但在实际应用中，通常结合对称加密和非对称加密，先用非对称加密传输对称加密的密钥，再用对称加密加密大量数据。
- **密码学与法律**：随着《密码法》的实施，国内企业在选择加密算法时，可能需要考虑国密算法的合规性。国密算法（如SM2、SM3、SM4）在国内的应用逐渐增多，尤其是在金融、政府等敏感领域。
- **密码学的未来**：随着量子计算的发展，传统的加密算法（如RSA）可能会面临挑战。量子计算机可以在多项式时间内破解RSA等基于大数分解的加密算法，因此，未来的密码学研究可能会更多地关注抗量子计算的加密算法。


# 身份认证
这份PDF文件是《安全攻防技能30讲》课程的第四讲，主题是“身份认证：除了账号密码，我们还能怎么做身份认证？”。以下是核心知识点的总结：

### 1. 身份认证的重要性
- **身份认证**是安全的第一道门槛，确保用户身份的合法性，为后续的授权和审计提供基础。
- 身份认证不仅仅是账号密码的输入，还包括**对外认证**（面向用户的登录注册）和**对内认证**（内部系统的登录，如服务器、数据库、Git等）。

### 2. 身份认证的分类
- **对外认证**：面向用户的登录注册模块，通常只有一个登录入口，可以通过多种认证方式（如密码、手机验证、生物特征等）进行认证。
- **对内认证**：面向内部系统的登录，场景复杂且分散，管理难度较大，通常需要长期治理。

### 3. 身份认证面临的威胁
- **无认证**：很多内部系统（如数据库、管理后台）没有认证环节，直接暴露在风险中。
- **弱密码**：用户倾向于使用简单易记的密码，导致密码容易被破解。
- **认证信息泄漏**：黑客通过钓鱼、拖库等手段获取用户的密码或身份凭证（如Cookie、Session ID），进行重放攻击。

### 4. 身份认证的安全措施
- **密码强度限制**：强制使用复杂密码（字母、数字、特殊字符组合），并定期修改密码。
- **多因素认证**：结合多种认证方式（如密码+手机验证码、指纹、人脸识别等），增加安全性。
- **加密信道**：使用HTTPS等加密协议，防止认证信息在传输过程中被窃听。
- **凭证有效期**：为下发的身份凭证设置有效期，减少重放攻击的风险。
- **单点登录（SSO）**：通过统一的认证中心管理多个应用的登录，简化用户操作，提升安全性。

### 5. 单点登录（SSO）的解决方案
- **CAS（Central Authentication Service）**：集中式认证服务，用户只需在认证中心进行一次认证，即可访问所有应用。
- **JWT（JSON Web Token）**：轻量级的单点登录方案，客户端保存凭证信息，每次请求携带该凭证，适合无状态的应用场景。
- **OAuth（Open Authorization）**：主要用于授权，用户通过第三方（如微信、QQ）登录后，应用可以获取用户的部分信息，适合需要授权的场景。
- **OpenID**：与OAuth类似，但不提供授权功能，适合仅需认证的场景。

### 6. 单点登录的实现建议
- **避免自行实现简化版SSO**：自行实现的SSO可能存在安全隐患，建议接入成熟的单点登录体系（如CAS、OAuth等）。
- **选择合适的SSO方案**：根据业务需求选择适合的单点登录方案，如JWT适合轻量级应用，OAuth适合需要授权的场景。

### 7. 总结
- **身份认证**是安全的基础，涉及对外和对内两个场景，尤其是对内认证容易被忽视。
- **单点登录SSO**是解决复杂认证体系的有效方案，能够简化用户操作并提升安全性。
- **多因素认证**、**加密信道**、**凭证有效期**等技术手段可以有效提升身份认证的安全性。

### 8. 扩展思考
- **内部认证的治理**：内部系统的认证（如服务器、数据库）往往容易被忽视，建议通过**跳板机**、**VPN**等方式加强内部认证的安全性。
- **安全意识培训**：除了技术手段，提升员工和用户的安全意识也是保障身份认证安全的重要环节。
- **密码管理工具**：推荐使用密码管理工具（如LastPass、1Password）生成和存储强密码，减少弱密码的使用。

# 访问控制
这份PDF文件是《安全攻防技能30讲》课程的第五讲，主题是“访问控制：如何选取一个合适的数据保护方案？”。以下是核心知识点的总结：

### 1. 访问控制的重要性
- **访问控制**是安全的核心机制之一，确保只有经过授权的用户或系统能够访问特定的资源或执行特定的操作。
- 访问控制与**身份认证**和**审计**共同构成了安全的“黄金法则”。

### 2. 访问控制的基本模型
- **主体**：发起访问请求的实体，可以是用户、进程、应用或设备。
- **客体**：被访问的资源，如文件、数据库、设备等。
- **请求**：主体对客体执行的操作，如读、写、执行等。

### 3. 常见的访问控制机制
- **DAC（Discretionary Access Control，自主访问控制）**：
  - **特点**：由客体的所有者定义访问控制规则，灵活性高，但安全性依赖于所有者的安全意识。
  - **适用场景**：面向用户的场景，如Linux文件系统，用户可以控制自己的文件访问权限。
  
- **role-BAC（Role-Based Access Control，基于角色的访问控制）**：
  - **特点**：将用户划分为不同的角色，每个角色拥有特定的权限，管理员集中管理角色和权限。
  - **适用场景**：企业内部系统（如ERP），管理员可以轻松管理用户权限，适合集中管理的场景。
  
- **rule-BAC（Rule-Based Access Control，基于规则的访问控制）**：
  - **特点**：基于预定义的规则进行访问控制，规则可以结合主体、客体和请求的属性。
  - **适用场景**：复杂场景，如防火墙、风控系统等，适合无法清晰划分角色的场景。
  
- **MAC（Mandatory Access Control，强制访问控制）**：
  - **特点**：基于安全级别标签进行访问控制，主体和客体被标记为不同的安全级别（如秘密、私人、敏感、公开）。
  - **适用场景**：政府系统或高安全性要求的场景，适合能够对所有数据进行标签化的系统。

### 4. 访问控制机制的选择
- **DAC**：适合用户自主控制权限的场景。
- **role-BAC**：适合管理员集中管理的场景，简化权限分配和变更。
- **rule-BAC**：适合复杂场景，如网络请求、风控系统等。
- **MAC**：适合高安全性要求的场景，如政府系统。

### 5. 威胁评估的步骤
- **识别数据**：确定哪些数据是核心资产，评估数据泄露或损坏对公司的影响。
- **识别攻击**：根据数据的价值，推测可能的攻击方式。
- **识别漏洞**：根据应用类型，识别可能存在的安全漏洞（如XSS、SQL注入等）。

### 6. 总结
- **访问控制机制**是确保数据安全的重要手段，不同的机制适用于不同的场景。
- **DAC**、**role-BAC**、**rule-BAC**和**MAC**各有优缺点，实际应用中常常需要组合使用。
- **威胁评估**是安全方案落地的前提，通过识别数据、攻击和漏洞，明确公司面临的安全威胁，推动安全方案的实施。

### 7. 扩展思考
- **访问控制的组合使用**：在实际应用中，单一的访问控制机制可能无法满足所有需求，通常需要组合使用多种机制。例如，Linux系统中既使用DAC（用户控制文件权限），也使用role-BAC（用户组管理）。
- **威胁评估的周期性**：随着公司业务的发展，安全威胁也在不断变化，建议定期进行威胁评估，及时调整安全策略。
- **访问控制的自动化**：随着系统规模的扩大，手动管理访问控制规则变得不现实，建议引入自动化工具（如IAM系统）来简化权限管理。



![image.png](/static/img/7df2100ffda51560db5c75e1f3607965.image.webp)

安全基础概念

最近在玩Burp suit,用来分析网站数据交互，逆向啥的，爬虫还有渗透，没有什么东西测试，尝试访问自家路由器，小米路由器

ipconfig查看网关


![image.png](/static/img/8dbc31fd5b3980f6a1452e043302074a.image.webp)

然后直接分析,nmap 192.168.31.0/24

```shell
C:\Users\zyh16>nmap 192.168.31.0/24
Starting Nmap 7.80 ( https://nmap.org ) at 2025-01-18 17:18 ?D1ú±ê×?ê±??
Nmap scan report for XiaoQiang (192.168.31.1)
Host is up (0.032s latency).
Not shown: 993 closed ports
PORT     STATE    SERVICE
53/tcp   open     domain
80/tcp   filtered http
8192/tcp open     sophos
8193/tcp open     sophos
8383/tcp open     m2mservices
8443/tcp open     https-alt
8899/tcp open     ospf-lite
MAC Address: A4:39:B3:16:C9:12 (Unknown)

Nmap scan report for 192.168.31.32
Host is up (0.0032s latency).
All 1000 scanned ports on 192.168.31.32 are closed
MAC Address: FA:F9:29:9B:AA:93 (Unknown)

Nmap scan report for 192.168.31.78
Host is up (0.014s latency).
All 1000 scanned ports on 192.168.31.78 are closed
MAC Address: D2:1E:F5:F9:30:47 (Unknown)

Nmap scan report for 192.168.31.143
Host is up (0.00s latency).
Not shown: 995 closed ports
PORT    STATE SERVICE
135/tcp open  msrpc
139/tcp open  netbios-ssn
445/tcp open  microsoft-ds
902/tcp open  iss-realsecure
912/tcp open  apex-mesh

Nmap done: 256 IP addresses (4 hosts up) scanned in 5.86 seconds
```

拿到了所有链接该wifi的设备

我们的目标是路由器

使用nmap -O ip,nmap -sV ip分析

```shell
C:\Users\zyh16>nmap -O 192.168.31.1
Starting Nmap 7.80 ( https://nmap.org ) at 2025-01-18 17:22 ?D1ú±ê×?ê±??
Nmap scan report for XiaoQiang (192.168.31.1)
Host is up (0.00061s latency).
Not shown: 993 closed ports
PORT     STATE SERVICE
53/tcp   open  domain
80/tcp   open  http
8192/tcp open  sophos
8193/tcp open  sophos
8383/tcp open  m2mservices
8443/tcp open  https-alt
8899/tcp open  ospf-lite
MAC Address: A4:39:B3:16:C9:12 (Unknown)
No exact OS matches for host (If you know what OS is running on it, see https://nmap.org/submit/ ).
TCP/IP fingerprint:
OS:SCAN(V=7.80%E=4%D=1/18%OT=53%CT=1%CU=44371%PV=Y%DS=1%DC=D%G=Y%M=A439B3%T
OS:M=678B72CA%P=i686-pc-windows-windows)SEQ(SP=0%GCD=0%ISR=0%TI=Z%CI=Z%II=I
OS:%TS=7)SEQ(CI=Z%II=I)OPS(O1=M5B4ST11NW3%O2=M5B4ST11NW3%O3=M5B4NNT11NW3%O4
OS:=M5B4ST11NW3%O5=M5B4ST11NW3%O6=M5B4ST11)WIN(W1=3890%W2=3890%W3=3890%W4=3
OS:890%W5=3890%W6=3890)ECN(R=Y%DF=Y%T=40%W=3908%O=M5B4NNSNW3%CC=N%Q=)T1(R=Y
OS:%DF=Y%T=40%S=A%A=S+%F=AS%RD=0%Q=)T2(R=N)T3(R=N)T4(R=Y%DF=Y%T=40%W=0%S=A%
OS:A=Z%F=R%O=%RD=0%Q=)T5(R=Y%DF=Y%T=40%W=0%S=Z%A=S+%F=AR%O=%RD=0%Q=)T6(R=Y%
OS:DF=Y%T=40%W=0%S=A%A=Z%F=R%O=%RD=0%Q=)T7(R=N)U1(R=Y%DF=N%T=40%IPL=164%UN=
OS:0%RIPL=G%RID=G%RIPCK=G%RUCK=G%RUD=G)IE(R=Y%DFI=N%T=40%CD=S)

Network Distance: 1 hop

OS detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 14.27 seconds

```

得不到更详细的信息，往下看
```shell 

C:\Users\zyh16>nmap -sV 192.168.31.1
Starting Nmap 7.80 ( https://nmap.org ) at 2025-01-18 17:23 ?D1ú±ê×?ê±??
Nmap scan report for XiaoQiang (192.168.31.1)
Host is up (0.000046s latency).
Not shown: 993 closed ports
PORT     STATE SERVICE VERSION
53/tcp   open  domain  dnsmasq 2.71
80/tcp   open  http    nginx
8192/tcp open  http    nginx
8193/tcp open  http    nginx
8383/tcp open  http    nginx
8443/tcp open  http    nginx
8899/tcp open  http    nginx
MAC Address: A4:39:B3:16:C9:12 (Unknown)

Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 13.88 seconds

C:\Users\zyh16>


```
随便访问一个端口,发现是运行了好几个一样的客户端，不知道什么原因，容错吗，接下来访问一下登录，毕竟咱什么也不懂


上BP，

![image.png](/static/img/1d6377a7aea7c0e4b1be61a5a2f60bed.image.webp)


随便输个密码拦截一下

请求
```
POST /cgi-bin/luci/api/xqsystem/login HTTP/1.1
Host: 192.168.31.1
Content-Length: 126
X-Requested-With: XMLHttpRequest
Accept-Language: zh-CN,zh;q=0.9
Accept: */*
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.70 Safari/537.36
Origin: http://192.168.31.1
Referer: http://192.168.31.1/cgi-bin/luci/web
Accept-Encoding: gzip, deflate, br
Cookie: __guid=86847064.352973640720185540.1737182970960.3284; monitor_count=2
Connection: keep-alive

username=admin&password=be4f487645ecc828e8b58b73c149789b79ee5743&logtype=2&nonce=0_8c%3Ae9%3Aee%3Ade%3A61%3A24_1737192442_7143
```

这个登录逻辑nonce应该是生成用于保证幂等或者别的什么的，只能用一次的字符串，暂时还不清楚，看密码，前端加密传过去，好办，翻代码，看密码长度像sha1，自己找个网站试了一下不像
后面这个nonce老手可能一眼就看出来可能是盐了，但我是新手，只能翻代码

搜索function login相关的


![image.png](/static/img/e6a8afcee1924589d475fcd74adf0638.image.webp)

完整代码

```js
   function loginHandle ( e ) {
        e.preventDefault();
        var formObj = document.rtloginform;
        var pwd = $( '#password' ).val();
        if ( pwd == '') {
            return;
        }
        var nonce = Encrypt.init();
        var oldPwd = Encrypt.oldPwd( pwd );
        var param = {
            username: 'admin',
            password: oldPwd,
            logtype: 2,
            nonce: nonce
        };
        $.pub('loading:start');
        var url = '/cgi-bin/luci/api/xqsystem/login';
            $.post( url, param, function( rsp ) {
                $.pub('loading:stop');
                var rsp = $.parseJSON( rsp );
                if ( rsp.code == 0 ) {
                    var redirect,
                        token = rsp.token;
                    if ( /action=wan/.test(location.href) ) {
                        redirect = buildUrl('wan', token);
                    } else if ( /action=lannetset/.test(location.href) ) {
                        redirect = buildUrl('lannetset', token);
                    } else {
                        redirect = rsp.url;
                    }
                    window.location.href = redirect;
                } else if ( rsp.code == 403 ) {
                    window.location.reload();
                } else {
                    pwdErrorCount ++;
                    var errMsg = '密码错误';
                    if (pwdErrorCount >= 4) {
                        errMsg = '多次密码错误，将禁止继续尝试';
                    }
                    Valid.fail( document.getElementById('password'), errMsg, false);
                    $( formObj )
                    .addClass( 'shake animated' )
                    .one( 'webkitAnimationEnd mozAnimationEnd MSAnimationEnd oanimationend animationend', function(){
                        $('#password').focus();
                        $( this ).removeClass('shake animated');
                    } );
                }
            });
    }
```

加密过程
```js
var nonce = Encrypt.init();
        var oldPwd = Encrypt.oldPwd( pwd );
        var param = {
            username: 'admin',
            password: oldPwd,
            logtype: 2,
            nonce: nonce
        };
```

接下来需要把这个加密工具对象拔出来，直接搜方法名

```js
var Encrypt = {
    key: 'a2ffa5c9be07488bbb04a3a47d3c5f6a',
    iv: '64175472480004614961023454661220',
    nonce: null,
    init: function(){
        var nonce = this.nonceCreat();
        this.nonce = nonce;
        return this.nonce;
    },
    nonceCreat: function(){
        var type = 0;
        var deviceId = '8c:e9:ee:de:61:24';
        var time = Math.floor(new Date().getTime() / 1000);
        var random = Math.floor(Math.random() * 10000);
        return [type, deviceId, time, random].join('_');
    },
    oldPwd : function(pwd){
        return CryptoJS.SHA1(this.nonce + CryptoJS.SHA1(pwd + this.key).toString()).toString();
    },
    newPwd: function(pwd, newpwd){
        var key = CryptoJS.SHA1(pwd + this.key).toString();
        key = CryptoJS.enc.Hex.parse(key).toString();
        key = key.substr(0, 32);
        key = CryptoJS.enc.Hex.parse(key);
        var password = CryptoJS.SHA1(newpwd + this.key).toString();
        var iv = CryptoJS.enc.Hex.parse(this.iv);
        var aes = CryptoJS.AES.encrypt(
                password,
                key,
                {iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 }
            ).toString();
        return aes;
    }
};

```

到这整个加密过程被扒出来了

，接下来尝试用go还原加密过程，看看和拦截到的是不是一样
输入密码123456,拦截到
```

username=admin&password=18568a99082996cf802d26ceb548090eef74c574&logtype=2&nonce=0_8c%3Ae9%3Aee%3Ade%3A61%3A24_1737193552_5123
```

记住，nonce要更他一样

```
zyh16@qwm MINGW64 /d/GoProS/manty
$ go run test.go
Nonce: 0_8c:e9:ee:de:61:24_1737193552_5123
Encrypted Password: 18568a99082996cf802d26ceb548090eef74c574

zyh16@qwm MINGW64 /d/GoProS/manty
```
生成的一样

接下来尝试用go去登录

完整代码
```go
package main

import (
	"crypto/sha1"
	"encoding/hex"
	"fmt"
	"io/ioutil"
	"math/rand"
	"net/http"
	"net/url"
	"strings"
	"time"
)

// Encrypt 结构体
type Encrypt struct {
	Key   string // 固定的 key
	IV    string // 固定的 iv
	Nonce string // 动态生成的 nonce
}

// 初始化 Encrypt
func NewEncrypt() *Encrypt {
	return &Encrypt{
		Key: "a2ffa5c9be07488bbb04a3a47d3c5f6a",
		IV:  "64175472480004614961023454661220",
	}
}

// 生成 nonce
func (e *Encrypt) Init() string {
	e.Nonce = e.nonceCreat()
	return e.Nonce
}

// 生成 nonce 的逻辑
func (e *Encrypt) nonceCreat() string {
	typeVal := 0
	deviceID := "8c:e9:ee:de:61:24"
	timestamp := time.Now().Unix() // 当前时间戳（秒）
	random := rand.Intn(10000)     // 随机数
	return fmt.Sprintf("%d_%s_%d_%d", typeVal, deviceID, timestamp, random)
}

// 加密密码
func (e *Encrypt) OldPwd(pwd string) string {
	// 第一步：计算 SHA1(pwd + key)
	step1 := sha1.Sum([]byte(pwd + e.Key))
	step1Hex := hex.EncodeToString(step1[:])

	// 第二步：计算 SHA1(nonce + step1Hex)
	step2 := sha1.Sum([]byte(e.Nonce + step1Hex))
	step2Hex := hex.EncodeToString(step2[:])

	return step2Hex
}

// 发送登录请求
func sendLoginRequest(nonce, encryptedPwd string) {
	// 构造请求参数
	data := url.Values{}
	data.Set("username", "admin")
	data.Set("password", encryptedPwd)
	data.Set("logtype", "2")
	data.Set("nonce", nonce)

	// 构造请求
	req, err := http.NewRequest("POST", "http://192.168.31.1/cgi-bin/luci/api/xqsystem/login", strings.NewReader(data.Encode()))
	if err != nil {
		fmt.Println("Error creating request:", err)
		return
	}

	// 设置请求头
	req.Header.Set("Host", "192.168.31.1")
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
	req.Header.Set("X-Requested-With", "XMLHttpRequest")
	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.70 Safari/537.36")
	req.Header.Set("Referer", "http://192.168.31.1/cgi-bin/luci/web")
	req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
	req.Header.Set("Accept", "*/*")
	req.Header.Set("Connection", "keep-alive")

	// 发送请求
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error sending request:", err)
		return
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Error reading response body:", err)
		return
	}

	fmt.Println("Response Body:", string(body))
	// 输出响应
	fmt.Println("Response Status:", resp.Status)
	fmt.Println("Response Headers:", resp.Header)
}

func main() {
	// 初始化 Encrypt
	encrypt := NewEncrypt()

	// 生成 nonce
	nonce := encrypt.Init()
	fmt.Println("Nonce:", nonce)

	// 加密密码
	pwd := "zhang.123" // 用户输入的密码
	oldPwd := encrypt.OldPwd(pwd)
	fmt.Println("Encrypted Password:", oldPwd)

	// 发送登录请求
	sendLoginRequest(nonce, oldPwd)
}

```

成功
```go
zyh16@qwm MINGW64 /d/GoProS/manty
$ go run test.go 
Nonce: 0_8c:e9:ee:de:61:24_1737193824_9494
Encrypted Password: 7088cf0d28cccd73aafe7df63eae915adb8fd5d0
Response Body: {"url":"/cgi-bin/luci/;stok=5f6548ea094bee92b0ac55e770125cad/web/home","token":"5f6548ea094bee92b0ac55e770125cad","code":0}
Response Status: 200 OK
Response Headers: map[Cache-Control:[no-cache] Content-Length:[123] Content-Type:[text/html; charset=utf-8] Date:[Sat, 18 Jan 2025 09:50:22 GMT] Expires:[Thu, 01 Jan 1970 00:00:01 GMT] Micgi-Client-Ip:[192.168.31.143] Micgi-Host:[192.168.31.1] Micgi-Http-Host:[192.168.31.1] Micgi-Preload:[no] Micgi-Server-Ip:[192.168.31.1] Micgi-Server-Port:[80] Micgi-Status:[CGI] Micgi-Switch:[1 1] Server:[nginx] Set-Cookie:[psp=admin|||2|||0;path=/;]]

zyh16@qwm MINGW64 /d/GoProS/manty
$
```

后续想尝试爆破，但是失败了，连续请求多次接口耗时逐渐增加，应该是进行速率限制了



探索路由器登陆

根据大佬的教程成功安装BurpSuit，入门安全第一步

https://www.52pojie.cn/thread-1953331-1-1.html

![](https://www.shika.icu/static/img/fe587f0edb9435c4c5a206673520dd1c.image.webp)

BurpSuit安装

# flutter_staggered_grid_view 中文教程

`flutter_staggered_grid_view` 是一个提供多种 Flutter 网格布局的库。本教程将帮助你快速上手并使用该库。

## 开始使用

在你的 Flutter 项目的 `pubspec.yaml` 文件中，添加以下依赖：

```yaml
dependencies:
  ...
  flutter_staggered_grid_view: <最新版本>
```

在你的 Dart 文件中，添加以下导入：

```dart
import 'package:flutter_staggered_grid_view/flutter_staggered_grid_view.dart';
```

如果你需要帮助来开始使用 Flutter，可以查看[在线文档](https://flutter.dev/docs)。

## 布局介绍

这个库包含了多种网格布局。在接下来的部分中，你将了解每一种布局。为了简化描述，布局的解释将始终考虑从上到下和从左到右的方向。当然，你可以在代码中更改这些方向。

### 1. 交错网格布局 (Staggered Grid Layout)

这种布局适用于少量项目。目前还没有找到在 Sliver 上下文中运行的高效算法，因此这不是一个 `GridView`，所以也没有 `SliverStaggeredGrid`。

#### 网格属性
- 均匀分为 n 列
- 适用于少量项目
- 不可滚动

#### 瓦片属性
- 必须占据 1 到 n 列

#### 放置算法
- 从上到下，从左到右

#### 示例代码

```dart
import 'package:flutter/material.dart';
import 'package:flutter_staggered_grid_view/flutter_staggered_grid_view.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('Staggered Grid Layout')),
        body: StaggeredGridDemo(),
      ),
    );
  }
}

class StaggeredGridDemo extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return StaggeredGrid.count(
      crossAxisCount: 4,
      mainAxisSpacing: 4,
      crossAxisSpacing: 4,
      children: const [
        StaggeredGridTile.count(
          crossAxisCellCount: 2,
          mainAxisCellCount: 2,
          child: Tile(index: 0, color: Colors.blue),
        ),
        StaggeredGridTile.count(
          crossAxisCellCount: 2,
          mainAxisCellCount: 1,
          child: Tile(index: 1, color: Colors.green),
        ),
        StaggeredGridTile.count(
          crossAxisCellCount: 1,
          mainAxisCellCount: 1,
          child: Tile(index: 2, color: Colors.orange),
        ),
        StaggeredGridTile.count(
          crossAxisCellCount: 1,
          mainAxisCellCount: 1,
          child: Tile(index: 3, color: Colors.red),
        ),
        StaggeredGridTile.count(
          crossAxisCellCount: 4,
          mainAxisCellCount: 2,
          child: Tile(index: 4, color: Colors.purple),
        ),
      ],
    );
  }
}

class Tile extends StatelessWidget {
  final int index;
  final Color color;

  const Tile({required this.index, required this.color});

  @override
  Widget build(BuildContext context) {
    return Container(
      color: color,
      child: Center(
        child: Text('Tile $index', style: TextStyle(color: Colors.white)),
      ),
    );
  }
}

```


![image.png](/static/img/ed79ec93984ee37a5443e73fb1175888.image.webp)

### 2. 瀑布流网格布局 (Masonry Grid Layout)

这种布局便于浏览未裁剪的同等内容。容器的高度根据小部件的大小进行调整。

#### 网格属性
- 均匀分为 n 列

#### 瓦片属性
- 必须占据 1 列

#### 放置算法
- 从上到下，从左到右

#### 示例代码

```dart
import 'package:flutter/material.dart';
import 'package:flutter_staggered_grid_view/flutter_staggered_grid_view.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('Masonry Grid Layout')),
        body: MasonryGridDemo(),
      ),
    );
  }
}

class MasonryGridDemo extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MasonryGridView.count(
      crossAxisCount: 4,
      mainAxisSpacing: 4,
      crossAxisSpacing: 4,
      itemCount: 20,
      itemBuilder: (context, index) {
        return Tile(
          index: index,
          color: Colors.primaries[index % Colors.primaries.length],
          height: (index % 5 + 1) * 50,
        );
      },
    );
  }
}

class Tile extends StatelessWidget {
  final int index;
  final Color color;
  final double height;

  const Tile({required this.index, required this.color, required this.height});

  @override
  Widget build(BuildContext context) {
    return Container(
      color: color,
      height: height,
      child: Center(
        child: Text('Tile $index', style: TextStyle(color: Colors.white)),
      ),
    );
  }
}
```

![image.png](/static/img/b7f390f8c52a62a584d04cb6b0ee184e.image.webp)
### 3. 拼布网格布局 (Quilted Grid Layout)

这种布局通过不同的容器大小和比例来强调某些项目，从而创建层次结构。

#### 网格属性
- 均匀分为 n 列
- 每行的高度等于每列的宽度
- 模式定义了瓦片的大小，并且可以有不同的重复模式

#### 瓦片属性
- 必须占据 1 到 n 列
- 必须占据 1 行或更多行

#### 放置算法
- 从上到下，从左到右

#### 示例代码

```dart
import 'package:flutter/material.dart';
import 'package:flutter_staggered_grid_view/flutter_staggered_grid_view.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('Quilted Grid Layout')),
        body: QuiltedGridDemo(),
      ),
    );
  }
}

class QuiltedGridDemo extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return GridView.custom(
      gridDelegate: SliverQuiltedGridDelegate(
        crossAxisCount: 4,
        mainAxisSpacing: 4,
        crossAxisSpacing: 4,
        repeatPattern: QuiltedGridRepeatPattern.inverted,
        pattern: [
          QuiltedGridTile(2, 2),
          QuiltedGridTile(1, 1),
          QuiltedGridTile(1, 1),
          QuiltedGridTile(1, 2),
        ],
      ),
      childrenDelegate: SliverChildBuilderDelegate(
        (context, index) => Tile(
          index: index,
          color: Colors.primaries[index % Colors.primaries.length],
        ),
        childCount: 20,
      ),
    );
  }
}

class Tile extends StatelessWidget {
  final int index;
  final Color color;

  const Tile({required this.index, required this.color});

  @override
  Widget build(BuildContext context) {
    return Container(
      color: color,
      child: Center(
        child: Text('Tile $index', style: TextStyle(color: Colors.white)),
      ),
    );
  }
}

```

![image.png](/static/img/a6a83d313f76b601a56c36344c60581e.image.webp)
### 4. 编织网格布局 (Woven Grid Layout)

这种布局便于浏览同等内容。项目显示在不同比例的容器中，以创建有节奏的布局。

#### 网格属性
- 均匀分为 n 列
- 行的高度是瓦片的最大高度
- 模式定义了瓦片的大小
- 瓦片的大小按照 'z' 序列的模式排列

#### 瓦片属性
- 高度由 `aspectRatio`（宽高比）定义
- 宽度由 `crossAxisRatio`（宽度/列宽）定义，范围在 0（不包括）到 1（包括）之间
- 每个瓦片可以定义其在可用空间内的对齐方式

#### 放置算法
- 从上到下，从左到右

#### 示例代码

```dart
import 'package:flutter/material.dart';
import 'package:flutter_staggered_grid_view/flutter_staggered_grid_view.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('Quilted Grid Layout')),
        body: QuiltedGridDemo(),
      ),
    );
  }
}

class QuiltedGridDemo extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return GridView.custom(
      gridDelegate: SliverQuiltedGridDelegate(
        crossAxisCount: 4,
        mainAxisSpacing: 4,
        crossAxisSpacing: 4,
        repeatPattern: QuiltedGridRepeatPattern.inverted,
        pattern: [
          QuiltedGridTile(2, 2),
          QuiltedGridTile(1, 1),
          QuiltedGridTile(1, 1),
          QuiltedGridTile(1, 2),
        ],
      ),
      childrenDelegate: SliverChildBuilderDelegate(
        (context, index) => Tile(
          index: index,
          color: Colors.primaries[index % Colors.primaries.length],
        ),
        childCount: 20,
      ),
    );
  }
}

class Tile extends StatelessWidget {
  final int index;
  final Color color;

  const Tile({required this.index, required this.color});

  @override
  Widget build(BuildContext context) {
    return Container(
      color: color,
      child: Center(
        child: Text('Tile $index', style: TextStyle(color: Colors.white)),
      ),
    );
  }
}

```

### 5. 阶梯网格布局 (Staired Grid Layout)

这种布局使用交替的容器大小和比例来创建有节奏的效果。它是另一种编织网格布局。

#### 网格属性
- 模式定义了瓦片的大小
- 每个瓦片相对于前一个瓦片在水平和垂直方向上都有一定的偏移
- 放置遵循 'z' 序列

#### 瓦片属性
- 高度由 `aspectRatio`（宽高比）定义
- 宽度由 `crossAxisRatio`（宽度/可用水平空间）定义，范围在 0（不包括）到 1（包括）之间

#### 放置算法
- 按照 'z' 序列

#### 示例代码

```dart
import 'package:flutter/material.dart';
import 'package:flutter_staggered_grid_view/flutter_staggered_grid_view.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('Staired Grid Layout')),
        body: StairedGridDemo(),
      ),
    );
  }
}

class StairedGridDemo extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return GridView.custom(
      gridDelegate: SliverStairedGridDelegate(
        crossAxisSpacing: 8,
        mainAxisSpacing: 8,
        startCrossAxisDirectionReversed: true,
        pattern: [
          StairedGridTile(0.5, 1), // 第一个瓦片：宽度 50%，高度 1 倍
          StairedGridTile(0.5, 3 / 4), // 第二个瓦片：宽度 50%，高度 0.75 倍
          StairedGridTile(1.0, 10 / 4), // 第三个瓦片：宽度 100%，高度 2.5 倍
        ],
      ),
      childrenDelegate: SliverChildBuilderDelegate(
        (context, index) => Tile(
          index: index,
          color: Colors.primaries[index % Colors.primaries.length],
        ),
        childCount: 20,
      ),
    );
  }
}

class Tile extends StatelessWidget {
  final int index;
  final Color color;

  const Tile({required this.index, required this.color});

  @override
  Widget build(BuildContext context) {
    return Container(
      color: color,
      child: Center(
        child: Text('Tile $index', style: TextStyle(color: Colors.white)),
      ),
    );
  }
}

```

![image.png](/static/img/461877a9c01c99faab8fa4b594d22e46.image.webp)
### 6. 对齐网格布局 (Aligned Grid Layout)

![image.png](/static/img/4940db2e815d77f56f2142bde40df608.image.webp)
这种布局也被称为 CSS 网格。这是网页上常见的网格布局，其中每个项目在其轨道内具有与其兄弟项目相同的最大交叉轴范围。

#### 网格属性
- 均匀分为 n 列
- 行可以有不同的高度

#### 瓦片属性
- 必须占据 1 列
- 每个瓦片的高度与行中最高的瓦片相同

#### 放置算法
- 从上到下，从左到右

#### 示例代码

```dart
import 'package:flutter/material.dart';
import 'package:flutter_staggered_grid_view/flutter_staggered_grid_view.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('Aligned Grid Layout')),
        body: AlignedGridDemo(),
      ),
    );
  }
}

class AlignedGridDemo extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return AlignedGridView.count(
      crossAxisCount: 4,
      mainAxisSpacing: 4,
      crossAxisSpacing: 4,
      itemCount: 20,
      itemBuilder: (context, index) {
        return Tile(
          index: index,
          color: Colors.primaries[index % Colors.primaries.length],
          height: (index % 7 + 1) * 30,
        );
      },
    );
  }
}

class Tile extends StatelessWidget {
  final int index;
  final Color color;
  final double height;

  const Tile({required this.index, required this.color, required this.height});

  @override
  Widget build(BuildContext context) {
    return Container(
      color: color,
      height: height,
      child: Center(
        child: Text('Tile $index', style: TextStyle(color: Colors.white)),
      ),
    );
  }
}
```

![image.png](/static/img/fb79ce4c80afc9ee0f1b65b14a8842ed.image.webp)


安全的本质

1. 安全的本质

flutter_staggered_grid_view 中文教程

填空

第二章