def test_good_user_cache_expire_config(self): auth = authentication.Authentication( authentication.AuthenticationConfig(['32555940559'], ['.gserviceaccount.com'], 1)) token = "testtoken" expected_user_info = authentication.UserInfo("193481341723041", "*****@*****.**", token, 100) def token_fn(token): token_data = { "audience": "32555940559.apps.googleusercontent.com", "user_id": expected_user_info.id, "expires_in": expected_user_info.expires_in, "email": expected_user_info.email, "verified_email": True } return json.dumps(token_data) auth.require_user_info(TestRequestState('bearer ' + token), token_fn) def token_fn2(token): raise Exception("should detect this exception") import time time.sleep(2) with self.assertRaises(Exception): auth.require_user_info(TestRequestState('bearer ' + token), token_fn2)
def authentication_engine(): ''' 验证引擎 :param proxyDict: 代理 IP 字典 :return: 通过验证后,赋值给响应逻辑器LOGIC_RESPONSE ''' LOG.info("[*] 开始执行验证引擎") auth = authentication.Authentication(headers=HEADERS) # 避免每次创建对象都开辟块内存,调用四个进程池,特别占内存 proxyOP = proxyPool.IPOperator(headers=HEADERS) global VALID_URL try: #### 验证 HTTP #### # 遍历 url 列表进行 http 验证请求,将有效的 url 存储在 VALID_URL 中 LOG.info("[+] 验证 HTTP") # 写入日志 for url in URL_LIST.values(): if auth.httpCodeVerify(url): VALID_URL.append(url) # 遍历新加入的 url 列表 for url_zb in URL_LIST_ZB.values(): if auth.httpCodeVerify(url_zb): VALID_URL.append(url_zb) # 遍历有效的 URL print("-" * 40) print("[+] 有效的 URL({0})".format(len(VALID_URL))) for valid_url in VALID_URL: print(str(valid_url)) print("-" * 40) except Exception, e: LOG.error("[-] {0}".format(str(e.message))) # 写入日志
def __init__(self): def create_provider(provider_name): client_id = config.get(provider_name, 'CLIENT_ID') client_secret = config.get(provider_name, 'CLIENT_SECRET') open_id_config_url = config.get(provider_name, 'OPEN_ID_CONFIG_URL') fence_base_url = config.get(provider_name, 'FENCE_BASE_URL') user_name_path_expr = config.get(provider_name, 'USER_NAME_PATH_EXPR') sam_base_url = config.get('sam', 'BASE_URL') oauth_adapter = OauthAdapter(client_id, client_secret, open_id_config_url, provider_name) fence_api = FenceApi(fence_base_url) sam_api = SamApi(sam_base_url) fence_tvm = FenceTokenVendingMachine(fence_api, sam_api, oauth_adapter, provider_name) return BondProvider( fence_tvm, Bond(oauth_adapter, fence_api, sam_api, fence_tvm, provider_name, user_name_path_expr)) self.providers = { provider_name: create_provider(provider_name) for provider_name in config.sections() if provider_name != 'sam' } self.auth = authentication.Authentication( authentication.default_config())
def test_send_auth_message(sheets: Sheets, test_users: List[User]): user = test_users[0] class FooCrypto: def encrypt(self, value: str) -> str: return "foo" def decrypt(self, value: str) -> str: return "foo" class TestEmail: def __init__(self, to_email): self.to_email = user.email def send(self, to_email: str, subject: str, body: str) -> None: assert to_email == self.to_email assert subject == "Welcome to the Looker Hackathon!" assert (body == f"""<h1>Welcome to the Looker Hackathon!</h1> Please click https://foo.com/auth/foo to authenticate your email so you can use the Hackathon application and participate in the Hackathon """) auth_service = authentication.Authentication(crypto=FooCrypto(), sheet=sheets, email=TestEmail(user.email)) auth_service.send_auth_message(user, "https://foo.com/")
def __init__(self): self.verbosity = 0 self.configfile = "xfltreat.conf" self.servermode = 0 self.clientmode = 0 self.checkmode = 0 self.splitmode = 0 # split tunnelling self.ignoredependencies = 0 # ignoring missing dependencies self.short = "hsc" self.long = [ "help", "server", "client", "check", "split", "config=", "verbose=", "ignore-dependencies" ] # modules that should not be loaded self.forbidden_modules = [ "Generic_module", "Stateful_module", "Stateless_module" ] self.forbidden_modules_instance = [ Generic_module, Stateful_module, Stateless_module ] self.authentication = authentication.Authentication() self.encryption = encryption.Encryption()
def test_auth_user(sheets: Sheets, test_users: List[User]): auth_service = authentication.Authentication(crypto=NoopCrypto(), sheet=sheets, email=NoopEmail()) user = test_users[0] auth_code = auth_service.get_user_auth_code(user) authenticated_user = auth_service.auth_user(auth_code) assert authenticated_user == user
def setUp(self): # First, create an instance of the Testbed class. self.testbed = testbed.Testbed() # Then activate the testbed, which prepares the service stubs for use. self.testbed.activate() # Next, declare which service stubs you want to use. self.testbed.init_memcache_stub() self.auth = authentication.Authentication( authentication.AuthenticationConfig(['32555940559'], ['.gserviceaccount.com'], 600))
def test_get_user_auth_code(sheets: Sheets): user = User( first_name="Hundy", last_name="P", email="*****@*****.**", organization="company", role="BI analyst", tshirt_size="M", ) auth_service = authentication.Authentication(crypto=NoopCrypto(), sheet=sheets, email=NoopEmail()) auth_code = auth_service.get_user_auth_code(user) email, date = auth_code.split("~") assert email == "*****@*****.**"
def independent_proxy_engine(url): ''' 独立代理引擎,用于重新获取单个异常网页的代理 :param url: 异常网页的 url 链接 :return: ''' LOG.info("[+] 开始重新获取代理") Console_Color.print_color(str="[*] 开始重新获取代理", forecolor="洋红") global VALID_URL_PROXY auth = authentication.Authentication(headers=HEADERS) proxyOP = proxyPool.IPOperator(headers=HEADERS) while True: proxyDict = proxy_engine(proxyOP) if auth.proxyVerify(url, proxyDict["protocol"], proxyDict["ip"], proxyDict["port"]): global VALID_URL_PROXY VALID_URL_PROXY[url] = proxyDict break
def create_schema(self, schema_name): if schema_name in os.listdir(self.schemas_directory): print("Error! Schema already exists.") self.events_logger.error("Error! Schema already exists.") elif "$" + self.schema_name in os.listdir(self.schemas_directory): print("Error! Schema already exists.") self.events_logger.error("Error! Schema already exists.") else: json.dump({}, open(os.path.join(self.schemas_directory, schema_name), "w+"), indent=2) auth = authentication.Authentication() auth.add_schema_to_user(self.user_name, schema_name, ["C", "R", "U", "D"]) print("Schema created with name:", schema_name) self.events_logger.info("Schema created with name:" + schema_name) self.events_logger.info("Query : " + self.query)
def lambda_handler(event, context): client = authentication.Authentication() subject = event['Records'][0]['Sns']['Subject'] message_json = json.loads(event['Records'][0]['Sns']['Message']) message_desc = message_json['Description'] message_event = message_json['Event'] print(subject) print(message_desc) print(message_event) print(context.invoked_function_arn) print(context.invoked_function_arn.split(":")[4]) log_message = { "subject": subject, "description": message_desc, "asg_event": message_event } return log_message
def use_schema(self, schema_name): if schema_name in os.listdir(self.schemas_directory): # call a method and send user_name and schema_name to check for access auth = authentication.Authentication() access_level = auth.check_access(self.user_name, schema_name) if access_level is None: print("You don't have access to this schema") self.events_logger.error( "You don't have access to this schema" + schema_name) return else: self.user_access = access_level self.schema = json.load( open(os.path.join(self.schemas_directory, schema_name), "r")) self.schema_name = schema_name print("Current Schema:", self.schema_name) self.events_logger.info("Query : " + self.query) elif "$" + schema_name in os.listdir(self.schemas_directory): print("Schema is being locked by other user. Please try later.") self.events_logger.info("Schema is being locked by other user." + schema_name) else: print("No such schema exists!") self.events_logger.error("Schema not found!" + schema_name)
def __init__(self, conf, dht, sysInfo): self.dht = dht self.sysInfo = sysInfo self.api_ver = "1" self.authentication = Auth.Authentication(conf.getAccPassword())
class ManagementInterface: data_plane_config_file = None data_plane_config_filepath = 'Emulator/config/data_plane_config.json' pending_mgmt_config_filepath = 'Emulator/config/mgmt_config.json.pending' mgmt_config_filepath = 'Emulator/config/mgmt_config.json' schema_filepath = '/usr/src/app/openapi/schema.json' versioning_filepath = '/usr/src/app/VERSIONING' authentication = authentication.Authentication( authentication_backend=set_authentication_backend()) access_controller = RequestAccessControl(authentication) default_syslog_config = [] default_ntp_config = [] default_tls_config = { "certificate": "-----BEGIN CERTIFICATE-----\nMIIDOzCCAiOgAwIBAgIUN5q2Bu2aYaFLIciHgLWQnhGfV7QwDQYJKoZIhvcNAQELBQAwLTELMAkGA1UEBhMCR0IxHjAcBgNVBAMMFW1hbmFnZW1lbnQub2FrZG9vci5pbzAeFw0yMjA0MDYxNTQ1MDBaFw0yMzA0MDYxNTQ1MDBaMC0xCzAJBgNVBAYTAkdCMR4wHAYDVQQDDBVtYW5hZ2VtZW50Lm9ha2Rvb3IuaW8wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC/4qNnEKLv3f6bnqPX44d19FlhAJYOKUH6StM39U7jE5j3/Mh/sepTS6VpOp5y7kIZ5K042eM0nsljZcUWTl/SH2uqfx6vNgw86rI027h3IFPBg1GARXk5Tox0o78n/SccLi0OXyWQo9TN4pCjp4vV6x78iTJ1xh/qv3QvVRoA0vO0ZAXIOWjPyEmRaOhUVYoGS8SrD6JbIh50sjDlJs4jFreJAPGxVkwcpyOqh1ro7B7y08cbnFR3HXUe3b+ypYHyJCmn0aUYa2eo4po5me6bfHCDtOfodPAHosmCgMdXowBMSbQeFAE4TgPrZHqDBpWenni5uWi38KRGIvaeZ78zAgMBAAGjUzBRMB0GA1UdDgQWBBRcQvFH4rgx0qmLZdnmiYKKrZBoDzAfBgNVHSMEGDAWgBRcQvFH4rgx0qmLZdnmiYKKrZBoDzAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQAoz54OodDPlC6JC+hhdjhEOVSXLH0k/UVqmLoeuAX7WQB7jYe6pAkNnM+NjMjhmip/Ad8HjHPMGJkrTxohSVgJO+SUIq+cziFfunNWG6VImHpkHM37M9B7UkOE+7e6wo9WvF2fiKiMh5C9KrZoxBhM7oGwBL6Pnav1hRoZIs/5YAzUJ6BfvB21Z3GFPV2nxk62OXdhD2WrNj+1ULQg3DsD1LWUghgT95ITxTRMcvjzzEH93KD2Y4+yooMFmdPTq8gXdeRpeQqMpouuSHHigHJGGda32+vpi/6rMWPcUmPPONxE4oOKr79KY1ykMhu6wkERrBslQdCynfOU8+XWzAH7\n-----END CERTIFICATE-----", "key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC/4qNnEKLv3f6bnqPX44d19FlhAJYOKUH6StM39U7jE5j3/Mh/sepTS6VpOp5y7kIZ5K042eM0nsljZcUWTl/SH2uqfx6vNgw86rI027h3IFPBg1GARXk5Tox0o78n/SccLi0OXyWQo9TN4pCjp4vV6x78iTJ1xh/qv3QvVRoA0vO0ZAXIOWjPyEmRaOhUVYoGS8SrD6JbIh50sjDlJs4jFreJAPGxVkwcpyOqh1ro7B7y08cbnFR3HXUe3b+ypYHyJCmn0aUYa2eo4po5me6bfHCDtOfodPAHosmCgMdXowBMSbQeFAE4TgPrZHqDBpWenni5uWi38KRGIvaeZ78zAgMBAAECggEBAIuoVYuG9UAlz9DN5qwToxz7qi3Ksmw+JRIZcZ+xwCfPtK8RYZBnGohjb1GmY3p85MlZwaW2GALNawAYKxjwFBen3MHr4ZZefQu9OdT08k5pzevzOtdkOTW3cMzX/SIKw3NkPFDQeVPLme/7bZBfOoyIozXkWUCU4dgGXnawtstPex2FD2yAnXdVOoz4Gn5Mx2hv28K93KE4RkBz2Pp+L6+/p9/kJ1P3vEVvJv2TN6r8FhzUxqxR+ascpE2tNjy3VFfPjF8gm4R9iXzIO6AMHEP/+qaX3xn5WeU9+wNydFykBj/tYh+C28KFLlKp+WVvLaL8neHotOS7BnfFMh1RxaECgYEA6RQqN+h8fZD27GmjJbvZmBPIsaGtRHYVI4wqwxaZPMF3eHBzVOGTGrst9jTaXpOkycSQGjVYKn0xfElJAxWwYYf3A+rYzPqjHMDCNAnzPBpcV7VS2anzyOQxR8pWOCQWKcyhaF0TLTaRyGX2yT77cF7M/BYJpwzRYI7jwk8c6vECgYEA0sFqEICLISmVEP8pj+saJN+eaEm96NW73GShHk8miW7kjWs3I3EcI4L0qhJmwz+thmmc9Tl4+wZ+tWg4cO2gLXdtk79AzSPsA/FVGy5TsfN0/8mepSzqGYTrV2M960xi8ZoqvCUEZU+DlbQb5NMC/L/FdcyNkeJAlOtg1aIfJGMCgYAiAqJCdDcuL2gIiUWYLPgMW96uJNReqAhfnoVi4DpOBkEDnw0FNsE7ZlLHmWC/6jVih78rQ9twn8IHy73OqGyLXsapmKw4BN6mRG5SH52RiJsu5TOItWbwSnPycNDx8joVsVlgHCy/LTZKkq5XIUyZUgwBQMn5yUIIH/GWGeszUQKBgGRCgLuS+xzulCx+xn3hoRFTlB8WnZKLQxBoisFJdBLDP1ULYTKqF3HJVa0mjd5qh5k+2t1J1wTMJTEVgGwwjxeyDd3QiPpOEXQatZr1ofkw0ULx3lfDkyZKtk5fNtCeCR/YcGYK0hmEBxwLj41+2Jf2fvA4PEzfLkvp4aofsuLzAoGAb4ycDYI3h0Oaw/Sypwu+zKYRko6OpvHJndrsnF7QKynMpyZ0gsR7+C1rMO5cEhoQnH5cJiKls26d9s6ICse9+y/lhB3QtYJdAndMutXVWSrwp1oX9Lth3FOpvrB1199K2WfCltS+KAW7FuEcjl07WNjePzsbGf5d+YTk+rNyMHU=\n-----END PRIVATE KEY-----" } default_network_config = { "version": 2, "renderer": "networkd", "ethernets": { "eth0": { "dhcp4": False, "addresses": ["192.168.2.2/24"] }, "eth1": { "dhcp4": True, "optional": True } } } default_mgmt_config = { "syslog": default_syslog_config, "ntp": default_ntp_config, "tls": default_tls_config, "network": default_network_config } @classmethod def update_mgmt_firmware(cls): return cls.access_controller.enforce_sequential_api_calls( cls._update_firmware) @classmethod def update_diode_firmware(cls): return cls.access_controller.enforce_sequential_api_calls( cls._update_firmware) @classmethod def _update_firmware(cls, role): if not UserRole.check_role_meets_minimum_rank(role, "admin"): return Response( json.dumps({ "error": "Method doesn't exist or user has insufficient privileges" }), 401) if not len(connexion.request.get_data()): return Response( json.dumps({"error": "Exception processing API command"}), 500) return Response("", 200) @classmethod def get_config(cls): return cls.access_controller.enforce_sequential_api_calls( cls._get_config) @classmethod def _get_config(cls, role): if not UserRole.check_role_meets_minimum_rank(role, "readOnly"): return Response( json.dumps({ "error": "Method doesn't exist or user has insufficient privileges" }), 401) if cls._file_exists(cls.data_plane_config_filepath): return Response( json.dumps( cls._get_file_content(cls.data_plane_config_filepath)), 200) else: return Response(json.dumps({"error": "Config file not found"}), 404) @staticmethod def _file_exists(filepath): return os.path.exists(filepath) @staticmethod def _get_file_content(filepath): with open(filepath, 'r') as file: return json.loads(file.read()) @classmethod def get_config_schema(cls): return cls.access_controller.enforce_sequential_api_calls( cls._get_config_schema) @classmethod def _get_config_schema(cls, role): if not UserRole.check_role_meets_minimum_rank(role, "readOnly"): return Response( json.dumps({ "error": "Method doesn't exist or user has insufficient privileges" }), 401) return Response(json.dumps(cls._get_file_content(cls.schema_filepath)), 200) @classmethod def do_config_update(cls): return cls.access_controller.enforce_sequential_api_calls( cls._do_config_update) @classmethod def _do_config_update(cls, role): if not UserRole.check_role_meets_minimum_rank(role, "admin"): return Response( json.dumps({ "error": "Method doesn't exist or user has insufficient privileges" }), 401) try: cls.data_plane_config_file = cls._validate_config( connexion.request.get_data(as_text=True)) except DataPlaneConfigError as exc: return Response(json.dumps({"error": f"{exc}"}), 400) cls._update_config() return Response("", 200) @classmethod def _validate_config(cls, request_data): return VerifyDataPlaneConfig().validate_and_return_json(request_data) @classmethod def _update_config(cls): with open(cls.data_plane_config_filepath, 'w') as config_file: json.dump(cls.data_plane_config_file, config_file) @classmethod def do_power_on(cls): return cls.access_controller.enforce_sequential_api_calls( PowerControl.do_power_on, cls._get_user_from_request()) @classmethod def do_power_off(cls): return cls.access_controller.enforce_sequential_api_calls( PowerControl.do_power_off, cls._get_user_from_request()) @classmethod def _get_user_from_request(cls): if os.getenv("ANONYMOUSACCESS") != "True": return cls.authentication.extract_credentials( connexion.request.headers["Authorization"]) else: return "user" @classmethod def get_versioning_information(cls): return cls.access_controller.enforce_sequential_api_calls( cls._get_versioning_information) @classmethod def _get_versioning_information(cls, role): if not UserRole.check_role_meets_minimum_rank(role, "readOnly"): return Response( json.dumps({ "error": "Method doesn't exist or user has insufficient privileges" }), 401) with open(cls.versioning_filepath, 'r') as versioning_file: version_number = versioning_file.read() status = { "Diode": { "Firmware": { "F1": "0.0.0_rc0", "F2": "0.0.0_rc0", "F3": "0.0.0_rc0" } }, "Management": { "Kernel": "0.00.00-cl-som-imx7-0.0 #1 SMP PREEMPT Mon Jan 01 00:00:00 UTC 1970", "RestAPI": f"{version_number}-a0000a0a", "RootFS": { "Build": "000", "Hash": "0a0a0000", "MountPoint": "/dev/mmcblk2p0" }, "DiskImage": { "Build": "000", "Hash": "0a0a0000" } } } return Response(json.dumps(status), 200) @classmethod def get_status_information(cls): return cls.access_controller.enforce_sequential_api_calls( cls._get_status_information) @classmethod def _get_status_information(cls, role): if not UserRole.check_role_meets_minimum_rank(role, "readOnly"): return Response( json.dumps({ "error": "Method doesn't exist or user has insufficient privileges" }), 401) status = Status.get_status() status["Dataplane"]["PowerState"] = PowerControl.state.name.lower() if PowerControl.state == DataplanePowerState.ERROR and PowerControl.error_message is not None: status["Dataplane"]["PowerStateError"] = PowerControl.error_message return Response(json.dumps(status), 200) @classmethod def get_mgmt_config(cls): return cls.access_controller.enforce_sequential_api_calls( cls._get_mgmt_config) @classmethod def _get_mgmt_config(cls, role): if not UserRole.check_role_meets_minimum_rank(role, "support"): return Response( json.dumps({ "error": "Method doesn't exist or user has insufficient privileges" }), 401) deployed_config = cls._get_sanitised_mgmt_config_from_file( cls.mgmt_config_filepath) pending_config = cls._get_sanitised_mgmt_config_from_file( cls.pending_mgmt_config_filepath) return Response( json.dumps({ "deployed": deployed_config, "pending": pending_config }), 200) @classmethod def _get_sanitised_mgmt_config_from_file(cls, config_path): if cls._file_exists(config_path): return cls._get_sanitised_mgmt_config( cls._get_file_content(config_path)) else: return {} @classmethod def _get_sanitised_mgmt_config(cls, config): if "tls" in config: config["tls"].pop("key") return config @classmethod def stage_mgmt_config(cls): return cls.access_controller.enforce_sequential_api_calls( cls._stage_mgmt_config) @classmethod def _stage_mgmt_config(cls, role): if not UserRole.check_role_meets_minimum_rank(role, "admin"): return Response( json.dumps({ "error": "Method doesn't exist or user has insufficient privileges" }), 401) pending_mgmt_config = {} if os.path.exists(cls.pending_mgmt_config_filepath): with open(cls.pending_mgmt_config_filepath, 'r') as pending_config: pending_mgmt_config = json.load(pending_config) ManagementInterface._write_config_to_file( cls._get_updated_config(pending_mgmt_config, connexion.request.get_json()), cls.pending_mgmt_config_filepath) return Response("", 200) @classmethod def _get_updated_config(cls, base_config, updates): sections = set(base_config).union(set(updates)) return { section: cls._get_updated_section(section, base_config, updates) for section in sections } @classmethod def _get_updated_section(cls, section_name, base_config, updates): section = updates[ section_name] if section_name in updates else base_config[ section_name] if len(section) == 0: section = cls.default_mgmt_config[section_name] return section @staticmethod def _write_config_to_file(config, file_path): with open(file_path, 'w') as config_file: json.dump(config, config_file) @classmethod def deploy_mgmt_config(cls): return cls.access_controller.enforce_sequential_api_calls( cls._deploy_mgmt_config) @classmethod def _deploy_mgmt_config(cls, role): if not UserRole.check_role_meets_minimum_rank(role, "admin"): return Response( json.dumps({ "error": "Method doesn't exist or user has insufficient privileges" }), 401) if not os.path.exists(cls.pending_mgmt_config_filepath): return Response( json.dumps( {"error": "No staged config could be found to deploy"}), 400) cls._write_deployed_mgmt_config() os.remove(cls.pending_mgmt_config_filepath) return Response("", 200) @classmethod def _write_deployed_mgmt_config(cls): with open(cls.mgmt_config_filepath) as deployed_config, \ open(cls.pending_mgmt_config_filepath) as pending_config: deployed_mgmt_config = json.load(deployed_config) pending_mgmt_config = json.load(pending_config) ManagementInterface._write_config_to_file( cls._get_updated_config(deployed_mgmt_config, pending_mgmt_config), cls.mgmt_config_filepath) @classmethod def basic_authentication(cls, username, password): return cls.authentication.authenticate(username, password) @classmethod def user_add(cls, username): return cls.access_controller.enforce_sequential_api_calls( lambda role: Response(*cls.authentication.add_user( username, connexion.request.get_json(), role))) @classmethod def update_user(cls, username): return cls.access_controller.enforce_sequential_api_calls( lambda role: Response(*cls.authentication.update_user( username, connexion.request.get_json(), role)), cls._get_user_from_request()) @classmethod def list_users(cls): return cls.access_controller.enforce_sequential_api_calls( cls._list_users) @classmethod def _list_users(cls, role): if not UserRole.check_role_meets_minimum_rank(role, "support"): return Response( json.dumps({ "error": "Method doesn't exist or user has insufficient privileges" }), 401) users = cls.authentication.list_users() return Response(json.dumps(users[0]), users[1]) @classmethod def user_delete(cls, username): return cls.access_controller.enforce_sequential_api_calls( lambda role: Response(*cls.authentication.delete_user( username, role)))
def development_mode(config_file, args=[]): servicename = path.basename( config_file) # take the file name like amazon.cfg configfile = config_file # the dir + file name logfilename = path.splitext(servicename)[0] # remove the extension # check for existence of the config file if not path.exists(configfile): raise Exception("Configuration file %s not found." % configfile) suite = BasicWorkflowTestSuite(logfilename, args=args) fixtures = [] '''check if configuration file we read from the ServiceList exist''' try: path.exists(configfile) and path.isfile(configfile) and access( configfile, R_OK) except IOError: sys.exit(1) suite.configfile = configfile suite.smapiservice = SMAPIService(suite.configfile, wsdl=parser.wsdl, content_file=parser.options.content_file, logger=suite.logger, console_logger=suite.console_logger) suite.client = suite.smapiservice.buildservice() suite.client.login() suite.logger.info("Service Name: %s" % safe_str(suite.smapiservice.svcName)) suite.console_logger.info("Service Name: %s" % safe_str(suite.smapiservice.svcName)) getuserinfo.suite = suite f = getuserinfo.GetUserInfoTest(suite.client, suite.smapiservice) fixtures.append(f) # Relying on the fact that order is maintained in python lists, the updatetestcontent suite must run before any test # case that can change user's favorites (i.e., playlists, favorites, ratings) updatetestcontent.suite = suite f = updatetestcontent.UpdateTestContent(suite.client, suite.smapiservice) f.initialize() fixtures.append(f) smapimethodvalidation.suite = suite f = smapimethodvalidation.SMAPIMethodValidation(suite.client, suite.smapiservice) fixtures.append(f) playlist.suite = suite f = playlist.CreatePlaylist(suite.client, suite.smapiservice) f.create_playlist_with_seed_generator = playlist.generate_function_name_strings( ) f.playlist_in_folder_with_seed_generator = playlist.generate_function_name_strings( ) fixtures.append(f) f = playlist.DeletePlaylist(suite.client, suite.smapiservice) fixtures.append(f) f = playlist.RenamePlaylist(suite.client, suite.smapiservice) fixtures.append(f) f = playlist.AddToPlaylist(suite.client, suite.smapiservice) f.cannot_add_to_noneditable_playlist_generator = playlist.generate_items_for_addtoContainer_playlist_test( ) f.can_add_to_playlist_generator = playlist.generate_items_for_addtoContainer_playlist_test( ) fixtures.append(f) f = playlist.ReorderPlaylistContainer(suite.client, suite.smapiservice) f.generate_can_reorder_data = playlist.generate_reordering_data() f.generate_cannot_reorder_data = playlist.generate_cannot_reordering_data() fixtures.append(f) albumart.suite = suite f = albumart.Albumart(suite.client, suite.smapiservice) f.create_local_dir() f.create_html_result_file() fixtures.append(f) ratings.suite = suite fixtures.append(ratings.Ratings(suite.client, suite.smapiservice)) favorites.suite = suite f = favorites.Favorites(suite.client, suite.smapiservice) f.favorite_type_add = favorites.generate_name_strings() f.favorite_type_remove = favorites.generate_name_strings() fixtures.append(f) browse.suite = suite f = browse.Browse(suite.client, suite.smapiservice) f.test_scroll_driller = f.generate_iterative_list_drill( f.determiner_browse_scroll) f.test_leaf_driller = f.generate_iterative_list_drill( f.determiner_browse_leaf) f.pagination_total_count = f.generate_iterative_list_drill( f.determiner_browse_pagination) f.pagination_container = browse.generate_pagination_container( f.generate_iterative_list_drill(f.determiner_pagination_container)) f.pagination_container_nooverlap = browse.generate_pagination_container( f.generate_iterative_list_drill(f.determiner_pagination_container)) fixtures.append(f) httpverifications.suite = suite fixtures.append( httpverifications.HTTPBasedTests(suite.client, suite.smapiservice)) search.suite = suite f = search.Search(suite.client, suite.smapiservice) f.initialize() fixtures.append(f) progvalidation.suite = suite f = progvalidation.Progvalidation(suite.client, suite.smapiservice) f.test_program_driller = f.generate_iterative_list_drill( f.determiner_program) f.test_pagination_total_count = f.generate_iterative_list_drill( f.determiner_browse_pagination) fixtures.append(f) streamvalidation.suite = suite f = streamvalidation.StreamValidation(suite.client, suite.smapiservice) f.test_stream_driller = f.generate_iterative_list_drill( f.determiner_stream) fixtures.append(f) stringtable.suite = suite f = stringtable.Stringtable(suite.client, suite.smapiservice) f.language = stringtable.generate_language_list() fixtures.append(f) presentationmap.suite = suite f = presentationmap.Presentationmap(suite.client, suite.smapiservice) fixtures.append(f) extendedmetadatavalidations.suite = suite f = extendedmetadatavalidations.ExtendedMetadataValidations( suite.client, suite.smapiservice) f.metadata_data = extendedmetadatavalidations.generate_test_data() fixtures.append(f) getlastupdate.suite = suite fixtures.append( getlastupdate.PollingIntervalTest(suite.client, suite.smapiservice)) authentication.suite = suite fixtures.append( authentication.Authentication(suite.client, suite.smapiservice)) smapi_reporting.suite = suite f = smapi_reporting.SMAPIReporting(suite.client, suite.smapiservice) fixtures.append(f) # ssl_validation.suite = suite # f = ssl_validation.ssl_validation(suite.client, suite.smapiservice) # fixtures.append(f) try: import servicecatalog import mslogo servicecatalog.suite = suite f = servicecatalog.ServiceCatalog(suite.client, suite.smapiservice) fixtures.append(f) mslogo.suite = suite f = mslogo.MSLogo(suite.client, suite.smapiservice) fixtures.append(f) except: pass # Run it suite.run(fixtures)
def setUp(cls): cls.authentication_backend_spy = authentication.EphemeralAuthenticationBackend( ) cls.authentication = authentication.Authentication( cls.authentication_backend_spy)
from common_docker import * import time import json import pytest import os import authentication import admission import deployments import artifacts import inventory import device_authentication logger = logging.getLogger('root') auth = authentication.Authentication() adm = admission.Admission(auth) deploy = deployments.Deployments(auth, adm) image = artifacts.Artifacts() inv = inventory.Inventory(auth) deviceauth = device_authentication.DeviceAuthentication(auth) # -- When adding something here, also add a reset method and add it below -- def reset_mender_api(): auth.reset() adm.reset() deploy.reset() image.reset() inv.reset() deviceauth.reset()
def authentication_engine(): ''' 验证引擎 :param proxyDict: 代理 IP 字典 :return: 通过验证后,赋值给响应逻辑器LOGIC_RESPONSE ''' LOG.info("[*] 开始执行验证引擎") auth = authentication.Authentication(headers=HEADERS) # 避免每次创建对象都开辟块内存,调用四个进程池,特别占内存 proxyOP = proxyPool.IPOperator(headers=HEADERS) global VALID_URL try: #### 验证 HTTP #### # 遍历 url 列表进行 http 验证请求,将有效的 url 存储在 VALID_URL 中 LOG.info("[+] 验证 HTTP") # 写入日志 for url in URL_LIST.values(): if auth.httpCodeVerify(url): VALID_URL.append(url) # 遍历新加入的 url 列表 for url_zb in URL_LIST_ZB.values(): if auth.httpCodeVerify(url_zb): VALID_URL.append(url_zb) # 遍历有效的 URL print("-" * 40) print("[+] 有效的 URL({0})".format(len(VALID_URL))) for valid_url in VALID_URL: print(str(valid_url)) print("-" * 40) except Exception as e: LOG.error("[-] {0}".format(str(e.message))) # 写入日志 try: #### 验证代理 #### # 遍历有效的 url 列表 LOG.info("[+] 验证代理") # 写入日志 for url in VALID_URL: # 循环取出代理进行代理验证,将有效的代理与对应的 url 存储在字典中 while True: proxyDict = proxy_engine(proxyOP) if auth.proxyVerify(url, proxyDict["protocol"], proxyDict["ip"], proxyDict["port"]): global VALID_URL_PROXY VALID_URL_PROXY[url] = proxyDict break # 每进行一次 url 的代理验证,释放一次内存 gc.collect() # 遍历 VALID_URL_PROXY 字典 print("-" * 40) print("[+] 有效网址和代理") for valid_url in VALID_URL_PROXY: protocol = VALID_URL_PROXY[valid_url]['protocol'] ip = VALID_URL_PROXY[valid_url]['ip'] port = VALID_URL_PROXY[valid_url]['port'] print("{0}--({1}:{2}:{3})".format(valid_url, protocol, ip, port)) print("-" * 40) # 存储完成,赋值全局变量 global LOGIC_RESPONSE LOGIC_RESPONSE = True except Exception as e: LOG.error("[-] {0}".format(str(e.message))) # 写入日志 try: #### 验证数据库 #### LOG.info("[+] 验证数据库") if LOGIC_RESPONSE: global LOGIC_EXECUTE LOGIC_EXECUTE = auth.dataBaseVerify(DATABASE_PARAM) except Exception as e: LOG.error("[-] {0}".format(str(e.message))) # 写入日志 LOG.info("[+] 清理内存") # 删除 auth 和 proxyOP 对象 del auth, proxyOP # 清理内存 gc.collect()