java - “特殊” APP用例

我有一些包含如下方法的编译库：

public boolean foo(String userID) {
    Class<?> ntSystemClass = Thread.currentThread().getContextClassLoader()
        .loadClass("com.sun.security.auth.module.NTSystem");
    Method getNameMethod = ntSystemClass.getMethod("getName", null);
    Object ntSystem = ntSystemClass.newInstance();
    String name = (String)getNameMethod.invoke(ntSystem, null);
    boolean same=userID.equalsIgnoreCase(name);
    if (same) {
       // more work done here
    } else {
       // more work done here
    }
}

对于某些相当特殊的用例，我需要确保布尔same始终为true。

我的第一种方法是扩展类并覆盖方法foo()，但这是无法实现的，因为在该方法中，需要其他库私有对象上的许多引用。

因此，下一种方法是使用AOP。我用AspectJ尝试了几件事，但没有找到解决方案。有人可以帮助我们吗？据我了解，我不能直接更改布尔值same。是否可以在库中以任何方式解决String name = (String)getNameMethod.invoke(ntSystem, null);问题？

最佳答案

让我们在这里直接说：从现在起，我假设您的“特殊用例”是您希望调整/破解用户身份验证，希望以合法的方式进行测试或进行其他操作。

要解决的主要问题是：


只需操作您的foo方法的结果将很容易（我已将其重命名为isCurrentUser(String userID)以阐明其意图）。但是，如果我理解正确，该方法会产生副作用，即它调用其他方法，并且您希望保留这些副作用。因此，我们必须更加小心，并使用手术刀，而不是斧头。
没有局部变量更改的切入点，因此您必须截获更改局部变量值的方法执行或调用。
AspectJ通常无法截获JDK方法execution()（除非您想先编织JDK，这是可能的，但不在本文范围之内）。因此，您必须从自己的代码中截取call()。我假设即使它包含在JAR中并且您没有源，也可以将其编入该代码中。您可以将LTW用于目标类，也可以将Java用于JAR的二进制编织，以创建新的编织版本。
您对NTSystem.getName()的方法调用不是正常方式，而是通过Reflection API。因此，您不能仅使用像call(NTSystem.getName())这样的切入点，因为它永远不会被触发。您必须拦截call(public Object Method.invoke(Object, Object...))。
从理论上讲，可能是在isCurrentUser(..)内部进行了其他反射方法调用，因此我们必须优化切入点，以便仅在真正调用NTSystem.getName()时才匹配，而不是其他方法。
作为一项便利功能，我们希望能够动态地打开和关闭hackingMode。


现在，这里是一个完整的，可编译的代码示例（显然，仅在Windows上可以像您自己的代码片段一样工作）：

Java类，其中包含要操作的方法和用于演示目的的主要方法：

package de.scrum_master.app;

import java.lang.reflect.Method;

import de.scrum_master.aspect.TweakAuthenticationAspect;

public class UserAuthentication {
    private static final String USER_NAME_GOOD = "alexander"; // Add your own user name here
    private static final String USER_NAME_BAD = "hacker";

    public static boolean isCurrentUser(String userID) throws Exception {
        Class<?> ntSystemClass = Thread.currentThread().getContextClassLoader()
                .loadClass("com.sun.security.auth.module.NTSystem");
        Method getNameMethod = ntSystemClass.getMethod("getName");
        Object ntSystem = ntSystemClass.newInstance();
        String currentUserID = (String) getNameMethod.invoke(ntSystem);
        boolean same = userID.equalsIgnoreCase(currentUserID);
        if (same) {
            System.out.println("Do something (same == true)");
        } else {
            System.out.println("Do something (same == false)");
        }
        return same;
    }

    public static void main(String[] args) throws Exception {
        testAuthentication(false);
        testAuthentication(true);
    }

    private static void testAuthentication(boolean hackingMode) throws Exception {
        TweakAuthenticationAspect.hackingMode = hackingMode;
        System.out.println("Testing authentication for hackingMode == " + hackingMode);
        System.out.println("Authentication result for " + USER_NAME_GOOD + ": "
                + isCurrentUser(USER_NAME_GOOD));
        System.out.println("Authentication result for " + USER_NAME_BAD + ": "
                + isCurrentUser(USER_NAME_BAD));
        System.out.println();
    }
}

如您所见，testAuthentication(boolean hackingMode)被调用两次，一次是禁用黑客代码，然后再启用。在这两种情况下，它都会先测试一个好/正确的用户名（请编辑！），然后再测试一个错误的用户名（“黑客”）。

方面操纵身份验证方法：

package de.scrum_master.aspect;

import com.sun.security.auth.module.NTSystem;
import de.scrum_master.app.UserAuthentication;
import java.lang.reflect.Method;

public aspect TweakAuthenticationAspect {
    public static boolean hackingMode = false;

    pointcut reflectiveCall_NTSystem_getName(NTSystem ntSystem, Method method) :
        call(public Object Method.invoke(Object, Object...)) &&
        args(ntSystem, *) &&
        target(method) &&
        if(method.getName().equals("getName"));

    pointcut cflow_isCurrentUser(String userID) :
        cflow(
            execution(* UserAuthentication.isCurrentUser(String)) &&
            args(userID)
        );

    Object around(NTSystem ntSystem, Method method, String userID) :
        reflectiveCall_NTSystem_getName(ntSystem, method) &&
        cflow_isCurrentUser(userID) &&
        if(hackingMode)
    {
        System.out.println("Join point: " + thisJoinPoint);
        System.out.println("Given user ID: " + userID);
        System.out.println("Reflectively called method: " + method);
        return userID;
    }
}

这里有几句话解释：


Pointcut reflectiveCall_NTSystem_getName拦截对Method.invoke(..)的调用，将第一个参数限制为NTSystem类型，从而消除了对其他类的反射调用。它还检查目标方法是否实际上是getName。即切入点检查是否真的要调用NTSystem.getName（）`。
切入点cflow_isCurrentUser在方法UserAuthentication.isCurrentUser(..)的控制流中捕获连接点，公开其参数userID供以后使用。
around(NTSystem ntSystem, Method method, String userID)建议将两个切入点与&&组合在一起，并可以访问其签名中的三个命名对象。在其方法主体中，我们可以对这些对象做任何我们想做的事情，例如将它们打印到控制台。我们还可以更改它们的状态，在这种情况下这是不必要的。建议通过if(hackingMode)动态激活。如果不需要，可以将其删除，这只是为了方便。因为我们在这里使用around()建议，所以我们可以返回任何内容，而不是原始方法的结果。在这种情况下，我们总是返回userID，就像给定的用户是当前登录Windows的用户一样。这有效地导致局部same变量始终变为true，因为对equalsIgnoreCase(..)的调用也总是返回true。
我也可以直接操纵equalsIgnoreCase(..)的结果，但是局部变量currentUserID将不等于userID。根据所需的副作用种类，可以根据自己的喜好更改此行为。


样本输出：

Testing authentication for hackingMode == false
Do something (same == true)
Authentication result for alexander: true
Do something (same == false)
Authentication result for hacker: false

Testing authentication for hackingMode == true
Join point: call(Object java.lang.reflect.Method.invoke(Object, Object[]))
Given user ID: alexander
Reflectively called method: public java.lang.String com.sun.security.auth.module.NTSystem.getName()
Do something (same == true)
Authentication result for alexander: true
Join point: call(Object java.lang.reflect.Method.invoke(Object, Object[]))
Given user ID: hacker
Reflectively called method: public java.lang.String com.sun.security.auth.module.NTSystem.getName()
Do something (same == true)
Authentication result for hacker: true

您可以在上部看到，如果hackingMode == false，身份验证将照常进行，但如果使用hackingMode == true，将始终对任何给定的用户名进行肯定身份验证。