opensecurity: OpenSecurity/bin/cygwin.py@327f282364b9

     1 #!/bin/env python

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

     4 # ------------------------------------------------------------

     5 # cygwin command

6 #

     7 # executes a cygwin command inside the opensecurity project

8 #

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

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

    11 #

    12 # Copyright (C) 2013 AIT Austrian Institute of Technology

    13 # AIT Austrian Institute of Technology GmbH

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

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

    16 #

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

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

    19 # as published by the Free Software Foundation version 2.

    20 #

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

    22 # but WITHOUT ANY WARRANTY; without even the implied warranty of

    23 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    24 # GNU General Public License for more details.

    25 #

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

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

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

    29 # Boston, MA  02110-1301, USA.

    30 # ------------------------------------------------------------

    33 # ------------------------------------------------------------

    34 # imports

    36 import os

    37 import subprocess

    38 import sys

    39 import _winreg

    40 from subprocess import Popen, PIPE, STARTUPINFO, _subprocess

    41 import threading

    43 # local

    44 from environment import Environment

    45 from opensecurity_util import logger, setupLogger, OpenSecurityException

    46 import time

    49 # ------------------------------------------------------------

    50 # code

    52 def once(theClass):

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

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

    55     e = Environment('OpenSecurity')

    56     path_hint = [

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

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

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

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

    61     ]

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

    63     theClass.cygwin_root = path_valid[0]

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

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

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

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

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

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

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

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

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

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

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

    75     return theClass

    78 @once

    79 class Cygwin(object):

    80     cygwin_root = ''

    81     cygwin_bin = ''

    82     cygwin_bash = ''

    83     cygwin_ssh = ''

    84     cygwin_x11 = ''

    85     cygwin_scp = ''

    86     vbox_root = ''

    87     vbox_man = ''

    88     win_cmd = ''

    89     user_home = ''

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

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

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

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

    96     @staticmethod

    97     def getRegEntry(key, value):

    98         try:

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

   100             value = _winreg.QueryValueEx(k, value)

   101             _winreg.CloseKey(k)

   102             return value

   103         except:

   104             pass

   107     @staticmethod

   108     def root():

   109         return Cygwin.cygwin_root

   111     @staticmethod

   112     def bin():

   113         return Cygwin.cygwin_bin

   115     @staticmethod

   116     def bash():

   117         return Cygwin.cygwin_bash

   119     @staticmethod

   120     def ssh():

   121         return Cygwin.cygwin_ssh

   123     @staticmethod

   124     def scp():

   125         return Cygwin.cygwin_scp

   127     @staticmethod

   128     def x11():

   129         return Cygwin.cygwin_x11

   131     @staticmethod

   132     def vboxman():

   133         return Cygwin.vbox_man

   135     @staticmethod

   136     def cmd():

   137         return Cygwin.win_cmd

   139     @staticmethod

   140     def home():

   141         return Cygwin.user_home

   143     executeLock = threading.Lock()

   144     #executes command on host system

   145     @staticmethod

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

   147         _startupinfo = STARTUPINFO()

   148         if not window:

   149             _startupinfo.dwFlags |= _subprocess.STARTF_USESHOWWINDOW

   150             _startupinfo.wShowWindow = _subprocess.SW_HIDE

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

   153         result, res_stdout, res_stderr = None, None, None

   154         try:

   155             # quote the executable otherwise we run into troubles

   156             # when the path contains spaces and additional arguments

   157             # are presented as well.

   158             # special: invoking bash as login shell here with

   159             # an unquoted command does not execute /etc/profile

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

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

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

   163             if not wait_return:

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

   166             res_stdout, res_stderr = process.communicate()

   167             result = process.returncode

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

   170         except Exception as ex:

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

   172             result = 1

   174         if result != 0:

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

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

   178         return result, res_stdout, res_stderr

   180     @staticmethod

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

   182         retry = 0

   183         result = None

   184         while retry < try_count:

   185             if Cygwin.executeLock.acquire(True):

   186                 try:

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

   188                 except Exception as ex:

   189                     Cygwin.executeLock.release()

   190                     if (retry+1) == try_count:

   191                         raise ex

   192                 else:

   193                     Cygwin.executeLock.release()

   194                     return result

   195             retry+=1

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

   199     @staticmethod

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

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

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

   203         # directly

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

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

   207     @staticmethod

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

   209         command = ' /c ' + command

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

   212     # executes command over ssh on guest vm

   213     @staticmethod

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

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

   216             raise OpenSecurityException('Invalid parameter value')

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

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

   220     # executes command over ssh on guest vm

   221     @staticmethod

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

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

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

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

   227     #address = self.getHostOnlyIP(vm_name)

   228     #machineFolder = self.getDefaultMachineFolder()

   229     #machineFolder = Cygwin.cygwinPath(machineFolder)

   231     # executes command over ssh on guest vm with X forwarding

   232     @staticmethod

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

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

   236     @staticmethod

   237     def is_X11_running():

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

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

   240         return p[0] == 0

   242     @staticmethod

   243     def start_X11():

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

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

   247         method as often as needed.

   248         """

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

   250         return (0, None, None)

   252     @staticmethod

   253     def cygPath(path):

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

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

   257     @staticmethod

   258     def checkResult(result):

   259         #if result[0] != 0:

   260         #    logger.error('Command failed:' + ''.join(result[2]))

   261         #    raise OpenSecurityException('Command failed:' + ''.join(result[2]))

   262         return result

   264 # start

   265 import os

   266 import win32api

   267 import win32con

   268 import win32security

   270 if __name__ == "__main__":

   271     logger = setupLogger('Cygwin')

   272     c = Cygwin()

   273     logger.info(c.root())

   274     logger.info(c.bin())

   275     logger.info(c.bash())

   276     logger.info(c.ssh())

   277     logger.info(c.x11())

   278     logger.info(c.home())

   280     #PSEXEC -i -s -d CMD

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

   283     #runner = XRunner()

   284     #runner.start()

   286     #Cygwin.start_X11()

   288     #time.sleep(500)

   290     #Cygwin.start_X11()

   291     #print (Cygwin.is_X11_running())

   292     #print (Cygwin.is_X11_running())

   293     #new_sdvm = 'SecurityDVM0'

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

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

   296     #new_ip = '+'

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

   298     #browser = '/usr/bin/midori '

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

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

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

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

   305     sys.exit(0)

author	BarthaM@N3SIM1218.D03.arc.local
	Fri, 22 Aug 2014 09:35:02 +0100
changeset 218	327f282364b9
parent 212	59ebaa44c12c
child 219	9480e5ba1a82
permissions	-rwxr-xr-x