{"id":6558,"date":"2025-05-31T12:23:43","date_gmt":"2025-05-31T12:23:43","guid":{"rendered":"http:\/\/www.examcollection.com\/blog\/?p=6558"},"modified":"2026-01-08T05:54:19","modified_gmt":"2026-01-08T05:54:19","slug":"crafting-an-ssh-botnet-using-python-programming","status":"publish","type":"post","link":"https:\/\/www.examcollection.com\/blog\/crafting-an-ssh-botnet-using-python-programming\/","title":{"rendered":"Crafting an SSH Botnet Using Python Programming"},"content":{"rendered":"

An SSH botnet is a collection of compromised devices that are remotely accessed and controlled through the Secure Shell protocol. These botnets leverage SSH to establish secure, encrypted connections between an attacker\u2019s central controller and a network of infected machines. Typically, the devices involved in the botnet are servers, IoT devices, or any system running an SSH service that has been compromised, often through weak or reused credentials.<\/span><\/p>\n

SSH botnets have become increasingly popular among attackers because SSH provides encrypted communication, making it difficult to detect malicious activity by traditional network monitoring tools. Through these botnets, attackers can coordinate large-scale operations such as distributed denial-of-service attacks, password cracking attempts, data exfiltration, or even cryptocurrency mining without the victims\u2019 knowledge.<\/span><\/p>\n

From a cybersecurity standpoint, understanding how SSH botnets operate and are constructed is critical. It helps security professionals recognize attack patterns, develop countermeasures, and enhance defenses for SSH-enabled services. Additionally, learning how to program these botnets using a versatile language like Python not only sharpens one\u2019s coding skills but also deepens knowledge about network protocols, concurrency, and system security.<\/span><\/p>\n

Why Python for Botnet Development?<\/b><\/h2>\n

Python is a preferred language among hackers and cybersecurity researchers for many reasons. First, its syntax is clean and easy to read, which accelerates the development process. This simplicity allows even beginners to quickly prototype tools that interact with complex protocols such as SSH.<\/span><\/p>\n

Secondly, Python\u2019s extensive standard library and third-party modules provide powerful tools for networking, threading, and cryptography, all essential components when building a botnet. For SSH specifically, libraries like Paramiko abstract much of the complexity involved in establishing and managing secure connections, enabling developers to focus on botnet logic rather than low-level protocol details.<\/span><\/p>\n

Moreover, Python is cross-platform, meaning the same code can run on Windows, Linux, or macOS with minimal modifications. This flexibility is useful when developing tools intended to control a diverse range of devices that may be part of a botnet.<\/span><\/p>\n

Because of its widespread use in security research and automation, many penetration testers and ethical hackers choose Python for building custom tools that simulate or defend against real-world attacks, including botnets. Thus, Python serves both offensive and defensive purposes within cybersecurity.<\/span><\/p>\n

Setting Up the Environment for SSH Botnet Development<\/b><\/h2>\n

Before diving into botnet programming, setting up an appropriate development environment is essential. This includes installing Python, selecting the right libraries, and preparing target machines for testing.<\/span><\/p>\n

Begin by installing the latest version of Python 3.x from the official website or using a package manager,, depending on your operating system. Using Python 3 ensures access to the latest language features and compatibility with modern libraries.<\/span><\/p>\n

Next, install the Paramiko library, which is the cornerstone for SSH communication in Python. Paramiko handles key exchange, encryption, and session management, providing a robust interface for scripting SSH interactions. It can be installed easily using pip, Python\u2019s package installer, with the command pip install paramiko.<\/span><\/p>\n

Along with Paramiko, other libraries such as threading or asyncio can be useful for managing multiple SSH connections concurrently. These libraries allow the botnet controller to operate efficiently when communicating with many client bots.<\/span><\/p>\n

Setting up test environments is equally important. For ethical and legal reasons, experiments should be conducted on machines you own or have explicit permission to test on. Creating virtual machines or using cloud servers configured with SSH services provides safe platforms to test the botnet scripts without risking harm to third parties.<\/span><\/p>\n

Understanding SSH basics, including how key pairs work, password authentication, and common server configurations, lays the groundwork for effective botnet development. This knowledge enables you to tailor your Python scripts to handle different authentication methods and avoid common pitfalls during connection attempts.<\/span><\/p>\n

Key Concepts in Python for Botnet Programming<\/b><\/h2>\n

Developing a functional SSH botnet requires a solid grasp of several Python programming concepts, especially those related to networking, concurrency, and error handling.<\/span><\/p>\n

Networking fundamentals are crucial because SSH is a network protocol. Python\u2019s socket module and higher-level libraries like Paramiko facilitate opening network connections, sending commands, and receiving data. Knowing how to manipulate these connections programmatically allows the botnet to communicate seamlessly with compromised hosts.<\/span><\/p>\n

Concurrency is another vital topic. A botnet controller often needs to manage dozens or hundreds of SSH sessions simultaneously. Using Python\u2019s threading or asynchronous programming capabilities enables your script to handle multiple connections without blocking or slowing down. Threads run in parallel, allowing the botnet controller to send commands to many bots at once and gather their responses efficiently.<\/span><\/p>\n

Exception handling ensures that the botnet remains stable even when unexpected issues occur. Network errors, authentication failures, or server timeouts are common when working with remote connections. Writing Python code that gracefully catches these exceptions and retries or skips problematic hosts helps maintain botnet resilience and reliability.<\/span><\/p>\n

In addition to these, working knowledge of Python\u2019s data structures, such as lists, dictionaries, and queues, is necessary. These structures help organize information about each connected bot, including IP addresses, login credentials, and connection statuses, which are fundamental for effective botnet management.<\/span><\/p>\n

Ethical Considerations and Legal Implications<\/b><\/h2>\n

While creating and understanding SSH botnets can be intellectually rewarding and educational, it is critical to emphasize the ethical and legal boundaries surrounding their use.<\/span><\/p>\n

Unauthorized access to computers or networks is illegal in most countries and can lead to severe penalties, including fines and imprisonment. Deploying an SSH botnet on machines without explicit permission constitutes a criminal act. Therefore, it is essential to use such knowledge only in controlled environments, such as lab setups or with consent during penetration testing engagements.<\/span><\/p>\n

Ethical hacking involves using offensive skills to help organizations improve their security by identifying vulnerabilities before malicious actors can exploit them. Constructing SSH botnets for learning purposes must always respect privacy, property rights, and applicable laws.<\/span><\/p>\n

Beyond legality, ethical considerations include understanding the potential damage that botnets can cause, such as service disruptions, data loss, or breaches of confidentiality. Responsible cybersecurity professionals advocate for building secure systems and educating others about the risks and defenses related to botnets.<\/span><\/p>\n

In summary, mastering SSH botnet programming in Python should be viewed as a means to improve cybersecurity knowledge and defense capabilities, not to perpetrate harm. Always prioritize ethical guidelines and use this knowledge constructively.<\/span><\/p>\n

This introduction covered the basic concepts behind SSH botnets, the advantages of using Python for developing such tools, and the foundational skills needed to start programming. Setting up the environment, understanding key programming concepts, and respecting ethical boundaries provide a strong platform for further exploration.<\/span><\/p>\n

In the next part of this series, the focus will shift toward building the SSH connection module using Python. You will learn how to implement secure SSH sessions, manage authentication, and execute commands remotely using Paramiko. This hands-on approach will turn theoretical understanding into practical skills for crafting and controlling an SSH botnet.<\/span><\/p>\n

Building the SSH Connection Module with Python<\/b><\/h1>\n

Implementing SSH Connections Using Paramiko<\/b><\/h2>\n

At the core of any SSH botnet lies the ability to establish secure, authenticated connections to target devices. Python\u2019s Paramiko library is designed specifically for handling SSHv2 protocol connections and is the ideal tool for this purpose. Paramiko abstracts the complexities of the SSH protocol, providing an intuitive interface to open sessions, authenticate, and execute commands remotely.<\/span><\/p>\n

To get started, you import the Paramiko module and create an SSH client instance. This client manages the connection lifecycle, including key exchange and encryption setup. The connection process involves specifying the target IP address, port (usually 22), and providing valid credentials or SSH keys for authentication.<\/span><\/p>\n

For botnet development, automating these connections to multiple hosts is essential. Paramiko supports both password and key-based authentication, giving flexibility to handle a wide variety of targets. It is important to handle connection errors and timeouts gracefully since some hosts might be unreachable or protected by firewalls.<\/span><\/p>\n

The typical workflow begins by calling connect() on the SSH client with the necessary parameters. If the connection succeeds, you can open a channel to execute shell commands or transfer files. Paramiko provides methods like exec_command, which run commands on the remote host and return the command output and error streams.<\/span><\/p>\n

Handling Authentication Methods<\/b><\/h2>\n

One of the challenges in creating an SSH botnet is dealing with diverse authentication methods. Most SSH servers support either password authentication, public key authentication, or both. Your Python botnet should be capable of adapting to these variations.<\/span><\/p>\n

Password-based authentication requires a list of possible usernames and passwords to attempt connections. In a botnet context, this often involves automated brute-force or dictionary attacks, trying combinations unta il a successful login. Paramiko\u2019s connect() method allows passing a password directly, making it simple to script these attempts.<\/span><\/p>\n

Key-based authentication uses private-public key pairs for a more secure login process. When using Paramiko, you can specify a private key file to authenticate. This method is preferred on well-secured systems and requires the botnet to have access to valid private keys to gain access.<\/span><\/p>\n

To maximize success rates, the botnet script can implement a fallback mechanism: try key-based authentication first, and if it fails, revert to password-based attempts. Additionally, implementing a timeout for connection attempts prevents the script from hanging on unreachable hosts, allowing it to move on efficiently.<\/span><\/p>\n

Managing SSH Sessions and Command Execution<\/b><\/h2>\n

Once the SSH connection is established, maintaining an active session is critical for ongoing control. Paramiko\u2019s exec_command() function allows sending shell commands that execute remotely, with access to standard input, output, and error streams.<\/span><\/p>\n

For botnet operations, the controller needs to send commands that can perform various actions on the infected host, such as gathering system information, launching attacks, or downloading and executing additional payloads.<\/span><\/p>\n

Capturing the command output is important to verify the success of issued commands and to gather intelligence from compromised hosts. Python scripts can read the output streams line by line or all at once and then store or process this data.<\/span><\/p>\n

Because network connections can be unstable, the botnet should monitor session health and reconnect if necessary. Paramiko allows checking the status of SSH channels and reinitializing them if the connection drops.<\/span><\/p>\n

In addition to command execution, file transfers can be performed using Paramiko\u2019s SFTP client interface. This enables uploading scripts or tools to infected machines, increasing the botnet\u2019s versatility.<\/span><\/p>\n

Error Handling and Connection Stability<\/b><\/h2>\n

Network environments are unpredictable, and SSH connections are often subject to failures such as timeouts, refused connections, or authentication rejections. A robust Python botnet must anticipate and handle these issues without crashing.<\/span><\/p>\n

Using try-except blocks around connection attempts allows the script to catch exceptions like socket errors. Timeout, paramiko.AuthenticationException, or paramiko.SSHException. Handling these exceptions with appropriate logic, such as retrying connections or skipping hosts, helps maintain smooth operation.<\/span><\/p>\n

Implementing connection limits and delays between attempts prevents overloading network resources or triggering intrusion detection systems. Introducing randomized delays or exponential backoff strategies can reduce the risk of detection and blacklisting.<\/span><\/p>\n

Logging errors and connection outcomes provides valuable insights for botnet management. A log file or database can track which hosts are successfully compromised, which fail due to network errors, and which are rejected authentication failures, guiding future attack strategies.<\/span><\/p>\n

Testing the SSH Module in a Controlled Environment<\/b><\/h2>\n

Before integrating the SSH connection module into a full botnet framework, thorough testing in a safe, controlled environment is crucial. This ensures the module works as expected and prevents accidental damage or illegal activity.<\/span><\/p>\n

Setting up virtual machines with SSH servers configured to accept test credentials allows experimentation with connection parameters, authentication methods, and command execution. Testing edge cases like invalid credentials, unreachable hosts, or slow networks helps harden the script against real-world conditions.<\/span><\/p>\n

Simulating multiple simultaneous connections helps evaluate the module\u2019s concurrency capabilities and reveals potential bottlenecks or resource exhaustion issues. Performance profiling during these tests guides optimization efforts to make the botnet scalable.<\/span><\/p>\n

In addition to manual testing, automated unit tests can be written to validate critical functions of the SSH module. This approach supports long-term maintenance and safe modification of the codebase.<\/span><\/p>\n

Building the SSH connection module with Python and Paramiko is the foundational step toward crafting an SSH botnet. This part explored establishing secure connections, managing authentication methods, executing remote commands, and handling errors gracefully.<\/span><\/p>\n

A well-designed SSH module enables reliable communication with compromised hosts and lays the groundwork for more advanced botnet features such as concurrency and command distribution.<\/span><\/p>\n

The next installment in this series will focus on designing the botnet controller and client structure. You will learn how to manage multiple SSH bots simultaneously, distribute commands efficiently, and monitor botnet health, all using Python\u2019s powerful threading and networking capabilities.<\/span><\/p>\n

Designing the Botnet Controller and Client Architecture<\/b><\/h1>\n

Understanding the Client-Server Model in Botnets<\/b><\/h2>\n

An SSH botnet operates on a client-server architecture where the attacker\u2019s machine acts as the command and control (C&C) server, and the infected devices are the clients (or bots). The C&C server sends commands to the clients, which execute them and return the results.<\/span><\/p>\n

Designing this architecture requires careful planning to ensure efficient communication, scalability, and stealth. The server must be capable of handling multiple SSH connections simultaneously, distributing commands, and collecting responses. The clients should be lightweight and responsive, able to execute commands promptly and maintain connection stability.<\/span><\/p>\n

Python\u2019s flexibility allows you to implement both client and server components in one script or separate them for modularity. Understanding the responsibilities and interactions between the controller and the bots is key to building an effective botnet framework.<\/span><\/p>\n

Structuring the Botnet Controller<\/b><\/h2>\n

The botnet controller is the central hub that manages all compromised hosts. Its primary functions include scanning for vulnerable machines, establishing SSH connections, authenticating successfully, sending commands, and processing feedback.<\/span><\/p>\n

To manage multiple SSH sessions concurrently, the controller utilizes Python\u2019s threading or asynchronous programming libraries. Threads allow simultaneous control of each bot, so commands can be sent to many bots without waiting for individual responses.<\/span><\/p>\n

The controller script maintains a data structure, such as a dictionary or list, to keep track of each bot\u2019s status, including IP address, username, password or key used, connection state, and command history. This organization enables targeted commands or group broadcasts.<\/span><\/p>\n

A command interface, often a simple terminal menu or input prompt, allows the attacker to issue instructions to one or many bots. The controller forwards commands via the SSH connections and collects outputs, which it displays or logs for analysis.<\/span><\/p>\n

Implementing the Bot Client<\/b><\/h2>\n

Each bot is essentially an SSH server with a backdoor connection to the controller. However, in this Python botnet, the bots are remote SSH-enabled devices that accept incoming SSH sessions from the controller. The bot script primarily listens for incoming commands over the SSH session, executes them on the host machine, and sends back the results.<\/span><\/p>\n

Since the bot itself does not initiate connections but accepts commands via the SSH session, the client script must be designed to handle command execution securely and efficiently. It should parse commands received over SSH, execute them on the local shell or via Python subprocess calls, capture the output, and send it back to the controller.<\/span><\/p>\n

Bots must handle errors gracefully, such as invalid commands or resource limitations, without crashing. To avoid detection, bots should minimize resource consumption and avoid suspicious activity patterns.<\/span><\/p>\n

Managing Concurrency and Command Distribution<\/b><\/h2>\n

Handling multiple bots concurrently is a challenge requiring careful use of Python\u2019s concurrency mechanisms. The threading module provides a straightforward way to run multiple SSH sessions in parallel, but it is limited by Python\u2019s Global Interpreter Lock (GIL). For IO-bound operations like network communication, threading is generally sufficient.<\/span><\/p>\n

Alternatively, asynchronous programming with asyncio can manage thousands of connections efficiently by using event loops and non-blocking IO. However, asyncio\u2019s complexity may be more than necessary for a simple botnet prototype.<\/span><\/p>\n

Within the controller, each bot connection runs in its thread, responsible for maintaining the SSH session, sending commands, and receiving responses. The main thread manages user input and dispatches commands to individual bot threads or broadcasts to all.<\/span><\/p>\n

A queue data structure can help manage commands waiting to be sent. Commands entered by the operator are placed into the queue and picked up by the bot threads, ensuring orderly command execution and avoiding message collisions.<\/span><\/p>\n

Monitoring and Logging Botnet Activity<\/b><\/h2>\n

Visibility into the botnet\u2019s state is critical for effective control. The controller maintains logs of connection attempts, successful authentications, command executions, and responses. This information helps track which hosts are online, which commands have been issued, and any errors encountered.<\/span><\/p>\n

Logging also aids in debugging and tuning the botnet. For example, if a particular command consistently fails on many bots, it may indicate compatibility issues or permission restrictions.<\/span><\/p>\n

Implementing status reports from bots can improve monitoring. Bots can periodically send system information such as CPU usage, uptime, or network status, allowing the controller to assess bot health and prioritize commands.<\/span><\/p>\n

Logs should be stored securely and protected from unauthorized access, as they contain sensitive information about compromised devices and attack methods.<\/span><\/p>\n

Ensuring Security and Stealth<\/b><\/h2>\n

While the goal of a botnet is to control many machines, stealth is essential to avoid detection and takedown. From a programming perspective, stealth can be enhanced by minimizing resource usage, encrypting communication, and avoiding suspicious patterns.<\/span><\/p>\n

Paramiko\u2019s SSH encryption already protects data in transit, but further obfuscation techniques can be applied at the application layer, such as encoding commands or randomizing command intervals.<\/span><\/p>\n

Bots should avoid launching resource-intensive tasks simultaneously, as this might trigger alerts on the victim systems or network monitoring tools. Implementing randomized delays and staggered command execution helps distribute load and reduce visibility.<\/span><\/p>\n

Securing the controller itself is also important. Limiting access via firewalls, using VPNs or proxies, and protecting authentication credentials prevent compromise of the botnet infrastructure.<\/span><\/p>\n

This part covered the design of the botnet controller and client architecture, focusing on client-server interactions, concurrency management, logging, and stealth considerations. Understanding these aspects allows you to build a scalable and resilient SSH botnet framework.<\/span><\/p>\n

The final part of this series will delve into advanced botnet features such as dynamic command updates, persistence mechanisms on bots, and techniques to evade detection. You will also see how to integrate all components into a cohesive system and test the complete botnet in a controlled environment.<\/span><\/p>\n

Advanced Features and Deployment of the SSH Botnet<\/b><\/h1>\n

Implementing Dynamic Command Updates<\/b><\/h2>\n

One of the hallmarks of a sophisticated SSH botnet is its ability to receive and execute updated commands dynamically without restarting the bots. This feature allows the botnet operator to adapt tactics, deploy new payloads, or modify behavior in real time.<\/span><\/p>\n

To achieve dynamic command updates, the controller periodically sends command packets or scripts to the bots over the active SSH sessions. The bots run a listening loop that checks for incoming commands continuously or at set intervals. Upon receiving new instructions, the bot parses and executes them, then reports results back to the controller.<\/span><\/p>\n

This approach requires designing a communication protocol between the controller and the bots, ensuring commands are correctly formatted and responses are reliably transmitted. Using structured data formats like JSON or custom delimiters can help maintain command integrity.<\/span><\/p>\n

In Python, asynchronous loops or threaded listeners in the bot script facilitate constant monitoring for new commands. The controller, in turn, manages a command queue or scheduler to send updates efficiently across all connected bots.<\/span><\/p>\n

Persistence Mechanisms on Infected Hosts<\/b><\/h2>\n

To maintain control over compromised devices, botnets often implement persistence mechanisms that ensure the bot client restarts automatically after reboots or crashes. Persistence increases the botnet\u2019s longevity and reduces the need for reinfection.<\/span><\/p>\n

Common persistence methods include creating startup scripts, modifying cron jobs on Linux systems, or adding entries to system service managers like systemd. The bot client, once installed, can copy itself to hidden directories and register for automatic execution.<\/span><\/p>\n

In Python, persistence can be achieved by running shell commands remotely via SSH that add the bot script to startup sequences. The botnet controller can send these commands to each bot after initial compromise to guarantee long-term access.<\/span><\/p>\n

Additionally, the bot client can include self-monitoring features that detect termination and relaunch the script automatically. This watchdog functionality makes removal more difficult and ensures continuous presence.<\/span><\/p>\n

Techniques for Evasion and Anti-Detection<\/b><\/h2>\n

Avoiding detection by security tools is critical for botnet survival. Developers implement various evasion techniques to reduce the botnet\u2019s footprint and bypass antivirus, intrusion detection systems, and network monitoring.<\/span><\/p>\n

One common technique is encrypting or obfuscating command payloads. Although SSH already encrypts communication, adding a layer of obfuscation on the application data makes signature-based detection harder. Simple XOR encoding or base64 with random padding are lightweight options.<\/span><\/p>\n

Randomizing connection intervals and command execution times helps evade behavior-based detection systems that flag repetitive or bursty network activity. Introducing jitter and delays between bot actions creates less predictable patterns.<\/span><\/p>\n

Another approach is limiting the scope of commands and resource usage. Bots should avoid running high CPU or memory-intensive tasks simultaneously, which could raise alarms on the host or network.<\/span><\/p>\n

Implementing user agent spoofing and mimicking legitimate SSH clients also helps the botnet blend into normal traffic, making it less conspicuous.<\/span><\/p>\n

Integrating All Components into a Cohesive System<\/b><\/h2>\n

After building the SSH connection module, designing the controller and clients, and implementing advanced features, integrating these components into a cohesive botnet system is essential.<\/span><\/p>\n

The integration process involves unifying the codebase, ensuring compatibility between modules, and establishing reliable communication channels. The controller must handle new bots joining dynamically, manage disconnections, and distribute commands seamlessly.<\/span><\/p>\n

Testing integration requires simulating a network of infected hosts and verifying that commands propagate correctly and bots respond as expected. Automated scripts can create mock bots or virtual machines to facilitate comprehensive tests.<\/span><\/p>\n

Robust error handling and recovery mechanisms are implemented to maintain botnet stability. This includes reconnecting dropped SSH sessions, retrying failed commands, and updating configurations on the fly.<\/span><\/p>\n

Deploying the Botnet in a Controlled Environment<\/b><\/h2>\n

Ethical considerations are paramount when working with botnet technology. Deployment should be restricted to controlled lab environments to avoid illegal activity.<\/span><\/p>\n

Setting up virtualized test beds with SSH servers configured on various operating systems allows experimentation with botnet operations without harming real networks. These environments can simulate different network conditions, firewall settings, and authentication methods.<\/span><\/p>\n

Deployment scripts automate the distribution of the bot client to target machines in the lab and initiate the controller. Monitoring tools observe network traffic, resource usage, and botnet behavior for analysis.<\/span><\/p>\n

Such controlled deployment enables refining the botnet design, identifying weaknesses, and improving stealth features safely.<\/span><\/p>\n

Ethical Use and Defense Applications<\/b><\/h2>\n

Although SSH botnets are often associated with malicious activity, the underlying technology can be repurposed for legitimate security research and defense.<\/span><\/p>\n

Penetration testers can use similar frameworks to automate assessments of SSH service vulnerabilities across enterprise networks, identifying weak credentials or misconfigurations.<\/span><\/p>\n

Security researchers develop honeypots that mimic SSH servers and use botnet-like control systems to study attacker behaviors and malware propagation patterns.<\/span><\/p>\n

Understanding botnet architecture also aids in developing better detection and mitigation tools, enhancing cybersecurity defenses.<\/span><\/p>\n

Final Thoughts<\/b><\/h2>\n

This concluding part explored advanced SSH botnet capabilities, including dynamic command updates, persistence, evasion techniques, integration, and controlled deployment. Together with the earlier parts, this series provides a comprehensive guide to building an SSH botnet framework using Python.<\/span><\/p>\n

While this knowledge is valuable for cybersecurity professionals, it carries serious ethical and legal responsibilities. Unauthorized use of botnets causes harm and violates laws worldwide.<\/span><\/p>\n

Studying and simulating botnet techniques responsibly contributes to improving network security and defending against real-world threats.<\/span><\/p>\n

 <\/p>\n","protected":false},"excerpt":{"rendered":"

An SSH botnet is a collection of compromised devices that are remotely accessed and controlled through the Secure Shell protocol. These botnets leverage SSH to establish secure, encrypted connections between an attacker\u2019s central controller and a network of infected machines. Typically, the devices involved in the botnet are servers, IoT devices, or any system running\u2026 Read More »<\/a><\/span><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2374,2378],"tags":[1956,1957],"class_list":["post-6558","post","type-post","status-publish","format-standard","hentry","category-all-technology","category-programming","tag-python-programming","tag-ssh-botnet"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t