コード例 #1
0
ファイル: qapi.py プロジェクト: nima/insecurity
    def __init__(self, username, realm_id, config, debug=False):
        self._version = QAPI_VERSION
        self._cookiejar = CookieJar()
        self._username = username
        self._realm_id = realm_id
        self._profile = '@'.join((username, realm_id))
        self._realm = REALMS[self._realm_id]
        self._proxy = None
        self._templates = None
        self._debug = debug
        self._config = None #. User configuration file for scripted mode
        self._connected = False
        self._username = '******'
        self._cFM = None
        try:
            from ConfigFileManager import ConfigFileManager, InternalConfigError
            try:
                self._config = ConfigFileManager(config)
                self._qapi_ini = self._config.option('qapi', 'ini')
                self._cFM = ConfigFileManager(self._qapi_ini)
            except InternalConfigError as e:
                raise Exception("Sorry, %s" % e)
        except ImportError as e:
            raise Exception("Sorry, %s" % e)

        urllib2.install_opener(self._opener())
コード例 #2
0
    def test_property_gameNumber_getter_and_setter(self):
        cf = CF()
        gameNumber = cf.gameNumber
        # verify getter returns an int
        self.assertIsInstance(gameNumber, int,
                              "gameNumber getter should return an int")

        # increment gameNumber and save to the config file
        cf.gameNumber = gameNumber + 1
        self.assertEqual(
            cf.gameNumber, gameNumber + 1,
            "gameNumber setter expected {}, but got {}".format(
                gameNumber + 1, cf.gameNumber))
コード例 #3
0
 def new_event(self, button):
     """ Adds a new row to the bottom of the array / Grid """  
     now = datetime.now();      
     self.config.events.append([
         ConfigFileManager.get_new_id(),
         True,
         '',
         False,
         now.year,
         now.month,
         now.day,
         8,
         30,
         0,
         False,
         '',
         'Yearly',
         True,
         'Green',
         0,
         0,
         0,
         15,
         0,
         0
     ])        
     self.treeview.set_cursor(len(self.config.events) - 1, self.treeview.get_column(0), True)
     self.set_size_request(-1, 150 + len(self.config.events) * 20 )
コード例 #4
0
 def new_feed(self, button):
     """ Adds a new row to the bottom of the array / Grid """
     self.config.feeds.append([
         ConfigFileManager.get_new_id(), True, "http://", "", True, 5,
         False, False
     ])
     self.treeview.set_cursor(
         len(self.config.feeds) - 1, self.treeview.get_column(0), True)
     self.set_size_request(-1, 150 + len(self.config.feeds) * 20)
コード例 #5
0
ファイル: shutdown.py プロジェクト: davidbjanes/jarvis
def shutdown(error_code = 0):

	# Initialize Configuration File
	configFile = ConfigFileManager(CONFIG_FILE_PATH)

	configFile.update("Program", "instance_ID", "NaN")
	configFile.update("Program", "status", STATE_OFF)
	configFile.update("Program", "error_code", error_code)
コード例 #6
0
ファイル: View.py プロジェクト: mellertson/BlackJackSimulator
    def main(cls):
        """
        Get the game number from ConfigFileManager.
        Begin main loop
            Instantiate Game object, passing it the game number.
            Execute Game.run() method
            If Game.run() returns 1, continue loop. Else, exit the program
        :return: none
        :rtype None:
        """
        rCode = Game.NEW_GAME
        while rCode == Game.NEW_GAME:
            cf = ConfigFileManager()
            game = Game(cf.gameNumber)
            rCode = game.run()

            # increment the game number in the config file
            if rCode == Game.QUIT_GAME:
                cf.gameNumber += 1

        return Game.QUIT_GAME
コード例 #7
0
ファイル: qapi.py プロジェクト: nima/insecurity
class QualysGuard:
    def __init__(self, username, realm_id, config, debug=False):
        self._version = QAPI_VERSION
        self._cookiejar = CookieJar()
        self._username = username
        self._realm_id = realm_id
        self._profile = '@'.join((username, realm_id))
        self._realm = REALMS[self._realm_id]
        self._proxy = None
        self._templates = None
        self._debug = debug
        self._config = None #. User configuration file for scripted mode
        self._connected = False
        self._username = '******'
        self._cFM = None
        try:
            from ConfigFileManager import ConfigFileManager, InternalConfigError
            try:
                self._config = ConfigFileManager(config)
                self._qapi_ini = self._config.option('qapi', 'ini')
                self._cFM = ConfigFileManager(self._qapi_ini)
            except InternalConfigError as e:
                raise Exception("Sorry, %s" % e)
        except ImportError as e:
            raise Exception("Sorry, %s" % e)

        urllib2.install_opener(self._opener())

    def __del__(self):
        self.logout()

    def __repr__(self):
        return "<QualysGuard conn:%s user:%s>" % (
            self._connected,
            self._username
        )

    def _opener(self):
        ntlm = False
        proxy = False
        if 'proxy' in self._config.sections():
            try:
                self._proxy = {
                    'proto'   : self._config.option('proxy', 'proto'),
                    'host'    : self._config.option('proxy', 'host'),
                    'port'    : int(self._config.option('proxy', 'port', 8080)),
                    'user'    : self._config.option('proxy', 'user', None),
                    'pass'    : self._config.option('proxy', 'pass', None),
                }
                if self._proxy['user'] is not None:
                    ntlm = self._proxy['user'].count('\\') == 1

                if self._proxy['host'] and self._proxy['port']:
                    proxy = True

            except InternalConfigError as e:
                pass

        proxy_handler_dict = {}
        if proxy:
            proxy_handler_uri = None
            if self._proxy['user']:
                if self._proxy['pass'] is not None:
                    proxy_handler_uri = "%s://%s:%s@%s:%d" % (
                        "http",
                        self._proxy['user'],
                        self._proxy['pass'],
                        self._proxy['host'],
                        self._proxy['port']
                    )
                else:
                    proxy_handler_uri = "%s://%s@%s:%d" % (
                        "http",
                        self._proxy['user'],
                        self._proxy['host'],
                        self._proxy['port']
                    )
            else:
                proxy_handler_uri = "%s://%s:%d" % (
                    "http",
                    self._proxy['host'],
                    self._proxy['port']
                )

            proxy_handler_dict[self._proxy['proto']] = proxy_handler_uri

        self._pwmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
        cookiemonster = urllib2.HTTPCookieProcessor(self._cookiejar)
        auth_NTLM   = HTTPNtlmAuthHandler.HTTPNtlmAuthHandler(self._pwmgr)
        auth_basic  = urllib2.HTTPBasicAuthHandler(self._pwmgr)
        auth_digest = urllib2.HTTPDigestAuthHandler(self._pwmgr)
        auth_proxy  = urllib2.ProxyHandler(proxy_handler_dict)

        openers = [
            auth_basic,
            auth_digest,
            auth_proxy,
            cookiemonster,
        ]
        if ntlm:
            openers.append(auth_NTLM)

        opener = urllib2.build_opener(*openers)
        return opener

    def _cookies(self):
        return self._cookiejar._cookies[self._realm]['/api']['QualysSession']

    def _validate(self, resource, **parameters):
        valid = False
        action = parameters.get('action', None)
        if action is not None:
            valid = resource in self._cFM.option('resource', 'valid')
        else:
            raise NameError(
                "Missing mandarory option `action'"
            )

        msg = None
        if valid:
            for param in self._cFM.section('%s-options' % resource):
                meaning = self._cFM.option(
                    '%s-options' % resource,
                    param
                )
                if meaning.has_key(action):
                    if meaning[action] is 1 and param not in parameters.keys():
                        raise NameError(
                            "Missing mandarory option `%s' for `%s'" % (
                                param, resource
                            )
                        )
                else:
                    pass

            validators = self._cFM.section('%s-validators' % resource)
            for param in parameters:
                if param in self._cFM.options('%s-options' % resource):
                    validator = validators.get(param, None)
                    if validator is not None:
                        if type(validator) is list:
                            valid = parameters[param] in validator
                            msg = "`%s=%s' (required) not in %s" % (
                                param,
                                parameters[param],
                                validator
                            )
                        else:
                            validator_fn = eval(validator)
                            valid = validator_fn(parameters[param])
                            msg = "`%s=%s' failed on %s" % (
                                param,
                                validator,
                                parameters[param]
                            )

                        if not valid:
                            raise QAPILocalValidationError(
                                "`%s:%s=%s': %s",
                                resource, param, parameters[param], msg
                            )
                else:
                    raise NameError(
                        "Invalid option `%s' for `%s'" % (
                            param, resource
                        )
                    )
        else:
            raise NameError(
                "Invalid resource `%s'" % resource
            )

        return valid

    def _request(self, resource, application, data=dict()):
        '''
        application:
            api: QualysGuard API v1
            msp: QualysGuard API v2
        '''
        if application == 'api':
            assert self._validate(resource, **data) is True
        elif application != 'msp':
            raise QAPIInteralError(
                "%s not in `api' or `msp'", application,
            )

        uri = None
        if application == 'api':
            uri = 'https://%s:443/%s/%0.1f/%s/%s/' % (
                self._realm,
                application, URI_DATA['version'], 'fo',
                resource
            )
        elif application == 'msp':
            uri = 'https://%s:443/%s/%s.php' % (
                self._realm,
                application,
                resource
            )

        if self._debug:
            print "\n#. %-8s: %s (%s)" % ('URI', uri, application)
            if application is 'api':
                print "#. %-8s: %s" % ('POST', urllib.urlencode(data))

        encdata = urllib.urlencode(data)
        headers = { 'X-Requested-With' : 'qapi-v%s' % QAPI_VERSION }
        response = None
        error = None
        try:
            request = urllib2.Request(uri, encdata, headers)
            if self._debug:
                print "#. REQUEST HEADERS"
                print request.headers
                print "#. REQUEST DATA"
                print request.data

            response = urllib2.urlopen(request)
            if self._debug:
                print "#. RESPONSE HEADERS"
                print response.msg
                print response.headers
                #print "#. RESPONSE DATA"
                #print '\n'.join(response.readlines())
                #print dir(response.fp)
                #print dir(response)

        except urllib2.HTTPError, e:
            if not self._debug: raise e #. TODO: Cleanup - Not XML, so can't use QAPIHTTPError(e)
            else: error = e
        except urllib2.URLError, e:
            #if not self._debug: raise QAPISessionTimeoutError(e)
            #else:
            error = e
            if hasattr(e, 'reason'):
                print 'We failed to reach a server.'
                print 'Reason: ', e.reason
            elif hasattr(e, 'code'):
                print 'The server couldn\'t fulfill the request.'
                print 'Error code: ', e.code
コード例 #8
0
                #ConfigManager.write(self.config.events, filename=filename)
            except Exception as ex:
                sys.stderr.write(_("Unable to export file, exception: %s") % str(ex))
                error_dialog = Gtk.MessageDialog(self, 0,
                                        Gtk.MessageType.ERROR,
                                        Gtk.ButtonsType.CLOSE,
                                        _("Unable to export file"))
                error_dialog.format_secondary_text(str(ex))
                
                error_dialog.run()
                error_dialog.destroy()                         


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('filename', help='settings filename including path')
    parser.add_argument('instance', help='instance name')

    args = parser.parse_args()    

    filename = args.filename
    instance_name = args.instance

    # Display the window to allow the user to manage the events.
    config = ConfigFileManager(filename, instance_name)
    window = MainWindow(config)
    window.connect("delete-event", Gtk.main_quit)
    
    window.show_all()
    Gtk.main()
コード例 #9
0
ファイル: startup.py プロジェクト: davidbjanes/jarvis
def startup():

	# Get Name of Operating System
	os_name = platform.system()

	# Initialize Configuration File
	configFile = ConfigFileManager(CONFIG_FILE_PATH)

	instance_ID = configFile.poll("Program", "instance_ID")

	# Don't allow multiple instances of Jarvis to run concurrently
	if not(isinstance(instance_ID,str) and instance_ID == "NaN"):
		print "Multiple Instances Running, Start-up Failure."
		return

	# Operating System Check
	if os_name == "Windows" or os_name == "Linux":
		print "Jarvis is Running!"

		# Initialize Configuration File
		configFile.update("Program", "status", "NaN")
		configFile.update("Program", "instance_id", "NaN")
		configFile.update("Program", "error_code", "NaN")

		command_str = "python main.py"

		if os_name == "Windows":
			process_obj = subprocess.Popen(command_str.split(), creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
			configFile.update("Program", "instance_ID", process_obj.pid)
			print "Windows Version Created!"

		else:
			# Create New Process Group
			os.setpgrp() 

			# spawn JARVIS
			process_obj = subprocess.Popen(command_str.split(), shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
			configFile.update("Program", "instance_ID", process_obj.pid)

	else:
		print "I'm sorry, you are running " + os_name + ". I currently only run on Windows/Linux"
		return
コード例 #10
0
ファイル: autoKill.py プロジェクト: davidbjanes/jarvis
## DEPENDANCIES  --------------------------------------------
import os
import signal
import ctypes
from ConfigFileManager import ConfigFileManager

## Global Constants  ----------------------------------------
CONFIG_FILE_PATH = "config.ini"

## Code -----------------------------------------------------
configFile = ConfigFileManager(CONFIG_FILE_PATH)
pid = configFile.poll("Program", "instance_id")

PROCESS_TERMINATE = 1
handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE, False, pid)
ctypes.windll.kernel32.TerminateProcess(handle, -1)
ctypes.windll.kernel32.CloseHandle(handle)
コード例 #11
0
 def loadConfigFile(self, configType):
     setattr(self, configType, ConfigFileManager(configType))
コード例 #12
0
 def new_feed(self, button):
     """ Adds a new row to the bottom of the array / Grid """        
     self.config.feeds.append([ConfigFileManager.get_new_id(), True, "http://", "", True, 5, False, False])        
     self.treeview.set_cursor(len(self.config.feeds) - 1, self.treeview.get_column(0), True)
     self.set_size_request(-1, 150 + len(self.config.feeds) * 20 )