Community Question

[WoWMulti]

Hi Freddie,

Thanks for your input I appreciate it. I would definitely agree.

To shed some light on it, I do not use a global keyboard hook.

Here's basically the code that does it. All it does is calls Window's API to register and unregister global hotkeys:

Besides posting source code, what can I do to prove legitimacy?

Welcome and good luck with your software. I don't think it's possible to prove that a program doesn't contain malware or that it can't break rules.

Of course you can avoid certain features that people find particularly scary, like global hooks. Probably this would encourage more people to try the program. But there are several other methods for logging every keystroke, so this doesn't prove anything.

I think the main thing you can do is act responsibly and over time, if nobody complains about your program, more and more people will trust it. It has to be handled as a social issue not a technical one.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Collections;

namespace WoWMulti
{
    public class HotKeyManager
    {
        public class HotKey
        {
            public short ID;
            public string Name;
            public int KeyValue;
            public int Modifiers;
            public IntPtr WindowParent;

            public const int MOD_NONE = 0;
            public const int MOD_ALT = 1;
            public const int MOD_CONTROL = 2;
            public const int MOD_SHIFT = 4;
            public const int MOD_WIN = 8;

            public HotKey(string sName, int keyValue, int iModifiers)
            {
                this.ID = 0;
                this.Name = sName;
                this.KeyValue = keyValue;
                this.Modifiers = iModifiers;
            }
            public HotKey(string sName, int keyValue)
            {
                this.ID = 0;
                this.Name = sName;
                this.KeyValue = keyValue;
                this.Modifiers = MOD_NONE;
            }
        }

        [DllImport("user32", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
        private static extern int RegisterHotKey(IntPtr hwnd, int id, int fsModifiers, int vk);
        
        [DllImport("user32", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
        private static extern int UnregisterHotKey(IntPtr hwnd, int id);
        
        [DllImport("kernel32", EntryPoint = "GlobalAddAtomA", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
        private static extern short GlobalAddAtom(string lpString);
        
        [DllImport("kernel32", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
        private static extern short GlobalDeleteAtom(short nAtom);
        // Windows API functions and constants


        /// <summary>
        /// Collection of managed hotkeys.
        /// </summary>
        private static Dictionary<int, HotKey> Hotkeys = new Dictionary<int, HotKey>(30);

        /// <summary>
        /// Registers a hotkey.
        /// </summary>
        /// <param name="hotKey"></param>
        public static short RegisterGlobalHotKey(HotKey hotKey)
        {
            try
            {
                // use the GlobalAddAtom API to get a unique ID (as suggested by MSDN docs)
                hotKey.ID = GlobalAddAtom(hotKey.Name);

                if (hotKey.ID == 0)
                {
                    throw new Exception("Unable to generate unique hotkey ID. Error code: " + Marshal.GetLastWin32Error().ToString());
                }

                // register the hotkey, throw if any error
                if (RegisterHotKey(hotKey.WindowParent, hotKey.ID, hotKey.Modifiers, hotKey.KeyValue) == 0)
                {
                    throw new Exception("Unable to register hotkey. Error code: " + Marshal.GetLastWin32Error().ToString());
                }


                Hotkeys.Add(hotKey.ID, hotKey);

                return hotKey.ID;
            }
            catch (Exception ex)
            {
                // clean up if hotkey registration failed
                UnregisterHotKey(hotKey.ID);

                return -1;
            }
        }

        /// <summary>
        /// Unregisters a global hotkey by it's global ID.
        /// </summary>
        /// <param name="hotkeyID"></param>
        /// <param name="bRemove"></param>
        public static void UnregisterHotKey(short keyID, bool removeFromCollection)
        {
            HotKey hotKey = null;
            if (Hotkeys.ContainsKey(keyID))
            {
                hotKey = Hotkeys[keyID];

                UnregisterHotKey(hotKey.WindowParent, hotKey.ID);
                // clean up the atom list
                GlobalDeleteAtom(hotKey.ID);

                if (removeFromCollection && Hotkeys.ContainsKey(hotKey.ID))
                {
                    Hotkeys.Remove(hotKey.ID);
                }
            }
        }
        public static void UnregisterHotKey(short keyID)
        {
            UnregisterHotKey(keyID, true);
        }
        /// <summary>
        /// Releases all of the global hotkeys.
        /// </summary>
        public static void ReleaseAllHotKeys()
        {
            //Unregister all the hotkeys.
            foreach (KeyValuePair<int, HotKey> kvp in Hotkeys)
            {
                UnregisterHotKey(kvp.Value.ID, false);
            }

            Hotkeys.Clear();
        }

        public static string GetHotKeyName(short HotKeyID)
        {
            HotKey objhotkey = Hotkeys[HotKeyID];
            if ((objhotkey != null))
            {
                return objhotkey.Name;
            }
            else
            {
                return "Nothing";
            }
        }
    }
}