dlls/msv1_0/unixlib.c

   1 /*
   2  * Unix interface for ntlm_auth
   3  *
   4  * Copyright 2005, 2006 Kai Blin
   5  * Copyright 2021 Hans Leidekker for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #if 0
  23 #pragma makedep unix
  24 #endif
  25
  26 #include <stdarg.h>
  27 #include <stdlib.h>
  28 #include <unistd.h>
  29 #include <fcntl.h>
  30 #include <errno.h>
  31 #include <sys/wait.h>
  32 #include "ntstatus.h"
  33 #define WIN32_NO_STATUS
  34 #include "windef.h"
  35 #include "winternl.h"
  36 #include "winbase.h"
  37 #include "sspi.h"
  38
  39 #include "wine/debug.h"
  40 #include "unixlib.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(ntlm);
  43 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  44
  45 #define INITIAL_BUFFER_SIZE 200
  46
  47 static SECURITY_STATUS read_line( struct ntlm_ctx *ctx, unsigned int *offset )
  48 {
  49     char *newline;
  50
  51     if (!ctx->com_buf)
  52     {
  53         if (!(ctx->com_buf = malloc( INITIAL_BUFFER_SIZE )))
  54             return SEC_E_INSUFFICIENT_MEMORY;
  55         ctx->com_buf_size = INITIAL_BUFFER_SIZE;
  56         ctx->com_buf_offset = 0;
  57     }
  58
  59     do
  60     {
  61         ssize_t size;
  62         if (ctx->com_buf_offset + INITIAL_BUFFER_SIZE > ctx->com_buf_size)
  63         {
  64             char *buf = realloc( ctx->com_buf, ctx->com_buf_size + INITIAL_BUFFER_SIZE );
  65             if (!buf) return SEC_E_INSUFFICIENT_MEMORY;
  66             ctx->com_buf_size += INITIAL_BUFFER_SIZE;
  67             ctx->com_buf = buf;
  68         }
  69         size = read( ctx->pipe_in,  ctx->com_buf +  ctx->com_buf_offset,  ctx->com_buf_size -  ctx->com_buf_offset );
  70         if (size <= 0) return SEC_E_INTERNAL_ERROR;
  71
  72         ctx->com_buf_offset += size;
  73         newline = memchr( ctx->com_buf, '\n',  ctx->com_buf_offset );
  74     } while (!newline);
  75
  76     /* if there's a newline character, and we read more than that newline, we have to store the offset so we can
  77        preserve the additional data */
  78     if (newline != ctx->com_buf + ctx->com_buf_offset) *offset = (ctx->com_buf + ctx->com_buf_offset) - (newline + 1);
  79     else *offset = 0;
  80
  81     *newline = 0;
  82     return SEC_E_OK;
  83 }
  84
  85 static NTSTATUS ntlm_chat( void *args )
  86 {
  87     struct chat_params *params = args;
  88     struct ntlm_ctx *ctx = params->ctx;
  89     SECURITY_STATUS status = SEC_E_OK;
  90     unsigned int offset;
  91
  92     write( ctx->pipe_out, params->buf, strlen(params->buf) );
  93     write( ctx->pipe_out, "\n", 1 );
  94
  95     if ((status = read_line( ctx, &offset )) != SEC_E_OK) return status;
  96     *params->retlen = strlen( ctx->com_buf );
  97
  98     if (*params->retlen > params->buflen) return SEC_E_BUFFER_TOO_SMALL;
  99     if (*params->retlen < 2) return SEC_E_ILLEGAL_MESSAGE;
 100     if (!strncmp( ctx->com_buf, "ERR", 3 )) return SEC_E_INVALID_TOKEN;
 101
 102     memcpy( params->buf, ctx->com_buf, *params->retlen + 1 );
 103
 104     if (!offset) ctx->com_buf_offset = 0;
 105     else
 106     {
 107         memmove( ctx->com_buf, ctx->com_buf + ctx->com_buf_offset, offset );
 108         ctx->com_buf_offset = offset;
 109     }
 110
 111     return SEC_E_OK;
 112 }
 113
 114 static NTSTATUS ntlm_cleanup( void *args )
 115 {
 116     struct cleanup_params *params = args;
 117     struct ntlm_ctx *ctx = params->ctx;
 118
 119     if (!ctx || (ctx->mode != MODE_CLIENT && ctx->mode != MODE_SERVER)) return STATUS_INVALID_HANDLE;
 120     ctx->mode = MODE_INVALID;
 121
 122     /* closing stdin will terminate ntlm_auth */
 123     close( ctx->pipe_out );
 124     close( ctx->pipe_in );
 125
 126     if (ctx->pid > 0) /* reap child */
 127     {
 128         pid_t ret;
 129         do {
 130             ret = waitpid( ctx->pid, NULL, 0 );
 131         } while (ret < 0 && errno == EINTR);
 132     }
 133
 134     free( ctx->com_buf );
 135     return STATUS_SUCCESS;
 136 }
 137
 138 static NTSTATUS ntlm_fork( void *args )
 139 {
 140     struct fork_params *params = args;
 141     struct ntlm_ctx *ctx = params->ctx;
 142     int pipe_in[2], pipe_out[2];
 143
 144 #ifdef HAVE_PIPE2
 145     if (pipe2( pipe_in, O_CLOEXEC ) < 0)
 146 #endif
 147     {
 148         if (pipe( pipe_in ) < 0 ) return SEC_E_INTERNAL_ERROR;
 149         fcntl( pipe_in[0], F_SETFD, FD_CLOEXEC );
 150         fcntl( pipe_in[1], F_SETFD, FD_CLOEXEC );
 151     }
 152 #ifdef HAVE_PIPE2
 153     if (pipe2( pipe_out, O_CLOEXEC ) < 0)
 154 #endif
 155     {
 156         if (pipe( pipe_out ) < 0)
 157         {
 158             close( pipe_in[0] );
 159             close( pipe_in[1] );
 160             return SEC_E_INTERNAL_ERROR;
 161         }
 162         fcntl( pipe_out[0], F_SETFD, FD_CLOEXEC );
 163         fcntl( pipe_out[1], F_SETFD, FD_CLOEXEC );
 164     }
 165
 166     if (!(ctx->pid = fork())) /* child */
 167     {
 168         dup2( pipe_out[0], 0 );
 169         close( pipe_out[0] );
 170         close( pipe_out[1] );
 171
 172         dup2( pipe_in[1], 1 );
 173         close( pipe_in[0] );
 174         close( pipe_in[1] );
 175
 176         execvp( params->argv[0], params->argv );
 177
 178         write( 1, "BH\n", 3 );
 179         _exit( 1 );
 180     }
 181     else
 182     {
 183         ctx->pipe_in = pipe_in[0];
 184         close( pipe_in[1] );
 185         ctx->pipe_out = pipe_out[1];
 186         close( pipe_out[0] );
 187     }
 188
 189     return SEC_E_OK;
 190 }
 191
 192 #define NTLM_AUTH_MAJOR_VERSION 3
 193 #define NTLM_AUTH_MINOR_VERSION 0
 194 #define NTLM_AUTH_MICRO_VERSION 25
 195
 196 static NTSTATUS ntlm_check_version( void *args )
 197 {
 198     struct ntlm_ctx ctx = { 0 };
 199     char *argv[3], buf[80];
 200     NTSTATUS status = STATUS_DLL_NOT_FOUND;
 201     struct fork_params params = { &ctx, argv };
 202     int len;
 203
 204     argv[0] = (char *)"ntlm_auth";
 205     argv[1] = (char *)"--version";
 206     argv[2] = NULL;
 207     if (ntlm_fork( &params ) != SEC_E_OK) return status;
 208
 209     if ((len = read( ctx.pipe_in, buf, sizeof(buf) - 1 )) > 8)
 210     {
 211         char *newline;
 212         int major = 0, minor = 0, micro = 0;
 213
 214         if ((newline = memchr( buf, '\n', len ))) *newline = 0;
 215         else buf[len] = 0;
 216
 217         if (sscanf( buf, "Version %d.%d.%d", &major, &minor, &micro ) == 3)
 218         {
 219             if (((major > NTLM_AUTH_MAJOR_VERSION) ||
 220                  (major == NTLM_AUTH_MAJOR_VERSION && minor > NTLM_AUTH_MINOR_VERSION) ||
 221                  (major == NTLM_AUTH_MAJOR_VERSION && minor == NTLM_AUTH_MINOR_VERSION &&
 222                   micro >= NTLM_AUTH_MICRO_VERSION)))
 223             {
 224                 TRACE( "detected ntlm_auth version %d.%d.%d\n", major, minor, micro );
 225                 status = STATUS_SUCCESS;
 226             }
 227         }
 228     }
 229
 230     if (status) ERR_(winediag)( "ntlm_auth was not found or is outdated. "
 231                               "Make sure that ntlm_auth >= %d.%d.%d is in your path. "
 232                               "Usually, you can find it in the winbind package of your distribution.\n",
 233                               NTLM_AUTH_MAJOR_VERSION, NTLM_AUTH_MINOR_VERSION, NTLM_AUTH_MICRO_VERSION );
 234     ntlm_cleanup( &ctx );
 235     return status;
 236 }
 237
 238 const unixlib_entry_t __wine_unix_call_funcs[] =
 239 {
 240     ntlm_chat,
 241     ntlm_cleanup,
 242     ntlm_fork,
 243     ntlm_check_version,
 244 };