This article may require cleanup to meet Wikipedia’s quality standards. Please improve this article if you can. The talk page may contain suggestions. (March 2008)

This article may be divided into too many sections considering its overall length. To help improve Wikipedia’s quality standards, some of the sections may need to be condensed or merged. August 2009

Keystroke logging (often called keylogging) is the action of tracking (or logging) the keys struck on a keyboard,
typically in a covert manner so that the person using the keyboard is
unaware that their actions are being monitored. There are numerous
keylogging methods, ranging from hardware and software-based approaches
to electromagnetic and acoustic analysis.

Contents [hide] 1 Application 1.1 Software-based keyloggers 1.1.1 Remote access software keyloggers 1.1.2 Related features 1.2 Hardware-based keyloggers 1.2.1 Wireless keyboard sniffers 1.2.2 Keyboard overlays 1.2.3 Acoustic keyloggers 1.2.4 Electromagnetic emissions 1.3 Other 1.3.1 Optical surveillance 2 History 3 Cracking 3.1 Trojan 3.2 Ciphertext 3.2.1 Use by police 4 Countermeasures 4.1 Anti keyloggers 4.2 Live CD/USB 4.3 Anti-spyware / Anti-virus programs 4.4 Network monitors 4.5 Automatic form filler programs 4.6 One-time passwords (OTP) 4.7 Security tokens 4.8 On-screen keyboards 4.9 Keystroke interference software 4.10 Speech recognition 4.11 Handwriting recognition and mouse gestures 4.12 Macro expanders/recorders 4.13 Non-technological methods 5 See also 6 References 7 External links

[edit] Application

[edit] Software-based keyloggers

These are software programs designed to work on the target computer’s operating system. From a technical perspective there are five categories:

• Hypervisor-based: The keylogger can theoretically reside in a malware hypervisor running underneath the operating system, which remains untouched. It effectively becomes a virtual machine. Blue Pill is a conceptual example.
• Kernel-based: This method is difficult both to write and to combat. Such keyloggers reside at the kernel level and are thus difficult to detect, especially for user-mode applications. They are frequently implemented as rootkits
  that subvert the operating system kernel and gain unauthorized access
  to the hardware, making them very powerful. A keylogger using this
  method can act as a keyboard device driver for example, and thus gain access to any information typed on the keyboard as it goes to the operating system.
• API-based: These keyloggers hook keyboard APIs;
  the operating system then notifies the keylogger each time a key is
  pressed and the keylogger simply records it. Windows APIs on such as GetAsyncKeyState(), GetForegroundWindow(), etc. are used to poll the state of the keyboard or to subscribe to keyboard events.^[1]
  These types of keyloggers are the easiest to write, but where constant
  polling of each key is required, they can cause a noticeable increase in
  CPU usage, and can also miss the occasional key. A more recent example simply polls the BIOS for pre-boot authentication PINs that have not been cleared from memory.^[2]
• Form grabbing based: Form grabbing-based keyloggers log web form
  submissions by recording the web browsing onsubmit event functions.
  This records form data before it is passed over the Internet and
  bypasses HTTPS encryption.
• Packet analyzers: This involves capturing network traffic associated with HTTP POST events to retrieve unencrypted passwords.

[edit] Remote access software keyloggers

These are local software keyloggers with an added feature that allows
access to the locally recorded data from a remote location. Remote
communication may be achieved using one of these methods:

• Data is uploaded to a website, database or an FTP server.
• Data is periodically emailed to a pre-defined email address.
• Data is wirelessly transmitted by means of an attached hardware system.
• The software enables a remote login to the local machine from the
  Internet or the local network, for data logs stored on the target
  machine to be accessed.

[edit] Related features

Software Keyloggers may be augmented with features that capture user
information without relying on keyboard key presses as the sole input.
Some of these features include:

• Clipboard logging. Anything that has been copied to the clipboard can be captured by the program.
• Screen logging. Screenshots
  are taken in order to capture graphics-based information. Applications
  with screen logging abilities may take screenshots of the whole screen,
  just one application or even just around the mouse cursor. They may take
  these screenshots periodically or in response to user behaviours (for
  example, when a user has clicked the mouse). A practical application
  used by some keyloggers with this screen logging ability is to take
  small screenshots around where a mouse has just clicked; these defeat
  web-based keyboards (for example, the web-based screen keyboards that
  are often used by banks) and any web-based on-screen keyboard without
  screenshot protection.
• Programmatically capturing the text in a control. The Microsoft Windows API
  allows programs to request the text ‘value’ in some controls. This
  means that some passwords may be captured, even if they are hidden
  behind password masks (usually asterisks).^[3]
• The recording of every program/folder/window opened including a
  screenshot of each and every website visited, also including a
  screenshot of each.
• The recording of search engines queries, instant messenger conversations, FTP downloads and other Internet-based activities (including the bandwidth used).

[edit] Hardware-based keyloggers

Hardware-based keyloggers do not depend upon any software being
installed as they exist at a hardware level in a computer system.

• Firmware-based: BIOS-level firmware that handles keyboard events can be modified to record these events as they are processed. Physical and/or root-level access
  is required to the machine, and the software loaded into the BIOS needs
  to be created for the specific hardware that it will be running on.
• Keyboard hardware: Hardware keyloggers are used for keystroke
  logging by means of a hardware circuit that is attached somewhere in
  between the computer keyboard
  and the computer, typically inline with the keyboard’s cable connector.
  More stealthy implementations can be installed or built into standard
  keyboards, so that no device is visible on the external cable. Both
  types log all keyboard activity to their internal memory, which can be subsequently accessed, for example, by typing in a secret key sequence.^[4]
  A hardware keylogger has an advantage over a software solution: it is
  not dependent on being installed on the target computer’s operating
  system and therefore will not interfere with any program running on the
  target machine or be detected by any software.
  However its physical presence may be detected if, for example, it is
  installed outside the case as an inline device between the computer and
  the keyboard. Some of these implementations have the ability to be
  controlled and monitored remotely by means of a wireless communication
  standard.^[5]

[edit] Wireless keyboard sniffers

These passive sniffers collect packets of data being transferred from
a wireless keyboard and its receiver. As encryption may be used to
secure the wireless communications between the two devices, this may
need to be cracked beforehand if the transmissions are to be read.

[edit] Keyboard overlays

Criminals have been known to use keyboard overlays on ATMs
to capture people’s PINs. Each keypress is registered by the keyboard
of the ATM as well as the criminal’s keypad that is placed over it. The
device is designed to look like an integrated part of the machine so
that bank customers are unaware of its presence.^[6]

[edit] Acoustic keyloggers

Acoustic cryptanalysis
can be used to monitor the sound created by someone typing on a
computer. Each character on the keyboard makes a subtly different
acoustic signature when stroked. It is then possible to identify which
keystroke signature relates to which keyboard character via statistical methods such as frequency analysis.
The repetition frequency of similar acoustic keystroke signatures, the
timings between different keyboard strokes and other context information
such as the probable language in which the user is writing are used in
this analysis to map sounds to letters.^[7] A fairly long recording (1000 or more keystrokes) is required so that a big enough sample is collected.^[8]

[edit] Electromagnetic emissions

It is possible to capture the electromagnetic emissions of a wired keyboard from up to 20 metres (66 ft) away, without being physically wired to it.^[9] In 2009, Swiss researches tested 11 different USB, PS/2 and laptop keyboards in a semi-anechoic chamber and found them all vulnerable, primarily because of the prohibitive cost of adding shielding during manufacture.^[10] The researchers used a wide-band receiver to tune into the specific frequency of the emissions radiated from the keyboards.

[edit] Other

[edit] Optical surveillance

Optical surveillance, while not a keylogger in the classical sense,
is nonetheless an approach that can be used to capture passwords or
PINs. A strategically placed camera, such as a hidden surveillance camera at an ATM, can allow a criminal to watch a PIN or password being entered.^[11]

[edit] History

An early keylogger was written by Perry Kivolowitz and posted to the Usenet news group net.unix-wizards,net.sources on November 17, 1983.^[12] The posting seems to be a motivating factor in restricting access to /dev/kmem on Unix systems. The user-mode program operated by locating and dumping character lists (clists) as they were assembled in the Unix kernel.

[edit] Cracking

Writing simple software applications for keylogging can be trivial,
and like any nefarious computer program, can be distributed as a trojan horse or as part of a virus.
What is not trivial for an attacker, however, is installing a covert
keystroke logger without getting caught and downloading data that has
been logged without being traced. An attacker that manually connects to a
host machine to download logged keystrokes risks being traced. A trojan
that sends keylogged data to a fixed e-mail address or IP address risks exposing the attacker.

[edit] Trojan

Young and Yung devised several methods for solving this problem and presented them in their 1997 IEEE Security & Privacy paper^[13] (their paper from ’96 touches on it as well).^{[citation needed]}
They presented a deniable password snatching attack in which the
keystroke logging trojan is installed using a virus or worm. An attacker
who is caught with the virus or worm can claim to be a victim. The cryptotrojan asymmetrically encrypts the pilfered login/password pairs using the public key of the trojan author and covertly broadcasts the resulting ciphertext. They mentioned that the ciphertext can be steganographically encoded and posted to a public bulletin board such as Usenet.^{[citation needed]}

[edit] Ciphertext

Young and Yung also mentioned having the cryptotrojan unconditionally write the asymmetric ciphertexts to the last few unused sectors of every writable disk that is inserted into the machine.^{[citation needed]} The sectors remain marked as unused. This can be done using a USB
token. So, the trojan author may be one of dozens or even thousands of
people who are given the stolen information. Only the trojan author can
decrypt the ciphertext because only the author knows the needed private
decryption key. This attack is from the field known as cryptovirology.

[edit] Use by police

In 2000, the FBI used a keystroke logger to obtain the PGP passphrase of Nicodemo Scarfo, Jr., son of mob boss Nicodemo Scarfo.^[14]
Also in 2000, the FBI lured two suspected Russian cyber criminals to
the US in an elaborate ruse, and captured their usernames and passwords
with a keylogger that was covertly installed on a machine that they used
to access their computers in Russia. The FBI then used these
credentials to hack into the suspects’ computers in Russia in order to
obtain evidence to prosecute them.^[15]

[edit] Countermeasures

The effectiveness of countermeasures varies, because keyloggers use a
variety of techniques to capture data and the countermeasure needs to
be effective against the particular data capture technique. For example,
an on-screen keyboard will be effective against hardware keyloggers,
transparency will defeat some screenloggers – but not all – and an anti-spyware application that can only disable hook-based keyloggers will be ineffective against kernel-based keyloggers.

Also, keylogger software authors may be able to update the code to
adapt to countermeasures that may have proven to be effective against
them.

[edit] Anti keyloggers

An anti keylogger is a piece of software
specifically designed to detect keyloggers on your computer, typically
comparing all files in your computer against a database of keyloggers
looking for similarities which might signal the presence of a hidden
keylogger. As anti keyloggers have been designed specifically to detect
keyloggers, they are generally much more effective than conventional
anti virus software; many anti virus softwares do not consider certain
keyloggers a virus, as under many circumstances a keylogger can be
considered a legitimate piece of software.

[edit] Live CD/USB

Rebooting the computer using a Live CD or write-protected Live USB
is a possible countermeasure against software keyloggers if the CD is
clean of malware and the operating system contained on it is secured and
fully patched so that it cannot be infected as soon as it is started.
Booting a different operating system does not impact the use of a
hardware keylogger.

[edit] Anti-spyware / Anti-virus programs

Many anti-spyware
applications are able to detect some software keyloggers and
quarantine, disable or cleanse them. However, because many keylogging
programs are legitimate piece of software under some circumstances, anti
spyware often neglects to label keylogging programs as spyware or a
virus. These applications are able to detect software-based keyloggers
based on patterns in executable code, heuristics and keylogger behaviours (such as the use of hooks and certain APIs).

No software-based anti-spyware application can be 100% effective against all keyloggers^{[citation needed]}.
Also, software-based anti-spyware cannot defeat non-software keyloggers
(for example, hardware keyloggers attached to keyboards will always
receive keystrokes before any software-based anti-spyware application).

However, the particular technique that the anti-spyware application
uses will influence its potential effectiveness against software
keyloggers. As a general rule, anti-spyware applications with higher privileges
will defeat keyloggers with lower privileges. For example, a hook-based
anti-spyware application cannot defeat a kernel-based keylogger (as the
keylogger will receive the keystroke messages before the anti-spyware
application), but it could potentially defeat hook- and API-based
keyloggers.

[edit] Network monitors

Network monitors
(also known as reverse-firewalls) can be used to alert the user
whenever an application attempts to make a network connection. This
gives the user the chance to prevent the keylogger from “phoning home” with his or her typed information.

[edit] Automatic form filler programs

Automatic form-filling programs may prevent keylogging by removing
the requirement for a user to type personal details and passwords using
the keyboard. Form fillers are primarily designed for web browsers to fill in checkout pages and log users into their accounts. Once the user’s account and credit card information has been entered into the program, it will be automatically entered into forms without ever using the keyboard or clipboard,
thereby reducing the possibility that private data is being recorded.
However someone with physical access to the machine may still be able to
install software that is able to intercept this information elsewhere
in the operating system or while in transit on the network. (Transport Layer Security (TLS) prevents the interception of data in transit by network sniffers and proxy tools.)

[edit] One-time passwords (OTP)

Using one-time passwords
may be keylogger-safe, as each password is invalidated as soon as it’s
used. This solution may be useful for someone using a public computer,
however an attacker who has remote control over such a computer can
simply wait for the victim to enter his/her credentials before
performing unauthorised transactions on their behalf while their session
is active.

One-time passwords also prevent replay attacks where an attacker uses the old information to impersonate. One example is online banking where one-time passwords are implemented to protect accounts from keylogging attacks as well as replay attacks. KYPS is a service that gives OTP access to websites that normally do not offer OTP access.

[edit] Security tokens

Use of smart cards or other security tokens may improve security against replay attacks
in the face of a successful keylogging attack, as accessing protected
information would require both the (hardware) security token as well as
the appropriate password/passphrase. Knowing the keystrokes, mouse
actions, display, clipboard etc used on one computer will not
subsequently help an attacker gain access to the protected resource.
Some security tokens work as a type of hardware-assisted one-time
password system, and others implement a cryptographic challenge-response authentication, which can improve security in a manner conceptually similar to one time passwords. Smartcard readers and their associated keypads for PIN entry may be vulnerable to keystoke logging through a so called supply chain attack^[16] where an attacker substitutes the card reader/PIN entry hardware for one which records the user’s PIN.

[edit] On-screen keyboards

Most on screen keyboards (such as the onscreen keyboard that comes with Windows XP)
send normal keyboard event messages to the external target program to
type text. Every software keylogger can log these typed characters sent
from one program to another.^[17]
Additionally, keylogging software can take screenshots of what is
displayed on the screen (periodically, and/or upon each mouse click),
which means that although certainly a useful security measure, an
on-screen keyboard will not protect you from all keyloggers.

[edit] Keystroke interference software

Keystroke interference software is also available.^[18]
These programs attempt to trick keyloggers by introducing random
keystrokes, although this simply results in the keylogger recording more
information than it needs to. An attacker has the task of extracting
the keystrokes of interest—the security of this mechanism, specifically
how well it stands up to cryptanalysis, is unclear.

[edit] Speech recognition

Similar to on-screen keyboards, speech-to-text conversion
software can also be used against keyloggers, since there are no typing
or mouse movements involved. The weakest point of using
voice-recognition software may be how the software sends the recognized
text to target software after the recognition took place.

[edit] Handwriting recognition and mouse gestures

Also, many PDAs and lately tablet PCs can already convert pen (also called stylus) movements on their touchscreens to computer understandable text successfully. Mouse gestures
utilize this principle by using mouse movements instead of a stylus.
Mouse gesture programs convert these strokes to user-definable actions,
such as typing text. Similarly, graphics tablets and light pens can be used to input these gestures, however these are less common everyday.

The same potential weakness of speech recognition applies to this technique as well.

[edit] Macro expanders/recorders

With the help of many programs, a seemingly meaningless text can be
expanded to a meaningful text and most of the time context-sensitively,
e.g. “en.wikipedia.org” can be expanded when a web browser window has
the focus. The biggest weakness of this technique is that these programs
send their keystrokes directly to the target program. However, this can
be overcome by using the ‘alternating’ technique described below,
i.e. sending mouse clicks to non-responsive areas of the target
program, sending meaningless keys, sending another mouse click to target
area (e.g. password field) and switching back-and-forth.

[edit] Non-technological methods

Alternating between typing the login credentials and typing characters somewhere else in the focus window^[19]
can cause a keylogger to record more information than they need to,
although this could easily be filtered out by an attacker. Similarly, a
user can move their cursor using the mouse during typing, causing the
logged keystrokes to be in the wrong order e.g. by typing a password
beginning with the last letter and then using the mouse to move the
cursor for each subsequent letter. Lastly, someone can also use context menus to remove, cut, copy, and paste
parts of the typed text without using the keyboard. An attacker who is
able to capture only parts of a password will have a smaller key space to attack if he chose to execute a brute-force attack.

Another very similar technique utilizes the fact that any selected
text portion is replaced by the next key typed. E.g. if the password is
“secret”, one could type “s”, then some dummy keys “asdfsd”. Then these
dummies could be selected with mouse, and next character from the
password “e” is typed, which replaces the dummies “asdfsd”.

These techniques assume incorrectly that keystroke logging software
cannot directly monitor the clipboard, the selected text in a form, or
take a screenshot every time a keystroke or mouse click occurs. They may
however be effective against some hardware keyloggers.

[edit] See also

• Anti keylogger
• Black-bag cryptanalysis
• Computer surveillance
• Digital footprint
• Hardware keylogger
• Reverse connection
• Spyware
• Trojan horse
• Virtual keyboard

[edit] References

[edit] External links

• Keylogging Hardware and software keylogging methods.
• Introduction to Spyware Keyloggers
• Keyloggers: How they work and how to detect them
• How To Login From an Internet Cafe Without Worrying About Keyloggers
• Keyloggers at the Open Directory Project

[hide]v · d · eMalware Infectious malware Computer virus · List of computer viruses · Computer worm · List of computer worms · Timeline of computer viruses and worms Concealment Trojan horse · Rootkit · Backdoor · Zombie computer Malware for profit Privacy-invasive software · Adware · Spyware · Botnet · Keystroke logging · Web threats · Fraudulent dialer · Malbot · Scareware · Rogue security software · Ransomware By operating system Linux malware · Palm OS viruses · Mobile virus · Macro virus Protection Antivirus software · Defensive computing · Firewall · Intrusion detection system · Data loss prevention software Countermeasures Computer surveillance · Operation: Bot Roast · Honeypot · Anti-Spyware Coalition