Rehtt's Blog

【NFC】恢复被写入cpu卡SAK的CUID魔术卡

Sun, 10 May 2026 04:12:00 GMT

0x00#

不小心将cpu卡的uid及特征写入了Gen2 CUID魔术卡，导致魔术卡不能被设备正常识别 cpu卡的SAK通常为0x20或0x60，一般读卡器识别是cpu卡后要求卡要回复ATS，而CUID/M1 的魔术卡回复不了ATS，导致读卡握手失败因为握手失败，所以常规的写卡手段都会卡在第一步报错读取不到卡因此恢复方法是让写卡器忽略掉检测ATS这一步

0x01#

使用变色龙cli处理：

1
hw connent
2
# 关键的一步，跳过ATS检测
3
hf 14a config --rats skip
4
# 跳过后一般检测就正常了
5
hf 14a scan
6

7
# 向0区块写入正常M1 1K的数据
8
hf mf wrbl --blk 0 -a -k FFFFFFFFFFFF -d 11223344440804006263646566676869
9
# 切换到正常模式
10
hf 14a config --std
11
# 再次读取
12
hf 14a scan
13

14
# 如果A密钥失败，就写入B密钥
15
hf 14a config --rats skip
16
hf mf wrbl --blk 0 -b -k FFFFFFFFFFFF -d 11223344440804006263646566676869
17
hf 14a config --std
18
hf 14a scan

展开收起

如果是Gen1A卡，可以试试Gen1A后门

1
hf 14a config --rats skip
2
hf 14a raw -b 7 -d 40 -k
3
hf 14a raw -d 43 -k
4
hf 14a raw -d A000 -c -k
5
hf 14a raw -d 11223344440804006263646566676869 -c
6
hf 14a config --std
7
hf 14a scan

【脚本】在jetson nano上使用摄像头分段录像并开启端口推流

Thu, 08 Jan 2026 06:53:00 GMT

可设置录像保留天数、分段时间、分辨率、码率

1
#!/usr/bin/env python3
2
import sys
3
import os
4
import time
5
import datetime
6
import threading
7
import glob
8
import gi
9
import signal
10

11
gi.require_version("Gst", "1.0")
12
from gi.repository import Gst, GLib, GObject
13

14
# ================= 配置 =================
15
CONFIG = {
16
    # 保存位置
17
    "save_dir": "/home/r/Videos/cctv",
18
    # 分段时长
19
    "segment_duration_ns": 60 * 1_000_000_000,  # 60s
20
    # 保留天数
21
    "retention_days": 7,
22
    # 剩余空间低于多少自动删除前面的录像
23
    "free_space_threshold": 50 * 1024 * 1024,  # 50MB
24
    # 端口
25
    "stream_port": 5000,
26
    # 摄像头地址
27
    "usb_device": "/dev/video0",
28
    # 分辨率
29
    "width": 1280,
30
    "height": 720,
31
    # 平均码率
32
    "bitrate": 2000000,
33
    # 峰值码率
34
    "peak-bitrate": 4000000,
35
}
36
# =======================================
37

38

39
class JetsonDVR:
40
    def __init__(self):
41
        # 初始化 GStreamer
42
        Gst.init(None)
43

44
        self.mainloop = GLib.MainLoop()
45
        os.makedirs(CONFIG["save_dir"], exist_ok=True)
46

47
        # 清理线程
48
        self.cleanup_thread = threading.Thread(target=self.cleanup_loop, daemon=True)
49
        self.cleanup_thread.start()
50

51
        self.pipeline = self.create_pipeline()
52

53
        # 监听总线消息
54
        bus = self.pipeline.get_bus()
55
        bus.add_signal_watch()
56
        bus.connect("message", self.on_message)
57

58
        # 优雅退出的信号处理
59
        signal.signal(signal.SIGINT, self.handle_sigint)
60
        signal.signal(signal.SIGTERM, self.handle_sigint)
61

62
    def create_pipeline(self):
63
        print(f"[*] 初始化管道... 设备: {CONFIG['usb_device']}")
64

65
        source = (
66
            f"v4l2src device={CONFIG['usb_device']} ! "
67
            f"image/jpeg, width={CONFIG['width']}, height={CONFIG['height']}, framerate=30/1 ! "
68
            "jpegdec ! "
69
            "nvvidconv ! "
70
            "video/x-raw(memory:NVMM), format=I420"
71
        )
72

73
        #        encoder = (
74
        #            f" ! nvv4l2h264enc maxperf-enable=1 insert-sps-pps=1 bitrate={CONFIG['bitrate']} ! "
75
        #            "h264parse ! tee name=t"
76
        #        )
77

78
        # 使用 h265
79
        encoder = (
80
            " ! nvv4l2h265enc maxperf-enable=1 insert-sps-pps=1 "
81
            f"control-rate=1 bitrate={CONFIG['bitrate']} peak-bitrate={CONFIG['peak-bitrate']} ! "
82
            "video/x-h265,stream-format=byte-stream ! "
83
            "h265parse ! tee name=t"
84
        )
85

86
        record_branch = (
87
            f" t. ! queue ! "
88
            f"splitmuxsink name=sink "
89
            f"max-size-time={CONFIG['segment_duration_ns']} "
90
            f"muxer=mp4mux async-handling=true"
91
        )
92

93
        # Streaming Branch (推流):
94
        stream_branch = (
95
            f" t. ! queue leaky=1 ! "
96
            f"matroskamux streamable=true ! "
97
            f"tcpserversink host=0.0.0.0 port={CONFIG['stream_port']} "
98
            f"recover-policy=keyframe sync-method=latest-keyframe"
99
        )
100

101
        pipeline_str = source + encoder + record_branch + stream_branch
102

103
        print("-" * 60)
104
        print("GStreamer Pipeline String:")
105
        print(pipeline_str)
106
        print("-" * 60)
107

108
        try:
109
            pipeline = Gst.parse_launch(pipeline_str)
110
        except Exception as e:
111
            print("[!] 管道构建失败:", e)
112
            sys.exit(1)
113

114
        sink = pipeline.get_by_name("sink")
115
        if sink:
116
            sink.connect("format-location", self.on_format_location)
117
        else:
118
            print("[!] 警告: 找不到 splitmuxsink")
119

120
        return pipeline
121

122
    def on_format_location(self, splitmux, fragment_id):
123
        now = datetime.datetime.now()
124
        filename = now.strftime("%Y%m%d-%H%M%S.mp4")
125
        return os.path.join(CONFIG["save_dir"], filename)
126

127
    def cleanup_loop(self):
128
        retention_sec = CONFIG["retention_days"] * 24 * 3600
129
        while True:
130
            try:
131
                now = time.time()
132
                for f in glob.glob(os.path.join(CONFIG["save_dir"], "*.mp4")):
133
                    if os.path.isfile(f):
134
                        delete = False
135
                        if now - os.path.getmtime(f) > retention_sec:
136
                            delete = True
137
                        elif CONFIG["free_space_threshold"] > 0:
138
                            s_info = os.statvfs(CONFIG["save_dir"])
139
                            free_space = s_info.f_bsize * s_info.f_bavail
140
                            if free_space < CONFIG["free_space_threshold"]:
141
                                delete = True
142
                        if delete:
143
                            os.remove(f)
144
                            print(f"[-] 删除过期录像: {os.path.basename(f)}")
145
            except Exception as e:
146
                print("[!] 清理线程错误:", e)
147
            time.sleep(3600)
148

149
    def on_message(self, bus, message):
150
        mtype = message.type
151
        if mtype == Gst.MessageType.ERROR:
152
            err, debug = message.parse_error()
153
            print("[!] Pipeline Error:", err)
154
            if debug:
155
                print("[!] Debug Info:", debug)
156
            self.quit()
157
        elif mtype == Gst.MessageType.EOS:
158
            print("[*] End of Stream")
159
            self.quit()
160

161
    def handle_sigint(self, sig, frame):
162
        print("\n[*] 接收到中断信号，正在停止...")
163
        self.quit()
164

165
    def quit(self):
166
        if self.mainloop.is_running():
167
            self.mainloop.quit()
168

169
    def run(self):
170
        print("[*] 启动 DVR 系统...")
171
        self.pipeline.set_state(Gst.State.PLAYING)
172
        try:
173
            self.mainloop.run()
174
        except KeyboardInterrupt:
175
            pass
176
        finally:
177
            self.stop_pipeline()
178

179
    def stop_pipeline(self):
180
        print("[*] 发送 EOS 并停止管道...")
181
        # 发送 EOS 以正确结束录像文件（防止 MP4 损坏）
182
        self.pipeline.send_event(Gst.Event.new_eos())
183
        # 给一点时间让 EOS 传播
184
        time.sleep(1)
185
        self.pipeline.set_state(Gst.State.NULL)
186
        print("[*] 已退出")
187

188

189
if __name__ == "__main__":
190
    dvr = JetsonDVR()
191
    dvr.run()

展开收起

【杂项】ssh隐匿登录

Wed, 13 Aug 2025 03:32:23 GMT

0x01 清除 Bash 命令历史记录#

为防止命令行操作被记录，可在登录后立即禁用 Bash 的历史功能：

Terminal window

1
unset HISTORY HISTFILE HISTSAVE HISTLOG HISTZONE HISTORY HISTLOG
2
export HISTFILE=/dev/null
3
export HISTSIZE=0
4
export HISTFILESIZE=0

说明：#

unset 命令用于清除可能影响历史记录的环境变量。
HISTFILE=/dev/null 将命令历史文件重定向至空设备，确保所有输入命令不会写入磁盘。
HISTSIZE=0 和 HISTFILESIZE=0 分别禁用内存中的历史命令缓存和文件中的持久化存储。

建议：该配置可临时生效。若需永久禁用，可将相关设置写入用户的 shell 配置文件（如 .bashrc 或 .profile），但应谨慎操作，避免影响正常运维。

0x02 隐藏登录 IP 地址#

系统命令 last 读取 /var/log/lastlog 文件显示用户登录记录。此文件为二进制格式，无法直接编辑。以下是两种处理方式：

方法一：删除 lastlog 文件#

Terminal window

1
sudo rm /var/log/lastlog

注意事项：#

删除该文件会清除所有用户的最近登录记录。
部分系统在重启或执行某些认证操作时会自动重建该文件。
此类操作可能触发日志完整性检测机制，引起管理员注意。
不建议在生产环境中随意删除系统日志文件，尤其是未经审计许可的操作。

方法二：通过 SSH 端口转发隐藏真实 IP#

使用本地端口转发建立代理连接：

Terminal window

1
ssh -N -L 2212:<目标主机IP>:22 root@<目标主机>

随后通过本地端口连接目标系统：

Terminal window

1
ssh -p 2212 root@127.0.0.1

原理：#

该命令将本地的 2212 端口映射到目标主机的 22 端口。
登录时，系统记录的来源 IP 是 127.0.0.1，即本地回环地址，而非你的真实公网 IP。
last 或 who 命令显示的将是隧道末端的地址，从而实现一定程度的身份隐藏。

补充说明：若目标系统启用了 PAM 审计模块或 auditd 等内核级审计工具，仍有可能记录原始连接信息。此方法仅适用于基础日志规避。

0x03 清理认证日志（auth.log）#

认证相关的登录行为通常记录在 /var/log/auth.log（Debian/Ubuntu 系统）或 /var/log/secure（RHEL/CentOS 系统）中。可通过以下方式移除特定 IP 的记录。

删除包含指定 IP 的日志行：#

Terminal window

1
sudo sed -i '/192\.168\.1\.1/d' /var/log/auth.log

注意：IP 地址中的点号需用反斜杠转义，否则会被当作正则表达式中的通配符处理。

替代方法：使用 grep 过滤并重写文件#

Terminal window

1
sudo grep -v '192.168.1.100' /var/log/auth.log > /tmp/auth.log
2
sudo mv /tmp/auth.log /var/log/auth.log

对于使用 systemd 的系统：#

还需清理 journald 的内存日志：

Terminal window

1
sudo journalctl --vacuum-time=1d

该命令会删除超过一天的日志条目，释放存储空间。

提醒：

修改认证日志属于高风险行为，容易被入侵检测系统（IDS）、安全信息与事件管理系统（SIEM）识别。

现代安全架构普遍采用集中式日志收集（如 ELK、Splunk、rsyslog 转发等），即使本地日志被清除，远程日志服务器仍可能保留副本。

任何日志篡改行为在未经授权的情况下均可能违反法律法规。

0x04 清除 wtmp 与 btmp 登录记录#

Linux 系统中还有两个重要的二进制日志文件用于记录登录活动：

/var/log/wtmp：记录所有成功登录和登出的事件，last 命令读取此文件。
/var/log/btmp：记录失败的登录尝试，lastb 命令可查看其内容。

由于这两个文件为二进制格式，不能使用文本编辑器直接修改。

清空日志文件：#

推荐使用 truncate 命令将文件大小置零：

Terminal window

1
sudo truncate -s 0 /var/log/wtmp
2
sudo truncate -s 0 /var/log/btmp

替代方式（谨慎使用）：#

也可删除后创建新的空文件，并恢复正确权限：

Terminal window

1
sudo rm /var/log/wtmp
2
sudo touch /var/log/wtmp
3
sudo chmod 644 /var/log/wtmp

对 btmp 文件操作类似。

提示：truncate 是更安全的选择，避免因删除文件导致某些服务无法写入日志。

0x05 隐藏进程痕迹#

运行扫描工具、反弹 shell 或提权程序时，进程名可能出现在 ps、top 等监控命令输出中，暴露操作行为。

检测当前进程：#

Terminal window

1
ps aux | grep python
2
top -b -n 1 | grep <your-tool>

隐藏进程名称：#

利用 exec 系统调用覆盖当前进程名：

Terminal window

1
exec -a "sshd" /path/to/your-tool

执行后，该进程在 ps 输出中将显示为 sshd，具有一定迷惑性。

说明：这种方法仅修改进程的“显示名称”（argv[0]），不会改变实际的可执行文件路径或内存映像。高级监控工具（如 auditd、EDR 软件）仍可通过系统调用追踪其真实行为。

0x06 结语#

本文介绍的技术主要用于理解系统日志机制和攻击者可能采取的规避手段，帮助系统管理员加强日志保护与入侵检测能力。需要强调的是：

所有日志清理操作都应仅在授权测试环境或合法合规前提下进行。
在真实生产系统中篡改或删除日志，不仅可能破坏系统稳定性，还可能触犯法律。
强烈建议部署集中式日志审计、文件完整性监控（FIM）和实时告警机制，以防范未授权访问和痕迹清除行为。

了解攻击，是为了更好地防御。安全的本质，始终是攻防之间的持续博弈。

【Golang】xlsx.row to struct slice

Tue, 13 May 2025 01:10:00 GMT

0x00#

之前业务中解析xlsx表格总是用手动写数组下标的方式，这种方式一来繁琐二来容易出错，特别是表头多的时候排查起来也很麻烦。所以就自己写一个将xlsx转为struct的模块，感觉用struct比数组更直观

代码#

1
import (
2
  "errors"
3
  "reflect"
4
  "strconv"
5
  "strings"
6
  "time"
7

8
  "github.com/gogf/gf/v2/os/gtime"
9
  "github.com/tealeg/xlsx"
10
)
11

12
type FieldTagOption struct {
13
  boolMap    map[string]bool // boolmap:是-true,否-false,真-true,假-false
14
  timeformat string          // timeformat:2006-01-02 15:04:05
15
}
16

17
func ParseXlsxStruct(rows []*xlsx.Row, data any) error {
18
  rdata := reflect.ValueOf(data)
19
  if rdata.Kind() != reflect.Ptr {
20
    return errors.New("data must be &[]*struct/&[]struct")
21
  }
22
  rdata = rdata.Elem()
23
  if rdata.Type().Kind() != reflect.Slice {
24
    return errors.New("data must be &[]*struct/&[]struct")
25
  }
26
  dataElemType := rdata.Type().Elem()
27
  var isPrt bool
28
  if dataElemType.Kind() == reflect.Ptr {
29
    dataElemType = dataElemType.Elem()
30
    isPrt = true
31
  }
32
  if dataElemType.Kind() != reflect.Struct {
33
    return errors.New("data must be &[]*struct/&[]struct")
34
  }
35

36
  dataElemTypeOptions := make(map[int]*FieldTagOption)
37
  for i := 0; i < dataElemType.NumField(); i++ {
38
    dataElemTypeOptions[i] = &FieldTagOption{}
39
    for _, tag := range strings.Split(dataElemType.Field(i).Tag.Get("xlsx"), ";") {
40
      s := strings.SplitN(tag, ":", 2)
41
      switch s[0] {
42
      case "timeformat":
43
        dataElemTypeOptions[i].timeformat = s[1]
44
      case "boolmap":
45
        for _, v := range strings.Split(s[1], ",") {
46
          if dataElemTypeOptions[i].boolMap == nil {
47
            dataElemTypeOptions[i].boolMap = make(map[string]bool)
48
          }
49
          b := strings.Split(v, "-")
50
          if len(b) != 2 {
51
            return errors.New("boolmap tag value must be like true-false,true-true,false-false,false-false")
52
          }
53
          bb, err := strconv.ParseBool(b[1])
54
          if err != nil {
55
            return errors.New("boolmap tag value must be like true-false,true-true,false-false,false-false")
56
          }
57
          dataElemTypeOptions[i].boolMap[b[0]] = bb
58
        }
59
      }
60
    }
61
  }
62

63
  tmp := reflect.MakeSlice(reflect.SliceOf(rdata.Type().Elem()), 0, len(rows))
64
  for _, r := range rows {
65
    var elemPtr, elemVal reflect.Value
66
    if isPrt {
67
      elemPtr = reflect.New(dataElemType)
68
      elemVal = elemPtr.Elem()
69
    } else {
70
      elemVal = reflect.New(dataElemType).Elem()
71
    }
72
    for i, v := range r.Cells {
73
      if i >= dataElemType.NumField() {
74
        break
75
      }
76
      f := elemVal.Field(i)
77
      if !f.CanSet() {
78
        continue
79
      }
80

81
      txt, _ := v.FormattedValue()
82
      switch f.Kind() {
83
      case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
84
        if n, err := strconv.ParseInt(txt, 10, 64); err == nil {
85
          f.SetInt(n)
86
        }
87
      case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
88
        if n, err := strconv.ParseUint(txt, 10, 64); err == nil {
89
          f.SetUint(n)
90
        }
91
      case reflect.Float32, reflect.Float64:
92
        if f64, err := strconv.ParseFloat(txt, 64); err == nil {
93
          f.SetFloat(f64)
94
        }
95
      case reflect.Bool:
96
        if dataElemTypeOptions[i].boolMap != nil {
97
          f.SetBool(dataElemTypeOptions[i].boolMap[txt])
98
        } else {
99
          if b, err := strconv.ParseBool(txt); err == nil {
100
            f.SetBool(b)
101
          }
102
        }
103
      case reflect.String:
104
        f.SetString(txt)
105
      default:
106
        switch f.Interface().(type) {
107
        case *gtime.Time:
108
          t := gtime.NewFromStr(txt)
109
          if dataElemTypeOptions[i].timeformat != "" {
110
            t = gtime.NewFromStrLayout(txt, dataElemTypeOptions[i].timeformat)
111
          }
112
          f.Set(reflect.ValueOf(t))
113
        case time.Time:
114
          t := gtime.NewFromStr(txt)
115
          if dataElemTypeOptions[i].timeformat != "" {
116
            t = gtime.NewFromStrLayout(txt, dataElemTypeOptions[i].timeformat)
117
          }
118
          f.Set(reflect.ValueOf(t.Time))
119
        case *time.Time:
120
          t := gtime.NewFromStr(txt)
121
          if dataElemTypeOptions[i].timeformat != "" {
122
            t = gtime.NewFromStrLayout(txt, dataElemTypeOptions[i].timeformat)
123
          }
124
          f.Set(reflect.ValueOf(&t.Time))
125
        }
126
      }
127
    }
128
    if isPrt {
129
      tmp = reflect.Append(tmp, elemPtr)
130
    } else {
131
      tmp = reflect.Append(tmp, elemVal)
132
    }
133
  }
134
  rdata.Set(tmp)
135
  return nil
136
}

展开收起

测试用例#

1
import (
2
  "errors"
3
  "reflect"
4
  "testing"
5
  "time"
6

7
  "github.com/gogf/gf/v2/os/gtime"
8
  "github.com/tealeg/xlsx"
9
)
10

11
func newRow(sheet *xlsx.Sheet, vals ...string) *xlsx.Row {
12
  r := sheet.AddRow()
13
  for _, v := range vals {
14
    cell := r.AddCell()
15
    cell.SetString(v)
16
  }
17
  return r
18
}
19

20
type Person struct {
21
  Name  string
22
  Age   int
23
  GTime *gtime.Time `xlsx:"timeformat:20060102"`
24
  Time  time.Time
25
  PTime *time.Time
26
  Bool  bool `xlsx:"boolmap:是-true,否-false"`
27
}
28

29
func TestParseXlsxStruct_Basic(t *testing.T) {
30
  // 准备 2 行数据
31
  file := xlsx.NewFile()
32
  sh, _ := file.AddSheet("Sheet1")
33
  _ = newRow(sh, "Alice", "30", "20250405", "2025-01-01", "2022-01-01 12:14:15", "是")
34
  _ = newRow(sh, "Bob", "25", "20250102")
35

36
  var got []Person
37
  if err := ParseXlsxStruct(sh.Rows, &got); err != nil {
38
    t.Fatalf("unexpected error: %v", err)
39
  }
40

41
  p := gtime.NewFromStr("2022-01-01 12:14:15")
42
  want := []Person{
43
    {Name: "Alice", Age: 30, GTime: gtime.NewFromStrLayout("20250405", "20060102"), Time: gtime.New("2025-01-01").Time, PTime: &p.Time, Bool: true},
44
    {Name: "Bob", Age: 25, GTime: gtime.NewFromStrLayout("20250102", "20060102")},
45
  }
46
  if !reflect.DeepEqual(got, want) {
47
    t.Fatalf("mismatch\nwant: %+v\ngot : %+v", want, got)
48
  }
49
}
50

51
func TestParseXlsxStruct_PtrSlice(t *testing.T) {
52
  file := xlsx.NewFile()
53
  sh, _ := file.AddSheet("Sheet1")
54
  _ = newRow(sh, "Cat", "7")
55

56
  var got []*Person
57
  if err := ParseXlsxStruct(sh.Rows, &got); err != nil {
58
    t.Fatalf("unexpected error: %v", err)
59
  }
60
  if len(got) != 1 || got[0].Name != "Cat" || got[0].Age != 7 {
61
    t.Fatalf("unexpected result: %+v", got)
62
  }
63
}
64

65
func TestParseXlsxStruct_NotPointer(t *testing.T) {
66
  file := xlsx.NewFile()
67
  sh, _ := file.AddSheet("Sheet1")
68
  _ = newRow(sh, "Dog", "3")
69

70
  var wrong []Person
71
  // 直接传切片而不是 *切片，应报错
72
  err := ParseXlsxStruct(sh.Rows, wrong)
73
  if err == nil {
74
    t.Fatal("expected error, got nil")
75
  }
76
}
77

78
func TestParseXlsxStruct_ElemNotStruct(t *testing.T) {
79
  file := xlsx.NewFile()
80
  sh, _ := file.AddSheet("Sheet1")
81
  _ = newRow(sh, "1", "2")
82

83
  var wrong []int
84
  err := ParseXlsxStruct(sh.Rows, &wrong)
85
  if !errors.Is(err, errors.New("slice element must be struct or *struct")) {
86
    // 只要报错即可；不必精确判定同一个 error 实例
87
    if err == nil {
88
      t.Fatal("expected error, got nil")
89
    }
90
  }
91
}
92

93
func TestParseXlsxStruct_ExtraColumnsIgnored(t *testing.T) {
94
  file := xlsx.NewFile()
95
  sh, _ := file.AddSheet("Sheet1")
96
  // 第 3 列将被忽略
97
  _ = newRow(sh, "Eve", "40", "ignored")
98

99
  var got []Person
100
  if err := ParseXlsxStruct(sh.Rows, &got); err != nil {
101
    t.Fatalf("unexpected error: %v", err)
102
  }
103
  if got[0].Name != "Eve" || got[0].Age != 40 {
104
    t.Fatalf("unexpected result: %+v", got[0])
105
  }
106
}

展开收起

【杂项】tmpfs

Wed, 25 Sep 2024 14:26:01 GMT

blog-tmpfs#

0x00#

tmpfs是一种临时文件系统，物理位置位于内存或交换分区中。读写文件的速度远远快于硬盘的速度（未使用交换分区时），但因为物理位置位于内存或交换分区，当机器重启时就会丢失数据。因为高速且重启自动删除数据，因此适合用来存储临时文件，例如一些编程语言的临时编译文件，在一些linux发行版中会将/tmp挂载为tmpfs（使用df /tmp命令可以查看）。tmpfs可以灵活调整大小，且实际占用大小也是根据存储的数据大小动态分配的。假如创建了4G大小的tmpfs分区，并往里面写入1G大小的文件，这时实际占用内存大小为1G而不是4G

tmpfs衍生于ramfs，ramfs是完全位使用物理内存的文件系统，但是ramfs没有处理内存不足的情况会影响整个系统。而tmpfs会在物理内存不足时使用交换分区中的空间，但又因为交换分区一般都是挂载在硬盘上，因此当使用交换分区时性能与硬盘普通文件系统没有差别。

0x01#

Linux挂载tmpfs#

使用命令

Terminal window

1
# 将tmpfs挂载在/mnt/tmpfs上，并限定大小为4G
2
# 如果不指定size将会自动调整为实际内存大小的一半
3
sudo mount -o size=4G tmpfs /mnt/tmpfs
4

5
# 将大小调整为1G
6
sudo mount -o remount,size=1G tmpfs /mnt/tmpfs

MacOS挂载#

在网上搜索MacOS上使用tmpfs时，显示的结果都是使用ramdisk文件系统，而ramdisk就没有tmpfs那么灵活，并且占用内存是创建时固定分配的。在一筹莫展时，在终端里输入mount并按了两次tab键，在提示框中显示有mount_tmpfs选项，这说明在MacOS中也可以使用tmpfs文件系统

Terminal window

1
# 将/Volumes/tmpfs_dir挂载为tmpfs
2
sudo mount_tmpfs -s 4G /Volumes/tmpfs_dir

【杂项】常用正则匹配备忘（持续更新）

Fri, 31 May 2024 08:20:43 GMT

找出没有包含“数值”的句子#

1
^(?!数值).*&

解释：

^ 表示行的开始。
(?=.*数值) 是正向前瞻，表示任意位置包含“数值”
(?!.*数值) 是负向前瞻，表示任意位置不包含“数值”
.* 匹配任意字符（除换行符外）
$ 表示行的结束 (?!abc)与[^abc]的区别： [^abc]匹配任何不是 a、b 或 c 的单个字符 (?!abc)匹配不是abc这个”词语”

【杂项】搜集各种好用的库(不定时更新)

Wed, 27 Mar 2024 01:08:00 GMT

Golang#

kardianos/service - 将golang程序作为服务运行 [📕]
go-survey/survey - 用于构建交互式和可访问的提示，并完全支持windows和posix终端。[📕]
go-toast/toast - windows通知 [📕]
getlantern/systray - 托盘 [📕]
lxn/win - windows api封装 [📕]
lxn/walk - windows gui [📕]
jroimartin/gocui - 漂亮的cli gui库 [📕]
jesseduffield/lazygit - 使用了gocui的git gui客户端 [📕]
SagerNet/sing-box - 通用代理平台
jmorganca/ollama - 在本地启动并运行 Llama 2 和其他大型语言模型
flyteorg/flyte - 可扩展且灵活的工作流协调平台，可无缝统一数据、ML 和分析堆栈
AdguardTeam/AdGuardHome - 全网广告和跟踪器拦截 DNS 服务器
argoproj/argo-cd - Kubernetes 的声明式持续部署
avelino/awesome-go - 超赞 Go 框架、库和软件的精选列表 [集合]
sundowndev/phoneinfoga - 电话号码信息收集框架
msteinert/pam - PAM api
go-delve/delve - 类似pprof的调试工具，可以调试运行中的程序
alist-org/alist - 一个支持多存储的文件列表/WebDAV程序，使用 Gin 和 Solidjs
shenghui0779/api-tpl-go - 🔥 轻量好用的 Go API 项目框架 🚀🚀🚀 [📕]
ginuerzh/gost - GO语言实现的安全隧道
usememos/memos - 开源轻量级在线笔记
zzl/go-win32api - win32 api 封装 [📕]
casdoor/casdoor - 基于 OAuth 2.0 / OIDC 的 UI 优先集中认证 / 单点登录 (SSO) 平台

前端#

baidu/amis - 前端低代码框架，通过 JSON 配置就能生成各种页面
youzan/vant - 一个轻量级的、可定制的Vue UI库，用于移动web应用程序

Windows Shell#

https://github.com/lukesampson/psutils - powershell 实用脚本（常用：sudo.ps1）

Android#

LAMDA - 安卓抓包/逆向/HOOK & 云手机/远程桌面/自动化辅助框架
DisplayToggle - 关闭屏幕而不是熄屏

Python#

Ciphey - 使用自然语言处理和人工智能以及一些全自动解密/解码/破解工具
immich - 自建照片视频库

杂项#

typst - 类Markdown语法，可以输出类似word的效果
dbcli/mycli - 基于Python的MySQL/MariaDB/Percona的命令行client，自动补全非常好用
reqable - 抓包工具，界面直观
0dayCTF/reverse-shell-generator - 反弹shell
dockur/windows - 在docker里跑windows

Gorm1.25.7 同时使用joins与preload获取列表报错 reflect: call of reflect.Value.Field on slice Value

Mon, 04 Mar 2024 03:13:00 GMT

参考issues: 6834

触发错误#

当join与preload是同一个表时会触发错误，例如：

1
var a []A
2
db.where("type = 2").Joins("A").Preload("A.B").Find(&a)

触发错误：reflect: call of reflect.Value.Field on slice Value

触发原因#

源码 preload.go<124>

1
reflectValue := rel.Field.ReflectValueOf(db.Statement.Context, db.Statement.ReflectValue)

使用rel.Field.ReflectValueOf获取db.Statement.ReflectValue对象field，但是前面Find(&a)是一个slice类型，因此会导致映射错误

解决办法（2024-03-04）#

在go.mod 将 gorm 回滚至 1.25.6

【linux】目录

Mon, 19 Feb 2024 02:09:40 GMT

0x00#

发现自己以及周围的人关于linux的目录结构和作用还不怎么清楚，因此查了一些资料并记录下来

0x01#

首先更正一点， /usr 目录很多人认为是user的意思，而usr是Unix System Resource的缩写，是系统级目录

/usr/bin 为系统预装的一些可执行程序，所有用户都可用，随系统升级会改变 /usr/sbin 存放超级用户才能使用的应用程序 /usr/local为用户级目录，用户可以将自己编译的程序放在该目录的bin下

/bin 存放所有用户皆可用的系统程序，系统启动或者系统修复时可用 /sbin 存放超级用户才能使用的系统程序

好用的工具

Thu, 04 Jan 2024 01:49:00 GMT

Linux#

CLI工具#

speedometer 显示网卡接口出入流量速度#

Terminal window

1
apt install speedometer
2
speedometer -r eth0 -t eth0

btop/bashtop/bpytop 比htop更全面更炫酷的资源显示#

其中bashtop是第一个版本，使用bash实现 bpytop 是第二个迭代版本，使用python实现 btop++ 是第三个迭代版本，使用c++实现，但是功能相对bpytop少

Terminal window

1
apt install btop
2
apt install bashtop
3
apt install bpytop

s-tui CPU温度显示#

Terminal window

1
apt install s-tui
2
或
3
pip install s-tui

macchanger 更改mac地址#

Terminal window

1
apt install macchanger
2

3
macchanger -s eth0 # 显示当前mac
4
macchanger -r eth0 # 随机生成mac
5
macchanger -m XX:XX:XX:XX:XX:XX eth0 # 指定mac
6
macchanger -e eth0 # 生成同品牌mac地址
7
macchanger -a eth0 # 生成不同厂家同一类型mac地址
8
macchanger -A eth0 # 生成不同厂家不同类型mac地址
9
macchanger -l # 品牌列表

【备忘】nvimdots安装及配置（持续更新）

Thu, 23 Nov 2023 00:41:21 GMT

0x00#

nvim即neovim，对vim架构进行了大调整，并可以使用lua进行编写插件和配置，nvim集成了LSP 尽管nvim 已经集成了很多功能，但对于新手和不愿意折腾的人来说还是太麻烦了，于是就有了nvimdots，nvimdots是一个集成nvim常用功能和插件的开源项目，就好比oh-my-zsh与zsh的关系一样

0x01 准备#

尽管 nvimdots 有安装脚本，但是还是有一些依赖需要手动安装 nvimdots wiki 里有相关的教程，按照教程基本没问题

不过nvim还是需要手动安装，截至目前nvim建议安装0.9版本 nvim wiki有相关教程

0x02 安装#

因为安装时大部分插件是从github上下载的，因此国内用户需要自备梯子，并在安装时将梯子设为全局代理，否则大概率会安装失败

linux安装

Terminal window

1
if command -v curl >/dev/null 2>&1; then
2
    bash -c "$(curl -fsSL https://raw.githubusercontent.com/ayamir/nvimdots/HEAD/scripts/install.sh)"
3
else
4
    bash -c "$(wget -O- https://raw.githubusercontent.com/ayamir/nvimdots/HEAD/scripts/install.sh)"
5
fi

windows安装

Terminal window

1
Set-ExecutionPolicy Bypass -Scope Process -Force; Invoke-Expression ((New-Object System.Net.WebClient).DownloadString('https://raw.githubusercontent.com/ayamir/nvimdots/HEAD/scripts/install.ps1'))

0x03 配置#

进入nvim使用:Mason管理LSP，过打开文件后使用:LspInstall可以安装或查看对应的LSP

clangd的默认filetype中包含proto文件类型，但是在非C/C++项目中使用proto文件会一直提示报错，虽然没什么影响但是很碍眼，而clangd又是默认安装的还卸载不掉，卸载后又会自动安装。因此使用的办法是修改clangd的配置文件，使其不对proto文件做出反应。默认的clangd中的filetype是"c", "cpp", "objc", "objcpp", "cuda", "proto"

clangd.lua 因此我们需要删除proto

Terminal window

1
nvim ~/.config/nvim/lua/modules/configs/completion/servers/clangd.lua

在require("lspconfig").clangd.setup({...})的里面加入

1
filetypes = { "c", "cpp", "objc", "objcpp", "cuda" },

【Linux】使用Go开发PAM模块

Fri, 20 Oct 2023 15:17:12 GMT

0x0 前言#

PAM (Pluggable Authentication Modules) 系统的一部分，它是一个用于 Linux 系统认证的模块化框架。

如果给 ssh 登录添加 TOTP 验证一般会用到 google-authenticator 模块，这个模块就是实现和使用 PAM API 实现的。

PAM 不光可以在 ssh 登录时使用在其他大多数需要验证的时候也可以使用，甚至可以在自己程序中调用，总之 PAM 是一个非常好用的系统认证框架。

本篇文章将使用 Go 实现相关功能，而 PAM 的接口是用 C 语言实现的。因此将会使用 Go 的 CGO 进行编译，并且会尽量减少 C 语言的部分。

0x1 准备#

因为 PAM 是 Linux 系统的认证框架，所以在 Linux 上开发最方便

首先安装依赖库： Debian/Ubuntu

Terminal window

1
apt install libpam0g-dev

Centos

Terminal window

1
yum install pam-devel

安装后 include 文件在 /usr/include/security/ 目录下

0x2 开发 PAM 认证模块#

首先在 Go 中引入 C 的库， Go 是在 import "C" 上方使用注释的方式引入 C 的内容

注意 import "C" 上方不能有空行

#cgo LDFLAGS: -lpam 是 CGO 的命令，LDFLAGS: -lpam 是表示链接 PAM 静态库

typedef const char cchar_t; 是将 cchar_t 自定义为 const char 关键字，因为后面讲 C 转写成 GO 的时候 const xx 无法转写，因此需要提前定义一个关键字

#include "pam_prompt_wrapper.h" 是引入一个本地自定义的库，后面会后详解

1
/*
2
#cgo LDFLAGS: -lpam
3
#include <stdio.h>
4
#include <stdlib.h>
5
#include <security/pam_appl.h>
6
#include <security/pam_modules.h>
7
#include <security/pam_ext.h>
8
#include "pam_prompt_wrapper.h"
9
typedef const char cchar_t;
10
*/
11
import "C"

函数说明#

pam_sm_authenticate是认证逻辑的接口函数，也是认证的核心，函数定义在pam_modules.h里

接口函数是需要开发人员自己实现的函数，在函数内可以实现各种自定义的功能

函数签名为

1
int pam_sm_authenticate(pam_handle_t *pamh, int flags,
2
                        int argc, const char **argv);

使用 Go 实现，因为这个函数是要被外部调用的，因此需要在上方添加 //export 的注释，CGO 转写成 C 的时候会转成 extern 关键字

1
//export pam_sm_authenticate
2
func pam_sm_authenticate(pamh *C.pam_handle_t, flags C.int, argc C.int, argv **C.cchar_t) C.int {
3
  return C.PAM_SUCCESS
4
}

pam_sm_acct_mgmt是用户识别管理接口函数，用户判断用户否有权限，ssh登录中需要，函数定义也在pam_modules.h里，函数签名为

1
int pam_sm_acct_mgmt(pam_handle_t *pamh, int flags, int argc,
2
                                const char **argv);

使用 Go 实现

1
//export pam_sm_acct_mgmt
2
func pam_sm_acct_mgmt(pamh *C.pam_handle_t, flags C.int, argc C.int, argv **C.cchar_t) C.int {
3
  return C.PAM_SUCCESS
4
}

pam_prompt是认证过程中用于交互的函数，改函数直接调用，函数定义在 pam_ext.h 中，函数签名为

1
extern int PAM_FORMAT((printf, 4, 5)) PAM_NONNULL((1,4))
2
pam_prompt (pam_handle_t *pamh, int style, char **response,
3
      const char *fmt, ...);

注意该函数中带有 ... 表示可以接受可变参数，而 CGO 中则不支持调用可变参数函数。因此需要使用 C 将该函数简单包装成一个固定参数的函数

1
int pam_prompt_wrapper (pam_handle_t *pamh, int style, char **response,const char *str) {
2
  return pam_prompt(pamh, style, response, "%s", str)
3
}

并且该函数要额外使用 C 文件存储，并在 Go 中引入

代码文件#

pam_prompt_wrapper.h

1
#include <security/pam_appl.h>
2

3
int pam_prompt_wrapper(pam_handle_t *pamh, int style, char **response, const char *str);

pam_prompt_wrapper.c

1
#include <security/pam_appl.h>
2
#include <security/pam_ext.h>
3
#include <security/pam_modules.h>
4
#include <stdarg.h>
5

6
int pam_prompt_wrapper(pam_handle_t *pamh, int style, char **response, const char *str) {
7
    return pam_prompt(pamh, style, response, "%s", fmt);
8
}

main.go

1
package main
2

3
/*
4
#cgo LDFLAGS: -lpam
5
#include <stdio.h>
6
#include <stdlib.h>
7
#include <security/pam_appl.h>
8
#include <security/pam_modules.h>
9
#include <security/pam_ext.h>
10
#include "pam_prompt_wrapper.h"
11
typedef const char cchar_t;
12
*/
13
import "C"
14

15
import (
16
    "fmt"
17
    "os"
18
    "unsafe"
19
)
20

21
//export pam_sm_authenticate
22
func pam_sm_authenticate(pamh *C.pam_handle_t, flags C.int, argc C.int, argv **C.cchar_t) C.int {
23
    // 实现认证功能
24

25
    // 例如：
26
    // 认证时会显示 input >
27
    // 输入 123 后认证成功，否则失败
28
    a, _ := qa(pamh, false, "input >")
29
    if a == "123" {
30
        return C.PAM_SUCCESS
31
    }
32

33
    return C.PAM_AUTH_ERR
34
}
35

36
//export pam_sm_acct_mgmt
37
func pam_sm_acct_mgmt(pamh *C.pam_handle_t, flags C.int, argc C.int, argv **C.cchar_t) C.int {
38
    // 这里直接返回成功，也可以根据自己需求添加更多功能
39
    return C.PAM_SUCCESS
40
}
41

42
// 简单封装了交互函数
43
func qa(pamh *C.pam_handle_t, echo bool, query string) (string, C.int) {
44
    var f C.int
45
    f = C.PAM_PROMPT_ECHO_OFF
46
    if echo {
47
        f = C.PAM_PROMPT_ECHO_ON
48
    }
49
    input := C.CString("")
50
    defer C.free(unsafe.Pointer(input))
51
    prompt := C.CString(query)
52
    defer C.free(unsafe.Pointer(prompt))
53
    code := C.pam_prompt_wrapper(pamh, f, &input, prompt)
54
    return C.GoString(input), code
55
}
56

57
func main() {
58
}

展开收起

编译#

需要将 Go 编译成 C 的共享库

Terminal window

1
go build -buildmode=c-shared -o pam_example.so

0x3 使用#

需要将模块放置到指定目录

Terminal window

1
sudo cp pam_example.so /lib/x86_64-linux-gnu/security

然后启动，这里展示在 ssh 登录验证中使用我们的模块

首先编辑 /etc/ssh/sshd_config ，修改 ChallengeResponseAuthentication 或 KbdInteractiveAuthentication 选项的值将其设为 yes

重启 sshd 服务 sudo service sshd restart

编辑 /etc/pam.d/sshd ，在文件添加 auth required pam_example.so

【Linux】使用cryptsetup进行luks加密

Tue, 19 Sep 2023 09:38:00 GMT

0x00#

LUKS （Linux Unified Key Setup）是 Linux 硬盘加密的标准。通过提供标准的磁盘格式，它不仅可以促进发行版之间的兼容性，还可以提供对多个用户密码的安全管理。与现有解决方案相比，LUKS 将所有必要的设置信息存储在分区信息首部中，使用户能够无缝传输或迁移其数据。

0x01 准备#

Terminal window

1
sudo apt install cryptsetup

0x02 使用#

加密磁盘分区#

假设现在有磁盘分区 /dev/sdb2

格式化磁盘分区为luks

Terminal window

1
sudo cryptsetup luksFormat /dev/sdb2

输入大写YES 输入两次密码

这个时候会对磁盘分区进行全盘覆写，所以速度会比较慢

使用密钥文件（可选）：

Terminal window

1
dd if=/dev/random of=keyfile bs=1K count=16  # 创建一个16k密钥文件，count可以大一点
2
sudo cryptsetup luksAddKey /dev/sdb2 keyfile # 使用密钥文件加密

映射加密分区

映射加密分区到jmsdb2，实际上是将加密分区映射到linux逻辑分区/dev/mapper/jmsdb2中

Terminal window

1
sudo cryptsetup luksOpen /dev/sdb2 jmsdb2

格式化加密分区

之前在1中的格式化是将加密的物理分区格式化为luks，这个时候还需要对加密的逻辑分区格式化为常见的文件系统才可以使用

我这里示例选用ext4

Terminal window

1
sudo mkfs.ext4 /dev/mapper/jmsdb2

1
结构：
2
┌────────┐
3
│  luks  │
4
│┌──────┐│
5
││ ext4 ││
6
│└──────┘│
7
└────────┘

挂载分区

为了正常使用需要将逻辑分区挂载出来作为一个普通目录进行读写我这挂在到/mnt/jmsdb2

Terminal window

1
# sudo mkdir /mnt/jmsdb2 # 如果有创建/mnt/jmsdb2可以跳过这一步
2
sudo mount /dev/mapper/jmsdb2 /mnt/jmsdb2

至此可以正常在 /mnt/jmsdb2 写数据了

卸载分区

如果不想使用了可以对分区进行卸载

Terminal window

1
sudo umont /mnt/jmsdb2  # 卸载逻辑分区
2
sudo cryptsetup luksClose jmsdb2  #关闭加密分区

创建加密文件#

如果不想对整个分区加密，那可以在普通磁盘里创建一个加密文件，这样的好处是可以随意移动加密文件

Terminal window

1
dd if=/dev/zero of=/home/rehtt/cryptfile bs=1M count=1024

这里在/home/rehtt/下创建了一个名为cryptfile的文件，块大小(bs)为1M，共有(count)1024个块，也就是1024M

将上面的加密磁盘分区中的/dev/sdb2替换为/home/rehtt/cryptfile再跟着步骤即可

开机自动挂载#

首先要使用密钥加密（上述第1步）

编辑/etc/crypttab

1
# <target name> <source device>    <key file>      <options>
2
jmsdb2 /dev/sdb2 /home/rehtt/keyfile luks

编辑/etc/fstab

1
/dev/mapper/jmsdb2 /mnt/jmsdb2 ext4  0 0

【脚本】修改wireguard端口

Tue, 12 Sep 2023 09:03:27 GMT

1
#!/bin/bash
2
PORT=0
3
#判断当前端口是否被占用，没被占用返回0，反之1
4
function Listening {
5
   TCPListeningnum=`netstat -an | grep ":$1 " | awk '$1 == "tcp" && $NF == "LISTEN" {print $0}' | wc -l`
6
   UDPListeningnum=`netstat -an | grep ":$1 " | awk '$1 == "udp" && $NF == "0.0.0.0:*" {print $0}' | wc -l`
7
   (( Listeningnum = TCPListeningnum + UDPListeningnum ))
8
   if [ $Listeningnum == 0 ]; then
9
       echo "0"
10
   else
11
       echo "1"
12
   fi
13
}
14

15
#指定区间随机数
16
function random_range {
17
   shuf -i $1-$2 -n1
18
}
19

20
#得到随机端口
21
function get_random_port {
22
   templ=0
23
   while [ $PORT == 0 ]; do
24
       temp1=`random_range $1 $2`
25
       if [ `Listening $temp1` == 0 ] ; then
26
              PORT=$temp1
27
       fi
28
   done
29
}
30
get_random_port 9000 10000  # 9000 ~ 10000 端口
31
wg set wg0 listen-port $PORT

展开收起

【脚本】wireguard配合socat转发端口

Tue, 12 Sep 2023 09:01:11 GMT

0x0#

之前是使用iptables进行端口转发，但是iptables规则较为麻烦，所以就使用socat进行转发

0x1#

首先，在PostUp选项中启动socat时，将socat的进程ID（PID）保存到一个文件中。然后，在PostDown选项中读取该文件，并使用保存的PID来关闭socat进程。

示例：

1
[Interface]
2
PrivateKey = <PrivateKey>
3
Address = <IPAddress>
4
...
5

6
PostUp = /usr/bin/python3 /root/socat.py --range '10.13.13.0/24' add 8080 192.168.137.1:8000
7
# -d -d可以输出详细的调试信息
8
#PostUp = socat -d -d TCP-LISTEN:8080,range=10.13.13.0/24,fork,reuseaddr TCP:192.168.137.1:8000 & echo $! > /home/rehtt/8080_socat.pid
9

10
# 在停止 WireGuard 接口之后执行操作
11
PostDown = /usr/bin/python3 /root/socat.py --range '10.13.13.0/24' del 8080 192.168.137.1:8000
12
#PostDown = kill $(cat /home/rehtt/8080_socat.pid) && rm -f /home/rehtt/8080_socat.pid

在示例中，使用/home/rehtt/8080_socat.pid文件来存储socat进程的PID，并在PostUp选项中使用echo $!将其写入文件。然后，在PostDown选项中，我们使用kill $(cat /home/rehtt/8080_socat.pid)命令来杀死socat进程，并使用rm -f /home/rehtt/8080_socat.pid命令删除PID文件

使用封装好的脚本处理

脚本链接

【脚本】使用Python对socat简单的控制

Tue, 12 Sep 2023 08:11:00 GMT

Use#

Terminal window

1
python3 socat.py add 8080 192.168.137.1:8000
2

3
python3 socat.py del 8080 192.168.137.1:8000
4

5
python3 socat.py list
6

7
python3 socat.py -h

Code#

1
import argparse
2
import os
3
import re
4
import subprocess
5

6

7
def get_dict(d, key):
8
    if type(d) is not dict:
9
        raise Exception('not dict')
10
    dd = d.get(key)
11
    if dd is None:
12
        return ''
13
    return dd
14

15

16
def socat_port():
17
    output = subprocess.check_output("ps aux | grep socat", shell=True, universal_newlines=True)
18

19
    out = []
20
    for line in output.splitlines():
21
        match = re.compile(r'socat (\w+)-LISTEN:(\d+)').search(line)
22
        if not match:
23
            continue
24
        data = {
25
            'listen_protocol': match.group(1).upper(),
26
            'listen_port': match.group(2)
27
        }
28

29
        match = re.compile(r'(\w+):([^:]+):(\d+)$').search(line)
30
        if not match:
31
            continue
32
        data['remote_protocol'] = match.group(1).upper()
33
        data['remote_host'] = match.group(2)
34
        data['remote_port'] = match.group(3)
35

36
        match = re.compile(r'(\d+)').search(line)
37
        if not match:
38
            continue
39
        data['listen_pid'] = match.group(1)
40

41
        match = re.compile(r',range=([^,]+),').search(line)
42
        if match:
43
            data['listen_range'] = match.group(1)
44
        match = re.compile(r',bind=([^,]+),').search(line)
45
        if match:
46
            data['listen_bind'] = match.group(1)
47
        out.append(data)
48

49
    return out
50

51

52
if __name__ == '__main__':
53
    parser = argparse.ArgumentParser()
54
    parser.add_argument('-r', '--range', help='监听网段范围，例如：192.168.1.0/24')
55
    parser.add_argument('-b', '--bind', help='绑定监听地址，例如：192.168.1.1')
56
    parser.add_argument('-p', '--protocol', default='all', help='[all | tcp | udp]')
57
    parser.add_argument('positional', nargs='*',
58
                        help='<add | del | list> <本地端口> <远程地址>，例如：add 8000 192.168.1.2:8080')
59

60
    args = parser.parse_args()
61

62
    try:
63
        operation = args.positional[0]
64
        if operation != 'list':
65
            if len(args.positional) != 3:
66
                raise Exception()
67

68
            port = int(args.positional[1])
69
            raddr = args.positional[2]
70

71
            if not 0 < port < 1 << 16:
72
                print('端口不正确')
73
                exit(1)
74
    except:
75
        parser.print_usage()
76
        exit(1)
77

78
    if operation == 'add':
79
        command = 'socat {protocol}-LISTEN:{port},{option}fork,reuseaddr {protocol}:{raddr} &'
80
        option = ''
81
        if args.range is not None:
82
            option += 'range=%s,' % args.range
83
        if args.bind is not None:
84
            option += 'bind=%s,' % args.bind
85

86
        commands = []
87
        if args.protocol == 'all':
88
            commands.append({'protocol': 'TCP',
89
                             'command': command.format(protocol='TCP', port=port, option=option, raddr=raddr)})
90
            commands.append({'protocol': 'UDP',
91
                             'command': command.format(protocol='UDP', port=port, option=option, raddr=raddr)})
92
        elif args.protocol == 'tcp':
93
            commands.append({'protocol': 'TCP',
94
                             'command': command.format(protocol='TCP', port=port, option=option, raddr=raddr)})
95
        elif args.protocol == 'udp':
96
            commands.append({'protocol': 'UDP',
97
                             'command': command.format(protocol='UDP', port=port, option=option, raddr=raddr)})
98
        list = socat_port()
99
        for c in commands:
100
            bk = False
101
            for data in list:
102
                if data.get('listen_port') == str(c.get('port')) and data.get('listen_protocol') == c.get(
103
                        'protocol').upper():
104
                    bk = True
105
                    break
106
            if bk:
107
                print('{protocol} {port} 已被占用'.format(protocol=c.get('protocol'), port=c.get('port')))
108
                continue
109
            os.system(c.get('command'))
110
    elif operation == 'del':
111
        list = socat_port()
112
        command = 'kill %s'
113
        commands = []
114
        for data in list:
115
            if args.protocol != 'all' and data.get('listen_protocol') != args.protocol:
116
                continue
117
            if str(port) != data.get('listen_port'):
118
                continue
119
            commands.append(command % data.get('listen_pid'))
120

121
        for c in commands:
122
            os.system(c)
123
    elif operation == 'list':
124
        layout = '{listen_protocol}\t{listen_port}\t{listen_bind}\t{listen_range}\t{remote}'
125
        # print(layout.format(listen_protocol=''))
126
        for data in socat_port():
127
            print(layout.format(
128
                listen_protocol=get_dict(data, 'listen_protocol'),
129
                listen_port=get_dict(data, 'listen_port'),
130
                listen_bind=get_dict(data, 'listen_bind'),
131
                listen_range=get_dict(data, 'listen_range'),
132
                remote='%s:%s:%s' % (
133
                    get_dict(data, 'remote_protocol'), get_dict(data, 'remote_host'), get_dict(data, 'remote_port')),
134
            ))
135
    else:
136
        print('参数不正确')
137
        parser.print_usage()
138
        exit(1)

展开收起

【脚本】ADB调用摄像头拍照并处理图片

Thu, 29 Jun 2023 01:20:00 GMT

需安装：jpegoptim

1
#!/bin/bash
2

3
# 预处理目录
4
pre_dir=/mnt/sda/cam/pre
5
# 最终保存目录
6
dir=/mnt/sda/cam
7

8
mkdir $pre_dir 2&>1 > /dev/null
9
mkdir $dir 2&>1 > /dev/null
10

11
# 【可选】上报电池信息，用于自动化充电
12
# adb shell dumpsys battery | grep -E 'level|AC' |
13
#     sed ':a;N;s/\n/,/g;ta' - |
14
#     sed 's/AC powered/AC/g' - |
15
#     sed 's/ //g' - |
16
#     sed 's/,/,"/g' - |
17
#     sed 's/:/":/g' - |
18
#     sed 's/^|&/"/g' - |
19
#     sed 's/^/{"/g' - |
20
#     sed 's/$/}/g' - |
21
#     xargs -I value -o mosquitto_pub -t 'phone/battery/level' -h 192.168.31.110 -p 9883 -m 'value'
22

23

24
adb shell input keyevent 26
25
sleep 0.5
26
adb shell am start -a android.media.action.STILL_IMAGE_CAMERA
27
sleep 0.5
28
adb shell input tap 539 900
29
sleep 1
30
adb shell input keyevent 27
31
sleep 1
32
adb shell input keyevent 4
33
adb shell input keyevent 26
34

35
adb shell find /sdcard/DCIM/Camera -name "*.jpg" | xargs -o -I path adb pull path $pre_dir
36
adb shell rm /sdcard/DCIM/Camera/*
37

38
# 【可选】压缩图片，修改size可控制图片大小
39
find $pre_dir -name "*.jpg" | xargs jpegoptim --size=500k
40

41
mv $pre_dir/* $dir

展开收起

python3版本：

添加了对屏幕是否亮屏的检测

1
#!/bin/python3
2

3
import os
4
import re
5
import json
6
import time
7
adb_id = '192.168.31.129:5555'
8
pre_dir = '/mnt/sda/cam/pre/'
9
dir = '/mnt/sda/cam/'
10

11
try:
12
    os.mkdir(dir)
13
except:
14
    pass
15
try:
16
    os.mkdir(pre_dir)
17
except:
18
    pass
19

20

21
def cmd(command, display=True):
22
    if display:
23
        print(command)
24
    out = os.popen(command).read()
25
    if display:
26
        print(out)
27
    return out
28

29

30
def adb(shell, display=True):
31
    if not shell.startswith('adb'):
32
        shell = 'adb %s' % (shell)
33
    return cmd(shell.replace('adb', 'adb -s %s' % (adb_id)), display)
34

35

36
def is_screenState():
37
    return True if 'state=ON' in adb('shell dumpsys power | grep "Display Power: state="') else False
38

39

40
def open_screen():
41
    if not is_screenState():
42
        adb('shell input keyevent 26')
43

44

45
def close_screen():
46
    if is_screenState():
47
        adb('shell input keyevent 26')
48

49
# 发送电量数据
50

51

52
def send_power_status():
53
    info = adb('shell dumpsys battery', False)
54
    ac = True if re.compile(
55
        r'AC powered: ([^\n]+)').findall(info)[0] == 'true' else False
56
    level = int(re.compile(r'level: ([0-9]+)').findall(info)[0])
57
    j = json.dumps({"level": level, "AC": ac})
58
    os.popen(
59
        'mosquitto_pub -t \'phone/oppo/battery\' -h 192.168.31.110 -p 9883 -m \'%s\'' % (j))
60

61

62
send_power_status()
63
open_screen()
64
adb('shell am start -a android.media.action.STILL_IMAGE_CAMERA')
65
time.sleep(0.5)
66
adb('shell input tap 539 900')
67
time.sleep(1)
68
adb('shell input keyevent 27')
69
time.sleep(1)
70
adb('shell input keyevent 4')
71
close_screen()
72

73
for path in adb('adb shell find /sdcard/DCIM/Camera -name "*.jpg"').split('\n'):
74
    if path == '':
75
        continue
76
    adb('adb pull %s %s' % (path, pre_dir))
77
adb('adb shell rm /sdcard/DCIM/Camera/*')
78
for path in cmd('find %s -name "*.jpg"' % (pre_dir)).split('\n'):
79
    if path == '':
80
        continue
81
    cmd('jpegoptim --size=250k %s' % (path))
82
cmd('mv %s/* %s' % (pre_dir, dir))

展开收起

【Golang】反射

Wed, 14 Jun 2023 09:32:34 GMT

0x00#

程序正常编译时变量会被转换为内存地址，而变量名、类型信息等不会被编译进可执行部分。而使用反射（golang中使用reflect包）则会将这些信息编译进可执行文件（所以有时为了程序安全而不会使用反射）。

0x01 实例#

贴上一个经常用的xlsx文件转[]*struct代码

1
import (
2
  "errors"
3
  "github.com/tealeg/xlsx"
4
  "io"
5
  "net/http"
6
  "reflect"
7
)
8
// ParseXlsxToStruct
9
//
10
//   @Description: 解析xlsx到struct中
11
//   @param data  xlsx数据
12
//   @param out  目标struct
13
//   @param sheet 默认第一个sheet
14
//   @return error
15
//    ParseXlsxToStruct(data,&out)
16
func ParseXlsxToStruct(data []byte, out any, sheet ...string) error {
17
  value := reflect.ValueOf(out)
18
  if value.Type().Kind() != reflect.Ptr {
19
    return errors.New("必须以指针的方式传入")
20
  }
21
  value = value.Elem()
22
  if value.Type().Kind() != reflect.Slice {
23
    return errors.New("内部必须为struct切片")
24
  }
25
  if value.Len() != 0 {
26
    return errors.New("必须是空切片")
27
  }
28

29
  xfile, err := xlsx.OpenBinary(data)
30
  if err != nil {
31
    return err
32
  }
33
  if len(xfile.Sheets) == 0 {
34
    return errors.New("xlsx中没有sheet")
35
  }
36
  var sheets []*xlsx.Sheet
37
  if len(sheet) > 0 {
38
    sheets = make([]*xlsx.Sheet, 0, len(sheet))
39
    for _, v := range sheet {
40
      if s, ok := xfile.Sheet[v]; ok {
41
        sheets = append(sheets, s)
42
      }
43
    }
44
  } else {
45
    sheets = append(sheets, xfile.Sheets[0])
46
  }
47

48
  title := GetUniqueSheetsTitle(sheets)
49
  var tmp = make(map[string][]string, len(title))
50
  for _, s := range sheets {
51
    if len(s.Rows) == 0 {
52
      continue
53
    }
54
    title := GetSheetTitle(s)
55
    for i, row := range s.Rows {
56
      if i == 0 {
57
        continue
58
      }
59
      var dataMap = make(map[string]string)
60
      for j, cell := range row.Cells {
61
        if title[j] == "" {
62
          continue
63
        }
64
        dataMap[title[j]] = cell.String()
65
      }
66
      for _, t := range title {
67
        if t == "" {
68
          continue
69
        }
70
        tmp[t] = append(tmp[t], dataMap[t])
71
      }
72
    }
73
  }
74
  MapToStructByTag(tmp, out, "xlsx")
75
  return nil
76
}
77

78
func MapToStructByTag(data map[string][]string, in interface{}, tagKey string) {
79
  // 获取传入结构体切片的反射类型和值
80
  inValue := reflect.ValueOf(in).Elem()
81
  inType := inValue.Type().Elem()
82

83
  var l int
84
  for _, v := range data {
85
    if l < len(v) {
86
      l = len(v)
87
    }
88
  }
89
  //fmt.Println(inType)
90
  news := reflect.MakeSlice(inValue.Type(), l, l)
91
  defer func() {
92
    inValue.Set(news)
93
  }()
94

95
  for i := 0; i < news.Len(); i++ {
96
    structValue := news.Index(i)
97
    structType := inType
98
    // 获取结构体指针所指向的类型
99
    var prt bool
100
    var structValuePtr reflect.Value
101
    if structValue.Kind() == reflect.Ptr {
102
      structType = structType.Elem()
103
      structValuePtr = reflect.New(structType)
104
      structValue = structValuePtr.Elem()
105
      prt = true
106
    }
107

108
    // 遍历结构体字段
109
    for j := 0; j < structType.NumField(); j++ {
110
      fieldValue := structValue.Field(j)
111
      fieldType := structType.Field(j)
112
      // 检查字段的 tag 是否与 key 匹配
113
      tag := fieldType.Tag.Get(tagKey)
114
      if values, ok := data[tag]; ok {
115
        if i >= len(values) {
116
          continue
117
        }
118
        // 检查字段是否可以被设置
119
        if fieldValue.CanSet() {
120
          // 根据字段类型进行适当的转换并设置值
121
          switch fieldType.Type.Kind() {
122
          case reflect.String:
123
            structValue.Field(j).SetString(values[i])
124
          }
125
        }
126
      }
127

128
    }
129
    if prt {
130
      news.Index(i).Set(structValuePtr)
131
    }
132
  }
133
}
134

135
func ParseXlsxToStructByUrl(url string, out any, sheet ...string) error {
136
  resp, err := http.Get(url)
137
  if err != nil {
138
    return err
139
  }
140
  defer resp.Body.Close()
141
  data, _ := io.ReadAll(resp.Body)
142
  return ParseXlsxToStruct(data, out, sheet...)
143
}
144

145
func ParseStructToXlsx(a any, fn func(tag string, val any, cell *xlsx.Cell) error) (*xlsx.File, error) {
146
  val := reflect.ValueOf(a)
147
  if val.Type().Kind() != reflect.Slice {
148
    return nil, errors.New("必须传入[]*struct")
149
  }
150
  xFile := xlsx.NewFile()
151
  sheet, _ := xFile.AddSheet("A1")
152
  title := sheet.AddRow()
153
  for i := 0; i < val.Len(); i++ {
154
    elemVal := val.Index(i)
155
    for elemVal.Kind() == reflect.Ptr {
156
      elemVal = elemVal.Elem()
157
    }
158
    if elemVal.Kind() != reflect.Struct {
159
      return nil, errors.New("必须传入[]*struct")
160
    }
161
    row := sheet.AddRow()
162
    for j := 0; j < elemVal.NumField(); j++ {
163
      cell := row.AddCell()
164
      tag, ok := elemVal.Type().Field(j).Tag.Lookup("xlsx")
165
      if !ok {
166
        continue
167
      }
168
      if i == 0 {
169
        title.AddCell().SetString(tag)
170
      }
171
      v := elemVal.Field(j).Interface()
172
      if err := fn(tag, v, cell); err != nil {
173
        return nil, err
174
      }
175
    }
176
  }
177
  return xFile, nil
178
}
179

180
func GetUniqueSheetsTitle(ss []*xlsx.Sheet) []string {
181
  var tmp = make(map[string]struct{})
182
  var out []string
183
  for _, s := range ss {
184
    title := GetSheetTitle(s)
185
    for _, t := range title {
186
      if _, ok := tmp[t]; !ok && t != "" {
187
        out = append(out, t)
188
      }
189
    }
190
  }
191
  return out
192
}
193

194
func GetSheetTitle(s *xlsx.Sheet) []string {
195
  if len(s.Rows) == 0 {
196
    return nil
197
  }
198
  if row := s.Rows[0]; row != nil {
199
    var title = make([]string, len(row.Cells))
200
    for i, cell := range row.Cells {
201
      title[i] = cell.String()
202
    }
203
    return title
204
  }
205
  return nil
206
}

展开收起

【Linux】使用iptables进行端口映射

Fri, 21 Apr 2023 10:16:00 GMT

使用#

Terminal window

1
./iptable.sh -I 本地ip 本地端口 远程ip 远程端口

插入到头部

Terminal window

1
./iptable.sh -I 127.0.0.1 1234 127.0.0.2 2345

尾部追加

Terminal window

1
./iptable.sh -A 127.0.0.1 1234 127.0.0.2 2345

删除

Terminal window

1
./iptable.sh -D 127.0.0.1 1234 127.0.0.2 2345

脚本#

1
#!/bin/bash
2

3
case $1 in
4
  -I)
5
    echo "执行插入操作-I"
6
    ;;
7
  -A)
8
    echo "执行追加操作-A"
9
    ;;
10
  -D)
11
    echo "执行删除操作-D"
12
    ;;
13
  -h)
14
    echo "$0 <-I -A -D> 本地ip 本地端口 远程ip 远程端口"
15
    exit 0
16
    ;;
17
  *)
18
    echo "无效的参数，请输入-I -A -D之一"
19
    echo "$0 <-I -A -D> 本地ip 本地端口 远程ip 远程端口"
20
    exit 1
21
    ;;
22
esac
23

24
iptables -t nat $1 PREROUTING -p tcp -d $2 --dport $3 -j DNAT --to $4:$5
25
iptables -t nat $1 POSTROUTING -p tcp -d $4 --dport $5 -j SNAT --to $2
26

27
# 本地链路
28
iptables -t nat $1 OUTPUT -p tcp -d $2 --dport $3 -j DNAT --to $4:$5

展开收起

【LXC】lxc debian安装桌面

Fri, 24 Feb 2023 13:47:18 GMT

转自 https://www.right.com.cn/forum/thread-8227639-1-1.html

原教程写得很简练，就直接转过来了，改天再提取一下

1、创建一个debian 11系统，模板在PVE管理页面下载就有（ubuntu也可以，试过安装debian更精减），4G内存，2 CPU起步，指定你想要的ip（例如：192.168.1.10/24）

2、登录并修改为清华软件源

Terminal window

1
nano /etc/apt/sources.list
2

3
apt update

3、添加一个新用户

Terminal window

1
adduser username
2
apt install sudo
3
usermod -aG sudo username

4、配置中文环境：

Terminal window

1
dpkg-reconfigure locales

选择zh_CN.UTF-8 UTF-8

5、安装XFCE桌面环境和思源字体：在安装过程中，会看到一个屏幕询问想要哪个桌面管理器：选择 lightdm

Terminal window

1
sudo apt install xfce4 xfce4-goodies xorg dbus-x11 x11-xserver-utils fonts-noto-cjk

7、安装xrdp

Terminal window

1
sudo apt install xrdp

8、验证 xrdp 安装是否正确并且正在运行

Terminal window

1
sudo systemctl status xrdp

9、 RDP 安装后需要添加这个代码，以便让桌面管理器知道使用什么来显示

Terminal window

1
sudo update-alternatives --set x-session-manager /usr/bin/xfce4-session

这时可以使用远程桌面连接192.168.1.10了，中文输入法可以安装fcitx（fcitx-table-wbpy这个是五笔拼音混合输入）

0x2#

更新一下xrdp远程桌面连接声音重定向 https://bbs.deepin.org/post/192129 https://github.com/neutrinolabs/xrdp https://github.com/neutrinolabs/pulseaudio-module-xrdp 1、安装编译需要的环境

Terminal window

1
sudo apt install build-essential dpkg-dev libpulse-dev git autoconf libtool

2、安装pulseaudio和编译依赖 (需要启用deb-src源）非root用户进入 /home/username

Terminal window

1
sudo apt install
2
sudo apt build-dep pulseaudio
3
apt source pulseaudio

3、编译 cd 下载的pulseaudio源码目录

Terminal window

1
./bootstrap
2
./configure
3
make

4、下载 pulseaudio-module-xrdp源码并编译

Terminal window

1
git clone https://github.com/neutrinolabs/pulseaudio-module-xrdp.git
2
cd pulseaudio-module-xrdp
3
./bootstrap && ./configure PULSE_DIR=/home/username/pulseaudio-14.2(上一步下载的源码目录）
4
make

5、安装模块

Terminal window

1
cd src
2
sudo make install

6、查看是否成功

Terminal window

1
ls $(pkg-config --variable=modlibexecdir libpulse) | grep xrdp

现出module-xrdp-sink.so 和 module-xrdp-source.so 就是成功了

【疑难杂症】特权lxc下运行非特权docker报错

Fri, 24 Feb 2023 00:53:31 GMT

0x0 问题#

报错类似：

1
AppArmor enabled on system but the docker-default profile could not be loaded: running `/usr/sbin/apparmor_parser apparmor_parser

0x1 解决#

在lxc的配置文件添加：

1
lxc.apparmor.profile = unconfined

添加后重启lxc

docker运行参数添加：

1
--security-opt apparmor=unconfined

如果是以docker-compose，添加：

1
services:
2
  your_service:
3
    security_opt:
4
      - apparmor=unconfined

【N5105】PVE+Docker+Jellyfin 核显直通

Sun, 19 Feb 2023 02:41:00 GMT

0x00#

当前我使用的PVE版本是7.3-3当前的内核是5.15.74，网上教程试了一圈发现都不行。最后发现问题是内核的原因。

0x01#

首先升级宿主机内核

Terminal window

1
apt update
2
apt upgrade -y
3
apt install pve-kernel-5.19 -y

查看固件

Terminal window

1
cd /lib/firmware/i915 && ls ehl_guc*.bin &&  ls ehl_huc*.bin &&  ls icl_dmc*.bin

修改配置并重启

Terminal window

1
echo "options i915 enable_guc=3" >> /etc/modprobe.d/i915.conf
2
reboot

启动后检查

Terminal window

1
journalctl -b -o short-monotonic -k | egrep -i "i915|dmr|dmc|guc|huc"

输出的内容中有GuV HuC就代表驱动成功

1
[    4.841415] home kernel: Setting dangerous option enable_guc - tainting kernel
2
[    4.866046] home kernel: i915 0000:00:02.0: vgaarb: deactivate vga console
3
[    4.869642] home kernel: i915 0000:00:02.0: vgaarb: changed VGA decodes: olddecodes=io+mem,decodes=io+mem:owns=io+mem
4
[    4.871436] home kernel: i915 0000:00:02.0: [drm] Finished loading DMC firmware i915/icl_dmc_ver1_09.bin (v1.9)
5
[    4.876510] home kernel: mei_hdcp 0000:00:16.0-b638ab7e-94e2-4ea2-a552-d1c54b627f04: bound 0000:00:02.0 (ops i915_hdcp_component_ops [i915])
6
[    5.545198] home kernel: i915 0000:00:02.0: [drm] failed to retrieve link info, disabling eDP
7
[    5.552915] home kernel: i915 0000:00:02.0: [drm] GuC firmware i915/ehl_guc_70.1.1.bin version 70.1
8
[    5.552922] home kernel: i915 0000:00:02.0: [drm] HuC firmware i915/ehl_huc_9.0.0.bin version 9.0
9
[    5.569445] home kernel: i915 0000:00:02.0: [drm] HuC authenticated
10
[    5.569889] home kernel: i915 0000:00:02.0: [drm] GuC submission enabled
11
[    5.569891] home kernel: i915 0000:00:02.0: [drm] GuC SLPC disabled
12
[    5.572145] home kernel: [drm] Initialized i915 1.6.0 20201103 for 0000:00:02.0 on minor 0
13
[    5.575832] home kernel: sof-audio-pci-intel-icl 0000:00:1f.3: bound 0000:00:02.0 (ops i915_audio_component_bind_ops [i915])
14
[    5.576361] home kernel: i915 0000:00:02.0: [drm] Cannot find any crtc or sizes
15
[    5.576501] home kernel: i915 0000:00:02.0: [drm] Cannot find any crtc or sizes

展开收起

0x02#

docker映射设备/dev/dri:/dev/dri

jellyfin 硬解选择QSV

如果中间还加了一层LXC就在配置上添加

1
lxc.cgroup2.devices.allow: c 226:0 rwm
2
lxc.cgroup2.devices.allow: c 226:128 rwm
3
lxc.cgroup2.devices.allow: c 29:0 rwm
4
lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir
5
lxc.apparmor.profile: unconfined

【脚本】docker日志清理

Thu, 05 Jan 2023 00:07:00 GMT

0x0#

docker的容器日志一般存储在/var/lib/docker/containers/下，容器的id的目录下有一个-json.log结尾的文件就是日志文件。

因为linux的文件系统原因，正在运行的容器中的日志直接删除是不会中断进程与文件的连接的，说人话就是“删不掉”（可以删除，但磁盘空间不会释放），所以直接删除就必须停止docker容器。

0x01#

所以如果想不停docker容器的情况下清理日志，那就清空日志文件（这里用词是“清空”）。

Terminal window

1
echo "" | sudo tee /var/lib/docker/containers/容器id/容器id-json.log

0x02#

这里我使用find命令批量清理：

Terminal window

1
find /var/lib/docker/containers/ -name *-json.log -size +10M -ok dd if=/dev/null of={} \;

参数：

-name 文件名匹配

-size +10M 匹配大小超过10M的文件

-ok 后面接匹配到文件后执行命令，会提示输入y/n的保险来确认是否执行命令，如果想不提示y/n就自动处理就将-ok替换为-exec，命令最后面接\;结束命令

这里将文件置空我使用的是dd if=/dev/null of={}，其中的{}表示文件路径，是find的占位符会自动替换为匹配到的文件路径。

【Linux】文件备份脚本

Wed, 26 Oct 2022 10:14:00 GMT

1
#!/bin/bash
2

3
backup_num=3
4

5
function help() {
6
  echo "-in 源文件路径"
7
  echo "-out 备份路径"
8
  echo "-backup_num 备份数量"
9
  echo "-inKey 使用公钥加密，详情：https://github.com/Rehtt/archive"
10
  echo "-genKey 生成密钥对，详情：https://github.com/Rehtt/archive"
11
  exit 0
12
}
13

14
while [ $# -gt 0 ]; do
15
  case $1 in
16
  -in)
17
    in_path="$2"
18
    shift
19
    ;;
20
  -out)
21
    out="$2"
22
    shift
23
    ;;
24
  -backup_num)
25
    backup_num=$2
26
    shift
27
    ;;
28
  -inKey)
29
    inKey="$2"
30
    shift
31
    ;;
32
  -genKey)
33
    archive -generateRsaKey
34
    exit 0
35
    shift
36
    ;;
37
  -help)
38
    help
39
    ;;
40
  -h)
41
    help
42
    ;;
43
  esac
44
  shift
45
done
46

47
if [ x"$in_path" = x ]; then
48
  help
49
fi
50
if [ x"$out" = x ]; then
51
  help
52
fi
53

54
filename=$(basename "$in_path")
55
tmp_file="/tmp/$filename-$(date +%Y-%m-%d).tar.xz"
56
out="$out/$filename"
57

58
function get_last_file() {
59
  local time=1
60
  del_file=""
61
  file_num=0
62
  while [ $# -gt 0 ]; do
63
    local name=$1
64
    local name=${name##*/}
65
    local t=$(echo $name | grep -o '[[:digit:]]\{4,\}-[[:digit:]]\{1,2\}-[[:digit:]]\{1,2\}')
66
    if [ x"$t" = x ]; then
67
      shift
68
      continue
69
    fi
70
    local date_str=$(date +%s -d "$t")
71
    file_num=$(($file_num + 1))
72
    #    echo $name
73
    local now=$(date +%s)
74
    if [[ $(($now - $date_str)) -gt $time ]]; then
75
      local time=$(($now - $date_str))
76
      del_file=$name
77
    fi
78
    shift
79
  done
80
}
81

82
#判断是否加密
83
if [ x"$inKey" = x ]; then
84
  tar -Jcvf "$tmp_file" "$in_path"
85
else
86
  tmp_file=$tmp_file.d
87
  if [ x"$(which archive)" = x ]; then
88
    echo "缺少archive"
89
    help
90
  fi
91
  archive -a -e -inKey "$inKey" -in "$in_path" -out "$tmp_file"
92
fi
93

94
# 判断是本地保存还是用rclone保存
95
if [[ $(echo "$out" | grep ":") != "" ]]; then
96
  if [ x"$(which rclone)" = x ]; then
97
    echo "缺少rclone"
98
    help
99
  fi
100
  rclone mkdir "$out"
101
  list=$(rclone ls "$out")
102
  get_last_file $list
103
  while [ $file_num -ge $backup_num ]; do
104
    rclone delete "$out/$del_file"
105
    list=$(rclone ls "$out")
106
    get_last_file $list
107
  done
108
  rclone copy "$tmp_file" "$out"
109
else
110
  mkdir -p "$out"
111
  list=$(ls "$out")
112
  get_last_file $list
113
  while [ $file_num -ge $backup_num ]; do
114
    rm -f "$out/$del_file"
115
    list=$(ls "$out")
116
    get_last_file $list
117
  done
118
  cp "$tmp_file" "$out"
119
fi
120
rm -f "$tmp_file"

展开收起

【Golang】调用syscall调用windows dll弹窗

Thu, 22 Sep 2022 02:47:18 GMT

1
package main
2
import (
3
    "fmt"
4
    "syscall"
5
    "time"
6
    "unsafe"
7
)
8

9
const (
10
    MB_OK                = 0x00000000
11
    MB_OKCANCEL          = 0x00000001
12
    MB_ABORTRETRYIGNORE  = 0x00000002
13
    MB_YESNOCANCEL       = 0x00000003
14
    MB_YESNO             = 0x00000004
15
    MB_RETRYCANCEL       = 0x00000005
16
    MB_CANCELTRYCONTINUE = 0x00000006
17
    MB_ICONHAND          = 0x00000010
18
    MB_ICONQUESTION      = 0x00000020
19
    MB_ICONEXCLAMATION   = 0x00000030
20
    MB_ICONASTERISK      = 0x00000040
21
    MB_USERICON          = 0x00000080
22
    MB_ICONWARNING       = MB_ICONEXCLAMATION
23
    MB_ICONERROR         = MB_ICONHAND
24
    MB_ICONINFORMATION   = MB_ICONASTERISK
25
    MB_ICONSTOP          = MB_ICONHAND
26

27
    MB_DEFBUTTON1 = 0x00000000
28
    MB_DEFBUTTON2 = 0x00000100
29
    MB_DEFBUTTON3 = 0x00000200
30
    MB_DEFBUTTON4 = 0x00000300
31
)
32

33
func abort(funcname string, err syscall.Errno) {
34
    panic(funcname + " failed: " + err.Error())
35
}
36

37
var (
38
    user32, _     = syscall.LoadLibrary("user32.dll")
39
    messageBox, _ = syscall.GetProcAddress(user32, "MessageBoxW")
40
)
41

42
func IntPtr(n int) uintptr {
43
    return uintptr(n)
44
}
45

46
func StrPtr(s string) uintptr {
47
    return uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(s)))
48
}
49

50
func MessageBox(caption, text string, style uintptr) (result int) {
51
    ret, _, callErr := syscall.Syscall9(messageBox,
52
        4,
53
        0,
54
        StrPtr(text),
55
        StrPtr(caption),
56
        style,
57
        0, 0, 0, 0, 0)
58
    if callErr != 0 {
59
        abort("Call MessageBox", callErr)
60
    }
61
    result = int(ret)
62
    return
63
}
64

65
func ShowMessage2(title, text string) {
66
    user32 := syscall.NewLazyDLL("user32.dll")
67
    MessageBoxW := user32.NewProc("MessageBoxW")
68
    MessageBoxW.Call(IntPtr(0), StrPtr(text), StrPtr(title), IntPtr(0))
69
}
70

71
func main() {
72
    defer syscall.FreeLibrary(user32)
73

74
    num := MessageBox("Title1", "test1", MB_YESNOCANCEL)
75
    fmt.Printf("Get Retrun Value Before MessageBox %d\n", num)
76
    ShowMessage2("Title2", "test2")
77
    time.Sleep(3 * time.Second)
78
}
79

80
func init() {
81
    fmt.Print("start...\n")
82
}

展开收起

【Golang】Go的构建模式

Thu, 05 May 2022 12:38:09 GMT

未完成

构建模式是在go build打包二进制的时候指定的打包模式，通过go help buildmode查看支持的打包模式

Terminal window展开收起

1
$ go version
2

3
go version go1.18.1 linux/amd64
4

5
$ go help buildmode
6

7
The 'go build' and 'go install' commands take a -buildmode argument which
8
indicates which kind of object file is to be built. Currently supported values
9
are:
10

11
        -buildmode=archive
12
                Build the listed non-main packages into .a files. Packages named
13
                main are ignored.
14

15
        -buildmode=c-archive
16
                Build the listed main package, plus all packages it imports,
17
                into a C archive file. The only callable symbols will be those
18
                functions exported using a cgo //export comment. Requires
19
                exactly one main package to be listed.
20

21
        -buildmode=c-shared
22
                Build the listed main package, plus all packages it imports,
23
                into a C shared library. The only callable symbols will
24
                be those functions exported using a cgo //export comment.
25
                Requires exactly one main package to be listed.
26

27
        -buildmode=default
28
                Listed main packages are built into executables and listed
29
                non-main packages are built into .a files (the default
30
                behavior).
31

32
        -buildmode=shared
33
                Combine all the listed non-main packages into a single shared
34
                library that will be used when building with the -linkshared
35
                option. Packages named main are ignored.
36

37
        -buildmode=exe
38
                Build the listed main packages and everything they import into
39
                executables. Packages not named main are ignored.
40

41
        -buildmode=pie
42
                Build the listed main packages and everything they import into
43
                position independent executables (PIE). Packages not named
44
                main are ignored.
45

46
        -buildmode=plugin
47
                Build the listed main packages, plus all packages that they
48
                import, into a Go plugin. Packages not named main are ignored.
49

50
On AIX, when linking a C program that uses a Go archive built with
51
-buildmode=c-archive, you must pass -Wl,-bnoobjreorder to the C compiler.

展开收起

archive 模式#

shared 模式#

c-archive 模式#

c-shared 模式#

exe 模式#

pie 模式#

是一种使用PIE技术的安全编译模式，能提供一定防反编译的防护能力（但也不能只寄望与一种技术，世界上没有绝对的技术）

PIE技术#

PIE全称是position-independent executable，中文解释为地址无关可执行文件。

一般程序的代码段(.text)、数据段(.data)和全局变量段(.bss)加载时是一个固定的地址，而PIE技术就是使其每次加载程序时都会变换地址，所以提高了反编译的难度。

plugin 模式#

该模式会将非main包的go程序打包成可以热加载的插件。

==不过，目前使用这种模板打包插件还是有缺陷的，首先它不支持windows下打包和使用，其次插件不支持热卸载==

使用#

插件要求是编译插件的包名必须是main

hello.go

1
package main
2

3
import "fmt"
4

5
func Hello(say any) {
6
  fmt.Println("在hello里：",say)
7
}

编译：

Terminal window

1
go build -buildmode=plugin -o hello.so hello.go

使用：

1
type Hello func(say any)
2

3
func main() {
4
  p, err := plugin.Open("./plugin.so")
5
  if err != nil {
6
    log.Fatalln(err)
7
  }
8
  h, err := p.Lookup("Hello")
9
  if err != nil {
10
    log.Fatalln(err)
11
  }
12
  h.(Hello)("hello")
13
}

archive 模式，最终会编译出名为.a的静态文件，编译时会忽略main包（也就是会忽略main入口）。这种模式类似与c/c++程序的打包过程，将代码编译为二进制，但此时程序还不能直接运行。
c-archive 模式，生成c/c++的静态库，编译后会生成.a和.h的c头文件，随后可将go程序一同编译进c程序。
c-shared 模式，与c-archive基本一致，区别是c-shared最终生成的是c/c++动态库。
default 模式，就是默认的模式，直接使用go build的时候就是使用此模式。
shared 模式，与archive基本一致，区别是shared生成的是go的动态库。
exe 模式，与default基本一致，区别是最终会生成exe文件。
pie 模式，会使编译后的文件更安全，使其无法轻易地反编译，主要是使用PIE技术。一般程序的代码段(.text)、数据段(.data)和全局变量段(.bss)是一个固定的地址，而PIE技术就是使其每次加载程序时都会变换地址，所以提高了反编译的难度。
plugin 模式，会生成go插件，可以在其他程序中热加载。

【Golang】1.18泛型初步理解

Mon, 18 Apr 2022 14:23:00 GMT

0x00#

这次golang正式更新了泛型（之前的1.17 和1.18 Beta 1 中的只是测试版，其中有一些用法和正式版有较大的差别），是一次重大的更新，原以为在GO2.0的时候更新。

0x01 类型形参（Type Parameters）#

在之前想要实现一些通用的功能还是比较麻烦的，而且代码冗余。

比如实现gorm添加json类型字段：

1
type Table struct {
2
  AField    A
3
  BField    B
4
}
5

6
type A struct {
7
    AText string
8
}
9
func (A) GormDataType() string {
10
    return "json"
11
}
12
func (a *A) Scan(value interface{}) error {
13
    return json.Unmarshal(value.([]byte), a)
14
}
15
func (a A) Value() (value driver.Value, err error) {
16
    src, err := json.Marshal(a)
17
    return string(src), err
18
}
19

20
type B struct {
21
    BText string
22
}
23
func (B) GormDataType() string {
24
    return "json"
25
}
26
func (b *B) Scan(value interface{}) error {
27
    return json.Unmarshal(value.([]byte), b)
28
}
29
func (b B) Value() (value driver.Value, err error) {
30
    src, err := json.Marshal(b)
31
    return string(src), err
32
}

展开收起

可以看到A和B中的GormDataType Scan Value方法几乎都是重复的，假如再添加C D那么就要添加6个重复发方法。

而golang 1.8开始正式支持泛型，那么利用泛型可以降低这样的代码冗余

使用泛型再次实现上述内容：

1
type Table struct {
2
  AField    JSON[A]
3
  BField    JSON[B]
4
}
5

6
type A struct {
7
  AText string
8
}
9

10
type B struct {
11
  BText string
12
}
13

14

15
type JSON[T any] struct {
16
    Data T
17
}
18
func (JSON[T]) GormDataType() string {
19
    return "json"
20
}
21
func (m *JSON[T]) Scan(value interface{}) error {
22
    return json.Unmarshal(value.([]byte), &m.Data)
23
}
24
func (m JSON[T]) Value() (value driver.Value, err error) {
25
    src, err := json.Marshal(m.Data)
26
    return string(src), err
27
}

展开收起

可以看到我这里定义了一个JSON[T any]的类型专门处理json类型，此后添加C D字段就只需要定义相关的结构体并且添加JSON[C] JSON[D]即可。

其中any类型也是这次更新后的新类型字段，但any其实就是interface类型的别称

源码：

1
// src/builtin/builtin.go 95行
2

3
// any is an alias for interface{} and is equivalent to interface{} in all ways.
4
type any = interface{}

个人感觉any相比interface在传参等场合更直观

比如：

1
func Println(v ...any){}
2

3
func Println(v ...interface){}

当然，在定义接口时还是得用interface字段

判断类型#

1
func (m *JSON[T]) Test() {
2
    switch any(m.Data).(type) {
3
      case A:
4
        fmt.Println("A")
5
      case B:
6
        fmt.Println("B")
7
    }
8
}

#1014950980

0x02 类型集合（Type Sets）#

类型集合允许定义一个类型具有不同类型的集合

例如：

1
type Test interface {
2
  int|float64
3
}

定义了一个Test类型，表示为int float64类型的集合

如果不用泛型那怎么写呢

不使用泛型：

1
func Add(a, b interface{}) interface{} {
2
    switch a.(type) {
3
    case int:
4
        return a.(int)+b.(int)
5
    case float64:
6
        return a.(float64)+b.(float64)
7
    }
8
    return 0
9
}

使用泛型：

1
func Add[T int | float64](a, b T) T {
2
    return a + b
3
}

这样一对比使用泛型就简洁多了

应用：

1
type Num interface {
2
    int | int64 | int32 |
3
        float64 | float32 |
4
        uint | uint8 | uint16 | uint64
5
}
6

7
func Add[T Num](a, b T) T {
8
    return a + b
9
}
10

11
func Sub[T Num](a, b T) T {
12
    return a - b
13
}

0x03 类型约束#

1
type T interface {
2
  int | float64 | ~string
3
}

其中的~string表示定义的T类型集合也支持底层类型是string的类型

比如：

1
type A interface {
2
  ~string
3
}
4

5
func Splic[T A](a, b T) T {
6
  return a + b
7
}
8

9
var BString string
10

11
func main() {
12
  var a string = "a"
13
  var b BString = "b"
14

15
  Splic(a, b)
16
}

展开收起

其中BString是自定义的一个底层为string的类型，如果没有加~的话会报错

【树莓派】板载LED控制

Mon, 10 Jan 2022 14:10:00 GMT

0x00#

有两种方式控制树莓派板载的LED

0x01 开机后方案#

重启会失效

控制板载灯的有以下文件：

1
# 状态灯
2
/sys/class/leds/led0/brightness
3
/sys/class/leds/led0/trigger
4

5
# 电源灯
6
/sys/class/leds/led1/brightness
7
/sys/class/leds/led1/trigger

就可以控制状态灯和电源灯

其中brightness文件是亮度控制，接受范围是0~255，数字越大越亮，默认是255

trigger文件是控制灯的模式，可以通过cat /sys/class/leds/led0/trigger读取模式，我的系统是树莓派爱好者基地提供的Debian-Pi-Aarch64，其中模式共有：

[none] usb-gadget usb-host rc-feedback kbd-scrolllock kbd-numlock kbd-capslock kbd-kanalock kbd-shiftlock kbd-altgrlock kbd-ctrllock kbd-altlock kbd-shiftllock kbd-shiftrlock kbd-ctrlllock kbd-ctrlrlock timer oneshot heartbeat backlight gpio cpu cpu0 cpu1 cpu2 cpu3 default-on input panic actpwr mmc1 mmc0 rfkill-any rfkill-none rfkill0 bluetooth-power hci0-power rfkill1

默认下状态灯的模式是cpu，电源灯的模式是hci0-power

将模式设为none就是关闭灯

示例：

Terminal window

1
# 关闭状态灯
2
echo none | sudo tee /sys/class/leds/led0/trigger
3

4
# 调节电源灯亮度
5
echo 125 | sudo tee /sys/class/leds/led1/brightness

0x02 开机前方案#

如果想要不重启失效，就需要通过修改/boot/config.txt文件来实现。

首先官方文档有说明：

1
  # 状态灯
2
      act_led_trigger         Choose which activity the LED tracks.
3
                                Use "heartbeat" for a nice load indicator.
4
                                (default "mmc")
5
        act_led_activelow       Set to "on" to invert the sense of the LED
6
                                (default "off")
7
                                N.B. For Pi 3B, 3B+, 3A+ and 4B, use the act-led
8
                                overlay.
9
        act_led_gpio            Set which GPIO to use for the activity LED
10
                                (in case you want to connect it to an external
11
                                device)
12
                                (default "16" on a non-Plus board, "47" on a
13
                                Plus or Pi 2)
14
                                N.B. For Pi 3B, 3B+, 3A+ and 4B, use the act-led
15
                                overlay
16
  # 电源灯
17
        pwr_led_trigger
18
        pwr_led_activelow
19
        pwr_led_gpio
20
                                As for act_led_*, but using the PWR LED.
21
                                Not available on Model A/B boards.
22
  # 网络灯
23
        eth_led0                Set mode of LED0 (usually orange) (default
24
                                "1"). The legal values are:
25
                                0=link/activity          1=link1000/activity
26
                                2=link100/activity       3=link10/activity
27
                                4=link100/1000/activity  5=link10/1000/activity
28
                                6=link10/100/activity    14=off    15=on
29
        eth_led1                Set mode of LED1 (usually green) (default
30
                                "6"). See eth_led0 for legal values.

展开收起

只需要在/boot/config.txt中添加相应的设置就可以实现

示例，关闭所有灯：

1
#设置状态灯为none模式
2
dtparam=act_led_trigger=none
3

4
#设置电源灯为none模式
5
dtparam=pwr_led_trigger=none
6

7
#设置网口灯为off
8
dtparam=eth_led0=14
9
dtparam=eth_led1=14

【树莓派】SD卡系统备份

Sun, 09 Jan 2022 09:39:00 GMT

0x00 前言#

一般常见简单的备份方式是是使用Win32DiskImager备份，但是有几个缺点：

整卡备份，Win32DiskImager会将SD卡内的所有区块都会备份下来，就类似Linux的dd命令。一个SD卡是16G但里面的数据只有100M，那么备份下来的文件就是16G，生成的备份文件大小就是SD的大小，这无疑浪费了空间
备份时间长，前面提到Win32DiskImager会将SD卡的所有块都备份下来，因此备份时间也就长了。
恢复时卡的容量必须要和备份文件大小一致或更大，这样就会造成一个问题，原本一张16G的卡内只有100M的有效数据，现在如果想将数据恢复到一张8G的卡，那么通过这种备份的方式是行不通的。

最后通过查找找到了一个更好方法，就是通过dump备份，恢复时也只恢复有效数据，因此只要恢复的SD卡比有效数据大就行了。

0x01 需要的软件#

dump 备份工具，用于备份系统
dosfstools fat32格式化工具，引导文件分区是fat32格式的
parted 分区调整工具
kpartx 虚拟文件系统工具

安装：

Terminal window

1
apt install dump -y &&
2
apt install dosfstools -y &&
3
apt install parted -y &&
4
apt install kpartx -y

0x02 创建img文件#

img是用于存储系统的镜像文件

首先使用df -h查看实际空间大小，再生成文件，比如：

1
Filesystem      Size  Used Avail Use% Mounted on
2
/dev/root        15G  8.9G  5.0G  65% /
3
/dev/mmcblk0p1  252M   72M  180M  29% /boot

从上可以看出实际使用空间8.9G+252M的boot空间

需要注意这里显示的空间单位是G，这里的G是将大小舍入到接近GiB（2302^{30}230字节），而不是GB(10910^{9}109字节)。

GB和GiB是两个有严格区别的单位，GB是方便10进制计算，GiB是方便2进制计算。

（插个题外话，Windows中默认的大小单位显示的是KB、MB、GB实际上计算的是KiB、MiB、GiB）

因此需要生成的img需要大于等于8.9G+252M

Terminal window

1
dd if=/dev/zero of=raspi.img bs=1M count=9570

if是输入路径，这里选择使用0填充

of是输出路径，就是创建img文件的路径

bs是块大小，这里选择M，也就是MiB，这样生成的文件是512bytes的整数倍，为了与分区表对上

count是块数，bs*count=真实大小

因为要生成的img文件需要大于等于8.9G``+252M，而这里的8.9G是进行了大小舍入所以不精确，所以为了容纳误差而选择生成9.1G`大小的系统。

因为bs是M，所以count为：(9.1×230÷220)+252≈9570(9.1\times2^{30}\div2^{20})+252\approx9570(9.1×230÷220)+252≈9570

0x03 img镜像分区#

分区前通过fdisk -l查看树莓派分区

1
Device         Boot  Start      End  Sectors  Size Id Type
2
/dev/mmcblk0p1 *      8192   524287   516096  252M  c W95 FAT32 (LBA)
3
/dev/mmcblk0p2      524288 31223807 30699520 14.7G 83 Linux

可以看到SD卡有两个分区，其中关键信息为：

/dev/mmcblk0p1是引导分区(boot)，分区类型是fat32，从8192柱面开始，到524287柱面结束。
/dev/mmcblk0p2是系统分区，分区从524288柱面开始。

接下来使用parted将刚生成的img文件进行分区

Terminal window

1
parted raspi.img -s  -- mklabel msdos   # 创建msdos分区表
2
parted raspi.img -s  -- mkpart primary fat32 8192s 524287s  # fat32分区从8192开始，到524287结束
3
parted raspi.img -s  -- mkpart primary ext4 524288s -1  # 系统分区一般都是ext4类型，从524288开始，到最后

0x04 挂载img并格式化#

将img挂载为虚拟设备，并获取虚拟设备地址

Terminal window

1
loopdevice=`losetup -f --show raspi.img`

使用kpartx挂载为虚拟文件系统

Terminal window

1
device=`kpartx -va $loopdevice | sed '1!d' | sed -E 's/.*(loop[0-9])p.*/\1/g'`

地址拼接

Terminal window

1
device="/dev/mapper/${device}"
2
imgBoot="${device}p1"
3
imgRoot="${device}p2"

格式化

Terminal window

1
mkfs.vfat $imgBoot
2
mkfs.ext4 $imgRoot

0x05 备份#

创建两个临时挂载目录，并挂载

Terminal window

1
mkdir tmpBoot tmpRoot
2
mount -t vfat $imgBoot tmpBoot
3
mount -t ext4 $imgRoot tmpRoot

备份Boot

Terminal window

1
cp -rfp /boot/* tmpBoot

备份系统

Terminal window

1
cd tmpRoot
2
dump -0uaf - / | restore -rf -
3
cd -

0x06 修改启动文件#

因为树莓派启动需要对应分区的PARTUUID，所以需要修改cmdline.txt和fstab文件

首先使用blkid命令查看分区PARTUUID

Terminal window

1
blkid -o export $imgBoot
2
blkid -o export $imgRoot

分别输出

1
DEVNAME=/dev/mapper/loop0p1
2
SEC_TYPE=msdos
3
UUID=161A-ED14
4
TYPE=vfat
5
PARTUUID=e74ab5ad-01
6

7
DEVNAME=/dev/mapper/loop0p2
8
UUID=20aa2e77-a211-4d43-996d-324f015e597c
9
TYPE=ext4
10
PARTUUID=e74ab5ad-02

可以看到PARTUUID分别为e74ab5ad-01（对应boot分区）和e74ab5ad-02（对应系统分区）。

将获取到的PARTUUID分别替换掉cmdline.txt和fstab文件中的PARTUUID

路径：

1
tmpBoot/cmdline.txt   # cmdline.txt
2
tmpRoot/etc/fstab     # fstab

0x07 END#

卸载分区

Terminal window

1
cd ~
2
umount tmpBoot/ tmpRoot/
3
rm -rf tmpBoot/ tmpRoot/

卸载虚拟设备

Terminal window

1
kpartx -d $loopdevice
2
losetup -d $loopdevice

至此系统备份就做好了，制作的img文件可以使用Win32DiskImager或dd刷入其他的SD卡了

【Golang】关于time包的一些记录

Tue, 04 Jan 2022 15:09:06 GMT

0x00 时间格式化#

相信都听说过Golang时间格式化规则layout2006-01-02 15:04:05 是Golang创始纪念日，以前我也是这样认为，还觉得golang太傲慢了（笑）。直到后面仔细观察后发现layout中年、月、日、时、分、秒的数字才发现事情没有那么简单，首先来观察这几组layout：

1
2006-01-02 15:04:05   // 24小时格式 有0占位
2
2006-1-2 15:4:5       // 24小时格式 无0占位
3
2006-01-02 03:04:05   // 12小时格式 有0占位
4
2006-1-2 3:4:5        // 12小时格式 无0占位
5
2006  // 长年份
6
06    // 短年份 有0占位
7
6     // 短年份 无0占位

不知发现其中规则了没有，年、月、日、时、分、秒格式中除了表示占位的0和长年份的2以外，没有一个数字是重复的，也就是说只要检查layout中特定的数字就能解析出字块的意义。

为了验证我的猜想，来看一下time的源码：

1
// nextStdChunk finds the first occurrence of a std string in
2
// layout and returns the text before, the std string, and the text after.
3
func nextStdChunk(layout string) (prefix string, std int, suffix string) {
4
  for i := 0; i < len(layout); i++ {
5
    switch c := int(layout[i]); c {
6
    case 'J': // January, Jan
7
      if len(layout) >= i+3 && layout[i:i+3] == "Jan" {
8
        if len(layout) >= i+7 && layout[i:i+7] == "January" {
9
          return layout[0:i], stdLongMonth, layout[i+7:]
10
        }
11
        if !startsWithLowerCase(layout[i+3:]) {
12
          return layout[0:i], stdMonth, layout[i+3:]
13
        }
14
      }
15

16
    case 'M': // Monday, Mon, MST
17
      if len(layout) >= i+3 {
18
        if layout[i:i+3] == "Mon" {
19
          if len(layout) >= i+6 && layout[i:i+6] == "Monday" {
20
            return layout[0:i], stdLongWeekDay, layout[i+6:]
21
          }
22
          if !startsWithLowerCase(layout[i+3:]) {
23
            return layout[0:i], stdWeekDay, layout[i+3:]
24
          }
25
        }
26
        if layout[i:i+3] == "MST" {
27
          return layout[0:i], stdTZ, layout[i+3:]
28
        }
29
      }
30

31
    case '0': // 01, 02, 03, 04, 05, 06, 002
32
      if len(layout) >= i+2 && '1' <= layout[i+1] && layout[i+1] <= '6' {
33
        return layout[0:i], std0x[layout[i+1]-'1'], layout[i+2:]
34
      }
35
      if len(layout) >= i+3 && layout[i+1] == '0' && layout[i+2] == '2' {
36
        return layout[0:i], stdZeroYearDay, layout[i+3:]
37
      }
38

39
    case '1': // 15, 1
40
      if len(layout) >= i+2 && layout[i+1] == '5' {
41
        return layout[0:i], stdHour, layout[i+2:]
42
      }
43
      return layout[0:i], stdNumMonth, layout[i+1:]
44

45
    case '2': // 2006, 2
46
      if len(layout) >= i+4 && layout[i:i+4] == "2006" {
47
        return layout[0:i], stdLongYear, layout[i+4:]
48
      }
49
      return layout[0:i], stdDay, layout[i+1:]
50

51
    case '_': // _2, _2006, __2
52
      if len(layout) >= i+2 && layout[i+1] == '2' {
53
        //_2006 is really a literal _, followed by stdLongYear
54
        if len(layout) >= i+5 && layout[i+1:i+5] == "2006" {
55
          return layout[0 : i+1], stdLongYear, layout[i+5:]
56
        }
57
        return layout[0:i], stdUnderDay, layout[i+2:]
58
      }
59
      if len(layout) >= i+3 && layout[i+1] == '_' && layout[i+2] == '2' {
60
        return layout[0:i], stdUnderYearDay, layout[i+3:]
61
      }
62

63
    case '3':
64
      return layout[0:i], stdHour12, layout[i+1:]
65

66
    case '4':
67
      return layout[0:i], stdMinute, layout[i+1:]
68

69
    case '5':
70
      return layout[0:i], stdSecond, layout[i+1:]
71

72
    case 'P': // PM
73
      if len(layout) >= i+2 && layout[i+1] == 'M' {
74
        return layout[0:i], stdPM, layout[i+2:]
75
      }
76

77
    case 'p': // pm
78
      if len(layout) >= i+2 && layout[i+1] == 'm' {
79
        return layout[0:i], stdpm, layout[i+2:]
80
      }
81

82
    case '-': // -070000, -07:00:00, -0700, -07:00, -07
83
      if len(layout) >= i+7 && layout[i:i+7] == "-070000" {
84
        return layout[0:i], stdNumSecondsTz, layout[i+7:]
85
      }
86
      if len(layout) >= i+9 && layout[i:i+9] == "-07:00:00" {
87
        return layout[0:i], stdNumColonSecondsTZ, layout[i+9:]
88
      }
89
      if len(layout) >= i+5 && layout[i:i+5] == "-0700" {
90
        return layout[0:i], stdNumTZ, layout[i+5:]
91
      }
92
      if len(layout) >= i+6 && layout[i:i+6] == "-07:00" {
93
        return layout[0:i], stdNumColonTZ, layout[i+6:]
94
      }
95
      if len(layout) >= i+3 && layout[i:i+3] == "-07" {
96
        return layout[0:i], stdNumShortTZ, layout[i+3:]
97
      }
98

99
    case 'Z': // Z070000, Z07:00:00, Z0700, Z07:00,
100
      if len(layout) >= i+7 && layout[i:i+7] == "Z070000" {
101
        return layout[0:i], stdISO8601SecondsTZ, layout[i+7:]
102
      }
103
      if len(layout) >= i+9 && layout[i:i+9] == "Z07:00:00" {
104
        return layout[0:i], stdISO8601ColonSecondsTZ, layout[i+9:]
105
      }
106
      if len(layout) >= i+5 && layout[i:i+5] == "Z0700" {
107
        return layout[0:i], stdISO8601TZ, layout[i+5:]
108
      }
109
      if len(layout) >= i+6 && layout[i:i+6] == "Z07:00" {
110
        return layout[0:i], stdISO8601ColonTZ, layout[i+6:]
111
      }
112
      if len(layout) >= i+3 && layout[i:i+3] == "Z07" {
113
        return layout[0:i], stdISO8601ShortTZ, layout[i+3:]
114
      }
115

116
    case '.': // .000 or .999 - repeated digits for fractional seconds.
117
      if i+1 < len(layout) && (layout[i+1] == '0' || layout[i+1] == '9') {
118
        ch := layout[i+1]
119
        j := i + 1
120
        for j < len(layout) && layout[j] == ch {
121
          j++
122
        }
123
        // String of digits must end here - only fractional second is all digits.
124
        if !isDigit(layout, j) {
125
          std := stdFracSecond0
126
          if layout[i+1] == '9' {
127
            std = stdFracSecond9
128
          }
129
          std |= (j - (i + 1)) << stdArgShift
130
          return layout[0:i], std, layout[j:]
131
        }
132
      }
133
    }
134
  }
135
  return layout, 0, ""
136
}

展开收起

可以看到不光年月日时分秒没有重复，甚至连时区也不是重复的。只要遵循这个规则就可以随心自定义layout。

由此可见前面说这是Golang创始纪念日的说法完全是无稽之谈。

而这种设计实际上很科学也很好记。

【Golang】使用反射实现验证struct必填字段是否为空

Fri, 20 Aug 2021 09:41:00 GMT

0x0#

反射：#

golang的reflect包实现了运行时的反射能力。reflect包中有两个重要函数：

reflect.TypeOf 获取数据类型信息，其类型为reflect.Type
reflect.ValueOf 获取数据运行时的信息，其类型为reflect.Value

Tag#

golang的struct中的每一个字段(field)后添加一段注释，称为 field tag，最经典就是构建json的struct，例如：

1
type Login struct{
2
  UserName string `json:"user_name"`
3
  Password string `json:"password"`
4
}

其中 json:"user_name" json:"password"就是 field tag

0x1#

假设现有一 struct：

1
type Note struct {
2
  Time    time.Time
3
  Content string
4
  Remarks string
5
}

我们想要指定一些字段非空，例如：Content != ""

按照一般通用的方法就是一个一个用if判断：

1
if content != "" { ... } else { ... }

如果只有几个字段需要这样判断还可以这样写。但如果有许多个字段或不同字段有不同类型，这样写的话就是一堆 if else，就不是很优雅。

0x2#

现在可以使用反射来更为优雅实现这一功能。只需要在struct需要非空的字段后添加一个 tag来标记，这个tag可以自定义，如：

1
type Note struct {
2
  Time    time.Time `must:"true"`
3
  Content string    `must:"true"`
4
  Remarks string
5
}

其中 must:"true"为我们自定义的tag，表示该字段非空。

0x3#

我们可以通过反射来获取struct字段的tag：

1
fmt.Println(reflect.TypeOf(&note).Elem().Field(0).Tag.Get("must"))  //获取第一个字段tag中"must"的值

0x4#

完整实现代码：

1
type Note struct {
2
  Time    time.Time `must:"true"`
3
  Content string    `must:"true"`
4
  Remarks string
5
}
6

7
func validator(value interface{}) {
8
  val := reflect.ValueOf(value).Elem() //获取字段值
9
  typ := reflect.TypeOf(value).Elem()  //获取字段类型
10
  // 遍历struct中的字段
11
  for i := 0; i < typ.NumField(); i++ {
12
    // 当struct中的tag为 must:"true" 且当前字段值为空值时，输出
13
    if typ.Field(i).Tag.Get("must") == "true" && val.Field(i).IsZero() {
14
      fmt.Println("Fail:", typ.Field(i).Name, "is null")
15
      return
16
    }
17
  }
18
  fmt.Println("Pass")
19
}
20

21
func main() {
22
  note1 := Note{
23
    Time:    time.Now(),
24
    Content: "content",
25
    Remarks: "",
26
  }
27
  validator(&note1)
28
  // Pass
29

30
  note2 := Note{
31
    Time:    time.Now(),
32
    Content: "",
33
    Remarks: "",
34
  }
35
  validator(&note2)
36
  // Fail: Content is null
37
}

展开收起

【杂项】使用gocv库实现视频转终端字符画

Thu, 12 Aug 2021 11:14:06 GMT

1
package main
2

3
import (
4
  "bytes"
5
  "fmt"
6
  "gocv.io/x/gocv"
7
  "golang.org/x/crypto/ssh/terminal"
8
  "image"
9
  "os"
10
  "os/exec"
11
  "time"
12
)
13

14
const pixels = ` .,-'` + `:!1+*abcdefghijklmnopqrstuvwxyz<>()\/{}[]?234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ%&@#$`
15

16
func main() {
17
  // 打开文件
18
  c, err := gocv.VideoCaptureFile("../1.mp4")
19
  // 获取帧数
20
  fps := c.Get(gocv.VideoCaptureFPS)
21
  if err != nil {
22
    panic(err)
23
  }
24

25
  mat := gocv.NewMat()
26
  w, h := 0, 0
27
  // 放大缩小倍率
28
  b := 0
29
  // 每一帧之间时长
30
  s := int64((1 / fps) * 1e6)
31

32
  var t time.Time
33
  // 每一帧时长与每一帧计算时长之差
34
  var sub int64
35

36
  var buf bytes.Buffer
37
  // 转化大小
38
  point := image.Point{Y: 0, X: 0}
39
  for c.Read(&mat) {
40
    t = time.Now()
41
    // 获取终端大小
42
    wl, hl, _ := terminal.GetSize(int(os.Stdout.Fd()))
43
    // 如果终端大小发生变化则重新计算放大缩小倍率
44
    if wl != w || hl != h {
45
      w = wl
46
      h = hl
47
      x, y := mat.Rows(), mat.Cols()
48
      if hl > wl {
49
        if x < wl {
50
          b = wl / x
51
          x *= b
52
          y *= b
53
        } else {
54
          b = x / wl
55
          x /= b
56
          y /= b
57
        }
58
      } else {
59
        if y < hl {
60
          b = hl / y
61
          x *= b
62
          y *= b
63
        } else {
64
          b = y / hl
65
          x /= b
66
          y /= b
67
        }
68
      }
69
      point.X = x
70
      point.Y = y
71
    }
72
    // 转灰度
73
    gocv.CvtColor(mat, &mat, gocv.ColorBGRToGray)
74
    // resize图像大小
75
    gocv.Resize(mat, &mat, point, 0, 0, gocv.InterpolationLinear)
76
    // 图像归一化
77
    mat.DivideFloat(255 / float32(len(pixels)-1))
78
    cols, rows := mat.Cols(), mat.Rows()
79
    buf.Reset()
80
    for i := 0; i < rows; i++ {
81
      for j := 0; j < cols; j++ {
82

83
        // 图像转化字符
84
        buf.WriteByte(pixels[mat.GetSCharAt(i, j)])
85
      }
86
      buf.WriteByte('\n')
87
    }
88
    sub= time.Now().Sub(t).Microseconds()
89
    // 如果比较计算时间与每一帧图像时间
90
    if sub < s {
91
      // 休眠，使字符显示时间靠近源视频每一帧时间
92
      time.Sleep(time.Duration(s-sub) * time.Microsecond)
93
    }
94
    // 清屏
95
    cmd := exec.Command("bash", "-c", "clear")
96
    cmd.Stdout = os.Stdout
97
    cmd.Run()
98
    fmt.Print(buf.String())
99
  }
100
}

展开收起

【杂项】x86机器使用docker交叉编译arm、arm64

Mon, 09 Aug 2021 11:40:46 GMT

0x00#

qemu是一款开源虚拟化软件，通过动态二进制转换来模拟CPU。

这次使用qemu-arm-static来模拟arm环境运行arm镜像。

0x01 注册#

使用命令

Terminal window

1
docker run --rm --privileged multiarch/qemu-user-static --reset -p yes

0x02 使用#

接下来就可以运行arm镜像了

Terminal window展开收起

1
$ docker run --rm -t arm32v6/alpine uname -m
2
armv7l
3

4
$ docker run --rm -t ppc64le/debian uname -m
5
ppc64le
6

7
$ docker run --rm -t s390x/ubuntu uname -m
8
s390x
9

10
$ docker run --rm -t arm64v8/fedora uname -m
11
aarch64
12

13
$ docker run --rm -t arm32v7/centos uname -m
14
armv7l
15

16
$ docker run --rm -t ppc64le/busybox uname -m
17
ppc64le
18

19
$ docker run --rm -t arm64v8/ubuntu uname -m
20
aarch64

展开收起

【Golang】使用gocv库编写三帧法

Wed, 04 Aug 2021 11:55:23 GMT

0x0#

三帧法运动检测属于帧间差分法，相关介绍在之前的文章中有介绍。跳转

这次使用Golang的OpenCV库：gocv 跳转来编写，是最近为了练手gocv而写的第一个demo

0x1#

1
package main
2

3
import (
4
  "gocv.io/x/gocv"
5
)
6

7
func main() {
8
  c, err := gocv.VideoCaptureFile("1.mp4")
9
  if err != nil {
10
    panic(err)
11
  }
12
  mat := gocv.NewMat()
13
  aMat, bMat := gocv.NewMat(), gocv.NewMat()
14
  ab, bc := gocv.NewMat(), gocv.NewMat()
15
  f := gocv.NewMat()
16
  w, err := gocv.VideoWriterFile("test.mp4", c.CodecString(), c.Get(gocv.VideoCaptureFPS), int(c.Get(gocv.VideoCaptureFrameWidth)), int(c.Get(gocv.VideoCaptureFrameHeight)), false)
17

18
  for c.Read(&mat) {
19
    //灰度
20
    gocv.CvtColor(mat, &mat, gocv.ColorBGRToGray)
21
    //二值
22
    gocv.Threshold(mat, &mat, 25, 255, gocv.ThresholdBinary)
23
    if bMat.Empty() {
24
      if aMat.Empty() {
25
        mat.CopyTo(&aMat)
26
      } else {
27
        mat.CopyTo(&bMat)
28
        gocv.AbsDiff(aMat, bMat, &ab)
29
      }
30
      continue
31
    }
32
    gocv.AbsDiff(bMat, mat, &bc)
33
    gocv.BitwiseAnd(ab, bc, &f)
34
    w.Write(f)
35
    bc.CopyTo(&ab)
36
    bMat.CopyTo(&aMat)
37
    mat.CopyTo(&bMat)
38
  }
39
  w.Close()
40
}

展开收起

【算法】动态规划

Fri, 16 Apr 2021 08:13:00 GMT

动态规划（一）#

动态规划（Dynamic Programming）其实是运筹学中一种优化方法，动态规划一般就是求最值，比如最少次数、最短距离等。

求解动态规划的核心问题其实就是 穷举。因为要求出问题的最值，所以需要穷举出每一种答案找到最值。

当存在重复子问题时，如果是暴力穷举就会重复计算，导致效率低下。而优化的方法是建立“备忘录”或“DP数组”，避免重复计算。

例题：凑零钱问题#

现有 k种面额的硬币，面值分别 c1,c2,...,ck，每种硬币的数量是无限的，现在有一个目标金额 amount，问最少需要多少枚硬币可以凑到这个金额，如果凑不出就返回 -1。

假如现有 k=3，面额为 1,2,5的三种硬币，目标金额 amount = 11，则最少需要3枚硬币凑出，即 5 + 5 + 1 = 11。

子问题#

子问题是原问题的划分，例如求f(8)需要求出f(7)，求f(7)需要求出f(6)以此类推，f(8)的子问题是f(7)，f(7)的子问题是f(6)。

凑零钱问题中，求目标 11最少硬币数量，子问题就是 10最少硬币数量，再次划分就是 9最少硬币数量以此类推。

最优子结构#

首先这是一个的动态规划问题，因为它具有“最优子结构”。“最优子结构”的子问题间必须相互独立、互不干扰。

比如：a = b + c，求a的最大值就需要求b和c的最大值，b和c互不干扰，因此这符合“最优子结构”。如果b与c互相干扰，比如增长b那么c就减小，那么就不是“最优子结构”。

凑零钱的问题中，各硬币的数量之间没有限制，硬币总数也是无限的。子问题之间是相互独立的。

状态转移#

动态规划的核心是穷举最值，只有列举出正确的“状态转移方程”才能正确穷举。

思考确定状态转移方程：

确定 base case（最简情况）。在凑零钱中当amount=0时就返回0，表示不需要硬币了。
确定“状态”，也是原问题和子问题的变量。因为硬币是无限的，硬币的面额也是确定的，当目标不断向base case靠近，所以唯一的“状态”就是目标amount。
确定“选择”，也就是导致“状态”产生“变化”的行为。目标amount之所以会变，是因为“选择”了硬币。当选择了面额为1的硬币，那么目标amount=11就变为了amount=10，所以硬币的面额就是选择。
明确dp函数/数组的定义。接下来会先展示递归，所以使用dp函数，dp函数中参数就是状态转移的变量，也就是“状态”，函数返回值就是计算的量。

一、暴力递归解法#

这道题中当目标金额为0 时，所需要的硬币为0；小于0时，无解，返回 -1。状态转移方程：

dp(n)={0,n=0amount+1,n<0min{dp(n−coin)+1∣coin∈coins)},n>0dp(n)=\begin{cases} 0,n=0 \\ amount+1,n<0 \\ min\{dp(n-coin)+1|coin \in coins)\},n>0 \end{cases}dp(n)=⎩⎨⎧0,n=0amount+1,n<0min{dp(n−coin)+1∣coin∈coins)},n>0 代码：

1
//coins为硬币面额，amount为目标金额
2
//coins=[1,2,5]，amount=11
3
func dp(coins []int,amount int)int{
4
    if n==0 {return 0}  // base case
5
    if n<0 {return -1}
6
    num:=amount+1   //因为凑出硬币的数量永远也不可能大于目标金额，所以amount+1表示无穷大。而求最小值，所以初始化无穷大。
7
    //“选择”
8
    for _,coin:=range coins{
9
        sub:=dp(coins,amount - coin)
10
        if sub == -1{continue}  //子问题无解，跳过
11
        //min()
12
        if num > 1+sub{
13
            num = 1+sub
14
        }
15
    }
16
    if num==amount+1{   //没有凑出
17
        return -1
18
    }
19
    return num
20
}

展开收起

递归树：

...

-1

...

-1

通过递归树可以看到，存在 amount相同的重复子问题，从而导致算法效率低下。

递归算法时间复杂度 = 子问题总数时间复杂度 x 每个子问题时间复杂度

在此暴力递归中，子问题总数时间复杂度为O(nk)O(n^{k})O(nk)，每个子问题时间复杂度为O(k)O(k)O(k)。因此本暴力递归的中时间复杂度为O(knk)O(kn^{k})O(knk)。

二、带“备忘录”的递归解法#

从上述的暴力递归树中可以看出，存在许多重复的子问题，这些重复的子问题就是导致算法效率低的主要原因。那么针对这个问题，我们可以建立一个“备忘录”来存储每个子问题计算的结果，在计算子问题之前先查询是有结果存在“备忘录”中，如果存在就直接使用“备忘录”中的值而不再去计算。

一般“备忘录”可以使用数组或哈希表来建立。

代码：

1
var tab []int   //备忘录
2
func dp(coins []int,amount int)int{
3
    //初始化备忘录
4
    if tab == nil{tab=make([]int,len(coins))}
5

6
    if n==0 {return 0}
7
    if n<0 {return -1}
8
    num:=amount+1
9
    for _,coin:=range coins{
10
        i := amount - coin
11
        //查表，若结果不存在的话就进行计算
12
        if tab[i]==0{
13
            tab[i] = dp(coins,i)
14
        }
15
        if tab[i] == -1{continue}
16
        //min()
17
        if num > 1 + tab[i]{
18
            num = 1 + tab[i]
19
        }
20
    }
21
    if num==amount+1{
22
        return -1
23
    }
24
    return num
25
}

展开收起

带有“备忘录”的递归就解决了重复子问题冗余的问题,因此子问题的个数不会超过目标金额nnn，因此带“备忘录”的递归的总时间复杂度为O(kn)O(kn)O(kn)。

三、dp数组迭代解法#

以上递归都是自顶向下的解法，“状态”amount的变化为：11、10、…、0 而dp数组迭代则是自底向上的解法，“状态”amount的变化为：1、2、…、11

dp数组的定义：当目标金额为 n时，最多需要 dp[n]枚硬币。

代码：

1
func coinChange(coins []int,amount int)int{
2
    //创建dp数组，长度为amount+1
3
    dp := make([]int,amount+1)
4

5
    //初始化dp数组，除dp[0]以外都赋值amount+1
6
    //以dp数组下标为各“状态”目标金额。
7
    //当“状态”为0时，结果为零，因此dp[0]=0。base case
8
    //除0其他以外，都赋值amount+1。amount+1为硬币永远也达不到的数量，本题求最少硬币数量，因此amount+1表示无穷大。
9
    for i:=1;i<amount+1;i++{
10
        dp[i] = amount+1
11
    }
12
    //变量所有状态取值
13
    for i:=0;i<len(dp);i++{
14
        //寻找最少硬币数量
15
        for _,coin := range coins{
16
            // 子问题无解，跳过
17
            if i-coin<0 {
18
                continue
19
            }
20
            //min()
21
            if dp[i] > 1+dp[i-coin]{
22
                dp[i] = 1+dp[i-coin]
23
            }
24
        }
25
    }
26
    //结果为amount+1“无穷大”为无解返回-1
27
    if dp[amount] == amount+1{
28
        return -1
29
    }
30
    return dp[amount]
31
}

展开收起

【计算机网络】UDP打洞

Sun, 28 Feb 2021 10:59:00 GMT

UDP打洞#

指用于NAT穿越的一种技术，也即内网穿透技术。

背景介绍#

IPv4枯竭#

现阶段大多网络设备是用IPv4地址作为互联网通信地址，IPv4使用32位（4字节）地址，因此只有4,294,967,296（2³²）个地址可供使用，其间有一些地址是为特殊用途而保留的，如专用网络（约1800万个地址）和多播网络（约2.7个地址），这将减少了互联网中可用的地址。随着时间的变化，接入互联网的设备越来越多，出现了IPv4地址的枯竭的问题。

NAT技术#

NAT全称：Network Address Translation，网络地址转换。是一种在IP数据包通过路由器或防火墙时重写来源IP或目的IP的技术。该技术可以实现多个网络设备共用一个对外IP或公网IP。

因此NAT技术可以缓解IPv4枯竭的问题，目前基本上家用宽带运营商都使用NAT技术为用户赋予IP地址，通常是一层或一栋楼共用一个公网IP（详情根据当地运营商而定）。

NAT.jpg

假如现有内网设备A、NAT(1.1.1.2)和公网服务器(1.1.1.1)

A向服务器发送请求包。
A请求包经过NAT，NAT从中得到请求的目的地址（1.1.1.1）。
NAT保存A的地址和A的目的地址（1.1.1.1），并给A随机分配映射一个端口（1234）。
NAT将A请求包的源地址（A的地址）和源端口，替换为NAT的公网IP和分配给A的端口（1234）。
NAT将请求包向公网服务器（1.1.1.1）发出。
服务器（1.1.1.1）接收到请求包并返回回应包。
NAT接收到回应包，并从中得到回应的端口（1234）。
NAT找查记录，发现与端口（1234）对应的设备是A，并且回应包发送者的IP（1.1.1.1）也在其中。（若两者其中一个不满足就会将此包丢弃）
NAT将回应包的目的IP（1.1.1.2）和目的端口（1234）改为A的地址。
NAT将回应包发送给A。

默认情况下在NAT内网的设备可以主动访问公网IP的设备，但公网IP设备却不能主动访问NAT内网的设备（因为NAT没有记录，对应上述例子第8步）.

打洞#

因为NAT技术的原因，造成两个NAT内网的设备无法直接通信（例如：不能直接访问没有公网IP的电脑）。打洞顾名思义，就是在NAT内网中打出一个洞，让两个不同内网的设备直接访问。

原理#

从上述NAT技术的第4步和第9步，可以看出NAT需要将内网设备映射到一个端口并保存其访问的公网地址和端口，才可以使内网设备和公网设备通信。所以打洞给关键一步就是让两个设备相互访问对方公网对应的IP和端口，让自己的NAT保存记录。

假如现有内网设备A、NAT A(1.1.1.2)、内网设备B、NAT B(1.1.1.3)以及公网服务器(1.1.1.1)，内网设备A和内网设备B想要直接通信。

UDPASS.jpg

A和B向服务器访问，NAT A和NAT B分别为AB分配映射端口4530与6540。
服务器收到请求后，保存IP和端口（1.1.1.2:4530，1.1.1.3:6540）。
服务器向A返回B的IP和端口，向B返回A的IP和端口。
A向B的地址发送数据（NAT B因为没有A的地址记录会丢弃A的包，但是这一步为的是让NAT A记住B的地址，让NAT A以后将带有B地址的包转发给A）。
B再向A发送数据。（这一步也是让NAT B记住A的地址，但上一步NAT A已经有了B的地址，所以这一次B发送的数据可以正常到达A）。
从此A和B就可以直接双向发送数据，洞就被打通了。

UDP#

UDP全称：User Datagram Protocol，用户数据报协议。是一种无连接的协议。

UDP负责将数据发送出去，但对方有没有接收到就不是UDP责任了（就算是错误的IP或端口，UDP也照样发送），因此也是一种不可靠的协议。

但是就很适合使用UDP来做NAT打洞，因为在上述原理第4步的过程中，NAT B没有A的记录就将A的包给丢弃了，在计划里这一步丢包是必然的，而UDP不管对方收到或丢弃。若是用其他可靠协议比如TCP，可能会造成打洞失败的情况，而解决办法就是修改系统内核，但这又非常麻烦。

代码实现#

这里使用Golang进行网络编程。

客户端之所以使用net.ListenUDP()而不是net.DialUDP()，是因为net.ListenUDP()的*UDPConn是unconnected，而net.DialUDP()的*UDPConn是connected的。

如果*UDPConn是connected,读写方法是Read和Write。

如果*UDPConn是unconnected,读写方法是ReadFromUDP和WriteToUDP（以及ReadFrom和WriteTo)。

使用ReadFromUDP和WriteToUDP进行读写可以指定读写任何UDP地址，而且net.ListenUDP()还可以固定本机UDP端口不被系统更换。

服务端demo#

1
type j struct {
2
  Name string `json:"name"`   //客户端名
3
  Addr string `json:"addr"`   //地址
4
  To   string `json:"to"`     //要连接的客户端名
5
}
6
dev := make(map[string]string)  //客户端地址
7

8
addr, _ := net.ResolveUDPAddr("udp", "0.0.0.0:7091")    //服务器端口为7091
9
conn, err := net.ListenUDP("udp", addr)
10
if err != nil {
11
  fmt.Println(err)
12
  os.Exit(1)
13
}
14
defer conn.Close()
15
for {
16
  data := make([]byte, 512)
17
  n, remoteAddr, err := conn.ReadFromUDP(data)    //获取客户端地址
18
  if err != nil {
19
    fmt.Println("f", err)
20
    return
21
  }
22
  var J j
23
  json.Unmarshal(data[:n], &J)
24
  fmt.Println(J)
25
  dev[J.Name] = remoteAddr.String()   //客户端注册
26

27
  if !strings.EqualFold(J.To, "")&& dev[J.To]!="" {
28
    outA,_:=json.Marshal(&j{
29
      Name: J.To,
30
      Addr: dev[J.To],
31
    })
32
    outB,_:=json.Marshal(&j{
33
      Name: J.Name,
34
      Addr: remoteAddr.String(),
35
    })
36
    conn.WriteToUDP(outA,remoteAddr)
37
    adr,_:=net.ResolveUDPAddr("udp",dev[J.To])
38
    conn.WriteToUDP(outB,adr)
39
  }
40
}

展开收起

客户端demo#

1
type j struct {
2
  Name string `json:"name"`
3
  Addr string `json:"addr"`
4
  To   string `json:"to"`
5
}
6
var name = flag.String("name", "", "")  //客户端名
7
var to = flag.String("to", "", "")      //要连接的客户端
8
var msg = flag.String("msg", "", "")    //发送消息
9
var server_ip = flag.String("server", "1.1.1.1", "")    //服务器IP
10
var server_port = flag.Int("sport", 9091, "")                   //服务器端口
11
flag.Parse()
12
conn, _ := net.ListenUDP("udp", &net.UDPAddr{
13
  IP:   net.ParseIP("0.0.0.0"),
14
  Port: 9091,
15
})
16
defer conn.Close()
17
put, _ := json.Marshal(&j{
18
  Name: *name,
19
  To:   *to,
20
})
21
conn.WriteToUDP(put, &net.UDPAddr{
22
  IP:   net.ParseIP(*server_ip),
23
  Port: *server_port,
24
})
25
res := make([]byte, 128)
26
n, _, _ := conn.ReadFromUDP(res)
27
var J j
28
json.Unmarshal(res[:n], &J)
29
fmt.Println(string(res[:n]))
30

31
if *to != "" {
32
  time.Sleep(1 * time.Second)
33
}
34
adr, _ := net.ResolveUDPAddr("udp", J.Addr)
35
conn.WriteToUDP([]byte("qwe"), adr)
36
n, _, _ = conn.ReadFromUDP(res)
37
fmt.Println(string(res[:n]))

展开收起

使用： A运行：./main -name A B运行：./main -name B -to A -msg "qwe"

参考#

1 NAT - wikipedia

2 UDP - wikipedia

【Lua】WOL原理与实现

Fri, 26 Feb 2021 05:16:00 GMT

WOL#

WOL全称为Wake-on-LAN，它的功效在于让休眠状态或关机状态的电脑，透过局域网的另一台电脑对其发令，使其唤醒、恢复成运作状态，或从关机状态转成引导状态[¹]。

简单来说，WOL就是通过网络唤醒开启电脑。

原理#

支持WOL的主板在通电时会监听并分析同一网络下的广播信息（xxx.xxx.xxx.255），在一般的局域网使用有限广播地址即可（255.255.255.255），当发现了“魔法包”（Magic Packet）就会对其进行解读。

魔法包是以广播的形式发送，作用于当前局域网（LAN），也可以是子网（Subnet）。

魔法包介绍#

Magic Packet，是一种广播帧（frame），使用无连接协议，例如：UDP，发送的端口没有限制，可以使用任何端口进行发送，但一般约定俗成使用7或9号端口发送。大部分情况下，魔法包在数据链路层（OSI第2层）发送，使用广播地址进行广播，但也可以使用特定IP地址进行发送（OSI第3层）。

由于采用的是无连接协议，所以不保证数据包被目标机接收。

魔法包结构#

魔法包最简单的构成是6个十六进制的255（ff ff ff ff ff ff）共6字节为数据包的头部标识，后面是目标机的十六进制MAC地址，并将MAC重复16次，到此数据包共102字节。有时数据包内还会紧接着4-6字节的密码信息。这个帧片段可以包含在任何协议中，最常见的是包含在 UDP 中。[²]

例如目标机MAC为：1a:2b:3c:4d:5e:6f

6字节头	96字节信息=MAC信息x12	4-6字节密码（可空）
ff ff ff ff ff ff	1a2b3c4d5e6f 1a2b3c4d5e6f 1a2b3c4d5e6f 1a2b3c4d5e6f 1a2b3c4d5e6f 1a2b3c4d5e6f 1a2b3c4d5e6f 1a2b3c4d5e6f 1a2b3c4d5e6f 1a2b3c4d5e6f 1a2b3c4d5e6f 1a2b3c4d5e6f	密码

代码实现#

我是用的是esp8266，刷入NodeMCU固件，是用LUA进行编程实现。

NodeMCU编译时起码需要编译net和wifi两个模块，并正确配置和连上wifi。

1
mac = '1a2b3c4d5e6f'    -- 要进行目标主机的MAC地址
2

3
bip = '255.255.255.255' -- 路由器广播地址
4
head = 'FFFFFFFFFFFF'   -- 数据头
5
head = to(head)
6
mac = to(mac)
7
for i = 1, 16 do
8
    head = head .. mac
9
end
10
u = net.createUDPSocket()
11
u:send(1234, bip, head)    -- 是用9号端口
12
u:close()
13

14
-- 将两个一组字符串表示的十六进制转为十六进制的字符串
15
-- 'ff'(66 66) -> 0xff -> '.'(255)
16
function to(str)
17
    ret = ''
18
    for i = 1, string.len(str), 2 do
19
        byte = ('0x' .. string.sub(str, 0 + i, 1 + i))
20
        a = tonumber(byte)
21
        ret = ret .. string.char(a)
22
    end
23
    return ret
24
end

展开收起

参考#

[1] wikipedia
[2] 网络唤醒（WOL）全解指南：原理篇

【python】查看v2ray流量统计脚本

Fri, 11 Dec 2020 07:39:00 GMT

查看v2ray多用户流量统计

使用前需要开启v2ray自带的统计工具，配置方法：https://guide.v2fly.org/advanced/traffic.html#%E9%85%8D%E7%BD%AE%E7%BB%9F%E8%AE%A1%E5%8A%9F%E8%83%BD

本脚本使用email作为用户标识，使用tag作为组标识

获取#

Github
wget https://raw.githubusercontent.com/Rehtt/v2ray-tools/main/v2ray-flow.py
复制下方代码

使用#

1
v2ray-flow.py [-h] [-g <tag>] [-c <file>] [-s <server>]
2
默认显示全部用户
3

4
-h,--help       显示帮助
5
-g <tag>        显示组的流量
6
        -g A            (显示tag:A组的流量)
7

8
-c <file>       输入v2ray配置文件
9
        -c /etc/v2ray/config.json
10

11
-s <server>     输入v2ctl api server地址
12
        -s 127.0.0.1:53844

代码#

1
#!/bin/python3
2

3
# Created by Rehtt on 2020/12/11
4
# 查看v2ray多用户流量统计
5
# 使用前需要开启v2ray自带的统计工具，配置方法：https://guide.v2fly.org/advanced/traffic.html#%E9%85%8D%E7%BD%AE%E7%BB%9F%E8%AE%A1%E5%8A%9F%E8%83%BD
6
# 本脚本使用email作为用户标识，使用tag作为组标识
7

8
import re
9
import os
10
import json
11
import getopt
12
import sys
13

14
v2ConfigFile = '/etc/v2ray/config.json'  # v2ray配置文件位置
15
v2ctlServer = '127.0.0.1:53844'  # v2ctl api配置信息
16

17

18
def dataSize(size, i=0):
19
    if size > 1e3:
20
        size /= 1e3
21
        s = dataSize(size, i+1)
22
    else:
23
        size = round(size, 2)
24
        if i == 1:
25
            s = str(size)+'KB'
26
        elif i == 2:
27
            s = str(size)+'MB'
28
        elif i >= 3:
29
            s = str(size)+'GB'
30
    return s
31

32

33
def red(f):
34
    return '\033[31m'+f+'\033[0m'
35

36

37
def help():
38
    print("v2ray-flow.py [-h] [-g <tag>] [-c <file>] [-s <server>]")
39
    print("默认显示全部用户\n")
40
    print("-h,--help\t显示帮助")
41
    print("-g <tag>\t显示组的流量")
42
    print("\t-g A\t\t(显示tag:A组的流量)\n")
43
    # print("-u <email>\t显示单个用户流量")
44
    # print("\t-u rehtt@qq.com\t(显示email为rehtt@qq.com的流量)\n")
45
    print("-c <file>\t输入v2ray配置文件")
46
    print("\t-c /etc/v2ray/config.json\n")
47
    print("-s <server>\t输入v2ctl api server地址")
48
    print("\t-s 127.0.0.1:53844")
49

50

51
def getDownUp(name, res):
52
    i = 0
53
    z = 0
54
    down = 0
55
    up = 0
56
    try:
57
        for r in res:
58
            i += 1
59
            if name in r:
60
                z += 1
61
                if 'downlink' in r:
62
                    down = dataSize(float(re.sub('\D', '', res[i])))
63
                else:
64
                    up = dataSize(float(re.sub('\D', '', res[i])))
65
                if z == 2:
66
                    break
67
    except:
68
        pass
69
    return down, up
70

71

72
def main(argv):
73
    global v2ctlServer, v2ConfigFile
74
    c = '/usr/bin/v2ray/v2ctl api --server={server} StatsService.QueryStats \'pattern: "{q}" reset: false\''
75
    try:
76
        opts, args = getopt.getopt(argv, "hg:c:s:u:", ["help"])
77
    except getopt.GetoptError:
78
        help()
79
        sys.exit(2)
80
    q = 'user'
81
    G = 0
82
    for opt, arg in opts:
83
        if opt in ('-h', '--help'):
84
            help()
85
            sys.exit()
86
        elif opt == '-g':
87
            q = arg
88
            G = 1
89
        # elif opt == '-u':
90
        #     q = arg
91
        #     G = 2
92
        if opt == '-c':
93
            v2ConfigFile = arg
94
        if opt == '-s':
95
            v2ctlServer = arg
96
    tags = {}
97

98
    c = c.format(server=v2ctlServer, q=q)
99
    res = os.popen(c).readlines()
100
    if G == 0:
101
        with open(v2ConfigFile, 'r') as f:
102
            data = json.load(f)
103
            for i in data['inbounds']:
104
                if i['tag'] != 'api':
105
                    emails = []
106
                    for email in i['settings']['clients']:
107
                        emails.append(email['email'])
108
                    tags[i['tag']] = emails
109
        for tag in tags:
110
            for email in tags[tag]:
111
                down, up = getDownUp(email, res)
112
                print('Email:', red(email), '\tTag:'+red(tag))
113
                print('上传:', up, '\t下载:', down, '\n')
114
    else:
115
        if G==1:
116
            print('Tag:', red(q))
117
            down, up = getDownUp(q, res)
118
        # else:
119
        #     print('Email:', red(q))
120
        print('上传:', up, '\t下载:', down, '\n')
121

122

123

124
if __name__ == "__main__":
125
    main(sys.argv[1:])

展开收起

【杂项】PSP作为PC电脑的WiFi手柄

Fri, 16 Oct 2020 15:00:00 GMT

0x00#

使用软件：

WiFi Controller（PSP）（下载）
PPJoy （PC）（下载）

实现原理是在通过PSP上运行WiFi Controller，将PSP的按键传送到PC上，PC再使用PPJoy将PSP的按键映射为一个虚拟的游戏手柄。

Warning

PSP的按键数量相对目前主流游戏手柄少。主要缺少LT、RT和右摇杆

0x01#

PSP#

下载WiFi Controller解压并进入文件夹，找到对应PSP版本的文件夹（分别为：1.00 1.50 3.40），修改文件夹中的wifi.cfg，将address改为PC的IP地址。最后将文件夹复制到PSP内存卡中。

PC#

下载PPJoy解压，进入文件夹并执行安装程序，安装流畅一路next。安装途中会有两次驱动安装的警告，选择允许安装。

Warning

安装会重启PC，重启后会进入测试模式（PC桌面右下角会有显示）

安装完成后会运行Parallel Port Joysticks程序（手动在控制面板开启：‘控制面板’ -> ‘硬件和声音’ -> ‘Parallel Port Joysticks（32位）‘）新建虚拟手柄。

新建虚拟手柄：

新建一个虚拟手柄点击Add...->add。
选中刚刚创建的手柄点击Mapping...。
选中Set a custom mapping for this controller，点击下一步。

Axes改为2，Axis 1和Axis 2分别为X Axis和Y Axis
Buttons改为9
POV hats改为1。

X Axis为Analog 0
Y Axis为Analog 1

修改

Button 1为nothing
Button 2为Digital 0
Button 3为Digital 1
Button 4为Digital 2
Button 5为Digital 3
Button 6为Digital 4
Button 7为Digital 5
Button 8为Digital 11
Button 9为Digital 10

0x02#

PC#

进入WiFi Controller解压的文件夹PC内，双击执行Start WiFiServer for Controller 1.bat（文件夹内其他的bat文件对应其他的虚拟手柄，通过上述新建虚拟手柄的方式创建）。

PSP#

打开PSP，运行WiFi Controller，稍等片刻，出现键位示意画面即连接成功。

从PC控制面板中的游戏控制器->属性->测试中可以看见具体的映射情况。

END#

【Docker】macvlan网络模式下容器与宿主机互通

Tue, 08 Sep 2020 14:32:00 GMT

0x00#

一般在macvlan模式下同网段的其他机器可以和容器互通，但宿主不能和容器互通，这是在macvlan模式设计的时候为了安全而禁止了宿主机和容器直接通信。

如果想要实现互通，有个曲线救国的方法，就是macvlan与macvlan之间可以互通，只需要在宿主机再创建一个macvlan网络，然后修改路由，让数据经过这个macvlan达到互通的目的。

0x01#

假设现有网段为192.168.1.0/24的网络：

名字	ip	接口
宿主机	192.168.1.10	eth0
容器	192.168.1.20	macvlan

建立一个名为macvlan2的macvlan接口，并分配一个ip：

名字	ip	接口
macvlan2	192.168.1.15	macvlan

命令：

Terminal window

1
ip link add macvlan2 link eth0 type macvlan mode bridge
2
ip addr add 192.168.1.15 dev macvlan2
3
ip link set macvlan2 up

修改路由，让宿主机到容器(192.168.1.20)的数据经过macvlan2:

Terminal window

1
ip route add 192.168.1.20 dev macvlan2

0x02#

宿主机访问容器的ip：192.168.1.20

容器访问宿主机ip：192.168.1.15

【树莓派】温控风扇脚本（shell版）

Sun, 06 Sep 2020 02:59:00 GMT

一个简单的脚本，和python版的一样，只是去除python版的RPi库的依赖。较为完善的是Golang版

配合crontab做定时任务

1
#每五分钟执行一次
2
*/5 * * * * /home/pi/fen.sh

fen.sh文件

1
#!/bin/bash
2
a=$(cat /sys/class/thermal/thermal_zone0/temp)
3
temp=$((a/1000))
4
pin=14
5

6
if [ ! -d "/sys/class/gpio/gpio${pin}" ]
7
then
8
        echo $pin > /sys/class/gpio/export
9
fi
10

11
if [ $temp -lt 50 ]
12
then
13
        echo low > /sys/class/gpio/gpio${pin}/direction
14
elif [ $temp -gt 55 ]
15
then
16
        echo high > /sys/class/gpio/gpio${pin}/direction
17
fi

展开收起

新版本系统使用上述脚本失败，使用下面脚本#

2025-01-04

1
#!/bin/bash
2
a=$(cat /sys/class/thermal/thermal_zone0/temp)
3
temp=$((a/1000))
4
pin=14
5

6
if [ $temp -lt 50 ]
7
then
8
  pinctrl set $pin ip pd
9
elif [ $temp -gt 55 ]
10
then
11
  pinctrl set $pin op dh
12
fi

【算法/图像处理】运动检测--帧间差分法

Fri, 24 Jul 2020 10:01:00 GMT

0x00#

帧间差分法顾名思义，就是将视频的前后帧对应的像素点进行差运算得出差值。

0x01 原理#

首先将视频每帧画面转为二值图（即只有“白”与“黑”两种颜色的图），再将前后帧进行差运算。当前后帧的同一个像素点的差值不为零，并且差值的绝对值超过设定的阈值时，就可以判断画面发生了移动。

0x02 优点#

算法简单，程序实现的难度不高
对光线的变化感知不明显（只要光线变化不是太大，二值化后的图像基本相同）
能够适应各种动态变化的图像，稳健性较强

0x03 缺点#

对于快速移动的物体，画面容易变“糊”，过快的话甚至会被认为是两个物体
对于慢速移动的物体，由于速度过慢导致前后帧几乎重合，而检测不到物体
检测出的物体有“空洞”，只能检测出移动物体的外边，而且检测出来的外边要比物体实际的轮廓大

0x10 相邻帧间差分法#

相邻帧间差分法就是二帧法，对相邻的两帧图像做差运算，取差值的绝对值构成移动物体。

其优点是实时性高，运算快速。但光照突变的情况下效果不好。

0x11 代码实现#

使用 opencv-python进行演示

1
import cv2
2

3
#上一帧
4
lastFram = None
5
#我这的视频源是使用网络摄像头
6
cap = cv2.VideoCapture("rtsp://admin:admin@192.168.31.89:8445/live")
7
while (cap.isOpened()):
8
    #逐帧读取摄像头画面
9
    ret, fram = cap.read()
10
    #转为灰度图
11
    fram = cv2.cvtColor(fram, cv2.COLOR_BGR2GRAY)
12
    #转为二值图
13
    fram = cv2.threshold(fram, 25, 255, cv2.THRESH_BINARY)[1]
14
    #初始帧
15
    if lastFram is None:
16
        lastFram = fram
17
        continue
18
    #将上一帧与当前帧做差运算
19
    frameDelta = cv2.absdiff(lastFram, fram)
20
    #当前帧设为上一帧
21
    lastFram = fram.copy()
22
    #显示
23
    cv2.imshow("f", fram)
24
    if cv2.waitKey(1) & 0xFF == ord('q'):
25
        break
26
cap.release()
27
cv2.destroyAllWindows()

展开收起

1.png

0x20 三帧法#

三帧就是在二帧让的基础上，进行与运算。

假设有A、B、C三帧，AB做差运算，BC做差运算，再将两个差运算做与运算。

相比二帧更适用于移动较快的情况。

0x21 程序实现#

1
import cv2
2

3
#A帧
4
aFram = None
5
#B帧
6
bFram = None
7
#我这的视频源是使用网络摄像头
8
cap = cv2.VideoCapture("rtsp://admin:admin@192.168.31.89:8445/live")
9
while (cap.isOpened()):
10
    #逐帧读取摄像头画面
11
    ret, fram = cap.read()
12
    #转为灰度图
13
    fram = cv2.cvtColor(fram, cv2.COLOR_BGR2GRAY)
14
    #转为二值图
15
    fram = cv2.threshold(fram, 25, 255, cv2.THRESH_BINARY)[1]
16
    #初始帧
17
    if bFram is None:
18
        if aFram is None:
19
            aFram = fram.copy()
20
        else:
21
            bFram = fram.copy()
22
            global abFram
23
            abFram = cv2.absdiff(aFram, bFram)
24
        continue
25

26
    bcFram = cv2.absdiff(bFram, fram)
27
    #与运算
28
    thresh = cv2.bitwise_and(adFram,bcFram)
29

30
    abFram = bcFram.copy()
31
    aFram = bFram.copy()
32
    bFram = fram.copy()
33
    #显示
34
    cv2.imshow("f", thresh)
35
    if cv2.waitKey(1) & 0xFF == ord('q'):
36
        break
37
cap.release()
38
cv2.destroyAllWindows()

展开收起

【杂项】Windows10 深色模式下文件资源管理器有一条白线

Tue, 26 May 2020 09:26:00 GMT

0x00#

Windows 10的深色模式下文件管理器的地址栏下有一条白线

QQ截图20200526155002.jpg

0x01 解决方法#

打开IE浏览器，右键栏选择锁定工具栏

批注 2020-05-26 171922.png

【Golang】使用CGO交叉编译

Wed, 08 Apr 2020 10:23:00 GMT

0x00#

Golang可以在一个平台交叉编译多个平台的程序，但是在默认情况下Golang中编译C语言的CGO不支持交叉编译。通过查询资料和阅读官方文档了解到CGO默认使用本地计算机自带的gcc和g++编译器，所以可以修改默认的编译器使用自己准备的编译器来进行交叉编译。

这里演示的是使用CGO在Linux下编译Windows程序我在这里环境是WSL/Kali (Windows是最好的Linux发行版（滑稽）) 我之所以选择WSL是因为Linux的包相对Windows好管理，而且windows下有一些软件都是linux的移植版比如gcc编译器等，并且WSL的开销比传统虚拟机要小。

0x01 安装#

首先在安装Linux编译Windows的交叉编译器mingw-w64

Terminal window

1
sudo apt install mingw-w64

这句命令主要安装了:

32位windows编译器i686-w64-mingw32-gcc和i686-w64-mingw32-g++
64位windows编译器x86_64-w64-mingw32-gcc和x86_64-w64-mingw32-g++

单独安装#

Terminal window

1
sudo apt install gcc-mingw-w64-x86-64-win32 g++-mingw-w64-x86-64-win32
2

3
sudo apt install gcc-mingw-w64-i686-win32 g++-mingw-w64-i686-win32

0x02 使用#

进行编译时配置环境变量

Terminal window

1
编译64位windows程序
2
export GOOS=windows
3
export GOARCH=amd64
4
export CC=x86_64-w64-mingw32-gcc
5
export CXX=x86_64-w64-mingw32-g++
6
export CGO_ENABLED=1
7

8
编译32位windows程序
9
export GOOS=windows
10
export GOARCH=386
11
export CC=i686-w64-mingw32-gcc
12
export CXX=i686-w64-mingw32-g++
13
export CGO_ENABLED=1

最后使用go build等命令进行编译

0x03 实用脚本#

64位编译#

1
#!/bin/bash
2
export GOOS=windows
3
export GOARCH=amd64
4
export CC=x86_64-w64-mingw32-gcc
5
export CXX=x86_64-w64-mingw32-g++
6
export CGO_ENABLED=1
7
cd $(pwd)
8
go build $*

32位编译#

1
#!/bin/bash
2
export GOOS=windows
3
export GOARCH=386
4
export CC=i686-w64-mingw32-gcc
5
export CXX=i686-w64-mingw32-g++
6
export CGO_ENABLED=1
7
cd $(pwd)
8
go build $*

将代码保存文件，编译时在要进行编译的源码目录直接执行这个文件，例如：

Terminal window

1
例如文件保存路径为/bin/cgo-w64-x86_64
2

3
在进行编译的目录下执行
4

5
$ /bin/cgo-w64-x86_64
6
等同于
7
$ go build
8

9
$ /bin/cgo-w64-x86_64 -ldflags="-X pkg.variable1=value -X pkg.variable2=value"
10
等同于
11
$ go build -ldflags="-X pkg.variable1=value -X pkg.variable2=value"
12
其他以此类推

0x04 其他架构的编译器#

1
gccgo-aarch64-linux-gnu
2

3
gccgo-alpha-linux-gnu
4

5
gccgo-arm-linux-gnueabi
6

7
gccgo-arm-linux-gnueabihf
8

9
gccgo-i686-linux-gnu
10

11
gccgo-multilib-i686-linux-gnu
12

13
gccgo-multilib-powerpc-linux-gnu
14

15
gccgo-multilib-powerpc64-linux-gnu
16

17
gccgo-multilib-s390x-linux-gnu
18

19
gccgo-multilib-sparc64-linux-gnu
20

21
gccgo-multilib-x86-64-linux-gnux32
22

23
gccgo-powerpc-linux-gnu
24

25
gccgo-powerpc64-linux-gnu
26

27
gccgo-powerpc64le-linux-gnu
28

29
gccgo-riscv64-linux-gnu
30

31
gccgo-s390x-linux-gnu
32

33
gccgo-sparc64-linux-gnu
34

35
gccgo-x86-64-linux-gnux32

展开收起

【Linux】man显示中文

Sat, 04 Apr 2020 05:56:24 GMT

0x00 man是个非常有用的linux命令帮助工具，里面有非常详细的帮助文档，但对于英语不好的人来说学习起来就比较困难。

0x01 man -M /usr/share/man/zh_CN可以将内容显示为中文。

在.bashrc中增加 cman=‘man -M /usr//share/man/zh_CN’

【杂项】Virtualbox 6与Hyper-V共存

Sat, 15 Feb 2020 09:11:00 GMT

0x00#

Virualbox（以下均称Vbox）以小巧开源免费等优势与VM和Hyper-v同台竞技。而Hyper-v靠着“巨硬”这个爸爸在Windows平台上也有非常优秀的表现，特别是最近Windows10新更新的“Windows沙盒”与“WSL2”这两个非常棒的工具就是使用Hyper-v虚拟技术实现的。但是这又会遇到一个“致命”问题，那就是Hyper-v不能与vbox和vm共存，原因是Hyper-v的虚拟方式不一样，开启Hyper-v后会将用户的桌面系统给虚拟化，用户的桌面系统就会成为Hyper-v的虚拟系统，而Hyper-v的虚拟系统是不允许再开虚拟机的，因此开启Hyper-v后VM和Vbox就不能运行。

虚拟方式

而Vbox在第六个版本（Vbox6.0）中新增了利用Hyper-v的api进行虚拟化系统

Caution

这个功能还是实验性的功能，可能会出现意想不到的问题，出现问题请向官方反馈以助于完善。

0x01#

由于这个功能还是实验性的功能，所以没有现成的GUI按钮或界面开启这个功能，需要使用命令行开启。找到vbox的安装目录，确定目录下有VBoxManage.exe 在该目录打开命令行工具（目录空白位置按住shift 鼠标点击右键，选择在此处打开命令窗口或在此处打开PwerShell窗口）命令窗口(cmd)输入：

Terminal window

1
#指定vbox下的虚拟系统开启这个功能
2
VBoxManage setextradata "<虚拟机名字>" "VBoxInternal/NEM/UseRing0Runloop" 0
3

4
#或指定vbox所有虚拟系统开启
5
VBoxManage setextradata global "VBoxInternal/NEM/UseRing0Runloop" 0

PowerShell需要加./和.exe

Terminal window

1
#指定vbox下的虚拟系统开启这个功能
2
./VBoxManage.exe setextradata "<虚拟机名字>" "VBoxInternal/NEM/UseRing0Runloop" 0
3

4
#或指定vbox所有虚拟系统开启
5
./VBoxManage.exe setextradata global "VBoxInternal/NEM/UseRing0Runloop" 0

0x02#

开启后就可以体验Hyper-v与Vbox双开的快乐了。但VM暂时还没有和Hyper-v共存的方法

[杂项]handsome主题美化

Wed, 12 Feb 2020 10:23:00 GMT

0x00#

handsome主题是基于Typecho博客框架打造的一款强大的付费主题主题页面

0x01 Mac风格代码高亮#

作者页面

0x02 底部页脚标签样式#

将以下添加至自定义CSS中

1
/*底部页脚*/
2
.github-badge {
3
  display: inline-block;
4
  border-radius: 4px;
5
  text-shadow: none;
6
  font-size: 12px;
7
  color: #fff;
8
  line-height: 15px;
9
  background-color: #abbac3;
10
  margin-bottom: 5px
11
}
12

13
.github-badge .badge-subject {
14
  display: inline-block;
15
  background-color: #4d4d4d;
16
  padding: 4px 4px 4px 6px;
17
  border-top-left-radius: 4px;
18
  border-bottom-left-radius: 4px
19
}
20

21
.github-badge .badge-value {
22
  display: inline-block;
23
  padding: 4px 6px 4px 4px;
24
  border-top-right-radius: 4px;
25
  border-bottom-right-radius: 4px
26
}
27

28
.github-badge .bg-blue {
29
  background-color: #007ec6
30
}
31

32
.github-badge .bg-orange {
33
  background-color: #ffa500
34
}
35

36
.github-badge .bg-red {
37
  background-color: #f00
38
}
39

40
.github-badge .bg-green {
41
  background-color: #3bca6e
42
}
43

44
.github-badge .bg-purple {
45
  background-color: #ab34e9
46
}

展开收起

将以下内容添加至博客底部左侧信息,将内容改成自己的

1
<div class="github-badge">
2
<a href="./" title="©2019&nbsp;Alvin">
3
<span class="badge-subject">Copyright</span><span class="badge-value bg-blue">©2019&nbsp;Alvin</span>
4
</a>
5
</div>
6
&nbsp;|&nbsp;
7
<div class="github-badge">
8
<a href="http://www.miitbeian.gov.cn/" target="_blank" title="粤ICP备 xxx号" style="cursor: url(&quot;/usr/plugins/HoerMouse/static/image/dew/link.cur&quot;), pointer;">
9
<span class="badge-subject">粤ICP备</span><span class="badge-value bg-green">xxx号</span>
10
</a>
11
</div>

将以下内容添加至博客底部右侧信息

1
<div class="github-badge">
2
<a href="http://www.typecho.org" target="_blank" title="由 Typecho 强力驱动" style="cursor: url(&quot;/usr/plugins/HoerMouse/static/image/dew/link.cur&quot;), pointer;">
3
<span class="badge-subject">Powered</span><span class="badge-value bg-blue">Typecho</span>
4
</a>
5
</div>
6
&nbsp;|&nbsp;
7
<div class="github-badge">
8
<a href="https://www.ihewro.com/archives/489/" target="_blank" title="站点使用 handsome 主题，作者：友人C" style="cursor: url(&quot;/usr/plugins/HoerMouse/static/image/dew/link.cur&quot;), pointer;">
9
<span class="badge-subject">Theme</span><span class="badge-value bg-orange">Handsome</span>
10
</a>
11
</div>

修改handsome\component\footer.php文件删除

1
Powered by <a target="blank" href="http://www.typecho.org">Typecho</a>&nbsp;|&nbsp;Theme by <a target="blank" href="https://www.ihewro.com/archives/489/">handsome</a>

删除代码:© <?php echo date("Y");?> Copyright 

0x03 评论获取用户信息插件#

作者页面

0x04 文本框打字机特效#

添加代码至自定义js

1
(function webpackUniversalModuleDefinition(a,b){if(typeof exports==="object"&&typeof module==="object"){module.exports=b()}else{if(typeof define==="function"&&define.amd){define([],b)}else{if(typeof exports==="object"){exports["POWERMODE"]=b()}else{a["POWERMODE"]=b()}}}})(this,function(){return(function(a){var b={};function c(e){if(b[e]){return b[e].exports}var d=b[e]={exports:{},id:e,loaded:false};a[e].call(d.exports,d,d.exports,c);d.loaded=true;return d.exports}c.m=a;c.c=b;c.p="";return c(0)})([function(c,g,b){var d=document.createElement("canvas");d.width=window.innerWidth;d.height=window.innerHeight;d.style.cssText="position:fixed;top:0;left:0;pointer-events:none;z-index:999999";window.addEventListener("resize",function(){d.width=window.innerWidth;d.height=window.innerHeight});document.body.appendChild(d);var a=d.getContext("2d");var n=[];var j=0;var k=120;var f=k;var p=false;o.shake=true;function l(r,q){return Math.random()*(q-r)+r}function m(r){if(o.colorful){var q=l(0,360);return"hsla("+l(q-10,q+10)+", 100%, "+l(50,80)+"%, "+1+")"}else{return window.getComputedStyle(r).color}}function e(){var t=document.activeElement;var v;if(t.tagName==="TEXTAREA"||(t.tagName==="INPUT"&&t.getAttribute("type")==="text")){var u=b(1)(t,t.selectionStart);v=t.getBoundingClientRect();return{x:u.left+v.left,y:u.top+v.top,color:m(t)}}var s=window.getSelection();if(s.rangeCount){var q=s.getRangeAt(0);var r=q.startContainer;if(r.nodeType===document.TEXT_NODE){r=r.parentNode}v=q.getBoundingClientRect();return{x:v.left,y:v.top,color:m(r)}}return{x:0,y:0,color:"transparent"}}function h(q,s,r){return{x:q,y:s,alpha:1,color:r,velocity:{x:-1+Math.random()*2,y:-3.5+Math.random()*2}}}function o(){var t=e();var s=5+Math.round(Math.random()*10);while(s--){n[j]=h(t.x,t.y,t.color);j=(j+1)%500}f=k;if(!p){requestAnimationFrame(i)}if(o.shake){var r=1+2*Math.random();var q=r*(Math.random()>0.5?-1:1);var u=r*(Math.random()>0.5?-1:1);document.body.style.marginLeft=q+"px";document.body.style.marginTop=u+"px";setTimeout(function(){document.body.style.marginLeft="";document.body.style.marginTop=""},75)}}o.colorful=false;function i(){if(f>0){requestAnimationFrame(i);f--;p=true}else{p=false}a.clearRect(0,0,d.width,d.height);for(var q=0;q<n.length;++q){var r=n[q];if(r.alpha<=0.1){continue}r.velocity.y+=0.075;r.x+=r.velocity.x;r.y+=r.velocity.y;r.alpha*=0.96;a.globalAlpha=r.alpha;a.fillStyle=r.color;a.fillRect(Math.round(r.x-1.5),Math.round(r.y-1.5),3,3)}}requestAnimationFrame(i);c.exports=o},function(b,a){(function(){var d=["direction","boxSizing","width","height","overflowX","overflowY","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","borderStyle","paddingTop","paddingRight","paddingBottom","paddingLeft","fontStyle","fontVariant","fontWeight","fontStretch","fontSize","fontSizeAdjust","lineHeight","fontFamily","textAlign","textTransform","textIndent","textDecoration","letterSpacing","wordSpacing","tabSize","MozTabSize"];var e=window.mozInnerScreenX!=null;function c(k,l,o){var h=o&&o.debug||false;if(h){var i=document.querySelector("#input-textarea-caret-position-mirror-div");if(i){i.parentNode.removeChild(i)}}var f=document.createElement("div");f.id="input-textarea-caret-position-mirror-div";document.body.appendChild(f);var g=f.style;var j=window.getComputedStyle?getComputedStyle(k):k.currentStyle;g.whiteSpace="pre-wrap";if(k.nodeName!=="INPUT"){g.wordWrap="break-word"}g.position="absolute";if(!h){g.visibility="hidden"}d.forEach(function(p){g[p]=j[p]});if(e){if(k.scrollHeight>parseInt(j.height)){g.overflowY="scroll"}}else{g.overflow="hidden"}f.textContent=k.value.substring(0,l);if(k.nodeName==="INPUT"){f.textContent=f.textContent.replace(/\s/g,"\u00a0")}var n=document.createElement("span");n.textContent=k.value.substring(l)||".";f.appendChild(n);var m={top:n.offsetTop+parseInt(j["borderTopWidth"]),left:n.offsetLeft+parseInt(j["borderLeftWidth"])};if(h){n.style.backgroundColor="#aaa"}else{document.body.removeChild(f)}return m}if(typeof b!="undefined"&&typeof b.exports!="undefined"){b.exports=c}else{window.getCaretCoordinates=c}}())}])});
2
POWERMODE.colorful=true;POWERMODE.shake=false;document.body.addEventListener("input",POWERMODE);

0x05 博主介绍闪字特效#

添加代码至博主的介绍

1
<!--博主介绍的闪字特效-->
2
<span class="text-muted text-xs block"><div id="chakhsu"></div> <script> var chakhsu = function (r) {function t() {return b[Math.floor(Math.random() * b.length)]} function e() {return String.fromCharCode(94 * Math.random() + 33)} function n(r) {for (var n = document.createDocumentFragment(), i = 0; r > i; i++) { var l = document.createElement("span"); l.textContent = e(), l.style.color = t(), n.appendChild(l) } return n}function i() {var t = o[c.skillI]; c.step ? c.step-- : (c.step = g, c.prefixP < l.length ? (c.prefixP >= 0 && (c.text += l[c.prefixP]), c.prefixP++) : "forward" === c.direction ? c.skillP < t.length ? (c.text += t[c.skillP], c.skillP++) : c.delay ? c.delay-- : (c.direction = "backward", c.delay = a) : c.skillP > 0 ? (c.text = c.text.slice(0, -1), c.skillP--) : (c.skillI = (c.skillI + 1) % o.length, c.direction = "forward")), r.textContent = c.text, r.appendChild(n(c.prefixP < l.length ? Math.min(s, s + c.prefixP) : Math.min(s, t.length - c.skillP))), setTimeout(i, d) } /*以下内容自定义修改*/ var l = "", o = ["Keep Fighting" ].map(function (r) {return r + ""}), a = 2, g = 1, s = 5, d = 75, b = ["rgb(110,64,170)", "rgb(150,61,179)", "rgb(191,60,175)", "rgb(228,65,157)", "rgb(254,75,131)", "rgb(255,94,99)", "rgb(255,120,71)", "rgb(251,150,51)", "rgb(226,183,47)", "rgb(198,214,60)", "rgb(175,240,91)", "rgb(127,246,88)", "rgb(82,246,103)", "rgb(48,239,130)", "rgb(29,223,163)", "rgb(26,199,194)", "rgb(35,171,216)", "rgb(54,140,225)", "rgb(76,110,219)", "rgb(96,84,200)"], c = {text: "", prefixP: -s, skillI: 0, skillP: 0, direction: "forward", delay: a, step: g}; i() }; chakhsu(document.getElementById('chakhsu')); </script> </span> </span>

0x06 复制提示特效#

添加代码至自定义js

1
<script defer src="https://cdn.staticfile.org/limonte-sweetalert2/8.11.8/sweetalert2.all.min.js"></script>

1
document.body.oncopy = function(){Swal.fire({allowOutsideClick:false,type:'success',title: '复制成功,如转载请注明出处！',showConfirmButton: false,timer: 2000});};

0x07 文章底部赞赏图标跳动#

添加代码至自定义css

1
/*赞赏图标跳动*/
2
.btn-pay {
3
    animation: star 0.5s ease-in-out infinite alternate;
4
}
5

6
@keyframes star {
7
    from {
8
        transform: scale(1);
9
    }
10

11
    to {
12
        transform: scale(1.1);
13
    }
14
}

0x07 彩色标签云#

添加至自定义js

1
let tags = document.querySelectorAll("#tag_cloud-2 a");
2
let colorArr = ["#428BCA", "#AEDCAE", "#ECA9A7", "#DA99FF", "#FFB380", "#D9B999"];
3
tags.forEach(tag => {
4
    tagsColor = colorArr[Math.floor(Math.random() * colorArr.length)];
5
    tag.style.backgroundColor = tagsColor;
6
});

如果主题中启用了pjax，还需要将上面代码添加到pjax-pjax回调函数中

0x08 首页文章列表悬停上浮#

添加至自定义CSS

1
.blog-post .panel:not(article) {
2
    transition: all 0.3s;
3
}
4

5
.blog-post .panel:not(article):hover {
6
    transform: translateY(-10px);
7
    box-shadow: 0 8px 10px rgba(73, 90, 47, 0.47);
8
}

0x09 首页文章列表头图悬停放大并将超出范围隐藏#

添加至自定义CSS

1
.index-post-img {
2
    overflow: hidden;
3
}
4

5
.item-thumb {
6
    transition: all 0.3s;
7
}
8

9
.item-thumb:hover {
10
    transform: scale(1.1)
11
}

0x10 文章内头图和文章图片悬停放大并将超出范围隐藏#

添加代码至自定义CSS

1
.entry-thumbnail {
2
    overflow: hidden;
3
}
4

5
#post-content img {
6
    border-radius: 10px;
7
    transition: 0.5s;
8
}
9

10
#post-content img:hover {
11
    transform: scale(1.05);
12
}

0x11 使用qq头像#

https://q1.qlogo.cn/g?b=qq&nk=1033853263&s=640 改为自己的qq号即可

0x12 Markdown 编辑器 Editor.md for Typecho#

作者页面

0x13 LoveKKComment-Typecho评论邮件提醒插件#

作者页面

0x14 更换网站光标#

添加css代码：

1
/** 鼠标样式 开始**/
2
/** 普通指针样式**/
3
body {
4
cursor: url(https://rehtt.com/css/光标/S1.cur), default;
5
}
6
/** 链接指针样式**/
7
a:hover{cursor:url(https://rehtt.com/css/光标/S2.cur), pointer;}
8
/** 鼠标样式 结束**/

光标文件：指针链接指针

0x15 鼠标点击特效#

js代码：

Caution

代码中包含了sketch.min.js的源码，如果你的网站已经引用了，请删掉下面的6到7行。

1
/*
2
 * 鼠标点击特效，canvas点击效果，第二版
3
 * 原文地址：https://www.iowen.cn/canvas-click-effect-second-edition
4
 */
5

6
/* Copyright (C) 2013 Justin Windle sketch.min.js, http://soulwire.co.uk */
7
var Sketch=function(){"use strict";function e(e){return"[object Array]"==Object.prototype.toString.call(e)}function t(e){return"function"==typeof e}function n(e){return"number"==typeof e}function o(e){return"string"==typeof e}function r(e){return E[e]||String.fromCharCode(e)}function i(e,t,n){for(var o in t)(n||!e.hasOwnProperty(o))&&(e[o]=t[o]);return e}function u(e,t){return function(){e.apply(t,arguments)}}function a(e){var n={};for(var o in e)n[o]=t(e[o])?u(e[o],e):e[o];return n}function c(e){function n(n){t(n)&&n.apply(e,[].splice.call(arguments,1))}function u(e){for(_=0;_<J.length;_++)G=J[_],o(G)?O[(e?"add":"remove")+"EventListener"].call(O,G,k,!1):t(G)?k=G:O=G}function c(){L(T),T=I(c),U||(n(e.setup),U=t(e.setup),n(e.resize)),e.running&&!j&&(e.dt=(B=+new Date)-e.now,e.millis+=e.dt,e.now=B,n(e.update),e.autoclear&&K&&e.clear(),n(e.draw)),j=++j%e.interval}function l(){O=Y?e.style:e.canvas,D=Y?"px":"",e.fullscreen&&(e.height=w.innerHeight,e.width=w.innerWidth),O.height=e.height+D,O.width=e.width+D,e.retina&&K&&X&&(O.height=e.height*X,O.width=e.width*X,O.style.height=e.height+"px",O.style.width=e.width+"px",e.scale(X,X)),U&&n(e.resize)}function s(e,t){return N=t.getBoundingClientRect(),e.x=e.pageX-N.left-w.scrollX,e.y=e.pageY-N.top-w.scrollY,e}function f(t,n){return s(t,e.element),n=n||{},n.ox=n.x||t.x,n.oy=n.y||t.y,n.x=t.x,n.y=t.y,n.dx=n.x-n.ox,n.dy=n.y-n.oy,n}function g(e){if(e.preventDefault(),W=a(e),W.originalEvent=e,W.touches)for(M.length=W.touches.length,_=0;_<W.touches.length;_++)M[_]=f(W.touches[_],M[_]);else M.length=0,M[0]=f(W,V);return i(V,M[0],!0),W}function h(t){for(t=g(t),q=(Q=J.indexOf(z=t.type))-1,e.dragging=/down|start/.test(z)?!0:/up|end/.test(z)?!1:e.dragging;q;)o(J[q])?n(e[J[q--]],t):o(J[Q])?n(e[J[Q++]],t):q=0}function p(t){F=t.keyCode,H="keyup"==t.type,Z[F]=Z[r(F)]=!H,n(e[t.type],t)}function v(t){e.autopause&&("blur"==t.type?b:C)(),n(e[t.type],t)}function C(){e.now=+new Date,e.running=!0}function b(){e.running=!1}function P(){(e.running?b:C)()}function A(){K&&e.clearRect(0,0,e.width,e.height)}function S(){R=e.element.parentNode,_=x.indexOf(e),R&&R.removeChild(e.element),~_&&x.splice(_,1),u(!1),b()}var T,k,O,R,N,_,D,B,G,W,z,F,H,q,Q,j=0,M=[],U=!1,X=w.devicePixelRatio,Y=e.type==m,K=e.type==d,V={x:0,y:0,ox:0,oy:0,dx:0,dy:0},J=[e.element,h,"mousedown","touchstart",h,"mousemove","touchmove",h,"mouseup","touchend",h,"click",y,p,"keydown","keyup",w,v,"focus","blur",l,"resize"],Z={};for(F in E)Z[E[F]]=!1;return i(e,{touches:M,mouse:V,keys:Z,dragging:!1,running:!1,millis:0,now:0/0,dt:0/0,destroy:S,toggle:P,clear:A,start:C,stop:b}),x.push(e),e.autostart&&C(),u(!0),l(),c(),e}for(var l,s,f="E LN10 LN2 LOG2E LOG10E PI SQRT1_2 SQRT2 abs acos asin atan ceil cos exp floor log round sin sqrt tan atan2 pow max min".split(" "),g="__hasSketch",h=Math,d="canvas",p="webgl",m="dom",y=document,w=window,x=[],v={fullscreen:!0,autostart:!0,autoclear:!0,autopause:!0,container:y.body,interval:1,globals:!0,retina:!1,type:d},E={8:"BACKSPACE",9:"TAB",13:"ENTER",16:"SHIFT",27:"ESCAPE",32:"SPACE",37:"LEFT",38:"UP",39:"RIGHT",40:"DOWN"},C={CANVAS:d,WEB_GL:p,WEBGL:p,DOM:m,instances:x,install:function(t){if(!t[g]){for(var o=0;o<f.length;o++)t[f[o]]=h[f[o]];i(t,{TWO_PI:2*h.PI,HALF_PI:h.PI/2,QUATER_PI:h.PI/4,random:function(t,o){return e(t)?t[~~(h.random()*t.length)]:(n(o)||(o=t||1,t=0),t+h.random()*(o-t))},lerp:function(e,t,n){return e+n*(t-e)},map:function(e,t,n,o,r){return(e-t)/(n-t)*(r-o)+o}}),t[g]=!0}},create:function(e){return e=i(e||{},v),e.globals&&C.install(self),l=e.element=e.element||y.createElement(e.type===m?"div":"canvas"),s=e.context=e.context||function(){switch(e.type){case d:return l.getContext("2d",e);case p:return l.getContext("webgl",e)||l.getContext("experimental-webgl",e);case m:return l.canvas=l}}(),e.container.appendChild(l),C.augment(s,e)},augment:function(e,t){return t=i(t||{},v),t.element=e.canvas||e,t.element.className+=" sketch",i(e,t,!0),c(e)}},b=["ms","moz","webkit","o"],P=self,A=0,S="AnimationFrame",T="request"+S,k="cancel"+S,I=P[T],L=P[k],O=0;O<b.length&&!I;O++)I=P[b[O]+"Request"+S],L=P[b[O]+"Cancel"+T];return P[T]=I=I||function(e){var t=+new Date,n=h.max(0,16-(t-A)),o=setTimeout(function(){e(t+n)},n);return A=t+n,o},P[k]=L=L||function(e){clearTimeout(e)},C}();
8

9

10
//---
11
if(document.getElementById("clickCanvas")) {
12
    function Particle(x, y, radius) {
13
        this.init(x, y, radius);
14
    }
15
    Particle.prototype = {
16
        init : function(x, y, radius) {
17
            this.alive = true;
18
            this.radius = radius || 10;
19
            this.wander = 0.15;
20
            this.theta = random(TWO_PI);
21
            this.drag = 0.92;
22
            this.color = '#ffeb3b';
23

24
            this.x = x || 0.0;
25
            this.y = y || 0.0;
26
            this.vx = 0.0;
27
            this.vy = 0.0;
28
        },
29
        move : function() {
30
            this.x += this.vx;
31
            this.y += this.vy;
32
            this.vx *= this.drag;
33
            this.vy *= this.drag;
34
            this.theta += random(-0.5, 0.5) * this.wander;
35
            this.vx += sin(this.theta) * 0.1;
36
            this.vy += cos(this.theta) * 0.1;
37
            this.radius *= 0.96;
38
            this.alive = this.radius > 0.5;
39
        },
40
        draw : function(ctx) {
41
            ctx.beginPath();
42
            ctx.arc(this.x, this.y, this.radius, 0, TWO_PI);
43
            ctx.fillStyle = this.color;
44
            ctx.fill();
45
        }
46
    };
47
    var MAX_PARTICLES = 50;
48
    //圆点颜色库
49
    var COLOURS = [ "#5ee4ff", "#f44033", "#ffeb3b", "#F38630", "#FA6900", "#f403e8", "#F9D423" ];
50
    var particles = [];
51
    var pool = [];
52
    var clickparticle = Sketch.create({
53
        container : document.getElementById('clickCanvas')
54
    });
55
    clickparticle.spawn = function(x, y) {
56
        if (particles.length >= MAX_PARTICLES)
57
            pool.push(particles.shift());
58
        particle = pool.length ? pool.pop() : new Particle();
59
        particle.init(x, y, random(5, 20));//圆点大小范围
60
        particle.wander = random(0.5, 2.0);
61
        particle.color = random(COLOURS);
62
        particle.drag = random(0.9, 0.99);
63
        theta = random(TWO_PI);
64
        force = random(1, 5);
65
        particle.vx = sin(theta) * force;
66
        particle.vy = cos(theta) * force;
67
        particles.push(particle);
68
    };
69
    clickparticle.update = function() {
70
        var i, particle;
71
        for (i = particles.length - 1; i >= 0; i--) {
72
            particle = particles[i];
73
            if (particle.alive)
74
                particle.move();
75
            else
76
                pool.push(particles.splice(i, 1)[0]);
77
        }
78
    };
79
    clickparticle.draw = function() {
80
        clickparticle.globalCompositeOperation = 'lighter';
81
        for ( var i = particles.length - 1; i >= 0; i--) {
82
            particles[i].draw(clickparticle);
83
        }
84
    };
85
    //按下时显示效果，mousedown 换成 click 为点击时显示效果（我用的 click）
86
    document.addEventListener("mousedown", function(e) {
87
        var max, j;
88
        //排除一些元素
89
        "TEXTAREA" !== e.target.nodeName && "INPUT" !== e.target.nodeName && "A" !== e.target.nodeName && "I" !== e.target.nodeName && "IMG" !== e.target.nodeName
90
        && function() {
91
            for (max = random(15, 20), j = 0; j < max; j++)
92
            clickparticle.spawn(e.clientX, e.clientY);
93
        }();
94
    });
95
}

展开收起

接着在body中引入：

1
<div id="clickCanvas" style=" position:fixed;left:0;top:0;z-index:999999999;pointer-events:none;"></div>

【杂项】win10专属快捷键

Mon, 10 Feb 2020 11:57:00 GMT

数字键#

按键	说明
win + 数字键	切换任务栏应用
win + ctrl + f4	删除最近打开的桌面

第一排字母键#

按键	说明
win + q	搜索
win + w	手写笔
win + e	文件管理器
win + r	运行
win + t	选择任务栏
win + u	win设置-显示
win + i	win设置
win + p	投影
win + tab	任务切换

第二排字母键#

按键	说明
win + a	管理面板
win + s	搜索
win + shift + s	截屏
win + d	显示桌面
win + ctrl + d	创建桌面
win + f	反馈中心
win + g	xbox
win + h	语音听写
win + k	连接视频/音频设备
win + l	锁屏
win + ;	表情符号

第三排字母键#

按键	说明
win + x	“右击开始”
win + c	语音助手（中国不可用）
win + v	剪切板
win + b	选择状态栏
win + m	最小化所有窗口
win + <	快速浏览桌面
win + >	表情符号

最后一排#

按键	说明
win + 空格	切换输入法
win + 左/右	应用靠左/右
win + shift + 左/右	应用转移到另一显示屏
win + 上	应用全屏
win + 下	应用窗口化

【Golang】实现文件服务器断点续传

Wed, 05 Feb 2020 04:24:00 GMT

0x00#

下载文件时暂停后可以继续接着下载，在线看视频时可以随意拖动进度条，这些都是断点续传所实现的应用。 http1.1支持Range属性从而实现断点续传，客户端在暂停时记录了已经下载的文件范围，当继续下载时就向服务器发送文件剩余的范围(Range)，服务器则根据客户端请求的范围(Range)返回相应文件的部分数据，而不用将整个文件返回给客户端。

多线程下载器就是利用这个属性进行多线程下载，下载器将服务器返回的文件数据范围进行分割，然后根据分割后的范围向服务器索取数据。

0x01#

首先要告诉客户端支持Range断点续传，然后客户端才能发起Range请求。这需要在服务器返回http的head以下内容：

1
writer.Header().Add("Accept-ranges", "bytes")   //告诉客户端支持Range，并且是bytes级的断点续传
2
writer.Header().Add("Content-Length", 文件大小)     //文件的总体大小
3
writer.Header().Add("Content-Disposition", "attachment; filename=文件名称“)

若客户端请求Ranges，服务器就返回Content-Range,Content-Range的内容是0~(文件大小-1)/文件大小例如一个大小为1024的文件，Content-Range内容为0-1023/1024

1
//
2
writer.Header().Add("Content-Range", "bytes 0-1023/1024")
3
//断点
4
writer.Header().Add("Content-Range", "bytes 200-1023/1024")

服务器要从客户端的请求的Range判断是否是有效的范围。 如果是有效的范围就要将相应状态码设为206 (Partial Content)，否则就设为416 (Request Range Not Satisfiable)

0x02#

代码实现：

1
func sendFile(writer http.ResponseWriter, request *http.Request, f *os.File) {
2
  defer f.Close()
3
  info, err := f.Stat()
4
  if err != nil {
5
    log.Println("sendFile1", err.Error())
6
    http.NotFound(writer, request)
7
    return
8
  }
9
  writer.Header().Add("Accept-Ranges", "bytes")
10
  writer.Header().Add("Content-Disposition", "attachment; filename="+info.Name())
11
  var start, end int64
12
  //fmt.Println(request.Header,"\n")
13
  if r := request.Header.Get("Range"); r != "" {
14
    if strings.Contains(r, "bytes=") && strings.Contains(r, "-") {
15

16
      fmt.Sscanf(r, "bytes=%d-%d", &start, &end)
17
      if end == 0 {
18
        end = info.Size() - 1
19
      }
20
      if start > end || start < 0 || end < 0 || end >= info.Size() {
21
        writer.WriteHeader(http.StatusRequestedRangeNotSatisfiable)
22
        log.Println("sendFile2 start:", start, "end:", end, "size:", info.Size())
23
        return
24
      }
25
      writer.Header().Add("Content-Length", strconv.FormatInt(end-start+1, 10))
26
      writer.Header().Add("Content-Range", fmt.Sprintf("bytes %v-%v/%v", start, end, info.Size()))
27
      writer.WriteHeader(http.StatusPartialContent)
28
    } else {
29
      writer.WriteHeader(http.StatusBadRequest)
30
      return
31
    }
32
  } else {
33
    writer.Header().Add("Content-Length", strconv.FormatInt(info.Size(), 10))
34
    start = 0
35
    end = info.Size() - 1
36
  }
37
  _, err = f.Seek(start, 0)
38
  if err != nil {
39
    log.Println("sendFile3", err.Error())
40
    writer.WriteHeader(http.StatusInternalServerError)
41
    return
42
  }
43
  n := 512
44
  buf := make([]byte, n)
45
  for {
46
    if end-start+1 < int64(n) {
47
      n = int(end - start + 1)
48
    }
49
    _, err := f.Read(buf[:n])
50
    if err != nil {
51
      log.Println("1:", err)
52
      if err != io.EOF {
53
        log.Println("error:", err)
54
      }
55
      return
56
    }
57
    err = nil
58
    _, err = writer.Write(buf[:n])
59
    if err != nil {
60
      //log.Println(err, start, end, info.Size(), n)
61
      return
62
    }
63
    start += int64(n)
64
    if start >= end+1 {
65
      return
66
    }
67
  }
68

69
}

展开收起

【Golang】简易的编译脚本

Mon, 20 Jan 2020 03:14:47 GMT

Terminal window

1
export GOPATH=${PWD}
2
if [ -n "$1" ]; then
3
    export GOOS=$1
4
fi
5
if [ -n "$2" ]; then
6
    export GOARCH=$2
7
fi
8

9
go install ${PWD##*/}

【Termux】使用atilo安装linux报错解决方案

Wed, 18 Dec 2019 09:21:18 GMT

0x00 安装时出现proot容器错误#

0.发现问题#

已经termux-chroot授权运行

Terminal window

1
atilo install (liunx版本)

时出现类似proot No such file or directory等报错。

1.查找问题#

通过查看atilo运行信息发现解压文件信息有明显的错误

1
[ Extracting ]
2
64.0KiB 0:00:00 [ 235KiB/s] [>        ]  0%

一般系统文件都有几十兆大小，而这个解压信息小得离谱再翻阅atilo代码时发现安装时会在~/.atilo/tmp中存放下载的系统文件，查看目录下的文件大小发现也是非常小的，这说明之前下载文件失败。

2.解决方案#

有了这个思路之后编辑atilo源码找到要下载的系统的链接，我这里使用安装kali来示范

Terminal window

1
找到
2
kali)
3
    aarch64=https://raw.githubusercontent.com/EXALAB/AnLinux-Resources/master/Rootfs/Kali/arm64/kali-rootfs-armhf.tar.gz
4
    arm=https://raw.githubusercontent.com/EXALAB/AnLinux-Resources/master/Rootfs/Kali/armhf/kali-rootfs-armhf.tar.gz
5
    amd64=https://raw.githubusercontent.com/EXALAB/AnLinux-Resources/master/Rootfs/Kali/amd64/kali-rootfs-amd64.tar.gz
6
    i386=https://raw.githubusercontent.com/EXALAB/AnLinux-Resources/master/Rootfs/Kali/i386/kali-rootfs-i386.tar.gz
7
    zip=xz
8
    upgrade="apt update"
9
    ;;

因为我的手机cpu是arm64架构的，所已更改aarch64的地址，将它替换为清华源https://mirrors.tuna.tsinghua.edu.cn/lxc-images/images/kali/current/arm64/default/20191216_17%3A14/rootfs.tar.xz 因为清华源提供的是.tar.xz的包，所已也要更改zip=xz为zip=Jx 其他系统或架构的需要替换对应的清华源

Terminal window

1
kali)
2
    aarch64=https://mirrors.tuna.tsinghua.edu.cn/lxc-images/images/kali/current/arm64/default/20191216_17%3A14/rootfs.tar.xz
3
    arm=https://raw.githubusercontent.com/EXALAB/AnLinux-Resources/master/Rootfs/Kali/armhf/kali-rootfs-armhf.tar.gz
4
    amd64=https://raw.githubusercontent.com/EXALAB/AnLinux-Resources/master/Rootfs/Kali/amd64/kali-rootfs-amd64.tar.gz
5
    i386=https://raw.githubusercontent.com/EXALAB/AnLinux-Resources/master/Rootfs/Kali/i386/kali-rootfs-i386.tar.gz
6
    zip=Jx
7
    upgrade="apt update"
8
    ;;

如果提供的是其他格式的包就要对应修改zip的内容

1
.tar.gz -> zip=xz
2
.tar.xz -> zip=Jx

重新运行安装之前要记得rm ~/.atilo/tmp/*删除下载失败的包

【Golang】简单的树莓派GPIO库

Sun, 24 Nov 2019 15:24:00 GMT

Github 版本：v0.3 对GPIO简单的操作功能： 1.设置指定的GPIO口是发射还是接收口（in/out） 2.设置发射口是高电平还是低电平（1/0） 3.释放GPIO口（Close()） 4.软件实现PWM（实验性，频率越高越消耗cpu资源）示例：

1
package main
2
import (
3
    gogpio "github.com/Rehtt/gogpio"
4
    "log"
5
    "time"
6
)
7
func main() {
8
//绑定针脚号(BCM)
9
pin1, err1 := gogpio.PinBind(20)
10
pin2, err2 := gogpio.PinBind(21)
11
pin3, err3 := gogpio.PinBind(22)
12
pin4, err4 := gogpio.PinBind(23)
13

14
//声明针脚为out输出
15
if err1 != nil {
16
log.Println(err1)
17
}
18
out := pin1.SetOut()
19
out.High() //输出高电平
20
out.Low()  //输出低电平
21

22
//声明针脚为in输入
23
if err2 != nil {
24
log.Println(err2)
25
}
26
in := pin2.SetIn()
27
log.Println(in.Read()) //读取输入的数据
28

29
//不声明，直接读取数据。时合在其他程序使用此针脚时读取其数据
30
if err3 != nil {
31
log.Println(err3)
32
}
33
log.Println(pin3.Read())
34

35
//声明为PWM（此功能为实验性功能，这里的PWM由软件生成，所以运行时会占用一定的cpu资源，频率越高cpu占用也越高）
36
if err4 != nil {
37
log.Println(err4)
38
}
39
pwm := pin4.SetPWM()
40
err = pwm.SetFreq(5) //频率单位为Hz，数值 > 0.0
41
err = pwm.SetDC(20) //占空比单位为% ，0.0 < 数值 < 100
42
if err != nil {
43
log.Println(err)
44
}
45
pwm.StartPWM() //开启PWM
46
pwm.StopPWM() //关闭PWM
47

48
//释放
49
pin1.Close()
50
pin2.Close()
51
pin3.Close()
52
pin4.Close()
53
}

展开收起

【Golang】程序通过服务的形式常驻后台

Thu, 07 Nov 2019 09:08:00 GMT

0x00#

Warning

此教程只在Linux和Windows上试验过，Mac可自行实验

一般使用命令带&实现后台运行，或使用守护进程来实现后台运行。其实golang自己也可以实现以服务的形式常驻后台。

需要的库#

这里使用库:github.com/kardianos/service

其中golang.org/x/...的库国内很难下载，将golang.org/x/替换为github.com/golang/进行下载，最后将github.com->golang文件目录替换为golang.org->x文件目录即可。

接口定义#

这个库有两个接口定义：

1
type Service interface {
2
  // Run should be called shortly after the program entry point.
3
  // After Interface.Stop has finished running, Run will stop blocking.
4
  // After Run stops blocking, the program must exit shortly after.
5
  Run() error
6

7
  // Start signals to the OS service manager the given service should start.
8
  Start() error
9

10
  // Stop signals to the OS service manager the given service should stop.
11
  Stop() error
12

13
  // Restart signals to the OS service manager the given service should stop then start.
14
  Restart() error
15

16
  // Install setups up the given service in the OS service manager. This may require
17
  // greater rights. Will return an error if it is already installed.
18
  Install() error
19

20
  // Uninstall removes the given service from the OS service manager. This may require
21
  // greater rights. Will return an error if the service is not present.
22
  Uninstall() error
23

24
  // Opens and returns a system logger. If the user program is running
25
  // interactively rather then as a service, the returned logger will write to
26
  // os.Stderr. If errs is non-nil errors will be sent on errs as well as
27
  // returned from Logger's functions.
28
  Logger(errs chan<- error) (Logger, error)
29

30
  // SystemLogger opens and returns a system logger. If errs is non-nil errors
31
  // will be sent on errs as well as returned from Logger's functions.
32
  SystemLogger(errs chan<- error) (Logger, error)
33

34
  // String displays the name of the service. The display name if present,
35
  // otherwise the name.
36
  String() string
37
}

展开收起

1
type Interface interface {
2
  // Start provides a place to initiate the service. The service doesn't not
3
  // signal a completed start until after this function returns, so the
4
  // Start function must not take more then a few seconds at most.
5
  Start(s Service) error
6

7
  // Stop provides a place to clean up program execution before it is terminated.
8
  // It should not take more then a few seconds to execute.
9
  // Stop should not call os.Exit directly in the function.
10
  Stop(s Service) error
11
}

这里只需实现start和stop接口就行

0x01 简单实例#

1
type program struct{}
2
func (p *program) Start(s service.Service) error {
3
    log.Println("开始服务")
4
    go p.run()
5
    return nil
6
}
7
func (p *program) Stop(s service.Service) error {
8
    log.Println("停止服务")
9
    return nil
10
}
11
func (p *program) run() {
12
    // 这里放置程序要执行的代码……
13
}
14

15
func main(){
16
//服务初始化
17
    //服务的配置信息
18
    cfg := &service.Config{
19
        Name:        "simple",
20
        DisplayName: "a simple service",
21
        Description: "This is an example Go service.",
22
    }
23
    // Interface 接口
24
    prg := &program{}
25
    // 构建服务对象
26
    s, err := service.New(prg, cfg)
27
    if err != nil {
28
        log.Fatal(err)
29
    }
30
    // logger 用于记录系统日志
31
    logger, err := s.Logger(nil)
32
    if err != nil {
33
        log.Fatal(err)
34
    }
35
    if len(os.Args) == 2 { //如果有命令则执行
36
        err = service.Control(s, os.Args[1])
37
        if err != nil {
38
            log.Fatal(err)
39
        }
40
    } else { //否则说明是方法启动了
41
        err = s.Run()
42
        if err != nil {
43
            logger.Error(err)
44
        }
45
    }
46
    if err != nil {
47
        logger.Error(err)
48
    }
49
}

展开收起

【网络】Caddy + PHP7.3

Tue, 05 Nov 2019 05:59:32 GMT

0x00#

Caddy是一个使用Go编写的开源的支持HTTP / 2的Web服务器。 Caddy可以运行在各种系统上，包括运行Linux，Windows，Mac OS，Android和BSD操作系统的系统。 Caddy有很多功能，可以作为Web服务器安装，也可以作为应用程序的反向代理。最显着的Caddy网络服务器功能是默认启用的自动HTTPS，无需额外配置。

0x01 Caddy#

安装#

使用一键安装脚本，如果想要安装其他扩展可以把名字加到命令后面（bash caddy_install.sh install xxx,xxx,xxx，扩展列表点击查看）

Terminal window

1
wget -N --no-check-certificate https://www.moerats.com/usr/shell/Caddy/caddy_install.sh && chmod +x caddy_install.sh && bash caddy_install.sh

使用说明#

1
启动：/etc/init.d/caddy start
2
停止：/etc/init.d/caddy stop
3
重启：/etc/init.d/caddy restart
4
查看状态：/etc/init.d/caddy status
5
查看Caddy启动日志：tail -f /tmp/caddy.log
6
安装目录：/usr/local/caddy
7
Caddy配置文件位置：/usr/local/caddy/Caddyfile
8
Caddy自动申请SSL证书位置：/.caddy/acme/acme-v01.api.letsencrypt.org/sites/xxx.xxx(域名)/

升级Caddy或更新扩展#

只需要重新执行你当初安装时候用的命令即可，会覆盖安装最新的Caddy+扩展。

卸载#

卸载不会删除虚拟主机的内容，只会删除Caddy自身和配置文件。

Terminal window

1
wget -N --no-check-certificate https://www.moerats.com/usr/shell/Caddy/caddy_install.sh && bash caddy_install.sh uninstall

网站配置文件#

配置文件为Caddyfile，列举几种caddy的conf的写法

1、本地访问80

1
:80

2、单网站访问

1
example.com
2
root /usr/local/caddy/www
3
//更多模块

2、多网站

1
example.com {
2
  gzip
3
  root /usr/local/caddy/www
4
  //更多模块
5
}

常用基本组成模块，均写入到conf站点配置中。

1
#log日志
2
log /usr/local/caddy/www/example.log
3

4
#目录访问
5
browse
6

7
#gzip压缩
8
gzip
9

10
#自主ssl证书
11
tls /path/ssl/example.com.crt /path/ssl/example.com.key
12

13
#访问口令认证（用户emiria，密码abc123）
14
basicauth / emiria abc123
15

16
#跳转功能
17
redir http://example.com{url}
18

19
#自定义错误页面
20
errors {
21
    404 404.html
22
    500 /usr/local/caddy/www/500.html
23
}

展开收起

例如，通过IP即80端口访问目录：

1
:80 {
2
     root /usr/local/caddy/www
3
     gzip
4
     browse
5
    }

也可以直接执行命令写入，以下是一个命令，直接复制粘贴即可。

Terminal window

1
echo ":80 {
2
 root /usr/local/caddy/www
3
 gzip
4
 browse
5
}" > /usr/local/caddy/Caddyfile

更多配置参考：https://caddyserver.com/tutorial/caddyfile 设置文档参考：https://caddyserver.com/docs

常见问题#

1、Caddy启动失败，打开ip访问地址显示的是 It works ! 一些系统会自带apache2，而apache2会占用80端口，导致Caddy无法绑定端口，所以只要关掉就好了。

Terminal window展开收起

1
netstat -lntp
2

3
# 我们可以通过这个命令查看是不是被其他软件占用了80端口。
4
不过apache2会默认开机自启动，如果不需要可以关闭自启动或者卸载apache2。
5

6
停止Apache2
7

8
# CentOS系统
9
/etc/init.d/httpd stop
10
# Debian/Ubuntu系统
11
/etc/init.d/apache2 stop
12

13
# 尝试使用上面代码关闭，如果没效果或者提示什么错误无法关闭，那就用下面这个强行关闭进程。
14
kill -9 $(ps -ef|grep "apache2"|grep -v "grep"|awk '{print $2}')
15
取消开机自启动
16

17
# CentOS 系统
18
chkconfig --del httpd
19
# Debian/Ubuntu 系统
20
update-rc.d -f apache2 remove
21
卸载Apache2
22

23
# CentOS 系统
24
yum remove httpd
25
# Debian/Ubuntu 系统
26
apt-get remove --purge apache2
27
关闭Apache2后，就可以尝试启动Caddy，并试试能不能打开网页。
28

29
/etc/init.d/caddy start

展开收起

2、启动Caddy后，无法访问这个可能是防火墙的问题，开放防火墙端口即可。

Terminal window

1
iptables -I INPUT -m state --state NEW -m tcp -p tcp --dport 端口 -j ACCEPT
2
iptables -I INPUT -m state --state NEW -m udp -p udp --dport 端口 -j ACCEPT
3

4
# 删除防火墙规则，内容一样把 -I 换成 -D 就行了：
5
iptables -D INPUT -m state --state NEW -m tcp -p tcp --dport 端口 -j ACCEPT
6
iptables -D INPUT -m state --state NEW -m udp -p udp --dport 端口 -j ACCEPT

3、SSL证书签发失败比如报错acme: error: 400 :: urn:ietf:params:acme:error:connection :: Error getting validation data, url:，检查下防火墙端口，需要开启80和443端口，然后重启即可。

0x02 PHP#

安装#

Terminal window

1
sudo apt install -y php7.3 php7.3-fpm php7.3-cli

配置#

编辑www.conf文件

Terminal window

1
sudo nano /etc/php/7.3/fpm/pool.d/www.conf

取消下面的注释。

1
listen.owner = www-data
2
listen.group = www-data
3
listen.mode = 0660

保存并退出

将caddy添加至www-data组

Terminal window

1
usermod -a -G www-data caddy

开机启动

Terminal window

1
systemctl start php7.3-fpm
2
systemctl enable php7.3-fpm

配置Caddyfilephp

1
#添加语句
2
fastcgi / /run/php/php7.3-fpm.sock php {
3
    ext .php
4
    split .php
5
    index index.php
6
}

例如：

1
http://example.com {
2
     root /var/www/html
3
     log /var/log/caddy/hakase-labs.log
4
     errors /var/log/caddy/errors.log
5
     tls off
6
     gzip
7

8
     # PHP-FPM Configuration for Caddy
9
     fastcgi / /run/php/php7.0-fpm.sock php {
10
         ext .php
11
         split .php
12
         index index.php
13
     }
14
}

重启Caddy和php-fpm即可。

[Golang]ssh登录及执行命令

Mon, 04 Nov 2019 11:01:00 GMT

1
package main
2

3
import (
4
  "fmt"
5
  "github.com/mitchellh/go-homedir"
6
  "golang.org/x/crypto/ssh"
7
  "io/ioutil"
8
  "log"
9
  "time"
10
)
11

12
func main() {
13
  re,err := sshL("192.168.199.1","root","rehttPassword","password","","uname -a",22)
14
  if err != nil{
15
  fmt.println(err)
16
  }
17
  fmt.println(string(re))
18
}
19

20
func sshL(sshHost,sshUser,sshPassword,sshType,sshKeyPath,command string,sshPort int) ([]byte,error) {
21

22
  //创建sshp登陆配置
23
  config := &ssh.ClientConfig{
24
    Timeout:         time.Second,//ssh 连接time out 时间一秒钟, 如果ssh验证错误 会在一秒内返回
25
    User:            sshUser,
26
    HostKeyCallback: ssh.InsecureIgnoreHostKey(), //这个可以， 但是不够安全
27
    //HostKeyCallback: hostKeyCallBackFunc(h.Host),
28
  }
29
  if sshType == "password" {
30
    config.Auth = []ssh.AuthMethod{ssh.Password(sshPassword)}
31
  } else {
32
    config.Auth = []ssh.AuthMethod{publicKeyAuthFunc(sshKeyPath)}
33
  }
34

35

36

37
  //dial 获取ssh client
38
  addr := fmt.Sprintf("%s:%d", sshHost, sshPort)
39
  sshClient, err := ssh.Dial("tcp", addr, config)
40
  if err != nil {
41
    log.Fatal("创建ssh client 失败",err)
42
    return nil,err
43
  }
44
  defer sshClient.Close()
45

46

47
  //创建ssh-session
48
  session, err := sshClient.NewSession()
49
  if err != nil {
50
    log.Fatal("创建ssh session 失败",err)
51
    return nil,err
52
  }
53
  defer session.Close()
54
  //执行远程命令
55
  combo,err := session.CombinedOutput(command)
56
  if err != nil {
57
    log.Fatal("远程执行cmd 失败",err)
58
    return nil,err
59
  }
60
  return combo,nil
61
}
62

63
func publicKeyAuthFunc(kPath string) ssh.AuthMethod {
64
  keyPath, err := homedir.Expand(kPath)
65
  if err != nil {
66
    log.Fatal("find key's home dir failed", err)
67
  }
68
  key, err := ioutil.ReadFile(keyPath)
69
  if err != nil {
70
    log.Fatal("ssh key file read failed", err)
71
  }
72
  // Create the Signer for this private key.
73
  signer, err := ssh.ParsePrivateKey(key)
74
  if err != nil {
75
    log.Fatal("ssh key signer failed", err)
76
  }
77
  return ssh.PublicKeys(signer)
78
}

展开收起

[杂项]handsome启用随机图片,将首页头图与文章头图设为一致

Sat, 26 Oct 2019 13:57:00 GMT

0x00#

handsome启用随机图片时,头图会被随机更换,但不能达到首页和文章头图一致

0x01 思路#

通过JS在首页刷新完后获取对应文章的随机头图地址,再将头图地址放在文章的地址后面p_i里加载文章时通过p_i将首页头图显示出来

随机图片

固定一致图片

0x02 代码#

适用于/archives/{cid}/永久链接随机头图存放地址/usr/themes/handsome/usr/img/sj/ 可根据自己实际情况更改将代码放进自定义js和PJAX中

1
if (window.location.pathname === "/") {
2
    var img =document.getElementsByClassName("item-thumb lazy");
3
    var a=document.getElementsByClassName("index-post-img")
4
    for (var i = 0; i < a.length; i++) {
5
        var yurl = a[i].getElementsByTagName("a")[0].getAttribute("href");
6
        url=img[i].style.backgroundImage.split("\"")[1].split("/")[9].split(".")[0]
7
        a[i].getElementsByTagName("a")[0].setAttribute("href",yurl+"?p_i="+url);
8
    }
9
}else if (GetQueryString("p_i")!==null) {
10
    document.getElementsByClassName("item-thumb lazy")[0].style.backgroundImage="url(\"/usr/themes/handsome/usr/img/sj/"+GetQueryString("p_i")+".jpg\")"
11

12
}
13
function GetQueryString(name)
14
{
15
     var reg = new RegExp("(^|&)"+ name +"=([^&]*)(&|$)");
16
     var r = window.location.search.substr(1).match(reg);
17
     if(r!=null)return  unescape(r[2]); return null;
18
}

展开收起

[杂项]修复handsome透明模式bug

Fri, 25 Oct 2019 05:49:00 GMT

0x00#

handsome开启了炫酷透明模式后,搜索框,音乐栏和提示栏会变透明而看不清字.

0x01 修复#

在自定义CSS添加代码:

1
#skPlayer .skPlayer-list {
2
background-color: rgba(0,0,0,0.8)
3
}
4

5
 .dropdown-menu{
6
background-color: rgba(0,0,0,0.8)
7
}

前面0,0,0是rgb,后面0.8是透明度,可自行调整

1.png

[杂项]handsome主题提示php函数损坏或主题文件缺失

Thu, 24 Oct 2019 15:18:34 GMT

0x00#

提示php缺失函数或者模块支持或者主题不完整,请联系作者. 原因是文件权限出了问题将主题目录下面的lisence文件给777权限即可

[杂项]去除handsome主题的时光机头图的蒙层

Thu, 24 Oct 2019 15:09:00 GMT

0x00#

如图,图片上有一层”灰蒙蒙”的蒙版,控制它的class name是bg-while-opacity,只需要添加JS代码将它去除即可.

0x01#

代码:

1
try{
2
document.getElementsByClassName("wrapper-lg bg-white-opacity")[0].classList.remove("bg-white-opacity");
3
}catch(err){}

去除效果:

【Linux】所遇问题及解答

Sun, 20 Oct 2019 00:00:00 GMT

用户权限#

0x00 “This account is currently not available”#

Terminal window

1
# usermod -s /bin/bash userName

0x01 使用指定用户运行命令#

Terminal window

1
# su - userName -c "Command"

SSH#

0x00 使用代理#

Terminal window

1
ssh -o ProxyCommand="nc -x proxyIp:port %h %p" user@server

【Arduino】ProMicro开发板

Tue, 03 Sep 2019 00:00:00 GMT

0x00#

这块Arduino板优点是价格相对便宜（淘宝10-20），引脚相对较多，体积较小（18mm*33mm)，其核心是ATmega32U4（兼容Arduino Leonardo)可用与模拟HID设备。

0x01 开发环境#

在Arduino IDE中，打开“首选项”，在“附加开发板管理器网站”中添加网站后保存:

1
https://raw.githubusercontent.com/sparkfun/Arduino_Boards/master/IDE_Board_Manager/package_sparkfun_index.json

打开“开发板管理器”，搜索并安装“SparkFun AVR Boards” 在“开发板”中选择“SparkFun Pro Micro”，在“处理器”根据板子标注的频率选择对应的处理器。

当然也可以直接使用Arduino IDE“开发板”中的“Arduino Leonardo”

0x02 “无法识别的USB设备”问题#

当刷入程序失败时会导致Windows无法识别开发板，插入电脑识别不出USB串口这时需要短接”GND”与”RST”进入Bootloader模式进行刷入程序 Bootloader模式只有几秒钟的时间，所以选择端口刷入的速度要快步骤：

Arduino IDE新建一个工程
点击上传，等待编译完成后显示“上传…”时，将开发板插入电脑
短接”GND”与”RST”，选择正确的端口
等待上传完成

【树莓派】使用GPS模块

Wed, 31 Jul 2019 00:00:00 GMT

0x00#

使用的GPS模块是ATGM336H-5N模块+IPX陶瓷有源天线

ATGM336H-5N系列模块是小尺寸的高性能BDS/GNSS全星座定位导航模块系列的总称。该系列模块产品都是基于中科微第四代低功耗GNSS SOC单芯片—AT6558，支持多种卫星导航系统，包括中国的BDS（北斗卫星导航系统），美国的GPS，俄罗斯的GLONASS，欧盟的GALILEO，日本的QZSS 以及卫星增强系统SBAS（WAAS，EGNOS，GAGAN，MSAS）。AT6558 是一款真正意义的六合一多模卫星导航定位芯片，包含32 个跟踪通道，可以同时接收六个卫星导航系统的GNSS 信号，并且实现联合定位、导航与授时。 ATGM336H-5N本系列模块具有高灵敏度、低功耗、低成本等优势，适用于车载导航、手持定位、可穿戴设备，可以直接替换Ublox MAX系列模块。

1.jpg

0x01接线#

2.jpg

剩下的pps口暂时用不到，所以不接

0x02配置#

树莓派终端输入sudo raspi-config,选择Interfacing Options>>Serial。在”Would you like a login shell to be accessible over serial?”选择No。在”Would you like the serial port hardware to be enabled?”选择Yes。重启

手动配置#

打开/boot文件夹。编辑config.txt文件，末尾添加

1
enable_uart=1

编辑cmdline.txt文件，作以下修改

1
删除
2
console=serial0,115200
3
quiet
4
init=/usr/lib/raspi-config/init_resize.sh

0x03测试#

串口接口为：/dev/ttyS0 这里使用minicom进行串口调试，没有的话使用apt安装即可。命令行输入：

Terminal window

1
minicom -b 9600 -D /dev/ttyS0
2
# -b 波特率，ATGM336H-5N的波特率是9600
3
# -D 接口

如果正常的话会显示这些：

3.jpg

第一次使用这个模块、模块的距离与上次使用时的距离过远或模块电池电量耗尽时，需要等一分钟左右同步卫星信息。

【Linux】记录命令操作

Wed, 10 Jul 2019 00:00:00 GMT

0x00#

在Linux上完整记录屏幕上的输入命令和输出结果，效果和屏幕录制差不多不过是记录命令行的。

主要用到script和scriptreplay这两个命令，一般在linux发行版都默认安装了。

0x01 录制与播放#

录制#

Terminal window

1
script -t 2>time.file -a scriptfile

其中time.file是时序记录文件，记录执行命令的时间；scriptfile是命令执行记录文件，记录所执行的命令。这些记录文件的名字可以自定义。

执行这句命令后，接下来的所有操作都会被记录下来。

加上-q ,--quiet参数可以是script一静默模式运行，不显示script启动和exit退出的命令，用户可以在完全察觉不到的情况下记录。

Terminal window

1
script -q -t 2>time.file -a scriptfile

要使script停止下来，可以按下组合键Ctrl+D结束记录，也可以执行exit结束记录。

播放#

Terminal window

1
scriptreplay time.file scriptfile

时序文件在前，命令文件在后。

添加参数-d, --divisor <num>可以调整播放速度的倍数（大于1：加快；小于1大于0：放慢）加快10倍速播放：

Terminal window

1
scriptreplay -d 10 time.file scriptfile

0x02 同步演示#

同步演示可以做到类似“直播”的效果。使用参数-f,--flush在每次操作后立即刷新缓存进行实时写入文件。使用端：

Terminal window

1
script -f demo

演示端：

Terminal window

1
scriptreplay -f demo

有些版本的scriptreplay没有-f参数，但可以使用tail -f来代替scriptreplay。

0x03 录制命令执行过程#

使用参数-c,--command直接执行命令，不过执行的命令不是交互式的shell

Terminal window

1
script -qa log.out -c "echo hello"

0x04 用户登录后自动触发实时监控#

这样可以监控用户登录后的操作。原理就是让script命令在用户登录后自动运行。

Terminal window

1
#建立记录文件夹
2
mkdir -p /var/log/user_record
3
#编辑启动文件
4
nano /etc/profile

在profile文件末尾添加

Terminal window

1
script -t -f -q 2>/var/log/user_record/$USER-$UID-`date +%Y%m%d%H%M%S`.time -a /var/log/user_record/$USER-$UID-`date +%Y%m%d%H%M%S`.his
2
if [ "$SHLVL" = 1 ]; then
3
   exit
4
fi

【Golang】GO项目结构

Tue, 25 Jun 2019 00:00:00 GMT

0x00#

一般语言没有规定项目目录结构，但golang有规定，这样可以保证一致性。

0x01#

Golang提供两个关键路径：

GOROOT指向GO的安装路径
GOPATH指向项目路径

一般GO安装好后GOROOT会自动指向安装路径，所以一般不需要动。除非你安装了几个不同版本的GO，GOROOT设置为指定版本的路径即可。

1
项目目录    <-GOPATH指向的路径
2
├─bin       <-编译后的可以执行文件存放的位置
3
├─pkg       <-编译的中间文件存放位置
4
└─src       <-项目源代码存放位置
5
    ├─项目          <-项目源代码存放位置
6
    └─vendor        <-第三方开源代码存放位置

一般只需要创建src，bin pkg编译时会自动创建。指定GOPATH:

Windows：

Terminal window

1
set GOPATH=项目目录路径

Linux：

Terminal window

1
export GOPATH=项目目录路径

假如项目名为test，使用go install test进行编译其项目文件结构：

1
.
2
├─bin       <-bin目录会自动生成
3
|   └─test      <-编译后的可执行文件
4
└─src
5
    └─test
6
        ├─main.go       <-作为入口，必须命名为main.go
7
        └─Hello         <-文件夹名随意
8
            └─hello.go  <-文件名随意

main.go

1
package main        //项目目录根目录和main.go的包名都为main
2

3
import (
4
  "test/Hello"    //指定目录
5
)
6
func main()  {
7
  Hello.Hello()   //调用Hello目录的hello.go中的Hello()函数
8
}

hello.go

1
package Hello   //包名为该文件所在的目录名
2

3
import "fmt"
4

5
func Hello() {  //被跨目录调用的函数名首字母需要大写
6
  fmt.Println("hello!!!")
7
}

0x02#

快捷编译脚本,将脚本放在项目目录根目录下（src同目录下）:

install.sh展开收起

1
#!/usr/bin/env bash
2
if [ ! -f install ]; then
3
echo 'install must be run within its container folder' 1>&2
4
exit 1
5
fi
6

7
CURDIR=`pwd`
8
OLDGOPATH="$GOPATH"
9
export GOPATH="$CURDIR"
10

11
gofmt -w src
12

13
go install test
14

15
export GOPATH="$OLDGOPATH"
16

17
echo 'finished'

展开收起

install.bat展开收起

1
@echo off
2

3
setlocal
4

5
if exist install.bat goto ok
6
echo install.bat must be run from its folder
7
goto end
8

9
: ok
10

11
set OLDGOPATH=%GOPATH%
12
set GOPATH=%~dp0
13

14
gofmt -w src
15

16
go install test
17

18
:end
19
echo finished

展开收起

【Linux】Oh My ZSH

Mon, 17 Jun 2019 00:00:00 GMT

0x00#

shell有许多种类型，linux里默认的是bash。虽然bash的功能非常强大，但界面不怎么炫酷，提示功能也不怎么强大.

而zsh的功能强大DIY性强，但又因配置过于复杂，使得大多数人望而止步只有少部分极客使用。

后来有人创建了oh-my-zsh开源项目，由用户社区共同维护。oh-my-zsh将zsh配置简化，就算是小白也能简单快速配置使用。配置完成后，你可以充分利用数百个强大的插件和漂亮的主题。在咖啡馆陌生人会问你:“这真是太棒了！你是计算机天才吗？”（滑稽）

0x01#

环境要求：

MacOS或Linux类Unix系统
需要提前安装zsh，且版本需高于v4.3.9，ubuntu与debain系操作系统输入apt install zsh即可安装成功，其他系统这里安装方法。
系统要有wget或curl工具
需要git工具

安装#

使用wget或curl，选择一个即可

Terminal window

1
sh -c "$(wget -O- https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"

Terminal window

1
sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"

脚本无误执行完即安装成功。

0x02#

主题#

oh-my-zsh自带大量炫酷主题，这里查看相关主题截图。

更改主题#

编辑文件~/.zshrc找到：

Terminal window

1
ZSH_THEME="robbyrussell"

将引号内文字替换为想要换的主题名字即可。

替换字体#

有些主题需要替换Powerline Fonts字体，否则个别符号会显示错误。 ubuntu/debain:

Terminal window

1
apt install fonts-powerline

WSL (使用PowerShell):

Terminal window

1
git clone https://github.com/powerline/fonts.git
2
cd fonts
3
./install.sp1

其他Linux或MacOS：

Terminal window

1
git clone https://github.com/powerline/fonts.git
2
cd fonts
3
./install.sh

安装完字体后在终端设置进行设置即可。

插件#

Oh My ZSH有许多插件这里安装一个命令自动补全插件incr.zsh

Terminal window

1
wget http://mimosa-pudica.net/src/incr-0.2.zsh
2
mkdir ~/.oh-my-zsh/plugins/incr
3
mv incr-0.2.zsh ~/.oh-my-zsh/plugins/incr/

修改.zshrc文件，在最后一行添加：

Terminal window

1
source ~/.oh-my-zsh/plugins/incr/incr*.zsh

更新配置：

Terminal window

1
source ~/.zshrc

【计算机网络】通过ssh端口转发建立网络隧道

Wed, 22 May 2019 00:00:00 GMT

0x00#

概述#

SSH 会自动加密和解密所有 SSH 客户端与服务端之间的网络数据。但是，SSH 还同时提供了一个非常有用的功能，这就是端口转发。它能够将其他 TCP 端口的网络数据通过 SSH 链接来转发，并且自动提供了相应的加密及解密服务。这一过程有时也被叫做“隧道”（tunneling）。这是因为 SSH 为其他 TCP 连接提供了一个安全的通道，避免了用户名，密码以及隐私信息的明文传输。例如，Telnet，SMTP，LDAP 这些 TCP 应用。

某些特殊的网络环境中的防火墙限制访问一些端口，但能进行ssh连接，在这种情况下可以使用ssh将限制访问的tcp进行转发访问。

0x01#

本地转发#

将服务器的限制访问的端口转发到客户端本地。

1.jpg

当没有服务器ssh登录的权限时，但有其他可以访问被限制的服务器端口的设备的ssh登录权限时，将此台设备作为跳板来访问。

2.jpg

命令规则：

Terminal window

1
ssh -L [local host:]<local port>:<remote host>:<remote port> <ssh hostname>

实例&解释：

Terminal window

1
ssh -L 8001（指定本地端口）:服务器ip:8000（被限制访问的端口） root@服务器ip
2

3
ssh -L 8001（指定本地端口）:服务器ip:8000（被限制访问的端口） root@跳板机ip

当ssh登录成功后就已经将服务器端口转发到客户端本地端口了，上面实例客户端访问地址：127.0.0.1<8001>

注意#

在上面的命令加一个-g可以让其他设备访问客户端

Terminal window

1
ssh -L 8000:服务器ip:8000 root@服务器ip
2
等价于
3
ssh -L 127.0.0.1:8000:服务器ip:8000 root@服务器ip

Terminal window

1
ssh -g -L 8000:服务器ip:8000 root@服务器ip
2
等价于
3
ssh -L 0.0.0.0:8000:服务器ip:8000 root@服务器ip

转发时要一直保持ssh的连接，也就是不能关闭ssh的命令窗口。也可以添加-qTfNn用于告知ssh连接成功后就转到后台运行。

远程转发（反向代理）#

远程访问就是将本地内网端口的流量通过一台公网设备转发出来

3.jpg

命令格式：

Terminal window

1
ssh -g -R [ssh server host:]<SSH server port>:<local host>:<local port> <SSH hostname>

实例：

Terminal window

1
ssh -g -R 8000（指定公网设备的端口）:内网设备ip:8000（内网设备的端口） root@公网设备ip

注意#

和本地访问一样转发时不能关闭ssh命令窗口。也可以添加-qTfNn用于告知ssh连接成功后就转到后台运行。
转发失败时检查/etc/ssh/sshd_config文件，将AllowTcpForwarding选项设置为yes。

动态转发(Socks代理)#

开启一条Socks隧道。前面的本地转发和远程转发都需要指定端口进行转发，而动态转发则不需要指定端口就可以转发（不建议使用这个来fq，因为该方法早已被GFW和谐），可以进行内网访问。

4.jpg

命令格式：

Terminal window

1
ssh -D <local port> <SSH Server>

实例：

Terminal window

1
ssh -D 8000(本地指定的端口) root@进行转发的服务器ip（跳板）

ssh执行为后台任务#

ssh -qTfNn用于建立纯端口转发用途的ssh连接，参数具体含义如下：

-q: quiet模式，忽视大部分的警告和诊断信息（比如端口转发时的各种连接错误）
-T: 禁用tty分配(pseudo-terminal allocation)
-f: 登录成功后即转为后台任务执行
-N: 不执行远程命令（专门做端口转发）
-n: 重定向stdin为/dev/null，用于配合-f后台任务

END#

【树莓派】配置usb口电流限制

Thu, 16 May 2019 00:00:00 GMT

0x00#

树莓派usb接口的默认电流只有600mA，而当接入对电流要求较高的设备时会出现问题导致工作不正常。这里采用的是修改树莓派配置将最大电流提升为1.2A（电源芯片限制）。

注意

这个方法会使树莓派主板过载，最坏情况会使树莓派主板报废！
如果需要的电流超过默认的600mA的50%以上则建议使用带电源接口的usb hub外接
QQ截图20190516224311.jpg
本方案不适用树莓派zero版本

0x01#

本方案实现原理是使电流绕过usb电流保护芯片实现达到更大电流。实现步骤：修改 /boot/config.txt，在文件末尾添加：

1
max_usb_current=1
2
current_limit_override=0x5A000020
3
avoid_warnings=2

重新启动树莓派即可生效。

END#

【树莓派】使用BerryBoot安装多系统

Mon, 13 May 2019 00:00:00 GMT

0x00#

BerryBoot是一款基于树莓派启动的启动管理工具，它最大的优势是可以在不通过SD卡的前提下在多个系统中选择启动，你既可以将系统存放在卡上，也可以, 如果你需要更多空间的话，将系统运行在外接的硬盘上并配置BerryBoot只将SD卡作为一个启动器。可以将它看作是一个引导系统

0x01#

在这里下载
下载后将其解压并将全部文件放入FAT32格式的空白SD卡，将SD卡插入树莓派，通电开机。
当树莓派的灯闪烁几下后会进入BerryBoot系统，在里面进行配置。
初次启动后第一个界面可以直接跳过，来到第二个界面选择系统安装位置，可以选择SD卡、usb设备或网络设备。
配置完第二个界面后来到第三个界面，在这可以在线下载系统并自动安装。如果要安装已经下载好的系统直接关闭这个界面即可。提前下载好的系统安装：
1. 下载系统，这里推荐BerryServer，BerryServer有大量适合树莓派的系统，也可以自己在BerryServer发布自己编译好的系统。
2. 将下载好的系统文件解压至xxxx.img格式的文件。
3. 将系统文件usb设备并将其插入树莓派。
4. 在BerryBoot中鼠标左键长按Add OS选择Install from USB stick，选择系统文件即可。
每次开机都会进入BerryBoot选择菜单，可以在Edit config的cmdline.txt中更改bootmenutimeout=10的倒计时，如果有其他设备（比如安装在USB设备中）就需要在uEnv.txt中添加bootmenutimeout=10或nobootmenutimeout表示不自动进入系统。如果要跳过BerryBoot可以将系统设为默认（set default），这样可以开机跳过BerryBoot直接进入选定的系统。若要Openelec支持ssh, 还需要在cmdline.txt 最后添加ssh
重启几秒后即可进入选定安装后的系统。

#无屏幕情况下使用BerryBoot#

这里使用VNC进行远程访问，树莓派需要连上网线并与电脑保持在同一个局域网的同一网段。最简单的办法是共享本地连接, 并用一根网线连接树莓派和电脑。

将BerryBoot系统文件中的cmdline.txt文件内容更改为：

1
smsc95xx.turbo_mode=N elevator=deadline quiet bootmenutimeout=10 vncinstall ipv4=192.168.137.27/255.255.255.0/192.168.137.1

其中192.168.137.27为局域网ip地址，192.186.137.1为局域网网段，可以根据自己情况更改，保证电脑能正常连接访问树莓派即可。

树莓派通电并接上网线后，电脑上使用VNC客户端，地址输入树莓派ip:5900

END#

【Linux】Ubuntu Server安装图形桌面及VNC远程桌面

Wed, 08 May 2019 00:00:00 GMT

0x00#

本篇采用xfce4轻量级图形桌面

0x01#

安装桌面环境与VNC服务器：

Terminal window

1
sudo apt install xfce4 xfce4-goodies vnc4server
2
sudo apt install xdm

如果想新建一个用户：

Terminal window

1
sudo useradd -m userName -d /home/userName
2
passwd userName
3
在/etc/sudoers里面将userName添加进去

执行完后重启：

Terminal window

1
sudo shutdown now

重启后执行：

Terminal window

1
vnc4server
2
输入vnc密码
3

4
mv ~/.vnc/xstartup ~/.vnc/xstartup.bak
5
nano ~/.vnc/xstartup

xstartup内容：

1
#!/bin/sh
2
xrdb $HOME/.Xresources
3
unset SESSION_MANAGER
4

5
unset DBUS_SESSION_BUS_ADDRESS
6

7
[ -x /etc/vnc/xstartup ] && exec /etc/vnc/xstartup
8

9
[ -r $HOME/.Xresources ] && xrdb $HOME/.Xresources
10

11
vncconfig -iconic &
12

13
xfce4-session & startxfce4 &

添加vnc服务器文件：

Terminal window

1
sudo nano /etc/init.d/vncserver

文件内容：

1
#!/bin/bash
2
PATH="$PATH:/usr/bin/"
3
export USER="user"
4
DISPLAY="1"
5
DEPTH="16"
6
GEOMETRY="1024x768"
7
OPTIONS="-depth ${DEPTH} -geometry ${GEOMETRY} :${DISPLAY} -localhost"
8
. /lib/lsb/init-functions

授权：

Terminal window

1
chmod +x ~/.vnc/xstartup
2
sudo chmod +x /etc/init.d/vncserver

开启服务：

Terminal window

1
sudo service vncserver start

0x02#

打开vnc客户端地址信息:

1
服务器ip:5901
2
或简写
3
服务器ip:1

输入密码连接完成

END#

【Linux】在AWS上配置人头识别环境

Thu, 25 Apr 2019 00:00:00 GMT

0x00#

这里使用FCHD-Fully-Convolutional-Head-Detector人头识别的开源项目

系统：AWS Ubuntu Server 18.04 LTS(HVM) 类型：p2类型 (我使用的是p2.xlarge)

0x01 环境安装#

首先更新系统,更新完建议重启
Terminal window
```
1
sudo apt update
2
sudo apt upgrade -y
```

安装所需要的工具

Terminal window

1
sudo apt install gcc make python3-pip unzip -y

安装CUDA

Terminal window

1
wget "https://developer.nvidia.com/compute/cuda/10.0/Prod/local_installers/cuda_10.0.130_410.48_linux" -O cuda.run
2
sudo bash cuda.run

安装选项使用默认就好

安装所需要的依赖库

Terminal window

1
sudo apt install python3-tk -y
2
sudo apt install libsm-dev -y

命令行输入
Terminal window
```
1
ldconfig /usr/local/cuda-10.0/lib64/
```

通过pip安装所需工具总共需要安装以下工具： ·torch ·torchvision ·cupy-cuda100 ·scikit-image ·opencv-python ·torchnet 命令：

Terminal window

1
###使用国内源会下载更快，这里使用清华的源
2
yuan=https://pypi.tuna.tsinghua.edu.cn/simple
3

4
pip3 install https://download.pytorch.org/whl/cu100/torch-1.0.1.post2-cp36-cp36m-linux_x86_64.whl
5
pip3 install torchvision cupy-cuda100 scikit-image opencv-python torchnet -i $yuan

0x02 部署#

通过S3储存桶下载并解压文件：

Terminal window

1
wget https://s3.cn-north-1.amazonaws.com.cn/neural-network-model/FCHD-Fully-Convolutional-Head-Detector.zip
2
unzip FCHD-Fully-Convolutional-Head-Detector

下载一个视频放入FCHD-Fully-Convolutional-Head-Detector/video中

命令行输入：

Terminal window

1
python3 head_detection_demo.py  --video_path video/视频文件名

若没有提示cuda错误即成功

【树莓派】温控风扇（golang)

Sat, 13 Apr 2019 00:00:00 GMT

0x00#

采用go语言编写，可编译直接运行使用s8050三极管作为开关使用14号针脚作为信号开关 2019-11-7 新增后台服务启动

0x01#

1
package main
2

3
import (
4
  "bufio"
5
  "flag"
6
  "fmt"
7
  "github.com/rehtt/gogpio"
8
  "github.com/kardianos/service"
9
  "log"
10
  "os"
11
  "strconv"
12
  "time"
13
)
14

15
var (
16
  max, min    int
17
  showTemp, h bool
18
)
19

20
func main() {
21

22
  flag.BoolVar(&h, "h", false, "help")
23
  flag.IntVar(&max, "m", 55, "开启风扇温度")
24
  flag.IntVar(&min, "n", 50, "关闭风扇温度")
25
  flag.BoolVar(&showTemp, "s", false, "查看当前温度")
26
  flag.Usage = help
27
  flag.Parse()
28
  if h {
29
    flag.Usage()
30
  } else {
31
    if !showTemp {
32
      //服务
33
      cfg := &service.Config{
34
        Name:        "temp",
35
        DisplayName: "RPI CPU Temp",
36
        Description: "RPI CPU Temp",
37
      }
38
      prg := &program{}
39
      s, err := service.New(prg, cfg)
40
      if err != nil {
41
        log.Fatal(err)
42
      }
43
      // logger 用于记录系统日志
44
      logger, err := s.Logger(nil)
45
      if err != nil {
46
        log.Fatal(err)
47
      }
48
      if len(os.Args) == 2 { //如果有命令则执行
49
        err = service.Control(s, os.Args[1])
50
        if err != nil {
51
          log.Fatal(err)
52
        }
53
      } else { //否则说明是方法启动了
54
        err = s.Run()
55
        if err != nil {
56
          logger.Error(err)
57
        }
58
      }
59
      if err != nil {
60
        logger.Error(err)
61
      }
62
    } else {
63
      fmt.Println("当前温度：", t(), "°")
64
    }
65
  }
66

67
}
68

69
func t() int {
70
  txt, _ := os.Open("/sys/class/thermal/thermal_zone0/temp")
71
  defer txt.Close()
72
  buf := bufio.NewReader(txt)
73
  t, _, _ := buf.ReadLine()
74
  temp, _ := strconv.Atoi(string(t))
75
  temp = temp / 1000
76
  return temp
77
}
78

79
func help() {
80
  fmt.Fprintln(os.Stderr, `使用：temp [选项] [服务操作]
81
选项：`)
82
  flag.PrintDefaults()
83
  fmt.Fprintln(os.Stderr,`
84
服务操作：
85
  install    安装服务（开启服务必做）
86
  start    运行服务
87
  stop    停止服务
88
  uninstall  卸载服务
89

90
示例：
91
  temp -s      显示温度
92
  temp install && temp start    安装服务并启动
93
  temp stop    停止服务
94
  temp -m 50  start  带参数启动服务
95
启动服务需要root权限`)
96
}
97

98
//服务
99
type program struct{}
100

101
func (p *program) Start(s service.Service) error {
102
  log.Println("开始服务")
103
  go p.run()
104
  return nil
105
}
106
func (p *program) Stop(s service.Service) error {
107
  log.Println("停止服务")
108
  return nil
109
}
110
func (p *program) run() {
111
  // 这里放置程序要执行的代码……
112
  pin, _ := gogpio.Open(14, gogpio.OUT)
113
  for ; ; {
114
    if t() >= max {
115
      pin.High()
116
    } else if t() <= min {
117
      pin.Low()
118
    }
119
    time.Sleep(30 * time.Second)
120
  }
121
}

展开收起

【Golang】Golang在Windows上获取管理员权限

Thu, 11 Apr 2019 00:00:00 GMT

0x00#

此方法可以双击程序获取权限

0x01#

1.打开命令终端输入：

Terminal window

1
go get github.com/akavel/rsrc

2.在项目根目录创建名为nac.manifest的文件，并填充以下内容：

1
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
2
    <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
3
        <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
4
            <security>
5
                <requestedPrivileges>
6
                    <requestedExecutionLevel level="requireAdministrator"/>
7
                </requestedPrivileges>
8
            </security>
9
    </trustInfo>
10
</assembly>

3.项目根目录下打开命令行输入：

Terminal window

1
rsrc -manifest nac.manifest -o nac.syso
2
go build

0x02#

END#

【杂项】IDEA/Android Studio 窗口无显示问题

Sat, 30 Mar 2019 00:00:00 GMT

0x00#

在外接拓展显示器的情况下，如果突然拔掉显示器，就可能出现整个IDEA/Android Studio窗口无法显示的情况

19-3-30-1.png

0x01 解决方法#

找到最后一次操作的项目中的.idea文件夹下的workspace.xml文件

19-3-30-2.png

打开文件并找到ProjectFrameBounds关键字，将其name="x"的值修改为0即可，然后重启IDEA/Android Studio即可

19-3-30-3.png

0x03 END#

ffmpeg的简单用法

Thu, 31 Jan 2019 00:00:00 GMT

转自：https://www.jianshu.com/p/4f399b9dfb43

转码

最简单命令如下：

Terminal window

1
ffmpeg -i out.ogv -vcodec h264 out.mp4
2
ffmpeg -i out.ogv -vcodec mpeg4 out.mp4
3
ffmpeg -i out.ogv -vcodec libxvid out.mp4
4
ffmpeg -i out.mp4 -vcodec wmv1 out.wmv
5
ffmpeg -i out.mp4 -vcodec wmv2 out.wmv

-i 后面是输入文件名。-vcodec 后面是编码格式，h264 最佳，但 Windows 系统默认不安装。如果是要插入 ppt 的视频，选择 wmv1 或 wmv2 基本上万无一失。

附加选项：-r 指定帧率，-s 指定分辨率，-b 指定比特率；于此同时可以对声道进行转码，-acodec 指定音频编码，-ab 指定音频比特率，-ac 指定声道数，例如

Terminal window

1
ffmpeg -i out.ogv -s 640x480 -b 500k -vcodec h264 -r 29.97 -acodec libfaac -ab 48k -ac 2 out.mp4

剪切

用 -ss 和 -t 选项，从第 30 秒开始，向后截取 10 秒的视频，并保存：

Terminal window

1
ffmpeg -i input.wmv -ss 00:00:30.0 -c copy -t 00:00:10.0 output.wmv
2
ffmpeg -i input.wmv -ss 30 -c copy -t 10 output.wmv

达成相同效果，也可以用 -ss 和 -to 选项，从第 30 秒截取到第 40 秒：

Terminal window

1
ffmpeg -i input.wmv -ss 30 -c copy -to 40 output.wmv

值得注意的是，ffmpeg 为了加速，会使用关键帧技术，所以有时剪切出来的结果在起止时间上未必准确。通常来说，把 -ss 选项放在 -i 之前，会使用关键帧技术；把 -ss 选项放在 -i 之后，则不使用关键帧技术。如果要使用关键帧技术又要保留时间戳，可以加上 -copyts 选项：

Terminal window

1
ffmpeg -ss 00:01:00 -i video.mp4 -to 00:02:00 -c copy -copyts cut.mp4

合并

把两个视频文件合并成一个。

简单地使用 concat demuxer，示例：

Terminal window

1
$ cat mylist.txt
2
file '/path/to/file1'
3
file '/path/to/file2'
4
file '/path/to/file3'
5

6
$ ffmpeg -f concat -i mylist.txt -c copy output

更多时候，由于输入文件的多样性，需要转成中间格式再合成：

Terminal window

1
ffmpeg -i input1.avi -qscale:v 1 intermediate1.mpg
2
ffmpeg -i input2.avi -qscale:v 1 intermediate2.mpg
3
cat intermediate1.mpg intermediate2.mpg > intermediate_all.mpg
4
ffmpeg -i intermediate_all.mpg -qscale:v 2 output.avi

调整播放速度

加速四倍：

Terminal window

1
ffmpeg -i TheOrigin.mp4 -vf  "setpts=0.25*PTS" UpTheOrigin.mp4

四倍慢速：

Terminal window

1
ffmpeg -i TheOrigin.mp4 -vf "setpts=4*PTS" DownTheOrigin.mp4

帧率设置

使用-r选项
语法是：

Terminal window

1
ffmpeg -i input -r fps output

例如：

Terminal window

1
ffmpeg -i input.avi -r 30 output.mp4

使用fps filter

另一个设置帧率是用fps filter，特别是在filterchains使用时非常有用。
例如：修改输入文件的帧率到25

Terminal window

1
ffmpeg -v clip.mpg -vf fps=fps=25 clip.webm

比特率设置

比特率也是一个决定音视频总体质量的参数。他决定每个时间单位处理的bit数。
设置比特率：

比特率决定处理1s的编码流需要多少bits，设置用-b选项。区分音视频用-b:a和-b:v
例如：设置整体1.5Mbit每秒

Terminal window

1
ffmpeg -i file.avi -b 1.5M file.mp4
2

3
ffmpeg -i input.avi -b:v 1500K output.mp4

CBR设置

CBR设置一般用作直播流，比如视频会议。为输出设置CBR,有三个参数必须设置为同一个值。
bitrate(-b option), minimal rate(-minrate), maximal rate(-maxrate)。maximal rate需要设置-bufsize选项。例如设置CBR为0.5Mbit/s。

Terminal window

1
ffmpeg -i in.avi -b 0.5M -minrate 0.5M -maxrate 0.5M -bufsize 1M output.mkv

设置输出文件的最大size

用-fs选项。
例如设置输出文件的最大的size为10M

Terminal window

1
ffmpeg -i input.avi -fs 10MB output.mp4

文件大小计算

文件的大小是是音视频流大小的和。
视频流的大小的方程式是(除以8是由bits到bytes的转换):

1
video_size = video_bitrate * time_in_seconds / 8;

如果音频是解压缩的，计算公式是：

1
audio_size = smpaling_rate * bit_depth * channels * time_in_second / 8;

例如：计算10分钟的视频， 1500kbits/s 视频比特率和 128kbits/s的音频比特率，用下面的计算方法：

1
file_size = video_size + audio_size;
2
file_size = (video_bitrate + audio_bitrate) * time_in_seconds / 8;
3
file_size = (1500 kbits/s + 128kbits/s) * 600s
4
file_size = 1628kbits/s * 600s
5
file_size = 976800kb = 976800000 b / 8 = 122100000 B / 1024 = 119238.28125KB
6
file_size = 119238.28125 KB / 1024 = 116.443634033203125MB = 116.44M

【树莓派】ZERO W上快速安装Open CV

Tue, 22 Jan 2019 00:00:00 GMT

执行命令添加源：

Terminal window

1
echo 'deb [trusted=yes] http://dl.bintray.com/yoursunny/PiZero stretch-backports main' |\
2
sudo tee  /etc/apt/sources.list.d/bintray-yoursunny-PiZero.list
3
sudo apt update

Python3:

Terminal window

1
sudo apt install python3-opencv

Python2：

Terminal window

1
sudo apt install python-opencv

【树莓派】延时拍照并上传到服务端

Tue, 22 Jan 2019 00:00:00 GMT

服务端：

1
# -*- coding: utf-8 -*-
2
import socket
3
import os
4
import time
5
#监听ip和端口
6
IP_Post = ('0.0.0.0', 1234)
7
sk = socket.socket()
8
sk.bind(IP_Post)
9
sk.listen(5)
10

11
while True:
12
    conn, addr = sk.accept()
13

14
    # #循环接收文件
15
    # while True:
16
    data = conn.recv(1024)
17
    # print(str(data,'utf-8'))
18
    print(data)
19
    file_name, file_size = str(data, 'utf-8').split('|')
20

21
    # path=os.path.join(file_name,".jpg")
22
    path = file_name+".jpg"
23
    file_size = int(file_size)
24
    has_sent = 0
25
    with open(path, 'wb') as fp:
26
        while has_sent != file_size:
27
            data = conn.recv(1024)
28
            fp.write(data)
29
            has_sent += len(data)
30
    conn.close()

展开收起

客户端：

1
import os
2
import socket
3
import cv2
4
import time
5

6

7
def s(name):
8
    #服务端ip和端口
9
    IP_Post=('192.168.1.104',1234)
10
    sk=socket.socket()
11
    sk.connect(IP_Post)
12
    size=os.stat("./1.jpg").st_size
13
    data=name+"|"+str(size)
14
    sk.sendall(bytes(data,'utf-8'))
15

16
    has_sent=0
17
    with open("./1.jpg",'rb')as fp:
18
        while has_sent != size:
19
            data = fp.read(1024)
20
            sk.sendall(data)
21
            has_sent += len(data)
22

23
    sk.close()
24

25
while True:
26
    cam=cv2.VideoCapture(0)
27
    ret,c=cam.read()
28
    cam.release()
29
    cv2.imwrite("./1.jpg",c)
30
    s(str(int(time.time())))
31
    #延时30秒
32
    time.sleep(30)

展开收起

【树莓派】Docker安装脚本

Sun, 20 Jan 2019 00:00:00 GMT

1
#!/bin/sh
2
sudo apt update
3
sudo apt install -y apt-transport-https ca-certificates curl gnupg2 lsb-release software-properties-common
4
curl -fsSL https://mirrors.ustc.edu.cn/docker-ce/linux/raspbian/gpg | sudo apt-key add -
5
echo "deb [arch=armhf] https://mirrors.ustc.edu.cn/docker-ce/linux/raspbian $(lsb_release -cs) stable" |sudo tee /etc/apt/sources.list.d/docker.list
6
sudo apt update
7
sudo apt install -y docker-ce
8
curl -fsSL get.docker.com -o get-docker.sh
9
sudo sh get-docker.sh --mirror Aliyun
10
sudo systemctl enable docker
11
sudo systemctl start docker
12
# sudo groupadd docker
13
sudo usermod -aG docker $USER
14
echo "没有报错情况下退出终端重新登录即可完成"

【Linux】WSL+Xming实现gui显示

Mon, 14 Jan 2019 00:00:00 GMT

0x00#

WSL（Windows Subsystem for Linux）配合Xming实现显示图像界面

0x01 安装#

百度谷歌一下Xming下载并安装

安装过程使用默认就好（一直“下一步”）

安装好后在开始菜单打开XLaunch，选择你要的显示方式：

Multiple windows：为每一个需要显示的Linux应用单独打开一个窗口，类似Windows的窗口（默认选这个就好）
Fullscreen：将Linux界面全屏显示
One windows：和Multiple windows类似，不过多个应用只会开一个窗口共同显示
One windows without titlebar：功能和One windows一样，会窗口隐藏标题栏
Display number：设置显示器编号（默认：0）

之后一直下一步即可

0x02 使用#

显示WSL的Linux应用界面#

在要显示的应用命令前加DISPLAY=:0，例如：

Terminal window

1
$ DISPLAY=:0 xclock

xclock为一个显示时钟的程序

DISPLAY=:0后面的0为之前设置的显示器编号

远程Linux服务器通过WSL的SSH连接显示界面#

和上面一样，加在连接命令前：

Terminal window

1
$ DISPLAY=localhost:0 ssh -X root@192.168.1.100
2

3
root@192.168.1.100:~# xclock

连接远程服务器就需要加localhost，并且需要在SSH命令中加入-X表示X11转发

如果有报错就在服务器的/etc/ssh/sshd_config中将下列语句的注释去除（如果没有就在文末添加）：

1
X11Forwarding yes
2
X11DisplayOffset 10
3
X11UseLocalhost yes

重启SSH服务：sudo systemctl restart sshd.service

0x03 END#

如果客户端不是WSL，而是在Linux系统桌面版的情况下就将客户端的/etc/ssh/ssh_config中将下列语句注释去除（如果没有就在文末添加）：

1
ForwardAgent yes
2
ForwardX11 yes
3
ForwardX11Trusted yes

重启SSH服务：sudo systemctl restart ssh.service

【树莓派】在线实时视频流部署

Fri, 11 Jan 2019 00:00:00 GMT

0x00#

通过树莓派将摄像头推流

推流使用mjpg-streamer组件

我使用的摄像头为树莓派官方的CSI接口摄像头

0x01 安装#

1.挂载摄像头（USB摄像头可跳过）#

将摄像头插在指定的接口上

1.png

进入系统执行

Terminal window

1
$ sudo raspi-config

找到Camera选项并打开

2.png

编辑文件让/dev/video0显示

Terminal window

1
sudo nano /etc/modules
2

3
在文件中添加
4
snd-bcm2835
5
bcm2835-v4l2

重启树莓派

2.安装mjpg-streamer#

执行命令

Terminal window

1
sudo apt update
2
sudo apt upgrade -y
3
sudo apt install -y git cmake libjpeg62-dev libjpeg8-dev
4
git clone https://github.com/jacksonliam/mjpg-streamer.git

由于市面上大部分摄像头是YUYV格式输出，所以要修改mjpg-streamer项目的代码文件，让其默认支持此格式的摄像头。

打开mjpg-streamer-experimental/plugins/input_uvc/input_uvc.c并找到format = V4L2_PIX_FMT_MJPEG将其改为format = V4L2_PIX_FMT_YUYV

编译、部署

Terminal window

1
cd mjpg-streamer-master/mjpg-streamer-experimental
2
sudo make clean all
3
sudo cp mjpg_streamer /usr/local/bin
4
sudo cp output_http.so input_uvc.so /usr/local/lib/
5
sudo cp -R www /usr/local/www

0x02 启动#

使用命令启动

Terminal window

1
LD_LIBRARY_PATH=/usr/local/lib mjpg_streamer -i "input_uvc.so -r 640x480 -f 12" -o "output_http.so -p 4321 -w /usr/local/www"

其中-r 640x480可改为自己摄像头的分辨率

-f 12为帧数

-p 4321为端口号

更多设置请参考README

在同一局域网下在浏览器输入树莓派IP:端口号/?action=stream可观看视频流

0x03 END#

【树莓派】树莓派各版本图纸

Fri, 11 Jan 2019 00:00:00 GMT

图纸#

内容转自树莓派基金会官网

机械图纸#

Raspberry Pi 3B+#

Raspberry Pi 3B#

Raspberry Pi Model B+#

Raspberry Pi Zero (v1.2)#

Raspberry Pi PoE HAT#

Raspberry Pi TV HAT#

原理图#

【树莓派】在模拟器中运行树莓派arm系统

Sat, 29 Dec 2018 00:00:00 GMT

0x00#

我有时候使用golang编译好的程序想在树莓派（arm芯片）测试，但奈何有时候手边没有树莓派或我的远程树莓派掉线了(Ｔ▽Ｔ)，这个时候就需要一个模拟器了。实现这个方法使用的是QEMU模拟器，它是一个全平台模拟器，没有图形界面使用命令启动。

环境：Windows10 1809

软件：QEMU

实验镜像：2018-11-13-raspbian-stretch-lite.img

0x01 准备#

将在树莓派官网下载的镜像解压到.img后缀。
下载编译好的树莓派内核及相关文件：

下载kernel-qemu-x.x.xx文件，我当前使用的是kernel-qemu-4.9.59-stretch
下载versatile-pb.dtb文件

0x02 使用#

命令行执行（如果提示找不到该命令，到QEMU安装目录按住Shift鼠标右键，选择此处打开命令窗口）：

Terminal window

1
qemu-system-arm -kernel kernel-qemu-x.x.xx文件所在地址 -cpu arm1176 -m 256 -M versatilepb -dtb versatile-pb.dtb文件地址 -no-reboot -append "root=/dev/sda2 panic=1 rootfstype=ext4 rw" -net nic -net user,hostfwd=tcp::5022-:22 -hda 镜像文件地址

其中-m为运行内存大小

1.png

2.png

0x03 END#

如果想运行其他镜像可以自己编译相关的内核，参考地址

【树莓派】搭建FM发射器

Tue, 25 Dec 2018 00:00:00 GMT

0x00#

Warning

未尽有关部门批准私人架设FM电台是违法的，轻则拘留重则判刑。本教程仅供实验、学习研究，切勿用作实际用途。

0x01 安装#

安装依赖组件

Terminal window

1
$ sudo apt install libsndfile1-dev

检查是否有rpi-mailbox驱动，该驱动在2015年以后的Raspbian自带。

下载并安装所需程序

Terminal window

1
$ git clone https://github.com/ChristopheJacquet/PiFmRds.git
2

3
$ cd PiFmRds/src
4
$ make clean
5
$ make

0x02 使用#

FM发射信号的发射天线定义在GPIO 4(pin 7)号针脚上，可以在此针脚连接杜邦线增强信号。

发射信号：#

Terminal window

1
$ sudo ./pi_fm_rds -audio sound.wav

运行pi_fm_rds的一般语法：#

Terminal window

1
pi_fm_rds [-freq 信号频率] [-audio 音频文件] [-ppm 振荡器误差] [-pi 广播代码] [-ps 电台名称] [-rt 传输无线电文本]

参数介绍：#

-freq指定载波频率（以MHz为单位）。示例：-freq 107.9
-audio指定要作为音频播放的音频文件。采样率无关紧要：Pi-FM-RDS将重新采样并对其进行过滤。如果提供立体声文件，Pi-FM-RDS将产生FM立体声信号。示例：-audio sound.wav。支持的格式取决于libsndfile。这包括WAV和Ogg / Vorbis（以及其他），但不包括MP3。指定-作为文件名来读取标准输入上的音频数据（用于将音频传输到Pi-FM-RDS，见下文）。
-pi指定RDS广播的PI代码。4个十六进制数字。示例：-pi FFFF。
-ps指定RDS广播的电台名称（节目服务名称，PS）。限制：8个字符。示例：-ps RASP-PI。
-rt指定要传输的无线电文本（RT）。限制：64个字符。示例：-rt 'Hello, world!'。
-ctl 指定一个命名管道（FIFO），用作控制通道，在运行时更改PS和RT（见下文）。
-ppm 以百万分率（ppm）表示您的Raspberry Pi振荡器误差，请参见下文。

默认情况下，PS在Pi-FmRds序列号之间来回切换，从00000000开始。PS每秒变化一次。

高级发射音频：#

如果使用参数-audio -，Pi-FM-RDS将读取标准输入的音频数据。这允许您将程序的输出传输到Pi-FM-RDS。例如，这可以用于使用Sox读取MP3文件：

Terminal window

1
sox -t mp3 http://www.linuxvoice.com/episodes/lv_s02e01.mp3 -t wav -  | sudo ./pi_fm_rds -audio -

或者将声卡的AUX输入传输到Pi-FM-RDS：

Terminal window

1
sudo arecord -fS16_LE -r 44100 -Dplughw:1,0 -c 2 -  | sudo ./pi_fm_rds -audio -

0x03 END#

其他问题请查看该项目说明文件

【Linux】硬盘休眠

Mon, 10 Dec 2018 00:00:00 GMT

本文转自：http://www.mkitby.com/2016/05/15/raspberry-pi-nas-manage-hdd-power/
使用树莓派3b和一块旧式笔记本ide硬盘实验，发现hd-idle可行。

为了延长硬盘使用寿命，当硬盘不使用时，需要让硬盘休眠，目前有一些软件可以自动做这事，像 hdparm, hd-idle 和 sdparm，具体用哪个取决于USB to SATA控制器和硬盘本身，其实说白了就是一个一个试，哪个有用就用哪个。当然，这里说的都是机械硬盘，固态硬盘没研究过。

注意：不要让机械硬盘频繁地休眠唤醒，这样会给电机和轴承较大负荷，会加剧硬盘损耗. 一般制造商建议的最小休眠时间是 3-5 分钟。参考（http://hd-idle.sourceforge.net/）

首先查看硬盘设备名，一般就是/dev/sda,dev/sdb之类的

Terminal window

1
sudo blkid

例如输出

1
/dev/mmcblk0p1: SEC_TYPE="msdos" LABEL="boot" UUID="15CD-3B79" TYPE="vfat"
2
/dev/mmcblk0p2: UUID="13d368bf-6dbf-4751-8ba1-88bed06bef77" TYPE="ext4"
3
/dev/sda1: UUID="7e623443-f19a-4564-8e60-e9d2170ac32a" TYPE="ext4"
4
/dev/sdb1: LABEL="COLORSPACE" UUID="F8E6-4FDB" TYPE="vfat"
5
/dev/sdb2: UUID="3007-F316" TYPE="exfat"

硬盘设备名为/dev/sdb,硬盘有两个分区

安装和配置hdparm#

先测试hdparm是否支持。

安装 hdparm，

Terminal window

1
sudo apt-get install hdparm -y

确保你的硬盘支持hdparm,

Terminal window

1
sudo hdparm -y /dev/sdb

如果输出如下结果，就表明支持，

1
/dev/sdb:
2
 issuing standby command

如果看到类似如下输出，就表明不支持，可以跳到 hd-idle 或者 sdparm，

1
/dev/sda:
2
 issuing standby command
3
SG_IO: bad/missing sense data, sb[]:  70 00 05 00 00 00 00 0a 00 00 00 00 20 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

检查硬盘是否支持写缓存功能，

Terminal window

1
sudo hdparm -I /dev/sdb | grep 'Write cache'

如果看到 * (星号)，表示支持，

1
*    Write cache

如果没有看到 * (星号)，表示不支持，

1
Write cache

编辑配置文件，

Terminal window

1
sudo vim /etc/hdparm.conf

spindown_time值乘以 5 得到总的时间（单位秒）. 例如想配置成空闲10分钟就休眠，spindown_time = 10 * 60 / 5 = 120

在文件结尾加入，

1
/dev/sdb {
2
write_cache = on
3
spindown_time = 120
4
}

如果不支持写缓存，去掉 write_cache = on。

重启 hdparm 服务，

Terminal window

1
sudo service hdparm restart

更多hdparm配置可以参考这(http://www.linux-magazine.com/Online/Features/Tune-Your-Hard-Disk-with-hdparm)

安装和配置 hd-idle#

如果你的硬盘不支持 hdparm，或者就想试下hd-idle, 可以删除hdparm

Terminal window

1
sudo apt-get remove hdparm -y

hd-idle 使用一个特殊的系统文件来检测磁盘活动, 如果没有这个文件，那么就不能使用hd-idle。输入

Terminal window

1
cat /proc/diskstats

应该会看到如下的输出, 如果提示找不到文件或目录，那就不支持hd-idle。

8 16 sdb 5604 130363 146538 16780 1814 51838 429152 763380 0 18230 780150 8 17 sdb1 5075 130363 139418 15370 8 0 8 10 0 8680 15370 8 18 sdb2 512 0 6984 1290 1805 51838 429144 763360 0 9770 764650

hd-idle的自己编译，

Terminal window

1
sudo apt-get install build-essential fakeroot debhelper -y

获取源代码，

Terminal window

1
wget http://sourceforge.net/projects/hd-idle/files/hd-idle-1.05.tgz

解压缩进入目录

Terminal window

1
tar -xvf hd-idle-1.05.tgz && cd hd-idle

编译安装，

Terminal window

1
dpkg-buildpackage -rfakeroot
2
sudo dpkg -i ../hd-idle_*.deb

继续检查硬盘是否支持hd-idle,

Terminal window

1
sudo hd-idle -i 0 -a sda -i 300 -d

你会看到如下输出：

probing sda: reads: 13418, writes: 594344 probing sdb: reads: 146538, writes: 429152

按 Ctrl+C 停止 hd-idle

编辑配置文件，

Terminal window

1
sudo vim /etc/default/hd-idle

修改下面来开启hd-idle

Terminal window

1
START_HD_IDLE=true

调整空闲时间为10分钟 (60 秒 * 10)

Terminal window

1
HD_IDLE_OPTS="-i 0 -a sda -i 600"

重启服务，

Terminal window

1
sudo service hd-idle restart

如果hd-idle也不支持，可以试下 sdparm

安装和配置 sdparm#

首先删除 hdparm 和 hd-idle

Terminal window

1
sudo apt-get remove hdparm -y
2
sudo dpkg -r hd-idle

安装 sdparm

Terminal window

1
sudo apt-get install sdparm -y

测试sdparm是否支持，停止一切硬盘操作，输入

Terminal window

1
sydo sdparm --flexible --command=stop /dev/sdb

应该可以看到如下输出，

1
/dev/sdb: SANHO     IUSBPORT          0

如果需要每隔10分钟休眠硬盘，可以用如下crontab命令

Terminal window

1
sudo crontab -l | { cat; echo "/10 * * * * sdparm --command=stop /dev/sda"; } | sudo crontab -

经过以上折腾，终于可以放心了，不用担心硬盘一天24小时不要命的转。

参考#

http://sg.danny.cz/sg/sdparm.html http://www.nslu2-linux.org/wiki/FAQ/SpinDownUSBHarddisks http://hd-idle.sourceforge.net/

【Tensorflow】卷积神经网络图片风格转化

Mon, 03 Dec 2018 00:00:00 GMT

0x00#

之前有一款火爆网络的图像风格转化软件 Prisma，它能将一张普通的图片转成各种艺术风格的图像。现在简单来了解一下背后的算法原理及使用Tensorflow实现一下。

0x01 原理简述#

2016 CVPR 一篇文章：” Image Style Transfer Using Convolutional Neural Networks”（文章翻译）提出了这种算法。

算法流程图：

1.png

简单地说就是使用一个训练好的卷积神经网络 VGG-19（19层VGG网络包含16个卷积层和5个池化层），而这个网络在ImageNet上已经有训练好了的。

假如现在有一张风格图像和一张普通图像，风格图像经过VGG-19 的时候在每个卷积层会得到很多 feature maps, 这些feature maps 组成一个集合 A，同样的，普通图像 通过 VGG-19 的时候也会得到很多 feature maps，这些feature maps 组成一个集合 B ，然后生成一张随机噪声图像 ,同样 随机噪声图像 通过VGG-19 的时候也会生成很多feature maps，这些 feature maps 构成集合 C ,最终的优化函数是希望调整 C 让 随机噪声图像 最后既保持普通图像 的内容, 又有一定的风格图像的风格。

2.png

想要了解更多请阅读原文 ” Image Style Transfer Using Convolutional Neural Networks”（文章翻译）

0x02 实现#

较好的实现项目：

neural-style *需要性能较好的计算机。512 x 512分辨率的图片使用不同硬件进行1000次迭代性能对比：
1. GTX 1080 ~60s
2. Maxwell Titan X ~90s
3. Intel Core i7-5930K ~1h
fast-neural-style-tensorflow *可以使用预训练模型或自己训练模型，使用预训练的模型在性能较低的计算机上也能较好地实现。

这里使用预训练模型。

Tensorflow安装

克隆项目：

Terminal window

1
git clone https://github.com/Rehtt/fast-neural-style-tensorflow.git

运行：

Terminal window

1
#图像
2
python eval.py --model_file <wave.ckpt-done模型的路径> --image_file img/test.jpg
3

4
#视频
5
python video.py --model_file <wave.ckpt-done模型的路径> --video_file video/test.mp4 --out_video_file video/video.mp4

详情及训练模型请阅读说明

【树莓派】树莓派+aria2搭建远程下载器

Sun, 25 Nov 2018 00:00:00 GMT

0x00#

之前采用的是迅雷+树莓派的方案搭建远程下载机，但是现在迅雷远程下载总是出现问题加上迅雷已经停止维护第三方下载机的程序(╯°Д°)╯︵┻━┻，不过劳动人民的智慧是无穷的(๑＞︶＜)و，在这里采用树莓派+aria2来搭建下载机使用云服务器使用frp内网穿透转发来实现远程控制。

环境：树莓派3B、Raspbian

软件：aria2（下载器）、frp（内网穿透）

0x01 搭建下载环境#

1.aria2安装#

Aria2是一款免费开源跨平台且不限速的多线程下载软件，Aria2的优点是速度快、体积小、资源占用少。

在树莓派官方系统Raspbian及大多数系统中是支持直接安装的，在其他系统中就有可能需要编译安装。

这里主要使用直接安装，在终端输入

Terminal window

1
$ sudo apt update && sudo apt upgrade -y
2
$ sudo apt install aria2 -y

2.aria2配置#

先创建配置文件夹和创建相关文件

Terminal window

1
$ mkdir ~/.config/aria2
2
$ touch ~/.config/aria2/aria2.conf
3
$ touch ~/.config/aria2/aria2.session

编写简单配置文件

Terminal window

1
$ nano ~/.config/aria2/aria2.conf

aria2.conf 内容：

1
#启用RPC远程连接, 默认:false
2
enable-rpc=true
3
#允许所有来源, 默认:false
4
rpc-allow-origin-all=true
5
#允许非外部访问, 默认:false
6
rpc-listen-all=true
7
#RPC监听端口, 端口被占用时可以修改, 默认:6800
8
rpc-listen-port=6800
9
#设置的RPC授权令牌, v1.18.4新增功能, 取代 --rpc-user 和 --rpc-passwd 选项。建议在远程连接下载启用保障安全
10
rpc-secret=123456
11

12
#从会话文件中读取下载任务
13
input-file=/etc/aria2/aria2.session
14
#在Aria2退出时保存`错误/未完成`的下载任务到会话文件
15
save-session=/etc/aria2/aria2.session
16
#定时保存会话, 0为退出时才保存, 需1.16.1以上版本, 默认:0
17
save-session-interval=60
18

19
#下载文件保存地址
20
dir=~/downloads
21
#断点续传
22
continue=true
23
#文件预分配，减少碎片文件，默认：prealloc
24
#预分配所需时间: none < falloc ? trunc < prealloc
25
#树莓派Raspbian是Linux系统采用EXT3/4文件系统，所以使用trunc
26
file-allocation=trunc

展开收起

可以在配置文件中选择添加bt下载服务器，服务器列表：

1
bt-tracker=（服务器地址以","分隔）

如果需要添加其他参数请阅读Aria2官方文档及善于搜索（求人不如求己(～￣▽￣)～）

0x02 配置远程下载及界面#

1.配置远程下载#

这里使用frp转发来实现内网穿透（需要有云服务器做中转），如果有公网ip就不需要，公网ip一般只有企业宽带才可能有，或者也可以打电话到宽带运营商开通（可以上网学习一下网友打电话开通的各种骚操作ヽ(￣▽￣)ﾉ）

使用frp主要转发aria2的rpc端口。

参考frp教程

2.配置界面#

由于aria2是没有图像界面的所以这里使用的是web网页界面webui-aria2，可以使用在线的网页需要填入树莓派地址、端口、令牌（可选），也可以将此网页界面下载到本地使用。

在本地电脑或树莓派或云服务器上下载webui-aria2

Terminal window

1
$ git clone https://github.com/ziahamza/webui-aria2.git

进入其中的docs目录修改文件

Terminal window

1
$ cd webui-aria2/docs
2
$ nano ./app.js
3

4
点击键盘ctrl+w搜索"location.hostname:"，修改
5
" location.hostname：树莓派所在的ip或网址 "
6
" port: aria2的rpc端口 "
7

8
搜索找到" (c = p && p.auth && p.auth.token ? p.auth.token : null),"，并将这行修改为" (c="你配置rpc-secret的值") "

0x03 END#

【免杀】通过修改特征码实现杀毒软件免杀

Wed, 17 Oct 2018 00:00:00 GMT

0x00 前言#

前几天写的一个程序被火绒误报毒了不开森(╬￣皿￣)，不过劳动人民的智慧是无穷的(๑＞︶＜)و，通过修改软件特征码就可以绕过杀毒软件的检测。

使用工具：myccl（将文件分块找查具体报毒的特征码所在的位置），c32asm（修改文件特征码，用其他的16进制/汇编修改工具也可以）

0x01 查找具体特征码#

1.打开myccl加载报毒文件，先将文件分块20份

Lily_Screenshot_1539742852.png

2.点击“生成”，找到分块的目录使用杀毒软件查杀文件

Lily_Screenshot_1539742992.png

3.将报毒的文件删除，回到myccl点击“二次处理”

4.循环“查杀病毒”>“二次处理”，一直到没报毒为止，这样做是为了缩小特征码范围

5.随后会定位到特征码范围

Lily_Screenshot_1539743989.png

但是特征码物理长度太大，所以还要进一步定位

6.点击“特征区间”，选中右键“复合定位此处特征”，随后可以看到被重新分块且长度为2

Lily_Screenshot_1539743135.png

7.点击“生成”，随后重复第4步，最后找到长度为2的特征码

Lily_Screenshot_1539744377.png

其中物理地址就是我们要找的特征码

0x02 修改特征码#

打开c32asm，以16进制打开文件

1.右键“跳到”，输入刚刚定位的物理地址

Lily_Screenshot_1539744661.png

2.右键“对应汇编模式编辑”

Lily_Screenshot_1539744905.png

3.我这16进制对应的汇编指令是“ADD”（根据自己实际情况而定），将它替换对应的“等价汇编指令”（上百度google一下），“ADD”对应的是“ADC”

4.右键“汇编”，输入相应的“等价汇编指令”

Lily_Screenshot_1539744948.png

5.点击“汇编”，“退出”

6.保存文件即可

0x03 END#

用杀毒软件扫描没有报毒就修改成功

【C++】修改注册表管理开机启动项

Tue, 16 Oct 2018 00:00:00 GMT

1
// 程序开机自动启动
2
void autostart()
3
{
4
    HKEY hKey;
5
    QString strRegPath = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run";
6

7
    //1、找到系统的启动项
8
    if (RegOpenKeyEx(HKEY_CURRENT_USER, strRegPath.toStdString().c_str(), 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS) ///打开启动项
9
    {
10
        //2、得到本程序自身的全路径
11
        TCHAR strExeFullDir[MAX_PATH];
12
        GetModuleFileName(NULL, strExeFullDir, MAX_PATH);
13

14
        //3、判断注册表项是否已经存在
15
        TCHAR strDir[MAX_PATH] = {};
16
        DWORD nLength = MAX_PATH;
17
        long result = RegGetValue(hKey, nullptr, "GISRestart", RRF_RT_REG_SZ, 0, strDir, &nLength); ///"GISRestart"是应用程序名字
18

19
        //4、已经存在
20
        if (result != ERROR_SUCCESS || _tcscmp(strExeFullDir, strDir) != 0)
21
        {
22
            //5、添加一个子Key,并设置值，"GISRestart"是应用程序名字（不加后缀.exe）
23
            RegSetValueEx(hKey, "GISRestart", 0, REG_SZ, (LPBYTE)strExeFullDir, (lstrlen(strExeFullDir) + 1)*sizeof(TCHAR));
24

25
            //6、关闭注册表
26
            RegCloseKey(hKey);
27
        }
28
    }
29
    else
30
    {
31
        MessageBox(NULL, "设置失败", "error", 0);
32
    }
33
}
34

35
// 取消开机自动启动
36
void cancelAutoStart()
37
{
38
    HKEY hKey;
39
    const char* strRegPath = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run";
40

41
    //1、找到系统的启动项
42
    if (RegOpenKeyEx(HKEY_CURRENT_USER, strRegPath, 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS)
43
    {
44
        //2、删除值
45
        RegDeleteValue(hKey, "GISRestart");
46

47
        //3、关闭注册表
48
        RegCloseKey(hKey);
49
    }
50
}

展开收起

【人工智能】TensorFlow Windows安装

Sun, 07 Oct 2018 00:00:00 GMT

0x00 TensorFlow环境搭建#

本教程引用 https://www.tensorflow.org/install/install_windows

仅支持CPU。如果您的系统没有 NVIDIA® GPU，则必须安装此版本。请注意，此版本的 TensorFlow 通常更容易安装（用时通常在 5 或 10 分钟内），所以即使您拥有 NVIDIA GPU，我们也建议先安装此版本。预编译的二进制文件将使用 AVX 指令。
支持GPU。TensorFlow 程序在 GPU 上的运行速度通常要比在 CPU 上快得多。因此，如果您的系统配有满足以下所示先决条件的 NVIDIA® GPU，并且您需要运行性能至关重要的应用，则最终应安装此版本。

GPU版本环境搭建#

GPU版本要求使用NVIDIA GPU卡，并且CUDA计算能力在3.0及以上。CUDA 计算能力为3.0或更高的卡需要从源码编译安装TensorFlow 。计算能力为3.5或更高的卡可以使用编译好的二进制文件安装TensorFlow （使用pip安装.whl）。

当前为TensorFlow-gpu 1.11.0的环境要求，必须按照要求的版本安装，若版本高于或低于要求都有可能出现错误。

CUDA Toolkit 9.0
cuDNN v7.0 下载完后解压，将内部的三个文件夹复制到CUDA Toolkit 的安装目录下

注意：cuDNN 版本必须完全匹配：如果无法找到 cuDNN64_7.dll，TensorFlow 就不会加载。要使用不同版本的 cuDNN，必须从源代码构建。

0x01 TensorFlow安装#

使用pip安装#

支持的python版本：3.5 3.6

CPU版本安装：

Terminal window

1
pip3 install tensorflow

GPU版本安装：

Terminal window

1
pip3 install tensorflow-gpu

使用Anaconda安装#

通过调用以下命令创建名为 tensorflow 的 conda 环境：
Terminal window
```
1
C:> conda create -n tensorflow pip python=3.5
```

通过发出以下命令激活 conda 环境：

Terminal window

1
C:> activate tensorflow
2
 (tensorflow)C:>  # Your prompt should change

发出相应命令以在 conda 环境中安装 TensorFlow。要安装仅支持 CPU 的 TensorFlow 版本，请输入以下命令：
Terminal window
```
1
(tensorflow)C:> pip install --ignore-installed --upgrade tensorflow
```
要安装 GPU 版本的 TensorFlow，请输入以下命令（在同一行）：
Terminal window
```
1
(tensorflow)C:> pip install --ignore-installed --upgrade tensorflow-gpu
```

验证安装是否成功#

进入Python环境

输入：

1
>>> import tensorflow as tf
2
>>> hello = tf.constant('Hello, TensorFlow!')
3
>>> sess = tf.Session()
4
>>> print(sess.run(hello))

若输出以下内容就说明安装成功：

1
Hello, TensorFlow!

如果系统输出一条错误消息而不是问候语，请参阅常见的安装问题

常见的安装问题#

我们借助 Stack Overflow 来记录 TensorFlow 安装问题及其补救措施。下表包含了 Stack Overflow 上一些常见安装问题解答的链接。如果您遇到了下表中未列出的错误消息或其他安装问题，请在 Stack Overflow 上进行搜索。如果 Stack Overflow 中没有显示相关错误消息，请在 Stack Overflow 上提一个新的问题，并指定 tensorflow 标签。

Stack Overflow 链接	错误消息
41007279	`[...\stream_executor\dso_loader.cc] Couldn't open CUDA library nvcuda.dll`
41007279	`[...\stream_executor\cuda\cuda_dnn.cc] Unable to load cuDNN DSO`
42006320	`ImportError: Traceback (most recent call last): File "...\tensorflow\core\framework\graph_pb2.py", line 6, in from google.protobuf import descriptor as _descriptor ImportError: cannot import name 'descriptor'`
42011070	`No module named "pywrap_tensorflow"`
42217532	`OpKernel ('op: "BestSplits" device_type: "CPU"') for unknown op: BestSplits`
43134753	`The TensorFlow library wasn't compiled to use SSE instructions`
38896424	`Could not find a version that satisfies the requirement tensorflow`

【Python】安装Dlib人脸识别库

Sun, 30 Sep 2018 00:00:00 GMT

安装环境#

Windows#

Terminal window

1
pip install opencv-python
2

3
pip install dlib==19.8.1

目前19.8.1及之前的版本支持.whl免编译安装，如果要安装最新版则需要采用编译安装的方式：

确保有安装Visual Studio，因为boost在Windows下需要使用Visual Studio的组件编译安装。
下载boost源文件解压后双击bootstrap.bat，在同目录下会生成b2.exe与bjam.exe两个文件。
命令输入

Terminal window

1
bjam install --toolset=msvc-10.0 architecture=x86 address-model=64 --build-type=complete --prefix="E:\boost_1_64_0\boost_1_64_0\bin\vc10_x64" link=static runtime-link=shared threading=multi debug release

进行编译安装

参数解释：

link=shared 可以生成dll。（.\bjam.exe link=shared)
- toolset=msvc-14.1 即VS2017 (我用的vs2017)
- toolset=msvc-12.0 即VS2013
- toolset=msvc-10.0 即VS2010
- toolset=msvc-9.0 即VS2008
—with-xxxx 如果你要编 chrono，就用 —with-chrono
—stagedir=”./vc2017” 自己设定一个输出目录
address-model=64 设定32或者64位模式

下载安装CMake
编译安装Dlib

Terminal window

1
pip install dlib

Linux#

Terminal window

1
sudo apt install cmake boost-dev
2
pip install opencv-python
3
pip install dlib

Mac#

Terminal window

1
brew install cmake brew install boost brew install boost-python --with-python3
2

3
pip install opencv-python
4

5
pip install dlib

【Linux】mysql服务安装

Wed, 19 Sep 2018 00:00:00 GMT

0x00 安装#

终端输入

Terminal window

1
$ sudo apt install -y mysql-server

0x01 设置root密码#

安装完后root默认是没有密码的，但可以使用系统root权限免密码进入数据库

Terminal window

1
$ sudo mysql -u root

进入后

1
use mysql;
2
update user set plugin='mysql_native_password' where user='root';
3
update user set password=password('密码') where user='root';
4
flush privileges;
5
exit;

重启数据库

Terminal window

1
$ sudo service mysql restart

0x02 开启远程访问#

修改配置

Terminal window

1
$ sudo nano /etc/mysql/mariadb.conf.d/50-server.cnf
2
将 bind-address 127.0.0.1 注释掉
3

4
$ sudo service mysql restart

进入数据库设置远程登录操作

1
use mysql;
2
grant all privileges on *.* to 'root'@'%' identified by 'root账户密码' with grant option;
3
flush privileges;

【Golang】所遇问题及解答

Thu, 13 Sep 2018 00:00:00 GMT

###0x00.Respones.Body只能读一遍

因为我采用ioutil.ReadAll读取Respones.Body，所以后来发现再次读取Respones.Body发现是空的。这是因为Body会标记读取位置，ReadAll会读取到末尾，因此第二次就会读不到数据。

解决方法：

1
res, _ := ioutil.ReadAll(respones.Body)
2

3
respones.Body.Close()
4
respones.Body = ioutil.NopCloser(bytes.NewBuffer(res))

【Golang】命令行传递参数

Thu, 13 Sep 2018 00:00:00 GMT

0x00 命令行参数的使用#

Go的命令行参数储存在切片os.Args中

1
for i,s := range os.Args{
2
    fmt.Println("Args[%d]=%s",i,s)
3
}

0x01 flag包对命令行参数解析#

flag包

1
flag.Type("Flag Name",Default Value,"Help Message") *Tpye

使用实例：

1
var i = flag.Int("i" , 1 ,"number")
2

3
func main(){
4
    flag.Pares()
5
    fmt.Println(*n)
6
}

Terminal window

1
#./main -h
2
Usage of ./main:
3
  -h int
4
        number (default 1)
5

6
#./main -i 1234
7
1234

0x02 cmd输入#

窗口停留等待输入

1
var i string
2

3
func main(){
4
    fmt.Scanln(&i)
5
    fmt.Println(i)
6
}

【树莓派】使用Python驱动SSD1306 OLED显示

Tue, 11 Sep 2018 00:00:00 GMT

0x00#

因为之前用的Nokia5110显示有故障，所以在网友的推荐下接触到了SSD1306。

显示模块型号：SSD1306 OLED
显示范围：单色 128*64点阵
测试机：树莓派zero w
测试机系统：Raspbian stretch life
开发语言：Python3
采用驱动库：Adafruit Python SSD1306

0x01环境准备#

1.树莓派开启I2C接口#

终端输入

Terminal window

1
sudo raspi-config

选择Interfacing Options，开启I2C接口

Lily_Screenshot_1536654250.png

Lily_Screenshot_1536654260.png

Lily_Screenshot_1536654272.png

更改显示速率（可选，不推荐，会占用大量GPIO资源）#

为了更好的显示性能，例如显示动画时如对帧率有要求，可以通过修改下面的参数将 I2C 频率从默认的 100KHz 或 400KHz 提升到 1MHz。

Terminal window

1
sudo nano /boot/config.txt

在文件末添加一行：

1
dtparam=i2c_baudrate=1000000

2.接线#

模块共4针脚，接线为

VCC 1
GND 6
SCL 5
SDA 3

Lily_Screenshot_1536654018.png

3.驱动#

GPIO驱动：

Terminal window

1
pip install Adafruit_GPIO

SSD1306采用的驱动是Adafruit Python SSD1306，用pip安装即可。

Terminal window

1
sudo python -m pip install --upgrade pip setuptools wheel
2
sudo pip install Adafruit-SSD1306

或者采用python文件安装：

Terminal window

1
sudo python -m pip install --upgrade pip setuptools wheel
2
git clone https://github.com/adafruit/Adafruit_Python_SSD1306.git
3
cd Adafruit_Python_SSD1306
4
sudo python setup.py install

0x03使用#

采用python文件安装的可以在Adafruit_Python_SSD1306文件夹中看见examples实例文件夹。

首先是导入驱动的库：

1
import Adafruit_GPIO.SPI as SPI
2
import Adafruit_SSD1306

针脚配置：

1
# Raspberry Pi pin configuration:
2
RST = 24
3
# Note the following are only used with SPI:
4
DC = 23
5
SPI_PORT = 0
6
SPI_DEVICE = 0

显示配置：

1
#分辨率选择一个即可
2
# 128x32
3
disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST)
4
# 128x64
5
disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST)
6

7

8
# 初始化库
9
disp.begin()
10
# 获取屏幕大小
11
width = disp.width
12
height = disp.height
13
# 清除屏幕内容
14
disp.clear()
15
disp.display()

展开收起

1.显示内容#

屏幕显示内容是先建立一张与屏幕相等的空白画布，将要显示的内容添加到其中，最后再显示出来：

1
# 创建空白画布
2
# 颜色为1 bit
3
width = disp.width
4
height = disp.height
5
image = Image.new('1', (width, height))
6

7
# 画布绘制对象
8
draw = ImageDraw.Draw(image)
9

10
# 绘制一个黑色内容清除画布内容
11
draw.rectangle((0,0,width,height), outline=0, fill=0)
12

13
# 绘制内容
14
# 定义一些常亮控制图形大小
15
padding = 2
16
shape_width = 20
17
top = padding
18
bottom = height-padding
19
# 从左向右移动，跟踪绘制形状的当前位置
20
x = padding
21
# 绘制椭圆
22
draw.ellipse((x, top , x+shape_width, bottom), outline=255, fill=0)
23
x += shape_width+padding
24
# 绘制矩形
25
draw.rectangle((x, top, x+shape_width, bottom), outline=255, fill=0)
26
x += shape_width+padding
27
# 绘制三角
28
draw.polygon([(x, bottom), (x+shape_width/2, top), (x+shape_width, bottom)], outline=255, fill=0)
29
x += shape_width+padding
30
# 绘制X
31
draw.line((x, bottom, x+shape_width, top), fill=255)
32
draw.line((x, top, x+shape_width, bottom), fill=255)
33
x += shape_width+padding
34

35
# 加载默认字体
36
font = ImageFont.load_default()
37

38
# 或者使用其他.ttf格式的字体，字体文件要与执行文件在同一目录
39
#font = ImageFont.truetype('Minecraftia.ttf', 8)
40

41
# 加两行文字
42
draw.text((x, top),    'Hello',  font=font, fill=255)
43
draw.text((x, top+20), 'World!', font=font, fill=255)
44

45
# 显示
46
disp.image(image)
47
disp.display()

展开收起

617739217782034705.jpg

2.显示图片#

1
# 根据OLED高度加载图片，图片要转换成1 bit颜色
2
if disp.height == 64:
3
    image = Image.open('image_64.png').convert('1')
4
else:
5
    image = Image.open('image_32.png').convert('1')

46229923031718465.jpg

PS<可以把喜欢的图片改成不超过128>*64，再在Photoshop里先把模式改成灰度，然后调对比度和亮度，在不影响视觉的前提下尽可能对比度大。然后再改模式为“位图”，方法选“扩散仿色”，然后另存为PNG，选项为交错，就可以让OLED显示了。

END

ArchLinux使用中文输入法

Wed, 29 Aug 2018 00:00:00 GMT

0x00

Terminal window

1
pacman -S fcitx fcitx-im

安装完后编辑~/.xprofile文件，添加代码：

Terminal window

1
#fcitx
2
export GTK_IM_MODULE=fcitx
3
export QT_IM_MODULE=fcitx
4
export XMODIFIERS="@im=fcitx"

重启或注销即可

0x01 安装搜狗输入法（先要导入国内arch论坛源）

Terminal window

1
pacman -S fcitx-sogoupinyin

Sun, 26 Aug 2018 00:00:00 GMT

0x01 强大的在线工具#

MikuTools - 在线工具集合

在线抠图 - 抠图

Processon - 在线作图流程图、思维导图、原型图、UML、网络拓扑图、组织结构图等

UZER - 随时使用各种应用

二次元头像生成器 - 生成二次元头像>>>GitHub

seq2seq-couplet - 深度学习对对联

ping.pe - 在线测试服务器延迟和丢包

0x02 生活需要点趣味#

0x03 学习也是门艺术#

多邻国 - 多国语言学习

hangzhou_house_knowledge - 买房参考

数据科学#

Data Science Cheatsheets - 数据科学相关资料

人工智能#

AiLearning - AI学习路线

算法#

Leetcode(中国) - 算法题库

Visualgo - 数据结构和算法动态可视化

Algorithm Visualizer - 算法可视化

基础学习#

Spring Boot 学习示例 - Spring Boot 学习

《第一行代码》代码资源 - Android

Kotlin-Tutorials - Kotlin学习视频

Go语言圣经 - Golang学习宝典

github-cheat-sheet - GitHub 秘籍>>>翻译

Docker — 从入门到实践 - Docker学习

鸟哥的linux私房菜 - Linux学习

SSH隧道：内网穿透实战 - SSH内网穿透

安全#

Papers - 安全大神的安全峰会文件

Awesome Hacking - 黑客技术清单

Freebuf

sec-wiki

看雪

趣味#

What happens when… - 从计算机底层讲起打开一个网页的全过程>>>翻译

How To Ask Questions The Smart Way - 提问的智慧，学习如何提问

themostdangerouswritingapp - 写作，超过5秒没输入就删档

0x03 好的工具让你事半功倍#

树莓派#

WOA Deployer for Raspberry Pi 3 - 树莓派3上运行win10

Pi-FM-RDS - 通过树莓派发送FM广播

BerryBoot - 树莓派多系统引导

OpenWrt（第三方编译，插件多，符合“国情”） - 树莓派路由器

OpenWrt/LEDE编译项目

网络#

SketchCode - 手绘图自动生成 html

Cloud Torrent - Golang开发的BT磁力下载神器

mjpg-streamer - 网络摄像头

itchat - Python实现微信

高可用IP代理池 - 为大型爬虫项目提供高可用低延迟的高匿IP代理池

you-get - 下载视频

youtube-dl - 下载视频

youtube-dl-gui - youtube-dl图形界面版

frp - 内网穿透

IPsec VPN Server Auto Setup Scripts - vpn服务器架设

Hack#

wifiphisher - wifi钓鱼

Wi-PWN - 在ESP8266上进行wifi攻击

P4wnP1 - 使用树莓派进行渗透攻击

cSploit - Android网络渗透

weevely3 - PHP后门

create_ap - linux Wifi热点

mimikatz - 套取windows密码

其他#

Terminalizer - 录制终端生成GIF或视频

Polacode - 生成代码截图，VScode插件

LabelImg - 图片标注

ASCII Camera - ASCII相机

etcher - 系统烧录工具

ephtracy - 快速3D建模

0x04 优质资源让人欲罢不能#

深度学习#

FCHD-Fully-Convolutional-Head-Detector - 基于torch的高精度人头识别

neural-style - 基于tensorflow的图片风格化（推荐）

neural-style - 基于torch的图片风格化

fast-neural-style-tensorflow - 基于tensorflow的图片风格化

waifu2x - 放大图片

waifu2x-caffe - waifu2x caffe版

Windows Terminal - windows终端

DAIN-APP - AI插帧（低帧视频转高帧）

Topaz Gigapixel AI for Video - AI提高视频分辨率

库#

#Android#

GlideImageView - 基于Glide V4.9.0封装的图片加载库，可以监听加载图片时的进度#Android

Highlight - 一个用于app指向性功能高亮的库#Android

LoadingDrawable - 加载动画#Android

android-process-button - 按钮库#Android

Android-ProgressBarWidthNumber - 滚动条#Android

JS#

Grade.js - 从图片中提取两种主色，并生成互补渐变背景

jsjs - 简易的 JavaScript 元循环解释器

树莓派#

BerryServer - 大量适用于树莓派BerryBoot的系统

qemu-rpi-kernel - 树莓派的QEMU模拟器内核

Debian Pi Aarch64 - 树莓派64位系统

|->1.0
|->2.0

其他#

Google Host - host

yiigo - 简单易用的轻量级 Golang 辅助库

.tmux - Tmux设置

Public APIs - 汇集了公开的API

Dash - 纯Python构建的Web框架，无js脚本

绅士

资源#

2019-11-24更新1条 2019-11-18更新1条 2019-11-8 更新1条 2019-11-2 更新3条 2019-8-26 更新5条网站 2019-5-26 更新 2020-2-21 更新

linux触摸板手势

Tue, 21 Aug 2018 00:00:00 GMT

0x00#

这里使用的是libinput-gestures，依赖xdotool（模拟鼠标/键盘输入)

Terminal window

1
sudo pacman -S libinput-gestures xdotool
2
sudo pacman -S libinput xf86-input-libinput

配置libinput文件（文件名字视情况而定，我的是40-libinput.conf）

Terminal window

1
sudo cp /usr/share/X11/xorg.conf.d/40-libinput.conf /etc/X11/xorg.conf.d/40-libinput.conf

下面是文件中touchpad部分的配置：

1
Section "InputClass"
2
        Identifier "touchpad"
3
        MatchIsTouchpad "on"
4
        MatchDevicePath "/dev/input/event*"
5
        Driver "libinput"
6
        Option "Tapping" "on"
7
        Option "ButtonMapping" "1 3 0 4 5 6 7"
8
        Option "TappingButtonMap" "lmr"
9
        Option "DisableWhileTyping" "on"
10
        Option "TappingDrag" "on"
11
EndSection

详细参数和解释见libinput man page: based on X.Org input dirver，解释下几个重要的配置参数：

Option “Tapping” “on”：手指点击touchpad发送鼠标点击事件 Option “TappingButtonMap” “lmr”：1个手指点击对应鼠标左键，2个手指点击对应鼠标中键，3个鼠标点击对应鼠标右键。 Option “ButtonMapping” “1 3 0 4 5 6 7″，按钮映射，详情见libinput#Button_Mapping，这里笔者关闭了3指对应的左键。 Option “DisableWhileTyping” “on”：打字时不检测touchpad事件，防止用户不小心触碰touchpad引起不必要的影响。 Option “TappingDrag” “on”：开启点击拖拽。

0x01#

添加当前用户到用户组

Terminal window

1
sudo gpasswd -a $USER input

复制文件

Terminal window

1
cp /etc/libinput-gestures.conf ~/.config/

编辑~/.config/libinput-gestures文件修改所需操作

1
gesture swipe left 4 xdotool key super+Left
2
# 4指左划: 切换到左侧工作区
3
gesture swipe right 4 xdotool key super+Right
4
# 4指右划: 切换到右侧工作区
5

6
gesture swipe left 3 xdotool key alt+Left
7
# 3指左划: 浏览器后退
8
gesture swipe right 3 xdotool key alt+Right
9
# 3指右划: 浏览器前进
10
gesture swipe up 3 xdotool key F5
11
# 3指上划: 刷新当前页面
12
gesture swipe down 3 xdotool key ctrl+w
13
# 3指下划: 关闭当前页面
14

15
gesture pinch in 2 xdotool key ctrl+minus
16
# 2指捏: 缩小
17
gesture pinch out 2 xdotool key ctrl+plus
18
# 2指张: 放大

展开收起

0x02#

启动

Terminal window

1
libinput-gestures-setup start

END

【vim】代码自动补全插件（YouCompleteMe）安装

Mon, 13 Aug 2018 00:00:00 GMT

0x00什么是YouCompleteMe

YouCompleteMe<一个随键而全的>、支持模糊搜索的、高速补全的插件。YCM 由 google 公司搜索项目组的软件工程师 Strahinja Val Markovic 所开发,YCM 后端调用 libclang(以获取AST,当然还有其他语言的语义分析库)、前端由 C++ 开发(以提升补全效率)、外层由 python 封装(以成为 vim 插件),它可能是我见过安装最复杂的 vim 插件了。

0x01安装

这里采用Vundle插件管理器安装

1.安装必要工具

sudo apt install build-essential cmake

sudo apt install python-dev python3-dev

2.配置vundle插件安装

打开编辑/usr/share/vim/vimrc文件，在其中添加Bundle ‘Valloric/YouCompleteMe’

退出文件并进入vim输入等待进度完成

3.安装YouCompleteMe

进入~/.vim/bundle/YouCompleteMe文件夹

./install.py —clang-completer

等待编译安装完即可

其他语言支持

C#：./install.py --cs-completer
Go：./install.py --go-completer
JavaScript 和 TypeScript：nmp install -gtypescript
Rust：./install.py --rust-completer
Java：./install.py --java-completer

如要安装所以支持可以使用--all参数：./install.py --all

0x02配置自动补全

打开.vimrc文件，添加配置：

1
" 自动补全配置
2
set completeopt=longest,menu  "让Vim的补全菜单行为与一般IDE一致(参考VimTip1228)
3
autocmd InsertLeave * if pumvisible() == 0|pclose|endif  "离开插入模式后自动关闭预览窗口
4
inoremap <expr> <cr>       pumvisible() ? "\<c-y>" : "\<cr>"  "回车即选中当前项
5
"上下左右键的行为 会显示其他信息
6
inoremap <expr> <down>     pumvisible() ? "\<c-n>" : "\<down>"
7
inoremap <expr> <up>       pumvisible() ? "\<c-p>" : "\<up>"
8
inoremap <expr> <pagedown> pumvisible() ? "\<pagedown>\<c-p>\<c-n>" : "\<pagedown>"
9
inoremap <expr> <pageup>   pumvisible() ? "\<pageup>\<c-p>\<c-n>" : "\<pageup>"
10

11
"youcompleteme  默认tab  s-tab 和自动补全冲突
12
"let g:ycm_key_list_select_completion=['<c-n>']
13
let g:ycm_key_list_select_completion = ['<down>']
14
"let g:ycm_key_list_previous_completion=['<c-p>']
15
let g:ycm_key_list_previous_completion = ['<up>']
16
let g:ycm_confirm_extra_conf=0 "关闭加载.ycm_extra_conf.py提示
17

18
let g:ycm_collect_identifiers_from_tags_files=1  " 开启 YCM 基于标签引擎
19
let g:ycm_min_num_of_chars_for_completion=2  " 从第2个键入字符就开始罗列匹配项
20
let g:ycm_cache_omnifunc=0  " 禁止缓存匹配项,每次都重新生成匹配项
21
let g:ycm_seed_identifiers_with_syntax=1  " 语法关键字补全
22
nnoremap <f5> :YcmForceCompileAndDiagnostics<cr>  "force recomile with syntastic
23
"nnoremap <leader>lo :lopen<cr>  "open locationlist
24
"nnoremap <leader>lc :lclose<cr>  "close locationlist
25
inoremap <leader><leader> <c-x><c-o>
26
"在注释输入中也能补全
27
let g:ycm_complete_in_comments = 1
28
"在字符串输入中也能补全
29
let g:ycm_complete_in_strings = 1
30
"注释和字符串中的文字也会被收入补全
31
let g:ycm_collect_identifiers_from_comments_and_strings = 0
32

33
nnoremap <leader>jd :YcmCompleter GoToDefinitionElseDeclaration<cr> " 跳转到定义处

展开收起

0x03后记

简单安装教程已完成，如需详情请访问作者GitHub

END

【vim】自动插件管理器（Vundle）安装

Sun, 12 Aug 2018 00:00:00 GMT

0x00什么是Vundle

Vundle意即Vim Bundle，是一个vim插件管理器。Vundle能让你很简单地实现插件的安装、升级、搜索或者清除。它还能管理你的运行环境并且在标签方面提供帮助。在本教程中我们将展示如何安装和使用Vundle。

0x01安装Vundle

这里使用git命令来下载文件，没有安装git的请自行安装

$ git clone https://github.com/VundleVim/Vundle.vim.git ~/.vim/bundle/Vundle.vim

编辑.vimrc文件，建议将原文件备份并另建一个新文件。

1
set nocompatible              " 必需。
2
filetype off                  " 必须。
3

4
" 在这里设置你的运行时环境的路径。
5
set rtp+=~/.vim/bundle/Vundle.vim
6
" 初始化vundle
7
call vundle#begin()
8

9
" 这一行应该永远放在开头。
10
Plugin 'gmarik/Vundle.vim'
11
" 这个示范来自https://github.com/gmarik/Vundle.vim README
12
Plugin 'tpope/vim-fugitive'
13

14
" 取自http://vim-scripts.org/vim/scripts.html的插件
15
Plugin 'L9'
16
"　该Git插件没有放在GitHub上。
17
Plugin 'git://git.wincent.com/command-t.git'
18

19
"本地计算机上的Git仓库路径　（例如，当你在开发你自己的插件时）
20
Plugin 'file:///home/gmarik/path/to/plugin'
21
" vim脚本sparkup存放在这个名叫vim的仓库下的一个子目录中。
22
" 将这个路径正确地设置为runtimepath。
23
Plugin 'rstacruz/sparkup', {'rtp': 'vim/'}
24
"　避免与L9发生名字上的冲突
25
Plugin 'user/L9', {'name': 'newL9'}
26

27
"所有的插件都应该在这一行之前。
28
call vundle#end()            " 必需。

展开收起

上文解释：

要从github安装插件：Plugin 'user/plugin'
要从特定网址安装：Plugin 'plugin_name'
要从一个git库安装：Plugin 'git://url.git'
从本地安装：Plugin 'file:///path'

你同样可以定制其它东西，例如你的插件的运行时路径，当你自己在编写一个插件时，或者你只是想从其它目录——而不是~/.vim——中加载插件时，这样做就非常有用。 Plugin 'rstacruz/sparkup', {'rtp' :'another_vim_path/'} 如果你有同名的插件，你可以重命名你的插件，这样它们就不会发生冲突了。 Plugin 'user/plugin', {'name': 'newPlugin'}

0x02Vundle相关命令

进入vim

1.安装新插件

输入安装配置文件中的插件

输入 <插件名>通过插件名安装指定插件

2.清除插件

删除配置文件中插件再运行来删除

3.查看插件列表

END

树莓派通过USB方式与计算机连接（Win10）

Wed, 25 Jul 2018 00:00:00 GMT

0x01#

刷入树莓派官方系统raspbian

0x02#

打开boot文件夹，找到 config.txt文件并在最后添加dtoverlay=dwc2

找到cmdline.txt文件，找到 rootwait并在后面添加modules-load=dwc2,g_ether

0x03#

树莓派通过usb连接电脑，过一会儿电脑会提示有新的设备。（第一次可能会识别为COM设备，在设备管理器更新驱动即可）

0x04#

打开ssh连接工具，输入地址raspberrypi.local即可（若提示找不到地址就安装Bonjour（基于mDNS，它允许你的电脑自动识别 USB/以太网设备， iTunes 与 Adobe CS 包含该软件，也可独立安装），最新版windows 10（我的是1809）已经内置mDNS功能不需要额外安装）

0x05（可选）#

更改hostname

修改/etc/hosts与/etc/hostname中的raspberry即可

连接地址就变为更改后的hostname.local

【python】查看Linux实时网速

Sun, 15 Jul 2018 00:00:00 GMT

1
import time
2

3
speed_down=[]
4
speed_up=[]
5
speed_name=[]
6

7
speed_up_1=[]
8
speed_down_1=[]
9

10
while True:
11
    i=open('/proc/net/dev','r').readlines()
12
    for p in i:
13
        p=p.split( )
14
        if p[1].isdigit() and p[1]!='0':
15
            index=0
16
            for i in range(len(speed_name)):
17
                if p[0]==speed_name[i]:
18
                    index=i
19
                    break
20
            if p[0] in speed_name:
21
                pass
22
            else:
23
                speed_name.append(p[0])
24
                speed_down_1.append(p[1])
25
                speed_up_1.append(p[9])
26
                speed_down.append(0)
27
                speed_up.append(0)
28
                break
29
            speed_down[index]=(float)((int)(p[1])-(int)(speed_down_1[index]))/1000
30
            speed_up[index]=(float)((int)(p[9])-(int)(speed_up_1[index]))/1000
31
            speed_down_1[index]=p[1]
32
            speed_up_1[index]=p[9]
33
    for i in range(len(speed_name)):
34
        print("网卡："+speed_name[i])
35
        print("上行："+speed_up[i])
36
        print("下行："+speed_down[i])
37
    time.sleep(1)

展开收起

【树莓派】使用温度湿度传感器DHT系列

Sun, 15 Jul 2018 00:00:00 GMT

Note

2019-10-24更新

新版本的raspbian内核包括一些传感器,在/boot/overlays/README里有相关说明,以DHT11为例: 在/boot/config最后一行添加

1
dtoverlay=dht11,gpiopin=4

重启. gpiopin为读取数据的引脚,可自行更改,引脚号码为BCM编码. 读取数据直接读取/dev/dht11即可

Warning

2018-7-15

驱动：https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code

具体：

Terminal window

1
git clone https://github.com/adafruit/Adafruit_Python_DHT.git
2
cd Adafruit_Python_DHT
3
sudo python3 setup.py install

使用：

1
import Adafruit_DHT
2
sensor = Adafruit_DHT.DHT11     #DHT22型号的传感器就填Adafruit_DHT.DHT22
3
humidity, temperature = Adafruit_DHT.read_retry(sensor, 26)    #26 是 GPIO 的引脚编号
4
print (humidity)
5
print (temperature)

LCD显示系统信息脚本

Sun, 15 Jul 2018 00:00:00 GMT

包括,系统运行时间,网卡名称,上下行网速

1
from PCD8544 import PCD8544 as lcd
2
import time
3
import os
4
import threading
5

6
cpu_info=""
7
time_info=""
8

9
speed_down=[]
10
speed_up=[]
11
speed_name=[]
12

13
# 显示cpu温度
14
def cpu_t():
15
    global cpu_info
16
    while(True):
17
        info=open('/sys/class/thermal/thermal_zone0/temp','r').read()
18
        info=(int)(info)/1000
19
        info=(str)(info)+'C'
20
        cpu_info=info
21
        time.sleep(1)
22

23
# 显示开机运行时间
24
def time_local():
25
    global time_info
26
    while(True):
27
        info=os.popen('cat /proc/uptime| awk -F. \'{run_days=$1 / 86400;run_hour=($1 % 86400)/3600;run_minute=($1 % 3600)/60;run_second=$1 % 60;printf(\"%dD %d:%d:%d\",run_days,run_hour,run_minute,run_second)}\'')
28
        info=info.read()
29
        time_info=info
30
        time.sleep(1)
31

32
# 显示网卡速度
33
def net_speed():
34
    global speed_name
35
    global speed_down
36
    global speed_up
37

38
    speed_down_1={}
39
    speed_up_1={}
40

41
    speed_net_time={}       #记录各网卡有网速的时间
42

43
    while True:
44
        info=open('/proc/net/dev','r').readlines()
45
        for p in info:
46
            p=p.split( )
47
            if p[1].isdigit() and p[1] != 0:
48
                index = 0
49
                if p[0] in speed_name:
50
                    index = speed_name.index(p[0])
51

52
                    #若10秒后网速仍然为0就取消显示该网卡速度
53
                    if (int)(time.time()) - speed_net_time.get(p[0],0) > 10 and speed_down_1.get(p[0]) == p[1] and speed_up_1.get(p[0]) == p[9]:
54
                        del speed_name[index]
55
                        del speed_down[index]
56
                        del speed_up[index]
57
                        speed_net_time[p[0]] = (int)(time.time())
58
                    else:
59
                        speed_down[index]=(float)((int)(p[1])-(int)(speed_down_1.get(p[0])))/1000
60
                        speed_up[index]=(float)((int)(p[9])-(int)(speed_up_1.get(p[0])))/1000
61
                        if speed_down[index] != 0 and speed_up[index] != 0:
62
                            speed_net_time[p[0]] = (int)(time.time())
63
                    speed_down_1[p[0]]=p[1]
64
                    speed_up_1[p[0]]=p[9]
65
                else:
66
                    if speed_down_1.get(p[0],0) != p[1] and speed_up_1.get(p[0],0) != p[9]:
67
                        speed_name.append(p[0])
68
                        speed_down.append(0)
69
                        speed_up.append(0)
70
                        speed_down_1[p[0]] = p[1]
71
                        speed_up_1[p[0]] = p[9]
72
                    continue
73
        time.sleep(1)
74

75

76

77
def main():
78
    a = lcd(dc=13, rst=5, sclk=26, din=19, cs=6, vcc=20, bl=21, bk=0)
79
    a.begin(contrast=60)        #屏幕对比度
80

81
    #各任务使用多线程运行
82
    tmp=threading.Thread(target=time_local)
83
    tmp.setDaemon(True)
84
    tmp.start()
85
    tmp=threading.Thread(target=cpu_t)
86
    tmp.setDaemon(True)
87
    tmp.start()
88
    tmp=threading.Thread(target=net_speed)
89
    tmp.setDaemon(True)
90
    tmp.start()
91

92
    t1=(int)(time.time())
93
    index=0
94
    while(True):
95
        try:
96
            t2=(int)(time.time())
97
            a.clear()
98
            a.draw_str(0,'CPU: '+cpu_info)
99
            a.draw_str(1,time_info)
100
            try:
101
                # 网卡显示，10秒切换网卡信息
102
                if t2-t1>10:
103
                    t1=t2
104
                    if index < len(speed_name)-1:
105
                        index=index+1
106
                    else:
107
                        index=0
108
                a.draw_str(2,speed_name[index]+" ("+(str)(index+1)+"/"+(str)(len(speed_name))+")")
109
                a.draw_str(3,"D: "+(str)(speed_down[index])+"k/s")
110
                a.draw_str(4,"U: "+(str)(speed_up[index])+"k/s")
111
            except Exception as e:
112
                pass
113
            a.display()
114
            time.sleep(1)
115
        except KeyboardInterrupt:
116
            a.quit()
117
            exit(0)
118

119
if __name__ == '__main__':
120
    main()

展开收起

【树莓派】使用Nokia5110显示信息

Sat, 14 Jul 2018 00:00:00 GMT

接线：

1
dc 13
2
rst 5
3
sclk 26
4
din 19
5
cs 6
6
bl 21

需要的python库Adafruit_GPIO

屏幕显示驱动：

1
# coding:utf-8
2
import time
3
import Adafruit_GPIO as GPIO
4
import Adafruit_GPIO.SPI as SPI
5

6
LCDWIDTH = 84
7
LCDHEIGHT = 48
8
ROWPIXELS = LCDHEIGHT//6
9
PCD8544_POWERDOWN = 0x04
10
PCD8544_ENTRYMODE = 0x02
11
PCD8544_EXTENDEDINSTRUCTION = 0x01
12
PCD8544_DISPLAYBLANK = 0x0
13
PCD8544_DISPLAYNORMAL = 0x4
14
PCD8544_DISPLAYALLON = 0x1
15
PCD8544_DISPLAYINVERTED = 0x5
16
PCD8544_FUNCTIONSET = 0x20
17
PCD8544_DISPLAYCONTROL = 0x08
18
PCD8544_SETYADDR = 0x40
19
PCD8544_SETXADDR = 0x80
20
PCD8544_SETTEMP = 0x04
21
PCD8544_SETBIAS = 0x10
22
PCD8544_SETVOP = 0x80
23
FONT = {
24
  ' ': [0x00, 0x00, 0x00, 0x00, 0x00],
25
  '!': [0x00, 0x00, 0x5f, 0x00, 0x00],
26
  '"': [0x00, 0x07, 0x00, 0x07, 0x00],
27
  '#': [0x14, 0x7f, 0x14, 0x7f, 0x14],
28
  '$': [0x24, 0x2a, 0x7f, 0x2a, 0x12],
29
  '%': [0x23, 0x13, 0x08, 0x64, 0x62],
30
  '&': [0x36, 0x49, 0x55, 0x22, 0x50],
31
  "'": [0x00, 0x05, 0x03, 0x00, 0x00],
32
  '(': [0x00, 0x1c, 0x22, 0x41, 0x00],
33
  ')': [0x00, 0x41, 0x22, 0x1c, 0x00],
34
  '*': [0x14, 0x08, 0x3e, 0x08, 0x14],
35
  '+': [0x08, 0x08, 0x3e, 0x08, 0x08],
36
  ',': [0x00, 0x50, 0x30, 0x00, 0x00],
37
  '-': [0x08, 0x08, 0x08, 0x08, 0x08],
38
  '.': [0x00, 0x60, 0x60, 0x00, 0x00],
39
  '/': [0x20, 0x10, 0x08, 0x04, 0x02],
40
  '0': [0x3e, 0x51, 0x49, 0x45, 0x3e],
41
  '1': [0x00, 0x42, 0x7f, 0x40, 0x00],
42
  '2': [0x42, 0x61, 0x51, 0x49, 0x46],
43
  '3': [0x21, 0x41, 0x45, 0x4b, 0x31],
44
  '4': [0x18, 0x14, 0x12, 0x7f, 0x10],
45
  '5': [0x27, 0x45, 0x45, 0x45, 0x39],
46
  '6': [0x3c, 0x4a, 0x49, 0x49, 0x30],
47
  '7': [0x01, 0x71, 0x09, 0x05, 0x03],
48
  '8': [0x36, 0x49, 0x49, 0x49, 0x36],
49
  '9': [0x06, 0x49, 0x49, 0x29, 0x1e],
50
  ':': [0x00, 0x36, 0x36, 0x00, 0x00],
51
  ';': [0x00, 0x56, 0x36, 0x00, 0x00],
52
  '<': [0x08, 0x14, 0x22, 0x41, 0x00], '=': [0x14, 0x14, 0x14, 0x14, 0x14], '>': [0x00, 0x41, 0x22, 0x14, 0x08],
53
  '?': [0x02, 0x01, 0x51, 0x09, 0x06],
54
  '@': [0x32, 0x49, 0x79, 0x41, 0x3e],
55
  'A': [0x7e, 0x11, 0x11, 0x11, 0x7e],
56
  'B': [0x7f, 0x49, 0x49, 0x49, 0x36],
57
  'C': [0x3e, 0x41, 0x41, 0x41, 0x22],
58
  'D': [0x7f, 0x41, 0x41, 0x22, 0x1c],
59
  'E': [0x7f, 0x49, 0x49, 0x49, 0x41],
60
  'F': [0x7f, 0x09, 0x09, 0x09, 0x01],
61
  'G': [0x3e, 0x41, 0x49, 0x49, 0x7a],
62
  'H': [0x7f, 0x08, 0x08, 0x08, 0x7f],
63
  'I': [0x00, 0x41, 0x7f, 0x41, 0x00],
64
  'J': [0x20, 0x40, 0x41, 0x3f, 0x01],
65
  'K': [0x7f, 0x08, 0x14, 0x22, 0x41],
66
  'L': [0x7f, 0x40, 0x40, 0x40, 0x40],
67
  'M': [0x7f, 0x02, 0x0c, 0x02, 0x7f],
68
  'N': [0x7f, 0x04, 0x08, 0x10, 0x7f],
69
  'O': [0x3e, 0x41, 0x41, 0x41, 0x3e],
70
  'P': [0x7f, 0x09, 0x09, 0x09, 0x06],
71
  'Q': [0x3e, 0x41, 0x51, 0x21, 0x5e],
72
  'R': [0x7f, 0x09, 0x19, 0x29, 0x46],
73
  'S': [0x46, 0x49, 0x49, 0x49, 0x31],
74
  'T': [0x01, 0x01, 0x7f, 0x01, 0x01],
75
  'U': [0x3f, 0x40, 0x40, 0x40, 0x3f],
76
  'V': [0x1f, 0x20, 0x40, 0x20, 0x1f],
77
  'W': [0x3f, 0x40, 0x38, 0x40, 0x3f],
78
  'X': [0x63, 0x14, 0x08, 0x14, 0x63],
79
  'Y': [0x07, 0x08, 0x70, 0x08, 0x07],
80
  'Z': [0x61, 0x51, 0x49, 0x45, 0x43],
81
  '[': [0x00, 0x7f, 0x41, 0x41, 0x00],
82
  '\\': [0x02, 0x04, 0x08, 0x10, 0x20],
83
  ']': [0x00, 0x41, 0x41, 0x7f, 0x00],
84
  '^': [0x04, 0x02, 0x01, 0x02, 0x04],
85
  '_': [0x40, 0x40, 0x40, 0x40, 0x40],
86
  '`': [0x00, 0x01, 0x02, 0x04, 0x00],
87
  'a': [0x20, 0x54, 0x54, 0x54, 0x78],
88
  'b': [0x7f, 0x48, 0x44, 0x44, 0x38],
89
  'c': [0x38, 0x44, 0x44, 0x44, 0x20],
90
  'd': [0x38, 0x44, 0x44, 0x48, 0x7f],
91
  'e': [0x38, 0x54, 0x54, 0x54, 0x18],
92
  'f': [0x08, 0x7e, 0x09, 0x01, 0x02],
93
  'g': [0x0c, 0x52, 0x52, 0x52, 0x3e],
94
  'h': [0x7f, 0x08, 0x04, 0x04, 0x78],
95
  'i': [0x00, 0x44, 0x7d, 0x40, 0x00],
96
  'j': [0x20, 0x40, 0x44, 0x3d, 0x00],
97
  'k': [0x7f, 0x10, 0x28, 0x44, 0x00],
98
  'l': [0x00, 0x41, 0x7f, 0x40, 0x00],
99
  'm': [0x7c, 0x04, 0x18, 0x04, 0x78],
100
  'n': [0x7c, 0x08, 0x04, 0x04, 0x78],
101
  'o': [0x38, 0x44, 0x44, 0x44, 0x38],
102
  'p': [0x7c, 0x14, 0x14, 0x14, 0x08],
103
  'q': [0x08, 0x14, 0x14, 0x18, 0x7c],
104
  'r': [0x7c, 0x08, 0x04, 0x04, 0x08],
105
  's': [0x48, 0x54, 0x54, 0x54, 0x20],
106
  't': [0x04, 0x3f, 0x44, 0x40, 0x20],
107
  'u': [0x3c, 0x40, 0x40, 0x20, 0x7c],
108
  'v': [0x1c, 0x20, 0x40, 0x20, 0x1c],
109
  'w': [0x3c, 0x40, 0x30, 0x40, 0x3c],
110
  'x': [0x44, 0x28, 0x10, 0x28, 0x44],
111
  'y': [0x0c, 0x50, 0x50, 0x50, 0x3c],
112
  'z': [0x44, 0x64, 0x54, 0x4c, 0x44],
113
  '{': [0x00, 0x08, 0x36, 0x41, 0x00],
114
  '|': [0x00, 0x00, 0x7f, 0x00, 0x00],
115
  '}': [0x00, 0x41, 0x36, 0x08, 0x00],
116
  '~': [0x10, 0x08, 0x08, 0x10, 0x08],
117
  '\x7f': [0x00, 0x7e, 0x42, 0x42, 0x7e],
118
}
119
X = 13
120
Y = 5
121

122
class PCD8544(object):
123
    """Nokia 5110/3310 PCD8544-based LCD display."""
124

125
    def __init__(self,bk, dc, rst, sclk=None, din=None, cs=None, gpio=None, spi=None, vcc=None, bl=None):
126
        self._sclk = sclk
127
        self._din = din
128
        self._dc = dc
129
        self._cs = cs
130
        self._rst = rst
131
        self._gpio = gpio
132
        self._spi = spi
133
        self._buffer = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFC, 0xFE, 0xFF, 0xFC, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF0, 0xF0, 0xE0, 0xE0, 0xC0, 0x80, 0xC0, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x3F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE7, 0xC7, 0xC7, 0x87, 0x8F, 0x9F, 0x9F, 0xFF, 0xFF, 0xFF, 0xC1, 0xC0, 0xE0, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFC, 0xFC, 0xFC, 0xFE, 0xFE, 0xFE, 0xFC, 0xFC, 0xF8, 0xF8, 0xF0, 0xE0, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF1, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x1F, 0x0F, 0x0F, 0x87, 0xE7, 0xFF, 0xFF, 0xFF, 0x1F, 0x1F, 0x3F, 0xF9, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x3F, 0x0F, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x7E, 0x3F, 0x3F, 0x0F, 0x1F, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0xE0, 0xF1, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0F, 0x1F, 0x3F, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x7F, 0x1F, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]
134
        if self._gpio is None:
135
            self._gpio = GPIO.get_platform_gpio()
136
            self._gpio.setup(vcc, GPIO.OUT)
137
            self._gpio.setup(bl, GPIO.OUT)
138
            self._gpio.output(vcc, 1)
139
            if bk ==0:
140
                self._gpio.output(bl, 0)
141
            else:
142
                self._gpio.output(bl, 1)
143
        if self._rst is not None:
144
            self._gpio.setup(self._rst, GPIO.OUT)
145
        # Default to bit bang SPI.
146
        if self._spi is None:
147
            self._spi = SPI.BitBang(self._gpio, self._sclk, self._din, None, self._cs)
148
        # Set pin outputs.
149
        self._gpio.setup(self._dc, GPIO.OUT)
150
        # Initialize buffer to Adafruit logo.
151

152
    def command(self, c):
153
        """Send command byte to display."""
154
        # DC pin low signals command byte.
155
        self._gpio.set_low(self._dc)
156
        self._spi.write([c])
157

158
    def extended_command(self, c):
159
        """Send a command in extended mode"""
160
        # Set extended command mode
161
        self.command(PCD8544_FUNCTIONSET | PCD8544_EXTENDEDINSTRUCTION)
162
        self.command(c)
163
        # Set normal display mode.
164
        self.command(PCD8544_FUNCTIONSET)
165
        self.command(PCD8544_DISPLAYCONTROL | PCD8544_DISPLAYNORMAL)
166

167
    def begin(self, contrast=40, bias=4):
168
        """Initialize display."""
169
        self.reset()
170
        # Set LCD bias.
171
        self.set_bias(bias)
172
        self.set_contrast(contrast)
173

174
    def reset(self):
175
        """Reset the display"""
176
        if self._rst is not None:
177
            # Toggle RST low to reset.
178
            self._gpio.set_low(self._rst)
179
            time.sleep(0.1)
180
            self._gpio.set_high(self._rst)
181

182
    def display(self):
183
        """Write display buffer to physical display."""
184
        # TODO: Consider support for partial updates like Arduino library.
185
        # Reset to position zero.
186
        self.command(PCD8544_SETYADDR)
187
        self.command(PCD8544_SETXADDR)
188
        # Write the buffer.
189
        self._gpio.set_high(self._dc)
190
        self._spi.write(self._buffer)
191

192
    def clear(self):
193
        """Clear contents of image buffer."""
194
        self._buffer = [0] * (LCDWIDTH * LCDHEIGHT // 8)
195

196
    def set_contrast(self, contrast):
197
        """Set contrast to specified value (should be 0-127)."""
198
        contrast = max(0, min(contrast, 0x7f)) # Clamp to values 0-0x7f
199
        self.extended_command(PCD8544_SETVOP | contrast)
200

201
    def set_bias(self, bias):
202
        """Set bias"""
203
        self.extended_command(PCD8544_SETBIAS | bias)
204

205
    def draw_str(self, y, s):
206
        """修改显示数据，y 为第几行，s 为要显示的数据"""
207
        if (y >= Y ) or (y < 0):
208
            return False
209
        x = 0
210
        for c in s[0:14]:
211
            try:
212
                self._buffer[y*84+x*6: y*84+x*6 + 6] = FONT[c] + [0]
213
            except KeyError:
214
                pass
215
            x += 1
216

217
    def draw_char(self, x, y):
218
        pass
219

220
    def quit(self):
221
        self._gpio.cleanup()

展开收起

使用方法：

1
from PCD8544 import PCD8544 as lcd
2

3
a = lcd(dc=13, rst=5, sclk=26, din=19, cs=6, vcc=20, bl=21, bk=1)       //bk为0时关闭背景灯
4
a.begin(contrast=60)
5
a.draw_str(0,"hello")
6
a.draw_str(1,"hi")                //最多5行
7
a.display()                       //显示
8
a.clear()                         每次显示新的前要清除旧的

OkHttp封装

Thu, 21 Jun 2018 00:00:00 GMT

1
/**
2
 * Okhttp封装
3
 */
4
public class OkhttpNet {
5
    private static OkHttpClient client = null;
6

7
    private OkhttpNet() {
8
    }
9

10
    public static OkHttpClient getInstance() {
11
        if (client == null) {
12
            synchronized (OkhttpNet.class) {
13
                if (client == null)
14
                    client = new OkHttpClient();
15
            }
16
        }
17
        return client;
18
    }
19

20
    /**
21
     * Get请求
22
     *
23
     * @param url
24
     * @param callback
25
     */
26
    public static void doGet(String url, Callback callback) {
27
        Request request = new Request.Builder()
28
                .url(url)
29
                .build();
30
        Call call = getInstance().newCall(request);
31
        call.enqueue(callback);
32
    }
33

34
    /**
35
     * Post请求发送键值对数据
36
     *
37
     * @param url
38
     * @param mapParams
39
     * @param callback
40
     */
41
    public static void doPost(String url, Map mapParams, Callback callback) {
42
        FormBody.Builder builder = new FormBody.Builder();
43
        for (String key : mapParams.keySet()) {
44
            builder.add(key, mapParams.get(key));
45
        }
46
        Request request = new Request.Builder()
47
                .url(url)
48
                .post(builder.build())
49
                .build();
50
        Call call = getInstance().newCall(request);
51
        call.enqueue(callback);
52
    }
53

54

55
    /**
56
     * Post请求发送JSON数据
57
     *
58
     * @param url
59
     * @param jsonParams
60
     * @param callback
61
     */
62
    public static void doPost(String url, String jsonParams, Callback callback) {
63
        RequestBody body = RequestBody.create(MediaType.parse("application/json; charset=utf-8")
64
                , jsonParams);
65
        Request request = new Request.Builder()
66
                .url(url)
67
                .post(body)
68
                .build();
69
        Call call = getInstance().newCall(request);
70
        call.enqueue(callback);
71
    }
72

73

74
    /**
75
     * 上传文件
76
     *
77
     * @param url
78
     * @param callback
79
     * @param map           上传文件，map值：file///文件路径
80
     */
81
    public static void doFile(String url, Map map, Callback callback) {
82

83
        //创建文件参数
84
        MultipartBody.Builder builder = new MultipartBody.Builder()
85
                .setType(MultipartBody.FORM);
86
        if (map != null) {
87
            for (String key : map.keySet()) {
88

89
                Pattern pattern = Pattern.compile("^file///");
90
                    Matcher matcher = pattern.matcher(map.get(key));
91
                    //判断是否是要上传文件
92
                    if (matcher.find()) {
93
                        String[] path = map.get(key).split("file///");
94
                        String filePath = path[1];
95
                        String[] fileName = filePath.split("/");
96
                        //判断文件类型
97
                        MediaType MEDIA_TYPE = MediaType.parse(judgeType(filePath));
98
                        builder.addFormDataPart(key, fileName[fileName.length - 1],
99
                                RequestBody.create(MEDIA_TYPE, new File(filePath)));
100
                } else {
101
                    builder.addFormDataPart(key, map.get(key));
102
                }
103
            }
104
        }
105

106
        //发出请求参数
107
        Request request = new Request.Builder()
108
//                .header("Authorization", "Client-ID " + "9199fdef135c122")
109
                .url(url)
110
                .post(builder.build())
111
                .build();
112
        Call call = getInstance().newCall(request);
113
        call.enqueue(callback);
114
    }
115

116
    /**
117
     * 根据文件路径判断MediaType
118
     *
119
     * @param path
120
     * @return
121
     */
122
    private static String judgeType(String path) {
123
        FileNameMap fileNameMap = URLConnection.getFileNameMap();
124
        String contentTypeFor = fileNameMap.getContentTypeFor(path);
125
        if (contentTypeFor == null) {
126
            contentTypeFor = "application/octet-stream";
127
        }
128
        return contentTypeFor;
129
    }
130

131

132
    /**
133
     * 下载文件
134
     *
135
     * @param url
136
     * @param fileDir
137
     * @param fileName
138
     */
139
    public static void downFile(String url, final String fileDir, final String fileName) {
140
        Request request = new Request.Builder()
141
                .url(url)
142
                .build();
143
        Call call = getInstance().newCall(request);
144
        call.enqueue(new Callback() {
145
            @Override
146
            public void onFailure(Call call, IOException e) {
147

148
            }
149

150
            @Override
151
            public void onResponse(Call call, Response response) throws IOException {
152
                InputStream is = null;
153
                byte[] buf = new byte[2048];
154
                int len = 0;
155
                FileOutputStream fos = null;
156
                try {
157
                    is = response.body().byteStream();
158
                    File file = new File(fileDir, fileName);
159
                    fos = new FileOutputStream(file);
160
                    while ((len = is.read(buf)) != -1) {
161
                        fos.write(buf, 0, len);
162
                    }
163
                    fos.flush();
164
                } catch (IOException e) {
165
                    e.printStackTrace();
166
                } finally {
167
                    if (is != null) is.close();
168
                    if (fos != null) fos.close();
169
                }
170
            }
171
            //获取进度条
172
//            @Override
173
//            public void onResponse(Call call, Response response) throws IOException {
174
//                InputStream is = null;
175
//                byte[] buf = new byte[2048];
176
//                int len = 0;
177
//                FileOutputStream fos = null;
178
//                try {
179
//                    is = response.body().byteStream();
180
//                    File file = new File(fileDir, fileName);
181
//                    fos = new FileOutputStream(file);
182
//                    //---增加的代码---
183
//                    //计算进度
184
//                    long totalSize = response.body().contentLength();
185
//                    long sum = 0;
186
//                    while ((len = is.read(buf)) != -1) {
187
//                        sum += len;
188
//                        //progress就是进度值
189
//                        int progress = (int) (sum * 1.0f/totalSize * 100);
190
//                        //---增加的代码---
191
//                        fos.write(buf, 0, len);
192
//                    }
193
//                    fos.flush();
194
//                } catch (IOException e) {
195
//                    e.printStackTrace();
196
//                } finally {
197
//                    if (is != null) is.close();
198
//                    if (fos != null) fos.close();
199
//                }
200
//            }
201
        });
202
    }
203
}

展开收起

Android Dialog回传

Thu, 21 Jun 2018 00:00:00 GMT

1
MyDialog.java
2

3
//定义一个接口
4
public interface chuang{
5
        public void chuang(String string);
6
    }
7
    chuang chuang;
8

9
public MyDialog(@NonNull Context context,chuang chuang) {
10
    super(context);
11
    this.chuang=chuang;
12
    }
13

14
public void test(){
15
    chuang.chuang("asd");
16
 }

展开收起

1
MainActivity.java
2

3
...
4
new MyDialog(this, new MyDialog.chuang() {
5
            @Override
6
            public void chuang(String string) {
7
                Log.i("chuang",string);
8
            }
9
        }).show();
10
...

Linux下对设备进行压力测试

Thu, 21 Jun 2018 00:00:00 GMT

0x00

使用sysbench进行测试

安装：apt install sysbench

0x01一般语法

prepare<用于文件io和数据库oltp测试的数据准备阶段>。

run<性能测试阶段>

cleanup<移除测试过程中产生的数据>

help<显示帮助信息>，获取—test帮助可以使用—test=name —help

主要参数

—num-threads

—max-requests

—test

以下几个参数也经常会使用：

—max-time 最大的测试时长

—debug(开启debug可以显示更详细的每个线程的执行情况)

0x02测试

cpu测试

对CPU的性能测试通常有：1. 通过算质数；2计算圆周率等；sysbench使用的就是通过质数相加的测试。对CPU测试直接运行run即可

Terminal window

1
sysbench --num-threads=12 --max-requests=10000 --debug=on --test=cpu --cpu-max-prime=20000 run

上面的测试是：12个线程执行1万条请求，每个请求执行质数相加到20000

线程测试

测试线程调度的性能，用于高负载下的线程性能测试。

—thread-yields=N 每个请求执行“lock/yield/unlock”循环的次数，默认1000

—thread-locks=N 每个线程的互斥锁，默认8个

Terminal window

1
./sysbench --num-threads=12 --max-requests=10000  --test=threads --thread-yields=100 --thread-locks=2 run

内存测试

内存分配测试，主要是针对不同的块大小进行内存的连续读写或者随机读写测试。

1.8k顺序分配

Terminal window

1
./sysbench --num-threads=12 --max-requests=10000 --test=memory --memory-block-size=8K --memory-total-size=100G --memory-access-mode=seq run

2.8k随机分配

Terminal window

1
./sysbench --num-threads=12 --max-requests=10000 --test=memory --memory-block-size=8K --memory-total-size=100G --memory-access-mode=rnd run

3.16K顺序分配

Terminal window

1
./sysbench --num-threads=12 --max-requests=10000 --test=memory --memory-block-size=16K --memory-total-size=100G --memory-access-mode=seq run

4.16K随机分配

Terminal window

1
./sysbench --num-threads=12 --max-requests=10000 --test=memory --memory-block-size=16K --memory-total-size=100G --memory-access-mode=rnd run

总结：对于分配同样大小的内存，块月大分配的速率越快，随机分配比顺序分配的速度要快

文件IO测试

文件IO的测试主要用于测试IO的负载性能。主要的测试选项为—file-test-mode。还有几个可以关注的参数包括—file-block-size、—file-io-mode、—file-fsync-freq 、—file-rw-ratio

1
--file-num=N                   创建测试文件的数量,默认128个
2
  --file-block-size=N          block size大小,默认16K
3
  --file-total-size=SIZE       所有文件的总大小，默认2G
4
  --file-test-mode=STRING      测试类型 {seqwr(顺序写), seqrewr(顺序读写), seqrd(顺序读), rndrd(随机读), rndwr(随机写), rndrw(随机读写)}
5
  --file-io-mode=STRING         I/O模式,需要系统支持默认sync[sync(同步IO),async(异步IO),mmap()]
6
  --file-async-backlog=N        每个线程的异步操作队列数，默认128个，需要--file-io-mode=async;
7
  --file-extra-flags=STRING     additional flags to use on opening files {sync,dsync,direct} []
8
  --file-fsync-freq=N           当请求数达到多少时执行fsync()刷新,默认100,0代表过程中不执行fsync()
9
  --file-fsync-all=[on|off]     执行每一个写操作后执行fsync()刷新操作,默认关闭off
10
  --file-fsync-end=[on|off]     测试结束执行fsync()操作,默认开启on
11
  --file-fsync-mode=STRING      同步刷新方法,默认fsync {fsync, fdatasync}
12
  --file-merged-requests=N      合并指定数量的IO请求,0代表不合并,默认0
13
  --file-rw-ratio=N            读写比例，默认1.5/1

Terminal window

1
./sysbench --num-threads=12 --max-requests=10000  --test=fileio --file-total-size=3G --file-test-mode=rndrw prepare
2
./sysbench --num-threads=12 --max-requests=10000  --test=fileio --file-total-size=3G --file-test-mode=rndrw run
3
./sysbench --num-threads=12 --max-requests=10000  --test=fileio --file-total-size=3G --file-test-mode=rndrw clean

注意：如果要对比两台服务器的io性能，需要跑相同的线程。

互斥锁测试

互斥锁测试模拟所有线程在同一时刻并发运行

Terminal window

1
./sysbench  --num-threads=12  --test=mutex --mutex-num=1024 --mutex-locks=10000 --mutex-loops=10000 run

oltp测试

oltp是针对数据库的基准测试，例如每次对数据库进行优化后执行基准测试来测试不同的配置的tps。

1
--oltp-test-mode=STRING                    测试类型：simple(简单select测试),complex(事务测试),nontrx(非事务测试),sp(存储过程) ；默认complex
2
  --oltp-reconnect-mode=STRING             连接类型：session(每个线程到测试结束不重新连接),transaction(执行每个事务重新连接),query(每一个查询重新连接),random(随机)；默认 [session]
3
  --oltp-sp-name=STRING                    指定执行测试的存储过程名
4
  --oltp-read-only=[on|off]                仅执行select测试，默认关闭
5
  --oltp-avoid-deadlocks=[on|off]          更新过程中忽略死锁，默认[off]
6
  --oltp-skip-trx=[on|off]                 语句以bigin/commit开始结尾，默认[off]
7
  --oltp-range-size=N                      范围查询的范围大小，默认 [100]，例如begin 100 and 200
8
  --oltp-point-selects=N                   单个事务中select查询的数量，默认 [10]
9
  --oltp-use-in-statement=N                每个查询中主键查找(in 10个值)的数量，默认 [0]
10
  --oltp-simple-ranges=N                   单个事务中执行范围查询的数量(SELECT c  FROM sbtest WHERE id BETWEEN  N AND  M)，默认[1]
11
  --oltp-sum-ranges=N                      单个事务中执行范围sum查询的数量，默认 [1]
12
  --oltp-order-ranges=N                    单个事务中执行范围order by查询的数量，默认[1]
13
  --oltp-distinct-ranges=N                 单个事务中执行范围distinct查询的数量，默认[1]
14
  --oltp-index-updates=N                   单个事务中执行索引更新的操作的数量，默认[1]
15
  --oltp-non-index-updates=N               单个事务中执行非索引更新操作的数量，默认[1]
16
  --oltp-nontrx-mode=STRING                指定单独非事务测试类型进行测试，默认select {select, update_key, update_nokey, insert, delete} [select]
17
  --oltp-auto-inc=[on|off]                 id列默认自增，默认[on]
18
  --oltp-connect-delay=N                   指定每一次重新连接延时的时长，默认1秒 [10000]
19
  --oltp-user-delay-min=N                  minimum time in microseconds to sleep after each request [0]
20
  --oltp-user-delay-max=N                  maximum time in microseconds to sleep after each request [0]
21
  --oltp-table-name=STRING                 指定测试的表名，默认[sbtest]
22
  --oltp-table-size=N                      指定表的记录大小，默认[10000]
23
  --oltp-dist-type=STRING                  随机数分布状态。uniform(均匀分布)、gauss(高斯分布)、special(特殊分布)，默认 [special]
24
  --oltp-dist-iter=N                       number of iterations used for numbers generation [12]
25
  --oltp-dist-pct=N                        启用百分比特殊分布，默认 [1]
26
  --oltp-dist-res=N                        special 百分比[75]
27
  --oltp-point-select-mysql-handler=[on|off] Use MySQL HANDLER for point select [off]
28
  --oltp-point-select-all-cols=[on|off]    select查询测试时select所有列，默认[off]
29
  --oltp-secondary=[on|off]                索引不是主键索引而是二级索引，默认[off]
30
  --oltp-num-partitions=N                  指定表分区的数量，默认 [0]
31
  --oltp-num-tables=N                      指定测试表的数量，默认[1]
32
General database options:
33
  --db-driver=STRING  指定测试数据库类型，默认mysql
34
  --db-ps-mode=STRING prepared statements usage mode {auto, disable} [auto]
35

36
mysql options:
37
  --mysql-host=[LIST,...]       MySQL server host [localhost]
38
  --mysql-port=N                MySQL server port [3306]
39
  --mysql-socket=STRING         MySQL socket
40
  --mysql-user=STRING           MySQL user [sbtest]
41
  --mysql-password=STRING       MySQL password []
42
  --mysql-db=STRING             MySQL database name [sbtest]
43
  --mysql-table-engine=STRING   storage engine to use for the test table {myisam,innodb,bdb,heap,ndbcluster,federated} [innodb]
44
  --mysql-engine-trx=STRING     whether storage engine used is transactional or not {yes,no,auto} [auto]
45
  --mysql-ssl=[on|off]          use SSL connections, if available in the client library [off]
46
  --myisam-max-rows=N           max-rows parameter for MyISAM tables [1000000]
47
  --mysql-create-options=STRING additional options passed to CREATE TABLE []

展开收起

oltp测试主要会有以下相关参数的测试,,其它相关参数默认即可，有需求也可以自定义：

1
--mysql-engine-trx=STRING     指定不同的存储引擎测试。
2
--oltp-test-mode=STRING       测试类型：simple(简单select测试),complex(事务测试),nontrx(非事务测试),sp(存储过程) ；默认complex
3
--oltp-sp-name=STRING         指定存储过程进行语句测试
4
--oltp-table-size=N           指定表的记录大小，默认[10000]
5
--oltp-num-tables=N           指定测试表的数量，默认[1]

需要先创建好测试数据库sbtest。

1.事务测试，测试12个线程执行1万条请求，10个表，每个表大小100W

Terminal window

1
./sysbench --num-threads=12 --max-requests=100000  --test=oltp --mysql-user=root --mysql-password=root --oltp-test-mode=complex --mysql-db=sbtest --oltp-table-size=1000000 --oltp-num-tables=10 prepare

Terminal window

1
./sysbench --num-threads=12 --max-requests=100000  --test=oltp --mysql-user=root --mysql-password=root --oltp-test-mode=complex --mysql-db=sbtest --oltp-table-size=1000000 --oltp-num-tables=10 run

Terminal window

1
./sysbench --num-threads=12 --max-requests=100000  --test=oltp --mysql-user=root --mysql-password=root --oltp-test-mode=complex --mysql-db=sbtest --oltp-table-size=1000000 --oltp-num-tables=10 cleanup

【Linux】测试硬盘读写速度

Tue, 19 Jun 2018 00:00:00 GMT

0x00

测试速度采用的是dd命令，dd命令用于复制文件并对原文件的内容进行转换和格式化处理。

统计消耗时间采用的是time，若无安装可采用apt、yum安装。

0x01测速纯写速度

time dd if=/dev/zero of=/var/test bs=8k count=100000

if为源文件
of为写入文件
bs为每次写入块的字节数
count为写入块的数量
/dev/zero为Unix中一个特殊字符设备，读取时可以提供无限的空字符（NULL, ASCII NUL, 0x00）

![](./images/89.1.avif)

0x02测试纯读速度

在上一步的基础上测试读的速度

time dd if=/var/test of=/dev/null bs=8k

/dev/null为Unix中“空设备”，它丢弃一切写入其中的数据（但报告写入操作成功），读取它则会立即得到一个EOF。可以将它理解为文件“黑洞”。

![](./images/89.2.avif)

0x03测试读写速度

在纯写的基础上测试

time dd if=/var/test of=/var/test2 bs=8k

【Linux】常用命令

Tue, 19 Jun 2018 00:00:00 GMT

备份磁盘并压缩

dd if=/dev/hdb | gzip > /root/image.gz

压缩恢复磁盘

gzip -dc /root/image.gz | dd of=/dev/hdb

备份磁盘开始的512个字节大小的MBR信息到指定文件

dd if=/dev/hda of=/root/image count=1 bs=512

销毁磁盘数据

dd if=/dev/urandom of=/dev/hda

/dev/random设备会封锁，直到系统产生的随机字符流已经充分够用，所以耗用时间较长
/dev/urandom设备不会封锁，数据的随机程度不高，但是一般情况已经够用

测试读写速度

[/posts/89/](/posts/89/)

确定硬盘的最佳块大小

dd if=/dev/zero bs=1024 count=1000000 of=/root/1Gb.file

dd if=/dev/zero bs=2048 count=500000 of=/root/1Gb.file

dd if=/dev/zero bs=4096 count=250000 of=/root/1Gb.file

dd if=/dev/zero bs=8192 count=125000 of=/root/1Gb.file

通过比较以上命令输出中所显示的命令执行时间,即可确定系统最佳的块大小。

修复硬盘

dd if=/dev/sda of=/dev/sda

当硬盘较长时间(比如1,2年)放置不使用后,磁盘上会产生magnetic fluxpoint。当磁头读到这些区域时会遇到困难,并可能导致I/O错误。当这种情况影响到硬盘的第一个扇区时,可能导致硬盘报废。上边的命令有可能使这些数据起死回生。且这个过程是安全,高效的。

磁盘操作（分区、挂载、格式化）

[/posts/83/](/posts/83/)

Android 6.0(API 23)及以上动态申请权限

Wed, 13 Jun 2018 00:00:00 GMT

0x00 权限组

所属权限组	权限
日历	READ_CALENDAR
日历	WRITE_CALENDAR
相机	CAMERA
联系人	READ_CONTACTS
联系人	WRITE_CONTACTS
联系人	GET_ACCOUNTS
位置	ACCESS_FINE_LOCATION
位置	ACCESS_COARSE_LOCATION
麦克风	RECORD_AUDIO
电话	READ_PHONE_STATE
电话	CALL_PHONE
电话	READ_CALL_LOG
电话	WRITE_CALL_LOG
电话	ADD_VOICEMAIL
电话	USE_SIP
电话	PROCESS_OUTGOING_CALLS
传感器	BODY_SENSORS
短信	SEND_SMS
短信	RECEIVE_SMS
短信	READ_SMS
短信	RECEIVE_WAP_PUSH
短信	RECEIVE_MMS
存储	READ_EXTERNAL_STORAGE
存储	WRITE_EXTERNAL_STORAGE

来自谷歌API,点击此处跳转注意：如果应用程序请求在AndroidManifest中列出的危险权限，并且应用程序已经在同一权限组中具有另一个危险权限，系统会立即授予权限，而不会与用户进行任何交互,。例如，如果一个应用程序先前已经请求并被授予READ_CONTACTS权限，然后它请求WRITE_CONTACTS(同属于联系人一组)，系统会立即授予该权限，不会再弹出权限授予询问的对话框。

0x01 动态申请权限方法

1
public void requestPower() {
2
    //判断是否已经赋予权限
3
        if (ContextCompat.checkSelfPermission(this,
4
                Manifest.permission.上表权限字符)
5
                != PackageManager.PERMISSION_GRANTED) {
6
           //如果应用之前请求过此权限但用户拒绝了请求，此方法将返回 true。
7
            if (ActivityCompat.shouldShowRequestPermissionRationale(this,
8
                    Manifest.permission.上表权限字符)) {//这里可以写个对话框之类的项向用户解释为什么要申请权限，并在对话框的确认键后续再次申请权限
9
            } else {
10
            //申请权限，字符串数组内是一个或多个要申请的权限，1是申请权限结果的返回参数，在onRequestPermissionsResult可以得知申请结果
11
                ActivityCompat.requestPermissions(this,
12
                        new String[]{Manifest.permission.上表权限字符,}, 1);
13
            }
14
        }
15
    }

展开收起

注意，因为判断语句，其实实际上当用户拒绝一次权限申请后，再次调用方法，不会再出现申请权限对话框。而如果不把权限写在数组里，而是每条权限放在一个多个以下方法里一起调用，实际上，每次一起调用这多个方法，实际只申请这些方法的一条权限。

0x02 判断权限申请结果

判断权限申请结果的方法（在权限申请对话框消失后执行）

1
@Override
2
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
3
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
4

5
        if (requestCode == 1) {
6
            for (int i = 0; i < permissions.length; i++) {
7
                if (grantResults[i] == PERMISSION_GRANTED) {
8
                    Toast.makeText(this, "" + "权限" + permissions[i] + "申请成功", Toast.LENGTH_SHORT).show();
9
                } else {
10
                    Toast.makeText(this, "" + "权限" + permissions[i] + "申请失败", Toast.LENGTH_SHORT).show();
11
                }
12
            }
13
        }
14
    }

当系统要求用户授予权限时，用户可以选择指示系统不再要求提供该权限。这种情况下，无论应用在什么时候使用 requestPermissions() 再次要求该权限，系统都会立即拒绝此请求。

Linux硬盘操作

Wed, 13 Jun 2018 00:00:00 GMT

0x01 查看磁盘设备

# df

0x02 查看磁盘信息

# fdisk -l

0x03 磁盘分区命令

fdisk可以用m命令来看fdisk命令的内部命令；

a：命令指定启动分区；

d：命令删除一个存在的分区；

l：命令显示分区ID号的列表；

m：查看fdisk命令帮助；

n：命令创建一个新分区；

p：命令显示分区列表；

t：命令修改分区的类型ID号；

w：命令是将对分区表的修改存盘让它发生作用。

# fdisk /dev/sda进入磁盘

1
Command (m for help):n
2
Command action
3
　　   e    extended                  //输入e为创建扩展分区
4
　　   p    primary partition (1-4)      //输入p为创建逻辑分区
5
p
6
Partion number(1-4)：1      //在这里输入l，就进入划分逻辑分区阶段了；
7
First cylinder (51-125, default 51):   //注：这个就是分区的Start 值；这里最好直接按回车，如果您输入了一个非默认的数字，会造成空间浪费；
8
Using default value 51
9
Last cylinder or +size or +sizeM or +sizeK (51-125, default 125): +200M 注：这个是定义分区大小的，+200M 就是大小为200M ；当然您也可以根据p提示的单位cylinder的大小来算，然后来指定 End的数值。回头看看是怎么算的；还是用+200M这个办法来添加，这样能直观一点。如果您想添加一个10G左右大小的分区，请输入 +10000M ；
10

11
Command (m for help): w                     //最后输入w回车保存。

0x04 格式化分区

mkfs.ext3 /dev/sda6 # 把该设备格式化成ext3文件系统 mke2fs -j /dev/sda6 # 把该设备格式化成ext3文件系统 mkfs.reiserfs /dev/sda6 # 格式化成reiserfs文件系统 mkfs.vfat /dev/sda6 # 格式化成fat32文件系统 mkfs.msdos /dev/sda6 # 格式化成fat16文件系统,msdos就是fat16 mkdosfs /dev/sda6 # 格式化成msdos文件系统

0x05 挂载分区

# mount /dev/sda /mnt将/dev/sda挂载到/mnt（umount卸载）

# mount —bind /home /mnt将/home内容挂载到/mnt（mount —move卸载）

参数说明：

-V：显示程序版本
-h：显示辅助讯息
-v：显示较讯息，通常和 -f 用来除错。
-a：将 /etc/fstab 中定义的所有档案系统挂上。
-F：这个命令通常和 -a 一起使用，它会为每一个 mount 的动作产生一个行程负责执行。在系统需要挂上大量 NFS 档案系统时可以加快挂上的动作。
-f：通常用在除错的用途。它会使 mount 并不执行实际挂上的动作，而是模拟整个挂上的过程。通常会和 -v 一起使用。
-n：一般而言，mount 在挂上后会在 /etc/mtab 中写入一笔资料。但在系统中没有可写入档案系统存在的情况下可以用这个选项取消这个动作。
-s-r：等于 -o ro
-w：等于 -o rw
-L：将含有特定标签的硬盘分割挂上。
-U：将档案分割序号为的档案系统挂下。-L 和 -U 必须在/proc/partition 这种档案存在时才有意义。
-t：指定档案系统的型态，通常不必指定。mount 会自动选择正确的型态。
-o async：打开非同步模式，所有的档案读写动作都会用非同步模式执行。
-o sync：在同步模式下执行。
-o atime、-o noatime：当 atime 打开时，系统会在每次读取档案时更新档案的『上一次调用时间』。当我们使用 flash 档案系统时可能会选项把这个选项关闭以减少写入的次数。
-o auto、-o noauto：打开/关闭自动挂上模式。
-o defaults:使用预设的选项 rw, suid, dev, exec, auto, nouser, and async.
-o dev、-o nodev-o exec、-o noexec允许执行档被执行。
-o suid、-o nosuid：
允许执行档在 root 权限下执行。
-o user、-o nouser：使用者可以执行 mount/umount 的动作。
-o remount：将一个已经挂下的档案系统重新用不同的方式挂上。例如原先是唯读的系统，现在用可读写的模式重新挂上。
-o ro：用唯读模式挂上。
-o rw：用可读写模式挂上。
-o loop=：使用 loop 模式用来将一个档案当成硬盘分割挂上系统。

实例

将 /dev/hda1 挂在 /mnt 之下。

Terminal window

1
mount /dev/hda1 /mnt

将 /dev/hda1 用唯读模式挂在 /mnt 之下。

Terminal window

1
mount -o ro /dev/hda1 /mnt

将 /tmp/image.iso 这个光碟的 image 档使用 loop 模式挂在 /mnt/cdrom之下。用这种方法可以将一般网络上可以找到的 Linux 光碟 ISO 档在不烧录成光碟的情况下检视其内容。

Terminal window

1
mount -o loop /tmp/image.iso /mnt/cdrom

NTFS格式磁盘挂载

这里采用简单的方式，安装ntfs-3g来实现挂载

# apt install ntfs-3g

挂载：

# mount -t ntfs-3g /dev/sda1 /mnt

开机自动挂载

编辑/etc/fstab

插入格式： <实际分区> <挂载点> <分区类型> <挂载参数> <dump备份设置> <fsck磁盘检查设置>

分区类型 Linux可以使用ext2、ext3等类型，此字段须与分区格式化时使用的类型相同。也可以使用 auto 这一特殊的语法，使系统自动侦测目标分区的分区类型。auto通常用于可移动设备的挂载。

挂载参数

auto: 系统自动挂载，fstab默认就是这个选项
defaults: rw, suid, dev, exec, auto, nouser, and async.
noauto 开机不自动挂载
nouser 只有超级用户可以挂载
ro 按只读权限挂载
rw 按可读可写权限挂载
user 任何用户都可以挂载请注意光驱和软驱只有在装有介质时才可以进行挂载，因此它是noauto

dump备份设置当其值设置为1时，将允许dump备份程序备份；设置为0时，忽略备份操作

fsck磁盘检查设置其值是一个顺序。当其值为0时，永远不检查；而 / 根目录分区永远都为1。其它分区从2开始，数字越小越先检查，如果两个分区的数字相同，则同时检查

实例

/dev/sda1 /mnt ntfs-3g defaults 0 0

服务脚本

Wed, 13 Jun 2018 00:00:00 GMT

1
import commands
2
import sys
3
import os
4

5
Error = "\033[1;31;40m"
6
Through = "\033[1;32;40m"
7
Tail = "\033[0m"
8

9

10
def fen(x):
11
    status, result = commands.getstatusoutput(
12
        'ps aux|grep fen.py|grep -v grep')
13
    if status == 0:
14
        if x == "k":
15
            return 1
16
        return Through + "运行中" + Tail
17
    else:
18
        if x== "g":
19
            return 1
20
        return Error + "未运行" + Tail
21

22

23
def xunlei(x):
24
    status, result = commands.getstatusoutput(
25
        'ps aux|grep xunlei|grep -v grep')
26
    if status == 0:
27
        if x == "k":
28
            return 1
29
        return Through + "运行中" + Tail
30
    else:
31
        if x== "g":
32
            return 1
33
        return Error + "未运行" + Tail
34

35
def frp(x):
36
    status, result = commands.getstatusoutput(
37
        'ps aux|grep frp|grep -v grep')
38
    if status == 0:
39
        if x == "k":
40
            return 1
41
        return Through + "运行中" + Tail
42
    else:
43
        if x== "g":
44
            return 1
45
        return Error + "未运行" + Tail
46

47
def state():
48
    f = open("/etc/startup-script/state.txt")
49
    for line in f:
50
        line = line.strip('\n')
51
        v = line.split(':')
52
        if v[0] == "fen_state":
53
            return fen_state(v[1])
54
    return Error + "Error" + Tail
55

56

57
def fen_state(stat):
58
    if stat == "1":
59
        return "风扇开启中\n"
60
    else:
61
        return "风扇已关闭\n"
62

63
def help():
64
    print("  _____      _     _   _   ")
65
    print(" |  __ \    | |   | | | |  ")
66
    print(" | |__) |___| |__ | |_| |_ ")
67
    print(" |  _  // _ \ '_ \| __| __|")
68
    print(" | | \ \  __/ | | | |_| |_ ")
69
    print(" |_|  \_\___|_| |_|\__|\__|")
70
    print
71
    print("-h | help    显示帮助")
72
    print("-f           开启温控风扇")
73
    print("-df          关闭温控风扇")
74
    print("-x           开启迅雷远程下载")
75
    print("-dx          关闭迅雷远程下载")
76
    print("-frp         开启frpc")
77
    print("-dfrp        关闭frpc")
78
    print("-ls          显示服务状态")
79

80
def show():
81
    print("cpu温控风扇：" + fen(0))
82
    print("迅雷远程下载：" + xunlei(0))
83
    print("frp:"+frp(0))
84
    print
85
    print("状态：" + state())
86

87
if __name__ == '__main__':
88
    arg=sys.argv
89
    k="k"
90
    g="g"
91
    try:
92
        if arg[1] == "help" and arg[1] == "-h":
93
            help()
94
        elif arg[1] == "-f":
95
            if fen(k) == 1:
96
                os.system('sudo python /etc/startup-script/fen.py &')
97
                print("开启成功")
98
            else:
99
                print("温控风扇已在运行状态")
100
        elif arg[1] == "-df":
101
            if fen(g) ==1:
102
                os.system('sudo killall python /etc/startup-script/fen.py')
103
                print("关闭成功")
104
            else:
105
                print("温控风扇未运行")
106
        elif arg[1] == "-x":
107
            if fen(k) == 1:
108
                os.system('sudo python /etc/startup-script/xunlei/setup.py')
109
                print("开启成功")
110
            else:
111
                print("迅雷远程下载已在运行状态")
112
        elif arg[1] == "-dx":
113
            if fen(g) ==1:
114
                os.system('sudo /etc/startup-script/xunlei/portal -s')
115
                print("关闭成功")
116
            else:
117
                print("迅雷远程下载未运行")
118
        elif arg[1]=="-frp":
119
            if frp(k) ==1:
120
                os.system('sudo screen -dmS frp /etc/startup-script/frp_0.20.0_linux_arm/frpc -c /etc/startup-script/frp_0.20.0_linux_arm/frpc.ini')
121
                print("开启成功")
122
            else:
123
                print("frp已在运行状态")
124
        elif arg[1]=="-dfrp":
125
            if frp(g)==1:
126
                os.system('sudo screen -d frp')
127
                print("关闭成功")
128
            else:
129
                print("frp未运行")
130
        elif arg[1] =="-ls":
131
            show()
132
        else:
133
            help()
134
    except:
135
        help()

展开收起

面向对象六大原则

Thu, 24 May 2018 00:00:00 GMT

0x01 单一职责原则-优化代码的第一步#

单一职责原则英文名称为Single Responsilbility Principle，缩写为SRP

定义：就一个类而言，应该仅有一个引起它变化的原因。

简单来说，一个类中应该是一组相关性很高的函数、数据的封装。

两个完全不一样的功能就不能放在一个类中。

0x02 闭源原则-让程序更稳定、更灵活#

开闭原则的英文是Open Close Principle，缩写为OCP，它是java中最基础的设计原则，它指导我们如何建立一个稳定、灵活的系统。

定义：软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是，对于修改是封闭的。

在软件生命周期内，因为变化、升级和维护等原因需要对软件原有代码进行修改时，可能将错误引入原本已经经过测试的旧代码中，破坏原有系统。因此，当软件需要变化时，我们应该尽量通过扩展的方式来实现变化，而不是通过修改已有的代码来实现。当然，在显示开发中，只通过继承的方式来实现升级、扩展原有系统只是一个理想化的愿景，因此，在实际开发中，修改原有代码、扩展代码往往是同时存在的。

程序一旦开发完成，原有的类只因修改代码错误而被修改，新的或更改的特性应该建立新的类来实现，新建的类可以通过继承的方式来重写原有类的代码。

0x03 里氏替换原则-构建扩展性更好的系统#

用AndroidStudio编写.so

Mon, 07 May 2018 00:00:00 GMT

Android开发中，我们经常会用到.so文件。原因有很多，比如部分方法不想暴露，如加密规则。比如部分秘钥需要存储，哪怕最简单的一个String我们使用.so调用获取这个String，也比直接明文写在代码中要来的安全。 NDK开发环境搭建

0x01#

首先新建一个java文件

QQ截图20180507165536-1024x190.png

代码：

1
public class myJNT {
2
    static {
3
        System.loadLibrary("JniTest");
4
    }
5
    public static native String Hello();
6
}

0x02#

使用javah工具生成.h文件

QQ截图20180507170454.png

0x03#

将生成好的.h文件改为.c文件，并修改其中内容

生成的.h文件：

1
/* DO NOT EDIT THIS FILE - it is machine generated */
2
#include <jni.h>
3
/* Header for class com_rehtt_test_ndk_myJNT */
4

5
#ifndef _Included_com_rehtt_test_ndk_myJNT
6
#define _Included_com_rehtt_test_ndk_myJNT
7
#ifdef __cplusplus
8
extern "C" {
9
#endif
10
/*
11
 * Class:     com_rehtt_test_ndk_myJNT
12
 * Method:    Hello
13
 * Signature: ()Ljava/lang/String;
14
 */
15
JNIEXPORT jstring JNICALL Java_com_rehtt_test_ndk_myJNT_Hello
16
  (JNIEnv *, jclass);
17

18
#ifdef __cplusplus
19
}
20
#endif
21
#endif

展开收起

修改后的.c文件：

1
/* DO NOT EDIT THIS FILE - it is machine generated */
2
#include <jni.h>
3
/* Header for class com_rehtt_test_ndk_myJNT */
4

5
#ifndef _Included_com_rehtt_test_ndk_myJNT
6
#define _Included_com_rehtt_test_ndk_myJNT
7
#ifdef __cplusplus
8
extern "C" {
9
#endif
10
/*
11
 * Class:     com_rehtt_test_ndk_myJNT
12
 * Method:    Hello
13
 * Signature: ()Ljava/lang/String;
14
 */
15
JNIEXPORT jstring JNICALL Java_com_rehtt_test_ndk_myJNT_Hello
16
  (JNIEnv *env, jclass jobj){
17
  //返回字符串
18
  return (*env)->NewStringUTF(env,"emmmmmm");
19
  }
20

21
#ifdef __cplusplus
22
}
23
#endif
24
#endif

展开收起

0x04#

打开moduled的build.gradle文件，在defaultConfig下添加代码：

1
ndk {
2
moduleName "JniTest"    //编译出来so的名字
3
ldLibs "log", "z", "m"
4
abiFilters "armeabi", "armeabi-v7a", "x86"
5
}

QQ截图20180507171708-1024x554.png

在gradle.properties里面加上: android.useDeprecatedNdk=true 可能会报错，根据报错提示信息进行相应修改即可。

0x05#

Rebuild Project就可以生成so库，在app\build\intermediates\ndk\debug\lib路径下。如果出现了...\ndk-bundle\ndk-build.cmd'' finished with non-zero exit value 2报错就将app\build\intermediates\ndk\debug\lib下的Android.mk复制到src\main\jni下，并使用ndk -build手动生成so文件。

0x06#

myJNT.Hello()即可调用so中的字符串

END

AndroidStudio NDK开发环境搭建

Mon, 07 May 2018 00:00:00 GMT

0x00#

NDK即Native Development Kit,NDK允许开发者使用类似C / C++之类的原生代码语言执行部分程序。为何要用到NDK? 概括来说主要分为以下几种情况：

代码的保护，由于apk的java层代码很容易被反编译，而C/C++库被反编译的难度较大。
在NDK中调用第三方C/C++库，因为大部分的开源库都是用C/C++代码编写的。
便于移植，用C/C++写的库可以方便在其他的嵌入式平台上再次使用。

0x01#

打开AndroidStudio的settings，找到Android SDK一栏点击SDK Tools，找到NDK选项并勾选。

QQ截图20180507174001-1024x684.png

0x02#

在settings中找到External Tools添加javah -jni和ndk -build javah -jni

QQ截图20180507174824.png

$JDKPath$\bin\javah.exe -classpath . -jni -d "$ModuleFileDir$\src\main\jni" $FileClass$ $ModuleFileDir$\src\main\java

ndk -build

QQ截图20180507175123.png

C:\Users\用户名\.android\Android_SDK\ndk-bundle\ndk-build.cmd ndk工具所在的路径 $ModuleFileDir$\src\main\

END#

计算机网络-根据掩码和ip计算网段起始ip和最终ip

Mon, 23 Apr 2018 00:00:00 GMT

一个B类ip
ip：10.254.68.136
掩码：255.255.224.0

网络位	主机位

掩码二进制：

1111 1111	1111 1111	1110 0000	0000 0000

掩码中0为主机位，1为网络位

ip二进制：

0000 1010	1111 1110	0100 0100	1000 1000

网段网络位不动，主机位从0到1，所以该网段起始ip为：

10	254	64	0
0000 1010	1111 1110	0100 0000	0000 0000

最终ip为：

10	254	95	255
0000 1010	1111 1110	0101 1111	1111 1111

Python中sys.arg[]的用法

Thu, 12 Apr 2018 00:00:00 GMT

引入库：import sys 文件名：test.py

1
a=sys.arg[0]
2
print(a)
3
结果输出：test.py
4

5
a=sys.arg[1]
6
b=sys.arg[2]
7
print(a+" "+b)
8
运行>test.py 1 2
9
结果输出：1 2
10

11
a=sys.arg[1:]
12
print(a)
13
运行>test.py 1 2 3
14
结果输出：['1','2','3']
15

16
a=sys.arg[2:]:
17
print(a)
18
运行>test.py 1 2 3
19
结果输出：['2','3']
20

21
a=sys.arg[0:]
22
print(a)
23
运行>test.py 1 2 3
24
结果输出：['test.py','1','2','3']

展开收起

P4wnP1通过USB连接电脑网络(windowns)

Sat, 07 Apr 2018 00:00:00 GMT

0x00#

插入电脑后在“网络连接”中会出现P4wnP1网卡以太网 Remote NDIS Compatibl...

打开目前连接网络的网卡设置，选择“共享”勾选“连接共享”，选择P4wnP1的接口以太网 选择P4wnP1的网卡，配置静态ip,更改ip和子网掩码：

1
ip:         172.16.0.2
2
子网掩码:    255.255.255.252

0x01 win8-10额外配置(ping 172.16.0.2不通)可忽略#

以管理员身份运行power shell，将网卡改为私有

输入Get-NetConnectionProfile，复制P4wnP1网卡的名字

输入Set-NetConnectionProfile -Name "你的P4wnP1网卡名字" -NetworkCategory Private

微信截图_20180407132535.png

0x02设置路由访问外网#

ssh连接P4wnP1后输入sudo route add -net default gw 172.16.0.2

切换到root添加dns，输入echo nameserver 114.114.114.114 > /etc/resolv.conf

Done

ARP攻击（断网攻击）

Sun, 01 Apr 2018 00:00:00 GMT

Note

所谓ARP攻击，就是伪造IP和MAC地址进行的攻击或者欺骗，ARP攻击和ARP欺骗应该是两个概念，ARP攻击所产生的效果就是使目标主机（当然这里默认的是局域网，倘若你处在外网，涉及到内网渗透，以后在具体说内网渗透）断网，这种行为从某种意义上来说是，是损人不利己的，因为攻击者并没有得到什么好处，只是让对方不能上网，但是如果在ARP攻击的基础上，通过嗅探对方的流量，非法获取一些隐私信息，那就大大不同了。

ARP欺骗：传送

0x00环境及工具#

环境：Kali linux环境

工具：Dsniff、fping

Dsniff是一个基于unix系统网络嗅探工具集，这里所用的是arpspoof命令。

fping可以说是ping的增强版,可以在ping时间按照从1毫秒到5秒的频率调整时间并且在每次应答成功(超时)的时间发出语音提示,还可以同时ping多台主机，在这里的作用是寻找局域网中的设备ip地址。

0x01寻找目标#

使用fping寻找地址：

Terminal window

1
$ fping -a -g 192.168.199.0/24 2>/dev/null
2
也可以用：
3
$ fping -a -g 192.168.199.1 192.168.199.254 2>/dev/null

微信截图_20180401163933.png

这里选用192.168.199.180作为目标

0x02攻击#

arpspoof语法：

1
arpspoof [-i interface] [-c own|host|both] [-t target] [-r] host

攻击：

Terminal window

1
arpspoof -i wlan0 -t 192.168.199.180 192.168.199.1

微信截图_20180401164416.png

这时会发现目标上不了网了，攻击目标也达到了。

树莓派配置wifi连接

Sat, 31 Mar 2018 00:00:00 GMT

0x00#

在树莓派官方系统可以更快捷配置wifi和ssh：传送

在非官方系统下使用命令配置wifi连接。

0x01#

树莓派默认wifi接口为wlan0，如果不确定可以输入命令查看：

Terminal window

1
iwconfig

首先保证接口的服务是运行的：

Terminal window

1
$ sudo ip link set wlan0 up

扫描网络：

Terminal window

1
$ sudo iw dev wlan0 scan | less

如果连接没有加密的网络：

Terminal window

1
$ sudo iw dev wlan0 connect [网络 SSID]

`如果连接WEP加密的网络：

Terminal window

1
$ sudo iw dev wlan0 connect [网络 SSID]

如果连接WPA\WPA2加密的网络则需要使用wpasupplicant 来连接，修改或创建/etc/wpasupplicant/wpa_supplicant.conf 文件写入：

1
country=CN
2
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
3
update_config=1
4

5
network={
6
ssid="WiFi-A"
7
psk="12345678"                  #psk可以填加密后的值，加密：终端输入 wpa_passphrase WiFi-A 12345678
8
priority=1                       #连接优先级，数字越大优先级越高（不可以是负数）
9
scan_ssid:=1                 #连接隐藏WiFi时需要指定该值为1
10
}

写好了后输入命令启动：

Terminal window

1
$ sudo wpa_supplicant -i wlan0 -c /etc/wpa_supplicant/wpa_supplicant.conf &

输入命令自动获取ip：

Terminal window

1
$ sudo dhcpcd wlan0
2
或
3
$ sudo dhclient wlan0

0x03#

输入命令查看wlan0是否在配置中：

Terminal window

1
$ cat /etc/network/interfaces

如果没有就输入:

Terminal window

1
$ sudo nano /etc/network/interfaces

文本中追加写入：

1
auto wlan0
2
iface wlan0 inet dhcp
3
wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

配置完后就可开机自动连接wifi

Arduino入门hello world

Thu, 29 Mar 2018 00:00:00 GMT

Note

Arduino是一款单片机开发板，是个很好上手的入门级开发板，适合于用于开发电子产品原型，开发语言采用Ｃ，其特点是简单、方便、软件库多、模块配件多。

0x00初识Arduino#

工欲善其事，必先利其器。首先是需要一块Arduino开发版，我使用的是Arduino uno r3，淘宝售价在25元左右。

微信图片_20180328230444-1024x768.jpg

这块板子使用的是atmega328p的芯片，闪存容量32K（其中0.5K用作引导程序），EEPROM容量1K，时钟速度16MHz，I/O针脚电流为20mA，3.3V针脚电流为50mA。

针脚中A为模拟引入脚，D为数字IO脚，RET是复位脚，RX，TX分别是串行通信收发脚，GND为电源零线，5V、3.3V为正电引出脚（向外供电），VIN为电源输入脚（向板子供电，工作电压为5V，正常电压为7-12V，极限电压为6-20V）。

0x01安装软件#

Arduino IDE 是 Arduino的集成开发环境，用于单片机软件编程、下载、测试等。

到官网下载Arduino IDE即可。

连接电脑后Windowns系统电脑需要安装驱动（Mac os与Liunx可以不用安装驱动），需要安装的驱动根据板子的usb转串口芯片有关，我的是CH340G，下载相关驱动安装即可。

微信图片_20180328233548.jpg

安装好后会在电脑设备管理器中的端口出现一个新的端口

微信截图_20180328234119.png

如果没安装好（或与芯片型号不匹配）会显示一个“未知设备”。

Arduino IDE安装目录下有一个drivers目录，包含了Arduino官方版本的驱动程序。可以选中未知设备，更新驱动程序，将搜索目录指向Arduino IDE安装目录下有一个drivers目录试试。

0x02配置#

板子连接电脑后启动Arduino IDE，点击“工具”->“开发版”选择对应型号的板子，点击“工具”->“端口”选择对应的端口。

1.jpg

2.jpg

0x03编写第一个程序#

Arduino IDE会自动给新项目添加setup()和loop()函数，Arduino程序不需要写main()因为会自动生成main函数，但是必须要setup()和loop()。

setup()是设置函数，主要写初始化相关的代码，板子启动后只会调用一次etup()函数。

loop()是循环函数，在setup()执行完后会执行loop()，loop()执行完后将会再次执行loop()函数。

用c语言理解：

1
void main()
2
{
3
    setup();
4

5
    while(1){
6
        loop();
7

8
}

写入下列代码：

1
void setup(){
2
    Serial.begin(9600);  //初始化串口，波特率为9600
3
}
4

5
void loop(){
6
    Serial.println("hello world");  //向串口打印字符串
7
}

在Arduino IDE左上角有两个按钮，分别为编译和上传。

微信截图_20180329000820.jpg

程序写好后先编译后上传，如果编译出错下方会有提示。

当程序上传完毕后将立即运行。

点击“工具”->“串口监视器”选择正确的波特率就可以看见运行结果。

微信截图_20180329001410.jpg

到这来你的第一个Arduino程序开发、运行起来了。

理解Linux硬链接与软链接

Mon, 26 Mar 2018 00:00:00 GMT

内容转自：https://www.ibm.com/developerworks/cn/linux/l-cn-hardandsymb-links/index.html

0x00文件概念#

现代操作系统为解决信息能独立于进程之外被长期存储引入了文件，文件作为进程创建信息的逻辑单元可被多个进程并发使用。在 UNIX 系统中，操作系统为磁盘上的文本与图像、鼠标与键盘等输入设备及网络交互等 I/O 操作设计了一组通用 API，使他们被处理时均可统一使用字节流方式。换言之，UNIX 系统中除进程之外的一切皆是文件，而 Linux 保持了这一特性。为了便于文件的管理，Linux 还引入了目录（有时亦被称为文件夹）这一概念。目录使文件可被分类管理，且目录的引入使 Linux 的文件系统形成一个层级结构的目录树。下图所示的是普通 Linux 系统的顶层目录结构，其中 /dev 是存放了设备相关文件的目录。

tree.png

Linux 与其他类 UNIX 系统一样并不区分文件与目录：目录是记录了其他文件名的文件。使用命令 mkdir 创建目录时，若期望创建的目录的名称与现有的文件名（或目录名）重复，则会创建失败。

Linux 将设备当做文件进行处理，下图展示了如何打开设备文件 /dev/input/event5 并读取文件内容。文件 event5 表示一种输入设备，其可能是鼠标或键盘等。查看文件 /proc/bus/input/devices 可知 event5 对应设备的类型。设备文件 /dev/input/event5 使用 read() 以字符流的方式被读取。结构体 input_event 被定义在内核头文件 linux/input.h 中。

1-1.png

0x01硬链接与软链接的联系与区别#

我们知道文件都有文件名与数据，这在 Linux 上被分成两个部分：用户数据 (user data) 与元数据 (metadata)。用户数据，即文件数据块 (data block)，数据块是记录文件真实内容的地方；而元数据则是文件的附加属性，如文件大小、创建时间、所有者等信息。在 Linux 中，元数据中的 inode 号（inode 是文件元数据的一部分但其并不包含文件名，inode 号即索引节点号）才是文件的唯一标识而非文件名。文件名仅是为了方便人们的记忆和使用，系统或程序通过 inode 号寻找正确的文件数据块。下图展示了程序通过文件名获取文件内容的过程。

微信截图_20180326100721.png

在 Linux 系统中查看 inode 号可使用命令 stat 或 ls -i（若是 AIX 系统，则使用命令 istat）。假设一个文件名为a，inode号为2485677，对其使用命令 mv 移动并重命名文件，其结果不影响文件的用户数据及 inode 号，文件移动前后 inode 号均为：2485677。

为解决文件的共享使用，Linux 系统引入了两种链接：硬链接 (hard link) 与软链接（又称符号链接，即 soft link 或 symbolic link）。链接为 Linux 系统解决了文件的共享使用，还带来了隐藏文件路径、增加权限安全及节省存储等好处。若一个 inode 号对应多个文件名，则称这些文件为硬链接。换言之，硬链接就是同一个文件使用了多个别名硬链接可由命令 link 或 ln 创建。

微信截图_20180326101044.png

由于硬链接是有着相同 inode 号仅文件名不同的文件，因此硬链接存在以下几点特性：

文件有相同的 inode 及 data block；
只能对已存在的文件进行创建；
不能交叉文件系统进行硬链接的创建；
不能对目录进行创建，只可对文件创建；
删除一个硬链接文件并不影响其他有相同 inode 号的文件。

inode 是随着文件的存在而存在，因此只有当文件存在时才可创建硬链接，即当 inode 存在且链接计数器（link count）不为 0 时。inode 号仅在各文件系统下是唯一的，当 Linux 挂载多个文件系统后将出现 inode 号重复的现象，因此硬链接创建时不可跨文件系统。设备文件目录 /dev 使用的文件系统是 devtmpfs，而 /root（与根目录 / 一致）使用的是磁盘文件系统 ext4。

值得一提的是，Linux 系统存在 inode 号被用完但磁盘空间还有剩余的情况。

硬链接不能对目录创建是受限于文件系统的设计现（下图）。 Linux 文件系统中的目录均隐藏了两个个特殊的目录：当前目录（.）与父目录（..）。查看这两个特殊目录的 inode 号可知其实这两目录就是两个硬链接（注意目录 /mnt/lost+found/ 的 inode 号）。若系统允许对目录创建硬链接，则会产生目录环。

微信截图_20180326101548.png

软链接与硬链接不同，若文件用户数据块中存放的内容是另一文件的路径名的指向，则该文件就是软连接。软链接就是一个普通文件，只是数据块内容有点特殊。软链接有着自己的 inode 号以及用户数据块。因此软链接的创建与使用没有类似硬链接的诸多限制：

软链接有自己的文件属性及权限等；
可对不存在的文件或目录创建软链接；
软链接可交叉文件系统；
软链接可对文件或目录创建；
创建软链接时，链接计数 i_nlink 不会增加；
删除软链接并不影响被指向的文件，但若被指向的原文件被删除，则相关软连接被称为死链接（即 dangling link，若被指向路径文件被重新创建，死链接可恢复为正常的软链接）。

微信截图_20180326101728.png

微信截图_20180326101955.png

当然软链接的用户数据也可以是另一个软链接的路径，其解析过程是递归的。但需注意：软链接创建时原文件的路径指向使用绝对路径较好。使用相对路径创建的软链接被移动后该软链接文件将成为一个死链接（如下所示的软链接 a 使用了相对路径，因此不宜被移动），因为链接数据块中记录的亦是相对路径指向。

微信截图_20180326102051.png

0x02链接相关命令#

在 Linux 中查看当前系统已挂着的文件系统类型，除上述使用的命令 df，还可使用命令 mount 或查看文件 /proc/mounts。
命令 ls 或 stat 可帮助我们区分软链接与其他文件并查看文件 inode 号，但较好的方式还是使用 find 命令，其不仅可查找某文件的软链接，还可以用于查找相同 inode 的所有硬链接。
系统根据磁盘的大小默认设定了 inode 的值，如若必要，可在格式文件系统前对该值进行修改。如键入命令 mkfs -t ext4 -I 512/dev/sda4，将使磁盘设备 /dev/sda4 格式成 inode 大小是 512 字节的 ext4 文件系统。

0x03Linux VFS#

Linux 有着极其丰富的文件系统，大体上可分如下几类：

网络文件系统，如 nfs、cifs 等；
磁盘文件系统，如 ext4、ext3 等；
特殊文件系统，如 proc、sysfs、ramfs、tmpfs 等。实现以上这些文件系统并在 Linux 下共存的基础就是 Linux VFS（Virtual File System 又称 Virtual Filesystem Switch），即虚拟文件系统。VFS 作为一个通用的文件系统，抽象了文件系统的四个基本概念：文件、目录项 (dentry)、索引节点 (inode) 及挂载点，其在内核中为用户空间层的文件系统提供了相关的接口（下图所示 VFS 在 Linux 系统的架构）。VFS 实现了 open()、read() 等系统调并使得 cp 等用户空间程序可跨文件系统。VFS 真正实现了上述内容中：在 Linux 中除进程之外一切皆是文件。
微信截图_20180326102645.png

Linux VFS 存在四个基本对象：超级块对象 (superblock object)、索引节点对象 (inode object)、目录项对象 (dentry object) 及文件对象 (file object)。超级块对象代表一个已安装的文件系统；索引节点对象代表一个文件；目录项对象代表一个目录项，如设备文件 event5 在路径 /dev/input/event5 中，其存在四个目录项对象：/ 、dev/ 、input/ 及 event5。文件对象代表由进程打开的文件。这四个对象与进程及磁盘文件间的关系如图 4. 所示，其中 d_inode 即为硬链接。为文件路径的快速解析，Linux VFS 设计了目录项缓存（Directory Entry Cache，即 dcache）。

微信截图_20180326102733.png

mount命令

Mon, 26 Mar 2018 00:00:00 GMT

mount命令用于加载文件系统到指定的加载点。此命令的最常用于挂载cdrom，使我们可以访问cdrom中的数据，因为你将光盘插入cdrom中，Linux并不会自动挂载，必须使用Linux mount命令来手动完成挂载。

语法#

1
mount(选项)(参数)

选项#

1
-V：显示程序版本；
2
-l：显示已加载的文件系统列表；
3
-h：显示帮助信息并退出；
4
-v：冗长模式，输出指令执行的详细信息；
5
-n：加载没有写入文件“/etc/mtab”中的文件系统；
6
-r：将文件系统加载为只读模式；
7
-a：加载文件“/etc/fstab”中描述的所有文件系统。

参数#

设备文件名：指定要加载的文件系统对应的设备名；
加载点：指定加载点目录。

实例#

1
mount -t auto /dev/cdrom /mnt/cdrom
2
mount: mount point /mnt/cdrom does not exist           /mnt/cdrom目录不存在，需要先创建。
3

4
cd /mnt
5
-bash: cd: /mnt: No such file or directory
6

7
mkdir -p /mnt/cdrom    创建/mnt/cdrom目录
8
ls
9
bin   dev  home    lib         media  mnt  proc  sbin     srv  tmp  var
10
boot  etc  initrd  lost+found  misc   opt  root  selinux  sys  usr
11

12
mount -t auto /dev/cdrom /mnt/cdrom     挂载cdrom
13
mount: block device /dev/cdrom is write-protected, mounting read-only     挂载成功
14

15
ll /mnt/cdrom    查看cdrom里面内容
16
total 859
17
dr-xr-xr-x  4 root root   2048 Sep  4  2005 CentOS
18
-r--r--r--  2 root root   8859 Mar 19  2005 centosdocs-man.css
19
-r--r--r--  9 root root  18009 Mar  1  2005 GPL
20
dr-xr-xr-x  2 root root 241664 May  7 02:32 headers
21
dr-xr-xr-x  4 root root   2048 May  7 02:23 images
22
dr-xr-xr-x  2 root root   4096 May  7 02:23 isolinux
23
dr-xr-xr-x  2 root root  18432 May  2 18:50 NOTES
24
-r--r--r--  2 root root   5443 May  7 01:49 RELEASE-NOTES-en.html
25
dr-xr-xr-x  2 root root   2048 May  7 02:34 repodata
26
-r--r--r--  9 root root   1795 Mar  1  2005 rpm-GPG-KEY
27
-r--r--r--  2 root root   1795 Mar  1  2005 RPM-GPG-KEY-centos4
28
-r--r--r--  1 root root 571730 May  7 01:39 yumgroups.xml

展开收起

AppCompatActivity的标题栏上加上返回按钮

Sun, 25 Mar 2018 00:00:00 GMT

0x00#

一般情况下新创建的Activity默认没有添加返回按钮，目前基于android6.0版本sdk并通过android studio创建的空Activity默认都是继承自AppCompatActivity。

微信截图_20180325171241.png

0x01#

此时如果需要给AppCompatActivity的标题栏上加上返回按钮，可以在Activity的onCreate中加入如下代码：

1
android.support.v7.app.ActionBar actionBar = getSupportActionBar();
2
if(actionBar != null){
3
    actionBar.setHomeButtonEnabled(true);
4
    actionBar.setDisplayHomeAsUpEnabled(true);
5
}

在onOptionsItemSelected中加入如下代码：

1
@Override
2
public boolean onOptionsItemSelected(MenuItem item) {
3
    if(item.getItemId()==android.R.id.home){
4
        this.finish();
5
        return true;
6
    }
7
    return super.onOptionsItemSelected(item);
8
}

frp内网穿透

Wed, 21 Mar 2018 00:00:00 GMT

0x00#

frp是一款使用go语言开发开源的内网穿透反向代理应用，通过一台拥有公网ip的服务器来转发没有公网ip服务器的端口实现反向代理，支持 tcp, udp, http, https 协议。

1-2.png

architecture.png

0x01 下载及配置#

1.下载#

应用作者已经编译好各平台的应用，只需找到相应平台的版本即可。

例如树莓派的cpu平台是arm的，所以选择下载linux_arm

常见设备版本：

linux_amd64 linux 64位版

linux_386 linux 32位版

windows_amd64 windows 64位版

windows_386 windows 32位版

darwin_amd64 mac系统版

下载地址

2.配置简单配置：公网ip端使用frps和frps.ini

frps.ini

1
#必填
2
[common]
3
#连接端口，自义定不要端口冲突就好
4
bind_port=7000

内网端使用frpc和frpc.ini

frpc.ini展开收起

1
#必填
2
[common]
3
#公网ip机器的ip或网址
4
server_addr=x.x.x.x
5
#公网ip机器的连接端口，必须和公网机器一致
6
server_port=7000
7

8
#名字自义定
9
[test]
10
#协议类型
11
type=tcp
12
#要转发的本地ip
13
local_ip=127.0.0.1
14
#要转发的本地端口
15
local_port=1234
16
#公网机器转发端口，自义定不要与公网机器端口冲突就好
17
remote_port=6000

展开收起

启动：公网机器：

Terminal window

1
$ ./frps -c ./frps.ini

内网机器：

Terminal window

1
$ ./frpc -c ./frpc.ini

0x02 END 其他详情请查阅官方配置说明

Java、android彻底关闭应用方法

Wed, 21 Mar 2018 00:00:00 GMT

android应用中new出很多线程在关闭应用时发现不能彻底退出。只用finish()方法，有时候不能彻底退出。

彻底退出用：System.exit(0);

System.exit(0)是将你的整个虚拟机里的内容都停掉了。内存都释放了！也就是说连JVM都关闭了，内存里根本不可能还有什么东西

Android: runOnUiThread

Wed, 14 Mar 2018 00:00:00 GMT

在Fragment中使用getActivity().runOnUiThread()更新Ui可能会遇到报错：

java.lang.NullPointerException: Attempt to invoke virtual method ‘void android.support.v4.app.FragmentActivity.runOnUiThread(java.lang.Runnable)’ on a null object reference at com.rehtt.app.Fragment.MainFragment$3.onFailure(MainFragment.java<103>)

这是因为getActivity()为null所致。

解决方法：

1
if (getActivity() !=null ){
2

3
   getActivity().runOnUiThread(......);
4

5
}

SSH免密码登录

Tue, 06 Mar 2018 00:00:00 GMT

0x00 前言#

实现ssh服务器免密码登录

0x01 生成密钥#

命令行:

Terminal window

1
ssh-keygen -t rsa #使用rsa加密

在当前用户根目录下~/.ssh/会生成两个文件:id_rsa(密钥文件),id_rsa.pub(公钥文件)

0x02 发送公钥到服务器#

1.使用ssh自带工具发送

Terminal window

1
ssh-copy-id -i ~/.ssh/id_rsa.pub <UserName>@<ServerIP>

2.使用scp发送

Terminal window

1
scp -p ~/.ssh/id_rsa.pub <UserName>@<ServerIp>:~/.ssh/authorized_keys

0x03 常见问题#

如果提示权限不够,修改权限即可

Terminal window

1
chmod 755 ~/.ssh/
2
chmod 600 ~/.ssh/id_rsa ~/.ssh/id_rsa.pub
3
chmod 644 ~/.ssh/known_hosts

NodeMcu安装wifi killer

Mon, 05 Mar 2018 00:00:00 GMT

0x00#

所需下载：nodemcu firmware programmer（一键刷入工具），CH340G驱动（usb转串口驱动，我的板子是CH340G根据自己的情况下载并安装），wifi kllier固件（适用esp8266芯片）

0x01#

插入板子并安装驱动，打开nodemcu firmware programmer，选择固件文件地址，选择端口，刷入

1.png

2.jpg

0x02#

进度条走完了后，左下角出现绿色的√即刷入成功

将板子拔出电源再插入电源即可开机（插入电源时板子的esp8266芯片的灯会闪一下），手机或电脑搜索名为：pwned的wifi，密码为：deauther

浏览器打开192.168.4.1进入主界面

ps.如果更改密码后忘记密码需要进行Flash清除

树莓派安装Raspbian

Mon, 05 Mar 2018 00:00:00 GMT

0x00#

Raspbian是一个单纯的Arm版的Linux系统，基于Debian

下载文件：Raspbian（分为桌面版与无桌面版，根据所需选择），镜像写入工具（推荐Etcher）

0x01#

将内存卡插入读卡器再插入电脑，打开Etcher，选择镜像文件地址和要烧录的驱动器，进行烧录

0x02#

1.登录#

raspbain默认账户是，密码是raspberry

登录后可运行sudo passwd pi来更改密码。

2.开启Root账户#

运行sudo passwd root设置root密码

因为raspbain默认的root账户是锁定的，所以需运行sudo passwd --unlock root

3.SSH#

2016-11-25 官方发布的 Raspbian 系统镜像，系统默认禁用了 SSH 服务。

官方方案：

SSH disabled by default; can be enabled by creating a file with name “ssh” in boot partiti.

因此只需在/boot目录下新建一个ssh目录即可解决。

4.WiFi 网络配置

用户可以在未启动树莓派的状态下单独修改 /boot/wpa_supplicant.conf 文件配置 WiFi 的 SSID 和密码，这样树莓派启动后会自行读取wpa_supplicant.conf配置文件连接 WiFi 设备。

操作方法简单：将刷好 Raspbian 系统的 SD 卡用电脑读取。在 boot 分区，也就是树莓派的 /boot 目录下新建 wpa_supplicant.conf 文件，按照下面的参考格式填入内容并保存 wpa_supplicant.conf 文件。

1
country=CN
2
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
3
update_config=1
4

5
network={
6
ssid="WiFi-A"
7
psk="12345678"
8
key_mgmt=WPA-PSK
9
priority=1
10
}
11

12
network={
13
ssid="WiFi-B"
14
psk="12345678"
15
key_mgmt=WPA-PSK
16
priority=2
17
scan_ssid=1
18
}

展开收起

说明以及不同安全性的 WiFi 配置示例：

1
#ssid:网络的ssid
2
#psk:密码
3
#priority:连接优先级，数字越大优先级越高（不可以是负数）
4
#scan_ssid:连接隐藏WiFi时需要指定该值为1

如果你的 WiFi 没有密码

1
network={
2
ssid="你的无线网络名称（ssid）"
3
key_mgmt=NONE
4
}
5
如果你的 WiFi 使用WEP加密
6

7
network={
8
ssid="你的无线网络名称（ssid）"
9
key_mgmt=NONE
10
wep_key0="你的wifi密码"
11
}
12
如果你的 WiFi 使用WPA/WPA2加密
13

14
network={
15
ssid="你的无线网络名称（ssid）"
16
key_mgmt=WPA-PSK
17
psk="你的wifi密码"
18
}

展开收起

如果你不清楚 WiFi 的加密模式，可以在安卓手机上用 root explorer 打开 /data/misc/wifi/wpa/wpa_supplicant.conf，查看 WiFi 的信息。

树莓派zero w安装P4wnP1

Mon, 05 Mar 2018 00:00:00 GMT

0x00#

P4wnP1是一个高度可定制的usb攻击平台，可在zero和zero w上运行（zero w上功能100%兼容）。

Caution

本教程仅用于学习交流

P4wnP1帮助文档

P4wnP1作者GitHub

P4wnP1通过usb连接网络

0x01 1 首先下载并刷入树莓派官方系统raspbain，安装教程，建议更改密码以免被别人反（bao）黑（ju）。

2 安装git，下载安装P4wnP1

Terminal window

1
sudo apt-get -y install git
2
cd /home/pi
3
git clone --recursive https://github.com/mame82/P4wnP1
4
cd P4wnP1
5
./install.sh
6
sudo reboot

0x02#

搜索名为P4wnP1的wifi

密码为MaMe82-P4wnP1

ssh连接pi@127.16.0.1

0x03#

配置P4wnP1

Terminal window

1
nano setup.cfg

界面

（图片转自：http://image.3001.net/images/20171003/15069622944860.png!small）

这个配置文件的话可以修改wifi的名字还有密码

还有键盘语言之类的底部有payload选择

刚开始的时候 playload=network_only.txt前面加上#

每次只能执行一个payload

然后选择执行的payload即可(去掉注释即可执行payload)

比如选择hid_backdoor的话就去去掉#PAYLOAD=hid_backdoor_remote.txt

前面的#

如下图:

请输入图片描述

（图片转自：http://image.3001.net/images/20171003/15069623442312.png!small）

米特尼克在defcon上那个解锁win10锁屏界面这个程序也是可以给你实现的，那个就是 PAYLOAD=Win10_LockPicker.txt

hash密码文件存储在P4wnP1/responder/logs/文件夹里

其他更多功能可以输入help查看

ESP8266清除Flash数据

Sun, 04 Mar 2018 00:00:00 GMT

0x00#

一键刷入固件工具只能向8266写入固件程序，无法对flash进行擦除操作，因而可能会由于某些原因造成烧录的固件运行不正常。

这里使用的是esptool.py，在python2.7环境下运行，python3.0可能会出错。

0x01#

使用pip自动安装esptool

命令：pip install esptool

Terminal window

1
pip install pyserial

0x02#

注意下面命令中的串口需要根据实际串口设定，如果擦除的速度过快（不到1S），很可能没有完全擦除，这是可以再擦除一次。擦除时和刷固件一样，需要保持按住Flash按键然后再按下并释放RESET按键，然后在进行擦除。

在Linux下：esptool.py --port /dev/ttyUSB0 erase_flash 在Windows下：c:\Python27\Scripts\esptool.py --port /COM9 erase_flash

中间人攻击-简单窃听

Mon, 26 Feb 2018 00:00:00 GMT

0x01前提#

攻击者与目标要位于同一路由网络下

使用工具：kali linux（ettercap+wireshark+dsniff）

（本教程仅用于学术交流）#

0x02过程#

终端输入echo 1 > /proc/sys/net/ipv4/ip_forward开启转发保证目标能正常上网

一。开启嗅探#

终端输入ettercap -G打开ettercap界面，选择Sniff –> Unified sniffing –> 选择你对应的网卡 –> Hosts –> Scan for hosts –> Hosts list –> 将目标ip添加到Target 1，将路由器ip添加到Target 2 –> Mitm –> APR poisoning –> Sniff remote connections –> Start –> Start sniffing

二。监听数据#

终端输入driftnet -i eth0（我嗅探使用的网卡是eth0，具体情况具体填写），弹出一个窗口会显示目标正在浏览的图片。

终端输入urlsnarf -i eth0 监听目标浏览过的网页日志。

打开wireshark进行抓包。

new一个对象的引用在循环里与循环外的区别

Wed, 14 Feb 2018 00:00:00 GMT

1
for(int i=0;i<100;i++){
2
Object obj = new Object();
3
}
4

5

6
Object obj;
7
for(int i=0;i<100;i++){
8
obj  = new Object();
9
}

以上分别为在循环里与循环外new对象。

在循环里就相当于为100个引用了100个对象分配内存，直到内存不足会被GC释放。

在循环外使用1个引用分别100次调用了100个对象所以当后一个对象init后，前一个对象已经是“无引用状态”，会很快的被GC自动回收(在你的循环还未结束时，可能已经进行了多次GC回收，这点很重要)。

也就是说第二种方法能更好的管理内存。

Android自带抽屉布局及NavigationView的使用

Wed, 14 Feb 2018 00:00:00 GMT

转自：https://segmentfault.com/a/1190000004151222

获取NavigationView的中的控件出现空指针异常我们在Navigation Drawer Activity中获取控件，第一反应就是直接在onCreateView里调用findViewById,例如我想获取上图中的TextView，假如id为tv_user

1
TextView tv = (TextView)findViewById(R.id.tv_user);

然后给tv改下字

1
tv.setText("Hello world");

这时候就会报错说tv为空指针。问题引起其实非常简单，是因为在activity刚创建的时候，Dawer其实是没有打开的，所以布局没有初始化，自然也不能找到其中的空间。一般这种情况我们为了获取这类未初始布局里的空间会使用inflate方法，这里其实处理是类似的，后面会提到。

我们首先了解一下NavigationView的使用，新建一个抽屉活动后，我们可以看到主界面的布局文件是这样的

1
    <?xml version="1.0" encoding="utf-8"?>
2
    <android.support.v4.widget.DrawerLayout xmlns:android="http://schemas.android.com/apk/res/android"
3
        xmlns:app="http://schemas.android.com/apk/res-auto"
4
        xmlns:tools="http://schemas.android.com/tools"
5
        android:id="@+id/drawer_layout"
6
        android:layout_width="match_parent"
7
        android:layout_height="match_parent"
8
        android:fitsSystemWindows="true"
9
        tools:openDrawer="start">
10

11
        <include
12
            layout="@layout/app_bar_main"
13
            android:layout_width="match_parent"
14
            android:layout_height="match_parent" />
15

16
        <android.support.design.widget.NavigationView
17
            android:id="@+id/nav_view"
18
            android:layout_width="wrap_content"
19
            android:layout_height="match_parent"
20
            android:layout_gravity="start"
21
            android:fitsSystemWindows="true"
22
            app:headerLayout="@layout/nav_header_main"
23
            app:menu="@menu/activity_main_drawer" />
24

25
    </android.support.v4.widget.DrawerLayout>

展开收起

其实这里的NavigationView就是左边抽屉拉出来后的布局了~可以看到它有两个属性app:headerLayout和app

其实这两个属性后面就分别是上图中蓝色背景部分的抽屉头和下面的菜单。要对其编辑也很简单，进入ID对应的布局修改即可。

操作1：前面提到的获取不到控件的方法，可以在onCreate方法中这样来获取

1
    View headerLayout = navigationView.inflateHeaderView(R.layout.nav_header_main);
2
    tv_nav_user = (TextView)headerLayout.findViewById(R.id.tv_nav_username);

通过查看谷歌官方开发文档我们还可以发现几个方法 http://developer.android.com/reference/android/support/design/widget/NavigationView.html

这时会发现有两个头，解决方法也很简单，就是在layout文件中去掉

1
app:headerLayout="@layout/nav_header_main"

然后就可以获取到里面的控件愉快玩耍了~

补充：其实如果不用上面的方法的话也是可以直接获取到header的，可以调用

1
View headerView = navigationView.getHeaderView(0);

来获得头部布局

Weevely 介绍

Fri, 02 Feb 2018 00:00:00 GMT

0x0前言

Weevely is a stealth PHP web shell that simulate telnet-like connection. It is an essential tool for web application post exploitation, and can be used as stealth backdoor or as a web shell to manage legit web accounts, even free hosted ones.

Weevely是一个用python写的一个作用于php的web shell工具，可以很好帮助开发者进行开发，但是它又是一个很好的php后门程序。

（仅用于安全学习教学之用，禁止非法用途）

项目地址：https://github.com/epinna/Weevely

环境：python>= 2.7.10

linux环境安装：

Terminal window

1
# Make sure that the python package manager and yaml libraries are installed
2
$ sudo apt-get install g++ python-pip libyaml-dev python-dev libncurses5-dev
3
# Install requirements from within the weevely3/ folder
4
$ cd weevely3/
5
$ sudo pip install -r requirements.txt --upgrade

OS X环境安装：

Terminal window

1
$ sudo port install python27 py27-pip
2
$ sudo port select --set pip pip27
3
$ sudo port select --set python python27
4
# Ideally, at this point you should install editline library (http://thrysoee.dk/editline/)
5
# to have a working line completion in terminal. See issue #7 for more info.
6
# Install requirements from within the weevely3/ folder
7
$ cd weevely3/
8
$ sudo pip install -r requirements.txt --upgrade

Windows环境安装：

Terminal window

1
# Enter in a folder which allows to call pip.exe usually C:\Python27\Scripts\ with no %PATH% set and
2
# install the following requirements
3
> pip install prettytable Mako PyYAML python-dateutil pyreadline PySocks --upgrade

0x1生成后门文件#

可以生成三种文件后门：

php（生成php后门文件）
img（将后门代码插入到图片中，并修改.htaccess，该后门需要服务器开启.htaccess）
htaccess（将后门代码插入到.htaccess，同样需要开启.htaccess支持）

使用：

格式：weevely generate <password> <path>

例子：weevely generate mypassword ~/test.php（生成了一名为“test.php”密码为“mypassword”的php后门。最好在文件名前加路径，不然可能生成的文件在weevely的根目录下）

weevely generate mypassword ~/test.jpg（生成了一名为“test.php”密码为“mypassword”的图片后门）

0x2连接#

格式：weevely <URL> <password> [cmd]

例子：weevely http://127.0.0.1/test.php mypassword（连接了php后门。连接img或htaccess后门需要开启服务器对htaccess的支持）

0x3操作#

连接成功后即可对服务器进行相应操作。

－audit.userfiles 枚举用户目录下的具有权限的文件（可加载用户字典），默认情况下字典很小（注意：该模块目前只支持linux，windows不支持）

－audit.systemfiles [logs|root|home|…] 枚举各种系统目录并寻找可读写的目录，模块仅默认搜索部分linux下的常见目录，logs、root、home等等（注意：该模块也仅支持linux，windows不支持）

－audit.phpconf 查看php配置信息

－audit.etcpasswd [-real] 查看/etc/passwd文件（特殊说明：很多命令的-vector参数是用以指定php执行命令函数的，当默认函数不可用是，使用该参数来尝试指定其他命令执行函数来获取信息），同时也可使用-real参数来过滤出真实用户

－audit.mapwebfiles 从制定url开始爬取目标站点结构，可用-depth参数来指定爬取深度

－shell.sh/shell.php 利用接口执行命令，和虚拟终端类似

－system.info 在weevely里比较由用的一个模块，可以获取到系统的基本信息

－backdoor.reverstcp host port [-vector] 反弹一个tcp shell到目标端口（同样也可指定向量：选择反弹shell的形式，nc，perl，ruby等）

－backdoor.tcp -port <listen_port> -no-connect [-vector] 在本地打开一个端口，等待连接（查看了该模块的源码，使用时必须带上-no-connect才能监听成功，负责他会在本地形成一个tcp环路）

－net.ifaces 查看网络ip地址

－file.upload lpath rpath 上传本地文件到目标站点指定路径

－file.rm filename [-recursive] [-vector] 删除指定文件，可开启安全确认模式

－file.check 用以检查目标站点下文件的状态（md5值，大小，权限等）

－file.download rpath lpath [-vector] 将目标站点上的文件下载到本地（可用于批量会话操作）

－file.edit filename 对指定文件进行编辑

－file.read filename 读取指定文件内容

－file.ls path 列觉指定路径的文件信息

－file.upload2web 将本地文件上传至目标站点文件夹（可自动枚举到一个可写目录将其写入）

－file.webdownload <webfile_path> filename 从其他服务器上下载文件到目标站点

－file.touch rpath 创建一个新文件

－bruteforce.sql 爆破指定数据库用户名密码

－bruteforce.sqlusers 爆破所有数据库用户密码

－sql.dump 脱裤，你懂的 ^_^

－sql.console sql交互式终端

－net.scan 端口扫描

－find.perms 搜索具有读、写、执行权限的文件，好像比较给力

－find.suidsgid 搜索linux具有suid或者sgid标记的文件

－find.name 查找某文件或者文件夹

延时拍照

Fri, 05 Jan 2018 00:00:00 GMT

1
import os
2
import time
3

4
def main():
5
    i = 0
6
    while i < 1000:
7
        res = "raspistill -t 1 -o img/"+str(i)+".jpg"
8
        # os.system(res)
9
        print(res)
10
        i += 1
11
        time.sleep(1)
12

13

14
if __name__ == '__main__':
15
    main()

展开收起

Python项目打包成exe文件

Mon, 18 Dec 2017 00:00:00 GMT

[转]https://note.youdao.com/share/?id=4ed1687d752255b2f44b34bab3c719a8&type=note#/

CMD下输入:py -m pip install pyinstaller，安装pyinstaller。

在要制作的exe文件目录输入pyinstaller -F -w *.py，就可以制作出exe。生成的文件放在同目录dist下。 -F（注意大写）是所有库文件打包成一个exe -w是不出黑色控制台窗口。不加-F参数生成一堆文件，但运行快。压缩后比单个exe文件还小一点点。加-F参数生成一个exe文件，运行起来慢。按照第一步的方法，将pyinstaller加入pycharm的external tool，我加了两个，一个生成单独exe文件，一个生成运行带库的程序目录。

frp开机启动与自动检查运行脚本(Python)

Fri, 08 Dec 2017 00:00:00 GMT

1
#!/bin/python
2
import os
3
import time
4
import commands
5

6
##开启frp
7
def start():
8
    os.system('/home/pi/frp/frpc -c /home/pi/frp/frpc.ini > /dev/null 2>&1 &')
9

10
##检查是否运行frp
11
def state():
12
    out=commands.getoutput('ps aux|grep frpc|grep -v grep')
13
    return out
14

15
def main():
16
    while(True):
17
        if "-c" in state() :
18
            pass
19
        else:
20
            start()
21
            time.sleep(15)      ##休眠15秒后再次检查
22
if __name__ == '__main__':
23
    time.sleep(15)        ##开机后延时15秒
24
    main()

展开收起

树莓派配置迅雷远程下载

Mon, 04 Dec 2017 00:00:00 GMT

0x01.配置#

所用固件为Xware1.0.31_armel_v5te_glibc固件，下载链接: https://pan.baidu.com/s/1jI7YmEi 密码: gxxv

下载

首先在/mnt建立一个新文件夹：

Terminal window

1
sudo mkdir /mnt/thunder

将下载文件存放目录挂载在刚刚建的文件夹下：

Terminal window

1
sudo mount --bind /home/pi/download /mnt/thunder(解除挂载只需将--bind换为--move即可)

将下载好的固件解压并运行portal文件：

Terminal window

1
sudo chmod +x ./portal
2

3
./portal

运行后找到the active code is复制后面的激活码，等迅雷远程下载进行绑定。

0x02.查看状态#

同一局域网下浏览器输入：

1
http://树莓派ip:9000/getsysinfo

其中有用的几项为：

第一项：0表示返回结果成功第二项：1表示检测网络正常，0表示检测网络异常第四项：1表示已绑定成功，0表示未绑定第五项：未绑定的情况下，为绑定的需要的激活码第六项：1表示磁盘挂载检测成功，0表示磁盘挂载检测失败

0x03.迅雷路由器固件开机启动#

在/etc/init.d/下新建xunlei脚本，写入:

1
#!/bin/sh
2
#
3
# Xunlei initscript
4
#
5
### BEGIN INIT INFO
6
# Provides: xunlei
7
# Required-Start: $network $local_fs $remote_fs
8
# Required-Stop:: $network $local_fs $remote_fs
9
# Should-Start: $all
10
# Should-Stop: $all
11
# Default-Start: 2 3 4 5
12
# Default-Stop: 0 1 6
13
# Short-Description: Start xunlei at boot time
14
# Description: A downloader
15
### END INIT INFO
16

17
do_start()
18
{
19
./root/xunlei/portal
20
}
21

22
do_stop()
23
{
24
./root/xunlei/portal -s
25
}
26

27
case "$1" in
28
start)
29
do_start
30
;;
31
stop)
32
do_stop
33
;;
34
esac

展开收起

然后将该脚本加入默认自启动中

Terminal window

1
update-rc.d xunlei defaults

Linux开机启动脚本编写

Mon, 04 Dec 2017 00:00:00 GMT

两种方法：#

0.编写rc.loacl脚本#

Ubuntu开机之后会执行/etc/rc.local文件中的脚本，所以我们可以直接在/etc/rc.local中添加启动脚本。要添加到语句exit 0 前面才行。此脚本在完全开机后才执行，所以优先级最低。

1.编写init.d脚本#

在/etc/init.d建立脚本，然后用软链接链接到rc?.d文件夹中。

1
/etc  下有 rc0.d  -- rc6.d
2

3
分别代表不同的级别：
4

5
0: 关闭计算机
6
1: 单用户模式
7
2: 无网络多用户模式
8
3: 有网络多用户模式
9
4: 保留作自定义，否则同运行级 3
10
5: 同运行级 4，一般用于图形界面(GUI)登录(如 X的 xdm 或 KDE的 kdm)
11
6: 重启动计算机

在 /etc/rc?.d 每个目录下都包含许多符号链接，其中一些以 K 字母开头，另外一些以 S 字母开头，这些链接名在首字母后面都跟着两个数字。这个 K 的含义是停止 (kill) 一个服务， S 的含义是启动一个服务。而数字则确定这些脚本的启动顺序，从 00 到 99(数字越小执行的越早)。当 init 转换到其它运行级时，一些相应的服务会停止，而另一些服务则会启动。

真正的脚本在 /etc/init.d 目录下，它们完成实际工作，符号链接都是指向它们的。停止脚本的链接和启动脚本的链接都指向 /etc/init.d 目录下的同一个脚本。这是因为调用这些脚本时可以使用不同的参数，例如 start, stop, restart, reload, 和 status。当调用 K 链接时，相应的脚本用 stop参数运行；当调用 S 链接时，相应的脚本用start 参数运行。

上面的说明有一个例外，在 rc0.d 和 rc6.d 目录下以 S 开头的链接不会启动任何东西，而是用stop参数调用，来停止某些服务。这背后的逻辑是，当用户要重启或关闭系统的时候，不会要启动什么服务，只会要系统停止。

以下是脚本参数的描述：

start 启动服务。 stop 停止服务。 restart 关闭服务，然后再启动。 reload 该服务的配置已更新。如果修改了某个服务的配置文件，又不必重启这个服务的时候，可以使用这个参数 status 显示服务的状态，如果服务正在运行，会显示该服务进程的 PID 。

您可以自由修改启动进程工作的方式。我们这里给出的文件只是它们怎样工作的一个示例而已。

脚本实例：

1
    #!/bin/sh
2
    #chkconfig:2345 80 05 --指定在哪几个级别执行，0一般指关机，6指的是重启，其他为正常启动。80为启动的优先级，05为关闭的优先级别
3
    #description:simple example service
4
    RETVAL=0
5
    start(){ #启动服务的入口函数
6
        echo  "simple example service is started..."
7
    }
8

9
    stop(){ #关闭服务的入口函数
10
        echo  "simple example service is stoped..."
11
    }
12

13
    #使用case选择
14
    case $1 in
15
    start)
16
        start  #调用上面的start函数
17
    ;;
18
    stop)
19
        stop   #调用上面的stop函数
20
    ;;
21
    *)
22
        echo "error choice ! please input start or stop";;
23
    esac
24
    exit $RETVAL

展开收起

Terminal window

1
# chmod +x /etc/init.d/bin.sh //加可执行权限

Terminal window

1
# /etc/init.d/bin.sh start //测试

将启动脚本链接到 /etc/rc2.d

Terminal window

1
# ln -s /etc/init.d/bin.sh /etc/rc2.d/S20bin //作用：开机启动时会执行 /etc/init.d/bin.sh start
2

3
# ln -s /etc/init.d/bin.sh /etc/rc0.d/K20bin
4
//作用： 关闭计算机时执行 /etc/init.d/bin.sh stop

2.当上一中没效果是可以试试这个脚本还是上一个的脚本，但链接方法有变。使用：update-rc.d xxx defaults NN命令(NN为启动顺序)，将脚本添加到初始化执行的队列中去。注意如果脚本需要用到网络，则NN需设置一个比较大的数字，如99。

将你的启动脚本复制到 /etc/init.d目录下以下假设你的脚本文件名为 test。
设置脚本文件的权限
执行如下命令将脚本放到启动脚本中去：

Terminal window

1
$ cd /etc/init.d
2
$ sudo update-rc.d test defaults 95

注：其中数字95是脚本启动的顺序号，按照自己的需要相应修改即可。在你有多个启动脚本，而它们之间又有先后启动的依赖关系时你就知道这个数字的具体作用了。该命令的输出信息参考如下：

1
update-rc.d: warning: /etc/init.d/test missing LSB information
2
update-rc.d: see <http://wiki.debian.org/LSBInitScripts>
3
Adding system startup for /etc/init.d/test ...
4
/etc/rc0.d/K95test -> ../init.d/test
5
/etc/rc1.d/K95test -> ../init.d/test
6
/etc/rc6.d/K95test -> ../init.d/test
7
/etc/rc2.d/S95test -> ../init.d/test
8
/etc/rc3.d/S95test -> ../init.d/test
9
/etc/rc4.d/S95test -> ../init.d/test
10
/etc/rc5.d/S95test -> ../init.d/test

卸载启动脚本的方法：

Terminal window

1
$ cd /etc/init.d
2
$ sudo update-rc.d -f test remove

命令输出的信息参考如下：

1
Removing any system startup links for /etc/init.d/test ...
2
/etc/rc0.d/K95test
3
/etc/rc1.d/K95test
4
/etc/rc2.d/S95test
5
/etc/rc3.d/S95test
6
/etc/rc4.d/S95test
7
/etc/rc5.d/S95test
8
/etc/rc6.d/K95test

树莓派U盘/移动硬盘安装系统

Sun, 03 Dec 2017 00:00:00 GMT

之前都是用TF烧录系统来作为树莓派的系统盘，后来发现可以用BerryBoot来作为引导来用U盘/移动硬盘安装系统，但是berryboot需要用一张TF来作为引导盘。这时树莓派官方给出了一种方案可以直接从U盘/移动硬盘安装系统。

在树莓派3从u盘启动之前，需要从设置了使能usb boot mode的sd启动。该设置树莓派芯片上的OTP（一次性可编程内存），这将使得树莓派能够从usb设备启动。一旦设置了该选项，sd卡就不需要了。注意，OTP一旦做出任何改动，都不能复原。你可以使用运行raspbian或者raspbian lite的sd卡来设置OTP,如果你还没有这样的sd卡，可按常规方式将系统烧入sd卡（推荐使用Etcher）。

Terminal window

1
sudo apt-get update && sudo apt-get upgrade

然后，输入以下代码使能usb boot mode

Terminal window

1
echo program_usb_boot_mode=1 | sudo tee -a /boot/config.txt

这行代码将program_usb_boot_mode=1插入到/boot/cinfig.txt文件的末尾。使用sudo reboot命令重启树莓派后，用以下命令检查OTP设置：

Terminal window

1
vcgencmd otp_dump | grep 17:

确保输出是17:3020000a，如果输出不是这个，那就说明OTP没有设置成功。之后，你可以在sd卡的config.txt末尾去掉program_usb_boot_mode=1这行代码，这样把这张sd用在其他树莓派上就不会设置OTP，注意，config.txt文件结尾不能有空行. 你可以直接将img镜像拷贝到usb存储设备，sd卡，u盘。其他系统按常规方式写入存储介质。

做完这些，你就可以把usb存储设备插入树莓派了。

在完成以上工作后，给树莓派上电，经过5到10秒，树莓派就开始启动了。

Android隐藏标题栏代码失效

Fri, 03 Nov 2017 00:00:00 GMT

相信很多android入门教程中隐藏状态栏都用到：requestWindowFeature(Window.FEATURE_NO_TITLE);但是有时候这代码无效，这是因为这句代码只能用在继承Activity的activity中，而现在AndroidStudio大多默认创建继承AppCompathActivity的activity.

解决方法：

（1）将AppCompatActivity改为Activity，此时 requestWindowFeature(Window.FEATURE_NO_TITLE);是有效的。

（2）换用getSupportActionBar().hide();注意：去掉标题栏注意这句一定要写在setContentView()方法的后面

OkHttp3基本用法(一)

Thu, 26 Oct 2017 00:00:00 GMT

依赖包#

首先添加jar包，或着用maven或gradle自动导包。（我用的是3.9.1的包，自动导包时注意实际情况） maven:

1
<dependency>
2
  <groupId>com.squareup.okhttp3</groupId>
3
  <artifactId>okhttp</artifactId>
4
  <version>3.9.1</version>
5
</dependency>

gradle:

1
compile 'com.squareup.okhttp3:okhttp:3.9.1'

注意：还需要okio的包 maven:

1
<dependency>
2
  <groupId>com.squareup.okio</groupId>
3
  <artifactId>okio</artifactId>
4
  <version>1.13.0</version>
5
</dependency>

gradle:

1
compile 'com.squareup.okio:okio:1.13.0'

GET请求#

1
String path="http://rehtt.cn"; OkHttpClient okHttpClient=new OkHttpClient(); Request request=new Request.Builder()         .url(path)
2
//如果要在request的的header添加参数。例如Cookie，User-Agent什么的：
3
        .header("键", "值")
4
         .header("键", "值")
5

6
        .build(); Call call=okHttpClient.newCall(request); try {
7
    Response response = call.execute();
8
    Log.i("返回：",response.body().string()); //返回网页body标签内容
9
//body()有多种输出方法，如果是下载文件就是response.body().bytes()，response.code()获取返回的状态码
10
} catch (IOException e) {
11
    e.printStackTrace();
12
}

POST请求#

post请求与get请求几乎一样，只是post需要提交表单，使用RequestBody。

RequestBody的数据格式都要指定Content-Type，常见的有三种：

application/x-www-form-urlencoded 数据是个普通表单 multipart/form-data 数据里有文件 application/json 数据是个json

普通表单：#

1
RequestBody body = new FormBody.Builder()
2
         .add("键", "值")
3
         .add("键", "值")
4
         ...
5
         .build();

文件表单：#

1
RequestBody requestBody = new MultipartBody.Builder()
2
         .setType(MultipartBody.FORM)
3
         .addFormDataPart("file", file.getName(),RequestBody.create(MediaType.parse("image/png"), file))
4
         .build();

另外如果你上传一个文件不是一张图片，但是MediaType.parse(“image/png”)里的”image/png”不知道该填什么，可以参考这个。

JSON表单：#

1
MediaType JSON = MediaType.parse("application/json; charset=utf-8");
2
RequestBody body = RequestBody.create(JSON, "传入的json");

同步与异步#

上文采用call.execute()执行http请求，但这是一个同步动作，是在主线程运行的。如果在UI线程执行就会抛异常。

所以在UI线程执行就要用异步，将call.execute()替换：

1
call.enqueue(new Callback() {
2
    @Override
3
//请求失败调用
4
    public void onFailure(Call call, IOException e) {
5

6
    }
7
    @Override
8
//请求成功调用
9
    public void onResponse(Call call, Response response) throws IOException {
10
        Log.e("返回：",response.body().string());
11
    }
12
});

onFailure()和onResponse()是在异步线程里执行的，所以如果你在Android把更新UI的操作写在这两个方法里面是会报错的，这个时候可以用runOnUiThread这个方法。

在debian上vbox虚拟机usb设备无法显示问题解决

Tue, 03 Oct 2017 00:00:00 GMT

问题原因是当前用户没有包含在vbox用户组里，所以解决方法就是将当前用户添加进vbox的用户组。

我当前用户名是rehtt，将当前用户添加进vbox用户组：

Terminal window

1
usermod -a -G vboxusers rehtt

重启后即可解决。

samba服务器配置

Mon, 02 Oct 2017 00:00:00 GMT

samba是一个文件共享服务器。

Terminal window

1
apt install samba samba-common-bin

使用samba需要开启137,138,139,389,445,901端口。

samba配置文件在/etc/samba/smb.conf

在文件最后添加：

1
[global]
2
    server string = Samba Server Version %v
3
    passdb backend = tdbsam
4
    cups options = raw
5
    security = user                            #认证模式为User
6
    map to guest = bad user            #这个很关键，实现匿名无须交互输入用户名和密码就靠它了
7
    guest account = guest               #匿名用户映射为guest用户
8

9
[myshare]                                       #显示名称
10
    comment = My share
11
    path = /home/public                       #共享路径
12
    browseable = Yes                          #可以被浏览，就是在网络邻居中能看到共享名
13
    read only = No                               #可读写
14
    guest ok = Yes                               #允许匿名访问，这个也需要设置，否则匿名无法访问
15
    valid users = samba liuag guest    #有效的用户和组
16
    invalid users = liuben                     #无效用户和组
17
    read list = samba                           #只读用户和组(如果read only = No，只读用户需要在此设置)
18
    write list = liuag                             #可读写用户和组(如果read only = Yes，可读写用户需要在此设置)
19
    allow hosts = 192.168.100.236     #允许访问主机列表，支持通配符
20
    deny hosts = 192.168.100.0/24    #禁止访问主机列表，支持通配符
21

22
[MyNAS]
23
    # 说明信息
24
    comment = NAS Storage
25
    # 可以访问的用户
26
    valid users = pi,root
27
    # 共享文件的路径,raspberry pi 会自动将连接到其上的外接存储设备挂载到/media/pi/目录下。
28
    path = /media/pi/
29
    # 可被其他人看到资源名称（非内容）
30
    browseable = yes
31
    # 可写
32
    writable = yes
33
    # 新建文件的权限为 664
34
    create mask = 0664
35
    # 新建目录的权限为 775
36
    directory mask = 0775

展开收起

可以把配置文件中你不需要的分享名称删除，例如 [homes], [printers] 等。

测试配置文件是否有错误，根据提示做相应修改

Terminal window

1
testparm

添加登陆账户并创建密码，必须是 linux 已存在的用户

Terminal window

1
smbpasswd -a pi

重启 samba 服务

Terminal window

1
/etc/init.d/samba restart

测试回到windows，就可以在网络当中发现共享的文件夹了

穿透内网思路(vpn方法)

Sun, 01 Oct 2017 00:00:00 GMT

首先需要一台位于外网且拥有外网ip的服务器
在外网服务器上搭建vpn服务器和反向代理服务器
内网服务器连上外网服务器的vpn
外网服务器根据vpn地址反向代理到内网服务器

树莓派温控风扇脚本（使用三极管 s8050）

Tue, 26 Sep 2017 00:00:00 GMT

这里均以s8050为开关，s8050为NPN型三极管，以平的那面为参考面，左边阵脚接电源正极，中间针脚为开关，右边阵脚接电源负极

不控速风扇：

1
#!/usr/bin/python
2
#coding:utf-8
3
import time
4

5
import RPi.GPIO as GPIO
6

7
#这里选择14（BCM）号针脚作为开关
8
GPIO_OUT = 14
9

10
def setup_GPIO():
11
    GPIO.setmode(GPIO.BCM)
12
    GPIO.setwarnings(False)
13
    GPIO.setup(GPIO_OUT, GPIO.OUT)
14

15
#开启风扇
16

17
def start_fan():
18
    GPIO.output(GPIO_OUT,GPIO.HIGH)
19

20
#关闭风扇
21

22
def stop_fan():
23
    GPIO.output(GPIO_OUT,GPIO.LOW)
24

25
#获取cpu温度
26

27
def cpu_temp():
28
    tempFile=open("/sys/class/thermal/thermal_zone0/temp")
29
    cpu_temp=tempFile.read()
30
    tempFile.close()
31
    temp_c=(int(cpu_temp)/1000)
32
    return int(temp_c)
33

34
#若温度大于等于55度开启风扇，小于等于45度关闭扇。中间相差温度作为缓冲，不然风扇就会一会开一会关。
35

36
def fen():
37
    if cpu_temp()>=55:
38
        start_fan()
39
        fen_state(1)
40

41
    elif cpu_temp()<=45:
42
        stop_fan()
43
        fen_state(0)
44

45
    else:
46
        pass
47

48
def fen_state(state):
49
    f=open("/etc/startup-script/state.txt")
50
    file=f.readlines()
51
    i=0
52
    for line in file:
53
        line = line.strip("\n")
54
        v = line.split(":")
55
        if v[0] == "fen_state":
56
            file[i] = "fen_state:"+str(state)
57
            break
58
        i=i+1
59
    f=open("/etc/startup-script/state.txt",'w+')
60
    f.writelines(file)
61
    f.close()
62

63

64

65
if __name__ == '__main__':
66
    setup_GPIO()
67
    fen_state(0)
68
    while True:
69
        fen()
70
        time.sleep(5)

展开收起

控速风扇：

1
#!/usr/bin/env python
2
# encoding: utf-8
3
import RPi.GPIO as GPIO
4
import time
5

6
#以14号(BCM)阵脚为开关
7
GPIO_OUT = 14
8
GPIO.setmode(GPIO.BCM)
9
GPIO.setwarnings(False)
10
GPIO.setup(GPIO_OUT,GPIO.OUT)
11
pwm = GPIO.PWM(GPIO_OUT, 100)
12

13
speed=0
14
prv_temp=0
15
try:
16
    while True:
17
        tmpFile=open('/sys/class/thermal/thermal_zone0/temp')
18
        cpu_temp=int(tmpFile.read())/1000
19
        tmpFile.close()
20
        if cpu_temp >= 34:
21
            if prv_temp < 34:
22
            # 启动时防止风扇卡死先全功率转0.1秒
23
                pwm.start(0)
24
                pwm.ChangeDutyCycle(100)
25
                time.sleep(.1)
26
            speed=min(cpu_temp, 100)
27
            pwm.ChangeDutyCycle(speed)
28
    else:
29
        pwm.stop()
30
    prv_temp=cpu_temp
31
    time.sleep(5)
32
except KeyboardInterrupt:
33
    pass
34
pwm.stop()

展开收起

关于/etc/init.d目录与/etc/rc.local脚本

Sun, 24 Sep 2017 00:00:00 GMT

它们都是linux自启动文件，区别在于/etc/rc.local是在系统初始化之后才执行，而/etc/init.d里面的是系统初始化级别脚本。

执行级别：/etc/init.d > /etc/rc.local

Berryboot安装

Sat, 23 Sep 2017 00:00:00 GMT

BerryBoot是一款基于树莓派启动的启动管理工具，它最大的优势是可以在不通过SD卡的前提下在多个系统中选择启动，你既可以将系统存放在卡上，也可以, 如果你需要更多空间的话，将系统运行在外接的硬盘上并配置BerryBoot只将SD卡作为一个启动器。

也就是说berryboot是一个系统启动的引导。

步骤：

官网下载berryboot
解压并放入sd内
通电开机

参考：http://shumeipai.nxez.com/2014/01/25/use-berryboot-make-raspberry-pi-supports-multi-system-boot.html

nextcloud/owncloud网页版设置中文

Fri, 22 Sep 2017 00:00:00 GMT

在页面的语言设置中只有”English”选项，这个问题是php的scandir()函数被禁用而导致的。

解决方法：编辑php.ini文件，找到”disable_functions”，并删除其中scandir，最后重启php服务即可。

Rehtt's Blog

【NFC】恢复被写入cpu卡SAK的CUID魔术卡

0x00#

0x01#

【脚本】在jetson nano上使用摄像头分段录像并开启端口推流

【杂项】ssh隐匿登录

0x01 清除 Bash 命令历史记录#

说明：#

0x02 隐藏登录 IP 地址#

方法一：删除 lastlog 文件#

注意事项：#

方法二：通过 SSH 端口转发隐藏真实 IP#

原理：#

0x03 清理认证日志（auth.log）#

删除包含指定 IP 的日志行：#

替代方法：使用 grep 过滤并重写文件#

对于使用 systemd 的系统：#

0x04 清除 wtmp 与 btmp 登录记录#

清空日志文件：#

替代方式（谨慎使用）：#

0x05 隐藏进程痕迹#

检测当前进程：#

隐藏进程名称：#

0x06 结语#

【Golang】xlsx.row to struct slice

0x00#

代码#

测试用例#

【杂项】tmpfs

blog-tmpfs#

0x00#

0x01#

Linux挂载tmpfs#

MacOS挂载#

【杂项】常用正则匹配备忘（持续更新）

找出没有包含“数值”的句子#

【杂项】搜集各种好用的库(不定时更新)

Golang#

前端#

Windows Shell#

Android#

Python#

杂项#

Gorm1.25.7 同时使用joins与preload获取列表 报错 reflect: call of reflect.Value.Field on slice Value

触发错误#

触发原因#

解决办法（2024-03-04）#

【linux】目录

0x00#

0x01#

好用的工具

Linux#

CLI工具#

speedometer 显示网卡接口出入流量速度#

btop/bashtop/bpytop 比htop更全面更炫酷的资源显示#

s-tui CPU温度显示#

macchanger 更改mac地址#

【备忘】nvimdots安装及配置（持续更新）

0x00#

0x01 准备#

0x02 安装#

0x03 配置#

【Linux】使用Go开发PAM模块

0x0 前言#

0x1 准备#

0x2 开发 PAM 认证模块#

函数说明#

代码文件#

编译#

0x3 使用#

【Linux】使用cryptsetup进行luks加密

0x00#

0x01 准备#

0x02 使用#

加密磁盘分区#

创建加密文件#

开机自动挂载#

【脚本】修改wireguard端口

【脚本】wireguard配合socat转发端口

0x0#

Gorm1.25.7 同时使用joins与preload获取列表报错 reflect: call of reflect.Value.Field on slice Value