#!/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 2013-2014 X-Net and AIT Austrian Institute of Technology

# 

# 

#     X-Net Services GmbH

#     Elisabethstrasse 1

#     4020 Linz

#     AUSTRIA

#     https://www.x-net.at

# 

#     AIT Austrian Institute of Technology

#     Donau City Strasse 1

#     1220 Wien

#     AUSTRIA

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

# 

# 

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

# 

#    http://www.apache.org/licenses/LICENSE-2.0

# 

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

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

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

# 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_rsync = os.path.join(theClass.cygwin_bin, 'rsync.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 = ''

    cygwin_rsync = ''

    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 rsync():

        return Cygwin.cygwin_rsync

    @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)