FWD

/*

** Module   : winspawn.c

** Abstract : a simple tool able to spawn a process on an existing user account.

**

** Copyright (c) 2013-2017, Golden Code Development Corporation.

**

** -#- -I- --Date-- --------------------------------Description---------------------------------

** 001 MAG 20131130 First version.

** 002 MAG 20140307 Added password and no password authentication: uses a secure P2J connection 

**                  and temporary credentials to authenticate the request. Redirect STDOUT to a 

**                  file for batch clients. 

** 003 CA  20140509 Fixed a key length usage in init().

** 004 OM  20151204 Removed MaxPermSize as it is was dropped from Java8. Temporarily disable

**                  redirect of stdout.

** 005 EVL 20160331 Restoring redirect mode for stdout.  Making new console to be hidden.

** 006 EVL 20170225 Adding DestroyEnvironmentBlock API call to clean up created resource.  A set

**                  of fixes to be able to run spawn.exe on 32-bit Windows.  Replace PathIsRoot

**                  usage with PathIsRelative, moving used in _GetUserProfileDirectoryW DWORD

**                  variable to the local function variable set. 

*/

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

#define _WIN32_WINNT 0x0500

#include <stdio.h>

#include <stdlib.h>

#include <wchar.h>

#include <jni.h>

#include <Windows.h>

#define EXIT_SUCCESS 0

#define ERR_SPAWN_NO_ARGS            -1

#define ERR_SPAWN_LOGON_USER         -2

#define ERR_SPAWN_CREATE_ENVIRONMENT -3

#define ERR_SPAWN_GET_USER_PROFILE   -4

#define ERR_SPAWN_WORKING_DIRECTORY  -5

#define ERR_SPAWN_CREATE_PROCESS     -6

#define ERR_SPAWN_LOAD_LIBRARIES     -7

#define ERR_JNI_JVM_CREATE             -100

#define ERR_JNI_P2J_ENTRY_POINT_CLASS  -101

#define ERR_JNI_P2J_ENTRY_POINT_METHOD -102

#define ERR_JNI_REMOTE_SERVER_PORT     -103

#define ERR_JNI_REMOTE_SERVER_HOST     -104

#define ERR_JNI_REMOTE_SERVER_ALIAS    -105

#define ERR_JNI_REMOTE_SERVER_UUID     -106

#define ERR_JNI_REMOTE_COMMAND         -107

#define ERR_JNI_JVM_DESTROY            -108

#define DEBUG_JVM 0

#define MIN_ARGS_PASSWORD    4

#define MIN_ARGS_NO_PASSWORD 6

#define MIN_ARGS_COMMAND     4

#define AUTH_OK           0

#define AUTH_ERR_USER     1

#define AUTH_ERR_PASSWORD 2

#define AUTH_ERR_ROOT     3

#define AUTH_ERR_PAM      4

#define MAX_SIZE 4096

#define KEY_SIZE 16

unsigned char key1[KEY_SIZE + 1], key2[KEY_SIZE + 1], key3[KEY_SIZE + 1];

/* STDOUT redirection flag. Default NO redirection */

int stdoutRedirect = 0;

WCHAR szOutputFile[MAX_SIZE] = L"";

WCHAR szUserProfile[MAX_SIZE] = L"";

WCHAR szCommandLine[MAX_SIZE] = L"";

WCHAR szPassword[MAX_PATH];

DWORD dwCreationFlags = CREATE_UNICODE_ENVIRONMENT | CREATE_NEW_CONSOLE;  // CREATE_NO_WINDOW

HANDLE hToken = NULL;

LPVOID lpvEnv;

STARTUPINFOW        si = {0};

PROCESS_INFORMATION pi = {0};

/* Function prototypes */

BOOL PathIsRelativeW(LPWSTR);

BOOL PathAppendW(LPWSTR,LPCWSTR);

BOOL WINAPI CreateEnvironmentBlock(LPVOID*,HANDLE,BOOL);

BOOL WINAPI DestroyEnvironmentBlock(LPVOID);

BOOL WINAPI GetUserProfileDirectoryW(HANDLE,LPWSTR,LPDWORD);

/* Function pointer definitions */

typedef BOOL (fpPathIsRelativeW)(LPCWSTR);

typedef BOOL (fpPathAppendW)(LPWSTR,LPCWSTR);

typedef BOOL (fpCreateEnvironmentBlock)(LPVOID*,HANDLE,BOOL);

typedef BOOL (fpDestroyEnvironmentBlock)(LPVOID);

typedef BOOL (fpGetUserProfileDirectoryW)(HANDLE,LPWSTR,LPDWORD);

/* Function pointer instances */

fpPathIsRelativeW* _PathIsRelativeW;

fpPathAppendW* _PathAppendW;

fpCreateEnvironmentBlock* _CreateEnvironmentBlock;

fpDestroyEnvironmentBlock* _DestroyEnvironmentBlock;

fpGetUserProfileDirectoryW* _GetUserProfileDirectoryW;

/* Libraries handles */

HINSTANCE hDllShlwapi = NULL, hDllUserenv = NULL;

/* spawn ini file */ 

static char ini_file[] = ".\\spawn.ini";

/* encryption enabled */

static unsigned int enabled = 0;

/**

* Initialize. Load configuration from spawn.ini file.

* File spawn.ini MUST be stored in the same folder where spawn.exe is located. 

*/

void init()

{

   // get enabled option

   enabled = GetPrivateProfileInt("Encryption", "enabled", 0, ini_file);

   // if enable load keys

   if (enabled)

   {

      // load keys

      int nKey1 = GetPrivateProfileString("Encryption", "key1", "", (LPSTR) key1, sizeof(key1), ini_file);

      int nKey2 = GetPrivateProfileString("Encryption", "key2", "", (LPSTR) key2, sizeof(key2), ini_file);

      int nKey3 = GetPrivateProfileString("Encryption", "key3", "", (LPSTR) key3, sizeof(key3), ini_file);

      // check key length

      if (nKey1 != KEY_SIZE || nKey2 != KEY_SIZE || nKey3 != KEY_SIZE)

      {

         enabled = 0;

         fwprintf(stderr, L"Key length must be 128 bits.\nFound key1=%d, key2=%d, key3=%d\n", 

            nKey1 << 3, nKey2 << 3, nKey3 << 3);

      }

   }   

}

/**

* Encode password.

*

* @param   password

*          Password clear-text.

*

* @param   enc

*          Encrypted password.

*/

void encode(LPSTR password, LPSTR enc)

{

   int i;

   for (i = 0;i < strlen(password);i++)

   {

      password[i] ^= key1[i % KEY_SIZE];

      password[i] ^= key2[i % KEY_SIZE];

      password[i] ^= key3[i % KEY_SIZE];

      sprintf(&enc[i * 2], "%02X", password[i]);

   }

}

/**

* Decode password.

*

* @param   password

*          Encoded password.

*

* @param   dec

*          Clear text password.

*/

void decode(LPSTR password, LPSTR dec)

{

   int i;

   for (i = 0;i < strlen(password) / 2;i++)

   {

      sscanf(&password[i * 2], "%02X", (unsigned int*)&dec[i]);

      dec[i] ^= key3[i % KEY_SIZE];

      dec[i] ^= key2[i % KEY_SIZE];

      dec[i] ^= key1[i % KEY_SIZE];

   }   

}

/**

* Convert UNICODE string to ANSI string.

*

* @param   szUNICODEString

*          UNICODE string to be converted.

*

* @param   szANSIString

*          Output ANSI string. Should have enough length to store the converted string.

*

* @return  The number of bytes written to the buffer or 0 on failure.

*/

int UnicodeToAnsi(LPCWSTR szUNICODEString, LPSTR szANSIString)

{

   return WideCharToMultiByte(CP_ACP,                // ANSI code page

                              WC_COMPOSITECHECK,     // Check for accented characters

                              szUNICODEString,       // Source Unicode string

                              -1,                    // -1 means string is zero-terminated

                              szANSIString,          // Destination char string

                              MAX_SIZE,              // Size of buffer

                              NULL,                  // No default character

                              NULL );                // Don't care about this flag

}

/**

* Convert ANSI string to UNICODE string.

*

* @param   szANSIString

*          ANSI string to be converted.

*

* @param   szUNICODEString

*          Output UNICODE string. Should have enough length to store the converted string.

*

* @return  The number of bytes written to the buffer or 0 on failure.

*/

int AnsiToUnicode(LPCSTR szANSIString, LPWSTR szUNICODEString)

{

   return MultiByteToWideChar(CP_ACP,                    // ANSI code page

                              MB_COMPOSITE,              // Check for accented characters

                              szANSIString,              // Source ANSI string

                              -1,                        // -1 means string is zero-terminated

                              szUNICODEString,           // Destination char string

                              MAX_SIZE);                 // Size of buffer

}

/**

* Load Shlwapi.dll

*

* @return   TRUE  load library success.

*           FALSE error loading library.

*/

BOOL LoadShlwapi()

{

   hDllShlwapi = LoadLibraryW(L"Shlwapi.dll");

   if (hDllShlwapi)

   {

      // get functions

      _PathIsRelativeW = (fpPathIsRelativeW*) GetProcAddress(hDllShlwapi, "PathIsRelativeW");

      _PathAppendW = (fpPathAppendW*) GetProcAddress(hDllShlwapi, "PathAppendW");

   }

   return hDllShlwapi != NULL;

}

/**

* Load Userenv.dll

*

* @return   TRUE  load library success.

*           FALSE error loading library.

*/

BOOL LoadUserenv()

{

   hDllUserenv = LoadLibraryW(L"Userenv.dll");

   if (hDllUserenv)

   {

      // get functions

      _CreateEnvironmentBlock = (fpCreateEnvironmentBlock*) 

            GetProcAddress(hDllUserenv, "CreateEnvironmentBlock");

      _DestroyEnvironmentBlock = (fpDestroyEnvironmentBlock*) 

            GetProcAddress(hDllUserenv, "DestroyEnvironmentBlock");

      _GetUserProfileDirectoryW = (fpGetUserProfileDirectoryW*) 

            GetProcAddress(hDllUserenv, "GetUserProfileDirectoryW");

   }

   return hDllUserenv != NULL;

}

/**

* Clean up.

*/

void CleanUp()

{

   /* Close handles */

   CloseHandle(hToken);

   CloseHandle(pi.hProcess);

   CloseHandle(pi.hThread);

   CloseHandle(si.hStdOutput);

}

/**

* Print errors on STDERR.

*

* @param   code

*          Exit code.

* @param   method

*          Method name where error is throw.

*

* @return  Exit code

*/

int audit(int code, LPCWSTR method)

{

   fwprintf(stderr, L"Error:%d method:%ls\n", code, method);

   return code;

}

/**

* Display error messages from system to STDERR.

*

* @param   pszAPI

*          Name of the API call that generate the error.

*/

void DisplayError(LPCWSTR pszAPI)

{

   LPVOID lpvMessageBuffer;

   FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,

                  NULL,

                  GetLastError(),

                  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

                  (LPWSTR)&lpvMessageBuffer,

                  0,

                  0);

   fwprintf(stderr, L"ERROR: API        = %ls\n", pszAPI);

   fwprintf(stderr, L"       error code = %d\n", GetLastError());

   fwprintf(stderr, L"       message    = %ls", (LPWSTR)lpvMessageBuffer);

   fflush(stderr);

   LocalFree(lpvMessageBuffer);

}

/**

* Prepare a command line string from arguments.

*

* @param   argc

*          Number of command line arguments.

* @param   argv

*          Command line arguments.

*

* @return  Command line string.

*/

LPWSTR CommandLine(int argc, LPWSTR argv[])

{

   int i;

   for (i = MIN_ARGS_PASSWORD;i < argc;i++)

   {

      if (i != MIN_ARGS_PASSWORD)

      {

         wcscat(szCommandLine, L" ");

      }

      wcscat(szCommandLine, argv[i]);

   }

   return szCommandLine;

}

/**

* Prepare a command line string from arguments.

*

* @param   argc

*          Number of command line arguments.

* @param   argv

*          Command line arguments.

*

* @return  Command line string.

*/

LPWSTR CommandLineFromAnsi(int beg, int end, LPSTR argv[])

{

   int i;

   static WCHAR arg[MAX_SIZE];

   for (i = beg;i < end;i++)

   {

      if (i != beg)

      {

         wcscat(szCommandLine, L" ");

      }

      AnsiToUnicode(argv[i], arg);

      wcscat(szCommandLine, arg);

   }

   return szCommandLine;

}

/**

* Read user password from stdin.

*

* @return  User password.

*/

LPWSTR ReadPassword()

{

   return _getws(szPassword);

}

/**

* Print help.

*

* @param   pname

*          The program's name.

*/

int help(LPWSTR pname)

{

   wprintf(L"Usage:\n");

   wprintf(L"- for password authentication: %ls 1 <user> <workdir> <command> [args]\n", pname);

   wprintf(L"- for server authentication: %ls 0 <secure-port> <host> <server-alias> <uuid>\n", pname);

   return EXIT_SUCCESS;

}

/**

* Replace a placeholder within a string.

*

* @param   string

*          Original string.

* @param   placeholder

*          Placeholder string.

* @param   value

*          Replacement string value.

*

* @return  The string after placeholder was replaced.

*          If the placeholder is not found returns original string.

*/

LPWSTR replace_str(LPWSTR string, LPCWSTR placeholder, LPWSTR value)

{

   static WCHAR buffer[MAX_SIZE];

   WCHAR *p;

   int len;

   p = wcsstr(string, placeholder);

   if (!p)

   {

      // placeholder not found

      return string;

   }

   len = (p - string) / sizeof(WCHAR);

   wcsncpy(buffer, string, len); 

   buffer[len] = 0;

   swprintf(buffer + len, sizeof(buffer), L"%ls%ls", value, p + wcslen(placeholder));

   return buffer;

}

/**

* Redirect STDOUT to an output file. 

*

* @param   szWorkingDir

*          Working directory.

* @param   szOutputFile

*          The name of the file where the STDOUT is redirected.

*/

void stdout_redirect(LPWSTR szWorkingDir, LPWSTR szOutputFile)

{

   HANDLE hFile;

   WCHAR pid[32];

   /* Goto working directory */

   if (!SetCurrentDirectoryW(szWorkingDir))

   {

      DisplayError(L"SetCurrentDirectoryW");

   }

   /* convert pid to string */

   swprintf(pid, sizeof(pid), L"%lu", GetCurrentProcessId()); 

   /* replace %pid% placeholder */

   LPWSTR szFileName = replace_str(szOutputFile, L"%pid%", pid);

   SECURITY_ATTRIBUTES sa;

   sa.nLength = sizeof(sa);

   sa.lpSecurityDescriptor = NULL;

   sa.bInheritHandle = TRUE;   

   /* create file */

   hFile = CreateFileW(szFileName,                         // file name 

                       FILE_APPEND_DATA,                   // open for writing

                       FILE_SHARE_WRITE | FILE_SHARE_READ, // allow multiple readers

                       &sa,                                // security

                       OPEN_ALWAYS,                        // open or create

                       FILE_ATTRIBUTE_NORMAL,              // normal file

                       NULL);                              // no template

   /* check for errors */

   if (hFile == INVALID_HANDLE_VALUE)

   {

      DisplayError(L"CreateFileW");

   }

   else

   {

      /* redirect */

      si.hStdOutput = hFile;

      si.dwFlags |= STARTF_USESTDHANDLES;

   }

}

/**

* Spawn a child process on the current logon account.

*

* @param   szWorkingDir

*          Working directory.

* @param   szCommand

*          Command line.

*

* @return  Exit status.

*/

int spawn_nologon(LPWSTR szWorkingDir, LPWSTR szCommand)

{

   si.cb = sizeof(STARTUPINFO);

   // creating hidden console

   si.dwFlags |= STARTF_USESHOWWINDOW;

   si.wShowWindow = SW_HIDE;

   /* Redirect STDOUT if required */

   if (stdoutRedirect)

   {

      stdout_redirect(szWorkingDir, szOutputFile);

   }

   if (!CreateProcessW(NULL,             // application name

                       szCommand,        // command line

                       NULL,             // process security attributes

                       NULL,             // thread security attribute

                       TRUE,             // inherit handles

                       dwCreationFlags,  // flags

                       NULL,             // environment block

                       szWorkingDir,     // current directory

                       &si,              // startup info

                       &pi))             // process info

   {

      DisplayError(L"CreateProcessW");

      return ERR_SPAWN_CREATE_PROCESS;

   }

   return EXIT_SUCCESS;

}

/**

* Spawn a child process on an user account.

*

* @param   szUser

*          User name.

* @param   szPswd

*          Password.

* @param   szWorkingDir

*          Working directory.

* @param   szCommand

*          Command line.

*

* @return  Exit status.

*/

int spawn_logon(LPWSTR szUser, LPWSTR szPswd, LPWSTR szWorkingDir, LPWSTR szCommand)

{

   DWORD dwSize;

   si.cb = sizeof(STARTUPINFO);

   // creating hidden console

   si.dwFlags |= STARTF_USESHOWWINDOW;

   si.wShowWindow = SW_HIDE;

   /* Attempts to log a user on to the local computer. */

   if (!LogonUserW(szUser,

                   NULL,

                   szPswd,

                   LOGON32_LOGON_INTERACTIVE,

                   LOGON32_PROVIDER_DEFAULT,

                   &hToken))

   {

      DisplayError(L"LogonUser");

      return ERR_SPAWN_LOGON_USER;

   }

   /* Retrieves the environment variables for the specified user. */

   if (!_CreateEnvironmentBlock(&lpvEnv, hToken, TRUE))

   {

      DisplayError(L"CreateEnvironmentBlock");

      return ERR_SPAWN_CREATE_ENVIRONMENT;

   }

   /* Retrieves the path to the root directory of the specified user's profile. */

   dwSize = sizeof(szUserProfile) / sizeof(WCHAR);

   if (!_GetUserProfileDirectoryW(hToken, szUserProfile, &dwSize))

   {

      DisplayError(L"GetUserProfileDirectory");

      // clean up enviromnent block on exit

      _DestroyEnvironmentBlock(lpvEnv);

      return ERR_SPAWN_GET_USER_PROFILE;

   }

   /* If relative path to user profile root directory */

   if (_PathIsRelativeW(szWorkingDir))

   {

      if (!_PathAppendW(szUserProfile, szWorkingDir))

      {

         DisplayError(L"PathAppend");

         // clean up enviromnent block on exit

         _DestroyEnvironmentBlock(lpvEnv);

         return ERR_SPAWN_WORKING_DIRECTORY;

      }

      szWorkingDir = szUserProfile;

   }

   /* Redirect STDOUT if required */

   if (stdoutRedirect)

   {

      stdout_redirect(szWorkingDir, szOutputFile);

   }

   fwprintf(stderr, L"Username: %s\n", szUser);

   fwprintf(stderr, L"Password: %s\n", szPswd);

   fwprintf(stderr, L"Command: %s\n", szCommand);

   fwprintf(stderr, L"Working directory: %s\n", szWorkingDir);

   /* Creates a new process and its primary thread.

      Then the new process runs the specified executable file in the security context

      of the specified credentials (user, domain, and password).

      It can optionally load the user profile for a specified user. */

   if (!CreateProcessWithLogonW((LPCWSTR)szUser,       // user name

                                NULL,                  // domain

                                (LPCWSTR)szPswd,       // password

                                LOGON_WITH_PROFILE,    // logon options

                                NULL,                  // application name

                                (LPWSTR)szCommand,     // command line

                                dwCreationFlags,       // flags

                                (LPVOID)lpvEnv,        // environment block

                                (LPCWSTR)szWorkingDir, // current directory

                                &si,                   // startup info

                                &pi))                  // process info

   {

      DisplayError(L"CreateProcessWithLogonW");

      // clean up enviromnent block on exit

      _DestroyEnvironmentBlock(lpvEnv);

      return ERR_SPAWN_CREATE_PROCESS;

   }

   // clean up enviromnent block on exit

   _DestroyEnvironmentBlock(lpvEnv);

   return EXIT_SUCCESS;

}

/**

* Check if provided user name match current account user name.

*

* @param   szUserName

*          User name.

*

* @return  1 - Account user name match.

*          0 - Account user name does not match.

*/

int check_user(LPWSTR szUserName)

{

   WCHAR szAccountUserName[MAX_SIZE]; 

   DWORD nSize = MAX_SIZE;

   int result = 0;

   if (GetUserNameW(szAccountUserName, &nSize))

   {

      result = wcscmp(szAccountUserName, szUserName) == 0;

      if (!result)

      {

         fwprintf(stderr, 

                  L"User name [%ls] does not match [%ls].\n", 

                  szUserName, 

                  szAccountUserName);

      }

   }

   else

   {   

      DisplayError(L"GetUserNameW");

   }

   return result;

}

/**

* Launch an in-process JVM and connects to the specified server. Authentication is assumed passed

* only if a secure connection can be establiashed with the server and the server's certificate  

* matches one from the store.

* <p>

* If authentication passes, starts a new process with the real command.

*

* @param   cport

*          The P2J server's port.

* @param   chost

*          The P2J server's host.

* @param   calias

*          The certificate alias for the P2J server.

* @param   uuid

*          Unique identifier for this request; must be known by the target P2J server.

*/

int launchP2JClient(LPSTR cport, LPSTR chost, LPSTR calias, LPSTR cuuid)

{

   JavaVM *jvm;

   JNIEnv *env;

   int nopts;

   JavaVMOption options[9];

   options[0].optionString = "-Djava.class.path=./p2j.jar;.";

   options[1].optionString = "-Djava.lib.path=.";

   options[2].optionString = "-Xmx512m";

   options[3].optionString = "-Djava.awt.headless=true";

   options[4].optionString = "-Djava.compiler=NONE";

   nopts = 5;

   if (DEBUG_JVM)

   {

      options[5].optionString = "-Xdebug";

      options[6].optionString = "-Xnoagent";

      options[7].optionString = "-Xrunjdwp:transport=dt_socket,address=2999,server=y,suspend=y";

      nopts = 8;

   }

   JavaVMInitArgs vm_args; /* VM initialization arguments */

   vm_args.version   = JNI_VERSION_1_6;

   vm_args.nOptions  = nopts;

   vm_args.options   = options;

   vm_args.ignoreUnrecognized = 0;

   jint err = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);

   if (err != JNI_OK)

   {

      return(audit(ERR_JNI_JVM_CREATE, L"JNI_CreateJavaVM"));

   }

   jclass cls = (*env)->FindClass(env, "com/goldencode/p2j/main/NativeSecureConnection");

   if (cls == NULL)

   {

      (*jvm)->DestroyJavaVM(jvm);

      return(audit(ERR_JNI_P2J_ENTRY_POINT_CLASS, L"FindClass(NativeSecureConnection)"));

   }

   char *signature = "(ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Ljava/lang/String;";

   jmethodID mid = (*env)->GetStaticMethodID(env, cls, "command", signature);

   if (mid == NULL)

   {

      (*jvm)->DestroyJavaVM(jvm);

      return(audit(ERR_JNI_P2J_ENTRY_POINT_METHOD, L"GetStaticMethodID(command)"));

   }

   int port = atoi(cport);

   jstring host = (*env)->NewStringUTF(env, chost);

   if (host == NULL)

   {

      (*jvm)->DestroyJavaVM(jvm);

      return(audit(ERR_JNI_REMOTE_SERVER_HOST, L"NewStringUTF(host)"));

   }

   jstring alias = (*env)->NewStringUTF(env, calias);

   if (alias == NULL)

   {

      (*jvm)->DestroyJavaVM(jvm);

      return(audit(ERR_JNI_REMOTE_SERVER_ALIAS, L"NewStringUTF(alias)"));

   }

   jstring uuid = (*env)->NewStringUTF(env, cuuid);

   if (uuid == NULL)

   {

      (*jvm)->DestroyJavaVM(jvm);

      return(audit(ERR_JNI_REMOTE_SERVER_UUID, L"NewStringUTF(uuid)"));

   }

   jobjectArray command = (*env)->CallStaticObjectMethod(env, (jclass) cls, (jmethodID) mid,

                                                    port, host, alias, uuid);

   if (command == NULL)

   {

      (*jvm)->DestroyJavaVM(jvm);

      return(audit(ERR_JNI_REMOTE_COMMAND, L"CallStaticObjectMethod(command)"));

   }

   /* extract the arguments */

   jsize jlength = (*env)->GetArrayLength(env, (jarray) command);

   int length = (int) jlength;

   /* make it 1-based, so it follows the structure of the command line arguments 

      (0 is program name); also, one more position is needed for execvp, which requires for the

      arguments to be null-terminated. */

   char **arguments = (char**) malloc((length + 2) * sizeof(char*));

   arguments[0] = NULL;

   arguments[length + 1] = NULL;

   int i;

   for (i = 0; i < (int) length; i++)

   {

      jstring jarg = (jstring) (*env)->GetObjectArrayElement(env, command, (jsize) i);

      jsize argLength = (*env)->GetStringUTFLength(env, jarg);

      const char *narg = (*env)->GetStringUTFChars(env, jarg, 0);

      int nlength = (int) argLength + 1;

      arguments[i + 1] = (char*) malloc(nlength * sizeof(char));

      memset(arguments[i + 1], '\0', nlength);

      strcpy(arguments[i + 1], narg);

      (*env)->ReleaseStringUTFChars(env, jarg, narg);

   }

   err = (*jvm)->DestroyJavaVM(jvm);

   if (err < 0)

   {

      return(audit(ERR_JNI_JVM_DESTROY, L"DestroyJavaVM"));

   }

   if (length < MIN_ARGS_COMMAND)

   {

      help(L"");

      return(ERR_SPAWN_NO_ARGS);

   }

   static WCHAR szWorkingDir[MAX_SIZE]; 

   static WCHAR szUserName[MAX_SIZE]; 

   static WCHAR szPassword[MAX_SIZE]; 

   /* Working directory */

   AnsiToUnicode(arguments[MIN_ARGS_COMMAND - 1], szWorkingDir);      

   /* Command line */

   LPWSTR szCommand = CommandLineFromAnsi(MIN_ARGS_COMMAND, length + 1, arguments);

   /* User name */

   AnsiToUnicode(arguments[1], szUserName);      

   // spawn

   if (strcmp(arguments[2], "\"\"") == 0)

   {

      // check if user name match current user name

      if (check_user(szUserName))

      {

         // spawn on server account

         return spawn_nologon(szWorkingDir, szCommand);

      }

      else

      {

         return AUTH_ERR_USER;

      }

   }

   else

   {

      if (enabled)

      {

         static CHAR password[MAX_SIZE]; 

         // decode password

         decode(arguments[2], password);

         // transform

         AnsiToUnicode(password, szPassword);

      }

      else

      {

         AnsiToUnicode(arguments[2], szPassword);

      }

      // spawn on user account

      return spawn_logon(szUserName, szPassword, szWorkingDir, szCommand);      

   }      

}

/**

* Main function.

* MinGW does not support UNICODE wmain function.

* A main function is used as a wrapper for wmain.

*

* @param   argc

*          Number of command line arguments.

* @param   argv

*          Command line arguments.

*

* @return  Exit status.

*/

int wmain(int argc, LPWSTR argv[])

{

   int result = EXIT_SUCCESS, i;

   /* Load configurations from spawn.ini file */

   init();

   /* Print a short help */

   if (argc == 1)

   {

      help(argv[0]);

      return(ERR_SPAWN_NO_ARGS);

   }

   if (wcscmp(argv[1], L"1") == 0)

   {  

      /* Check args */

      if(argc < MIN_ARGS_PASSWORD)

      {

         help(argv[0]);

         return ERR_SPAWN_NO_ARGS;

      }

      /* Get user password */

      LPWSTR szPswd = ReadPassword();

      /* Build command line */

      LPWSTR szCommand = CommandLine(argc, argv);

      /* Spawn */

      result = spawn_logon(argv[2], szPswd, argv[3], szCommand);

      /* Clear password */

      SecureZeroMemory(szPswd, wcslen(szPswd));

   }

   else if (wcscmp(argv[1], L"0") == 0)

   {      

      /* Could start with no window */

      dwCreationFlags |= CREATE_NO_WINDOW;  // flag ignored if the application is is used with CREATE_NEW_CONSOLE.

      if (argc < MIN_ARGS_NO_PASSWORD)

      {

         help(argv[0]);

         return(ERR_SPAWN_NO_ARGS);

      }

      /* Search for optional parameters */

      for (i = MIN_ARGS_NO_PASSWORD; i < argc; i++)

      {

         /* -O <outputToFile> */

         if ((wcscmp(L"-O", argv[i]) == 0) && (++i < argc))

         {

            wcscpy(szOutputFile, argv[i]);

            stdoutRedirect = 1; // restored redirection mode

         }

      }

      static CHAR port[MAX_SIZE]; 

      static CHAR host[MAX_SIZE]; 

      static CHAR alias[MAX_SIZE]; 

      static CHAR uuid[MAX_SIZE]; 

      UnicodeToAnsi(argv[2], port);

      UnicodeToAnsi(argv[3], host);

      UnicodeToAnsi(argv[4], alias);

      UnicodeToAnsi(argv[5], uuid);

      result = launchP2JClient(port, host, alias, uuid);

   }

   else if (wcscmp(argv[1], L"9") == 0)

   { 

      if (argc == 3)

      {

         if (enabled)

         {

            static CHAR password[MAX_SIZE]; 

            UnicodeToAnsi(argv[2], password);

            // encode password

            static CHAR encoded[MAX_SIZE]; 

            encode(password, encoded);

            // print encoded password

            puts(encoded);

         }

         else

         {

            fwprintf(stderr, L"Encryption is disabled.\n");

         }

      }

   }

   else

   {

      help(argv[0]);

      return ERR_SPAWN_NO_ARGS;

   }

   return result;

}

/**

 * This is for the MinGW compiler which does not support wmain.

 * It is a wrapper for _tmain when _UNICODE is defined (wmain).

 * This wrapper adds ~300 bytes to the program and negligible overhead.

 */

#undef _tmain

#ifdef _UNICODE

#define _tmain wmain

#else

#define _tmain main

#endif

#if defined(__GNUC__) && defined(_UNICODE)

#ifndef __MSVCRT__

#error Unicode main function requires linking to MSVCRT

#endif

extern int _CRT_glob;

extern

#ifdef __cplusplus

"C"

#endif

void __wgetmainargs(int*, LPWSTR**, LPWSTR**, int, int*);

int main() 

{

   LPWSTR *enpv, *argv;

   int argc, mode, result;

   // this also creates the global variable __wargv

   __wgetmainargs(&argc, &argv, &enpv, _CRT_glob, &mode); 

   /* Load DLL libraries. */

   if (!LoadShlwapi() || !LoadUserenv())

   {

      DisplayError(L"LoadLibraryW");

      return ERR_SPAWN_LOAD_LIBRARIES;

   }

   else

   {

#ifdef MAIN_USE_ENVP

      result = wmain(argc, argv, enpv);

#else

      result = wmain(argc, argv);

#endif

      /* Close handles */

      CleanUp();

      /* Unload Shlwapi.dll */

      if (!hDllShlwapi)

      {

         FreeLibrary(hDllShlwapi);

      }

      /* Unload Userenv.dll */   

      if (!hDllUserenv)

      {

         FreeLibrary(hDllUserenv);

      }

      /* flush log */

      fflush(stderr);

      /* Exit */

      return result;

   }

}

#endif //defined(__GNUC__) && defined(_UNICODE)