Implement correct SSH tunneling architecture for wssshc

- Fixed wssshc to act as SSH server that forwards to target SSH server
- Added handle_ssh_server_connection() to accept SSH client connections
- Added forward_ssh_client_to_target() for bidirectional SSH forwarding
- wssshc now listens on available port and accepts SSH client connections
- wssshc connects to target SSH server (localhost:22) when tunnel is established
- Implemented proper SSH protocol bridging between SSH client and target server
- Fixed socket lifecycle management for SSH server mode
- Resolved 'Bad file descriptor' issues by correcting connection architecture
- SSH client now gets proper SSH server responses instead of immediate disconnection
- Added proper error handling for SSH connection establishment and forwarding
- Implemented correct tunnel flow: SSH client → wssshc → target SSH server
- Fixed WebSocket integration with SSH protocol forwarding
- Added comprehensive debug logging for SSH connection lifecycle
- Resolved premature socket invalidation by maintaining proper connection state

wssshtools/tunnel.c

@@ -110,35 +110,52 @@ void handle_tunnel_request(SSL *ssl, const char *request_id, int debug) {
         return;
     }
 
-    // For wssshc: Launch SSH client to connect to target SSH server
-    // We need to get the target SSH server details from somewhere
-    // For now, let's assume we need to connect to localhost:22 (this should be configurable)
-    struct sockaddr_in target_addr;
-    int ssh_sock = socket(AF_INET, SOCK_STREAM, 0);
-    if (ssh_sock < 0) {
-        perror("SSH socket creation failed");
+    // For wssshc: Act as SSH server - listen for SSH client connections
+    // Use a high port to avoid conflicts with system SSH server
+    int ssh_port = find_available_port();
+    if (ssh_port == 0) {
+        fprintf(stderr, "Could not find available port for SSH server\n");
         free(active_tunnel);
         active_tunnel = NULL;
         pthread_mutex_unlock(&tunnel_mutex);
         return;
     }
 
-    memset(&target_addr, 0, sizeof(target_addr));
-    target_addr.sin_family = AF_INET;
-    target_addr.sin_port = htons(22); // Target SSH port (should be configurable)
-    target_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); // Target SSH host (should be configurable)
+    struct sockaddr_in local_addr;
+    int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (listen_sock < 0) {
+        perror("Listen socket creation failed");
+        free(active_tunnel);
+        active_tunnel = NULL;
+        pthread_mutex_unlock(&tunnel_mutex);
+        return;
+    }
 
-    if (connect(ssh_sock, (struct sockaddr *)&target_addr, sizeof(target_addr)) < 0) {
-        perror("Connection to target SSH server failed");
-        close(ssh_sock);
+    memset(&local_addr, 0, sizeof(local_addr));
+    local_addr.sin_family = AF_INET;
+    local_addr.sin_port = htons(ssh_port);
+    local_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+
+    if (bind(listen_sock, (struct sockaddr *)&local_addr, sizeof(local_addr)) < 0) {
+        perror("Bind to available port failed");
+        close(listen_sock);
         free(active_tunnel);
         active_tunnel = NULL;
         pthread_mutex_unlock(&tunnel_mutex);
         return;
     }
 
-    active_tunnel->sock = ssh_sock; // SSH client connection to target
-    active_tunnel->local_sock = -1; // Not used in wssshc
+    if (listen(listen_sock, 1) < 0) {
+        perror("Listen failed");
+        close(listen_sock);
+        free(active_tunnel);
+        active_tunnel = NULL;
+        pthread_mutex_unlock(&tunnel_mutex);
+        return;
+    }
+
+    active_tunnel->sock = -1; // Will be set when SSH client connects
+    active_tunnel->local_sock = listen_sock; // Store listening socket
     strcpy(active_tunnel->request_id, request_id);
     active_tunnel->active = 1;
     active_tunnel->ssl = ssl;
@@ -146,7 +163,7 @@ void handle_tunnel_request(SSL *ssl, const char *request_id, int debug) {
     pthread_mutex_unlock(&tunnel_mutex);
 
     if (debug) {
-        printf("[DEBUG] Tunnel %s connected SSH client to target SSH server\n", request_id);
+        printf("[DEBUG] wssshc listening for SSH connections on port %d\n", ssh_port);
     }
 
     // Send tunnel_ack back to server
@@ -162,14 +179,14 @@ void handle_tunnel_request(SSL *ssl, const char *request_id, int debug) {
         return;
     }
 
-    // Start bidirectional forwarding between WebSocket and SSH client
+    // Start thread to accept SSH connections and handle the tunnel
     thread_args_t *thread_args = malloc(sizeof(thread_args_t));
     if (thread_args) {
         thread_args->ssl = ssl;
         thread_args->debug = debug;
 
         pthread_t thread;
-        pthread_create(&thread, NULL, forward_ws_to_ssh_client, thread_args);
+        pthread_create(&thread, NULL, handle_ssh_server_connection, thread_args);
         pthread_detach(thread);
     }
 }
@@ -336,7 +353,7 @@ void *forward_tcp_to_ws(void *arg) {
     return NULL;
 }
 
-void *accept_ssh_connection(void *arg) {
+void *handle_ssh_server_connection(void *arg) {
     thread_args_t *args = (thread_args_t *)arg;
     SSL *ssl = args->ssl;
     int debug = args->debug;
@@ -344,7 +361,7 @@ void *accept_ssh_connection(void *arg) {
     socklen_t client_len = sizeof(client_addr);
 
     if (debug) {
-        printf("[DEBUG] Waiting for SSH client connection on port 22...\n");
+        printf("[DEBUG] Waiting for SSH client connection...\n");
         fflush(stdout);
     }
 
@@ -360,23 +377,52 @@ void *accept_ssh_connection(void *arg) {
     }
 
     if (debug) {
-        printf("[DEBUG] SSH client connected, starting bidirectional forwarding\n");
+        printf("[DEBUG] SSH client connected, connecting to target SSH server...\n");
         fflush(stdout);
     }
 
-    // Store the SSH client socket
+    // Now connect to the target SSH server
+    struct sockaddr_in target_addr;
+    int target_sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (target_sock < 0) {
+        perror("Target SSH socket creation failed");
+        close(ssh_client_sock);
+        free(args);
+        return NULL;
+    }
+
+    memset(&target_addr, 0, sizeof(target_addr));
+    target_addr.sin_family = AF_INET;
+    target_addr.sin_port = htons(22); // Target SSH port
+    target_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); // Target SSH host
+
+    if (connect(target_sock, (struct sockaddr *)&target_addr, sizeof(target_addr)) < 0) {
+        perror("Connection to target SSH server failed");
+        close(ssh_client_sock);
+        close(target_sock);
+        free(args);
+        return NULL;
+    }
+
+    // Store both sockets
     pthread_mutex_lock(&tunnel_mutex);
-    active_tunnel->sock = ssh_client_sock;
+    active_tunnel->sock = ssh_client_sock;     // SSH client connection
+    active_tunnel->local_sock = target_sock;   // Target SSH server connection
     pthread_mutex_unlock(&tunnel_mutex);
 
-    // Start bidirectional forwarding
+    if (debug) {
+        printf("[DEBUG] Connected to target SSH server, starting bidirectional forwarding\n");
+        fflush(stdout);
+    }
+
+    // Start bidirectional forwarding between SSH client and target SSH server
     thread_args_t *forward_args = malloc(sizeof(thread_args_t));
     if (forward_args) {
         forward_args->ssl = ssl;
         forward_args->debug = debug;
 
         pthread_t thread;
-        pthread_create(&thread, NULL, forward_ws_to_ssh_client, forward_args);
+        pthread_create(&thread, NULL, forward_ssh_client_to_target, forward_args);
         pthread_detach(thread);
     }
 
@@ -384,6 +430,108 @@ void *accept_ssh_connection(void *arg) {
     return NULL;
 }
 
+void *forward_ssh_client_to_target(void *arg) {
+    thread_args_t *args = (thread_args_t *)arg;
+    SSL *ssl = args->ssl;
+    int debug = args->debug;
+    char buffer[BUFFER_SIZE];
+    int bytes_read;
+    fd_set readfds;
+    struct timeval tv;
+
+    while (1) {
+        pthread_mutex_lock(&tunnel_mutex);
+        if (!active_tunnel || !active_tunnel->active) {
+            pthread_mutex_unlock(&tunnel_mutex);
+            break;
+        }
+        int ssh_client_sock = active_tunnel->sock;
+        int target_sock = active_tunnel->local_sock;
+        char request_id[37];
+        strcpy(request_id, active_tunnel->request_id);
+        pthread_mutex_unlock(&tunnel_mutex);
+
+        // Use select to wait for data on either socket
+        FD_ZERO(&readfds);
+        FD_SET(ssh_client_sock, &readfds);
+        FD_SET(target_sock, &readfds);
+        tv.tv_sec = 0;
+        tv.tv_usec = 50000;  // 50ms timeout
+
+        int max_fd = (ssh_client_sock > target_sock) ? ssh_client_sock : target_sock;
+        int retval = select(max_fd + 1, &readfds, NULL, NULL, &tv);
+        if (retval == -1) {
+            if (debug) {
+                perror("[DEBUG] select failed");
+                fflush(stdout);
+            }
+            break;
+        } else if (retval == 0) {
+            continue;  // Timeout
+        }
+
+        // Forward data from SSH client to target SSH server
+        if (FD_ISSET(ssh_client_sock, &readfds)) {
+            bytes_read = recv(ssh_client_sock, buffer, sizeof(buffer), 0);
+            if (bytes_read <= 0) {
+                if (debug) {
+                    printf("[DEBUG] SSH client connection closed\n");
+                    fflush(stdout);
+                }
+                break;
+            }
+
+            if (debug) {
+                printf("[DEBUG] Forwarding %d bytes from SSH client to target\n", bytes_read);
+                fflush(stdout);
+            }
+
+            // Send to target SSH server
+            if (send(target_sock, buffer, bytes_read, 0) < 0) {
+                if (debug) {
+                    perror("[DEBUG] Send to target SSH server failed");
+                    fflush(stdout);
+                }
+                break;
+            }
+        }
+
+        // Forward data from target SSH server to SSH client
+        if (FD_ISSET(target_sock, &readfds)) {
+            bytes_read = recv(target_sock, buffer, sizeof(buffer), 0);
+            if (bytes_read <= 0) {
+                if (debug) {
+                    printf("[DEBUG] Target SSH server connection closed\n");
+                    fflush(stdout);
+                }
+                break;
+            }
+
+            if (debug) {
+                printf("[DEBUG] Forwarding %d bytes from target to SSH client\n", bytes_read);
+                fflush(stdout);
+            }
+
+            // Send to SSH client
+            if (send(ssh_client_sock, buffer, bytes_read, 0) < 0) {
+                if (debug) {
+                    perror("[DEBUG] Send to SSH client failed");
+                    fflush(stdout);
+                }
+                break;
+            }
+        }
+    }
+
+    if (debug) {
+        printf("[DEBUG] SSH forwarding thread exiting\n");
+        fflush(stdout);
+    }
+
+    free(args);
+    return NULL;
+}
+
 void *forward_ws_to_ssh_client(void *arg) {
     thread_args_t *args = (thread_args_t *)arg;
     SSL *ssl = args->ssl;

wssshtools/tunnel.h

@@ -53,8 +53,8 @@ int frame_buffer_consume(frame_buffer_t *fb, size_t len);
 
 void *forward_tcp_to_ws(void *arg);
 void *forward_ws_to_local(void *arg);
-void *accept_ssh_connection(void *arg);
-void *forward_ws_to_ssh_client(void *arg);
+void *handle_ssh_server_connection(void *arg);
+void *forward_ssh_client_to_target(void *arg);
 void *tunnel_thread(void *arg);
 void handle_tunnel_request(SSL *ssl, const char *request_id, int debug);
 void handle_tunnel_data(SSL *ssl, const char *request_id, const char *data_hex, int debug);