Confluence CVE-2023-22518 漏洞分析

0x01 漏洞时间线

  • 10月16日 长亭安全研究员发现该漏洞
  • 10月31日 官方发布新版本修复漏洞
  • 10月31日 17:59 长亭安全应急响应中心发布通告
  • 10月31日 18:50 beichen 已经复现
    upload successful
    upload successful
  • 10月31日 threedream师傅疑问，beichen确认 
    1
    2
    3
    假设存在URL为/barspace/bar.action的请求，而且/barspace的命名空间下没有名为bar的Action，则默认命名空间下名为bar的Action也会处理用户请求。但根命名空间下的Action仅仅处理根命名空间下的Action的请求，这是根命名空间和默认命名空间的差别。

       命名空间仅仅有一个级别。假设请求的URL是/bookservice/search/get.action。系统将先在/bookservice/search的命名空间下查找名为get的Action，假设在该命名空间内找到名为get的Action。则由该Action处理用户的请求。假设未找到。系统将直接进入默认的命名空间中查找名为get的Action，而不会在/bookservice的命名空间下查找名为get的Action 。

0x02 Namespace & Action 机制

上文三梦师傅提到Namespace 下不存在对应的Action，那么会往上找Action，从而产生问题。

Namespace 有default-interceptor-ref，如果这两个Namespace 不一致，而且对应的Action 没有配置interceptor，用的Namespace 的default interceptor，那么就可能存在权限问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<package name="setup" extends="default" namespace="/setup">
    <default-interceptor-ref name="validatingSetupStack"/>
    <action name="selectglobaldefaultlocale" class="com.atlassian.confluence.setup.actions.SelectGlobalLocaleAction" method="execute">
        <interceptor-ref name="defaultSetupStack"/>
        <result name="success" type="redirect">/bootstrap/selectsetupstep.action</result>
    </action>

<package name="json" extends="admin" namespace="/json">
    <default-interceptor-ref name="validatingStack"/>
    <action name="deletedraft" class="com.atlassian.confluence.user.actions.ViewMyDraftsAction" method="doDelete">
        <param name="RequireSecurityToken">true</param>
        <result name="success" type="json"/>
        <result name="error" type="json"/>
        <result name="input" type="json"/>
    </action>

如上，

  1. /setup 默认的interceptor 是validatingSetupStack
  2. /json 默认的默认的interceptor 是validatingStack，这个interceptor-stack 不包含setupStack，所以可以绕过安装检测
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<interceptor-stack name="defaultSetupStack">
    <interceptor-ref name="setupStack"/>
    <interceptor-ref name="defaultStack"/>
</interceptor-stack>

<interceptor-stack name="validatingSetupStack">
    <interceptor-ref name="setupStack"/>
    <interceptor-ref name="validatingStack"/>
</interceptor-stack>

<interceptor-stack name="validatingStack">
    <interceptor-ref name="defaultStack"/>

    <!--Must come after pageAware and spaceAware, as the view rendered in a response to a failed validation may access properties of page and/or space objects.-->
    <interceptor-ref name="captcha"/>

    <interceptor-ref name="validator"/>
    <interceptor-ref name="workflow"/>
    <interceptor-ref name="profiling">
        <param name="location">After validatingStack</param>
    </interceptor-ref>
</interceptor-stack>

2.1 Namespace String

Namespace 的逻辑为uri path 中到最后一个反斜杠的子串

在ServletDispatcher中，决定了Namespace 和ActionName

1
this.serviceAction(request, response, this.getNameSpace(request), this.getActionName(request), this.getRequestMap(request), this.getParameterMap(request), this.getSessionMap(request), this.getApplicationMap());

upload successful

具体逻辑如下
ServletDispatcher

1
2
3
4
protected String getNameSpace(HttpServletRequest request) {
    String servletPath = request.getServletPath();
    return getNamespaceFromServletPath(servletPath);
}
1
2
3
4
public static String getNamespaceFromServletPath(String servletPath) {
    servletPath = servletPath.substring(0, servletPath.lastIndexOf("/"));
    return servletPath;
}

2.2 Action String

action string 对应的是最后一个/到最后一个. 之间的子串

1
2
3
4
5
6
7
8
protected String getActionName(HttpServletRequest request) {
    String servletPath = (String)request.getAttribute("javax.servlet.include.servlet_path");
    if (servletPath == null) {
        servletPath = request.getServletPath();
    }

    return this.getActionName(servletPath);
}
1
2
3
4
5
protected String getActionName(String name) {
    int beginIdx = name.lastIndexOf("/");
    int endIdx = name.lastIndexOf(".");
    return name.substring(beginIdx == -1 ? 0 : beginIdx + 1, endIdx == -1 ? name.length() : endIdx);
}

2.3 Namespace & Action

1
2
3
4
5
6
getActionConfig:137, PluginAwareConfiguration$RuntimeConfigurationImpl (com.atlassian.confluence.setup.webwork)
<init>:57, DefaultActionProxy (com.opensymphony.xwork)
createActionProxy:43, DefaultActionProxyFactory (com.opensymphony.xwork)
serviceAction:53, ConfluenceServletDispatcher (com.atlassian.confluence.servlet)
service:199, ServletDispatcher (com.opensymphony.webwork.dispatcher)
service:733, HttpServlet (javax.servlet.http)

漏洞逻辑如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public synchronized ActionConfig getActionConfig(String namespace, String name) {
    ActionConfig config = null;
    // 首先从namespace string 获取其下面所有的actions
    Map actions = (Map)this.namespaceActionConfigs.get(namespace == null ? "" : namespace);
    if (actions != null) {
    	// 再从对应的actions里面获取
        config = (ActionConfig)actions.get(name);
    }
			
    // 否则从""对应的namespace里获取
    if (config == null && namespace != null && !namespace.trim().equals("")) {
        actions = (Map)this.namespaceActionConfigs.get("");
        if (actions != null) {
            config = (ActionConfig)actions.get(name);
        }
    }

    return config;
}

upload successful
这里可能有两个问题

  1. 如果namespace实际不存在，也会从””里面获取，这里有46个action，可能会存在问题
  2. namespace 存在extends继承，但是不会继承其interceptors，到值权限问题。

比如：

1
2
3
4
5
6
7
8
9
<package name="setup" extends="default" namespace="/setup">
    <default-interceptor-ref name="validatingSetupStack"/>
    <action name="dosetuplicense" class="com.atlassian.confluence.setup.actions.SetupLicenseAction">
        <result name="error" type="velocity">/setup/setuplicense.vm</result>
        <result name="input" type="velocity">/setup/setuplicense.vm</result>
        <result name="quick-setup" type="redirect">setupembeddeddb-default.action?atl_token=${xsrfToken}</result>
        <result name="custom-setup" type="redirect">setupdbchoice-start.action</result>
        <result name="cluster-setup" type="redirect">setupcluster-start.action</result>
    </action>
1
2
<package name="admin" extends="setup" namespace="/admin">
    <default-interceptor-ref name="validatingStack"/>

在xwork.xml的定义中

  1. admin namespace extends setup namespace
  2. setup default interceptor validatingSetupStack，对应33个interceptor
  3. admin default interceptor validatingStack，对应32个interceptor

其中dosetuplicense action 没有自定义interceptor，所以继承的namespace的default interceptor，导致处理的interceptor 不同。

  1. 在setup namespace 中
    upload successful
  2. 在admin namespace 中
    upload successful

0x03 Confluence的认证机制

upload successful

在之前的一篇分析文章中，参考【2】，有提到Confulence的账号权限逻辑。现在看当时的分析还是太浅尝辄止了，这里再过一遍。

3.1 CVE-2021-26084 管中窥豹

还是以CVE-2021-26084 的doenterpagevariables.action 为授权为例进行跟踪。

3.1.1 doenterpagevariables

doenterpagevariables 继承的pages namespace 的default interceptor： validatingStack

1
2
3
4
5
6
7
  <package name="pages" extends="default" namespace="/pages">
      <default-interceptor-ref name="validatingStack"/>
<action name="doenterpagevariables" class="com.atlassian.confluence.pages.actions.PageVariablesAction" method="doEnter">
          <result name="error" type="velocity">/pages/createpage-entervariables.vm</result>
          <result name="input" type="velocity">/pages/createpage-entervariables.vm</result>
          <result name="success" type="velocity">/pages/createpage.vm</result>
      </action>

createpage 用到自定义的defaultStack interceptor

1
2
3
4
5
6
7
8
9
<action name="createpage" class="com.atlassian.confluence.pages.actions.CreatePageEntryAction" method="doDefault">
    <interceptor-ref name="defaultStack"/>
    <result name="error" type="velocity">/pages/createpage.vm</result>
    <result name="input" type="velocity">/pages/createpage.vm</result>
    <result name="already-exists" type="redirect">${@com.atlassian.confluence.util.GeneralUtil@getPageUrl(page)}</result>
    <result name="locked" type="redirectwithflash">/users/viewmydrafts.action?editingLocked</result>
    <result name="user-limit-reached" type="redirect">/users/viewmydrafts.action?userLimitReached</result>
    <result name="activity-unavailable" type="redirect">/users/viewmydrafts.action?editingFailed</result>
</action>

实际上validatingStack包含了defaultStack，为什么反而能为授权访问呢？

1
2
3
4
5
6
7
8
9
<interceptor-stack name="validatingStack">
    <interceptor-ref name="defaultStack"/>
    <interceptor-ref name="captcha"/>
    <interceptor-ref name="validator"/>
    <interceptor-ref name="workflow"/>
    <interceptor-ref name="profiling">
        <param name="location">After validatingStack</param>
    </interceptor-ref>
</interceptor-stack>

3.1.2 ConfluenceXsrfTokenInterceptor

实际上interceptor的不同只是授权的一个原因，还有原因是里面的

1
2
3
public String intercept(ActionInvocation actionInvocation) throws Exception {
    return this.isInspectionDisabledForRequest(actionInvocation) ? actionInvocation.invoke() : super.intercept(actionInvocation);
}

在此处result=input

说明下前文struts2 架构图中的interceptors 为什么只有3个。这是因为一般的interceptors invocation接口，默认最后都要return invocation.invoke()，以此交由下一个interceptor处理。当然如果当前interceptor 也可以直接返回其他的code，结束interceptors。
具体可以看DefaultAcationInvocation#invoke的逻辑，当某一个interceptor有返回resultCode，而不是invocation.invoke()，会进入executeResult，将executed 置为true，退出当前循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public String invoke() throws Exception {
    if (this.executed) {
        throw new IllegalStateException("Action has already executed");
    } else {
        if (this.interceptors.hasNext()) {
            Interceptor interceptor = (Interceptor)this.interceptors.next();
            this.resultCode = interceptor.intercept(this);
        } else if (this.proxy.getConfig().getMethodName() == null) {
            this.resultCode = this.getAction().execute();
        } else {
            this.resultCode = this.invokeAction(this.getAction(), this.proxy.getConfig());
        }

        if (!this.executed) {
            if (this.preResultListeners != null) {
                Iterator iterator = this.preResultListeners.iterator();

                while(iterator.hasNext()) {
                    PreResultListener listener = (PreResultListener)iterator.next();
                    listener.beforeResult(this, this.resultCode);
                }
            }

            if (this.proxy.getExecuteResult()) {
                this.executeResult();
            }

            this.executed = true;
        }

而在ConfluenceXsrfTokenInterceptor 中，extends 的 XsrfTokenInterceptor，其实现如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public String intercept(ActionInvocation invocation) throws Exception {
       Method invocationMethod = this.versionSupport.extractMethod(invocation);
       String configParam = (String)invocation.getProxy().getConfig().getParams().get("RequireSecurityToken");
       RequireSecurityToken legacyAnnotation = (RequireSecurityToken)invocationMethod.getAnnotation(RequireSecurityToken.class);
       XsrfProtectionExcluded annotation = (XsrfProtectionExcluded)invocationMethod.getAnnotation(XsrfProtectionExcluded.class);
       boolean isProtected = this.methodRequiresProtection(configParam, annotation, legacyAnnotation);
       String token = ServletActionContext.getRequest().getParameter("atl_token");
       boolean validToken = this.tokenGenerator.validateToken(ServletActionContext.getRequest(), token);
       if (isProtected && !validToken) {
           if (token == null) {
               this.addInvalidTokenError(this.versionSupport.extractAction(invocation), "atlassian.xwork.xsrf.notoken");
           } else {
               this.addInvalidTokenError(this.versionSupport.extractAction(invocation), "atlassian.xwork.xsrf.badtoken");
           }
           // 注意此处，直接return了有效的resultCode，不在进入下面的invocation.invoke() 逻辑

           ServletActionContext.getResponse().setStatus(403);
           return "input";
       } else {
           return invocation.invoke();
       }
   }

而在doenterpagevariables 对应的action中，input对应的是渲染vm模板？

1
2
3
4
5
<action name="doenterpagevariables" class="com.atlassian.confluence.pages.actions.PageVariablesAction" method="doEnter">
    <result name="error" type="velocity">/pages/createpage-entervariables.vm</result>
    <result name="input" type="velocity">/pages/createpage-entervariables.vm</result>
    <result name="success" type="velocity">/pages/createpage.vm</result>
</action>

疑问：为什么error 和input也是渲染模板，success也是

upload successful

疑问，这里问什么这了多resultconfig，xml中只配置了3个。

提示：有些interceptor会返回input的result，也会触发对应的result处理，不一定全在action 逻辑中。

3.1.3 createpage

同样的，先看result映射
upload successful

3.2 认证相关 Interceptors

  • ConfluenceAccessInterceptor
  • PageAwareInterceptor
  • PermissionCheckInterceptor
  • UserAwareInterceptor

3.2.1 ConfluenceAccessInterceptor

总结：

ConfluenceAccessInterceptor 是用来实现以下四个注解的，

  1. PublicAccess: 所有都可访问
  2. RequiresAnyConfluenceAccess: 对应LICENSED_ACCESS/UNLICENSED_AUTHENTICATED_ACCESS/ANONYMOUS_ACCESS
  3. RequiresLicensedConfluenceAccess：对应LICENSED_ACCESS
  4. RequiresLicensedOrAnonymousConfluenceAccess
    逻辑1: 如果目标 package / class / method 没有以上的注解，那么返回ABSTIN，也可以认证通过
    逻辑2: 如果目标 package / class / method 有以上注解，那么和当前用户对应的权限进行匹配，返回 GRANTED / DENIED。

具体逻辑如下：

1
2
3
4
5
6
7
public String intercept(ActionInvocation actionInvocation) throws Exception {
    return ContainerManager.isContainerSetup() && !this.isAccessPermitted(actionInvocation) ? "notpermitted" : actionInvocation.invoke();
}

private boolean isAccessPermitted(ActionInvocation actionInvocation) {
    return ((ActionAccessChecker)this.actionAccessChecker.get()).isAccessPermitted(actionInvocation.getAction(), actionInvocation.getProxy().getConfig().getMethodName());
}

Access 判断逻辑
ActionAccessChecker

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public boolean isAccessPermitted(Object action, @Nullable String methodName) {
    if (action instanceof ConfluenceActionSupport) {
        ConfluenceActionSupport actionSupport = (ConfluenceActionSupport)action;
        ConfluenceUser currentUser = AuthenticatedUserThreadLocal.get();
        // 跟踪
        AccessDecision decision = this.checkUserAccessFromAnnotations(action.getClass(), methodName, currentUser);
        switch (decision) {
            case GRANTED:
                actionSupport.setSkipAccessCheck(true);
                return true;
            case DENIED:
                this.eventPublisher.publish(new NoConfluencePermissionEvent(this));
                return false;
            default:
                return true;
        }
    } else {
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
private AccessDecision checkUserAccessFromAnnotations(Class<?> actionClass, @Nullable String methodName, ConfluenceUser currentUser) {
    Supplier<AccessStatus> accessStatusSupplier = Lazy.supplier(() -> {
     // 注意这里，根据user返回对应的权限，其值在AccessStatusImpl 结构中，有四个区之，详情见下面
        return this.confluenceAccessManager.getUserAccessStatus(currentUser);
    });
    // 获取目标方法/类/package 的注释
    Iterator var5 = this.getOrderedAnnotatedElements(actionClass, methodName).iterator();

    AccessDecision currentAccessDecision;
    // 如果没有注释，那么返回ABSTAIN
    do {
        if (!var5.hasNext()) {
            return ActionAccessChecker.AccessDecision.ABSTAIN;
        }

        AnnotatedElement annotatedElement = (AnnotatedElement)var5.next();
        currentAccessDecision = checkAccessAnnotations(annotatedElement, accessStatusSupplier);
        // 一直找到GRANTED/ DENIED的为止
    } while(currentAccessDecision != ActionAccessChecker.AccessDecision.GRANTED && currentAccessDecision != ActionAccessChecker.AccessDecision.DENIED);

    return currentAccessDecision;
}

AccessStatusImpl结构

  • LICENSED_ACCESS
  • UNLICENSED_AUTHENTICATED_ACCESS
  • ANONYMOUS_ACCESS
  • NOT_PERMITTED

upload successful

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
static AccessDecision checkAccessAnnotations(AnnotatedElement annotatedElement, Supplier<AccessStatus> accessStatusSupplier) {
        boolean foundAccessCheckAnnotation = false;
        Iterator var3 = POSITIVE_ACCESS_CHECKS.entrySet().iterator();

        while(var3.hasNext()) {
            Map.Entry<Class<? extends Annotation>, Predicate<AccessStatus>> accessCheckAnnotationEntry = (Map.Entry)var3.next();
            if (annotatedElement.isAnnotationPresent((Class)accessCheckAnnotationEntry.getKey())) {
                foundAccessCheckAnnotation = true;
                Predicate<AccessStatus> accessCheckPredicate = (Predicate)accessCheckAnnotationEntry.getValue();
                if (accessCheckPredicate.apply(accessStatusSupplier.get())) {
                    return ActionAccessChecker.AccessDecision.GRANTED;
                }
            }
        }

        if (foundAccessCheckAnnotation) {
            return ActionAccessChecker.AccessDecision.DENIED;
        } else {
            return ActionAccessChecker.AccessDecision.ABSTAIN;
        }
    }

upload successful

四个权限相关的注解

  • PublicAccess: 所有都可访问
  • RequiresAnyConfluenceAccess: 对应LICENSED_ACCESS/UNLICENSED_AUTHENTICATED_ACCESS/ANONYMOUS_ACCESS
  • RequiresLicensedConfluenceAccess：对应LICENSED_ACCESS
  • RequiresLicensedOrAnonymousConfluenceAccess：对应LICENSED_ACCESS / UNLICENSED_AUTHENTICATED_ACCESS

其对应的验证逻辑如下：

1
2
3
4
5
6
7
8
9
private static final Map<Class<? extends Annotation>, Predicate<AccessStatus>> POSITIVE_ACCESS_CHECKS = ImmutableMap.builder().put(PublicAccess.class, (accessStatus) -> {
    return true;
}).put(RequiresAnyConfluenceAccess.class, (accessStatus) -> {
    return accessStatus.canUseConfluence();
}).put(RequiresLicensedConfluenceAccess.class, (accessStatus) -> {
    return accessStatus.hasLicensedAccess();
}).put(RequiresLicensedOrAnonymousConfluenceAccess.class, (accessStatus) -> {
    return accessStatus.hasLicensedAccess() || accessStatus.hasAnonymousAccess();
}).build();

举个注解的例子

1
2
3
@RequiresAnyConfluenceAccess
@ReadOnlyAccessBlocked
public class LikeAction extends ConfluenceActionSupport {

3.2.2 PageAwareInterceptor

PageAwareInterceptor 也是权限相关，。总结：

PageAwareInterceptor 是理解是负责confluence page权限的。

看看具体的逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public String intercept(ActionInvocation actionInvocation) throws Exception {
    Ticker ignored = Timers.start("PageAwareInterceptor.intercept()");
    Throwable var3 = null;

    try {
        Action action = actionInvocation.getAction();
        // 如果不是Page 相关action，那么调用下一个interceptor
        if (!(action instanceof PageAware)) {
            String var23 = actionInvocation.invoke();
            return var23;
        } else {
        	// 如果是Page 相关action
            PageAware pageAware = (PageAware)action;
            // 判断对当前page是否有权限
            // 
            PageAwareHelper.Result result = ((PageAwareHelper)this.helperRef.get()).configure(pageAware, ServletActionContext.getRequest(), this::getParameter);
            String var7;
            switch (result) {
                case NOT_PERMITTED:
                    var7 = "notpermitted";
                    return var7;
                case PAGE_NOT_PERMITTED:
                    var7 = "pagenotpermitted";
                    return var7;
                case PAGE_NOT_FOUND:
                    var7 = "pagenotfound";
                    return var7;
                case READ_ONLY:
                    var7 = "readonly";
                    return var7;
                case OK:
                    var7 = actionInvocation.invoke();
                    return var7;
                default:
                    throw new IllegalStateException("Unhandled result type: " + result);
            }
        }

具体逻辑如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public @NonNull Result configure(PageAware pageAware, HttpServletRequest servletRequest, ParameterSource parameterSource) {
    RequestHelper helper = new RequestHelper(parameterSource);
    AbstractPage page = helper.getPage();
    AbstractPage draft = helper.getDraft();
    if (page != null && pageAware.isLatestVersionRequired()) {
        page = page.getLatestVersion();
    } else if (draft != null && pageAware.isLatestVersionRequired() && !draft.getLatestVersion().isDraft()) {
        page = draft.getLatestVersion();
    }

    if (log.isDebugEnabled()) {
        log.debug("Set page on PageAware " + pageAware.getClass().getName() + ": " + page);
    }

    if (page != null) {
        pageAware.setPage(page);
    }

    Space space = helper.getSpace(page);
    if (space == null && StringUtils.isNotEmpty(helper.getSpaceKeyFromParameter()) || space != null && !this.permissionManager.hasPermission(AuthenticatedUserThreadLocal.get(), Permission.VIEW, space)) {
        return AuthenticatedUserThreadLocal.get() == null ? PageAwareHelper.Result.NOT_PERMITTED : PageAwareHelper.Result.PAGE_NOT_FOUND;
    } else if (page == null && pageAware.isPageRequired()) {
        return PageAwareHelper.Result.PAGE_NOT_FOUND;
    } else if (page != null && page.isDeleted() && pageAware.isPageRequired()) {
        PageReference.set(servletRequest, page.getSpaceKey(), page.getTitle());
        return PageAwareHelper.Result.PAGE_NOT_FOUND;
    } else if (page == null || !pageAware.isPageRequired() || (!pageAware.isViewPermissionRequired() || this.hasPermission(page, Permission.VIEW)) && (!pageAware.isEditPermissionRequired() || this.hasPermission(page, Permission.EDIT))) {
        if ((pageAware instanceof CreatePageEntryAction || pageAware instanceof CreateBlogPostAction) && !((AbstractCreatePageAction)pageAware).isPermitted()) {
            return this.accessModeService.isReadOnlyAccessModeEnabled() ? PageAwareHelper.Result.READ_ONLY : PageAwareHelper.Result.PAGE_NOT_PERMITTED;
        } else {
            if (page != null && space != null) {
                boolean hasVewPermissions = this.hasPermission(page, Permission.VIEW);
                if (hasVewPermissions) {
                    this.webResourceManager.putMetadata("page-title", page.getTitle());
                    this.webResourceManager.putMetadata("latest-published-page-title", page.getTitle());
                    this.webResourceManager.putMetadata("space-name", space.getName());
                }

                this.webResourceManager.putMetadata("page-id", page.getIdAsString());
                this.webResourceManager.putMetadata("latest-page-id", page.getLatestVersion().getIdAsString());
                this.webResourceManager.putMetadata("content-type", page.getType());
                String parentPageId = "";
                if (page instanceof Page) {
                    Page p = (Page)page;
                    Page parent = p.getParent();
                    if (parent != null) {
                        parentPageId = parent.getIdAsString();
                        if (hasVewPermissions) {
                            this.webResourceManager.putMetadata("parent-page-title", parent.getTitle());
                        }
                    }
                }

                this.webResourceManager.putMetadata("parent-page-id", parentPageId);
                this.webResourceManager.putMetadata("space-key", space.getKey());
            } else if (draft != null) {
                this.webResourceManager.putMetadata("page-id", draft.getIdAsString());
            }

            this.webResourceManager.putMetadata("max-number-editors", String.valueOf(this.collaborativeEditingHelper.getUserLimit()));
            this.webResourceManager.putMetadata("macro-placeholder-timeout", Long.getLong("confluence.macro.placeholder.timeoutMillis", 5000L).toString());
            return PageAwareHelper.Result.OK;
        }
    } else {
        return PageAwareHelper.Result.PAGE_NOT_PERMITTED;
    }
}

具体不跟踪了，应该是confulence 文章/空间的权限问题。

3.2.3 PermissionCheckInterceptor

也是个权限相关的Interceptor，总结：

PermissionCheckInterceptor 是检测读写行为相关的
逻辑1: 未安装完成时，都是可写的（未安装完成也无法开启只读模式）
逻辑2: 如果开启了只读模式（默认不启用，可以参考https://blog.csdn.net/u013587602/article/details/84926864）
a. 如果action 的package / class / method 有ReadOnlyAccessBlocked 注解，那么返回readonly
b. 默认返回readonly
c. 逻辑3.a 中存在一种特殊情况
逻辑3: 如果action isPermitted 为false，默认返回”notpermitted”，除非一下情况
a. 如果开启readonly只读模式，且是POST/PUT/DELETE 操作，而且namespace是/admin开头、或者package / class / method 有ReadOnlyAccessAllowed 注解，那么允许访问，否则返回readonly
b. 如果是space 相关action，并且当前space 是私有的，那么返回”notpermittedpersonal”
逻辑4: 其他情况，返回ok

看看具体逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public String intercept(ActionInvocation actionInvocation) throws Exception {
    Action action = actionInvocation.getAction();

    try {
    	// 同样，只处理 ConfluenceActionSupport 的Action，否则交由下一个Interceptor
        if (action instanceof ConfluenceActionSupport) {
            ConfluenceActionSupport confluenceAction = (ConfluenceActionSupport)action;
            // class
            Class<? extends Action> actionClass = actionInvocation.getAction().getClass();
            // package
            Package actionClassPackage = actionClass.getPackage();
            String var7;
            // 判断是否安装，并且启用了只读模式
            if (ContainerManager.isContainerSetup() && this.getAccessModeService().isReadOnlyAccessModeEnabled()) {
            	// 如果package或者class 有注解 ReadOnlyAccessBlocked
                if (this.isAnnotated(actionClassPackage, "ReadOnlyAccessBlocked") || this.isAnnotated(actionClass, "ReadOnlyAccessBlocked")) {
                	// 那么返回readonly
                    String var13 = "readonly";
                    return var13;
                }
	// method
                Method method = this.getMethod(actionInvocation, actionClass);
                // 如果method有ReadOnlyAccessBlocked 注解，那么也返回readonly
                if (this.isAnnotated(method, "ReadOnlyAccessBlocked")) {
                    var7 = "readonly";
                    return var7;
                }
	// 判断：如果namespace 是/admin，或者class / package/ method 有ReadOnlyAccessAllowed 注解，那么启用线程readonly 设置为true
                if (this.isReadOnlyAccessAllowed(actionInvocation, actionClassPackage, actionClass)) {
                    ThreadLocalReadOnlyAccessCacheInternal.enableReadOnlyAccessExemption();
                }
            }
            
// 具体看下面的逻辑 
            // 如果没有权限
            if (!confluenceAction.isPermitted()) {
                log.debug("Not permitted to execute action of class {} ", confluenceAction.getClass());
                HttpServletRequest request = ServletActionContext.getRequest();
                // 如果启用了只读模式，并且当前http method为PUT/POST/DELETE
                if (this.getAccessModeService().isReadOnlyAccessModeEnabled() && this.isMutativeHttpMethod(request.getMethod())) {
                	// 获取当前线程下的readonly变量，如果为true，那么不做操作，继续下一个，否则返回readonly
                    var7 = ThreadLocalReadOnlyAccessCacheInternal.hasReadOnlyAccessExemption() ? actionInvocation.invoke() : "readonly";
                    return var7;
                }
	// 如果是space相关action，判断当前space是否是私人项目，如果是，返回"notpermittedpersonal"
                if (confluenceAction instanceof Spaced && ((Spaced)confluenceAction).getSpace() != null && ((Spaced)confluenceAction).getSpace().isPersonal()) {
                    var7 = "notpermittedpersonal";
                    return var7;
                }

                var7 = "notpermitted";
                return var7;
            }
        }

        String var11 = actionInvocation.invoke();
        return var11;
  1. ContainerManager.isContainerSetup() 判断是否安装
1
2
3
4
private boolean isReadOnlyAccessAllowed(ActionInvocation actionInvocation, Package actionClassPackage, Class<? extends Action> actionClass) {
    Method method = this.getMethod(actionInvocation, actionClass);
    return StringUtils.startsWith(actionInvocation.getProxy().getNamespace(), "/admin") || this.isAnnotated(actionClassPackage, "ReadOnlyAccessAllowed") || this.isAnnotated(actionClass, "ReadOnlyAccessAllowed") || this.isAnnotated(method, "ReadOnlyAccessAllowed");
}

功能：

  1. 如果namespace 以/admin开始
  2. 或者class / package/ method 有ReadOnlyAccessAllowed 注解，那么返回true

    这里存在问题

isPermitted

1
2
3
4
5
6
7
8
9
10
11
12
13
 public boolean isPermitted() {
 	// 如果没有安装完成，那么直接返回true
     if (!this.getBootstrapManager().isSetupComplete()) {
         return true;
     } else {
     	// 否则，查看当前用户是否有访问 USECONFLUENCE的权限
         if (!this.skipAccessCheck && !this.spacePermissionManager.hasPermission("USECONFLUENCE", (Space)null, this.getAuthenticatedUser())) {
             this.eventManager.publishEvent(new NoConfluencePermissionEvent(this));
         }
// 返回当前用户是否有所有space 的权限
         return this.spacePermissionManager.hasAllPermissions(this.getPermissionTypes(), (Space)null, this.getAuthenticatedUser());
     }
 }
  • 个人理解：除开admin，这里都会false，未验证
  • 实际测试：未登陆用户isPermitted 也为true ？？所以未登录客户可以直接bypass这个规则。

重要：

3.2.4 UserAwareInterceptor

总结：

UserAwareInterceptor 是鉴定和用户相关操作的

具体逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public String intercept(ActionInvocation actionInvocation) throws Exception {
    Ticker ignored = Timers.start("UserAwareInterceptor.intercept()");
    Throwable var3 = null;

    try {
        Action action = actionInvocation.getAction();
        // 用户相关操作
        if (action instanceof UserAware) {
            UserAware userAware = (UserAware)action;
            // 目标用户，比如feed某人
            User targetUser = userAware.getUser();
            // action需要查看用户的权限
            if (userAware.isViewPermissionRequired()) {
            	// 当前用户
                ConfluenceUser loggedInUser = AuthenticatedUserThreadLocal.get();
                // 判断当前用户可以查看目标用户
                if (!this.canBrowseUsers(loggedInUser)) {
                    String var8 = "notpermitted";
                    return var8;
                }
            }
// 如果action需要目标用户，但是目标用户不存在
            if (userAware.isUserRequired() && targetUser == null) {
                String var21 = "notfound";
                return var21;
            }
        }

3.2.5 SetupCheckInterceptor

前文中，判断是否已经安装有通过

  • ContainerManager.isContainerSetup()
  • this.getBootstrapManager().isSetupComplete()

在SetupCheckInterceptor 中，同时检验了这两处。

1
2
3
public String intercept(ActionInvocation actionInvocation) throws Exception {
    return BootstrapUtils.getBootstrapManager().isSetupComplete() && ContainerManager.isContainerSetup() ? "alreadysetup" : actionInvocation.invoke();
}

3.2.6 SetupIncompleteInterceptor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public String intercept(ActionInvocation invocation) throws Exception {
    HttpServletRequest request = ServletActionContext.getRequest();
    if (request != null && !StringUtils.isBlank(request.getServletPath()) && !this.shouldPassThrough(request.getServletPath())) {
        if (!this.isSetupComplete()) {
            String servletPath = request.getServletPath();
            if (!silentRedirects.contains(servletPath)) {
                log.warn("Redirecting request to current setup step: {}", HtmlUtil.htmlEncode(servletPath));
            }

            return "notsetup";
        } else {
            return invocation.invoke();
        }
    } else {
        return invocation.invoke();
    }
1
2
3
private boolean isSetupComplete() {
    return ContainerManager.isContainerSetup() && ((BootstrapManager)this.bootstrapManagerSupplier.get()).isSetupComplete();
}

逻辑同上，不过是检测没安装完成，如果没安装完成，就返回notsetup，进入安装。

3.3 区别

interceptor doenterpagevariables createpage
ConfluenceAccessInterceptor Y Y
PageAwareInterceptor Y pagenotpermitted

upload successful

注意这里的pageAware instanceof CreatePageEntryAction 导致进入了PAGE_NOT_PERMITTED 逻辑。
在doenterpagevariables中，直接进入到最下面的PageAwareHelper.Result.OK。

疑问：可能是健壮性设计要求？这个像个白名单逻辑，很容易出问题。

3.4 isPermitted

isPermitted 在最基础的ConfluenceActionSupport 类中出现，其他的子类中，也有对这一方法的重写。

如果还记得PermissionCheckInterceptor，中间有这么一段逻辑

1
2
3
4
5
6
7
8
    if (!confluenceAction.isPermitted()) {
    	...
    	var7 = "notpermitted";
        return var7;
    }
}
String var11 = actionInvocation.invoke();
return var11;

这里才是整个action权限验证的关键：重写isPermitted 实现权限约束。

3.4.1 admin权限

看看admin 相关action是如何通过isPermitted 实现权限约束的。

举个例子：ConfigureLog4jAction，管理员配置日志功能

1
2
3
public boolean isPermitted() {
    return this.permissionManager.hasPermission(this.getAuthenticatedUser(), Permission.ADMINISTER, PermissionManager.TARGET_SYSTEM);
}

0x04 漏洞挖掘

从漏洞关键点出发：

利用namespace 继承父namespace 的actions，但是default interceptor 用的却不是父namespace的，会造成interceptors的不一致

4.1 Actions with default Interceptor

思路如下：

setup namespace 默认setupStack，有SetupCheckInterceptor

admin/json namespace 默认validatingStack，没有setupStack

看看有哪些setup namespace 中没有SetupCheckInterceptor 的action。

筛选下来，有以下action：

  • getbundles
  • dosetuplicense
  • setupcluster
  • setupdatasourcedb
  • setupadministrator
  • setup-restore
  • setup-restore-local
  • finishsetup
  • finishclustersetup

试试/json/getbundles.action，发现过不了，原因为：

GetBundlesAction extends AbstractSetupAction，其isPermitted 接口如下：

1
2
3
public boolean isPermitted() {
    return !GeneralUtil.isSetupComplete();
}

剩下几个类似，也都是AbstractSetupAction子类，也没有重写isPermitted

4.2 setup-restore & setup-restore-local 未授权访问

直到setup-restore，重写了isPermitted，always true，导致可以为授权访问。

SetupRestoreAction

1
2
3
public boolean isPermitted() {
    return true;
}

但是发现过不了XsrfTokenInterceptor 的alt_token

1
2
3
public boolean validateToken(HttpServletRequest request, String token) {
    return token != null && token.equals(request.getSession(true).getAttribute("atlassian.xsrf.token"));
}

SSRF Token，在实现上，Confluence 并没有一个From & Session 一个Token，而是一个Session 一个Token，所以可以找到其他的未授权的From 表单，找到对应的atl_token

找到了login.action 登陆接口。

至此实现了未授权访问

4.3 setup-restore 网站备份恢复

恰巧的是setup-restore.action 是网站备份恢复接口，post 个zip 过去可以直接覆盖网站。

所以这是个“坐牢洞”，会严重影响系统数据，不可以在线上尝试。

搭配参考文章2中的Confluence 后台RCE，应该可以实现漏洞公告的效果，这里未实际验证，暂不深究了。

0x05 总结与思考

  1. 这是Struts xwrok.xml 配置实现中存在的通用问题：子namespace 会继承父namespace 的actions，但是却不会继承其default interceptors
  2. 算是个逻辑漏洞，作者很细心，也一定是对Struts很了解，由一点小bug引发的RCE

如何才能发现该漏洞：

  1. 深入分析struts 原理，了解namespace 和action、interceptor 机制才能发现
  2. 自动化不能解决此类问题

0x06 参考

  1. https://mp.weixin.qq.com/s/hjCEUJElc8I2H-gtv4gM7w
  2. https://mp.weixin.qq.com/s/TI4_fmt55IH62u5xkAuk_A

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true