Go黑帽子（第二章）

已于 2024-01-26 18:20:46 修改
阅读量1.1k 收藏 9
点赞数 14
分类专栏： Go黑帽子渗透测试编程之道 文章标签： golang 开发语言 后端
于 2024-01-26 18:20:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/newbie_______/article/details/135872467
版权

2.0 第二章 TCP、扫描器和代理

文章目录

2.1 TCP握手机制

这部分内容就不详细说了，百度讲的会更详细，如果看不懂请移步到哔哩哔哩大学。

2.2 通过端口转发绕过防火墙

说白了就是防火墙不允许访问的网站，通过访问允许访问的网站将流量进行代理到目标网站上。

2.3 编写一个TCP扫描器
2.3.1 测试端口可用性

单个端口扫描器

package main

import (
	"fmt"
	"net"
)

func main() {
	_, err := net.Dial("tcp", "scanme.nmap.org:80")
	if err == nil {
		fmt.Println("Connection successful")
	}
}
2.3.2 执行非并发扫描

说白了就是循环检测，看看能不能脸上，我觉得这个效率极低。

package main

import (
	"fmt"
	"net"
)

func main() {
	for i := 1; i <= 1024; i++ {
		address := fmt.Sprintf("scanme.nmap.org:%d", i)
		conn, err := net.Dial("tcp", address)
		if err == nil {
			fmt.Println("Connection successful")
		} else {
			//端口已关闭或已过滤
			continue
		}
		conn.Close()
		fmt.Printf("%d opne\n", i)
	}
}
2.3.3 执行并发扫描

这个时候用到go语言的独有的goroutine

package main

import (
	"fmt"
	"net"
)

func main() {
	for i := 1; i <= 1024; i++ {
		go func(j int) {
			address := fmt.Sprintf("scanme.nmap.org:%d", j)
			conn, err := net.Dial("tcp", address)
			if err != nil {
				return
			}
			conn.Close()
			fmt.Printf("%d open\n", j)
		}(i)
	}
}
//这里给大家对这个程序进行解释
在这个代码片段中，i 被传递给了匿名函数作为参数 j。这是为了避免在并发的情况下出现竞态条件。
在Go语言中，使用 go 关键字启动一个 goroutine 时，它会在一个新的 goroutine 中执行指定的函数。由于 goroutines 是并发执行的，它们可能会在同一时间访问和修改相同的变量。在这个例子中，i 是在 for 循环中定义的，如果直接在匿名函数中使用 i，会导致竞态条件，因为 i 的值在 goroutines 中可能会被不同的 goroutines 修改。
通过将 i 作为参数传递给匿名函数，确保每个 goroutine 都使用了 for 循环中当前迭代的 i 值的副本，而不是共享相同的 i 变量。这有助于避免竞态条件和确保正确的结果。
所以，i 在后面是为了确保在 go 关键字创建的 goroutine 中使用当前迭代的 i 的正确副本。
             

竞态条件（Race Condition）是指在多线程或多进程的程序中，由于执行顺序不确定性导致的程序行为异常的情况。竞态条件发生在多个线程或进程同时访问共享资源，并且其中至少一个是写操作时。
竞态条件的发生通常需要满足以下几个条件：
并发访问： 两个或多个线程（或进程）同时访问相同的共享资源。
至少一个写操作： 其中至少有一个线程执行写操作，修改共享资源的状态。
无同步机制： 缺乏适当的同步机制，导致多个线程之间的执行顺序不确定。

以上代码在for循环结束后就会直接退出程序，说明这样做是有问题的，因为for循环完成的时间可能会小于完成连接所需要的时间 ，因此我们需要使用sync包中的waitgroup，这是一种控制并发的线程的安全的方法。

修改后的代码如下：

package main

import (
	"fmt"
	"net"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	for i := 1; i <= 1024; i++ {
		wg.Add(1)//递增计数器
		go func(j int) {
			defer wg.Done()
			address := fmt.Sprintf("scanme.nmap.org:%d", j)
			conn, err := net.Dial("tcp", address)
			if err != nil {
				return
			}
			conn.Close()
			fmt.Printf("%d open\n", j)
		}(i)
	}
	wg.Wait()
}

defer 是 Go 语言中的一个关键字，用于延迟（defer）函数或方法的执行，通常用于确保在函数执行结束时（无论是正常返回还是发生异常）执行一些清理操作。（个人理解就是，只有当函数执行结束之前执行的语句，也就是最后一个执行的语句）

这里可以简单了解一下defer和WaitGroup的用法，这里就不做详细解释。

以上代码还存在蛮多的问题比如：并发量太大，可能导致网络或系统限制、网络超时之后的操作等并没有给出。

因此代码可以进行进一步的优化：

使用goroutine池管理真正进行的并发工作

package main

import (
	"fmt"
	"sync"
)

func worker(ports chan int, wg *sync.WaitGroup) {
	for p := range ports {
		fmt.Println(p)
		wg.Done()
	}
}

func main() {
	ports := make(chan int, 100)
	var wg sync.WaitGroup
    //cap测量通道的容量大小
	for i := 0; i < cap(ports); i++ {
		go worker(ports, &wg)
	}
	for i := 1; i <= 1024; i++ {
		wg.Add(1)
		ports <- i
	}
	wg.Wait()
	close(ports)
}

综合上面的代码得到：

package main

import (
	"fmt"
	"net"
	"sort"
)

//测试连接并将可以连接的端口号传入results通道中
func worker(ports, results chan int) {
	for p := range ports {
		address := fmt.Sprintf("scanme.nmap.org:%d", p)
		conn, err := net.Dial("tcp", address)
		if err != nil {
			results <- 0//区分连接成功和不能连接的端口号
			continue
		}
		conn.Close()
		results <- p
	}
}

func main() {
    //说白了就是限制了通道的容量，减少并发的数量
	ports := make(chan int, 100)
	results := make(chan int)
	var openports []int

	for i := 0; i < cap(ports); i++ {
		go worker(ports, results)
	}//相对于上面的代码并发量直接少了10倍

	go func() {
		for i := 1; i <= 1024; i++ {
            //达到容量后就会阻塞通道，直到有值被取出
			ports <- i
		}
	}()

	for i := 0; i < 1024; i++ {
		port := <-results
        //将端口号取出存入切片中，目的是使用排序函数将端口号按顺序打印出来
		if port != 0 {
			openports = append(openports, port)
		}
	}

	close(ports)
	close(results)
	sort.Ints(openports)//使打印的端口号递增次序
	for _, port := range openports {
		fmt.Printf("%d open\n", port)
	}
}

results的作用还有确保指定扫描范围的端口全部完成，防止出现竞态条件。

扫描器解析端口字符串

package portformat

import (
	"errors"
	"strconv"
	"strings"
)

const (
	porterrmsg = "Invalid port specification"
)

func dashSplit(sp string, ports *[]int) error {
	//以-为分隔符进行分割，得到的结构以字符串的形式存入字符串切片中
	dp := strings.Split(sp, "-")
	if len(dp) != 2 {
		return errors.New(porterrmsg)
	}
	//将开始的端口号的形式从字符串转换为整型数
	start, err := strconv.Atoi(dp[0])
	if err != nil {
		return errors.New(porterrmsg)
	}
	end, err := strconv.Atoi(dp[1])
	if err != nil {
		return errors.New(porterrmsg)
	}
	//确保端口范围在有效范围里面
	if start > end || start < 1 || end > 65535 {
		return errors.New(porterrmsg)
	}
	for ; start <= end; start++ {
		*ports = append(*ports, start)
	}
	return nil
}

func convertAndAddPort(p string, ports *[]int) error {
	i, err := strconv.Atoi(p)
	if err != nil {
		return errors.New(porterrmsg)
	}
	if i < 1 || i > 65535 {
		return errors.New(porterrmsg)
	}
	*ports = append(*ports, i)
	return nil
}

// Parse turns a string of ports separated by '-' or ',' and returns a slice of Ints.
func Parse(s string) ([]int, error) {
	//创建一个空的整数切片，用于存储解析后的端口。
	ports := []int{}
	//如果字符串包含逗号和破折号，表示可能包含多个端口和端口范围。
	if strings.Contains(s, ",") && strings.Contains(s, "-") {
		sp := strings.Split(s, ",")
		for _, p := range sp {
			if strings.Contains(p, "-") {
				if err := dashSplit(p, &ports); err != nil {
					return ports, err
				}
			} else {
				if err := convertAndAddPort(p, &ports); err != nil {
					return ports, err
				}
			}
		}
	} else if strings.Contains(s, ",") {
		sp := strings.Split(s, ",")
		for _, p := range sp {
			convertAndAddPort(p, &ports)
		}
	} else if strings.Contains(s, "-") {
		if err := dashSplit(s, &ports); err != nil {
			return ports, err
		}
	} else {
		if err := convertAndAddPort(s, &ports); err != nil {
			return ports, err
		}
	}
	return ports, nil
}
//我觉得作者这里写的真的好！有可能不懂的地方留言给我，我看到消息给大家解答。

这个Go程序定义了一个名为portformat的包，提供了解析和格式化端口规范的功能。它包含一个名为Parse的函数，该函数接受一个表示端口规范的字符串，并返回一个包含解析后端口的整数切片。

2.4 构造TCP代理

Go语言的Net包基本上涵盖了TCP通信所需要的机制。

2.4.1 使用io.Reader 和io.Write

这里是重写了接口里面的read和write方法

package main

import (
	"fmt"
	"log"
	"os"
)

// FooReader defines an io.Reader to read from stdin.
type FooReader struct{}

// Read reads data from stdin.
func (fooReader *FooReader) Read(b []byte) (int, error) {
	fmt.Print("in > ")
	return os.Stdin.Read(b)
}

// FooWriter defines an io.Writer to write to Stdout.
type FooWriter struct{}

// Write writes data to Stdout.
func (fooWriter *FooWriter) Write(b []byte) (int, error) {
	fmt.Print("out> ")
	return os.Stdout.Write(b)
}

func main() {
	// Instantiate reader and writer.
	var (
		reader FooReader
		writer FooWriter
	)

	// Create buffer to hold input/output.
	input := make([]byte, 4096)

	// Use reader to read input.
	s, err := reader.Read(input)
	if err != nil {
		log.Fatalln("Unable to read data")
	}
	fmt.Printf("Read %d bytes from stdin\n", s)

	// Use writer to write output.
	s, err = writer.Write(input)
	if err != nil {
		log.Fatalln("Unable to write data")
	}
	fmt.Printf("Wrote %d bytes to stdout\n", s)
}

这个程序（说白了就是自定义类型实现该接口，然后根据自己的需要进行方法的重写，感觉可以和那个扫描器解析端口字符串集合起来一起使用，晚点试试，如果结合的较好的话我会发出来供大家一起讨论）应该不难理解，所以我就不详细给大家描述了，如果有问题百度或者留言给我。

package main

import (
	"fmt"
	"io"
	"log"
	"os"
)

// FooReader defines an io.Reader to read from stdin.
type FooReader struct{}

// Read reads data from stdin.
func (fooReader *FooReader) Read(b []byte) (int, error) {
	fmt.Print("in > ")
	return os.Stdin.Read(b)
}

// FooWriter defines an io.Writer to write to Stdout.
type FooWriter struct{}

// Write writes data to Stdout.
func (fooWriter *FooWriter) Write(b []byte) (int, error) {
	fmt.Print("out> ")
	return os.Stdout.Write(b)
}

func main() {
	// Instantiate reader and writer.
	var (
		reader FooReader
		writer FooWriter
	)
    //这里函数的调用是隐式的，是单个的调用先w->r
	if _, err := io.Copy(&writer, &reader); err != nil {
		log.Fatalln("Unable to read/write data")
	}
}
//简化
2.4.2 创建回显服务器
package main

import (
	"io"
	"log"
	"net"
)

// echo is a handler function that simply echoes received data.
func echo(conn net.Conn) {
	defer conn.Close()

	// Create a buffer to store received data.
	b := make([]byte, 512)
	for {
		// Receive data via conn.Read into a buffer.
		size, err := conn.Read(b[0:])
		if err != nil && err != io.EOF {
			log.Println("Unexpected error")
			break
		}

		if err == io.EOF && size == 0 {
			log.Println("Client disconnected")
			break
		}

		log.Printf("Received %d bytes: %s", size, string(b))

		// Send data via conn.Write.
		log.Println("Writing data")
		if _, err := conn.Write(b[0:size]); err != nil {
			log.Fatalln("Unable to write data")
		}
	}
}

func main() {
	// Bind to TCP port 20080 on all interfaces.
	listener, err := net.Listen("tcp", ":20080")
	if err != nil {
		log.Fatalln("Unable to bind to port")
	}
	log.Println("Listening on 0.0.0.0:20080")
	for {
		// Wait for connection. Create net.Conn on connection established.
        //等待连接
		conn, err := listener.Accept()
		log.Println("Received connection")
		if err != nil {
			log.Fatalln("Unable to accept connection")
		}
		// Handle the connection. Using goroutine for concurrency.
        //处理连接
		go echo(conn)
	}
}

给出一个简单的客户端

package main

import (
	"bufio"
	"fmt"
	"log"
	"net"
	"os"
)

func main() {
	// Connect to the server on TCP port 20080.
	conn, err := net.Dial("tcp", "127.0.0.1:20080")
	if err != nil {
		log.Fatalln("Unable to connect to the server")
	}
	defer conn.Close()

	// Create a scanner to read input from the user.
	scanner := bufio.NewScanner(os.Stdin)

	// Create a goroutine to read and display server responses.
	go func() {
		for {
			// Read server response.
			response := make([]byte, 512)
			size, err := conn.Read(response)
			if err != nil {
				log.Fatalln("Error reading from server:", err)
				return
			}
			fmt.Printf("Server says: %s\n", string(response[:size]))
		}
	}()

	// Read user input and send it to the server.
	for {
		fmt.Print("Enter text to send to the server: ")
		scanner.Scan()
		text := scanner.Text()

		// Send user input to the server.
		_, err := conn.Write([]byte(text))
		if err != nil {
			log.Fatalln("Error writing to server:", err)
			return
		}
	}
}

跑完你会发现，你输入的字符串和在服务端接收到的字符串会不匹配，初步猜测缓冲区的内容没有及时写出

2.4.3 创建带缓冲的监听器
package main

import (
	"bufio"
	"log"
	"net"
)

func echo(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	s, err := reader.ReadString('\n')
	if err != nil {
		log.Fatalln("Unable to read data")
	}
	log.Printf("Read %d bytes:%s", len(s), s)
	log.Println("Writing data")
	writer := bufio.NewWriter(conn)
	if _, err := writer.WriteString(s); err != nil {
		log.Fatalln("Unable to write data")
	}
	writer.Flush()
}

func main() {
	// Bind to TCP port 20080 on all interfaces.
	listener, err := net.Listen("tcp", ":20080")
	if err != nil {
		log.Fatalln("Unable to bind to port")
	}
	log.Println("Listening on 0.0.0.0:20080")
	for {
		// Wait for connection. Create net.Conn on connection established.
		conn, err := listener.Accept()
		log.Println("Received connection")
		if err != nil {
			log.Fatalln("Unable to accept connection")
		}
		// Handle the connection. Using goroutine for concurrency.
		go echo(conn)
	}
}

客户端

package main

import (
	"bufio"
	"fmt"
	"log"
	"net"
	"os"
)

func main() {
	// Connect to the server on TCP port 20080.
	conn, err := net.Dial("tcp", "127.0.0.1:20080")
	if err != nil {
		log.Fatalln("Unable to connect to the server")
	}
	defer conn.Close()

	// Create a scanner to read input from the user.
	scanner := bufio.NewScanner(os.Stdin)

	// Create a goroutine to read and display server responses.
	go func() {
		for {
			// Read server response.
			response, err := bufio.NewReader(conn).ReadString('\n')
			if err != nil {
				log.Fatalln("Error reading from server:", err)
				return
			}
			fmt.Printf("Server says: %s", response)
		}
	}()

	// Read user input and send it to the server.
	for {
		fmt.Print("Enter text to send to the server: ")
		scanner.Scan()
		text := scanner.Text()

		// Send user input to the server.
        //Fprintln使用其操作数的默认格式进行格式化，并写入w
		_, err := fmt.Fprintln(conn, text)
		if err != nil {
			log.Fatalln("Error writing to server:", err)
			return
		}
	}
}

对比2.4.2 和2.4.3 的客户端，两个客户端不能交换使用，因为服务端和客户端对conn的写入和读取方式不一样，建议统一，要么使用缓冲区，要么使用切片，不然会照成无法正常对数据读写的情况。

2.4.4 代理一个TCP客户端

这个示例我单独重写一个博客

newbie_______
关注
  • 14
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
go 端口转发 代理 --chatGPT
Fly_Sky
09-28 475
这个程序通过命令行参数接收本地端口和目标地址（包括目标主机和端口），然后创建一个本地监听器以接收传入的连接。每当有连接到达时，它将启动一个 goroutine 来处理数据传输，将本地端口的数据转发到目标地址上的端口，同时处理从远程到本地的数据传输。fmt.Printf("开始将本地端口 %s 转发到 %s\n", localPort, remoteAddr)fmt.Println("用法: ./portforward <本地端口> <目标地址:目标端口>")// 处理从远程到本地的数据传输。
分享一个go开发的端口转发工具-port-forward
风声的专栏
03-15 1641
port-forward Go语言开发的端口转发工具 for port data forward 官网地址： https://gitee.com/tavenli/port-forward 开发语言：GO 控制台框架：beego 数据库：sqlite3 最近更新 v1.3.5 发布，增加批量导入、批量添加规则 v1.3.3 发布，增加 一键开启所有转发 和 一键关闭所有转发 v1.3.2 发布，服务稳定性已经过长时间的验证 v1.3.1 发布，增加程序启动自动开启转发 v1.2.9_beta 发布，完善点
GO实现TCP端口转发
qq_37451250的博客
02-27 2737
1 . 导包 package main import ( "fmt" "net" "io" ) 2 . 全局变量 var ( dst_addr string="127.0.0.1:8900" //目标服务器地址 local_addr string="0.0.0.0:8901" //本地监听地址 ) 3 . 转发函数 func tcp_handle(tc...
go io.Copy 实现 端口转发 SSH 代理
shelutai的博客
08-26 646
go proxy,ssh
go实现tcp服务端口转发
qq_22335577的专栏
06-09 514
package main import ( "fmt" "log" "net" "os" "strconv" ) func main() { //源端口 argument1 := os.Args[1] log.Println( "需要变更的源端口为: %d",argument1) //目的端口 argument2 := os.Args[2] log.Println( "变更后的目的端口为: %d",argument2) .
浅谈Python黑帽子取代netcat
09-20
本篇文章通过一个小小实例给大家分析了Python黑帽子取代netcat的过程以及相关知识点，对此有兴趣的朋友可以学习下。
python黑帽子编程，部分实现的代码
03-22
python黑帽子编程，部分实现的代码
黑帽子Python英文版
03-28
本书是畅销书《Python 灰帽子—黑客与逆向工程师的 Python 编程之道》的姊妹篇，那本书一面市便占据计算机安全类书籍的头把交椅。本书由 Immunity 公司的高级安全研究员 Justin Seitz 精心撰写。作者根据自己在安全...
python黑帽子(英文)+pyhton灰帽子中文Pdf
03-30
python黑帽子(英文版)+pyhton灰帽子中文Pdf
Python黑帽子带源码
07-03
Python黑帽子带源码Python黑帽子带源码Python黑帽子带源码Python黑帽子带源码Python黑帽子带源码
Go-Go语言开发的端口转发工具forwardforportdata
08-14
forwardPort 端口转发/映射工具 forward for port data 编译： 配置好你的GO开发环境，推荐GO 1.7以上； 执行build.dat，会自动编译出linux和windows的执行程序
forwardPort Go语言开发的端口转发工具
04-14
Go语言开发的端口转发工具， 新版本已迁移至：http://git.oschina.net/tavenli/port-forward
用go实现Tcp转发
qq_45535340的博客
06-23 2085
Tcp 转发 网络代理，是一种特殊的网络服务，允许一个（一般为客户端）通过这个服务与另一个网络终端（一般为服务器）进行非直接的连接。例如：Nginx ,VPN 等 代码 // main.go package main import ( "fmt" "io" "net" ) var ( address string = "127.0.0.1:7490" ) func tcp_handle(tcpConn net.Conn) { remote_tcp, err := net.Dial("
GO tcp端口转发与映射
lishuangquan1987的博客
12-10 2106
TCP端口转发与映射核心代码： package main import ( "fmt" "log" "net" ) func main() { //源端口，目的端口 var fromport, toport int = 2222, 10000 fromaddr := fmt.Sprintf("127.0.0.1:%d", fromport) toaddr := fmt.Sprintf("127.0.0.1:%d", toport) fromlistener, err := net.Li
golang 实现tcp转发代理
JieLinDee的专栏
05-26 1万+
package main import ( "flag" "fmt" "io" "net" "os" "strings" "sync" ) var lock sync.Mutex var trueList []string var ip string var list string func main() { flag.StringVar(&ip, "l", ":9897",
GO语言实现TCP端口转发【代码】
苏南生的CSDN博客
05-13 2373
package main import ( "fmt" "log" "net" ) func main() { //源端口，目的端口 var fromport, toport int = 2222, 88 fromaddr := fmt.Sprintf("127.0.0.1:%d", fromport) toaddr := fmt.Sprintf("127.0.0.1:%d", ...
golang 超简单实现反向代理（nginx 端口转发 Proxy）
王能的小屋
12-16 5818
100行你就可以做到类似nginx带自动更新的端口转发功能 总共就2个文件，一个main（总行数128行），一个配置文件 main： 里面的json解析和log可以忽略 package main import ( "github.com/weimingjue/json" utils2 "goProxy/utils" "goService/utils" "io/ioutil"...
go语言实现dcv端口转发
wz122330的博客
06-27 556
go语言实现dcv端口转发环境及目标代码实现 环境及目标 环境 所有转发机器已经实现了端口和ip的转发。端口为默认端口。 参考https://blog.csdn.net/wz122330/article/details/91980227 代码实现 package app import ( "io/ioutil" "os" "os/exec" "path/filepath" "str...
内网端口转发及穿透
热门推荐
jsd2root的博客
03-07 2万+
最近尝试了一些内网端口的转发和内网穿透，现在一起总结一下。 0x01 正向和反向代理 正向代理中，proxy 和 client 同属一个 LAN，对 server 透明； 反向代理中，proxy 和 server 同属一个 LAN，对 client 透明。 实际上 proxy 在两种代理中做的事都是代为收发请求和响应，不过从结构上来看正好左右互换了下，所以把前者那种代理方式叫做正向代理，后...
python黑帽子第二版
最新发布
08-20
引用和的内容来自《黑帽Python第二版》这本书的第二章，主题是网络工程基础。在这一章中，作者介绍了TCP客户端/服务端和SSH与SSH隧道的相关内容。在TCP客户端/服务端部分，书中讲解了如何使用Python编写TCP客户端和服务端程序，以及如何进行简单的网络通信。而在SSH与SSH隧道部分，书中介绍了使用Paramiko库进行SSH连接和操作的方法，还提到了SSH隧道的概念和使用方法。通过这些内容，读者可以学习到如何使用Python<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [黑帽python第二版（Black Hat Python 2nd Edition）读书笔记 之 第二章 网络工程基础（1）TCP客户端/服务端...](https://blog.csdn.net/lipeixinglive/article/details/127079453)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [黑帽python第二版（Black Hat Python 2nd Edition）读书笔记 之 第二章 网络工程基础（3）SSH与SSH隧道](https://blog.csdn.net/lipeixinglive/article/details/127132402)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

newbie_______

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值