sshpass-win32

https://github.com/xhcoding/sshpass-win32
Admin
sshpass-win32 is a Windows port of the sshpass utility, allowing users to provide passwords...
Tokens:4,892
Snippets:18
Trust Score:7.6
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### sshpass-win32 Example: Basic SSH Command

Source: https://github.com/xhcoding/sshpass-win32/blob/main/README.md

Demonstrates a basic usage of sshpass-win32 to execute an 'ls' command on a remote server via SSH, providing the password directly as an argument. Note the security implications of using '-p'.

```shell
sshpass -p 12345 ssh xhcoding@192.168.139.128 ls
```

--------------------------------

### sshpass-win32 Example: Rsync with Custom SSH Path

Source: https://github.com/xhcoding/sshpass-win32/blob/main/README.md

Illustrates using sshpass-win32 with rsync to transfer a file, specifying a custom path to the SSH executable. This is useful when SSH is not in the system's PATH or a specific version is required.

```shell
sshpass -p 12345 rsync -avz -e 'c:/Users/xhcoding/scoop/apps/cwrsync/current/bin/ssh.exe' README.md xhcoding@192.168.139.128:/home/xhcoding/
```

--------------------------------

### sshpass-win32 Usage and Options

Source: https://github.com/xhcoding/sshpass-win32/blob/main/README.md

This section details the command-line syntax and available options for the sshpass-win32 utility. It covers password input methods (stdin, file, file descriptor, argument, environment variable), prompt detection, and verbosity.

```shell
Usage: sshpass [ options ] command arguments

    -h, --help    show this help message and exit

Password options: With no options - password will be taken from stdin
    -f=<str>      Take password to use from file
    -d=<int>      Use number as file descriptor for getting password
    -p=<str>      Provide password as argument (security unwise)
    -e            Password is passed as env-var "SSHPASS"

Other options:
    -P=<str>      Which string should sshpass search for to detect a password prompt
    -v            Be verbose about what you're doing
```

--------------------------------

### Main Execution Flow with Pseudo-Console

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

This C function orchestrates the main execution flow, setting up a UTF-8 console, parsing arguments, and creating a pseudo-console (ConPTY) for the child SSH process. It spawns threads for pipe listening and user input handling, initiates the child process, and waits for their completion before cleaning up resources. The function returns the exit code of the spawned SSH process.

```c
int wmain(int argc, const wchar_t* argv[]) {
    Context ctx;
    DWORD childExitCode = 0;

    SetupConsole();  // UTF-8 console setup

    char** argvUtf8 = ConvertArgcToMultiByte(argc, argv);
    ParseArgs(argc, argv, argvUtf8, &ctx);

    ctx.pipeIn = INVALID_HANDLE_VALUE;
    ctx.pipeOut = INVALID_HANDLE_VALUE;
    ctx.stdOut = GetStdHandle(STD_OUTPUT_HANDLE);
    ctx.events[0] = CreateEvent(NULL, FALSE, FALSE, NULL);

    // Enable VT processing for output
    DWORD consoleMode = 0;
    GetConsoleMode(ctx.stdOut, &consoleMode);
    SetConsoleMode(ctx.stdOut, consoleMode | ENABLE_VIRTUAL_TERMINAL_PROCESSING);

    HPCON hpcon = INVALID_HANDLE_VALUE;
    HRESULT hr = CreatePseudoConsoleAndPipes(&hpcon, &ctx);

    if (S_OK == hr) {
        HANDLE pipeListener = (HANDLE)_beginthread(PipeListener, 0, &ctx);

        STARTUPINFOEXW startupInfo = {0};
        if (S_OK == InitializeStartupInfoAttachedToPseudoConsole(&startupInfo, hpcon)) {
            PROCESS_INFORMATION cmdProc;
            hr = CreateProcessW(NULL, ctx.args.cmd, NULL, NULL, FALSE,
                               EXTENDED_STARTUPINFO_PRESENT, NULL, NULL,
                               &startupInfo.StartupInfo, &cmdProc) ? S_OK : GetLastError();

            if (S_OK == hr) {
                ctx.events[1] = cmdProc.hThread;
                HANDLE inputHandler = (HANDLE)_beginthread(InputHandlerThread, 0, &ctx);

                // Wait for either pipe listener or process completion
                WaitForMultipleObjects(2, ctx.events, FALSE, INFINITE);
                GetExitCodeProcess(cmdProc.hProcess, &childExitCode);
            }

            CloseHandle(cmdProc.hThread);
            CloseHandle(cmdProc.hProcess);
            DeleteProcThreadAttributeList(startupInfo.lpAttributeList);
            free(startupInfo.lpAttributeList);
        }

        ClosePseudoConsole(hpcon);
        CloseHandle(ctx.pipeOut);
        CloseHandle(ctx.pipeIn);
        CloseHandle(ctx.events[0]);
    }

    return S_OK == hr ? childExitCode : EXIT_FAILURE;
}
```

--------------------------------

### Pseudo Console Creation with Pipes (C)

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

This C function creates a pseudo-console (ConPTY) and bidirectional pipes for communication with a child process. It determines console dimensions and initializes the ConPTY with appropriate handles. It returns S_OK on success or an error HRESULT on failure.

```c
static HRESULT CreatePseudoConsoleAndPipes(HPCON* hpcon, Context* ctx) {
    HRESULT hr = E_UNEXPECTED;
    HANDLE pipePtyIn = INVALID_HANDLE_VALUE;
    HANDLE pipePtyOut = INVALID_HANDLE_VALUE;

    // Create bidirectional pipes
    if (CreatePipe(&pipePtyIn, &ctx->pipeOut, NULL, 0) &&
        CreatePipe(&ctx->pipeIn, &pipePtyOut, NULL, 0)) {

        // Get console dimensions
        COORD consoleSize;
        CONSOLE_SCREEN_BUFFER_INFO csbi;
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        if (GetConsoleScreenBufferInfo(hConsole, &csbi)) {
            consoleSize.X = csbi.srWindow.Right - csbi.srWindow.Left + 1;
            consoleSize.Y = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
        } else {
            consoleSize.X = 120;
            consoleSize.Y = 25;
        }

        // Create pseudo console
        hr = CreatePseudoConsole(consoleSize, pipePtyIn, pipePtyOut, 0, hpcon);

        CloseHandle(pipePtyOut);
        CloseHandle(pipePtyIn);
    }
    return hr;
}

// Returns: S_OK on success, error HRESULT on failure
// Creates ConPTY with 120x25 default size or actual console dimensions
```

--------------------------------

### sshpass-win32 Core Architecture Structures (C)

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

Defines the core data structures used in sshpass-win32 for managing command-line arguments and the main execution context. Includes enum for password source types and a union for source specifics, along with handles for inter-process communication.

```c
// Password source types
typedef struct {
    enum { PWT_STDIN, PWT_FILE, PWT_FD, PWT_PASS } pwtype;
    union {
        const wchar_t* filename;
        int64_t fd;
        const char* password;
    } pwsrc;
    const char* passPrompt;
    int verbose;
    wchar_t* cmd;
} Args;

// Main context with pipes and events
typedef struct {
    Args args;
    HANDLE pipeIn;      // Read from child process
    HANDLE pipeOut;     // Write to child process
    HANDLE stdOut;      // Standard output handle
    HANDLE events[2];   // Synchronization events
} Context;

// Usage example:
Context ctx;
ctx.args.pwtype = PWT_PASS;
ctx.args.pwsrc.password = "mypassword";
ctx.args.passPrompt = "password:";
ctx.args.verbose = 1;
ctx.args.cmd = L"ssh user@192.168.1.100";

```

--------------------------------

### Parse Command-Line Arguments for SSH Pass

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

This C code defines and parses command-line options for sshpass, including password sources (file, descriptor, argument, environment variable, stdin), password prompt detection, and verbose output. It uses the 'argparse' library to handle option processing and populates a context structure with parsed values and the command to be executed. Dependencies include the 'argparse' library and a custom 'ToUtf16' function.

```c
static const char* const usages[] = {
    "sshpass [options] command arguments",
    NULL,
};

void ParseArgs(int argc, const wchar_t* wargv[], char** argv, Context* ctx) {
    const char* filename = NULL;
    int64_t number = 0;
    const char* strpass = NULL;
    int envPass = 0;
    const char* passPrompt = NULL;
    int verbose = 0;

    struct argparse_option options[] = {
        OPT_HELP(),
        OPT_GROUP("Password options: With no options - password will be taken from stdin"),
        OPT_STRING('f', NULL, &filename, "Take password to use from file", NULL, 0, 0),
        OPT_INTEGER('d', NULL, &number, "Use number as file descriptor for getting password", NULL, 0, 0),
        OPT_STRING('p', NULL, &strpass, "Provide password as argument (security unwise)", NULL, 0, 0),
        OPT_BOOLEAN('e', NULL, &envPass, "Password is passed as env-var \"SSHPASS\"", NULL, 0, 0),
        OPT_GROUP("Other options: "),
        OPT_STRING('P', NULL, &passPrompt, "Which string should sshpass search for to detect a password prompt", NULL, 0, 0),
        OPT_BOOLEAN('v', NULL, &verbose, "Be verbose about what you're doing", NULL, 0, 0),
        OPT_END(),
    };

    struct argparse argparse;
    argparse_init(&argparse, options, usages, ARGPARSE_STOP_AT_NON_OPTION);
    argc = argparse_parse(&argparse, argc, (const char**)argv);

    if (argc == 0) {
        argparse_usage(&argparse);
        exit(EXIT_FAILURE);
    }

    // Set context based on parsed options
    ctx->args.verbose = verbose;
    if (filename != NULL) {
        ctx->args.pwtype = PWT_FILE;
        ctx->args.pwsrc.filename = ToUtf16(filename);
    } else if (number != 0) {
        ctx->args.pwtype = PWT_FD;
        ctx->args.pwsrc.fd = number;
    } else if (strpass != NULL) {
        ctx->args.pwtype = PWT_PASS;
        ctx->args.pwsrc.password = strpass;
    } else if (envPass != 0) {
        ctx->args.pwtype = PWT_PASS;
        ctx->args.pwsrc.password = getenv("SSHPASS");
    } else {
        ctx->args.pwtype = PWT_STDIN;
    }

    ctx->args.passPrompt = (passPrompt != NULL) ? passPrompt : "password:";

    // Build command string from remaining arguments
    int cmdLen = 0;
    int parsedArgc = totalArgc - argc; // Assuming totalArgc is defined elsewhere
    for (int i = 0; i < argc; i++) {
        cmdLen += wcslen(wargv[i + parsedArgc]) + 2; // Assuming wargv and wcslen are available
    }
    ctx->args.cmd = malloc(sizeof(wchar_t) * cmdLen); // Assuming malloc is available
    // ... concatenate arguments into cmd
}

// Example: sshpass -v -p mypass ssh user@host
// Parsed: verbose=1, pwtype=PWT_PASS, password="mypass", cmd="ssh user@host"

```

--------------------------------

### State Machine for Password Prompt Detection (C)

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

This C code implements a state machine to detect password prompts from a child process. It transitions through INIT, VERIFY, EXEC, and END states to manage the password input and verification process. It relies on helper functions like IsWaitInputPass and WritePass.

```c
typedef enum { INIT, VERIFY, EXEC, END } State;

// Process output and detect password prompts
static State ProcessOutput(Context* ctx, const char* buffer, DWORD len, State state) {
    State nextState;
    switch (state) {
    case INIT:
        // Wait for password prompt
        if (!IsWaitInputPass(ctx, buffer, len)) {
            nextState = INIT;  // Keep waiting
        } else {
            WritePass(ctx);     // Found prompt, send password
            nextState = VERIFY;
        }
        break;
    case VERIFY:
        // Check if password was accepted
        if (IsWaitInputPass(ctx, buffer, len)) {
            fprintf(stderr, "Password is error!");
            nextState = END;    // Password rejected
        } else {
            fprintf(stdout, "%s", buffer);
            nextState = EXEC;   // Password accepted
        }
        break;
    case EXEC:
        // Normal execution, pass through output
        fprintf(stdout, "%s", buffer);
        nextState = EXEC;
        break;
    case END:
        nextState = END;
        break;
    }
    return nextState;
}

// Password prompt detection
static BOOL IsWaitInputPass(Context* ctx, const char* buffer, DWORD len) {
    char* pos = strstr(buffer, ctx->args.passPrompt);
    return (pos != NULL) ? TRUE : FALSE;
}
```

--------------------------------

### SSH with Inline Password Authentication (Shell)

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

Demonstrates basic SSH connection using sshpass with the password provided directly as a command-line argument. This method is convenient but insecure due to the password being visible in the command history. It executes a specified remote command upon successful authentication.

```sh
# SSH connection with password as argument (insecure but convenient)
sshpass -p mypassword123 ssh user@192.168.1.100 ls -la

# Execute remote command
sshpass -p mypassword123 ssh admin@server.example.com "df -h && uptime"

# Expected output: SSH command executes without password prompt
# Connection established, remote command output displayed directly
```

--------------------------------

### SSH with Stdin Password Input (Shell)

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

Demonstrates how to provide the SSH password via standard input (stdin) to sshpass. This can be done by piping the password or by allowing sshpass to wait for interactive input. This method is useful for scripting and interactive sessions.

```sh
# Read password from stdin (no options)
echo mypassword123 | sshpass ssh user@192.168.1.100

# Interactive stdin input
sshpass ssh user@192.168.1.100
# Waits for password input on stdin
# Type password and press Enter
# SSH connection proceeds
```

--------------------------------

### SSH with Environment Variable Password Authentication (Shell)

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

Illustrates using sshpass with a password provided via an environment variable (SSHPASS). This method offers a balance between security and convenience for automated scripts. It can be used with standard SSH commands and SCP.

```sh
# Set password in environment variable
set SSHPASS=mypassword123

# Use environment variable password
sshpass -e ssh user@192.168.1.100

# Combine with SCP
sshpass -e scp localfile.txt user@192.168.1.100:/home/user/

# Expected output: Password retrieved from SSHPASS env var
# SSH authentication succeeds without prompt
```

--------------------------------

### Input Handler Thread for Raw Console Input

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

This C function sets up a console for raw input, disabling line input and echo, while enabling virtual terminal input. It then reads user input character by character and forwards it to a pipe. The original console mode is restored upon exit. This is crucial for interactive SSH sessions.

```c
static void __cdecl InputHandlerThread(LPVOID arg) {
    Context* ctx = arg;
    HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
    DWORD mode;

    // Configure console for raw input
    GetConsoleMode(hStdin, &mode);
    mode &= ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT);
    mode |= ENABLE_VIRTUAL_TERMINAL_INPUT;
    SetConsoleMode(hStdin, mode);

    char buffer;
    DWORD bytesRead, bytesWritten;

    // Forward user input character by character
    while (1) {
        if (!ReadFile(hStdin, &buffer, 1, &bytesRead, NULL) || bytesRead == 0) {
            break;
        }
        if (!WriteFile(ctx->pipeOut, &buffer, 1, &bytesWritten, NULL)) {
            break;
        }
    }

    SetConsoleMode(hStdin, mode);  // Restore original mode
}
```

--------------------------------

### UTF-8 and UTF-16 Conversion Utilities

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

Provides functions to convert strings between UTF-8 and UTF-16 encoding. `ToUtf16` converts a UTF-8 string to UTF-16, and `ToUtf8` converts a UTF-16 string to UTF-8. These utilities handle memory allocation and error checking for the conversion process, essential for cross-platform text handling.

```c
// Convert UTF-8 string to UTF-16
static wchar_t* ToUtf16(const char* utf8) {
    if (utf8 == NULL) return NULL;

    int buf_size = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
    if (buf_size == 0) return NULL;

    wchar_t* utf16 = malloc(sizeof(wchar_t) * (buf_size + 1));
    buf_size = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, utf16, buf_size);
    if (buf_size == 0) {
        free(utf16);
        return NULL;
    }
    utf16[buf_size] = L'\0';
    return utf16;
}
```

```c
// Convert UTF-16 string to UTF-8
static char* ToUtf8(const wchar_t* wstr) {
    if (wstr == NULL) return NULL;

    int len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
    if (len == 0) return NULL;

    char* utf8 = (char*)malloc(len);
    if (utf8 == NULL) return NULL;

    if (WideCharToMultiByte(CP_UTF8, 0, wstr, -1, utf8, len, NULL, NULL) == 0) {
        free(utf8);
        return NULL;
    }
    return utf8;
}
```

--------------------------------

### Custom Password Prompt Detection (Shell)

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

Explains how to configure sshpass to recognize custom password prompts, essential for non-standard SSH server configurations. The `-P` option specifies the prompt string. The `-v` flag enables verbose output for debugging.

```sh
# Default prompt is "password:" (case-insensitive)
# Specify custom prompt string for non-standard SSH servers
sshpass -p mypassword123 -P="Enter passphrase:" ssh user@192.168.1.100

# Verbose mode shows command execution details
sshpass -v -p mypassword123 -P="Password:" ssh user@192.168.1.100
# Output: cmd: ssh user@192.168.1.100
# Then proceeds with SSH connection
```

--------------------------------

### File Descriptor Password Source (Shell)

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

Presents an advanced usage of sshpass where the password is read from a specific file descriptor. This technique requires shell support for manipulating file descriptors and is typically used in complex scripting scenarios.

```sh
# Advanced usage: read password from specific file descriptor
# (Requires shell support for FD manipulation)
exec 3< password.txt
sshpass -d=3 ssh user@192.168.1.100
exec 3<&-

# Expected output: Password read from file descriptor 3
# Useful for complex shell scripting scenarios
```

--------------------------------

### SSH with File-Based Password Authentication (Shell)

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

Shows how to use sshpass with a password stored in a file. This is a more secure approach than inline passwords. The file should contain the password on the first line, terminated by a newline. Supports standard SSH and rsync over SSH.

```sh
# Store password in file (secure approach)
echo mypassword123 > password.txt

# Use password from file
sshpass -f=password.txt ssh user@192.168.1.100

# With rsync over SSH
sshpass -f=password.txt rsync -avz -e 'ssh' ./localdir/ user@192.168.1.100:/remote/path/

# Expected output: Password read from file, SSH connection established
# File should contain password on first line, newline terminated
```

--------------------------------

### Pipe Listener Thread for Child Process Output (C)

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

This C function defines a pipe listener thread that continuously reads output from a child process through a pipe. It processes the output using a state machine to detect password prompts and forwards data to stdout. The thread signals a completion event upon termination, typically due to pipe closure or a detected error state.

```c
#define BUFFER_SIZE 8192

static void __cdecl PipeListener(LPVOID arg) {
    Context* ctx = arg;
    char buffer[BUFFER_SIZE + 1] = {0};
    DWORD bytesRead;
    BOOL fRead = FALSE;
    State state = INIT;

    // Continuously read from child process output
    while (1) {
        fRead = ReadFile(ctx->pipeIn, buffer, BUFFER_SIZE, &bytesRead, NULL);
        if (!fRead || bytesRead == 0) {
            break;  // Pipe closed or error
        }
        buffer[bytesRead] = 0;  // Null terminate

        // Process output through state machine
        state = ProcessOutput(ctx, buffer, bytesRead, state);
        if (state == END) {
            break;  // Password error or completion
        }
    }
    SetEvent(ctx->events[0]);  // Signal completion
}

// Thread reads child output in 8KB chunks
// Detects password prompts and forwards to stdout
// Signals completion event when done
```

--------------------------------

### Password Writing Based on Source Type (C)

Source: https://context7.com/xhcoding/sshpass-win32/llms.txt

This C function writes a password to the child process's input based on the specified source type (stdin, file descriptor, file, or a direct string). It handles reading from different sources, stripping carriage returns and newlines, and automatically appends a newline character after the password.

```c
static void WritePass(Context* ctx) {
    switch (ctx->args.pwtype) {
    case PWT_STDIN:
        // Read from standard input
        WritePassHandle(ctx, GetStdHandle(STD_INPUT_HANDLE));
        break;
    case PWT_FD:
        // Read from file descriptor
        WritePassHandle(ctx, (HANDLE)ctx->args.pwsrc.fd);
        break;
    case PWT_FILE:
        // Read from file
        HANDLE file = CreateFileW(ctx->args.pwsrc.filename, GENERIC_READ, 
                                  FILE_SHARE_READ, NULL, OPEN_EXISTING, 
                                  FILE_ATTRIBUTE_READONLY, NULL);
        if (file != INVALID_HANDLE_VALUE) {
            WritePassHandle(ctx, file);
            CloseHandle(file);
        }
        break;
    case PWT_PASS:
        // Use string directly
        WriteFile(ctx->pipeOut, ctx->args.pwsrc.password, 
                  strlen(ctx->args.pwsrc.password), NULL, NULL);
        WriteFile(ctx->pipeOut, "\n", 1, NULL, NULL);
        break;
    }
}

// Automatically appends newline after password
// Strips \r and \n from file/fd sources
```
Tokens:
Raw