Application of Artificial Intelligence Algorithms in Cybersecurity and the Protection of a Selected Web Application, Based on an IDPS System

University of Economics and Computer Science in Kraków (now IDEIS University)

• Author: Sebastian Małek
• Master's thesis written under the supervision of: prof. WSEI Jan Werewka
• Place and year: Kraków, 2025

---

Abstract

This master's thesis focuses on the design and implementation of an Intrusion Detection and Prevention System titled "AI Web Gateway", which operates at the application layer as an HTTP/HTTPS proxy. Leveraging mitmproxy for traffic interception, the system employs machine learning models to analyze and detect threats such as SQL Injection, Cross-Site Scripting (XSS), and Command Injection. The solution was developed as a containerized application, enabling deployment in cloud environments, with the option of integration with tools for log analysis and basic visualization.

The conducted research confirmed that artificial intelligence significantly enhances the effectiveness of threat detection in cyberspace, while simultaneously becoming a potential target of attacks itself. The thesis combines theoretical perspectives with practical implementation, demonstrating that the development of AI in cybersecurity can provide a foundation for future defense systems protecting web applications against increasingly sophisticated attacks.

Keywords: IDPS, Machine Learning, Cybersecurity

Table of Contents

• Introduction
• 1. Objectives and Assumptions of the Thesis
  • 1.1. Definition of an IDPS System
  • 1.2. Project Objectives
• 2. Application Requirements Analysis
  • 2.1. Review of Existing Solutions
    • 2.1.1. Snort
    • 2.1.2. Suricata
  • 2.2. Marketing Personas
  • 2.3. Functional and Non-Functional Requirements
    • 2.3.1. Functional Requirements
    • 2.3.2. Non-Functional Requirements
  • 2.4. Cybersecurity Objectives and the Nature of Digital Attacks
    • 2.4.1. History of the Development of Attack Motives
    • 2.4.2. Cybersecurity Objectives
  • 2.5. Analysis of Current Cybersecurity Threats
    • 2.5.1. Attack Structure
    • 2.5.2. Most Common Attack Methods
  • 2.6. Review of Current Artificial Intelligence Algorithms
• 3. Implementation of the "AI Web Gateway" IDPS Application
  • 3.1. Technology Selection and Library Overview
  • 3.2. Model
    • 3.2.1. Data
    • 3.2.2. Data Interpretation
    • 3.2.3. Method Selection
  • 3.3. Project Implementation Vision
    • 3.3.1. Application Architecture Diagram
    • 3.3.2. Penetration Testing
    • 3.3.3. Plugin Implementation
    • 3.3.4. Containerization
• 4. Summary
  • 4.1. Project Conclusions
    • 4.1.1. Project Status
    • 4.1.2. Development Opportunities
  • 4.2. The Impact of Artificial Intelligence on Current Threats in Cyberspace
  • 4.3. Analysis of Applicable AI-Based Solutions in Cybersecurity
  • 4.4. Conclusion of the Thesis
• 5. Bibliography
• 6. List of Tables
• 7. List of Figures
• 8. List of Code Listings

---

Introduction

The purpose of this master's thesis is to design and implement an Intrusion Detection and Prevention System titled "AI Web Gateway", operating as an HTTP/HTTPS proxy at the application layer. This solution is intended to intercept network traffic and analyze it for the detection of attacks such as SQL Injection, Cross-Site Scripting, and Command Injection. The system incorporates elements of artificial intelligence, which enable more effective and adaptive threat detection compared to classic signature-based systems. The application was built using a container-based architecture, which allows for easy deployment in cloud environments.

Intrusion Detection and Prevention Systems form the foundation of network and application infrastructure protection. Traditionally, they rely on rules and signatures, which allows for the rapid detection of known threats but proves insufficient in the case of zero-day attacks or variants of existing exploits. A particularly significant challenge is posed by application-layer attacks at layer 7 of the ISO/OSI model, such as SQL Injection or Command Injection, which exploit the logic of web application operation. Their effectiveness stems not only from a high degree of targeting toward a specific victim, but also from the fact that classic protective mechanisms — firewalls or transport-layer IDS systems — are not able to fully analyze the semantic context of HTTP/HTTPS traffic.

The dynamic development of cyberspace is associated with a growing number and complexity of attacks aimed at web applications. Traditional IDS/IPS systems often fail to cope with new attack vectors, especially those that operate on application logic and exploit HTTP/HTTPS protocols. For this reason, new tools are needed that will not only react to known threats but also learn to recognize previously unseen patterns. The author of this thesis recognized the potential in combining proxy tools with artificial intelligence techniques, which makes it possible to create a solution that is more flexible and better suited to the realities of contemporary cybersecurity.

The author set out to develop and deploy the "AI Web Gateway" application, along with defining its functionality, technical requirements, and potential directions for further development. The key research problem is to verify the effectiveness of applying machine learning methods to the detection of selected application-layer attacks, and to analyze the limitations related to the quality and representativeness of the training data. An important aspect of the research is also the integration of the system with existing tools for the visualization and reporting of security events, which is intended to facilitate the work of incident response teams.

The designed application is based on the mitmproxy tool, which enables the interception and modification of HTTP/HTTPS traffic in real time. At the analytical layer, machine learning methods were applied, including logistic regression as the primary classification technique. In order to ensure portability and ease of deployment, the entire solution was containerized using Docker technology, with the possibility of running it in the Microsoft Azure cloud. Integration with tools such as Grafana and the ELK Stack for log analysis was also considered, as was a potential extension involving integration with SIEM systems.

The thesis consists of four main chapters. Chapter one presents the objectives and assumptions of the thesis, defines the IDPS system, and outlines the project objectives. Chapter two covers the analysis of application requirements, including a review of existing solutions such as Snort and Suricata, a description of marketing personas, functional and non-functional requirements, cybersecurity objectives, an analysis of attack structure and methods, and a review of current artificial intelligence algorithms. Chapter three concerns the implementation of the "AI Web Gateway" IDPS application and includes a description of the technology and library selection, a discussion of the data model and the choice of learning method, the project implementation vision along with the architecture diagram, penetration test results, the plugin implementation, and the containerization process. Chapter four presents the summary, in which the project conclusions are presented, the current state of the project and its development opportunities are assessed, and the impact of artificial intelligence on threats in cyberspace, along with applicable solutions from this field, is analyzed.

The thesis was prepared on the basis of both Polish- and English-language literature, with particular emphasis on foreign sources. Scientific publications concerning artificial intelligence in cybersecurity, conference materials, articles from industry journals, and research reports were used. Given the nature of a project-based thesis, an important element of the sources was the technical documentation of the tools used in the project, as well as electronic resources including open-source repositories, API documentation, and sample datasets for training machine learning models.

1. Objectives and Assumptions of the Thesis

The following chapter is devoted to researching current solutions in the area of protecting and monitoring web applications through an analysis of existing solutions, defining marketing personas, and preparing the functional and non-functional requirements for the IDPS application project.

All tasks carried out in this chapter are aimed at preparing the requirements for the implementation of the IDPS application titled "AI Web Gateway", which will be presented in Chapter 2.

1.1. Definition of an IDPS System

An IDPS system, from the English Intrusion Detection & Prevention System, is an application that intercepts network communication between a user and a server and analyzes packet content for malicious content in order to protect the integrity, confidentiality, and availability of IT resources.

An IDPS consists of two components: IDS and IPS. The IDS component performs an analytical function, deciding whether given traffic is malicious, and then informs the relevant systems, such as the IPS, log servers, or SIEM systems, of the occurrence of an incident.[^1]

The IPS is responsible for neutralizing the threat once information about its occurrence in the system infrastructure has been received. Threat neutralization can proceed in several ways: it is possible to remove the suspicious signature from the traffic, reconfigure the infrastructure to prevent further actions from being taken, or simply intercept and block the continuation of the packet's path.[^2]

1.2. Project Objectives

The author of this master's thesis considers the main project objective to be creating a proof of concept by training a model capable of intercepting most of the basic attacks directed at a web application over the HTTP and HTTPS protocols, under the name "AI Web Gateway".

Currently, injection attacks — Command Injection, SQL Injection, and Cross-Site Scripting — are considered among the most popular attacks; according to the OWASP Top 10 list, maintained by the OWASP Foundation, they rank 3rd among the most common attacks.[^3]

2. Application Requirements Analysis

2.1. Review of Existing Solutions

The author of the project began the work by gathering requirements based on existing solutions — a well-conducted competitive analysis makes it easier to identify key product features, as well as unique selling points in the case of commercial solutions.

2.1.1. Snort

An open-source IDPS application with rich configuration options, created as a Sourcefire community project and subsequently acquired by Cisco. It offers a simple user interface. Beyond standard IDPS functionality such as blocking suspicious signatures, it can also be used as a packet logger.

Figure 1. Snort application GUI. Source: blog.snort.org [21.05.2025]

Snort is offered in two versions, the second and the third. Version two has greater community support, but its disadvantage is the lack of multithreading support, which can cause bottlenecks in network traffic.

Version 3 offers support for newer versions of protocols, for example HTTP/2, and also supports the creation of modules extending the tool's functionality using the Lua scripting language; however, it does not offer full support for the rules and configuration from version two, and at this point does not have as extensive a community.[^4]

The software supports many community-built GUIs, and also supports integration with the ELK technology stack[^5], which nowadays is a standard valued by many companies and institutions.

2.1.2. Suricata

Created in 2009 by the Open Information Security Foundation, an open-source IDPS application distributed under the GNU GPL 2 license; alternatively, it can also perform network monitoring functions.

Figure 2. Suricata application GUI (EveBox). Source: suricata.io [21.05.2025]

The greatest advantage of Suricata is the advanced technology used for packet analysis — this includes, among other things, deep packet inspection combined with signature analysis and anomaly detection, as well as TLS certificate analysis.[^6]

Nevertheless, the software also has a few drawbacks, such as configuration complexity, less user support compared to the aforementioned Snort, or high hardware requirements, making this solution suited for larger companies that can afford higher costs in exchange for effectiveness.

2.2. Marketing Personas

The term "marketing persona" originated in the 1980s. Its creator was Alan Cooper, who, by creating a persona named "Kathy" based on user surveys, laid the foundations of modern user-requirements engineering in this way.[^7]

Before understanding why marketing personas matter, it is worth recalling the main paradigm of programming, which states that the main goal of software is to solve problems — a point made repeatedly by, among others, the aforementioned Alan Cooper[^8], as well as by the "Agile Manifesto"[^9], whose signatories were people who had a key influence on today's direction of software development.

Defining the customer profile and their needs, as well as their problems, is of key importance when designing IT products — it allows for the creation of highly personalized products, and thus products that are competitive on the market.[^10]

Attempting to build an authentic marketing persona is a complex process, and its effectiveness depends on many factors, such as access to customer data, regularly conducted surveys, or opinions about existing solutions; therefore, the author of this thesis focused primarily on the analysis of publicly available customer data for existing solutions.

The first persona who could be a potential user of the application is the Chief Information Security Officer. He is an employee of a large corporation with over a decade of experience in the cybersecurity industry; his priority is compliance with numerous regulations, such as ISO or GDPR, as well as efficient budget management. This person's motivation may be the desire to protect corporate data and ensure the continuity of system operation, while the problem may turn out to be the integration of the software with the company's advanced technology stack and the pressure associated with SLAs.[^11]

Another fictional persona to whom the software may be targeted is an IT department manager working at a medium-sized company, whose experience in the field of cybersecurity is rather superficial and who may not be up to date with all the trends. His main problem is ensuring security while minimizing costs associated with personnel or infrastructure — he needs a solution that is immediately ready to use.[^12]

The last persona defined by the author is a DevSecOps specialist, i.e., a person who integrates the software development lifecycle with operations and cybersecurity — as a specialist in their field, they must be able to integrate the software with the CI/CD pipeline through tools such as Jira or Jenkins.[^13]

2.3. Functional and Non-Functional Requirements

The analysis carried out in the previous subsection made it possible to define the key features of the IDPS system, where the main factor determining the choice of solution is considered to be effectiveness relative to the cost of the solution, while optional properties can be considered to be modularity or a modern user interface.

2.3.1. Functional Requirements

• Blocking attacks on the web application over the HTTP and HTTPS protocols
• Detecting various types of attacks
• A user interface that facilitates browsing logs as well as simple application configuration

Taking the above analysis into account, the author of this thesis focused, during the implementation of the solution, on optimizing effectiveness without a significant increase in the cost of the solution.

2.3.2. Non-Functional Requirements

• The application operates independently of the operating system
• Automation of penetration tests
• The application should be efficient and should not block protected resources
• The system should be simple to maintain, with source code that is easy to modify
• Containerized development environment
• Application modularity
• Detection effectiveness of at least 70%

Nowadays, containerization has become the foundation of most business applications, as proven by the growing popularity of technologies such as Kubernetes or Docker in recent years.[^14] The automation of all kinds of processes, such as testing, or writing clean code based on OOP paradigms and rules such as SOLID, KISS, or DRY, can also be considered a standard.[^15]

2.4. Cybersecurity Objectives and the Nature of Digital Attacks

Over the decades of ever-accelerating technological progress, attack vectors, vulnerabilities, and systems have evolved; the goals of the people behind attacks on sensitive IT systems have not changed all that much. Recognizing who might want to attack an organization, and why, is one of the more important steps in designing cyberspace protection.

2.4.1. History of the Development of Attack Motives

Some of the first attacks carried out on IT systems were conducted mainly out of human curiosity. Cybercriminals such as Kevin Mitnick explored the security of their network service providers and carried out social engineering attacks to see what they could achieve using computer knowledge and for entertainment.[^16]

Over the following years, further hacking motives developed, such as the desire for financial gain, espionage, and industrial sabotage — these reasons remain, to this day, among the most common reasons behind attacks on private or public infrastructure.

Due to the growing popularity of cyberattacks and cybersecurity, as well as the popularization of advanced computer systems in recent years, more intriguing driving motives for attacks have emerged, such as hacktivism, exemplified by the "Anonymous" group, which has repeatedly acted in various regions of the world, attempting to counteract attempts to restrict freedom of speech through attacks on state infrastructure.

The growth in popularity in the public sphere has also translated into interest among most states in the topic of cybersecurity — more and more states are establishing special cybersecurity components within their military structures, protecting critical infrastructure[^17], ranging from power plants to satellite communications and telecommunications. Analogously to cybersecurity, intelligence techniques based on attacks in the digital sphere have also developed, as well as unofficial state funding of hacking groups, officially referred to as APTs, from the English "advanced persistent threat"[^18], which engage in the long-term infiltration of the infrastructure of rival or hostile states.

The last reason for which attacks are carried out is cyberterrorism, which is only now gaining popularity among terrorist groups — the underlying ideas are similar to hacktivism, but the attacks themselves are more often aimed at bystanders, such as the civilian population, through attacks on critical infrastructure such as hospitals, power plants, or the financial sector.

2.4.2. Cybersecurity Objectives

The overarching goal of cybersecurity is to protect an organization's resources against unauthorized access, modification, or loss of access to a resource by authorized persons — this is the so-called CIA triad model, from the English "Confidentiality – Integrity – Availability".[^19]

Over the years that this field has been in operation, a "defense in depth" model has been developed, also often called the onion model, meaning that at each layer of the system a service should be placed to protect that layer against attack attempts. This most often refers to the layers of the ISO/OSI model, i.e., the seven-layer structure of network traffic, but this is not the only possible way to divide it — the onion model itself can also be applied to deeper layers, such as that of the operating system.[^20]

The above model, however, is not ideal, which has forced cybersecurity specialists to search for newer architectures. One of them is the cybersecurity mesh architecture, which encourages the application of a protection perimeter per resource rather than per layer, making it more difficult to carry out an effective attack — this architecture pairs well with microservice architecture, which is increasingly used in organizations, enabling faster rollout of changes.[^21]

It is worth mentioning that the above architectures are not the only ones used in cybersecurity — many frameworks have also been created, designed to facilitate the implementation of security measures in enterprises and organizations.

One of the older ones, and frequently applied worldwide, is the ISO 27001 standard, also often called an ISMS, from the English Information Security Management System. It defines information security and concentrates protection around four pillars: organization, people, physical security, and technology.[^22]

2.5. Analysis of Current Cybersecurity Threats

Nowadays, threats in cyberspace are changing continuously — due to the dynamics of the development of IT technologies, every new library, new device, or new algorithm affects existing threats or creates new ones.

The development of artificial intelligence algorithms has also increased the number of threats by adding new attack vectors, automating scripts, or creating so-called "deepfakes", i.e., very realistic voice or video forgeries; therefore, the author of this thesis emphasizes how important it is to carry out a proper risk and threat analysis before attempting to implement defense mechanisms.

2.5.1. Attack Structure

The first of the phases that must be carried out before proceeding with an attack is reconnaissance. This phase is usually legal, due to the absence of any permanent or temporary actions that violate a company's security, which is why it is often referred to as "White Intelligence", reconnaissance, or by the acronym OSINT. During these activities, all information that may be useful for carrying out an attack is gathered — this may include, among other things: information about employees, publicly available services, internet addresses, entries on social media profiles, or physical locations.[^23]

Next, the attacking party proceeds to "weaponize" the collected information. This involves using the information found about the target to prepare the attack — among other things, this may be the creation of a phishing email, the creation of a fake organization website, or the exploitation of vulnerabilities in existing weaknesses to prepare software intended to exploit a vulnerability.[^24]

The third phase focuses on delivering infected artifacts to the recipient, who may be either a natural person or a system. After delivering the artifact, the attacking party most often waits for an action to be performed on the recipient's side — this may, for example, be clicking on an infected attachment, visiting a fake website, or the execution of a script by the server. After the action is performed, a time window opens during which the attacker gains access to the system, using the recipient's privileges.[^25]

The next phase assumes the use of the recipient's privileges to explore the internal network, discover what capabilities the recipient has, and scan for internal vulnerabilities, which in most cases are easier to exploit or more numerous — this phase is similar to the first one.

The moment at which the attacker has greater awareness of the internal system of the attack's recipient is used to create an emergency entry point for the attacking party — this may, for example, be the creation of a user account, or the creation of a tunnel enabling connection via the SSH protocol. Such an entry point is called a "persistent backdoor" and gives the attacker the ability to enter the attacked system without any interaction from the attack's recipient.[^26]

The second-to-last phase is called command and control, as it focuses on executing commands and scripts intended to bring the attacker closer to achieving the attack's goal — this includes, among other things, taking over further parts of the system, impersonating other users, or encrypting files.

The final phase is equivalent to the attacker's partial or complete achievement of their designated goals and proceeding to exploit them for their own benefit — this may be demanding a ransom, selling confidential information, or simply disabling or destroying a competing system.

2.5.2. Most Common Attack Methods

Given the constantly growing number of attacks carried out against all kinds of entities, many foundations have been established that collect data on attacks, analyze these attacks, and disseminate knowledge about the most common attack vectors. The most popular among them is the OWASP Foundation, which regularly publishes its "Top 10" list[^27], containing the most common attacks on web applications. The second is the Mitre Corporation, which is responsible for the continuous maintenance and updating of the "ATT&CK" list[^28], containing the most common techniques used in individual phases of attacks.

The author of this thesis decided to collect several of the most common ones and present them briefly for a broader understanding:

• SQL Injection — an attack involving the addition of one's own SQL expression to a field in the user interface, which allows the selection, modification, and deletion of data to which the entity should not have access.[^29]
• Cross-Site Scripting — a vulnerability that allows an attacker to place a JavaScript script on an application's page; this can be achieved using user-interface fields, but also images, hiding code fragments within them — such code is subsequently executed on the side of every client loading the page.
• Phishing — an attack involving impersonating trusted entities, using popular distribution channels such as email or SMS, to deliver infected artifacts or extort confidential data.[^30]
• Command Injection — analogous to SQL Injection, it exploits user-interface fields that execute programs on the server, in order to execute commands ordered by the attacking party; command chaining is most often used for this purpose.
• Replication through removable media — assumes the use of the autorun feature on removable media such as a USB flash drive or a CD, to launch malicious software on the user's machine.[^31]

The above list presents only a few of the many possible techniques used in hacking attacks, illustrating how important it is to secure a system on many levels. It is also worth relying on many types of security measures, since some vulnerabilities may result from outdated software or from the human factor.

2.6. Review of Current Artificial Intelligence Algorithms

Recent years have popularized the development of machine learning and artificial intelligence in an increasing number of areas, resulting in a large number of algorithms that can be applied in many fields — cybersecurity is no exception, where an increasing number of technologies are being used both to attack and to secure systems:

• Linear regression — a statistical method used to model a linear relationship between variables and predict a continuous value; it can be used to analyze trends, both in a business context and to predict traffic in network communication, as well as a component of anomaly detection algorithms.
• Logistic regression — a classification technique focused on predicting the probability that a given item belongs to one of two classes; these classes can be specific entities, but a yes/no classification is also possible, useful for, among other things, phishing detection.
• Decision trees — a model based on nodes and leaves, in which each leaf can determine a class, while nodes are responsible for performing an operation based on a feature; they perform well with a small number of features and classes, and can be part of more advanced models such as "Random Forest".
• Clustering — an unsupervised method used to group data into clusters with similar properties, particularly useful for data segmentation and identification.
• Neural networks — an advanced classification technique that is part of deep learning methods, allowing the processing of complex patterns and analyses, but requiring large resources and data for training, and also difficult to interpret.
• SVM — a supervised classification method that uses kernels to find the optimal hyperplane; it performs well on datasets containing multidimensional features and is highly resistant to overfitting, but is computationally expensive.
• Association rules — an algorithm based on probability, calculating the chance of an item occurring if the preceding conditions are met; it is simple to implement, but very difficult to maintain with large numbers of conditions.
• Autoencoders — advanced neural networks possessing a latent space, performing very well in reconstruction, but, similarly to neural networks, difficult to interpret and requiring large datasets for training.
• Q-Learning — a reinforcement learning algorithm, focused on the principle of reward and punishment, choosing actions that offer the greatest reward, which allows it to adapt to new patterns based on defined rules; however, its reaction time is delayed compared to other models, and it does not scale efficiently, although it is used in many more advanced techniques, such as DQN.

The above list presents some of the most popular, basic techniques used in the field of machine learning, but it is not exhaustive — new techniques are emerging at a rapid pace, and older models are also frequently combined into more complex models, thereby achieving higher effectiveness.[^32]

3. Implementation of the "AI Web Gateway" IDPS Application

Having information about the application's functional and non-functional requirements, competing solutions, and currently applied solutions, it is necessary to proceed to selecting the technology for the project and its implementation.

3.1. Technology Selection and Library Overview

Selecting the right technology stack for the task at hand is key to any IT project. The remainder of this subsection presents a list of the main technologies and libraries used to build the application.

The author of this project decided to use the Python programming language to implement the application, due to the available libraries, its simple syntax, the popularity of the cybersecurity community working with it, and his own experience with this language.

One of the key libraries for the project is the MitmProxy library, which implements the establishment of a tunnel using the SSL/TLS protocols, in which it uses a man-in-the-middle attack implementation to inspect encrypted traffic, and also offers a web-based user interface and modularity through support for plugins written in Python.[^33]

Figure 3. Log viewer of the MITMProxy library. Source: own work.

The SciKit-Learn library was responsible for providing ready-to-train machine learning algorithms, such as logistic regression, which were used to build the model based on the data.[^34]

The project was stored using the GIT version control tool on a GitHub repository, ensuring the ability to revert to previous versions of the project, as well as facilitating incremental work on the application's code and viewing the history of file changes.

The "reverse proxy" function is handled by the NGINX web server, stable and highly configurable software containing many useful features, support for many operating systems, and a multitude of extensions.[^35]

The target to be protected was the DVWA web application, implemented by the GitHub community as software for learning cybersecurity and penetration testing. The application has deliberately prepared vulnerabilities that can be exploited, which made it possible to test the operation of the "AI Web Gateway" IDPS application without the need to implement a custom frontend application.[^36]

Figure 4. DVWA application interface. Source: own work.

The containerization of the software and the entire infrastructure is handled by one of the more popular, continuously developed containerization applications called Docker, together with the Windows manager Docker Desktop and the declarative environment configuration using YAML files called Docker Compose.[^37]

3.2. Model

Before proceeding with the implementation of the model, it is necessary to review and interpret the data, in order to know what data the model will be trained on and to select the best one for the task at hand — in accordance with subsection 2.6, every model has its strengths and weaknesses.

3.2.1. Data

The data for the project was sourced from the Kaggle website, which offers open-source datasets for training models. It is the most commonly used website for conducting artificial intelligence research and development; however, while this data is sufficient to prove a concept, commercial solutions typically use private enterprise data, which is difficult to obtain.

Table 1. Excerpt of the model's training data. Source: kaggle.com [26.07.2025]

Query	Label
? or 1 = 1 --	1
2689	0
<div draggable="true" contenteditable>drag me</div><content ondrop=alert(1) contenteditable>drop here</content>	1
</span><link rel="mw-deduplicated-inline-style" href="mw-data:TemplateStyles:r935243608"/>	0

The format of the supervised-learning data consists of feature columns and a label, which determines whether a given set of features belongs to the class or not — in the case of the IDPS model this is a single feature, namely the query, which, as part of data normalization, will be broken down into smaller parts. A sample excerpt of the data is presented in Table 1.

3.2.2. Data Interpretation

The dataset consists of 3 types of attacks plus valid data: 30 thousand records were prepared for SQL Injection, approximately 15 thousand for Cross-Site Scripting, and the smallest set contains 2 thousand Command Injection attacks. After training on such a set, the model should have no problem recognizing SQL Injection or XSS, but due to the size of the Command Injection set, problems may arise in detecting this type of attack.

The distribution of data labeled as an attack, i.e., containing label 1, compared to legitimate traffic, labeled 0, is close to balanced, so the model should be able to distinguish well between legitimate and malicious traffic.

In the case of data classification, a character string is most often split into smaller strings and then vectorized, creating a dictionary of expressions known to the model. In the case of the current model, this may mean that if the model encounters an attack pattern that does not contain any known word, it will not recognize such an attack — however, there is a way to address this problem, which will be presented as part of the project summary.[^38]

3.2.3. Method Selection

This project uses logistic regression to detect attack patterns, due to its speed and ease of interpretation while maintaining high effectiveness. These are very important features in IDPS-type systems.[^39]

Models such as SVM and decision trees were also considered, but their effectiveness is lower in most comparisons, and their implementation costs are incomparably higher.[^40]

The last aspect that tipped the scales in the choice of model was the possibility of scaling up to more effective solutions — a case has been demonstrated in which, for Internet of Things devices, an effectiveness of over 99% was achieved on the test set using an extended logistic regression within an IDS application.[^41]

3.3. Project Implementation Vision

The project was carried out in an incremental manner, which made it possible to adapt the software to stakeholder requirements, better detect errors, and deliver a working version of the software more quickly.

3.3.1. Application Architecture Diagram

It is natural for an IDPS-type application to be plugged in as a reverse proxy in front of the web application server, which makes it possible to hide the server from clients and supervise the traffic coming into the service.[^42]

Figure 5. Network architecture diagram of the application. Source: own work. The diagram shows two users (Threat Actor and Web Application User) connecting through their routers and the Internet to an entry point, behind which, within a single docker-compose pod, are located, in sequence: the NGINX reverse proxy, the IDPS application, and the DVWA application.

The author of this project decided to separate the server providing the reverse proxy function into a separate container, in accordance with the architecture presented in Figure 5, in order to reduce image size, make it easier to scale IDPS containers, reduce the attack surface, as well as speed up container startup — however, it is possible for the IDPS to simultaneously serve as the reverse proxy and run on the NGINX image.[^43]

3.3.2. Penetration Testing

The next step in software implementation, once the development team has the requirements and technologies needed to carry out the project, should be the preparation of test scenarios.

Table 2. Test cases for penetration testing. Source: own work.

No.	Payload	Attack type	Expected	Result	Status
1	1 UNION SELECT null, username || '~' || password FROM users --	SQLI	403	403	Positive
2	105' OR 1=1	SQLI	403	200	Negative
3	' OR EXISTS(SELECT * FROM users WHERE username='admin') --	SQLI	403	403	Positive
4	'; EXEC xp_cmdshell('dir'); --	SQLI	403	403	Positive
5	' AND SLEEP(5) --	SQLI	403	403	Positive
6	" OR "" = "	SQLI	403	403	Positive
7	abc	SQLI	200	200	Positive
8	105	SQLI	200	200	Positive
9	1 ORDER BY 10 --	SQLI	403	403	Positive
10	1; SHUTDOWN --	SQLI	403	200	Negative
11	<iframe src='javascript:alert(1)'></iframe>	XSS	403	403	Positive
12	<body onload=alert('test')>	XSS	403	403	Positive
13	<math><mi>x</mi><mtext><svg onload=alert(1)></svg></mtext></math>	XSS	403	403	Positive
14	<div onmouseover=alert(1)>XSS</div>	XSS	403	403	Positive
15	";alert(1);//	XSS	403	403	Positive
16	Welcome back!	XSS	200	200	Positive
17	<a href='http://example.com'>Click me</a>	XSS	200	200	Positive
18	XSS	XSS	200	200	Positive
19	<b>bold</b>	XSS	200	200	Positive
20	<img src='x' onerror='console.log(1)'>	XSS	403	200	Negative
21	8.8.8.8; rm -rf /	CMDI	403	200	Negative
22	127.0.0.1 && sleep 5	CMDI	403	403	Positive
23	localhost | whoami	CMDI	403	200	Negative
24	;echo vulnerable	CMDI	403	200	Negative
25	192.168.1.1	CMDI	200	200	Positive
26	127.0.0.1	CMDI	200	403	Negative
27	8.8.4.4	CMDI	200	200	Positive
28	;ping -c 4 evil.com	CMDI	403	200	Negative
29	|| ls	CMDI	403	403	Positive
30	| id	CMDI	403	403	Positive

The cases presented in Table 2 are composed of realistic data that could be entered, as well as data that can be considered malicious — this data is called the payload. Next in sequence is the attack type, as well as the endpoint the payload is sent to, the expected and received HTTP response code; the last column is the test result — if the expected code matches the received one, the test status is positive, otherwise the test result is negative and requires further work on the model.[^44]

The prepared payload is simple, given that the application's task is to prove the concept of using artificial intelligence models — for commercial applications, the tests should be expanded to include a larger number of cases, as well as more sophisticated methods of carrying out the above attack types.

Listing 1. Penetration test configuration in the pentest.py file. Source: own work.

import requests

BASE_URL = "http://localhost"
TIMEOUT = 5

# === 1. Defined tests: (payload, function, expected_status_code) ===

tests = [
    # Table of test cases
]

Listing 1 presents the initial penetration test configuration and the import of the required internal Python library called requests[^45], used to make HTTP requests. The next step was to define the initial configuration, in which the base of the address path was extracted, i.e., the hosting machine — in this case it is the local machine, but in more advanced environments this could be a different host. Defining a global timeout before aborting is good practice, since although in the case of a local environment there is no question of unavailability, such a phenomenon can occur in more advanced environments. The last definition is the list of test cases, declared in accordance with Table 2.

Listing 2. Definition of test methods in the pentest.py file. Source: own work.

def sqli(payload: str) -> int:
    endpoint = f"{BASE_URL}/vulnerabilities/sqli/"
    params = {"id": payload, "Submit": "Submit"}
    resp = requests.get(endpoint, params=params, timeout=TIMEOUT)
    return resp.status_code

def xss(payload: str) -> int:
    endpoint = f"{BASE_URL}/vulnerabilities/xss_r/"
    params = {"name": payload, "Submit": "Submit"}
    resp = requests.get(endpoint, params=params, timeout=TIMEOUT)
    return resp.status_code

def cmdi(payload: str) -> int:
    endpoint = f"{BASE_URL}/vulnerabilities/exec/"
    data = {"ip": payload, "Submit": "Submit"}
    resp = requests.post(endpoint, data=data, timeout=TIMEOUT)
    return resp.status_code

method_map = {
    "sqli": sqli,
    "xss": xss,
    "cmdi": cmdi,
}

The next stage was to develop test methods for the individual endpoints, presented in Listing 2, and to map the payload string from the test-case table to a specific test method.

Each method took a character string, which it then sent to an endpoint built from the base address and a path adjusted to the attack type; in response, the method returned the HTTP code returned by the service. This implementation made it possible to build a more generic test runner, i.e., the method responsible for executing specific cases.

Listing 3. Test runner implementation in the pentest.py file. Source: own work.

def run_tests():
    total = len(tests)
    correct = 0
    failed_cases = []

    print("\n=== Running tests ===\n")
    for i, (payload, method_name, expected_status) in enumerate(tests, 1):
        test_func = method_map[method_name]
        try:
            actual_status = test_func(payload)
            match = actual_status == expected_status
            if match:
                correct += 1
                status = "[OK]"
            else:
                status = "[FAIL]"
                failed_cases.append(
                    (i, payload, method_name, expected_status, actual_status)
                )
        except Exception as e:
            status = "[ERROR]"
            failed_cases.append(
                (i, payload, method_name, expected_status, f"ERROR: {e}")
            )
            actual_status = "ERR"

        print(
            f"{status} {i:02d} | {method_name.upper()} | payload={repr(payload):<30} | "
            f"expected={expected_status}, got={actual_status}"
        )

The main body of the program that executes the penetration tests is presented in Listing 3, where the number of loop iterations is calculated dynamically based on the list of cases, and within it the specific cases are executed, with errors being stored in the failed_cases array, which at a later stage will make it possible to calculate the necessary metrics.

Listing 4. Formatting and calculating test statistics in the pentest.py file. Source: own work.

    print("\n=== Summary ===")
    print(f"Correct: {correct}/{total}")
    print(f"Accuracy: {correct / total * 100:.2f}%")

    if failed_cases:
        print("\n Failed cases:")
        for i, payload, method, expected, got in failed_cases:
            print(
                f" - Test {i}: {method.upper()} | {repr(payload)} | "
                f"expected={expected}, got={got}"
            )


if __name__ == "__main__":
    run_tests()

The last stage of work on the tests is to prepare a visualization of them for easier presentation and broader understanding of their results — at the proof-of-concept stage, well-formatted console text is sufficient. The code preparing the statistics is presented in Listing 4.

A condition was also included there to check whether the file being executed is the pentest.py file; if so, the run_tests method should be started. This is a safeguard against executing the code in the event that the code is imported as a library.[^46]

Figure 6. Output of the pentest.py test script execution. Source: own work.

The final result of the script is presented in Figure 6, where formatted text can be seen, reporting the status of specific cases as well as the overall effectiveness of the "AI Web Gateway" IDPS application — a detailed interpretation of these results will take place in Chapter 4 of this thesis.

3.3.3. Plugin Implementation

Having knowledge of the requirements, the solution architecture, and having prepared the test cases, it is possible to implement the target software. Since this is a solution based on a reverse proxy, running it in isolation does not allow for reliable testing, so first it is necessary to consider how this application will be run.

Listing 5. Script named entrypoint.sh launching the IDPS application. Source: own work.

#!/bin/bash
TARGET=http://dvwa

echo "[ENTRYPOINT] Starting IDPS with reverse proxy on $TARGET"

echo "[MITM] Launching mitmweb..."
exec mitmweb \
  --mode reverse:$TARGET \
  --listen-port 8080 \
  --web-port 8081 \
  --web-host 0.0.0.0 \
  --listen-host 0.0.0.0 \
  -s /script.py

The script presented in Listing 5 shows the form of a Bash startup script, which is responsible for executing the mitmweb command, launching the application's web interface on port 8081, together with establishing a tunnel between the client — which can be any address sending a request to port 8080 in accordance with the passed arguments — and the Python script called script.py, which will be used as an overlay on the mitmproxy sniffer.

Listing 6. Importing the required script.py libraries. Source: own work.

import os
import pandas as pd
from mitmproxy import http
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression

Work on the plugin began with importing the necessary libraries in accordance with Listing 6, such as os, which enables working with system file paths, the pandas library and sklearn modules for data processing and model building, and the http module from the mitmproxy library for creating plugins that interpret and process HTTP and HTTPS traffic.

Listing 7. script.py plugin constructor. Source: own work.

class AIIDS:
    def __init__(self):
        self.vectorizer = TfidfVectorizer(analyzer="char_wb", ngram_range=(3, 5))
        self.model = LogisticRegression()
        self.train()

The AIIDS class presented in Listing 7 is the main element of the program, responsible for the entirety of the plugin. In its constructor, a vectorizer is defined, whose task is to transform the data into a format more friendly to the model.

The TF-IDF vectorizer defines the weight of a given phrase based on the product of the TF and IDF factors. The first of these is the frequency of occurrence of the expression, while the second is the inverse frequency. The char_wb parameter passed determines the way the n-gram is created, while the ngram_range tuple defines the resolution of this n-gram.[^47]

Besides the vectorizer, an initial, untrained logistic regression model is also created, which is stored as the class's model field, after which the training function is executed.

It is worth noting that in commercial environments a more common solution is to separate model creation and training into separate files, most often using a specialized IDE such as Jupyter Notebook, then exporting the model to a separate file, and in the target solution importing the ready-made model, in order to reduce responsibilities and improve the software instance creation time — however, for the purposes of this thesis, the idea of combining these steps is sufficient to prove the concept.

Listing 8. Definition of the script.py model training function. Source: own work.

def train(self):
    data_path = os.path.join("Data", "Attacks.csv")

    if not os.path.exists(data_path):
        print(f"[AIIDS] Training file not found: {data_path}")
        return

    try:
        df = pd.read_csv(data_path)
        if "Query" not in df.columns or "Label" not in df.columns:
            raise ValueError("The CSV must contain the 'Query' and 'Label' columns")
        queries = df["Query"].astype(str).tolist()
        labels = df["Label"].astype(int).tolist()

        X = self.vectorizer.fit_transform(queries)
        self.model.fit(X, labels)

        print(f"[AIIDS] Model retrained on {len(labels)} samples.")
    except Exception as e:
        print(f"[AIIDS] Error during training: {e}")

The model training function was implemented in accordance with Listing 8. It reads data from a CSV file, using the pandas library's read_csv function, which performs an on-the-fly conversion into a data frame, i.e., a special pandas object that enables operations to be carried out on vectors.[^48]

The next step is to split the data into patterns and their labels. In this case, the patterns are specific fragments of HTTP requests, which are then vectorized. Once the data is in vectorized form, the model must be trained by passing the data and labels to the fit function, which will be used to validate the training results and improve the feature weights in subsequent training iterations.

Listing 9. script.py prediction function. Source: own work.

def predict(self, text):
    try:
        vec = self.vectorizer.transform([text])
        prediction = self.model.predict(vec)[0]
        return prediction == 1
    except Exception as e:
        print(f"[AIIDS] Prediction error: {e}")
        return False

It is good practice to define a helper function predict, as in Listing 9, which transforms real queries into a common form with the test data, making it easier to guarantee consistency, although there is nothing stopping one from writing the same code inline wherever it is used.

Listing 10. Sniffing HTTP and HTTPS traffic in script.py. Source: own work.

def request(self, flow: http.HTTPFlow):
    params = {}

    # GET params
    for key, value in flow.request.query.items(multi=True):
        params.setdefault(key, []).append(value)

    # POST params (if any)
    if flow.request.method == "POST":
        try:
            for key, value in flow.request.urlencoded_form.items(multi=True):
                params.setdefault(key, []).append(value)
        except Exception:
            pass  # e.g. no form-urlencoded data

    print(f"[AIIDS] Request received: {params}")

    for key, values in params.items():
        for value in values:
            if self.predict(value):
                print(f"[AIIDS] SQLi detected in field '{key}': {value}")
                flow.response = http.Response.make(
                    403,
                    b"Blocked by AI IDPS: suspicious SQL query detected",
                    {"Content-Type": "text/plain"},
                )
                return

Listing 10 presents the actual use of the model. The mitmproxy library requires the plugin to implement a request method, which will receive every request passing through the reverse proxy.

The request is then parsed into an object containing parameters — in the case of the "AI Web Gateway" application, this is taken from GET and POST requests, which are the only ones present in the DVWA application, whereas when implementing a comprehensive solution, support for the remaining HTTP methods should be provided analogously to the POST method.

The application then iterates over the list of parameters and normalizes them, then feeds them into the model's prediction, waiting for a positive or negative result for the query. If the result indicates the presence of a malicious instruction, the request is blocked and a 403 Forbidden response is returned.

Listing 11. script.py plugin export. Source: own work.

addons = [AIIDS()]

The last step is to export the list of extensions called addons, which contains the previously implemented AIIDS class. This list will be loaded by mitmproxy, and the constructor that trains the model will be invoked.[^49]

3.3.4. Containerization

Having written the application, it must be prepared for deployment by creating a package containing the correct application image along with its dependencies, and then running a local environment similar to a production one.

Listing 12. Dockerfile configuring the application image. Source: own work.

FROM mitmproxy/mitmproxy:latest

RUN pip install scikit-learn pandas
COPY entrypoint.sh /entrypoint.sh
COPY script.py /script.py
COPY Data /Data

RUN chmod +x /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]

When building an application, one of the requirements of modern software engineering is to ensure repeatability of application startup. The correct situation occurs when the production application is an exact copy of the application in the development environment — many ways of solving this problem have been developed, one of which is the Dockerfile.[^50]

A Dockerfile is a configuration file that runs applications in any environment defined by the developer, and then configures them into the state the application requires in order to run.[^51]

The file presented in Listing 12 is precisely such a Dockerfile, which, based on the image prepared by mitmproxy, installs the necessary dependencies and then copies the application files.

Finally, it grants execution rights via the Linux chmod command and sets the entry point, i.e., the command or script that will be executed by the newly created container — in this case, this is the previously discussed script from Listing 5.

Listing 13. docker-compose.yml file creating the environment. Source: own work.

services:
  dvwa:
    image: vulnerables/web-dvwa
    ports:
      - "8080:80"
    restart: always
    environment:
      - MYSQL_PASSWORD=p@ssw0rd
    depends_on:
      - mysql
    networks:
      - internal

  mysql:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: p@ssw0rd
      MYSQL_DATABASE: dvwa
    networks:
      - internal

  idps:
    build: ./idps  # directory containing the IDPS Dockerfile
    tty: true
    ports:
      - "8081:8081"
    networks:
      - internal

  gateway:
    image: nginx:alpine
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    ports:
      - "80:80"
    depends_on:
      - idps
    networks:
      - internal

networks:
  internal:
    driver: bridge

The second method, often used together with Docker containers, is infrastructure as code, or IaC for short, which provides a declarative way of creating infrastructure that, in most cases, is immutable. Of course, this does not prevent the system administrator from being able to modify systems, but doing so is inconsistent with best practice and increases costs by adding unnecessary maintenance work.[^52]

IaC assumes that whenever changes to the environment need to be made, it will be rebuilt from scratch, preserving only the data through mechanisms such as a volume in Docker, or a PVC in Kubernetes.

The docker-compose.yml file of the "AI Web Gateway" application defines the services in accordance with the architecture presented in subsection 3.3.1, as well as the database required by the DVWA application, by passing the correct image in the image parameter, or, in the case of a Dockerfile, the build parameter.

Environment variables made available by the application's authors were also defined, as well as an internal network with a bridge to the host network, so the applications were exposed outside the containerization engine and are available on ports in accordance with the ports declaration, where the first value is the port available externally, while the second value after the ":" character denotes the application's internal port as defined by the author.

A file prepared in this way makes it possible to stand up the infrastructure with a single command in the project directory — simply enter the command docker-compose up on Windows systems, or docker compose up on Linux and MacOS systems, to launch the project. It is also worth adding the --build parameter, which rebuilds the containers if a change has been made.

Listing 14. NGINX configuration. Source: own work.

events {}

http {
    server {
        listen 80;

        location / {
            proxy_pass http://idps:8080;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
}

Besides the aforementioned parameters, a volume was also defined for the NGINX reverse proxy, containing the file shown in Listing 14, whose task is to redirect traffic to the IDPS application using the proxy_pass parameter, together with the Host and X-Real-IP headers. The first of these makes it possible to determine where the request was called from, while the second passes on to the application where the target request was supposed to go, in order to redirect it correctly in the event that the traffic is not deemed malicious.

This is a popular NGINX configuration, also frequently used for load balancing network traffic, building an API Gateway, and when NGINX acts as an ingress controller in applications such as Kubernetes.[^53]

Figure 7. Output of running docker-compose for the application configuration. Source: own work.

Figure 7 presents the result of running the docker-compose.yml file in Docker Desktop[^54] on Windows 11, where, among other things, the status of the containers, their names, the exposed ports, and the resources allocated to the containers can be seen.

This tool is required to work with containers on Windows systems, since containerization tools are only available in environments based on the Linux kernel — it virtualizes the Linux kernel, creating a lightweight subsystem. An alternative to this solution is to use the Windows Subsystem for Linux, which allows a full-fledged Linux distribution to be installed under Windows.[^55]

Figure 8. Output of executing a malicious GET request. Source: own work.

Testing an application should not rely solely on automated tests, since automated tests are written by humans — manual unit tests should always be carried out to verify that no error was introduced in the automated tests, or at least during their first run.[^56]

The manual test is shown in Figure 8, where a GET request was sent to the application, to the endpoint used for testing SQL Injection attacks. The malicious payload was blocked with a 403 Forbidden response, in accordance with the application's design assumptions.

The application has been implemented in accordance with its design assumptions and is ready to be deployed in a production environment; however, one should keep in mind the principle of zero trust toward the software vendor, and it is best to secure the application with an additional layer of protection.[^57]

4. Summary

Having finished software in the form of a "Minimum Viable Product", the author of this thesis presents the conclusions drawn from the implemented project, as well as presenting the advantages of applying artificial intelligence in the field of cybersecurity, while also drawing attention to the risks arising from the excessively rapid development of artificial intelligence models.

4.1. Project Conclusions

The preceding chapter proved the validity of the concept of using artificial intelligence methodologies in cybersecurity applications through the implementation of the "AI Web Gateway" application, which uses a logistic regression algorithm, trained on publicly available data, to repel attacks on web applications.

The project was prepared using modern technologies, which made it easier to create an imitation of a commercial environment, sufficient to carry out reliable penetration tests.

4.1.1. Project Status

The artificial intelligence algorithm, presented and discussed in more detail in subsection 3.2 Model, achieved an effectiveness of over 73%, which is a good result given the small data sample.

The most recognition errors occur with Command Injection attacks — this is the attack that had the smallest set of training cases, which is why the result is understated.[^58]

SQL Injection and XSS attacks were correctly repelled by the IDPS, with the exception of the isolated cases presented in Table 2 — these attacks had the largest datasets.

The current state of the model allows for further development work and the implementation of additional functionalities required in commercial environments; however, it should be kept in mind that this should not be the application's only line of defense — as the author of this thesis mentioned in subsections 2.4 and 2.5, a combination of multiple cybersecurity technologies should be used to ensure adequate protection for an organization's resources.

4.1.2. Development Opportunities

There are many possibilities for developing the current application. The simplest and most effective is to expand the dataset with a larger number of cases — the example of the difference in errors between effectiveness against SQL Injection and XSS attacks compared to Command Injection perfectly illustrates the difference that high-quality data provides. The dataset can be expanded in many ways: a common practice is to purchase data from organizations that specialize in collecting attack data, or to deploy a trap, often called a honeypot[^59], which simulates real machines exposed to the public internet, allowing data on attacks to be collected from threat actors.

Another point of development for the application could be advanced logging. Although mitmproxy provides a basic log viewer, integration with tools such as Grafana or ELK, as well as various SIEM tools, makes it easier for a cybersecurity unit to work on incidents in terms of incident reporting and analysis.[^60]

The model could also be combined with other models trained for other types of attacks, expanding the defensive perimeter and creating a more comprehensive solution for defending web applications, protecting them against, for example, DDoS or CSRF attacks.

The previously mentioned separation of model training from its implementation is also a good idea — once a larger amount of data were fed into the model, this would minimize the application startup time in production environments, where downtime is usually very costly for an organization.

4.2. The Impact of Artificial Intelligence on Current Threats in Cyberspace

The continuously developing capabilities of artificial intelligence, and its growing use, contribute to the number of cybersecurity threats — this is a process analogous to that of any new technology. An example is quantum computers, which have the ability, among other things, to break traditional passwords instantaneously, which is why, alongside the development of technology, its regulation and safeguarding is important.

Machine learning algorithms themselves can be used by attackers to develop tools such as decryption algorithms, using password databases to train a model that cracks passwords using a brute-force technique, as well as generators that create dynamic virus signatures that standard antivirus software will not be able to detect.[^61]

Security applications themselves can also be the target of attacks using artificial intelligence, by modifying requests in a man-in-the-middle attack, so as to block traffic or make it harder to detect malicious code.[^62]

Natural language processing models, NLP for short, can popularize attack-creation techniques, and can themselves be used, for example, in phishing, creating fake content personalized to the targeted entity, and these models can also be used for OSINT, in order to search for the most sensitive information.[^63]

Propaganda content can also be created by generative artificial intelligence, to impersonate famous people, for terrorist or financial purposes — it is already possible to create a voice or video recording of a person that is difficult for a human to distinguish from the real person.

Popular online chatbots can also be used to obtain the data on which the model was trained, or to modify this data in order to carry out fraud, for example by directing customers to domains impersonating real ones, in order to extort further data.[^64]

Therefore, alongside the development of these technologies, work must be done on processes and applications that protect sensitive resources against new threats, bearing in mind that every new tool can be a weak point in an organization's defenses.[^65]

4.3. Analysis of Applicable AI-Based Solutions in Cybersecurity

The development of artificial intelligence brings not only new threat vectors, but also enables the construction of advanced defense mechanisms. The literature emphasizes that solutions based on machine learning and deep learning make it possible to analyze huge volumes of data, respond adaptively to new attacks, and predict previously unknown intrusion vectors. Below are presented the key areas in which artificial intelligence can find practical application in cybersecurity.

IDPS systems traditionally relied on rigidly defined rules and signatures, which meant that their development and maintenance involved high implementation costs, as well as frequent delays in implementing defenses against new attacks, often called zero-days. The application of artificial intelligence in these systems increases the chance of detecting attacks that do not originate from the patterns used for training, and also reduces production and maintenance costs through mechanisms such as reinforcement learning or fine-tuning.[^66]

NLP models can also be used to analyze internet forums, popular social networking sites, and many other internet sources as part of intelligence gathering — using techniques such as function calling, it is possible to search in advance for content from popular hacking groups regarding their attack targets and to prepare preventive measures.[^67]

Orchestration and automation tools, SOAR for short, can also gain a great deal by extending their operation not only to detecting activity and automating incident-handling processes, but also by giving them the ability to suggest or take action, for example: blocking infected machines, updating blacklists, or revoking user privileges in the event of an infection.[^68]

Recurrent and convolutional networks can be applied in the static analysis of source code, the detection of spoofed websites and phishing emails, and in antivirus analysis. Unlike classic heuristic methods, AI solutions can detect new, previously unknown variants of malware.[^69]

User behavior analysis and dynamic privilege management are also a domain in which AI is able to enhance current applications through the dynamic detection of anomalies, such as unusual logins or the sudden, mass execution of persistent commands — such algorithms are useful in detecting insider attacks, for which there is still no good means of prevention to this day.[^70]

An analysis of the literature and current trends indicates that artificial intelligence can constitute a key element of future cybersecurity systems. Its greatest value is its ability to adapt to new types of threats and its capacity to automate the analysis of enormous volumes of data that would be impossible for analysts to process in real time. On the other hand, researchers emphasize the need for further development of methods resistant to adversarial attacks and for ensuring high-quality training data. Every AI solution, like every new tool in IT infrastructure, can become a potential attack vector and requires an appropriate security audit.[^71]

4.4. Conclusion of the Thesis

This master's thesis presented the design and implementation of an application-layer Intrusion Detection and Prevention System operating as an HTTP/HTTPS proxy. This system uses mitmproxy to intercept traffic, and then analyzes it using a machine learning model, with particular emphasis on logistic regression as the chosen baseline method. The solution was containerized and prepared for deployment in the Microsoft Azure, Google Cloud Platform, and Amazon AWS clouds, which enables it to be easily run and scaled.

The literature analysis and experimental research showed that AI models are effective in detecting SQL Injection, XSS, and Command Injection attacks, although their effectiveness depends to a large degree on the quality and balance of the training data. The greatest difficulties were observed with Command Injection attacks, which were poorly represented in the datasets, resulting in an increased number of classification errors. This phenomenon confirms the literature's claims regarding the problem of class imbalance in ML-based security systems.

The thesis also identified possible directions for further development, including integrating the system with SIEM tools, using deep learning techniques, and implementing automated incident response mechanisms. At the same time, it was emphasized that although artificial intelligence significantly increases the effectiveness of threat detection, it can itself become the target of attacks, for example: data poisoning, adversarial examples, which requires building resilient models and taking risk into account at the design stage.

In summary, the presented solution constitutes proof that integrating a proxy, artificial intelligence, and modern deployment technologies, such as containers or the cloud, can be an effective method of strengthening the protection of web applications. The thesis demonstrates the practical potential of AI in cybersecurity, while at the same time pointing out the limitations and challenges that should be the subject of further research.

5. Bibliography

Note on translation: citation titles are given as originally published — Polish-language book/article titles are left untranslated, per standard bibliographic citation practice, since translating them would misidentify the cited edition.

5.1. List of Literature

• Thomas D., Hunt A., „Pragmatyczny programista. Od czeladnika do mistrza. Wydanie II", Helion, 2021
• Cooper A., „The Inmates Are Running the Asylum", Pearson Education, 2000
• Revella A., „Buyer Persona. Poznaj i zrozum decyzje zakupowe swoich klientów", MT Biznes, 2021
• Mitnick K., Wozniak S., Simon W.L., „Duch w sieci", Helion, 2019
• Vajjala S., Majumder B., Gupta A., Surana H., „Przetwarzanie języka naturalnego w praktyce. Przewodnik po budowie rzeczywistych systemów NLP", Helion, 2023
• Chelladhurai J.S., Singh V., Raj P., „Docker dla praktyków. Wydanie II", Helion, 2018
• Woolley S., „Manufacturing Consensus: Understanding Propaganda in the Era of Automation and Anonymity", Yale University Press, 2023
• Sikos F. L., „AI in Cybersecurity", Springer, 2019

5.2. Scientific Articles

• Ulah A.M., Jamal A.A., Tuhin R.A., Akhter S., „Detecting distributed denial of service attacks using logistic regression and SVM methods", source: arxiv.org/pdf/2411.14512 [27.07.2025]
• Disha A.R., Waheed S., „Performance analysis of machine learning models for intrusion detection system using Gini Impurity-based Weighted Random Forest (GIWRF) feature selection technique", source: cybersecurity.springeropen.com [27.07.2025]
• Chalichalamala S., Govidan N., Kasarapu R., „Logistic Regression Ensemble Classifier for Intrusion Detection System in Internet of Things", source: mdpi.com [27.07.2025]
• Schroer S. L., Pajola L., Castagnaro A., Apruzzese G., „Exploiting AI for Attacks: On the Interplay between Adversarial AI and Offensive AI", source: arxiv.org/html/2506.12519v1 [20.08.2025]
• Kolosnjaji B., Demontis A., Biggio B., Maiorca D., Giacinto G., Eckert C., Roli F., „Adversarial Malware Binaries: Evading Deep Learning for Malware Detection in Executables", source: arxiv.org/abs/1803.04173 [20.08.2025]
• Zhao C., Si S., Tu T., Shi Y., Qin S., „Deep-Learning Based Injection Attacks Detection Method for HTTP", source: mdpi.com [21.08.2025]
• Buczak A. L., Guven E., „A Survey of Data Mining and Machine Learning Methods for Cyber Security Intrusion Detection", source: ieeexplore.ieee.org [22.08.2025]
• Sommer R., Paxson V., „Outside the Closed World: On Using Machine Learning for Network Intrusion Detection", source: researchgate.net [22.08.2025]
• Hyrum S. A., „Evading Machine Learning Malware Detection", source: semanticscholar.org [22.08.2025]
• Iqbal H. S., Kayes A. S. M., Badsha S., Alqahtani H., Watters P., Ng A., „Cybersecurity data science: an overview from machine learning perspective", source: journalofbigdata.springeropen.com [22.08.2025]
• Mohiuddin A., Abdun M., Jiankun H., „A Survey of Network Anomaly Detection Techniques", source: researchgate.net [22.08.2025]

5.3. Online Sources

• Scarfone K., Mell P., „Guide to Intrusion Detection and Prevention Systems (IDPS)", source: nvlpubs.nist.gov [16.05.2025]
• Red Hat, „What is an intrusion detection and prevention system (IDPS)?", source: redhat.com [16.05.2025]
• OWASP Foundation, „OWASP Top Ten", source: owasp.org [16.05.2025]
• Cisco Secure Docs, „Snort 3 Adoption", source: secure.cisco.com [16.05.2025]
• Combs R., „Snort 3.0 with ElasticSearch, LogStash, and Kibana (ELK)", source: blog.snort.org [16.05.2025]
• Salmon M., „Suricata and OSSEC IDPS Systems Review", source: researchgate.net [16.05.2025]
• Persona Institut, „Persona knowledge: the history of buyer personas", source: persona-institut.de [09.06.2025]
• Agile Alliance, agilemanifesto.org [09.06.2025]
• Gartner, „Cybersecurity Leadership", gartner.com [09.06.2025]
• Bloomer T., „Do IT Managers Fit in an SMB?", cortavo.com [10.06.2025]
• Swimlane, „Roles & Responsibilities of a DevSecOps Engineer", swimlane.com [09.06.2025]
• Ramirez A., „Digital transformation driven by community: Kubernetes as example", source: cncf.io [20.05.2025]
• Homepage of the Polish Cyberspace Defence Forces, source: cyber.mil.pl [27.07.2025]
• Rapid7, list of APT groups, source: docs.rapid7.com [27.07.2025]
• Hakon Software, „Triada CIA w cyberbezpieczeństwie: Klucz do bezpieczeństwa IT", source: hakon.pl [27.07.2025]
• Fortinet, „What Is Defense In Depth?", source: fortinet.com [27.07.2025]
• Fortinet, „What Is Cybersecurity Mesh?", source: fortinet.com [27.07.2025]
• Resilia, „Co to jest norma ISO 27001 i dlaczego jest tak ważna dla organizacji?", source: resilia.pl [30.07.2025]
• Medium, „Persistence || Backdoor Techniques (Beginner to Advanced) in Linux", source: infosecwriteups.com [27.07.2025]
• Mitre Corporation, „ATT&CK", source: attack.mitre.org [27.07.2025]
• OWASP Foundation, „A03:2021 – Injection", source: owasp.org [27.07.2025]
• Mitre Corporation, „Phishing", source: attack.mitre.org [27.07.2025]
• Mitre Corporation, „Replication Through Removable Media", source: attack.mitre.org [27.07.2025]
• FlowHunt, „Model Chaining", source: flowhunt.io [27.07.2025]
• Mitmproxy, HTTP/HTTPS traffic monitoring library, source: mitmproxy.org [21.05.2025]
• SciKit-Learn, a library containing popular implementations of machine learning algorithms, source: scikit-learn.org [22.07.2025]
• NGINX application server, source: nginx.org [22.07.2025]
• DVWA application, source: github.com/digininja/DVWA [22.07.2025]
• Docker containerization technology, source: docker.com [22.07.2025]
• Kajdanowicz T., Tagowski K., Rajda K., Sawczyn A., Bielak P., „Zaawansowane przetwarzanie tekstów", source: pwr-ai.github.io [27.07.2025]
• Broniewski P., „Reverse proxy. Co to jest i jak działa reverse proxy?", source: webporadnik.pl [21.05.2025]
• Sandeep D., „Kubernetes best practices: How and why to build small container images", source: cloud.google.com [21.05.2025]
• BrowserStack, „How to write Test Cases in Software Testing?", source: browserstack.com [27.07.2025]
• Python requests library, source: pypi.org/project/requests [23.07.2025]
• Myrianthous G., „What Does "If __name__ == '__main__'" Do in Python?", source: builtin.com [23.07.2025]
• Official Pandas library documentation, „DataFrame", source: pandas.pydata.org [27.07.2025]
• Official MITMProxy library documentation, „Addons", source: docs.mitmproxy.org [27.07.2025]
• Docker documentation, „Dockerfile reference", source: docs.docker.com [27.07.2025]
• Buchanan I., „Infrastruktura jako kod", source: atlassian.com [27.07.2025]
• Official NGINX documentation, „NGINX Reverse Proxy", source: docs.nginx.com [30.07.2025]
• Docker Desktop container management tool, source: docker.com/products/docker-desktop [27.05.2025]
• Microsoft, „How to install Linux on Windows with WSL", source: learn.microsoft.com [30.07.2025]
• Buła A., „Do you really need a manual tester and why the answer is "yes"?", source: rst.software [27.07.2025]
• Crowdstrike, „Data Poisoning: The Exploitation of Generative AI", source: crowdstrike.com [20.08.2025]
• nFlo, „Co to jest Honeypot?", source: nflo.pl [19.08.2025]
• Prakash A., „Real-Time Continuous Monitoring with a SIEM Using the ELK Stack", source: arunprakashpj.medium.com [21.08.2025]
• Cloudflare, „What is a supply chain attack?", source: cloudflare.com [21.08.2025]
• Legaspi C., „The Collaboration Paradox: When Security Tools Become Your Biggest Vulnerability", source: avepoint.com [21.08.2025]

6. List of Tables

• Table 1: Excerpt of the model's training data
• Table 2: Test cases for penetration testing

7. List of Figures

• Figure 1: Snort application GUI, Source: blog.snort.org [21.05.2025]
• Figure 2: Suricata application GUI, Source: suricata.io/features [21.05.2025]
• Figure 3: Log viewer of the MITMProxy library, source: own work
• Figure 4: DVWA application interface, source: own work
• Figure 5: Network architecture diagram of the application, source: own work
• Figure 6: Output of the pentest.py test script execution, source: own work
• Figure 7: Output of running docker-compose for the application configuration, source: own work
• Figure 8: Output of executing a malicious GET request, source: own work

8. List of Code Listings

• Listing 1: Penetration test configuration in the pentest.py file, source: own work
• Listing 2: Definition of test methods in the pentest.py file, source: own work
• Listing 3: Test runner implementation in the pentest.py file, source: own work
• Listing 4: Formatting and calculating test statistics in the pentest.py file, source: own work
• Listing 5: Script named entrypoint.sh launching the IDPS application, source: own work
• Listing 6: Importing the required script.py libraries, source: own work
• Listing 7: script.py plugin constructor, source: own work
• Listing 8: Definition of the script.py model training function, source: own work
• Listing 9: script.py prediction function, source: own work
• Listing 10: Sniffing HTTP and HTTPS traffic in script.py, source: own work
• Listing 11: script.py plugin export, source: own work
• Listing 12: Dockerfile configuring the application image, source: own work
• Listing 13: docker-compose.yml file creating the environment, source: own work
• Listing 14: NGINX configuration, source: own work

---

Footnotes

[^1]: Scarfone K., Mell P., „Guide to Intrusion Detection and Prevention Systems (IDPS)", source: https://nvlpubs.nist.gov/nistpubs/legacy/sp/nistspecialpublication800-94.pdf [16.05.2025] [^2]: Red Hat, „What is an intrusion detection and prevention system (IDPS)?", source: https://www.redhat.com/en/topics/security/what-is-an-IDPS [16.05.2025] [^3]: OWASP Foundation, „OWASP Top Ten", source: https://owasp.org/www-project-top-ten/ [16.05.2025] [^4]: Cisco Secure Docs, „Snort 3 Adoption", source: https://secure.cisco.com/secure-firewall/docs/snort-3-adoption [16.05.2025] [^5]: Combs R., „Snort 3.0 with ElasticSearch, LogStash, and Kibana (ELK)", source: https://blog.snort.org/2017/11/snort-30-with-elasticsearch-logstash.html [16.05.2025] [^6]: Salmon M., „Suricata and OSSEC IDPS Systems Review", source: https://www.researchgate.net/publication/361825906_Suricata_and_OSSEC_IDPS_Systems_Review_April_2022 [16.05.2025] [^7]: Persona Institut, „Persona knowledge: the history of buyer personas", source: https://www.persona-institut.de/en/die-geschichte-der-buyer-personas/ [09.06.2025] [^8]: Cooper A., „The Inmates Are Running the Asylum", Pearson Education, 2000 [^9]: Agile Alliance, https://agilemanifesto.org/iso/pl/manifesto.html [09.06.2025] [^10]: Revella A., „Buyer Persona. Poznaj i zrozum decyzje zakupowe swoich klientów", MT Biznes, 2021 [^11]: Gartner, „Cybersecurity Leadership", https://www.gartner.com/en/cybersecurity/role/chief-information-security-officer [09.06.2025] [^12]: Bloomer T., „Do IT Managers Fit in an SMB?", https://cortavo.com/cortavo-blogs/what-role-should-your-it-manager-play-in-your-smb [10.06.2025] [^13]: Swimlane, „Roles & Responsibilities of a DevSecOps Engineer", https://swimlane.com/blog/devsecops-roles-responsibilites/ [09.06.2025] [^14]: Ramirez A., „Digital transformation driven by community: Kubernetes as example", source: https://www.cncf.io/blog/2025/01/30/digital-transformation-driven-by-community-kubernetes-as-example/ [20.05.2025] [^15]: Thomas D., Hunt A., „Pragmatyczny programista. Od czeladnika do mistrza. Wydanie II", Helion, 2021 [^16]: Mitnick K., Wozniak S., Simon W.L., „Duch w sieci", Helion, 2019 [^17]: Homepage of the Polish Cyberspace Defence Forces, source: https://www.cyber.mil.pl/ncbc-dkwoc/ [27.07.2025] [^18]: Rapid7, list of APT groups, source: https://docs.rapid7.com/insightidr/apt-groups/ [27.07.2025] [^19]: Hakon Software, „Triada CIA w cyberbezpieczeństwie: Klucz do bezpieczeństwa IT", source: https://hakon.pl/triada-cia-w-cyberbezpieczenstwie-klucz-do-bezpieczenstwa-it/ [27.07.2025] [^20]: Fortinet, „What Is Defense In Depth?", source: https://www.fortinet.com/resources/cyberglossary/defense-in-depth [27.07.2025] [^21]: Fortinet, „What Is Cybersecurity Mesh?", source: https://www.fortinet.com/resources/cyberglossary/what-is-cybersecurity-mesh [27.07.2025] [^22]: Resilia, „Co to jest norma ISO 27001 i dlaczego jest tak ważna dla organizacji?", source: https://resilia.pl/blog/iso-27001-czym-jest-jakie-daje-korzysci/ [30.07.2025] [^23]: Lindemulder G., „What is open source intelligence (OSINT)?", source: https://www.ibm.com/think/topics/osint [27.07.2025] [^24]: Buckman B., „What is Weaponization in Cybersecurity? A Guide for IT Professionals", source: https://www.huntress.com/cybersecurity-education/cybersecurity-101/topic/what-is-weaponization-in-cybersecurity [27.07.2025] [^25]: Koken N., „Breaking down the cyberattack lifecycle: Delivery", source: https://www.todyl.com/blog/cyberattack-lifecycle-delivery [27.07.2025] [^26]: Medium, „Persistence || Backdoor Techniques (Beginner to Advanced) in Linux", source: https://infosecwriteups.com/persistence-backdoor-techniques-beginner-to-advanced-in-linux-dd7e109ceeb9 [27.07.2025] [^27]: OWASP Foundation, „OWASP Top Ten", source: https://owasp.org/www-project-top-ten/ [27.07.2025] [^28]: Mitre Corporation, „ATT&CK", source: https://attack.mitre.org/# [27.07.2025] [^29]: OWASP Foundation, „A03:2021 – Injection", source: https://owasp.org/Top10/A03_2021-Injection/ [27.07.2025] [^30]: Mitre Corporation, „Phishing", source: https://attack.mitre.org/techniques/T1566/ [27.07.2025] [^31]: Mitre Corporation, „Replication Through Removable Media", source: https://attack.mitre.org/techniques/T1091/ [27.07.2025] [^32]: FlowHunt, „Model Chaining", source: https://www.flowhunt.io/glossary/model-chaining/ [27.07.2025] [^33]: Mitmproxy, HTTP/HTTPS traffic monitoring library, source: https://mitmproxy.org/ [21.05.2025] [^34]: SciKit-Learn, a library containing popular implementations of machine learning algorithms, source: https://scikit-learn.org/stable/index.html [22.07.2025] [^35]: NGINX application server, source: https://nginx.org/en/ [22.07.2025] [^36]: DVWA application, source: https://github.com/digininja/DVWA?tab=readme-ov-file [22.07.2025] [^37]: Docker containerization technology, source: https://www.docker.com/ [22.07.2025] [^38]: Kajdanowicz T., Tagowski K., Rajda K., Sawczyn A., Bielak P., „Zaawansowane przetwarzanie tekstów", source: https://pwr-ai.github.io/przetwarzanie-danych-i-odkrywanie-wiedzy/laboratoria/lab6-uczenie-maszynowe-2.html [27.07.2025] [^39]: Ulah A.M., Jamal A.A., Tuhin R.A., Akhter S., „Detecting distributed denial of service attacks using logistic regression and SVM methods", source: https://arxiv.org/pdf/2411.14512 [27.07.2025] [^40]: Disha A.R., Waheed S., „Performance analysis of machine learning models for intrusion detection system using Gini Impurity-based Weighted Random Forest (GIWRF) feature selection technique", source: https://cybersecurity.springeropen.com/articles/10.1186/s42400-021-00103-8 [27.07.2025] [^41]: Chalichalamala S., Govidan N., Kasarapu R., „Logistic Regression Ensemble Classifier for Intrusion Detection System in Internet of Things", source: https://www.mdpi.com/1424-8220/23/23/9583 [27.07.2025] [^42]: Broniewski P., „Reverse proxy. Co to jest i jak działa reverse proxy?", source: https://webporadnik.pl/reverse-proxy-co-to-jest-i-jak-dziala-reverse-proxy [21.05.2025] [^43]: Sandeep D., „Kubernetes best practices: How and why to build small container images", source: https://cloud.google.com/blog/products/containers-kubernetes/kubernetes-best-practices-how-and-why-to-build-small-container-images [21.05.2025] [^44]: BrowserStack, „How to write Test Cases in Software Testing?", source: https://www.browserstack.com/guide/how-to-write-test-cases [27.07.2025] [^45]: Python requests library, source: https://pypi.org/project/requests/ [23.07.2025] [^46]: Myrianthous G., „What Does "If __name__ == '__main__'" Do in Python?", source: https://builtin.com/articles/name-python [23.07.2025] [^47]: Vajjala S., Majumder B., Gupta A., Surana H., „Przetwarzanie języka naturalnego w praktyce. Przewodnik po budowie rzeczywistych systemów NLP", Helion, 2023 [^48]: Official Pandas library documentation, „DataFrame", source: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html [27.07.2025] [^49]: Official MITMProxy library documentation, „Addons", source: https://docs.mitmproxy.org/stable/addons/overview/ [27.07.2025] [^50]: Chelladhurai J.S., Singh V., Raj P., „Docker dla praktyków. Wydanie II", Helion, 2018 [^51]: Docker documentation, „Dockerfile reference", https://docs.docker.com/reference/dockerfile/ [27.07.2025] [^52]: Buchanan I., „Infrastruktura jako kod", source: https://www.atlassian.com/pl/microservices/cloud-computing/infrastructure-as-code [27.07.2025] [^53]: Official NGINX documentation, „NGINX Reverse Proxy", source: https://docs.nginx.com/nginx/admin-guide/web-server/reverse-proxy/ [30.07.2025] [^54]: Docker Desktop container management tool, source: https://www.docker.com/products/docker-desktop/ [27.05.2025] [^55]: Microsoft, „How to install Linux on Windows with WSL", source: https://learn.microsoft.com/en-us/windows/wsl/install [30.07.2025] [^56]: Buła A., „Do you really need a manual tester and why the answer is "yes"?", source: https://www.rst.software/blog/do-you-really-need-a-manual-tester-and-why-the-answer-is-yes [27.07.2025] [^57]: Cloudflare, „What is a supply chain attack?", source: https://www.cloudflare.com/pl-pl/learning/security/what-is-a-supply-chain-attack/ [21.08.2025] [^58]: Zhao C., Si S., Tu T., Shi Y., Qin S., „Deep-Learning Based Injection Attacks Detection Method for HTTP", source: https://www.mdpi.com/2227-7390/10/16/2914 [21.08.2025] [^59]: nFlo, „Co to jest Honeypot?", source: https://nflo.pl/slownik/honeypot/ [19.08.2025] [^60]: Prakash A., „Real-Time Continuous Monitoring with a SIEM Using the ELK Stack", source: https://arunprakashpj.medium.com/real-time-continuous-monitoring-with-a-siem-using-the-elk-stack-a536df7e77c0 [21.08.2025] [^61]: Schroer S. L., Pajola L., Castagnaro A., Apruzzese G., „Exploiting AI for Attacks: On the Interplay between Adversarial AI and Offensive AI", source: https://arxiv.org/html/2506.12519v1 [20.08.2025] [^62]: Kolosnjaji B., Demontis A., Biggio B., Maiorca D., Giacinto G., Eckert C., Roli F., „Adversarial Malware Binaries: Evading Deep Learning for Malware Detection in Executables", source: https://arxiv.org/abs/1803.04173 [20.08.2025] [^63]: Woolley S., „Manufacturing Consensus: Understanding Propaganda in the Era of Automation and Anonymity", Yale University Press, 2023 [^64]: Crowdstrike, „Data Poisoning: The Exploitation of Generative AI", https://www.crowdstrike.com/en-us/cybersecurity-101/cyberattacks/data-poisoning [20.08.2025] [^65]: Legaspi C., „The Collaboration Paradox: When Security Tools Become Your Biggest Vulnerability", source: https://www.avepoint.com/shifthappens/blog/the-collaboration-paradox-when-security-tools-become-your-biggest-vulnerability [21.08.2025] [^66]: Buczak A. L., Guven E., „A Survey of Data Mining and Machine Learning Methods for Cyber Security Intrusion Detection", source: https://ieeexplore.ieee.org/document/7307098 [22.08.2025] [^67]: Sommer R., Paxson V., „Outside the Closed World: On Using Machine Learning for Network Intrusion Detection", source: https://www.researchgate.net/publication/220713766_Outside_the_Closed_World_On_Using_Machine_Learning_for_Network_Intrusion_Detection [22.08.2025] [^68]: Hyrum S. A., „Evading Machine Learning Malware Detection", source: https://www.semanticscholar.org/paper/Evading-Machine-Learning-Malware-Detection-Anderson/1b570ed4b58908444465823880cb88fbb812b4fc [22.08.2025] [^69]: Iqbal H. S., Kayes A. S. M., Badsha S., Alqahtani H., Watters P., Ng A., „Cybersecurity data science: an overview from machine learning perspective", source: https://journalofbigdata.springeropen.com/articles/10.1186/s40537-020-00318-5 [22.08.2025] [^70]: Mohiuddin A., Abdun M., Jiankun H., „A Survey of Network Anomaly Detection Techniques", source: https://www.researchgate.net/publication/286848340_A_Survey_of_Network_Anomaly_Detection_Techniques [22.08.2025] [^71]: Sikos F. L., „AI in Cybersecurity", Springer, 2019