pftp 2.0.0__py3-none-any.whl

pftp/config.py

@@ -0,0 +1,152 @@
+"""Configuration management for PFTP"""
+
+from dataclasses import dataclass, asdict, field
+from pathlib import Path
+from typing import Optional, Dict
+import yaml
+
+from .constants import (
+    DEFAULT_HOST,
+    DEFAULT_PORT,
+    DEFAULT_DATA_DIR,
+    DEFAULT_DOCKER_IMAGE,
+    CONTAINER_NAME,
+    FTP_PORT,
+    FTP_PASSIVE_START,
+    FTP_PASSIVE_END,
+    SMB_PORT,
+    SMB_NETBIOS_PORT,
+)
+
+
+@dataclass
+class Config:
+    """PFTP configuration v2.0 with multi-protocol support"""
+
+    # Server settings
+    host: str = DEFAULT_HOST
+    port: int = DEFAULT_PORT
+
+    # v2.0 Protocol configurations
+    protocols: Dict = field(default_factory=lambda: {
+        'http': {'enabled': True, 'port': DEFAULT_PORT},
+        'ftp': {'enabled': True, 'port': FTP_PORT, 'passive_start': FTP_PASSIVE_START, 'passive_end': FTP_PASSIVE_END},
+        'smb': {'enabled': True, 'port': SMB_PORT, 'netbios_port': SMB_NETBIOS_PORT}
+    })
+
+    # Authentication
+    auth_enabled: bool = False
+    auth_username: Optional[str] = None
+    auth_password_hash: Optional[str] = None
+
+    # Docker and directories
+    docker_image: str = DEFAULT_DOCKER_IMAGE
+    data_dir: Path = DEFAULT_DATA_DIR
+    tools_dir: Optional[Path] = None
+    uploads_dir: Optional[Path] = None
+    ignore_dirs: str = ".git,__pycache__,.vscode"
+    debug: bool = False
+
+    # Docker restart policy: 'no', 'always', 'unless-stopped', 'on-failure'
+    restart_policy: str = "unless-stopped"
+
+    def __post_init__(self):
+        """Initialize paths"""
+        self.data_dir = Path(self.data_dir).expanduser()
+        if not self.tools_dir:
+            self.tools_dir = self.data_dir / "tools"
+        if not self.uploads_dir:
+            self.uploads_dir = self.data_dir / "uploads"
+
+    @classmethod
+    def load(cls, config_path: Path) -> 'Config':
+        """Load configuration from YAML file with v1.0 to v2.0 migration"""
+        if not config_path.exists():
+            return cls()
+
+        with open(config_path, 'r') as f:
+            data = yaml.safe_load(f) or {}
+
+        version = data.get('version', '1.0')
+
+        # v1.0 config - migrate to v2.0
+        if version == '1.0':
+            http_port = data.get('server', {}).get('port', DEFAULT_PORT)
+            config = cls(
+                host=data.get('server', {}).get('host', DEFAULT_HOST),
+                port=http_port,
+                docker_image=data.get('docker', {}).get('image', DEFAULT_DOCKER_IMAGE),
+                data_dir=Path(data.get('directories', {}).get('data_dir', DEFAULT_DATA_DIR)),
+                ignore_dirs=data.get('advanced', {}).get('ignore_dirs', ".git,__pycache__,.vscode"),
+                debug=data.get('advanced', {}).get('debug', False)
+            )
+            # Update HTTP port to match legacy config
+            config.protocols['http']['port'] = http_port
+            # Auto-save as v2.0
+            config.save(config_path)
+            return config
+
+        # v2.0 config
+        tools_dir_str = data.get('directories', {}).get('tools_dir')
+        uploads_dir_str = data.get('directories', {}).get('uploads_dir')
+
+        return cls(
+            host=data.get('server', {}).get('host', DEFAULT_HOST),
+            port=data.get('server', {}).get('port', DEFAULT_PORT),
+            protocols=data.get('protocols', cls().protocols),
+            auth_enabled=data.get('authentication', {}).get('enabled', False),
+            auth_username=data.get('authentication', {}).get('username'),
+            auth_password_hash=data.get('authentication', {}).get('password_hash'),
+            docker_image=data.get('docker', {}).get('image', DEFAULT_DOCKER_IMAGE),
+            data_dir=Path(data.get('directories', {}).get('data_dir', DEFAULT_DATA_DIR)),
+            tools_dir=Path(tools_dir_str) if tools_dir_str else None,
+            uploads_dir=Path(uploads_dir_str) if uploads_dir_str else None,
+            ignore_dirs=data.get('advanced', {}).get('ignore_dirs', ".git,__pycache__,.vscode"),
+            debug=data.get('advanced', {}).get('debug', False),
+            restart_policy=data.get('docker', {}).get('restart_policy', 'unless-stopped')
+        )
+
+    def save(self, config_path: Path):
+        """Save configuration to YAML file in v2.0 format"""
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        data = {
+            'version': '2.0',
+            'server': {
+                'host': self.host,
+                'port': self.port
+            },
+            'protocols': self.protocols,
+            'authentication': {
+                'enabled': self.auth_enabled,
+                'username': self.auth_username,
+                'password_hash': self.auth_password_hash
+            },
+            'docker': {
+                'image': self.docker_image,
+                'container_name': CONTAINER_NAME,
+                'restart_policy': self.restart_policy
+            },
+            'directories': {
+                'data_dir': str(self.data_dir),
+                'tools_dir': str(self.tools_dir),
+                'uploads_dir': str(self.uploads_dir),
+                'permissions': {
+                    'tools': 'ro',
+                    'uploads': 'rw'
+                }
+            },
+            'advanced': {
+                'ignore_dirs': self.ignore_dirs,
+                'debug': self.debug
+            }
+        }
+
+        with open(config_path, 'w') as f:
+            yaml.dump(data, f, default_flow_style=False)
+
+    def merge_cli_args(self, **kwargs):
+        """Merge CLI arguments into configuration"""
+        for key, value in kwargs.items():
+            if value is not None and hasattr(self, key):
+                setattr(self, key, value)

pftp/constants.py

@@ -0,0 +1,32 @@
+"""Constants and default values for PFTP"""
+
+from pathlib import Path
+
+# Default configuration values
+DEFAULT_PORT = 1234
+DEFAULT_HOST = "0.0.0.0"
+DEFAULT_DATA_DIR = Path.home() / ".pftp"
+DEFAULT_DOCKER_IMAGE = "ahmadalawneh3/pftp:latest"
+
+# Protocol ports
+FTP_PORT = 21
+FTP_PASSIVE_START = 60000
+FTP_PASSIVE_END = 60100
+SMB_PORT = 445
+SMB_NETBIOS_PORT = 139
+
+# Container and config settings
+CONTAINER_NAME = "pftp"
+CONFIG_FILE = "config.yaml"
+CONFIG_DIR = "config"
+TOOLS_DIR = "tools"
+UPLOADS_DIR = "uploads"
+
+# Docker environment variables
+ENV_PROTOCOL = "PROTOCOL"
+ENV_HOST = "HOST"
+ENV_PORT = "PORT"
+ENV_DEBUG = "DEBUG"
+ENV_UPLOAD_FOLDER = "UPLOAD_FOLDER"
+ENV_TOOLS_FOLDER = "TOOLS_FOLDER"
+ENV_IGNORE_DIRS = "IGNORE_DIRS"

pftp/docker_manager.py

@@ -0,0 +1,295 @@
+"""Docker container management for PFTP"""
+
+import click
+import docker
+from docker.errors import DockerException, ImageNotFound, NotFound
+from typing import Dict, Optional
+
+from .config import Config
+from .constants import CONTAINER_NAME
+
+
+class DockerManager:
+    """Manage PFTP Docker container"""
+
+    def __init__(self, config: Config):
+        """Initialize Docker manager
+
+        Args:
+            config: PFTP configuration
+        """
+        self.config = config
+        try:
+            self.client = docker.from_env()
+        except DockerException as e:
+            click.echo(f"Error: Cannot connect to Docker daemon. Is Docker running?", err=True)
+            click.echo(f"Details: {e}", err=True)
+            raise
+
+    def pull_image(self, image_name: str) -> bool:
+        """Pull Docker image from registry
+
+        Args:
+            image_name: Full image name (e.g., 'ahmadalawneh3/pftp:latest')
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            click.echo(f"Pulling image {image_name}...")
+            self.client.images.pull(image_name)
+            click.echo(f"✓ Successfully pulled {image_name}")
+            return True
+        except DockerException as e:
+            click.echo(f"Error pulling image: {e}", err=True)
+            return False
+
+    def is_running(self) -> bool:
+        """Check if container is running
+
+        Returns:
+            True if container exists and is running
+        """
+        try:
+            container = self.client.containers.get(CONTAINER_NAME)
+            return container.status == 'running'
+        except NotFound:
+            return False
+
+    def start_container(self) -> bool:
+        """Start PFTP container
+
+        Returns:
+            True if successful, False otherwise
+        """
+        # Check if container exists
+        try:
+            container = self.client.containers.get(CONTAINER_NAME)
+            if container.status == 'running':
+                click.echo(f"Container '{CONTAINER_NAME}' is already running")
+                return True
+            # Container exists but not running - start it
+            container.start()
+            click.echo(f"✓ Started container '{CONTAINER_NAME}'")
+            return True
+        except NotFound:
+            # Create new container
+            return self._create_and_start()
+
+    def _create_and_start(self) -> bool:
+        """Create and start new container
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Prepare volume mappings
+            volumes = {
+                str(self.config.tools_dir): {'bind': '/app/data/tools', 'mode': 'rw'},
+                str(self.config.uploads_dir): {'bind': '/app/data/uploads', 'mode': 'rw'},
+            }
+
+            # Prepare environment variables
+            environment = {
+                # General
+                'PROTOCOL': 'http',
+                'HOST': self.config.host,
+                'PORT': str(self.config.port),
+                'DEBUG': 'false',
+                'UPLOAD_FOLDER': 'data/uploads',
+                'TOOLS_FOLDER': 'data/tools',
+                'IGNORE_DIRS': '.git,__pycache__,.vscode',
+
+                # HTTP
+                'HTTP_ENABLED': str(self.config.protocols.get('http', {}).get('enabled', True)).lower(),
+                'HTTP_PORT': str(self.config.protocols.get('http', {}).get('port', 1234)),
+
+                # FTP
+                'FTP_ENABLED': str(self.config.protocols.get('ftp', {}).get('enabled', True)).lower(),
+                'FTP_PORT': str(self.config.protocols.get('ftp', {}).get('port', 21)),
+                'FTP_PASSIVE_START': str(self.config.protocols.get('ftp', {}).get('passive_start', 60000)),
+                'FTP_PASSIVE_END': str(self.config.protocols.get('ftp', {}).get('passive_end', 60100)),
+
+                # SMB
+                'SMB_ENABLED': str(self.config.protocols.get('smb', {}).get('enabled', True)).lower(),
+                'SMB_PORT': str(self.config.protocols.get('smb', {}).get('port', 445)),
+                'SMB_NETBIOS_PORT': str(self.config.protocols.get('smb', {}).get('netbios_port', 139)),
+
+                # Authentication
+                'AUTH_ENABLED': str(self.config.auth_enabled).lower(),
+                'AUTH_USERNAME': self.config.auth_username or '',
+                'AUTH_PASSWORD_HASH': self.config.auth_password_hash or '',
+            }
+
+            # Prepare restart policy
+            restart_policy_name = self.config.restart_policy or 'unless-stopped'
+            restart_policy = {'Name': restart_policy_name}
+            if restart_policy_name == 'on-failure':
+                restart_policy['MaximumRetryCount'] = 5
+
+            # Create and start container
+            container = self.client.containers.run(
+                self.config.docker_image,
+                name=CONTAINER_NAME,
+                volumes=volumes,
+                environment=environment,
+                network_mode='host',  # Required for IP detection
+                restart_policy=restart_policy,
+                detach=True,
+                stdin_open=True,
+                tty=True
+            )
+
+            click.echo(click.style(f"✓ Container created and started: {container.short_id}", fg='green'))
+
+            # Try to get actual IPs
+            try:
+                import subprocess
+                import re
+                result = subprocess.run(['ip', 'addr', 'show'],
+                                      capture_output=True, text=True, timeout=5)
+                if result.returncode == 0:
+                    ips = []
+                    current_interface = None
+
+                    for line in result.stdout.split('\n'):
+                        if_match = re.match(r'^\d+:\s+(\S+):', line)
+                        if if_match:
+                            current_interface = if_match.group(1)
+
+                        ip_match = re.search(r'inet\s+(\d+\.\d+\.\d+\.\d+)', line)
+                        if ip_match and current_interface:
+                            ip = ip_match.group(1)
+                            if ip != '127.0.0.1':
+                                # Priority system:
+                                # 0 = tun interfaces (VPN/pentest)
+                                # 1 = eth interfaces (ethernet)
+                                # 2 = wlan interfaces (wifi)
+                                # 3 = other interfaces
+                                if current_interface.startswith('tun'):
+                                    priority = 0
+                                elif current_interface.startswith('eth'):
+                                    priority = 1
+                                elif current_interface.startswith('wlan'):
+                                    priority = 2
+                                else:
+                                    priority = 3
+
+                                ips.append((priority, ip, current_interface))
+
+                    ips.sort()
+                    ip_list = [ip for _, ip, _ in ips]
+
+                    if ip_list:
+                        click.echo(click.style(f"✓ Server running at:", fg='green', bold=True))
+                        for ip in ip_list:
+                            click.echo(f"  {click.style(f'http://{ip}:{self.config.port}', fg='cyan', bold=True)}")
+                    else:
+                        click.echo(click.style(f"✓ Server running on http://<your-ip>:{self.config.port}", fg='green'))
+                else:
+                    click.echo(click.style(f"✓ Server running on http://<your-ip>:{self.config.port}", fg='green'))
+            except:
+                click.echo(click.style(f"✓ Server running on http://<your-ip>:{self.config.port}", fg='green'))
+
+            return True
+
+        except ImageNotFound:
+            click.echo(f"Error: Docker image '{self.config.docker_image}' not found", err=True)
+            click.echo("Run 'pftp install' to pull the image", err=True)
+            return False
+        except DockerException as e:
+            click.echo(f"Error starting container: {e}", err=True)
+            return False
+
+    def stop_container(self) -> bool:
+        """Stop container
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            container = self.client.containers.get(CONTAINER_NAME)
+            container.stop(timeout=10)
+            click.echo(f"✓ Container '{CONTAINER_NAME}' stopped")
+            return True
+        except NotFound:
+            click.echo(f"Container '{CONTAINER_NAME}' not found")
+            return False
+        except DockerException as e:
+            click.echo(f"Error stopping container: {e}", err=True)
+            return False
+
+    def remove_container(self) -> bool:
+        """Remove container
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            container = self.client.containers.get(CONTAINER_NAME)
+            container.remove(force=True)
+            click.echo(f"✓ Container '{CONTAINER_NAME}' removed")
+            return True
+        except NotFound:
+            # Already removed
+            return True
+        except DockerException as e:
+            click.echo(f"Error removing container: {e}", err=True)
+            return False
+
+    def get_logs(self, follow: bool = True, lines: int = 50):
+        """Get container logs
+
+        Args:
+            follow: Stream logs (like tail -f)
+            lines: Number of lines to show
+        """
+        try:
+            container = self.client.containers.get(CONTAINER_NAME)
+            if follow:
+                click.echo(click.style(f"Following logs from '{CONTAINER_NAME}' (Ctrl+C to stop)...", fg='cyan'))
+                buffer = b''
+                for chunk in container.logs(stream=True, follow=True, tail=lines):
+                    if isinstance(chunk, bytes):
+                        buffer += chunk
+                    else:
+                        buffer += chunk.encode('utf-8')
+                    while b'\n' in buffer:
+                        line, buffer = buffer.split(b'\n', 1)
+                        click.echo(line.decode('utf-8', errors='replace').rstrip())
+                if buffer:
+                    click.echo(buffer.decode('utf-8', errors='replace').rstrip())
+            else:
+                # Get logs as bytes, decode to string
+                logs_bytes = container.logs(tail=lines)
+                if isinstance(logs_bytes, bytes):
+                    click.echo(logs_bytes.decode('utf-8', errors='replace'))
+                else:
+                    click.echo(str(logs_bytes))
+        except NotFound:
+            click.echo(click.style(f"Container '{CONTAINER_NAME}' not found", fg='red'), err=True)
+        except KeyboardInterrupt:
+            click.echo(click.style("\n✓ Stopped following logs", fg='green'))
+        except DockerException as e:
+            click.echo(click.style(f"Error getting logs: {e}", fg='red'), err=True)
+
+    def get_status(self) -> Optional[Dict]:
+        """Get container status information
+
+        Returns:
+            Dictionary with container info or None if not found
+        """
+        try:
+            container = self.client.containers.get(CONTAINER_NAME)
+            return {
+                'status': container.status,
+                'id': container.short_id,
+                'image': container.image.tags[0] if container.image.tags else 'unknown',
+                'created': container.attrs['Created'],
+                'ports': container.attrs.get('NetworkSettings', {}).get('Ports', {})
+            }
+        except NotFound:
+            return {'status': 'not_found'}
+        except DockerException as e:
+            click.echo(f"Error getting status: {e}", err=True)
+            return None

pftp-2.0.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: pftp
+Version: 2.0.0
+Summary: PFTP - Pentest File Transfer Protocols - CLI Tool
+Author-email: Ahmad Alawneh <a.3alawneh@gmail.com>
+License: MIT
+Keywords: pentest,file-transfer,security,hacking,ctf,ftp,CTF
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT 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: Topic :: Security
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0
+Requires-Dist: docker>=6.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# PFTP CLI
+
+CLI tool for managing the PFTP (Pentest File Transfer Protocols) server.
+
+## Installation
+
+```bash
+pipx install pftp
+```
+
+Or from source:
+
+```bash
+cd cli
+pipx install .
+```
+
+## Quick Start
+
+```bash
+# Install and configure
+pftp install
+
+# Start the server
+pftp start
+
+# Check status
+pftp status
+
+# Add tools
+pftp add-tool /path/to/linpeas.sh
+
+# View logs
+pftp logs
+
+# Stop the server
+pftp stop
+```
+
+## Commands
+
+- `pftp install` - Install and configure pftp
+- `pftp configure` - Reconfigure settings
+- `pftp start` - Start the server
+- `pftp stop` - Stop the server
+- `pftp restart` - Restart the server
+- `pftp status` - Show status and configuration
+- `pftp logs` - View server logs
+- `pftp update` - Update to latest Docker image
+- `pftp remove` - Uninstall pftp
+- `pftp add-tool` - Add files to tools directory
+- `pftp version` - Show version
+
+## Requirements
+
+- Python 3.8+
+- Docker
+
+## License
+
+MIT

pftp-2.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pftp/__init__.py,sha256=V9qkxhFeWzkx2PC5yjNuNREk-LwtdRWT0DDbKoOp6TQ,173
+pftp/__main__.py,sha256=OgFKe0aksr0dwPtmMSbvtSRrRaPrhWrtLmLhjIWdLGA,108
+pftp/cli.py,sha256=EjaOnWCERNMkKj3shEHI2DVBYxuJOGEsizL51Djrn5M,31422
+pftp/config.py,sha256=9NBYpcd2xL021JHAymi_FANvodJfgOf8QEMZixEYfRE,5642
+pftp/constants.py,sha256=X9F7MdIP0FKVAY1GkKrAWOz08KxDr1i4KBtFRHGd7Sk,758
+pftp/docker_manager.py,sha256=q6L5wd52g3EbtlvC40ThsNb0zkgkCpO2W9fjVtU7u00,11812
+pftp-2.0.0.dist-info/METADATA,sha256=RYlrFffAcq7KgBN2CU4G8k_XuC0kJh2tebGdGxSLojc,1816
+pftp-2.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pftp-2.0.0.dist-info/entry_points.txt,sha256=Hp7IlQLGb30u4zTq3huSYls15Ecy9vw8tAxu5qf-79U,38
+pftp-2.0.0.dist-info/top_level.txt,sha256=Dn7MXqEDhB-cK4jiVjMlh0Xu1pq1yuO3_BTNwyd7TSk,5
+pftp-2.0.0.dist-info/RECORD,,

pftp-2.0.0.dist-info/WHEEL

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

pftp-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pftp = pftp.cli:cli

pftp-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pftp