Struts2 漏洞分析系列 - S2-003&S2-005/初识首个通用Struts2框架漏洞

阅读量    215419 |

分享到: QQ空间 新浪微博 微信 QQ facebook twitter

 

0x00 漏洞概述

S2-003的漏洞核心在于Struts2中的ParametersInterceptor(某个拦截器)会对请求中的参数名称进行OGNL的表达式解析,虽然有一定的过滤,但是过滤的不完全导致被绕过。

影响版本:2.0.0~2.1.8.1

官方issue地址:https://cwiki.apache.org/confluence/display/WW/S2-003

官方issue地址:https://cwiki.apache.org/confluence/display/WW/S2-005

 

0x01 环境搭建

S2-003的执行流程与S2-001不同,主要区别在于S2-003中必须包含一个Action,否则无法走到漏洞触发的流程,因此首先需要搭建一个漏洞环境。

首先编写一个LoginAction用于模拟登陆过程:

import com.opensymphony.xwork2.ActionSupport;

public class LoginAction extends ActionSupport {
    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String execute() throw Exception {
        if (this.username == null || this.password == null) {
            return "failed";
        }

        if (this.username.equals("admin") && this.password.equals("admin")) {
            return "success";
        }

        return "failed";
    }

    public static void main(String[] args) {

    }
}

LoginAction的继承关系如下:

随后写一个struts.xml:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
        "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
    <package name="st2-demo" extends="struts-default">
        <action name="login" class="LoginAction">
            <result name="success">index.jsp</result>
        </action>
    </package>
</struts>

这样我们就算是写好了一个login.action的路由了,直接启动Tomcat访问login.action即可使用LoginAction中execute的逻辑,当用户名与密码正确时会跳转到index.jsp中。

 

0x02 漏洞分析

在之前的文章中有介绍过,Struts2的执行流程中涉及一个叫拦截器的东西,Struts2自带了许多拦截器,在请求到达真正的Action前会进行一系列处理,并在执行完毕后重新调用一次用于做请求完毕的清理。

S2-003的漏洞就出在其中的ParametersInterceptor上,在Struts2的执行流程中,首先会调用每个拦截器的doIntercept对请求进行处理,首先看看ParametersInterceptor的doIntercept方法:

com.opensymphony.xwork2.interceptor.ParametersInterceptor#doIntercept
public String doIntercept(ActionInvocation invocation) throws Exception {
        Object action = invocation.getAction();
        if (!(action instanceof NoParameters)) {
            ActionContext ac = invocation.getInvocationContext();
            Map parameters = ac.getParameters();
            if (LOG.isDebugEnabled()) {
                LOG.debug("Setting params " + this.getParameterLogMap(parameters));
            }

            if (parameters != null) {
                Map contextMap = ac.getContextMap();

                try {
                    OgnlContextState.setCreatingNullObjects(contextMap, true);
                    OgnlContextState.setDenyMethodExecution(contextMap, true);
                    OgnlContextState.setReportingConversionErrors(contextMap, true);
                    ValueStack stack = ac.getValueStack();
                    this.setParameters(action, stack, parameters);
                } finally {
                    OgnlContextState.setCreatingNullObjects(contextMap, false);
                    OgnlContextState.setDenyMethodExecution(contextMap, false);
                    OgnlContextState.setReportingConversionErrors(contextMap, false);
                }
            }
        }

        return invocation.invoke();
    }

上述代码,首先获取了当前请求对应的Action,也就是之前编写好的LoginAction,随后获取在前面拦截器中封装完毕的Action上下文,并获取了当前请求中的参数。

随后当参数不为空时,会为ContextMap设置三个键,分别为xwork.NullHandler.createNullObjects、xwork.MethodAccessor.denyMethodExecution、report.conversion.errors,其值都被设置为true。最后获取了ValueStack并调用了setParameters方法,传入三个参数分别为LoginAction、ValueStack、parameters。

相关参数值如下:

com.opensymphony.xwork2.interceptor.ParametersInterceptor#setParameters
protected void setParameters(Object action, ValueStack stack, Map parameters) {
        ParameterNameAware parameterNameAware = action instanceof ParameterNameAware ? (ParameterNameAware)action : null;
        Map params = null;
        if (this.ordered) {
            params = new TreeMap(this.getOrderedComparator());
            params.putAll(parameters);
        } else {
            params = new TreeMap(parameters);
        }

        Iterator iterator = params.entrySet().iterator();

        while(true) {
            Entry entry;
            String name;
            boolean acceptableName;
            do {
                if (!iterator.hasNext()) {
                    return;
                }

                entry = (Entry)iterator.next();
                name = entry.getKey().toString();
                acceptableName = this.acceptableName(name) && (parameterNameAware == null || parameterNameAware.acceptableParameterName(name));
            } while(!acceptableName);

            Object value = entry.getValue();

            try {
                stack.setValue(name, value);
            } catch (RuntimeException var13) {
                if (devMode) {
                    String developerNotification = LocalizedTextUtil.findText(ParametersInterceptor.class, "devmode.notification", ActionContext.getContext().getLocale(), "Developer Notification:\n{0}", new Object[]{var13.getMessage()});
                    LOG.error(developerNotification);
                    if (action instanceof ValidationAware) {
                        ((ValidationAware)action).addActionMessage(developerNotification);
                    }
                } else {
                    LOG.error("ParametersInterceptor - [setParameters]: Unexpected Exception caught setting '" + name + "' on '" + action.getClass() + ": " + var13.getMessage());
                }
            }
        }
    }

从代码中去看,setParameters这个参数主要用于解析请求中的参数并将其设置到ValueStack这个栈中,在这里通过一个while循环取出参数名name,接着调用了acceptableName来判断允许解析。

当满足如下条件时,acceptableName返回true:

  • name中不包含=
  • name中不包含,
  • name中不包含#
  • name中不包含:

当满足上述条件时,会跳出while循环,并获取请求中的value,调用ValueStack#setValue来设置值:

com.opensymphony.xwork2.util.OgnlValueStack#setValue
public void setValue(String expr, Object value) {
        this.setValue(expr, value, devMode);
    }

com.opensymphony.xwork2.util.OgnlValueStack#setValue
public void setValue(String expr, Object value, boolean throwExceptionOnFailure) {
        Map context = this.getContext();

        try {
            String msg;
            try {
                context.put("conversion.property.fullName", expr);
                context.put("com.opensymphony.xwork2.util.ValueStack.ReportErrorsOnNoProp", throwExceptionOnFailure ? Boolean.TRUE : Boolean.FALSE);
                OgnlUtil.setValue(expr, context, this.root, value);
            } catch (OgnlException var11) {
                if (throwExceptionOnFailure) {
                    msg = "Error setting expression '" + expr + "' with value '" + value + "'";
                    throw new XWorkException(msg, var11);
                }

                if (LOG.isDebugEnabled()) {
                    LOG.debug("Error setting value", var11);
                }
            } catch (RuntimeException var12) {
                if (throwExceptionOnFailure) {
                    msg = "Error setting expression '" + expr + "' with value '" + value + "'";
                    throw new XWorkException(msg, var12);
                }

                if (LOG.isDebugEnabled()) {
                    LOG.debug("Error setting value", var12);
                }
            }
        } finally {
            OgnlContextState.clear(context);
            context.remove("conversion.property.fullName");
            context.remove("com.opensymphony.xwork2.util.ValueStack.ReportErrorsOnNoProp");
        }

    }

在setValue中主要在ContextMap设置了两个值,fullName代表了请求中key的完整值,随后继续调用OgnlUtil.setValue,传入四个参数分别为expr(key)、context(ContextMap)、this.root(RootContext)、value。

com.opensymphony.xwork2.util.OgnlUtil#setValue
public static void setValue(String name, Map context, Object root, Object value) throws OgnlException {
        Ognl.setValue(compile(name), context, root, value);
    }

ognl.Ognl#setValue
public static void setValue(Object tree, Map context, Object root, Object value) throws OgnlException {
        OgnlContext ognlContext = (OgnlContext)addDefaultContext(root, context);
        Node n = (Node)tree;
        n.setValue(ognlContext, root, value);
    }

在setValue方法中可以看到,这里首先将name(也就是key)编译为AST Node,随后调用AST Node的setValue方法设置值,后续的调用流程就不细跟了,在S2-001中可以发现最终的OGNL解析实现在getValue,然而在setValue这也会对key进行一次OGNL解析,因此也存在对应的表达式解析的漏洞。

在前面的调用流程中我们知道,前面在ContextMap中添加了一个键xwork.MethodAccessor.denyMethodExecution,其值为false,这个键影响到后续OGNL解析时是否可以调用方法,而此处为false,我们需要先将其修改为true。

那么怎么修改呢?在前面的学习中我们了解到,在OGNL中实现赋值的方式有两种:

Ognl.getValue(compile("id=123"),context,root,resultType) // 将root对象的id属性赋为123
Ognl.getValue(compile("#request.name='liming',#request.name"),context,root,resultType) // 将context中request对象的name属性赋为liming,并将其返回

那么我们是否可以通过#xwork.MethodAccessor.denyMethodExecution=false直接将contextMap中的这个键设置为false?答案是不行的…因为在OGNL中.代表访问属性,上面的OGNL语句代表访问xwork下的MethodAccessor这个属性,然而ContextMap中没有xwork这个对象,更不可能存在MethodAccessor这个属性了,因此我们需要换一种方法。

在OGNL中我们可以通过数组的方式获取一个对象中的属性,这点与Python的SSTI很像,即可以通过#context['xwork.MethodAccessor.denyMethodExecution']获取到这个属性,这下子获取属性的问题解决了,但是怎么赋值呢?

注意这是setValue而非getValue,最终是需要执行一个set的操作的,set必然操作的是一个对象而非undefined,而OGNL的AssignNode最终返回的肯定是一个undefined,因此我们没有办法直接通过#context['xwork.MethodAccessor.denyMethodExecution']=false来赋值,我们需要让这个OGNL最后返回一个对象让setValue执行set操作。

在之前的学习中可以了解到,一行OGNL的表达式可以通过,被拆分为多个OGNL表达式,并且最终这个表达式返回的是最后一个,所返回的值,通过这个思路,POC就可以完美的写出来了:#context['xwork.MethodAccessor.denyMethodExecution']=false,#request

这个POC最终返回的是ContextMap中的request,自然也支持set操作,不会报错,不影响后续的执行。现在属性设置完毕了,执行命令也就简单了,在上述POC中插入S2-001执行命令的POC即可。

最终POC:

#context['xwork.MethodAccessor.denyMethodExecution']=false,@java.lang.Runtime@getRuntime().exec('open -a /System/Applications/Calculator.app')#request

接下来需要解决最后一个问题,在前面acceptableName的过滤中,限制了name中不能出现几个关键字符,我们需要绕过这个。

在OGNL中支持Unicode编码,当其遇到\时会首先触发相关解码,随后再进行解析,利用这个特性,我们可以将黑名单中的字符转为unicode编码来绕过。

最终转换后的POC:

\u0023context['xwork.MethodAccessor.denyMethodExecution']\u003dfalse\u002c@java.lang.Runtime@getRuntime().exec('open -a /System/Applications/Calculator.app')\u002c\u0023request

至于为什么OGNL在compile时会解析Unicode,这点在https://xz.aliyun.com/t/2323中有过相关解释了,没什么好讲的,fastjson也会有这样的处理,都是为了兼容某些环境的运行情况而做的一个处理。

 

0x03 修复方案

对于S2-003漏洞,官方通过增加安全配置(禁止静态方法调用和类方法执行等)来修补,即在原有基础上添加allowStaticAccess这么一个过滤。

然鹅治标不治本,官方似乎没有意识到漏洞的核心在于黑名单被绕过,所以后续产生了S2-005这么一个漏洞,原理与S2-003相同,只不过POC中将allowStaticAccess设为true罢了:_memberAccess[‘allowStaticAccess’]=true.

最后的修复方案自然是修补黑名单了,从根本上解决Unicode编码、八进制编码绕过的安全问题:

protected boolean acceptableName(String name) {
        return this.isAccepted(name) && !this.isExcluded(name);
    }

protected boolean isAccepted(String paramName) {
        if (!this.acceptParams.isEmpty()) {
            Iterator i$ = this.acceptParams.iterator();

            Matcher matcher;
            do {
                if (!i$.hasNext()) {
                    return false;
                }

                Pattern pattern = (Pattern)i$.next();
                matcher = pattern.matcher(paramName);
            } while(!matcher.matches());

            return true;
        } else {
            return this.acceptedPattern.matcher(paramName).matches();
        }
    }

这里主要是增加了一个acceptedPattern:

private String acceptedParamNames = "[a-zA-Z0-9\\.\\]\\[\\(\\)_'\\s]+";

如果payload和之前一样,通过\u\x之类的方式绕过,会被这里的正则匹配到:

因此就没有办法通过\u等方式绕过acceptableName的过滤了。

 

0x04 一点吐槽

网上的分析文章中主要存在几个容易让新手产生误区的点:

  1. 漏洞只能在Tomcat6下复现(URLENCODE即可解决)
  2. Payload过于复杂化(都是照搬的,完全不讲Payload的原理,只讲如何到触发OGNL表达式注入)

以其中的一篇文章中的POC为例:

('\u0023context[\'xwork.MethodAccessor.denyMethodExecution\']\u003dfalse')(bla)(bla)&('\u0023myret\u003d@java.lang.Runtime@getRuntime().exec(\'calc\')')(bla)(bla)

这个POC,相信大家看了都会有一个疑问,为什么有unicode编码?这个括号是什么?这个bla是什么?这个&号是什么?然鹅这些作者都没有解释,而是直接代入到了OGNL表达式解析这块。

实际上做漏洞分析的时候,大家应该以挖掘者的身份去思考,这个点被过滤了,我要怎么绕?绕过的第一步是什么?而不是直接放网上公开的POC,然后自己开始瞎JB分析。

 

0x05 漏洞总结

通过本篇的分析我们可以了解到S2-003与S2-005的核心在于ParametersInterceptor在对请求中的参数进行解析时会对key进行OGNL的表达式解析,并且过滤不严谨,可以通过编码绕过。

S2-003与S2-005算是Struts2框架的通用问题,其不需要依赖于某个特定的写法,即不属于安全开发规范中,所以影响范围相比于S2-001会更广一些(S2-001依赖于标签)。

分享到: QQ空间 新浪微博 微信 QQ facebook twitter
|推荐阅读
|发表评论
|评论列表
加载更多