def delete_file( repo: Optional[str], package: Optional[str], version: Optional[str], filename: Optional[str], ): username, header = get_auth_header_and_username() if not username: return if not repo: repo = repositories.select_from_available_repo(subject=username) if not package: package = packages_core.select_from_available_packages( subject=username, repo=repo) if not version: version = select_from_available_versions(subject=username, repo=repo, package=package, filename=filename) if not filename: filename = select_from_available_files(subject=username, repo=repo, package=package, version=version) print_message(f"Deleting file {filename} version {version}") url = get_url(f"/{username}/{repo}/{package}/{version}/{filename}") password = typer.prompt("Password", hide_input=True) response = httpx.delete(url=url, auth=httpx.BasicAuth(username=username, password=password)) response_handler(response=response, return_model=FileDeleteResponseModel) return
async def process_login(self, code: str, request: Request) -> Optional[OpenID]: """This method should be called from callback endpoint to verify the user and request user info endpoint. This is low level, you should use {verify_and_process} instead. """ logging.debug(f'redirect_uri: {self.redirect_uri}') current_path = f'{self.redirect_uri}?code={code}' logging.debug(f'current_path with query_params: {current_path}') if self.state is not None and self.use_state and request.query_params.get("state"): current_path = f'{current_path}&state={request.query_params.get("state")}' logging.debug(f'current_path with query_params: {current_path}') token_url, headers, body = self.oauth_client.prepare_token_request( await self.token_endpoint, authorization_response=current_path, redirect_url=self.redirect_uri, code=code ) # type: ignore if token_url is None: return None auth = httpx.BasicAuth(str(self.client_id), self.client_secret) async with httpx.AsyncClient() as session: logging.debug(f'token_url: {token_url}') logging.debug(f'request_body: {body}') response = await session.post(token_url, headers=headers, content=body, auth=auth) content = response.json() logging.debug(f'response: {content}') self.oauth_client.parse_request_body_response(json.dumps(content)) uri, headers, _ = self.oauth_client.add_token(await self.userinfo_endpoint) logging.debug(f'userinfo_endpoint: {uri}') response = await session.get(uri, headers=headers) content = response.json() return await self.openid_from_response(content)
def file_upload(repo: Optional[str], package: Optional[str], version: str, filename: str): username, header = get_auth_header_and_username() if not username: return if not repo: repo = repositories.select_from_available_repo(subject=username) if not package: package = packages_core.select_from_available_packages( subject=username, repo=repo) file_path: str = filename if os.path.isabs(file_path): filename = os.path.basename(file_path) url = get_url(f"/content/{username}/{repo}/{package}/{version}/{filename}") try: with open(file_path, "br") as file: data = file.read() headers = { "x-bintray-publish": "1", "content-type": "application/octet-stream", "x-bintray-override": "1", } headers.update(header) password = typer.prompt("Password", hide_input=True) response = httpx.put( url=url, data=data, headers=headers, auth=httpx.BasicAuth(username=username, password=password), ) response_handler(response=response, return_with_out_model=True) except Exception as e: print_error(f"{e.args[0]}")
async def zabbix_login(self): """ Логинится на Zabbix по главной странице """ login_data = { "name": self.username, "password": self.password, "enter": "Sign in" } auth = httpx.BasicAuth(self.username, self.password) async with httpx.AsyncClient() as client: login_request = await client.post(str(self.host) + "/", data=login_data, auth=auth) if login_request.status_code != 200: self.log.warning('Login on Zabbix Failed!') self.log.debug(login_request.text) cookies = login_request.cookies if self.AUTH_COOKIE_NAME in cookies.keys(): self.log.info("LOGGING SUCCESS on Zabbix Web Interface") else: self.log.warning('Authentication on Zabbix Failed!') self.log.debug(login_request.text) self.cookies = cookies return login_request.text
async def _async_generate_token(self) -> None: """Create authentation to use with requests.""" cmd = "magicBox.cgi?action=getMachineName" _LOGGER.debug("%s Trying async Basic Authentication", self) self._async_token = httpx.BasicAuth(self._user, self._password) try: try: resp = (await self._async_command(cmd)).content.decode() except LoginError: _LOGGER.debug("%s Trying async Digest Authentication", self) self._async_token = httpx.DigestAuth(self._user, self._password) resp = (await self._async_command(cmd)).content.decode() except CommError: self._async_token = None raise # check if user passed result = resp.lower() if "invalid" in result or "error" in result: _LOGGER.debug( "%s Result from camera: %s", self, resp.strip().replace("\r\n", ": "), ) self._async_token = None raise LoginError("Invalid credentials") self._name = pretty(resp.strip()) _LOGGER.debug("%s Retrieving serial number", self) self._serial = pretty( (await self._async_command("magicBox.cgi?action=getSerialNo") ).content.decode().strip())
def __init__(self, hass, device_info): """Initialize a generic camera.""" super().__init__() self.hass = hass self._authentication = device_info.get(CONF_AUTHENTICATION) self._name = device_info.get(CONF_NAME) self._still_image_url = device_info[CONF_STILL_IMAGE_URL] self._stream_source = device_info.get(CONF_STREAM_SOURCE) self._still_image_url.hass = hass if self._stream_source is not None: self._stream_source.hass = hass self._limit_refetch = device_info[CONF_LIMIT_REFETCH_TO_URL_CHANGE] self._frame_interval = 1 / device_info[CONF_FRAMERATE] self._supported_features = SUPPORT_STREAM if self._stream_source else 0 self.content_type = device_info[CONF_CONTENT_TYPE] self.verify_ssl = device_info[CONF_VERIFY_SSL] if device_info.get(CONF_RTSP_TRANSPORT): self.stream_options[FFMPEG_OPTION_MAP[ CONF_RTSP_TRANSPORT]] = device_info[CONF_RTSP_TRANSPORT] username = device_info.get(CONF_USERNAME) password = device_info.get(CONF_PASSWORD) if username and password: if self._authentication == HTTP_DIGEST_AUTHENTICATION: self._auth = httpx.DigestAuth(username=username, password=password) else: self._auth = httpx.BasicAuth(username=username, password=password) else: self._auth = None self._last_url = None self._last_image = None
def refresh_token(self): refresh_token = self.token.get('refresh_token') body = self.oauth_client.prepare_refresh_body( body='', refresh_token=refresh_token, scope=self.scope, client_id=self.client_id, client_secret=self.client_secret) response = self.request( 'POST', self.token_url, headers={ 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8', }, data=dict(urldecode(body)), auth=httpx.BasicAuth(self.client_id, self.client_secret), withhold_token=True) self.token = self.oauth_client.parse_request_body_response( response.text, scope=self.scope) if 'refresh_token' not in self.token: self.token['refresh_token'] = refresh_token return self.token
def _get_token__get_kwargs(self): return { "url": f"{self.base_url}/token", "headers": self.headers, "timeout": self.timeout, "auth": httpx.BasicAuth(username=self.user, password=self.password), }
def __init__( self, host: Optional[str] = None, username: Optional[str] = None, password: Optional[str] = None, proto: Optional[str] = "https", port=None, **kwargs, ): """ Initializes the Device class. As a subclass to httpx.AsyncClient, the Caller can provide any of those initializers. Specific paramertes for Device class are all optional and described below. Parameters ---------- host: Optional[str] The EOS target device, either hostname (DNS) or ipaddress. username: Optional[str] The login user-name; requires the password parameter. password: Optional[str] The login password; requires the username parameter. proto: Optional[str] The protocol, http or https, to communicate eAPI with the device. port: Optional[Union[str,int]] If not provided, the proto value is used to lookup the associated port (http=80, https=443). If provided, overrides the port used to communite with the device. Other Parameters ---------------- base_url: str If provided, the complete URL to the device eAPI endpoint. auth: If provided, used as the httpx authorization initializer value. If not provided, then username+password is assumed by the Caller and used to create a BasicAuth instance. """ self.port = port or getservbyname(proto) self.host = host kwargs.setdefault("base_url", httpx.URL(f"{proto}://{self.host}:{self.port}")) kwargs.setdefault("verify", False) if username and password: self.auth = httpx.BasicAuth(username, password) kwargs.setdefault("auth", self.auth) super(Device, self).__init__(**kwargs) self.headers["Content-Type"] = "application/json-rpc"
def generate_auth(device_info) -> httpx.Auth | None: """Generate httpx.Auth object from credentials.""" username = device_info.get(CONF_USERNAME) password = device_info.get(CONF_PASSWORD) authentication = device_info.get(CONF_AUTHENTICATION) if username: if authentication == HTTP_DIGEST_AUTHENTICATION: return httpx.DigestAuth(username=username, password=password) return httpx.BasicAuth(username=username, password=password) return None
def change_password(current_password: str, new_password: str): username, headers = get_auth_header_and_username() if not username: return url = get_url(f"/user/profile/security/change-password") response = httpx.put( url=url, auth=httpx.BasicAuth(username=username, password=current_password), json=UserUpdatePasswordBodyModel(new_password=new_password).dict(), ) response_handler(response=response, return_model=UserUpdatePasswordResponseModel)
def test_basic_auth(): auth = httpx.BasicAuth(username="******", password="******") request = httpx.Request("GET", "https://www.example.com") # The initial request should include a basic auth header. flow = auth.sync_auth_flow(request) request = next(flow) assert request.headers["Authorization"].startswith("Basic") # No other requests are made. response = httpx.Response(content=b"Hello, world!", status_code=200) with pytest.raises(StopIteration): flow.send(response)
async def _detect_auth_method(self): """Establish the connection with device""" full_url = urljoin(self.host, self.isapi_prefix + '/System/status') for method in [ httpx.BasicAuth(self.login, self.password), httpx.DigestAuth(self.login, self.password), ]: async with httpx.AsyncClient(auth=method) as client: response = await client.get(full_url) if response.status_code == 200: self._auth_method = method if not self._auth_method: response.raise_for_status()
async def _async_publish(self, *, url: str, message: Dict) -> None: """ publish MQ using async http request """ try: r = await self.async_httpx_client.post( url, json=message, auth=httpx.BasicAuth(self.username, self.password), ) self._check_mq_response(r) except MQSendFailedException as e: raise e except Exception as e: raise MQSendFailedException(str(e))
async def request(self, method, url): self.method = method self.rest_url = url async with httpx.AsyncClient( verify=False, auth=httpx.BasicAuth(self.oracle_user, self.oracle_pass), params=self.params, headers=self.headers, timeout=self.timeout) as client: try: r = await client.request(self.method, f'{self.oracle_endpoint}{self.rest_url}', data=self.data, params=self.params) logger.info(f"""{self.__class__.__name__} - {inspect.stack()[1].function} - {r.status_code}""") return r except httpx.HTTPError as e: logger.exception(f"""{self.__class__.__name__} - {inspect.stack()[1].function} - {e}""")
def user_auth(user: Optional[User]): if user is None: return None if user.token is not None: return BearerAuth(user.token) if user.exec: return ExecAuth(user.exec) if user.username and user.password: return httpx.BasicAuth(user.username, user.password) if user.auth_provider: raise ConfigError("auth-provider not supported")
async def process_login(self, code: str, request: Request) -> Optional[OpenID]: """ This method should be called from callback endpoint to verify the user and request user info endpoint. This is low level, you should use {verify_and_process} instead. """ url = request.url scheme = url.scheme if not self.allow_insecure_http and scheme != "https": current_url = str(url).replace("http://", "https://") else: current_url = str(url) current_path = self.redirect_uri token_url, headers, body = self.oauth_client.prepare_token_request( await self.token_endpoint, authorization_response=current_url, redirect_url=current_path, code=code) # type: ignore if token_url is None: return {} auth = httpx.BasicAuth(self.client_id, self.client_secret) async with httpx.AsyncClient() as session: logging.debug(f'redirect_uri: {current_path}') logging.debug(f'request_body: {body}') response = await session.post(token_url, headers=headers, content=body, auth=auth) content = response.json() logging.debug(f'response: {content}') self.oauth_client.parse_request_body_response(json.dumps(content)) uri, headers, _ = self.oauth_client.add_token( await self.userinfo_endpoint) response = await session.get(uri, headers=headers) profile_details = response.json() uri, headers, _ = self.oauth_client.add_token( await self.useremail_endpoint) response = await session.get(uri, headers=headers) content = response.json() profile_details['emailAddress'] = content.get( 'elements', [{}])[0].get('handle~', {}).get('emailAddress') return await self.openid_from_response(profile_details)
def _get_client(self) -> httpx.AsyncClient: if (self.http_username and not self.http_password) or (not self.http_username and self.http_password): raise ValueError( "Both http_username and http_password should be defined") auth = None if self.http_username: auth = httpx.BasicAuth(self.http_username, self.http_password) return self._httpx_client_class( auth=auth, verify=self.ssl_verify, timeout=self.timeout, )
def auth_method(self, value): """Set the authentication method to use for the requests.""" self._auth_method = value if len(self._auth_credentials) == 2: username, password = self._auth_credentials self._auth = None if self._auth_method == "basic": self._auth = httpx.BasicAuth(username, password) elif self._auth_method == "digest": self._auth = httpx.DigestAuth(username, password) elif self._auth_method == "ntlm": # https://github.com/ulodciv/httpx-ntlm from httpx_ntlm import HttpNtlmAuth self._auth = HttpNtlmAuth( username, password) # username in the form domain\user self.client.auth = self._auth
def fetch_token(self, code): body = self.oauth_client.prepare_request_body( code=code, body='', redirect_uri=self.redirect_uri, include_client_id=None) response = self.request( 'POST', self.token_url, headers={ 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8', }, data=dict(urldecode(body)), auth=httpx.BasicAuth(self.client_id, self.client_secret)) self.token = self.oauth_client.parse_request_body_response( response.text, scope=self.scope) return self.token
def accept_legal_document(document_id: str, username: str, password: str): url = get_url(f"/v1/legals/{document_id}/accept") response = httpx.post(url=url, auth=httpx.BasicAuth(username=username, password=password)) response_handler(response=response, print_result=False)
def __init__(self, endpoint, origin='http://localhost:80', name='localhost', username=None, password=None, timeout=30): self.endpoint = endpoint self.origin = origin self.name = name self.timeout = timeout self.http_auth = httpx.BasicAuth(username, password=password) if (username and password) else None
"type": "index-pattern", }, ], }, headers=[("kbn-xsrf", "true")], params={"overwrite": "true"}, ) if __name__ == "__main__": username = getpass.getpass("Kibana username: "******"Kibana password: "******"Kibana endpoint: ") client = httpx.Client(base_url=endpoint, auth=httpx.BasicAuth(username, password)) for service_name in get_service_names(): # Skip services that don't log to Elasticsearch. if any(s in service_name for s in ("logstash_transit", "loris")): continue # For catalogue services that include a date in the service name # (e.g. catalogue-20200701_matcher), replace this with an asterisk (*) # as a wildcard search in ES. # # This avoids us having to recreate the saved searches every time # we redeploy in the catalogue. service_name = re.sub(r"([-_])[0-9-]+([-_]?)", r"\g<1>*\g<2>", service_name).strip("-")