#!/bin/env python

 # -*- coding: utf-8 -*-

 # ------------------------------------------------------------

 # cygwin command

 # 

 # executes a cygwin command inside the opensecurity project

 #

 # Autor: Mihai Bartha, <mihai.bartha@ait.ac.at>

 #        Oliver Maurhart, <oliver.maurhart@ait.ac.at>

 #

 # Copyright (C) 2013 AIT Austrian Institute of Technology

 # AIT Austrian Institute of Technology GmbH

 # Donau-City-Strasse 1 | 1220 Vienna | Austria

 # http://www.ait.ac.at

 #

 # This program is free software; you can redistribute it and/or

 # modify it under the terms of the GNU General Public License

 # as published by the Free Software Foundation version 2.

 # 

 # 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 General Public License for more details.

 # 

 # You should have received a copy of the GNU General Public License

 # along with this program; if not, write to the Free Software

 # Foundation, Inc., 51 Franklin Street, Fifth Floor, 

 # Boston, MA  02110-1301, USA.

 # ------------------------------------------------------------

 # ------------------------------------------------------------

 # imports

 import os

 import subprocess

 import sys

 import _winreg

 from subprocess import Popen, PIPE, STARTUPINFO, _subprocess

 import threading

 # local

 from environment import Environment

 from opensecurity_util import logger, setupLogger, OpenSecurityException

 import time

 # ------------------------------------------------------------

 # code

 def once(theClass):

     """get the path to our local cygwin installment"""

     home_drive = os.path.expandvars("%HOMEDRIVE%") + os.sep

     e = Environment('OpenSecurity')

     path_hint = [ 

         os.path.abspath(os.path.join(e.prefix_path, 'cygwin')), 

         os.path.abspath(os.path.join(e.prefix_path, 'cygwin64')), 

         os.path.abspath(os.path.join(home_drive, 'cygwin')),

         os.path.abspath(os.path.join(home_drive, 'cygwin64'))

     ]

     path_valid = [ p for p in path_hint if os.path.exists(p) ]

     theClass.cygwin_root = path_valid[0]

     theClass.cygwin_bin = os.path.join(theClass.cygwin_root, 'bin') + os.path.sep

     theClass.cygwin_bash = os.path.join(theClass.cygwin_bin, 'bash.exe')

     theClass.cygwin_ssh = os.path.join(theClass.cygwin_bin, 'ssh.exe')

     theClass.cygwin_scp = os.path.join(theClass.cygwin_bin, 'scp.exe')

     theClass.cygwin_x11 = os.path.join(theClass.cygwin_bin, 'XWin.exe')

     theClass.win_cmd = os.environ.get("COMSPEC", "cmd.exe") 

     """get the path to the VirtualBox installation on this system"""

     theClass.vbox_root = theClass.getRegEntry('SOFTWARE\Oracle\VirtualBox', 'InstallDir')[0]  

     theClass.vbox_man = os.path.join(theClass.vbox_root, 'VBoxManage.exe')

     #theClass.user_home = os.path.expanduser("~")

     theClass.user_home = os.environ['APPDATA']#os.path.expandvars("%APPDATA%")

     theClass.allow_exec = True 

     return theClass

 @once

 class Cygwin(object):

     cygwin_root = ''

     cygwin_bin = ''

     cygwin_bash = ''

     cygwin_ssh = ''

     cygwin_x11 = ''

     cygwin_scp = ''

     vbox_root = ''

     vbox_man = ''

     win_cmd = ''

     user_home = ''

     allow_exec = True 

     """Some nifty methods working with Cygwin"""

     def __call__(self, command, arguments, wait_return=True, window = False):

         """make an instance of this object act as a function"""

         return self.execute(command, arguments, wait_return, window)

     @staticmethod

     def getRegEntry(key, value):

         try:

             k = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, key)

             value = _winreg.QueryValueEx(k, value)

             _winreg.CloseKey(k)

             return value

         except:

             pass

     @staticmethod

     def root():

         return Cygwin.cygwin_root

     @staticmethod

     def bin():

         return Cygwin.cygwin_bin

     @staticmethod

     def bash():

         return Cygwin.cygwin_bash

     @staticmethod    

     def ssh():

         return Cygwin.cygwin_ssh

     @staticmethod    

     def scp():

         return Cygwin.cygwin_scp

     @staticmethod    

     def x11():

         return Cygwin.cygwin_x11

     @staticmethod

     def vboxman():

         return Cygwin.vbox_man

     @staticmethod

     def cmd():

         return Cygwin.win_cmd

     @staticmethod

     def home():

         return Cygwin.user_home

     @staticmethod

     def allowExec():

         Cygwin.allow_exec = True

     @staticmethod

     def denyExec():

         Cygwin.allow_exec = False

     executeLock = threading.Lock()

     #executes command on host system

     @staticmethod

     def execute(program, arguments, wait_return=True, window = False, stdin = PIPE, stdout = PIPE, stderr = PIPE):

         if not Cygwin.allow_exec:

             logger.error('Execution cancelled by system (shutting down).')

             raise OpenSecurityException('Execution cancelled by system (shutting down).')

         _startupinfo = STARTUPINFO()

         if not window:

             _startupinfo.dwFlags |= _subprocess.STARTF_USESHOWWINDOW

             _startupinfo.wShowWindow = _subprocess.SW_HIDE

             #logger.debug('trying to launch: ' + program + ' ' + ''.join(arguments))

         result, res_stdout, res_stderr = None, None, None

         try:

             # quote the executable otherwise we run into troubles

             # when the path contains spaces and additional arguments

             # are presented as well.

             # special: invoking bash as login shell here with

             # an unquoted command does not execute /etc/profile

             args = '"' + program + '" ' + arguments

             logger.debug('Launching: ' + program + ' ' + ''.join(arguments))

             process = Popen(args, startupinfo = _startupinfo, stdin = stdin, stdout = stdout, stderr = stderr, shell = False)

             if not wait_return:

                 return [0, 'working in background', '']

             res_stdout, res_stderr = process.communicate()

             result = process.returncode

             logger.debug('Finished: ' + program + ' ' + ''.join(arguments))

         except Exception as ex:

             res_stderr = ''.join(str(ex.args))

             result = 1 

         if result != 0:

             logger.error('Command failed:' + ''.join(res_stderr))

             raise OpenSecurityException('Command failed:' + ''.join(res_stderr))

         return result, res_stdout, res_stderr

     @staticmethod

     def vboxExecute(command, wait_return=True, window = False, bash_opts='', try_count = 3):

         retry = 0

         result = None

         while retry < try_count:

             if Cygwin.executeLock.acquire(True):

                 try:

                     result = Cygwin.execute(Cygwin.vbox_man, command, wait_return, window)

                 except Exception as ex:

                     Cygwin.executeLock.release()

                     if (retry+1) == try_count:

                         raise ex

                 else:

                     Cygwin.executeLock.release()

                     return result

             retry+=1

         raise OpenSecurityException('Command max retry reached: ' + ''.join(command))

     @staticmethod

     def bashExecute(command, wait_return=True, window = False, bash_opts='', stdin = PIPE, stdout = PIPE, stderr = PIPE):

         # for some reason, the '-l' is ignored when started via python

         # so the same behavior is triggered by calling /etc/profile 

         # directly

         command = bash_opts + ' -l -c "'  + command + '"'

         return Cygwin.execute(Cygwin.cygwin_bash, command, wait_return, window, stdin = stdin, stdout = stdout, stderr = stderr)

     @staticmethod

     def cmdExecute(command, wait_return=True, window = False):

         command = ' /c ' + command 

         return Cygwin.execute(Cygwin.win_cmd, command, wait_return, window)

     # executes command over ssh on guest vm

     @staticmethod

     def sshExecute(command, address, user_name, certificate, wait_return=True, window = False):

         if command == None or address == None or user_name == None or certificate == None:

             raise OpenSecurityException('Invalid parameter value')

         command = ' -v -o StrictHostKeyChecking=no -i "' + certificate + '" ' + user_name + '@' + address + ' ' + command        

         return Cygwin.execute(Cygwin.cygwin_ssh, command, wait_return, window)

     # executes command over ssh on guest vm

     @staticmethod

     def sshBackgroundExecute(command, address, user_name, certificate, wait_return=True, window = False):

         command = ' -f -v -o StrictHostKeyChecking=no -i "' + certificate + '" ' + user_name + '@' + address + ' ' + command        

         return Cygwin.execute(Cygwin.cygwin_ssh, command, wait_return, window)

     #machineFolder + '/' + vm_name + '/dvm_key

     #address = self.getHostOnlyIP(vm_name)

     #machineFolder = self.getDefaultMachineFolder()

     #machineFolder = Cygwin.cygwinPath(machineFolder)

     # executes command over ssh on guest vm with X forwarding

     @staticmethod

     def sshExecuteX11(command, address, user_name, certificate, wait_return=True):

         return Cygwin.bashExecute('DISPLAY=:0.0 ssh -Y -o StrictHostKeyChecking=no -i \\\"' + certificate +'\\\" ' + user_name + '@' + address + ' ' + command + '')

     @staticmethod

     def is_X11_running():

         """check if we can connect to a X11 running instance"""

         p = Cygwin.bashExecute('xset -display :0 q', wait_return = True, window = False) 

         return p[0] == 0

     @staticmethod

     def start_X11():

         """start X11 in the background (if not already running) on DISPLAY=:0

         If there is already a X11 running then exit silently, calling this

         method as often as needed.

         """

         Popen('"' + Cygwin.cygwin_x11 + '" :0 -multiwindow -resize -silent-dup-error')

         return (0, None, None)

     @staticmethod    

     def cygPath(path):

         cmd = 'cygpath -u \'' + path + '\''

         return Cygwin.bashExecute(cmd)[1].rstrip('\n')

 # start

 import os

 import win32api

 import win32con

 import win32security

 if __name__ == "__main__":

     logger = setupLogger('Cygwin')

     c = Cygwin()

     logger.info(c.root())

     logger.info(c.bin())

     logger.info(c.bash())

     logger.info(c.ssh())

     logger.info(c.x11())

     logger.info(c.home())   

     #PSEXEC -i -s -d CMD

     #tasklist /v /fo list /fi "IMAGENAME eq explorer.exe"

     #runner = XRunner()

     #runner.start()

     #Cygwin.start_X11()

     #time.sleep(500)

     #Cygwin.start_X11()

     #print (Cygwin.is_X11_running())

     #print (Cygwin.is_X11_running())

     #new_sdvm = 'SecurityDVM0'

     #new_ip = Cygwin.vboxExecute('guestproperty get ' + new_sdvm + ' /VirtualBox/GuestInfo/Net/0/V4/IP')[1]

     #new_ip = new_ip[new_ip.index(':')+1:].strip()

     #new_ip = '+'

     #result = Cygwin.bashExecute('DISPLAY=:0.0 xhost '+new_ip)

     #browser = '/usr/bin/midori '

     #print(Cygwin.sshExecuteX11(browser, new_ip, 'osecuser', '/cygdrive/c/Users/BarthaM/VirtualBox VMs' + '/' + new_sdvm + '/dvm_key'))

     #print(Cygwin.bashExecute('echo $PATH')[1])

     #print(Cygwin.cygPath('C:'))

     #print('C:\\Program Files\\OpenSecurity: ' + c.cygPath('C:\\Program Files\\OpenSecurity'))

     sys.exit(0)