private void considerMethod(ClassContext classContext, Method method) { boolean hasReferenceParameters = false; for (Type argument : method.getArgumentTypes()) { if (argument instanceof ReferenceType) { hasReferenceParameters = true; } } if (hasReferenceParameters && classContext.getMethodGen(method) != null) { if (VERBOSE_DEBUG) { System.out.println("Check " + method); } analyzeMethod(classContext, method); } }
@Override public void visit(Method method) { if(method.isPublic() && "next".equals(method.getName()) && method.getArgumentTypes().length == 0){ shouldVisitCode = true; super.visit(method); } else { shouldVisitCode = false; } }
@SuppressWarnings("unchecked") @Override public void visitMethod(Method obj) { argNums = null; Type[] argumentTypes = obj.getArgumentTypes(); if(argumentTypes.length == 0) { return; } int lvNum = obj.isStatic() ? 0 : 1; nArgs = argumentTypes.length; int argCount = lvNum; for(Type type : argumentTypes) { argCount+=type.getSize(); } for(int i=0; i<nArgs; i++) { if(argumentTypes[i].getSignature().equals("Ljava/lang/String;")) { if(argNums == null) { argNums = new int[argCount]; Arrays.fill(argNums, -1); } argNums[lvNum] = i; } lvNum+=argumentTypes[i].getSize(); } if(argNums != null) { passedParameters = new List[nArgs]; } super.visitMethod(obj); }
&& (seen == Const.INVOKESTATIC) == getMethod().isStatic() && (seen == Const.INVOKESPECIAL) == (getMethod().isPrivate() && !getMethod().isStatic() || Const.CONSTRUCTOR_NAME.equals(getMethodName()))) { Type arguments[] = getMethod().getArgumentTypes();
@Override public java.lang.reflect.Type[] getParameterTypes() { return HBCEL.toJava(method.getArgumentTypes()); }
private static List<String> sortMethodsAccordingToSourceOrder(Set<String> testMethods, Class<? extends TestCase> clazz) { List<String> sortedMethods = new ArrayList<String>(); for (org.apache.bcel.classfile.Method method : TestClassHelper.getMethodsSorted(clazz)) { if (method.getArgumentTypes().length == 0 && testMethods.remove(method.getName())) { sortedMethods.add(method.getName()); } } if (testMethods.size() != 0) { throw new IllegalArgumentException("Cannot find " + testMethods + " in the byte code of " + clazz.getName()); } return sortedMethods; }
public static boolean typeA(ClassGen cg) { for (Method m : cg.getMethods()) { if (m.getArgumentTypes().length == 1 && m.getArgumentTypes()[0].equals(Type.getType(char[].class))) { return true; } } return false; }
private void considerMethod(ClassContext classContext, Method method) { boolean hasReferenceParameters = false; for (Type argument : method.getArgumentTypes()) { if (argument instanceof ReferenceType) { hasReferenceParameters = true; } } if (hasReferenceParameters && classContext.getMethodGen(method) != null) { if (VERBOSE_DEBUG) { System.out.println("Check " + method); } analyzeMethod(classContext, method); } }
@Override public void visit(Method method) { if(method.isPublic() && "next".equals(method.getName()) && method.getArgumentTypes().length == 0){ shouldVisitCode = true; super.visit(method); } else { shouldVisitCode = false; } }
public boolean isAuthClass(ClassGen cg) { if (cg.getMethods().length == 2 && cg.getMethods()[0].getArgumentTypes().length == 1) { if (cg.getMethods()[0].getArgumentTypes()[0].getSignature().contains("String")) { if (cg.getMethods()[0].getReturnType().toString().contains("boolean")) { return true; } } } return false; }
/** * implement the visitor to reset the opcode stack and set of locals that are jdbc objects * * @param obj * the context param of the currently parsed method */ @Override public void visitMethod(Method obj) { stack.resetForMethodEntry(this); jdbcLocals.clear(); int[] parmRegs = RegisterUtils.getParameterRegisters(obj); Type[] argTypes = obj.getArgumentTypes(); for (int t = 0; t < argTypes.length; t++) { String sig = argTypes[t].getSignature(); if (isJDBCClass(sig)) { jdbcLocals.put(Integer.valueOf(parmRegs[t]), Integer.valueOf(RegisterUtils.getLocalVariableEndRange(obj.getLocalVariableTable(), parmRegs[t], 0))); } } }
@SuppressWarnings("unchecked") @Override public void visitMethod(Method obj) { argEnabled = null; org.apache.bcel.generic.Type[] argumentTypes = obj.getArgumentTypes(); if(argumentTypes.length == 0) { return; } nArgs = argumentTypes.length; for(int i=0; i<nArgs; i++) { if(argumentTypes[i].getSignature().equals("Ljava/lang/String;")) { if(argEnabled == null) { argEnabled = new boolean[nArgs]; } argEnabled[i] = true; } } if(argEnabled != null) { shift = obj.isStatic() ? 0 : -1; passedParameters = new List[nArgs]; } super.visitMethod(obj); }
/** * returns the first open register slot after parameters * * @param m * the method for which you want the parameters * @return the first available register slot */ public static int getFirstRegisterSlot(Method m) { Type[] parms = m.getArgumentTypes(); int first = m.isStatic() ? 0 : 1; for (Type t : parms) { first += getSignatureSize(t.getSignature()); } return first; }
/** * returns the first open register slot after parameters * * @param m * the method for which you want the parameters * @return the first available register slot */ public static int getFirstRegisterSlot(Method m) { Type[] parms = m.getArgumentTypes(); int first = m.isStatic() ? 0 : 1; for (Type t : parms) { first += getSignatureSize(t.getSignature()); } return first; }
/** * implement the visitor to reset the opcode stack and set of locals that are jdbc objects * * @param obj * the context param of the currently parsed method */ @Override public void visitMethod(Method obj) { stack.resetForMethodEntry(this); jdbcLocals.clear(); int[] parmRegs = RegisterUtils.getParameterRegisters(obj); Type[] argTypes = obj.getArgumentTypes(); for (int t = 0; t < argTypes.length; t++) { String sig = argTypes[t].getSignature(); if (isJDBCClass(sig)) { jdbcLocals.put(Integer.valueOf(parmRegs[t]), Integer.valueOf(RegisterUtils.getLocalVariableEndRange(obj.getLocalVariableTable(), parmRegs[t], 0))); } } }
/** * gets the set of registers used for parameters * * @param obj * the context object for the method to find the parameter registers of * * @return the set of registers that parameters are using */ public static int[] getParameterRegisters(Method obj) { Type[] argTypes = obj.getArgumentTypes(); int[] regs = new int[argTypes.length]; int curReg = obj.isStatic() ? 0 : 1; for (int t = 0; t < argTypes.length; t++) { String sig = argTypes[t].getSignature(); regs[t] = curReg; curReg += SignatureUtils.getSignatureSize(sig); } return regs; } }
/** * gets the set of registers used for parameters * * @param obj * the context object for the method to find the parameter registers of * * @return the set of registers that parameters are using */ public static int[] getParameterRegisters(Method obj) { Type[] argTypes = obj.getArgumentTypes(); int[] regs = new int[argTypes.length]; int curReg = obj.isStatic() ? 0 : 1; for (int t = 0; t < argTypes.length; t++) { String sig = argTypes[t].getSignature(); regs[t] = curReg; curReg += SignatureUtils.getSignatureSize(sig); } return regs; } }
MethodDesc( Method meth ) { this(meth.getName(), meth.getReturnType(), meth.getArgumentTypes(), (null == meth.getExceptionTable() ) ? new String[0] : meth.getExceptionTable().getExceptionNames()); }
public int findFirstStringLocalVariableOffset(final Method method) { final Type[] argumentTypes = method.getArgumentTypes(); int offset = -1; for (int i = 0, count = argumentTypes.length; i < count; i++) { if (Type.STRING.getSignature().equals(argumentTypes[i].getSignature())) { if (method.isStatic()) { offset = i; } else { offset = i + 1; } break; } } return offset; } }
public void setDecryptor() { for (ClassGen cg : cgs.values()) { for (Method m : cg.getMethods()) { try { if (m.isPublic() && m.isStatic() && m.getArgumentTypes()[0].toString().equals("java.lang.String") && m.getReturnType().toString().equals("java.lang.String")) { String dc = cg.getClassName() + "." + m.getName(); decryptor = m.getName(); decryptorclass = cg.getClassName(); logger.debug("Found String Decryptor! " + dc); return; } } catch (Exception e) { continue; } } } logger.error("String decrypt not found!"); }