Comment analyser l'audit de code dans Java Web Security

1. Bases de la sécurité JavaWeb

1. Qu'est-ce que l'audit de code ?

En termes simples, l'audit de code Java consiste à découvrir les problèmes de sécurité dans l'application Java elle-même en auditant le code Java lui-même est un langage compilé, même si Quand. il n'y a que des fichiers de classe, on peut toujours auditer le code Java. Pour les fichiers de code source Java non compilés, nous pouvons lire le code source directement, mais pour les fichiers de classe ou jar compilés, nous devons les décompiler.

L'audit du code Java en lui-même n'est pas très difficile. Tant que vous maîtrisez le processus d'audit et les techniques courantes d'audit des vulnérabilités, vous pouvez effectuer le travail d'audit du code relativement facilement. Cependant, la méthode d'audit du code Java ne consiste pas simplement à utiliser un outil d'audit pour analyser l'intégralité du code du projet Java. Certains audits de code système avec une logique métier et une architecture de programme complexes nécessitent que les auditeurs maîtrisent une certaine base Java et soient capables de le faire. Ce n'est qu'avec une certaine expérience, des compétences en matière d'audit et même une compréhension et une pratique plus approfondies de l'architecture Java que les problèmes de sécurité peuvent être découverts plus en profondeur.

Cet article sera divisé en plusieurs chapitres pour décrire les connaissances préalables requises pour l'audit de code Java ainsi que les processus et techniques d'audit de code Java.

2. Préparez l'environnement et les outils auxiliaires

Veuillez installer l'environnement de développement Java par vous-même avant de commencer l'audit du code Java. Il est recommandé d'utiliser les systèmes d'exploitation MacOS et Ubuntu.

Comme le dit le proverbe : « Si vous voulez bien faire votre travail, vous devez d'abord affûter vos outils. » Une bonne utilisation de certains outils auxiliaires peut grandement améliorer l'efficacité et la qualité de nos audits de code !

Les outils auxiliaires suivants sont fortement recommandés :

1.Jetbrains IDEA (IDE)

2.Sublime text (éditeur de texte)

3.JD-GUI (décompilation)

4.Fernflower (décompilation)

5.Bytecode-Viewer

6.Eclipse(IDE)

7.NetBeans(IDE)

2 Compétences de décompilation

Le code qui doit être audité lors des tests d'intrusion est généralement un fichier de classe ou un fichier jar. Package, alors comment devrions-nous l’auditer ? Voyons d'abord ce que sont le code source et le bytecode Java.

1. Bases de la compilation et de la décompilation des classes Java

En termes simples, le code source Java est un fichier .java non compilé, tandis que le fichier bytecode .class est un fichier .java. Le fichier généré après compilation ne peut pas être lu directement car le fichier .class est un fichier binaire compilé. Nous ne pouvons utiliser que des outils de décompilation pour convertir le fichier binaire en code Java ou en code ASM.

Exemple de code Test.java :

/**
 * @author yz
 */
public class Test {

	public static void hello() {
		System.out.println("Hello~");
	}

	public void world() {
		System.out.println("World!");
	}

	public static void main(String[] args) {
		hello();
	}

}

Processus de compilation et d'exécution de Test.java :

Code source de Test.java, bytecode

En raison de la lisibilité des fichiers de classe , Mauvais, nous devons généralement utiliser des outils de décompilation Java pour décompiler le code. Nous utilisons généralement des outils tels que JD-GUI, le plug-in IDEA Fernflower, Bytecode-Viewer, Fernflower, JAD, JBE, JEB, etc. pour décompiler les classes.

Parmi eux, JD-GUI est peut-être l'outil de décompilation le plus couramment utilisé, mais je pense personnellement que la capacité de décompilation de JD-GUI est bien inférieure à celle d'IDEA (IDEA devrait être le Fernflower révisé), car IDEA prend en charge la décompilation par défaut. . Décompilez le jar et la classe, je recommande donc personnellement fortement d'utiliser IDEA pour décompiler le code de la classe.

Bien sûr, les outils de décompilation ne sont pas omnipotents dans de nombreux cas. JD-GUI rencontre souvent des situations où il ne peut pas être décompilé ou le programme plante directement pendant le processus de décompilation. Dans de telles situations, nous pouvons généralement utiliser IDEA pour décompiler et essayer. IDEA ne peut pas non plus décompiler. Vous pouvez utiliser JBE pour charger le bytecode du programme de lecture du fichier de classe. Si JBE ne parvient toujours pas à lire les informations de classe, vous pouvez également utiliser la commande javap fournie avec le JDK pour lire le bytecode de la classe. all Si aucune des méthodes ne peut être décompilée, il se peut que la classe elle-même ne puisse pas être compilée ou que le fichier de classe ait été chiffré. Peut-être direz-vous que les classes compilées Java ne peuvent pas être chiffrées ? Oui, le cryptage mentionné ici vise en fait à protéger le code de classe compilé contre la décompilation. Il s'agit simplement d'un moyen de charger la classe cryptée en implémentant un ClassLoader personnalisé. Cette méthode de cryptage a également été rencontrée en combat réel.

2. Décompiler l'intégralité de la technique Jar

Habituellement, nous n'obtenons le fichier jar que dans certains scénarios spéciaux, alors comment devrions-nous décompiler le fichier de classe de l'ensemble du package jar ?

2.1. Fernflower

Fernflower peut facilement réaliser une décompilation complète de jar. Exécutez simplement la commande suivante : java -jar fernflower.jar jarToDecompile.jar decomp/ où jarToDecompile.jar est le fichier jar qui doit être décompilé. est le répertoire où sont stockés les fichiers de classe décompilés. Il est à noter que Fernflower peut générer des fichiers Java vides s'il ne peut pas être décompilé !

2.2. JD-GUI

JD-GUI est un outil de décompilation avec GUI. Cliquez sur Fichier -> Enregistrer toutes les sources dans le menu de JD-GUI pour décompiler le fichier jar.

2.3. IDEA

IDEA默认就支持jar包反编译，同时还支持class文件名(⇧⌘F)、类方法名称(⇧⌘O)搜索。

2.4. Bytecode-Viewer

FernFlower提供了GUI版本Bytecode-Viewer,Bytecode-Viewer提供了直接反编译的class、jar、zip、apk、dex功能，直接拖拽jar就可以直接对整个jar进行反编译了。

2.5. Find命令

find命令并不能支持Java反编译，但是find命令可以非常方便的搜索经过编译后的二进制文件中的内容,所以有的时候使用find命令通常是最简单实用的，直接解压jar包然后使用find命令搜索: find ./ -type f -name “*.class” |xargs grep XXXX 即可搞定。

2.6 使用Find命令和Fernflower实现批量反编译jar

当我们只有项目war包且源码经过打包后发布到WEB-INF/lib的情况下，我们不得不去找出待审计源码的具体jar文件并反编译。遇到这种情况我们可以巧妙的使用find命令来反编译所有目标的jar包。

这里以jcms的一个非常老版本为例,jcms最终给客户部署的war包中源码并不是在WEB-INF/classes目录下，而是将整个jcms系统按模块打包成了多个jar包放在了WEB-INF/lib目录下。我们可以通过搜索com.hanweb包名称来找出所有jar中包含了jcms的文件并通过Fernflower来反编译。

java -jar /Users/yz/Desktop/javaweb-decomplier/javaweb-decomplier.jar -dgs=1 $(find /Users/yz/Desktop/jcms/WEB-INF/lib/ -type f -name "*.jar" |xargs grep "com.hanweb" |awk '{print $3}') /Users/yz/jcms-decomplier

依赖的jar: javaweb-decomplier、Intellij java-decompiler。

执行上面的命令后会在jcms-decomplier目录下看到所有的jar已经被Fernflower反编译了。

3. IntelliJ IDEA 推荐

IntelliJ IDEA是Jetbrains出品的一款非常强大的Java IDE，IDEA提供了强大的代码搜索、近乎完美的反编译、动态调试等功能可以最大程度的辅助我们代码审计。

不可以否认，与IDEA相比虽然Eclipse和Netbeans也有与之类似的功能，但是在真正的实战体验中个人更倾向于使用IDEA，虽然曾经的我也是一个重度Eclipse开发者。

三、IDEA代码搜索技巧

IDEA的搜索快捷键是:⇧⌘F,使用IDEA提供的搜索功能可以非常快速的定位漏洞点信息。

IDEA可以通过自定义搜索范围来精确查找我们需要审计的代码。默认搜索的是所有的位置，不过我们可以点击红色箭头指向的...按钮来细化我们的搜索范围。

1. 自定义范围搜索

自定义搜索范围示例:

自定义搜索范围后就可以在搜索时使用自定义的配置进行范围搜索了，有助于我们在挖漏洞的时候缩小代码定位范围。

2. 标记搜索

搜索快捷键: ⌘O，标记搜索支持类名、方法名搜索（包括class或jar文件中的方法也支持搜索）。

3. Java调用链搜索

当我们审计代码的时候发现某个方法或类有漏洞时我们需要定位到漏洞的请求地址(触发点)，复杂业务系统往往会让我们很难定位到漏洞的触发点。借助IDEA的方法调用链搜索功能就可以很轻松的找出方法的调用链和触发点。

选择类或者方法名-->右键-->Find Useages或者使用快捷键⌥F7

四、Java Web基础

1. Java分层思想

为了更好的管理项目我们通常会采用分层架构的方式来开发Java Web项目，分层设计的好处在于可以非常方便的分清楚包之间的业务逻辑关系。

常见的JavaWeb项目分层：

视图层（View 视图)

控制层（Controller、Action 控制层）

服务层（Service）

业务逻辑层BO(business object)  

实体层（entity 实体对象、VO(value object) 值对象 、模型层（bean）。

Couche de persistance (couche d'accès aux données dao- Data Access Object, objet persistant PO (objet persistant))

Exemple de projet basé sur une architecture en couches Java :

Servlet est un petit programme exécuté sur un conteneur Web Java. Habituellement, nous utilisons Servlet pour gérer une logique métier plus complexe côté serveur. Il convient de noter qu'après Servlet3.0 (Tomcat7+), vous pouvez utiliser des annotations pour configurer les servlets.

Servlet basé sur des annotations

Les versions antérieures à Servlet3.0 doivent être configurées dans web.xml. balises, il se compose de et . Le framework Spring MVC est implémenté sur la base de la technologie Servlet.

Servlet implémenté en fonction de la configuration

HttpServlet class

Il est très simple d'implémenter un Servlet. Il suffit d'hériter de la classe javax.servlet.http.HttpServlet et de réécrire la méthode doXXX ou la méthode de service. Il est à noter que la réécriture de la méthode de service de la classe HttpServlet. peut obtenir les requêtes ci-dessus pour sept méthodes de requête HTTP.

5. Qu'est-ce que le filtre

package org.javaweb.codereview.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class IndexController {
@RequestMapping("/index.php")
public String index() {
return "/index.html";
}
}

package org.javaweb.codereview.controller;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 * @author yz
 */
public class TestController implements Controller {
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
ModelAndView mv = new ModelAndView();
mv.setViewName("index");
return mv;
}
}

<bean name="/test.do" class="org.javaweb.codereview.controller.TestController"/>

find ~/cms/ -type f -name "*.class" |xargs grep -E "Controller|@RestController|RepositoryRestController"

find ~/cms/ -type f -name "*.class" |xargs grep -E "RequestMapping|GetMapping|PostMapping|PutMapping|DeleteMapping|PatchMapping|RepositoryRestResource"

Runtime.class.getMethod("exec", String.class).invoke(Runtime.class.getMethod("getRuntime").invoke(null), "whoami")

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Scanner;
/**
 * @author yz
 */
public class ReflectionTest {
public static void exec() {
try {
System.out.println(Runtime.class.getMethod("exec", String.class).invoke(Runtime.class.getMethod("getRuntime").invoke(null), "curl -i localhost:8000"));
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
String str = "whoami";
// java.lang.Runtime
String runtime = new String(new byte[]{106, 97, 118, 97, 46, 108, 97, 110, 103, 46, 82, 117, 110, 116, 105, 109, 101});
// Runtime.class
Class<?> c = Class.forName(runtime);
// 获取getRuntime方法，Runtime.getRuntime()
Method m1 = c.getMethod(new String(new byte[]{103, 101, 116, 82, 117, 110, 116, 105, 109, 101}));
// 获取Runtime的exec方法，rt.exec(xxx)
Method m2 = c.getMethod(new String(new byte[]{101, 120, 101, 99}), String.class);
// Runtime.getRuntime().exec(str)
Object obj2 = m2.invoke(m1.invoke(null), str);
// 获取命令执行结果Process类的getInputStream()方法
Method m = obj2.getClass().getMethod(new String(new byte[]{103, 101, 116, 73, 110, 112, 117, 116, 83, 116, 114, 101, 97, 109}));
m.setAccessible(true);
// process.getInputStream()
InputStream in = (InputStream) m.invoke(obj2, new Object[]{});
// 输出InputStream内容到
Scanner scanner = new Scanner(in).useDelimiter("\\A");
System.out.println(scanner.hasNext() ? scanner.next() : "");
} catch (Throwable t) {
t.printStackTrace();
}
}
}

import java.io.InputStream;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.util.Scanner;
/**
 * @author yz
 */
public class MethodHandlesTest {
public static void main(String[] args) {
try {
String               str          = "ping p2j.cn -c 1";
Class                runtimeClass = Runtime.class;
MethodHandles.Lookup lookup       = MethodHandles.lookup();
// Runtime rt = Runtime.getRuntime()
MethodHandle methodHandle = lookup.findStatic(
runtimeClass, "getRuntime", MethodType.methodType(runtimeClass)
);
// 获取Runtime的exec方法
MethodHandle execMethod = lookup.findVirtual(
runtimeClass, "exec", MethodType.methodType(Process.class, new Class[]{
String.class
})
);
// 获取Process的getInputStream方法
MethodHandle inputStreamMethod = lookup.findVirtual(
Process.class, "getInputStream", MethodType.methodType(InputStream.class)
);
// 调用Runtime.getRuntime().exec(xxx).getInputStream()
InputStream in = (InputStream) inputStreamMethod.invoke(
execMethod.invoke(methodHandle.invoke(), str)
);
// 输出InputStream内容到
Scanner scanner = new Scanner(in).useDelimiter("\\A");
System.out.println(scanner.hasNext() ? scanner.next() : "");
} catch (Throwable t) {
t.printStackTrace();
}
}
}

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * @author yz
 */
public class FileNullBytes {
public static void main(String[] args) {
try {
String fileName = "/tmp/null-bytes.txt\u0000.jpg";
FileOutputStream fos = new FileOutputStream(new File(fileName));
fos.write("Test".getBytes());
fos.flush();
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="java.io.ByteArrayOutputStream" %>
<%@ page import="java.io.File" %>
<%@ page import="java.io.FileInputStream" %>
<%
    File file = new File(request.getParameter("path"));
    FileInputStream fis = new FileInputStream(file);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    byte[] b = new byte[1024];
    int a = -1;
    while ((a = fis.read(b)) != -1) {
        baos.write(b, 0, a);
    }
    out.write("<pre class="brush:php;toolbar:false">" + new String(baos.toByteArray()) + "

package org.javaweb.codereview.axis.client;
import java.net.URL;
/**
 * 文件Web Service服务测试
 *
 * @author yz
 */
public class FileServiceTest {
public static void main(String[] args) {
try {
FileServiceService         fileService   = new FileServiceServiceLocator();
URL                        webServiceUrl = new URL("http://localhost:8080/services/FileService");
FileServiceSoapBindingStub soapService   = new FileServiceSoapBindingStub(webServiceUrl, fileService);
String content = soapService.readFile("/etc/passwd");
System.out.println(content);
} catch (Exception e) {
e.printStackTrace();
}
}
}