时间从来不语，却回答了很多问题


命令行工具的使用问题
post @ 2022-11-12

当有很多个命令行工具时，每一个都添加一个$PATH环境变量有点不优雅。于是首先想到的办法是往固定路径创建软链接，例如：~/.local/bin。

但是，很多工具会根据当前工作路径来运行（例如生成配置文件），导致我们必须到工具所在路径下运行。因此我们可以创建脚本并传递命令行的参数来解决这两个问题。

接收命令行参数

手工处理

  • $0 : 在用sh 或者 ./执行脚本时，指的是脚本名，用source或.执行时，永运是bash，这也反应了sh 或者 ./执行脚本的原理和source的方式是不同的.
  • $1 : -v,第一个参数.
  • $2 : -f
  • $3 : -out
  • $4 : /test.log
  • 依次类推 $5 $6 …
  • $# : 参数的个数，不包括命令本身，上例中$#为5.
  • $@ : 参数本身的列表，也不包括命令本身，如上例为 -v -f -out /test.log –prefix=/home
  • $* : 参数本身的列表，也不包括命令本身，但”$*” 和”$@”(加引号)并不同，”$*“将所有的参数解释成一个字符串，而”$@”是一个参数数组。如下例所示：

编写脚本

在固定路径中创建脚本，例如~/.local/bin/xxx

1
2
3
#!/bin/zsh
cd /path/to/program
./program_name $@

这样，就可以实现任意地方调用命令行工具。

第二种方法

阅读全文


浅谈Android攻防
post @ 2022-11-06

无论是渗透测试还是逆向工程，移动安全都是一个重要的领域。在实际攻防过程中对移动端进行详尽的信息收集与渗透往往能大大扩展渗透测试的攻击面。

Android安全设计与架构

谷歌对Android系统的更新非常频繁，并且非常重视其安全性，因此如今的Android系统拥有非常多的安全机制。

Android总体架构分为5个层次：Android应用层，Android框架层，Dalvik虚拟机层，用户空间原生代码层，Linux内核层。

以下是来自 Android 开发人员网站的 Android 架构的图形表示：

image-20221106190835428

Android应用层允许开发者无需修改底层代码就能对设备的功能进行扩展和提升，框架层提供大量的访问Android设备所需的API，两者都是由Java开发，并且在DalvikVM中运行。

DalvikVM是一种基于寄存器的虚拟机，为底层操作系统提供了一个高效的抽象层，可以解释执行Dalvik至此的（DEX）字节码，同时依赖于一些支持性原生代码程序库提供的功能。

Android流量分析

无安全防护的应用流量分析

阅读全文


渗透测试方法论
post @ 2022-10-16

理论指导实践

PTES（渗透测试执行标准）

The Penetration Testing Execution Standard

以下是PTES为渗透测试执行基础的主要部分：

  1. 事前互动
  2. 信息收集
  3. 威胁建模
  4. 漏洞分析
  5. 漏洞利用
  6. 深度利用
  7. 书面报告

通用渗透测试框架

  1. 范围界定
  2. 信息收集
  3. 目标识别
  4. 服务枚举
  5. 漏洞映射
  6. 社会工程学
  7. 漏洞利用
  8. 权限提升
  9. 访问维护（后门持久化）
  10. 文档报告

image-20221016211744206

渗透测试流程

信息收集

阅读全文


SQL注入总结
post @ 2022-10-04

Sqli-labs

项目地址：Audi-1/sqli-labs: SQLI labs to test error based, Blind boolean based, Time based.

环境信息：MySQL8.0.12，Nginx1.15.11，php5.6.9nts

参考文章：sqli-labs 通关详解（sql注入知识点整理）_51CTO博客_sqli-labs注入天书

Less-1

最基础的字符注入，可以使用如下语句来获取数据库信息：

测试是否有注入，存在报错

1
http://127.0.0.1/Less-1/?id='

测试注入

1
http://127.0.0.1/Less-1/?id=1' or 1=1 --+
阅读全文


文件上传总结
post @ 2022-09-30

Upload-labs

项目地址：https://github.com/c0ny1/upload-labs

上传漏洞类型

image-20221001005305992

靶机包含漏洞类型分类

image-20221001005001448

文件上传漏洞测试流程

  1. 对文件上传的地方按照要求上传文件，查看返回结果（路径，提示等）
  2. 尝试上传不同类型的“恶意文件”，比如xx.php文件，分析结果
  3. 查看html源码，看是否通过js在前端做了上传限制，可以绕过
  4. 尝试使用不同方式进行绕过：黑名单绕过/MIME类型绕过/目录0x00截断绕过等
  5. 猜测或者结合其他漏洞（比如敏感信息泄露等）得到木马路径，连接测试

参考文章：

upload-labs通关记录_mb5ff2f1c4b5e55的技术博客_51CTO博客

阅读全文


放弃WSL2使用VMware后台虚拟机
post @ 2022-09-25

之前一直使用WSL2，但是它存在几个问题：

  1. Windows需开启HyperV虚拟化平台，可能导致一定程度的性能损失
  2. vmware无法开启Intel VT-x虚拟化（使用Hyper-V API - 虚拟化），可能导致某些虚拟机运行缓慢。
  3. WSL2运行非原生完整Linux
  4. 无法连接宿主机USB等外接设备（或者很麻烦）

使用VMware

首先关闭WSL2，HyperV虚拟化平台等Windows功能，此处不赘述

在要长期运行的虚拟机目录创建一个bat脚本，内容如下：

1
"D:\path\to\VMware Workstation\vmrun.exe" -T ws start "D:\path\to\ubuntu22.vmx" nogui

在本地组策略编辑器下新建登录脚本

image-20220925180356789

image-20220925180415814

进入powershell运行以下命令

阅读全文


羊了个羊并发通关脚本
post @ 2022-09-19

接口

先重定向第二关的请求接口到第一关，开始游戏，所有关卡变成第一关，手动通关后抓包到通关接口

1
http://cat-match.easygame2021.com/sheep/v1/game/game_over?rank_score=1&rank_state=1&rank_time=15&rank_role=1&skin=1

token

获取token始终没找到请求记录，于是通过对咩咩羊-羊了个羊小工具的逆向工程得知以下过程：

游戏先请求user_info接口查询uid对应用户信息，然后通过响应的wx_open_id请求login_oppo接口获取token

uid在游戏右上角设置里

脚本

修改次数和uid就可以跑了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import requests, json
from threading import Thread

# 通关次数
num = 100000
# uid
uid = 你的uid

print(f"用户uid: {uid}\n通关次数: {num}")

# 获取用户open_id
r = requests.get(
    f"https://cat-match.easygame2021.com/sheep/v1/game/user_info?uid={uid}",
    headers={
        "t": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE2OTAwMjA0MDIsIm5iZiI6MTY1ODkxODIwMiwiaWF0IjoxNjU4OTE2NDAyLCJqdGkiOiJDTTpjYXRfbWF0Y2g6bHQxMjM0NTYiLCJvcGVuX2lkIjoiIiwidWlkIjoxMDAwMDEsImRlYnVnIjoiIiwibGFuZyI6IiJ9.NQZAWBLYtq6hBff9YjNcaI2Soa6Z5vwbIU7YnjP1KBQ",
    },
)
wx_open_id = json.loads(r.text)["data"]["wx_open_id"]

# 获取用户token
r = requests.post(
    "https://cat-match.easygame2021.com/sheep/v1/user/login_oppo",
    data={"uid": wx_open_id, "nick_name": "14633282", "avatar": "123123123", "sex": 1},
)
token = json.loads(r.text)["data"]["token"]


def j(i):
    r = requests.get(
        url="http://cat-match.easygame2021.com/sheep/v1/game/game_over?rank_score=1&rank_state=1&rank_time=15&rank_role=1&skin=2",
        headers={
            "Cookie": f"t={token}"
        },
    )
    if json.loads(r.text)["err_code"] == 0:
        print(f"{i}次通关")
    else:
        print(f"第{i}次通关失败!")

for i in range(num):
    t = Thread(target=j, args=[i])
    t.start()


阅读全文


zsh一键配置
post @ 2022-09-13

我的终端环境一直是用的zsh + oh-my-zsh + zsh-syntax-highlighting + zsh-autosuggestions + powerlevel10k的配置。安装很简单，这里直接把shell放在一起方便复用。

Install

安装前的准备：你需要安装好git，并配置好git、apt、wget的代理或镜像源设置。

为配合powerlevel10k的shell主题最好设置终端字体，详见 https://github.com/romkatv/powerlevel10k#Fonts

1
2
3
4
5
6
sudo apt install zsh
sh -c "$(wget https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh -O -)"
chsh -s /bin/zsh
git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting
git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions
git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k

完成后修改~/.zshrc的插件列表和主题

1
2
ZSH_THEME="powerlevel10k/powerlevel10k"
plugins=( [plugins...] zsh-syntax-highlighting zsh-autosuggestions)
阅读全文


随身wifi打造近源渗透神器
post @ 2022-08-29

前言

随身wifi，价格低廉，可以跑安卓、openwrt、debian

文章比较简略，感兴趣请参考底部链接

买的三个设备：

image-20220720222204727

分别是uz801、ufi001c、ufi003_mb方案

便宜的随身 Wi-Fi 基本用的都是工模的方案，像是高通的 410、高通的 210、中兴微等方案，外观差别可能很大，内在或许都是同一种方案（同一种方案具体的板子也会有不同），当然也会有可能同一个商品发给买家不同的型号。我们这里使用的只能是高通骁龙410的方案

板子上的丝印是 UFI001B、UFI001C、UFI003、UFI-W-001 最好，或者 SP970（不推荐，细分版本目前13个太多，基本要短接才能进 9008 模式，然后现在的 openwrt Wi-Fi 也有问题）、UZ801 也 OK；需要带卡槽、能切卡。

大部分都是4gb存储，uz801有几率买到8gb版本。

备份

阅读全文


2022蓝帽杯半决赛WP By Mammoth
post @ 2022-08-04

一个人做了所有题，说实话有点累，哎

RE

babynim

和初赛一样的nim语言逆向，die识别出了虚拟机保护但实际上关键代码没有保护，有之前的经验逆起来更简单了，就是输入的字符串转换成大数与一个常数相乘（还伪装得很像一个flag），结果与常数相等。

所以除一下就是flag了。

审计后的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
__int64 NimMainModule()
{
  FILE *stdio; // rax
  String *input; // rax
  __int64 *v2; // rdx
  String *input_copy; // rsi
  __int64 v4; // rdi
  __int64 checkhello3_copy; // rax
  __int64 index; // rbx
  String *pre_5_String; // rdi
  String *input_copy_copy; // rdi
  __int64 input_copy_len; // rdx
  __int64 v11; // rdx
  __int64 index_2; // rbx
  __int64 v13; // rcx
  String *flag_content_string; // rbp
  __int64 length; // rdx
  unsigned __int64 v16; // rsi
  __int64 star_des_copy; // rbx
  __int64 v18; // rdx
  unsigned __int64 v19; // rcx
  __int64 unknownProperty; // rdi
  __int64 *p_unknownProperty; // rdx
  __m128i tmp_si128_2; // [rsp+20h] [rbp-58h] BYREF
  __m128i tmp_si128_1; // [rsp+30h] [rbp-48h] BYREF
  __int64 star_des_1; // [rsp+40h] [rbp-38h] BYREF
  __int64 v25; // [rsp+48h] [rbp-30h]

  nimRegisterGlobalMarker(TM__xLHv575t3PG1lB5wK05Xqg_4);
  nimRegisterGlobalMarker(TM__xLHv575t3PG1lB5wK05Xqg_10);
  nimRegisterGlobalMarker(TM__xLHv575t3PG1lB5wK05Xqg_11);
  nimRegisterGlobalMarker(TM__xLHv575t3PG1lB5wK05Xqg_13);
  nimRegisterGlobalMarker(TM__xLHv575t3PG1lB5wK05Xqg_14);
  nimRegisterGlobalMarker(TM__xLHv575t3PG1lB5wK05Xqg_15);
  PutStdio(&TM__xLHv575t3PG1lB5wK05Xqg_2, 1i64);
  stdio = __acrt_iob_func(0);
  input = (String *)readLineFromStdio(stdio);
  input_copy = input;
  if ( !input )
  {
    if ( ::input_copy )
    {
      unknownProperty = ::input_copy[-1].unknownProperty;
      p_unknownProperty = &::input_copy[-1].unknownProperty;
      ::input_copy[-1].unknownProperty = unknownProperty - 8;
      if ( (unsigned __int64)(unknownProperty - 8) <= 7 )
        addZCT__system_5314(refptr_gch__system_5267 + 3, p_unknownProperty);
      ::input_copy = 0i64;
    }
    goto error;
  }
  input[-1].unknownProperty += 8i64;
  if ( ::input_copy
    && (v4 = ::input_copy[-1].unknownProperty,
        v2 = &::input_copy[-1].unknownProperty,
        ::input_copy[-1].unknownProperty = v4 - 8,
        (unsigned __int64)(v4 - 8) <= 7) )
  {
    addZCT__system_5314(refptr_gch__system_5267 + 3, v2);
    ::input_copy = input_copy;
    if ( input_copy->length != 42 )
      goto error;
  }
  else
  {
    ::input_copy = input;
    if ( input->length != 42 )                  // 长度42
    {
error:
      checkhello3_copy = check__hello_3;
      goto error_;
    }
  }
  index = 0i64;
  pre_5_String = mnewString(5i64, v2);
  if ( !pre_5_String )
    raiseIndexError2(0i64, -1i64);
  do
  {
    if ( (unsigned __int64)index >= pre_5_String->length )
      raiseIndexError2(index, pre_5_String->length - 1);
    if ( (unsigned __int64)index >= input_copy->length )
      raiseIndexError2(index, input_copy->length - 1);
    pre_5_String->content[index] = input_copy->content[index];
    ++index;
  }
  while ( index <= 4 );                         // 提取前5字节flag{到new_string_1
  if ( pre_5_String->length != 5 || *(_DWORD *)pre_5_String->content != 1734437990 || pre_5_String->content[4] != 123 )
    goto error;
  input_copy_copy = ::input_copy;
  if ( !::input_copy )
  {
    v11 = -1i64;
LABEL_21:
    raiseIndexError2(41i64, v11);
  }
  input_copy_len = ::input_copy->length;
  if ( ::input_copy->length <= 0x29ui64 )
  {
    v11 = input_copy_len - 1;
    goto LABEL_21;
  }
  checkhello3_copy = check__hello_3;
  if ( BYTE1(::input_copy[2].unknownProperty) == '}' )// 确定最后一字节
  {
    index_2 = 0i64;
    flag_content_string = mnewString(36i64, input_copy_len);
    if ( !flag_content_string )
      raiseIndexError2(0i64, -1i64);
    do
    {
      length = flag_content_string->length;
      if ( flag_content_string->length <= (unsigned __int64)index_2 )
        raiseIndexError2(index_2, length - 1);
      v16 = index_2 + 5;
      if ( index_2 + 5 < 0 || v16 < index_2 )
        raiseOverflow(v13, length);
      if ( input_copy_copy->length <= v16 )
        raiseIndexError2(index_2 + 5, input_copy_copy->length - 1);
      flag_content_string->content[index_2++] = input_copy_copy->content[v16];
    }
    while ( index_2 <= 35 );                    // 提取36字节flag括号内数字内容
    InitBigInt(flag_content_string, 10i64, &flag_Int);// InitBitInt(src*, 进制, des*)
    InitBigInt(&Const_String_1, 10i64, &const_string_1_Int);
    star_des_1 = 0i64;
    v25 = 0i64;
    tmp_si128_1 = _mm_loadu_si128((const __m128i *)&flag_Int);// 输入的int
    tmp_si128_2 = _mm_loadu_si128((const __m128i *)&const_string_1_Int);// 常量1
    multiply((__int64)&tmp_si128_1, (__int64)&tmp_si128_2, &star_des_1);
    star_des_copy = star_des_1;
    if ( star_des_1 )
      *(_QWORD *)(star_des_1 - 16) += 8i64;
    if ( star_des_copy_copy )
    {
      v18 = star_des_copy_copy - 16;
      v19 = *(_QWORD *)(star_des_copy_copy - 16) - 8i64;
      *(_QWORD *)(star_des_copy_copy - 16) = v19;
      if ( v19 <= 7 )
        addZCT__system_5314(refptr_gch__system_5267 + 3, v18);
    }
    star_des_copy_copy = star_des_copy;
    byte_42C188 = v25;
    genericSeqAssign(&star_des_deep_copy);
    BYTE8(star_des_deep_copy) = byte_42C188;
    InitBigInt(&const_String_2, 10i64, &const_string_2_int);
    tmp_si128_1 = _mm_loadu_si128((const __m128i *)&star_des_deep_copy);// 结果1
    tmp_si128_2 = _mm_loadu_si128((const __m128i *)&const_string_2_int);// 常量结果
    if ( eqeq___6758Z85sersZ65ZOnimbleZpkgsZbigints4548O53O48Zbigints_259(&tmp_si128_1, &tmp_si128_2) )
    {                                           // 比较
      check__hello_3 = 1i64;
      return PutStdio(&String_Win, 1i64);
    }
    goto error;
  }
error_:
  if ( checkhello3_copy != 1 )
    return PutStdio(&error_string, 1i64);
  return PutStdio(&String_Win, 1i64);
}

exp:

1
2
3
4
5
6
7
8
9
10
11
# input = 123456789012345678901234567890123456
# input = 0xb1f36611aeca2ac04775feb51d2b7f

const_one = 56006392793428440965060594343955737638876552919041519193476344215226028549209672868995436445345986471

# print(hex(input * const_one))

const_two = 51748409119571493927314047697799213641286278894049840228804594223988372501782894889443165173295123444031074892600769905627166718788675801

print(hex(const_two // const_one))
# print(input)

MISC

阅读全文
⬆︎TOP