Esempio n. 1
0
        bool MethodIsLiteralMatch(PEFile module, MethodDefinition methodDefinition)
        {
            var blob = module.Reader.GetMethodBody(methodDefinition.RelativeVirtualAddress).GetILReader();

            if (searchTermLiteralType == TypeCode.Int64)
            {
                long val = (long)searchTermLiteralValue;
                while (blob.RemainingBytes > 0)
                {
                    ILOpCode code;
                    switch (code = ILParser.DecodeOpCode(ref blob))
                    {
                    case ILOpCode.Ldc_i8:
                        if (val == blob.ReadInt64())
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldc_i4:
                        if (val == blob.ReadInt32())
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldc_i4_s:
                        if (val == blob.ReadSByte())
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldc_i4_m1:
                        if (val == -1)
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldc_i4_0:
                        if (val == 0)
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldc_i4_1:
                        if (val == 1)
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldc_i4_2:
                        if (val == 2)
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldc_i4_3:
                        if (val == 3)
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldc_i4_4:
                        if (val == 4)
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldc_i4_5:
                        if (val == 5)
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldc_i4_6:
                        if (val == 6)
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldc_i4_7:
                        if (val == 7)
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldc_i4_8:
                        if (val == 8)
                        {
                            return(true);
                        }
                        break;

                    default:
                        ILParser.SkipOperand(ref blob, code);
                        break;
                    }
                }
            }
            else if (searchTermLiteralType != TypeCode.Empty)
            {
                ILOpCode expectedCode;
                switch (searchTermLiteralType)
                {
                case TypeCode.Single:
                    expectedCode = ILOpCode.Ldc_r4;
                    break;

                case TypeCode.Double:
                    expectedCode = ILOpCode.Ldc_r8;
                    break;

                case TypeCode.String:
                    expectedCode = ILOpCode.Ldstr;
                    break;

                default:
                    throw new InvalidOperationException();
                }
                while (blob.RemainingBytes > 0)
                {
                    var code = ILParser.DecodeOpCode(ref blob);
                    if (code != expectedCode)
                    {
                        ILParser.SkipOperand(ref blob, code);
                        continue;
                    }
                    switch (code)
                    {
                    case ILOpCode.Ldc_r4:
                        if ((float)searchTermLiteralValue == blob.ReadSingle())
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldc_r8:
                        if ((double)searchTermLiteralValue == blob.ReadDouble())
                        {
                            return(true);
                        }
                        break;

                    case ILOpCode.Ldstr:
                        if ((string)searchTermLiteralValue == ILParser.DecodeUserString(ref blob, module.Metadata))
                        {
                            return(true);
                        }
                        break;
                    }
                }
            }
            else
            {
                while (blob.RemainingBytes > 0)
                {
                    var code = ILParser.DecodeOpCode(ref blob);
                    if (code != ILOpCode.Ldstr)
                    {
                        ILParser.SkipOperand(ref blob, code);
                        continue;
                    }
                    if (IsMatch(ILParser.DecodeUserString(ref blob, module.Metadata)))
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }