Initial commit

sources/com/thoughtworks/xstream/security/AnyTypePermission.java

@@ -0,0 +1,39 @@
+package com.thoughtworks.xstream.security;
+
+/* loaded from: classes.dex */
+public class AnyTypePermission implements TypePermission {
+    public static final TypePermission ANY = new AnyTypePermission();
+    static /* synthetic */ Class class$com$thoughtworks$xstream$security$AnyTypePermission;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.security.TypePermission
+    public boolean allows(Class cls) {
+        return true;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj != null) {
+            Class<?> cls = obj.getClass();
+            Class<?> cls2 = class$com$thoughtworks$xstream$security$AnyTypePermission;
+            if (cls2 == null) {
+                cls2 = class$("com.thoughtworks.xstream.security.AnyTypePermission");
+                class$com$thoughtworks$xstream$security$AnyTypePermission = cls2;
+            }
+            if (cls == cls2) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return 3;
+    }
+}

sources/com/thoughtworks/xstream/security/ArrayTypePermission.java

@@ -0,0 +1,39 @@
+package com.thoughtworks.xstream.security;
+
+/* loaded from: classes.dex */
+public class ArrayTypePermission implements TypePermission {
+    public static final TypePermission ARRAYS = new ArrayTypePermission();
+    static /* synthetic */ Class class$com$thoughtworks$xstream$security$ArrayTypePermission;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.security.TypePermission
+    public boolean allows(Class cls) {
+        return cls != null && cls.isArray();
+    }
+
+    public boolean equals(Object obj) {
+        if (obj != null) {
+            Class<?> cls = obj.getClass();
+            Class<?> cls2 = class$com$thoughtworks$xstream$security$ArrayTypePermission;
+            if (cls2 == null) {
+                cls2 = class$("com.thoughtworks.xstream.security.ArrayTypePermission");
+                class$com$thoughtworks$xstream$security$ArrayTypePermission = cls2;
+            }
+            if (cls == cls2) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return 13;
+    }
+}

sources/com/thoughtworks/xstream/security/CGLIBProxyTypePermission.java

@@ -0,0 +1,66 @@
+package com.thoughtworks.xstream.security;
+
+import net.sf.cglib.proxy.Proxy;
+
+/* loaded from: classes.dex */
+public class CGLIBProxyTypePermission implements TypePermission {
+    public static final TypePermission PROXIES = new CGLIBProxyTypePermission();
+    static /* synthetic */ Class class$com$thoughtworks$xstream$security$CGLIBProxyTypePermission;
+    static /* synthetic */ Class class$java$lang$Object;
+    static /* synthetic */ Class class$net$sf$cglib$proxy$Proxy;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.security.TypePermission
+    public boolean allows(Class cls) {
+        if (cls != null) {
+            Class cls2 = class$java$lang$Object;
+            if (cls2 == null) {
+                cls2 = class$("java.lang.Object");
+                class$java$lang$Object = cls2;
+            }
+            if (cls != cls2 && !cls.isInterface()) {
+                if (!Proxy.isProxyClass(cls)) {
+                    String name = cls.getName();
+                    StringBuffer stringBuffer = new StringBuffer();
+                    Class cls3 = class$net$sf$cglib$proxy$Proxy;
+                    if (cls3 == null) {
+                        cls3 = class$("net.sf.cglib.proxy.Proxy");
+                        class$net$sf$cglib$proxy$Proxy = cls3;
+                    }
+                    stringBuffer.append(cls3.getPackage().getName());
+                    stringBuffer.append(".");
+                    if (name.startsWith(stringBuffer.toString())) {
+                    }
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj != null) {
+            Class<?> cls = obj.getClass();
+            Class<?> cls2 = class$com$thoughtworks$xstream$security$CGLIBProxyTypePermission;
+            if (cls2 == null) {
+                cls2 = class$("com.thoughtworks.xstream.security.CGLIBProxyTypePermission");
+                class$com$thoughtworks$xstream$security$CGLIBProxyTypePermission = cls2;
+            }
+            if (cls == cls2) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return 19;
+    }
+}

sources/com/thoughtworks/xstream/security/ExplicitTypePermission.java

@@ -0,0 +1,45 @@
+package com.thoughtworks.xstream.security;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public class ExplicitTypePermission implements TypePermission {
+    final Set names;
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [com.thoughtworks.xstream.security.ExplicitTypePermission$1] */
+    public ExplicitTypePermission(final Class[] clsArr) {
+        this(new Object() { // from class: com.thoughtworks.xstream.security.ExplicitTypePermission.1
+            public String[] getNames() {
+                Class[] clsArr2 = clsArr;
+                if (clsArr2 == null) {
+                    return null;
+                }
+                String[] strArr = new String[clsArr2.length];
+                int i = 0;
+                while (true) {
+                    Class[] clsArr3 = clsArr;
+                    if (i >= clsArr3.length) {
+                        return strArr;
+                    }
+                    strArr[i] = clsArr3[i].getName();
+                    i++;
+                }
+            }
+        }.getNames());
+    }
+
+    @Override // com.thoughtworks.xstream.security.TypePermission
+    public boolean allows(Class cls) {
+        if (cls == null) {
+            return false;
+        }
+        return this.names.contains(cls.getName());
+    }
+
+    public ExplicitTypePermission(String[] strArr) {
+        this.names = strArr == null ? Collections.EMPTY_SET : new HashSet(Arrays.asList(strArr));
+    }
+}

sources/com/thoughtworks/xstream/security/ForbiddenClassException.java

@@ -0,0 +1,10 @@
+package com.thoughtworks.xstream.security;
+
+import com.thoughtworks.xstream.XStreamException;
+
+/* loaded from: classes.dex */
+public class ForbiddenClassException extends XStreamException {
+    public ForbiddenClassException(Class cls) {
+        super(cls == null ? "null" : cls.getName());
+    }
+}

sources/com/thoughtworks/xstream/security/InterfaceTypePermission.java

@@ -0,0 +1,39 @@
+package com.thoughtworks.xstream.security;
+
+/* loaded from: classes.dex */
+public class InterfaceTypePermission implements TypePermission {
+    public static final TypePermission INTERFACES = new InterfaceTypePermission();
+    static /* synthetic */ Class class$com$thoughtworks$xstream$security$InterfaceTypePermission;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.security.TypePermission
+    public boolean allows(Class cls) {
+        return cls != null && cls.isInterface();
+    }
+
+    public boolean equals(Object obj) {
+        if (obj != null) {
+            Class<?> cls = obj.getClass();
+            Class<?> cls2 = class$com$thoughtworks$xstream$security$InterfaceTypePermission;
+            if (cls2 == null) {
+                cls2 = class$("com.thoughtworks.xstream.security.InterfaceTypePermission");
+                class$com$thoughtworks$xstream$security$InterfaceTypePermission = cls2;
+            }
+            if (cls == cls2) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return 31;
+    }
+}

sources/com/thoughtworks/xstream/security/NoPermission.java

@@ -0,0 +1,19 @@
+package com.thoughtworks.xstream.security;
+
+/* loaded from: classes.dex */
+public class NoPermission implements TypePermission {
+    private final TypePermission permission;
+
+    public NoPermission(TypePermission typePermission) {
+        this.permission = typePermission;
+    }
+
+    @Override // com.thoughtworks.xstream.security.TypePermission
+    public boolean allows(Class cls) {
+        TypePermission typePermission = this.permission;
+        if (typePermission == null || typePermission.allows(cls)) {
+            throw new ForbiddenClassException(cls);
+        }
+        return false;
+    }
+}

sources/com/thoughtworks/xstream/security/NoTypePermission.java

@@ -0,0 +1,39 @@
+package com.thoughtworks.xstream.security;
+
+/* loaded from: classes.dex */
+public class NoTypePermission implements TypePermission {
+    public static final TypePermission NONE = new NoTypePermission();
+    static /* synthetic */ Class class$com$thoughtworks$xstream$security$NoTypePermission;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.security.TypePermission
+    public boolean allows(Class cls) {
+        throw new ForbiddenClassException(cls);
+    }
+
+    public boolean equals(Object obj) {
+        if (obj != null) {
+            Class<?> cls = obj.getClass();
+            Class<?> cls2 = class$com$thoughtworks$xstream$security$NoTypePermission;
+            if (cls2 == null) {
+                cls2 = class$("com.thoughtworks.xstream.security.NoTypePermission");
+                class$com$thoughtworks$xstream$security$NoTypePermission = cls2;
+            }
+            if (cls == cls2) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return 1;
+    }
+}

sources/com/thoughtworks/xstream/security/NullPermission.java

@@ -0,0 +1,30 @@
+package com.thoughtworks.xstream.security;
+
+/* loaded from: classes.dex */
+public class NullPermission implements TypePermission {
+    public static final TypePermission NULL = new NullPermission();
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$Mapper$Null;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.security.TypePermission
+    public boolean allows(Class cls) {
+        if (cls != null) {
+            Class cls2 = class$com$thoughtworks$xstream$mapper$Mapper$Null;
+            if (cls2 == null) {
+                cls2 = class$("com.thoughtworks.xstream.mapper.Mapper$Null");
+                class$com$thoughtworks$xstream$mapper$Mapper$Null = cls2;
+            }
+            if (cls != cls2) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

sources/com/thoughtworks/xstream/security/PrimitiveTypePermission.java

@@ -0,0 +1,73 @@
+package com.thoughtworks.xstream.security;
+
+/* loaded from: classes.dex */
+public class PrimitiveTypePermission implements TypePermission {
+    public static final TypePermission PRIMITIVES = new PrimitiveTypePermission();
+    static /* synthetic */ Class class$com$thoughtworks$xstream$security$PrimitiveTypePermission;
+    static /* synthetic */ Class class$java$lang$Void;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:9:0x0018, code lost:
+    
+        if (r2.isPrimitive() != false) goto L13;
+     */
+    @Override // com.thoughtworks.xstream.security.TypePermission
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    public boolean allows(java.lang.Class r2) {
+        /*
+            r1 = this;
+            if (r2 == 0) goto L1a
+            java.lang.Class r0 = java.lang.Void.TYPE
+            if (r2 == r0) goto L1a
+            java.lang.Class r0 = com.thoughtworks.xstream.security.PrimitiveTypePermission.class$java$lang$Void
+            if (r0 != 0) goto L12
+            java.lang.String r0 = "java.lang.Void"
+            java.lang.Class r0 = class$(r0)
+            com.thoughtworks.xstream.security.PrimitiveTypePermission.class$java$lang$Void = r0
+        L12:
+            if (r2 == r0) goto L1a
+            boolean r0 = r2.isPrimitive()
+            if (r0 != 0) goto L20
+        L1a:
+            boolean r2 = com.thoughtworks.xstream.core.util.Primitives.isBoxed(r2)
+            if (r2 == 0) goto L22
+        L20:
+            r2 = 1
+            goto L23
+        L22:
+            r2 = 0
+        L23:
+            return r2
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.security.PrimitiveTypePermission.allows(java.lang.Class):boolean");
+    }
+
+    public boolean equals(Object obj) {
+        if (obj != null) {
+            Class<?> cls = obj.getClass();
+            Class<?> cls2 = class$com$thoughtworks$xstream$security$PrimitiveTypePermission;
+            if (cls2 == null) {
+                cls2 = class$("com.thoughtworks.xstream.security.PrimitiveTypePermission");
+                class$com$thoughtworks$xstream$security$PrimitiveTypePermission = cls2;
+            }
+            if (cls == cls2) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return 7;
+    }
+}

sources/com/thoughtworks/xstream/security/ProxyTypePermission.java

@@ -0,0 +1,54 @@
+package com.thoughtworks.xstream.security;
+
+import java.lang.reflect.Proxy;
+
+/* loaded from: classes.dex */
+public class ProxyTypePermission implements TypePermission {
+    public static final TypePermission PROXIES = new ProxyTypePermission();
+    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$DynamicProxyMapper$DynamicProxy;
+    static /* synthetic */ Class class$com$thoughtworks$xstream$security$ProxyTypePermission;
+
+    static /* synthetic */ Class class$(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e) {
+            throw new NoClassDefFoundError().initCause(e);
+        }
+    }
+
+    @Override // com.thoughtworks.xstream.security.TypePermission
+    public boolean allows(Class cls) {
+        if (cls != null) {
+            if (!Proxy.isProxyClass(cls)) {
+                Class cls2 = class$com$thoughtworks$xstream$mapper$DynamicProxyMapper$DynamicProxy;
+                if (cls2 == null) {
+                    cls2 = class$("com.thoughtworks.xstream.mapper.DynamicProxyMapper$DynamicProxy");
+                    class$com$thoughtworks$xstream$mapper$DynamicProxyMapper$DynamicProxy = cls2;
+                }
+                if (cls == cls2) {
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj != null) {
+            Class<?> cls = obj.getClass();
+            Class<?> cls2 = class$com$thoughtworks$xstream$security$ProxyTypePermission;
+            if (cls2 == null) {
+                cls2 = class$("com.thoughtworks.xstream.security.ProxyTypePermission");
+                class$com$thoughtworks$xstream$security$ProxyTypePermission = cls2;
+            }
+            if (cls == cls2) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return 17;
+    }
+}

sources/com/thoughtworks/xstream/security/RegExpTypePermission.java

@@ -0,0 +1,46 @@
+package com.thoughtworks.xstream.security;
+
+import java.util.regex.Pattern;
+
+/* loaded from: classes.dex */
+public class RegExpTypePermission implements TypePermission {
+    private final Pattern[] patterns;
+
+    public RegExpTypePermission(String[] strArr) {
+        this(getPatterns(strArr));
+    }
+
+    private static Pattern[] getPatterns(String[] strArr) {
+        if (strArr == null) {
+            return null;
+        }
+        Pattern[] patternArr = new Pattern[strArr.length];
+        for (int i = 0; i < patternArr.length; i++) {
+            patternArr[i] = Pattern.compile(strArr[i]);
+        }
+        return patternArr;
+    }
+
+    @Override // com.thoughtworks.xstream.security.TypePermission
+    public boolean allows(Class cls) {
+        if (cls != null) {
+            String name = cls.getName();
+            int i = 0;
+            while (true) {
+                Pattern[] patternArr = this.patterns;
+                if (i >= patternArr.length) {
+                    break;
+                }
+                if (patternArr[i].matcher(name).matches()) {
+                    return true;
+                }
+                i++;
+            }
+        }
+        return false;
+    }
+
+    public RegExpTypePermission(Pattern[] patternArr) {
+        this.patterns = patternArr == null ? new Pattern[0] : patternArr;
+    }
+}

sources/com/thoughtworks/xstream/security/TypeHierarchyPermission.java

@@ -0,0 +1,18 @@
+package com.thoughtworks.xstream.security;
+
+/* loaded from: classes.dex */
+public class TypeHierarchyPermission implements TypePermission {
+    private Class type;
+
+    public TypeHierarchyPermission(Class cls) {
+        this.type = cls;
+    }
+
+    @Override // com.thoughtworks.xstream.security.TypePermission
+    public boolean allows(Class cls) {
+        if (cls == null) {
+            return false;
+        }
+        return this.type.isAssignableFrom(cls);
+    }
+}

sources/com/thoughtworks/xstream/security/TypePermission.java

@@ -0,0 +1,6 @@
+package com.thoughtworks.xstream.security;
+
+/* loaded from: classes.dex */
+public interface TypePermission {
+    boolean allows(Class cls);
+}

sources/com/thoughtworks/xstream/security/WildcardTypePermission.java

@@ -0,0 +1,69 @@
+package com.thoughtworks.xstream.security;
+
+/* loaded from: classes.dex */
+public class WildcardTypePermission extends RegExpTypePermission {
+    public WildcardTypePermission(String[] strArr) {
+        super(getRegExpPatterns(strArr));
+    }
+
+    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+    private static String[] getRegExpPatterns(String[] strArr) {
+        if (strArr == null) {
+            return null;
+        }
+        String[] strArr2 = new String[strArr.length];
+        for (int i = 0; i < strArr.length; i++) {
+            String str = strArr[i];
+            StringBuffer stringBuffer = new StringBuffer(str.length() * 2);
+            stringBuffer.append("(?u)");
+            int length = str.length();
+            int i2 = 0;
+            while (i2 < length) {
+                char charAt = str.charAt(i2);
+                if (charAt != '$' && charAt != '.') {
+                    if (charAt != '?') {
+                        if (charAt != '|') {
+                            switch (charAt) {
+                                case '(':
+                                case ')':
+                                case '+':
+                                    break;
+                                case '*':
+                                    int i3 = i2 + 1;
+                                    if (i3 >= length || str.charAt(i3) != '*') {
+                                        stringBuffer.append("[\\P{C}&&[^");
+                                        stringBuffer.append('.');
+                                        stringBuffer.append("]]*");
+                                        break;
+                                    } else {
+                                        stringBuffer.append("[\\P{C}]*");
+                                        i2 = i3;
+                                        break;
+                                    }
+                                default:
+                                    switch (charAt) {
+                                        case '[':
+                                        case '\\':
+                                        case ']':
+                                        case '^':
+                                            break;
+                                        default:
+                                            stringBuffer.append(charAt);
+                                            break;
+                                    }
+                            }
+                        }
+                    } else {
+                        stringBuffer.append('.');
+                    }
+                    i2++;
+                }
+                stringBuffer.append('\\');
+                stringBuffer.append(charAt);
+                i2++;
+            }
+            strArr2[i] = stringBuffer.toString();
+        }
+        return strArr2;
+    }
+}