JsFu0k批量探测JS存在的敏感关键字

已于 2023-06-28 14:45:29 修改
阅读量174 收藏
点赞数
分类专栏： 网络爬虫 渗透工具编写 奇怪脚本 文章标签： javascript 前端 渗透测试 golang
于 2023-06-26 15:25:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19623861/article/details/131398288
版权

这是一个演示

GitHub地址：https://github.com/jumppppp/go/tree/master/htools/jsfu0k

输出窗口
在这里插入图片描述

输出的详细文件

在这里插入图片描述

以上演示的是全字匹配

这个自动化工具模仿人工在一个网页内进行寻找js中敏感信息

流程：

填写配置（输入批量域名） -》
选择模式 -》
爬取网站内连接 -》
判断后缀 -》
本域名下不同网页继续爬取（爬取深度自定义） -》
整体js链接 -》
保存到本地 -》
根据关键字进行搜索 -》
整理到输出和文档内

main.go

package main

import (
	"bufio"
	"fmt"
	"io"
	"jsfu0k/model"
	"net/url"
	"os"
	"strings"
	"time"
)

func main() {
	fmt.Printf("[1]模糊匹配\n[2]全字匹配\nSelect:")
	var keyy int
	_,err :=fmt.Scanf("%d\n",&keyy)
	if err != nil {
		fmt.Println("No=", err)
	}
	if keyy!=1||keyy!=2{
		keyy = 2
	}
	fmt.Println("You Select ",keyy)
	// 读取URL文件
	urls, err := readURLsFromFile("./config/urls.txt")
	if err != nil {
		fmt.Println("读取URL文件失败:", err)
	}
	
	// 获取当前日期作为数据库名称
	currentDate := time.Now().Format("2006-01-02")
	err = os.Mkdir("./out/"+currentDate, 0755)
	if err != nil {
		// fmt.Println("No=", err)
	}

	Ua:=&model.ReqTool_t{}
	Ua.UA,err = readUAsFromFile("./config/UA.txt")
	if err != nil {
		fmt.Println("读取UA文件失败:", err)
	}
	Keys,err:= readKeysFromFile("./config/Key.txt")
	if err != nil {
		
		fmt.Println("读取Key文件失败:", err)
	}

	// 创建表格
	for _, u := range urls {
		domain,Cdomain := DomainGet(u)
		DirPath:="./out/"+currentDate+"/"+domain
		err = os.Mkdir(DirPath, 0755)
		if err != nil {
			// fmt.Println("No=", err)
		}
		Ua.DirPath = DirPath
		Ua.MaxR = 2
		Ua.Domain = domain
		Ua.Cdomain = Cdomain
		Ua.AllUrls = make(map[string]bool)
		Ua.JsUrls = make(map[string]string)
		Ua.GoUrls = make(map[string]bool)
		Ua.KeyOut = make(map[string]map[string][]string)
		Ua.KeyOut[domain]= make(map[string][]string)
		for _,key:=range Keys{
			Ua.KeyOut[domain][key]= []string{}
		}
		Ua.CrawlURL(u,0)
		Ua.Wg.Wait()
		Ua.JS_Init()
		Ua.GetJsKey(keyy)
		Ua.ShowInfo()
	}
	fmt.Println("数据库和表格创建成功",urls)
}

// 从文件中读取URL列表
func readURLsFromFile(filename string) ([]string, error) {
	file, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	var urls []string
	reader := bufio.NewReader(file)
	for {
		line, err := reader.ReadString('\n')
		if err != nil && err != io.EOF {
			return nil, err
		}
		line = strings.TrimSpace(line)
		if line != "" {
			urls = append(urls, line)
		}
		if err == io.EOF {
			break
		}
	}

	return urls, nil
}
// 从文件中读取UA列表
func readUAsFromFile(filename string) ([]string, error) {
	file, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	var UAs []string
	reader := bufio.NewReader(file)
	for {
		line, err := reader.ReadString('\n')
		if err != nil && err != io.EOF {
			return nil, err
		}
		line = strings.TrimSpace(line)
		if line != "" {
			UAs = append(UAs, line)
		}
		if err == io.EOF {
			break
		}
	}

	return UAs, nil
}
// 从文件中读取Key列表
func readKeysFromFile(filename string) ([]string, error) {
	file, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	var Keys []string
	reader := bufio.NewReader(file)
	for {
		line, err := reader.ReadString('\n')
		if err != nil && err != io.EOF {
			return nil, err
		}
		line = strings.TrimSpace(line)
		if line != "" {
			Keys = append(Keys, line)
		}
		if err == io.EOF {
			break
		}
	}

	return Keys, nil
}
func DomainGet(u string)(domain string,Cdomain string){
	// 解析域名
	parsedURL, err := url.Parse(u)
	if err != nil {
		fmt.Println("解析域名失败:", err)
		return
	}

	// 获取主机名
	hostname := parsedURL.Hostname()

	// 分割主机名
	parts := strings.Split(hostname, ".")

	// 分解子域名和顶级域名
	Cdomain = strings.Join(parts[len(parts)-2:], ".")
	domain = strings.Join(parts[:len(parts)-2], ".")+"."+Cdomain


	// 输出结果
	fmt.Println("域名:", domain)
	fmt.Println("子域名:", Cdomain)
	return 
}

req.go

package model

import (
	"crypto/md5"
	"fmt"
	"io"
	"io/ioutil"
	"math/rand"
	"net/http"
	"net/url"
	"os"
	"path/filepath"
	"regexp"
	"strings"
	"sync"
	"time"
)
type ReqTool_t struct{
	UA []string
	Domain string
	Cdomain string
	DirPath string
	JsUrls map[string]string //url >> name
	AllUrls map[string]bool
	GoUrls map[string]bool
	MaxR int
	KeyOut map[string]map[string][]string // domain >> key >>{path1,path2}
	mutex   sync.Mutex
	Wg      sync.WaitGroup
}
// 提取链接的正则表达式
var linkRegex = regexp.MustCompile(`(?i)(?:href|src)=["']([^"']+)["']`)

func (this * ReqTool_t)CrawlURL(url string,MaxR int) {

	if MaxR > this.MaxR {
		return
	}
	// 加锁
	this.mutex.Lock()
	defer this.mutex.Unlock()
	
	// 检查是否已经访问过该链接
	if this.GoUrls[url] {
		return
	}

	// 标记该链接已访问
	this.GoUrls[url] = true

	// 创建一个 HTTP 客户端
	client := &http.Client{}
	// 创建一个 HTTP 请求
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		fmt.Println("创建请求失败:", err)
		return
	}
	// 设置随机数种子
	rand.Seed(time.Now().UnixNano())
	rUA := rand.Intn(len(this.UA))
	// 设置 User-Agent 头
	req.Header.Set("User-Agent", this.UA[rUA])
	rSleep := rand.Intn(5)+1
	delay := time.Duration(rSleep) * time.Second
	// 发送请求前进行延迟
	time.Sleep(delay)
	// 发送 HTTP 请求
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("发送请求失败:", err)
		return
	}
	defer resp.Body.Close()

	// 读取响应内容
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("读取响应内容失败:", err)
		return
	}
	// 获取响应状态码
	statusCode := resp.StatusCode


	fmt.Printf("<%d>%s\t[%d]\n", statusCode,url,MaxR)
	if statusCode == 200{
			MaxR +=1
			bodyString := string(body)
			// 使用正则表达式提取链接
			linksMap:= extractUniqueLinks(bodyString, resp.Request.URL)
			// 启动子协程前增加等待计数

			for key, value := range linksMap {
				this.AllUrls[key] = value
			}
			// 输出链接
			for key,_ := range linksMap {
				if key!=url{
					isGoflag := this.isGo(key)
					if isGoflag{
						this.Wg.Add(1)
						go func(url string) {
							// 在子协程执行完毕后减少等待计数
							defer this.Wg.Done()
		
							// 递归调用CrawlURL
							this.CrawlURL(url, MaxR+1)
						}(key)
					} else if strings.Contains(key, ".js") {
						this.JsUrls[key] = ""

					}
				}
			}
	}
}
func (this * ReqTool_t)JS_Init(){
	// 创建一个 HTTP 客户端
	client := &http.Client{}
	// 创建一个 HTTP 请求
	for key,value:=range this.JsUrls{
		value = MD5(key)
		this.JsUrls[key]=value
		req, err := http.NewRequest("GET", key, nil)
		if err != nil {
			fmt.Println("创建请求失败:", err)
			return
		}
		rSleep := rand.Intn(5)+1
		delay := time.Duration(rSleep) * time.Second
		// 发送请求前进行延迟
		time.Sleep(delay)
		// 发送 HTTP 请求
		resp, err := client.Do(req)
		if err != nil {
			fmt.Println("发送请求失败:", err)
			return
		}

	
		// 读取响应内容
		body, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			fmt.Println("读取响应内容失败:", err)
			return
		}
		resp.Body.Close()
		name:=this.DirPath+"/"+value+".js"
		var NewBody string 
		NewBody = fmt.Sprintf("\n\t\t[%s]\t\t\n\t\t<%s>\t\t\n\n",key,name)+string(body)

		err = ioutil.WriteFile(name, []byte(NewBody), 0644)
		if err != nil {
			fmt.Println("写入文件失败:", err)
			return
		}
		fmt.Printf("%s\t>>>\t%s\n",key,name)
	}
	
}
func MD5(str string) string {
	h := md5.New()
	io.WriteString(h, str)
	return fmt.Sprintf("%x", h.Sum(nil))
}
func (this * ReqTool_t)ShowInfo(){
	for domain,keys := range this.KeyOut{
		fmt.Printf("[+]%s\n",domain)
		for key,values := range keys{
			fmt.Printf("\t<%s>\t[%d]\n",key,len(values))
			for _,v:=range values{
				path:=this.findJSurl(v)
				fmt.Printf("\t\t%s\t<%s>\n",v,path)
			}
		}
	}
}
func (this * ReqTool_t)findJSurl(name string)(string){
	for url,value:= range this.JsUrls{
		if value+".js" == name{
			return url
		}
	}
	return ""
}
func (this * ReqTool_t)GetJsKey(Mod int){
	filey, err := os.OpenFile("./out/res.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Println("打开文件失败:", err)
		return
	}
	defer filey.Close()
	_, err = filey.WriteString(fmt.Sprintf("\n\t\t====%s====\t\t\n\n",this.Domain))
	if err != nil {
		fmt.Println("写入文件失败:", err)
		return
	}
	for key,_ := range this.KeyOut[this.Domain]{
		files, err := ioutil.ReadDir(this.DirPath)
		if err != nil {
			fmt.Println("No=",err)
		}
	
		// 遍历并打印文件名
		for _, file := range files {
			if !file.IsDir() {
				content, err := ioutil.ReadFile(filepath.Join(this.DirPath, file.Name()))
				if err != nil {
					fmt.Printf("Failed to read file: %s\n", file.Name())
					continue
				}
				// fmt.Printf("File: %s\n", file.Name())
				// fmt.Printf("Content: %s\n", content)
				var OutList []string
				switch Mod {
				case 1:
					OutList = SelectKey(key,string(content))
				case 2:
					OutList = FullSelectKey(key,string(content))
				default:
				}
				if len(OutList) != 0{
					this.KeyOut[this.Domain][key] = append(this.KeyOut[this.Domain][key],file.Name())
					for _,info:=range OutList{
						text1 := fmt.Sprintf("<%s>\t~%s~\t[%s]\n",key,info,this.DirPath+"/"+file.Name())
						_, err = filey.WriteString(text1)
						if err != nil {
							fmt.Println("写入文件失败:", err)
							return
						}
					}
				}
				
			}
		}
		
	}
	
}
func SelectKey(key string,content string)(outList []string){
	lowerStr := strings.ToLower(content)
	search := strings.ToLower(key)
	start := 0
	for {
		pos := strings.Index(lowerStr[start:], search)
		if pos == -1 {
			break
		}

		pos += start
		subStart := max(0, pos-20)
		subEnd := min(len(content), pos+20+len(search))
		start = pos + len(search)
		outList = append(outList,content[subStart:subEnd])
	}
	return 
}
func FullSelectKey(key string,content string)(outList []string){
	// 创建一个正则表达式来进行全词匹配
	re := regexp.MustCompile(`\b` + regexp.QuoteMeta(key) + `\b`)
	
	// 将句子和搜索词都转换为小写进行不区分大小写的搜索
	lowerStr := strings.ToLower(content)
	
	// 找到所有的匹配项
	matches := re.FindAllStringIndex(lowerStr, -1)
	
	// 遍历每一个匹配项并输出它们
	for _, match := range matches {
		subStart := max(0, match[0]-20)
		subEnd := min(len(content), match[1]+20)
		outList = append(outList,content[subStart:subEnd])
	}
	return
}
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}
// 提取并去重链接函数
func extractUniqueLinks(text string, baseURL *url.URL) map[string]bool {
	matches := linkRegex.FindAllStringSubmatch(text, -1)
	linksMap := make(map[string]bool)
	for _, match := range matches {
		absURL, err := joinURL(baseURL, match[1])
		if err != nil {
			// fmt.Println("拼接URL失败:", err,baseURL,match[1])
			continue
		}
		if strings.HasPrefix(absURL, "http://") || strings.HasPrefix(absURL, "https://"){
			linksMap[absURL] = true
		}

	}

	return linksMap
}

// 拼接URL函数
func joinURL(baseURL *url.URL, link string) (string, error) {
	linkURL, err := url.PathUnescape(link)
	if err != nil {
		return "", err
	}

	parsedLinkURL, err := url.Parse(linkURL)
	if err != nil {
		return "", err
	}

	absURL := baseURL.ResolveReference(parsedLinkURL).String()
	return absURL, nil
}

// 检查链接是否符合子域名规则
func (this * ReqTool_t)isGo(url string) bool {
	a1 := strings.Contains(url, this.Domain)
	a0 := []string {".gif",".png",".jpg",".js",".ico",".css",".jepg",".swf"}
	a2 := true
	for _,Ni:=range a0{
		if strings.Contains(url,Ni){
			a2 = false
		}
	}
	if a2 && a1{
		return true
	}else{
		return false
	}
}

本项目还在开发过程中，正在探测可能存在的bug，如有问题可以联系我

我重来不说话
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
一维位置敏感探测器位置准确度和线性度的改进
02-12
在常规的条状一维位置敏感探测器(PSD)中,光敏区和位置电阻区是结合在一起的,器件的欧姆接触电极难以做得比较理想,因此器件的位置准确度和线性度也受到了不利的影响。而在梳状一维位置敏感探测器中,光敏区和位置电阻区被分成了梳齿区和梳脊区两部分,并且位置电阻区被设计成很窄的长条,即使掺杂浓度比较高,位置电阻也能做得相当大。这样条状一维位置敏感探测器接触电极上的缺陷就可消除。用两种不同的一维位置敏感探测器所测量的位置特性曲线证实了理论分析的正确性。测量结果还表明,梳状一维位置敏感探测器的位置准确度和线性度比条状一维位置敏感探测器有了显著的提高,梳状一维位置敏感探测器的平均位置误差从条状一维位置敏感探测器的55 μm减小到了26 μm,梳状一维位置敏感探测器的均方根非线性度从条状一维位置敏感探测器的0.94%减小到了0.09%。
JSFinder—从js文件中寻找敏感接口和子域名
qq_50854662的博客
10-02 380
说在前面 在渗透测试及漏洞挖掘过程中，信息搜集是一个非常重要的步骤。而在网站的JS文件中，会存在各种对测试有帮助的内容。 比如：敏感接口，子域名等。 社区内的文章也有有些关于JS文件提取信息的片段，比如Brupsuite和LinkFinder结合的方式，但还是有些问题：不能提取子域名，是相对URL，没那么方便等等。 于是我写了一个工具 - JSFinder。能够根据一个URL自动的收集JS，并在其中发现提取URL和子域名。毕竟，信息搜集的方式，自然是越多越好。 项目地址：https:/.
关于.js文件敏感信息泄露
qq_38914940的博客
11-08 1438
js文件是一种脚本，可以控制页面达到一些动态效果（控制页面行为的）javascript(.js)文件存储客户端代码手动：查看源代码，在HTML中查找“.js”，新端点（路径/子域名）新参数隐藏的功能，在网络应用程序上不可用，但该功能的代码存在，仅限高级版？你可以与他进行非高级交互吗？（越权）api键开发人员评论（例如 // 这是一个开发评论或 /* 这是一个多行开发评论 */）有时可以包含诸如代码何时发布或发生的任何更新之类的信息（比如开发人员会注释关于 XSS 过滤，这有助于我了解他们如何修复它并绕过）。
JS文件中的敏感信息+swagger接口测试
yggcwhat
11-07 2850
JS文件中的敏感信息+swagger接口测试
前端 JavaScript
qq_42740465的博客
12-01 867
前端 JavaScript
vue中检测敏感词，锚点
weixin_30663391的博客
07-10 535
当发布文章的时候，标题有敏感词 则检测有敏感词的接口成功的时候，写锚点 eg: _this .$alert("检测到标题有敏感词，请修改后再发布", "提示", { cancelButtonText: "取消", confirmButtonText: "确定", showCancelButton: false, customClass: "applySucce...
js敏感词检测、替换、过滤
weixin_45146319的博客
07-16 2053
很多人因为找不到更多的敏感词，自己一个个添加敏感词的写又太麻烦，所以我在去年去网站爬了一点敏感词下来，敏感词类包括了 f罪、z治、b力、s情、x腥、r骂等。因考虑到词库记录不完整，为了方便使用者后续自行添加，打算不进行压缩。效果：输入一个字符串和替换字符，检测该字符串是否存在敏感词，存在则用替换词替换掉敏感词，返回新的字符串。效果：输入一个字符串，检测该字符串是否存在敏感词，返回Boolean。
js过滤检测敏感词汇
weixin_34319111的博客
06-20 1026
html: <textarea rows="10" cols="100" id="myDiv"></textarea> <button id="getFile" onclick="yz()">校验文字</button> 　　 js: //禁止多次请求 let stRs=sessionStorage.getItem('stR...
简易照明线路探测仪（K 题）
08-08
简易照明线路探测仪（K 题）
邮箱探测器_smtp探测器,经典smtp探测邮箱密码批量深探助手
06-12
邮箱探测器，弱密码本设置，批量导入探测，自动保存，探测成功发送进邮件箱
 基于位置敏感探测器的微位移测量关键电路设计
01-30
位置敏感探测器PSD（Position Sensitive Detector PSD）具有位置分辨精度高（可达1～2 μm）、输出实时性好（响应时间约几微秒）、系统简洁的特点，在位置探测及相关领域内获得了广泛的应用；但PSD的输出信号小，易...
JS实现探测网站链接的方法【测试可用】
10-21
主要介绍了JS实现探测网站链接的方法,通过网站返回错误响应触发onerror时间来判断网站链接的可用性，非常简便实用,需要的朋友可以参考下
【工具】Js敏感信息扫描器
信安是不可或缺的一部分！
04-09 2063
在做JS漏洞挖掘的时候，发现很多工具不是太好用，在信息收集的时间花费很多，自己就像写一个JS信息收集的工具，使用python开发了一个简单的收集工具，其中仿照JSFinder工具的功能，做了信息针对性优化，先做了一个测试版的工具，此工具带有GUI的界面，欢迎交流。在开发时采用tkinter开发的GUI界面，可以探测网站上的 JavaScript 文件，并检查它们是否包含敏感信息。该应用程序使用 requests、threading、tkinter、BeautifulSoup 和 selenium 等库实现。
vue快速入门（五十）重定向
最新发布
不起眼小菜菜的博客
05-03 369
注释很详细，直接上代码……
bpmn-js推荐几款常用的插件
飞云先生
04-30 157
bpmn-js整体框架库的风格是以组件的方式进行实现的，这样的结构也更加便于我们更好的对其进行功能扩展，以及客制化功能实现。其实bpmn.io已经为我们实现了较多场景的组件的实现，了解对应组件的功能更能便于我们区分是否需要自己实现，降低重复造轮子的行为，提高开发效率，本篇文章主要是介绍常见的bpmn-js中使用的组件库。
遍历JavaScript对象（字典）
weixin_45596561的博客
05-01 352
遍历JavaScript对象（字典）是编程中常见的需求。for...in循环提供了最直接的方式，但在某些情况下可能需要额外的检查。与forEach结合使用提供了另一种遍历方式，特别是在您使用现代JavaScript版本时。根据您的具体需求和偏好，可以选择最适合您的遍历方法。
表格隔行变色
weixin_54339833的博客
05-02 410
2.$(document).ready() 是 jQuery 中的一个函数，它确保在文档结构（DOM）加载完成后执行指定的代码。与原生 JavaScript 的 window.onload 不同，$(document).ready() 会在 HTML 文档结构被加载和解析完成后立即执行，而无需等待样式表、图片和子框架的完成加载。if (index % 2 === 0) { // 偶数行。if (i % 2 === 0) { // 偶数行。// 可以省略，因为默认背景色通常是白色。
pinia
u013195452的专栏
04-30 384
pinia: 2.0.11. npm install [email protected]采用去中心化的架构，每个模块拥有自己的状态、mutations和actions，而Vuex采用集中式的架构，将所有的状态存储在一个单一的全局状态树中，通过mutations和actions来修改和处理状态。 类型支持。Pinia从设计之初就对TypeScript提供了原生的支持，提供了更好的类型推导和类型检查的支持，而Vuex需要使用额外的插件来实现TypeScript支持。Pinia在性能上进行了一些优化，采用
设散列表的地址区间为0~17，散列函数为H(K) =K mod 13，K为关键字。用线性探测法
03-26
来解决散列冲突，其中插入的关键字序列为{16, 25, 20, 36, 14, 23, 8, 18}，请画出插入后的散列表。 首先，根据散列函数H(K) =K mod 13，我们可以算出每个关键字的散列地址： - 16 -> H(16) = 3 - 25 -> H(25) = 12 - 20 -> H(20) = 7 - 36 -> H(36) = 10 - 14 -> H(14) = 1 - 23 -> H(23) = 10（冲突） - 8 -> H(8) = 8 - 18 -> H(18) = 5 发现23和36的散列地址相同，因此需要使用线性探测法来处理冲突。具体来说，就是从冲突地址开始，依次往后查找下一个空闲位置，直到找到可以插入的位置。在这个例子中，我们可以按照以下步骤来插入关键字： - 16 -> 3 -> 空 -> 空 -> 16 - 25 -> 12 -> 空 -> 空 -> 25 - 20 -> 7 -> 空 -> 空 -> 20 - 36 -> 10 -> 空 -> 空 -> 36 - 14 -> 1 -> 空 -> 空 -> 14 - 23 -> 10 -> 空 -> 1 -> 23 - 8 -> 8 -> 空 -> 空 -> 8 - 18 -> 5 -> 空 -> 空 -> 18 最终的散列表如下图所示： ``` +----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+ | 16 | | | 25 | | | 20 | 36 | | 14 | 23 | 8 | 18 | | | | | | +----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ``` 注意，在线性探测法中，如果散列表已经被占满，插入新的关键字将失败。因此，在设计散列表时，需要考虑预留一定的空间，以免发生这种情况。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我重来不说话

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

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

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

打赏作者

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

抵扣说明：

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

余额充值