def gen_wss_token(user, passw, method='Digest', nonce=True, created=True): """Method generates WSS token Args: user (str): username passw (str): password method (str): token method Text|Digest nonce (bool): include nonce created (bool): include created Returns: dict """ token = UsernameToken(user, passw) if (nonce): token.setnonce() if (created): token.setcreated() token = {'username': user, 'password': passw, 'nonce': str( token.nonce), 'created': str(token.created)} if (method == 'Digest'): token['created'] = datetime.utcnow().isoformat()[:-3] + 'Z' token['password'] = encodestring( sha1(token['nonce'] + token['created'] + passw).digest())[:-1] token['nonce'] = encodestring(token['nonce'])[:-1] return token
def add_security(client, user, passwd): sec = Security() token = UsernameToken(user, passwd) token.setnonce() token.setcreated() sec.tokens.append(token) client.set_options(wsse=sec)
def __init__(self, username=None, password=None, setcreated=False, setnonce=False, digest=False): if digest: raise NotImplementedError() UsernameToken.__init__(self, username, password) self.autosetcreated = setcreated self.autosetnonce = setnonce
def setSoapHeader(client, username, password): security = Security() token = UsernameToken(username, password) token.setcreated() security.tokens.append(token) if debug: print security client.set_options(wsse=security)
def test_wsse_username_nonce(self): security = Security() token = UsernameToken("username", "password") token.setnonce() token.setcreated() token.setnonceencoding(True) token.setpassworddigest("digest") security.tokens.append(token) assert "<wsu:Created" in str(security.xml())
def __init__(self, username=None, password=None): """ @param username: A username. @type username: str @param password: A password. @type password: str """ UsernameToken.__init__(self, username, password) self.nsprefixes = {}
def __init__(self, username=None, password=None, setcreated=False, setnonce=False, digest=False): UsernameToken.__init__(self, username, password) self.autosetcreated = setcreated self.autosetnonce = setnonce self.digest = digest
def __init__(self, username=None, password=None): UsernameToken.__init__(self, username, password) utc = UsernameToken.utc() utc = datetime(utc.year, utc.month, utc.day, utc.hour, utc.minute, utc.second, tzinfo=utc.tzinfo) self.setcreated(utc) self.setnonce()
def __init__(self, username=None, password=None): UsernameToken.__init__( self, username, password ) utc = UsernameToken.utc() utc = datetime( utc.year, utc.month, utc.day, utc.hour, utc.minute, utc.second, tzinfo=utc.tzinfo ) self.setcreated(utc) self.setnonce()
def __init__(self, username, password, subscriber_id): """ Parameters: :param username: - Username for accessing the BancBox api. This should be an email address :param password: - Password for access the BancBox api. """ # Initialize the suds Client super(BancboxClient, self).__init__(url=WSDL_LOCATION, location=API_URL, plugins=[PasswordTypePlugin()]) # Set WSSE security headers # Create a new SUDS Security object security = Security() # Create a WSSE UsernameToken with the supplied username and password token = UsernameToken(username, password) # Add the token to the Security object security.tokens.append(token) # Set the security settings on the SUDS Client self.set_options(wsse=security) self.subscriber_id = subscriber_id
def add_client(self): logger.info('About to add a client to `%s` (%s)', self.address, self.conn_type) # Lazily-imported here to make sure gevent monkey patches everything well in advance from suds.client import Client from suds.transport.https import HttpAuthenticated from suds.transport.https import WindowsHttpAuthenticated from suds.wsse import Security, UsernameToken sec_type = self.config['sec_type'] if sec_type == SEC_DEF_TYPE.BASIC_AUTH: transport = HttpAuthenticated(**self.suds_auth) elif sec_type == SEC_DEF_TYPE.NTLM: transport = WindowsHttpAuthenticated(**self.suds_auth) elif sec_type == SEC_DEF_TYPE.WSS: security = Security() token = UsernameToken(self.suds_auth['username'], self.suds_auth['password']) security.tokens.append(token) client = Client(self.address, autoblend=True, wsse=security) if sec_type in(SEC_DEF_TYPE.BASIC_AUTH, SEC_DEF_TYPE.NTLM): client = Client(self.address, autoblend=True, transport=transport) # Still could be either none at all or WSS if not sec_type: client = Client(self.address, autoblend=True, timeout=self.config['timeout']) self.client.put_client(client)
def proof_of_delivery(self, shipment_awb, detailed=True): """ Connects to DHL ePOD service, and returns the POD for the requested shipment. :param shipment_awb: shipment waybill or identification number :param detailed: if a detailed POD should be returned, else simple :return: (True, pdf bytes) if successful else (False, [errors]) """ if not self.pod_client: url = self.pod_test_url if self.test_mode else self.pod_url self.pod_client = Client(url, faults=False) security = Security() token = UsernameToken(self.username, self.password) security.tokens.append(token) self.pod_client.set_options(wsse=security) msg = self._create_dhl_shipment_document(shipment_awb, detailed) code, res = self.pod_client.service.ShipmentDocumentRetrieve(msg) if code == 500: return DHLPodResponse(False, errors=[res.detail.detailmessage]) try: img = res.Bd.Shp[0].ShpInDoc[0].SDoc[0].Img[0]._Img return DHLPodResponse(True, img) except: return DHLPodResponse(False, errors=[ error.DatErrMsg.ErrMsgDtl._DtlDsc for error in res.DatTrErr ])
def add_client(): sec_type = self.config['sec_type'] if sec_type == security_def_type.basic_auth: transport = HttpAuthenticated(**self.suds_auth) elif sec_type == security_def_type.ntlm: transport = WindowsHttpAuthenticated(**self.suds_auth) elif sec_type == security_def_type.wss: security = Security() token = UsernameToken(self.suds_auth['username'], self.suds_auth['password']) security.tokens.append(token) client = Client(url, autoblend=True, wsse=security) if sec_type in (security_def_type.basic_auth, security_def_type.ntlm): client = Client(url, autoblend=True, transport=transport) # Still could be either none at all or WSS if not sec_type: client = Client(url, autoblend=True) self.client.queue.put(client) logger.debug('Adding Suds SOAP client to [%s]', url)
def get_client(self, endpoint): class FixMimeMultipart(MessagePlugin): """ StudySubject.listAllByStudy replies with what looks like part of a multipart MIME message(!?) Fix this. """ def received(self, context): reply = context.reply if reply.startswith('------='): matches = re.search( r'(<SOAP-ENV:Envelope.*</SOAP-ENV:Envelope>)', reply) context.reply = matches.group(1) if endpoint not in self._clients: raise ValueError('Unknown OpenClinica API endpoint') if self._clients[endpoint] is None: client = Client( '{url}OpenClinica-ws/ws/{endpoint}/v1/{endpoint}Wsdl.wsdl'. format(url=self._base_url, endpoint=endpoint), plugins=[FixMimeMultipart()]) security = Security() password = hashlib.sha1(self._password).hexdigest( ) # SHA1, not AES as documentation says token = UsernameToken(self._username, password) security.tokens.append(token) client.set_options(wsse=security) self._clients[endpoint] = client return self._clients[endpoint]
def rate_request(self, shipment, message=None): """ Contacts to DHL Rate Request to obtain carrier rates for this shipment :param shipment: DHLShipment object :param message: optional message :return: DHLResponse """ if not self.shipment_client: url = self.shipment_test_url if self.test_mode else \ self.shipment_url self.shipment_client = Client(url, faults=False) security = Security() token = UsernameToken(self.username, self.password) security.tokens.append(token) self.shipment_client.set_options(wsse=security) dhl_shipment = self._create_dhl_shipment_type2(self.shipment_client, shipment) result_code, reply = self.shipment_client.service.getRateRequest( None, dhl_shipment) if result_code == 500: return DHLPodResponse(False, errors=[reply.detail.detailmessage]) for rate_reply in reply: notif = rate_reply.Notification if notif._code != '0': print('[Code: ' + notif._code + ', ' 'Message: ' + notif.Message + ']') return DHLPodResponse(False, errors=[(notif._code, notif.Message)]) return DHLRateResponse(True, rate_reply.Service)
def make(self, authenticator: Authenticator): """Build and configure soap client""" if self._client is None: self._client = SoapClient(self._local_url, faults=False, cachingpolicy=0) if self.debug: logging.basicConfig(level=logging.INFO) logging.getLogger('suds.client').setLevel(logging.DEBUG) logging.getLogger('suds.transport').setLevel(logging.DEBUG) logging.getLogger('suds.xsd.schema').setLevel(logging.DEBUG) logging.getLogger('suds.wsdl').setLevel(logging.DEBUG) else: logging.getLogger('suds').setLevel(logging.INFO) # FIXME # Need make copy by suds.client.clone() method, # but now got this issue https://bitbucket.org/jurko/suds/issues/7/recursion-depth-reached # cl = self._client.clone() cl = self._client cl.set_options(location=authenticator.endpoint) security = Security() token = UsernameToken('*', '*') security.tokens.append(token) cl.set_options(wsse=security) element_oauth = Element('oAuth', ns=('etns', 'http://exacttarget.com')) element_oauth_token = Element('oAuthToken').setText(authenticator.auth_legacy_token) element_oauth.append(element_oauth_token) cl.set_options(soapheaders=[element_oauth]) return cl
def _setup_client(self, faults=False, wsse=False): client_args = { 'url': self.service_url, 'faults': faults, 'plugins': [LogPlugin(self.log_name)], 'timeout': 100, } log.info("Setting up SOAP client with WSDL at {wsdl_url}".format( wsdl_url=self.service_url)) if self.location_url: log.info("Overloading default location url with {url}".format( url=self.location_url)) client_args['location'] = self.location_url if wsse: log.info("Using WSSE for authentication.") security = Security() # noinspection PyTypeChecker security.tokens.append(UsernameToken(self.username, self.password)) client_args['wsse'] = security else: log.info("NOT using WSSE for authentication.") try: suds_client = Client(**client_args) except Exception as error: import traceback log.error(traceback.format_exc()) err_prefix = "Could not create SOAP client at {url}. Error message: {err}" err_msg = err_prefix.format(url=self.service_url, err=unicode(error)) raise BrregClientError(err_msg) self._suds_client = suds_client
def __init__(self): self.username_soa = settings.get("username_soa") self.password_soa = settings.get("password_soa") self.client = Client(self.url) security = Security() security.tokens.append( UsernameToken(self.username_soa, self.password_soa)) self.client.set_options(wsse=security)
def __init__(self, bus_user, bus_pass, wsdl): # Crear client SOA amb Securitiy activat # Obtenim el client amb z3c.suds i no amb suds.Client self.client = get_suds_client(wsdl) security = Security() token = UsernameToken(bus_user, bus_pass) security.tokens.append(token) self.client.set_options(wsse=security)
def create_tokens(response): security = Security() token = UsernameToken(AUTHORIZED_NUI) token.setcreated(response.Fecha) token.nonce_has_encoding = True token.setnonce(response.Nonce) token.setpassworddigest(response.Digest) security.tokens.append(token) token_ts = Timestamp() token_ts.created = response.Fecha token_ts.expires = response.FechaF security.tokens.append(token_ts) return security
def init_client(self): client = Client(self.config.wsdl_url) # Add wsse security security = Security() token = UsernameToken(username=self.config.merchant_id, password=self.config.api_key) security.tokens.append(token) client.set_options(wsse=security) return client
def __init__(self, user_login, user_passwd): """ Initialize a checker object, with authenticated access """ from suds.cache import ObjectCache from suds.wsse import Security, UsernameToken if not (user_login and user_passwd): raise RuntimeError( "You must specify user AFM and token for authentication") security = Security() security.tokens.append(UsernameToken(user_login, user_passwd)) self._client = self._getClient(wsse=security)
def test_wsse_username_token(self): security = Security() token = UsernameToken("username", "password") security.tokens.append(token) expected = """<wsse:Security xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" mustUnderstand="true"> <wsse:UsernameToken> <wsse:Username>username</wsse:Username> <wsse:Password Type="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText">password</wsse:Password> </wsse:UsernameToken> </wsse:Security>""" assert expected == str(security.xml())
def add_tokens(response, student_identity): """ Agregar token de seguridad y de tiempo en header de WS """ security = Security() token = UsernameToken(settings.WS_CONFIG['identity']) token.setcreated(response.Fecha) token.nonce_has_encoding = True token.setnonce(response.Nonce) token.setpassworddigest(response.Digest) security.tokens.append(token) token_ts = Timestamp() token_ts.created = response.Fecha token_ts.expires = response.FechaF security.tokens.append(token_ts) return security
def issue_credit(self, source, amount, currency): order = source.order try: order_request_token = source.reference security = Security() token = UsernameToken(self.merchant_id, self.transaction_key) security.tokens.append(token) client = Client(self.soap_api_url, transport=RequestsTransport()) client.set_options(wsse=security) credit_service = client.factory.create('ns0:CCCreditService') credit_service._run = 'true' # pylint: disable=protected-access credit_service.captureRequestID = source.reference purchase_totals = client.factory.create('ns0:PurchaseTotals') purchase_totals.currency = currency purchase_totals.grandTotalAmount = unicode(amount) response = client.service.runTransaction( merchantID=self.merchant_id, merchantReferenceCode=order.number, orderRequestToken=order_request_token, ccCreditService=credit_service, purchaseTotals=purchase_totals) request_id = response.requestID ppr = self.record_processor_response( suds_response_to_dict(response), transaction_id=request_id, basket=order.basket) except: msg = 'An error occurred while attempting to issue a credit (via CyberSource) for order [{}].'.format( order.number) logger.exception(msg) raise GatewayError(msg) if response.decision == 'ACCEPT': source.refund(amount, reference=request_id) event_type, __ = PaymentEventType.objects.get_or_create( name=PaymentEventTypeName.REFUNDED) PaymentEvent.objects.create(event_type=event_type, order=order, amount=amount, reference=request_id, processor_name=self.NAME) else: raise GatewayError( 'Failed to issue CyberSource credit for order [{order_number}]. ' 'Complete response has been recorded in entry [{response_id}]'. format(order_number=order.number, response_id=ppr.id))
def _build(self): #this is used for performance, wsdl and header will be built on initialization of object to save time and redudancy wsdl_url = 'https://wd2-impl-services1.workday.com/ccx/service/' + self.tenant + '/' + self.wws + '/' + self.version +'?wsdl' print wsdl_url print self.username +'\n' + 'building wsdl for ' + self.wws + ' object' self.client1 = client.Client(wsdl_url) # Wrapping our client call in Security() like this results in submitting # the auth request with PasswordType in headers in the format WD expects. security = Security() token = UsernameToken(self.username, self.password) security.tokens.append(token) self.client1.set_options(wsse=security) print '\n'+ ' wsdl and header has been built'
def parse_wsdl(self): """ Parses WSDL file to determine available services and objects. Sets WSSE security object as well. """ logger.debug("Parsing WSDL: %s...", self.settings['wsdl_path']) self.jasper_client = Client(self.settings['wsdl_path']) # WSSE security security = Security() token = UsernameToken(self.settings['username'], self.settings['password']) security.tokens.append(token) self.jasper_client.set_options(wsse=security, timeout=600)
def init_client(self): try: # create the SOAP client self.client = Client(self.schema_url) except URLError as e: self.log(e, logging.CRITICAL) return None # add WS-Security token security = Security() token = UsernameToken(self.username, self.password) security.tokens.append(token) self.client.set_options(wsse=security) return self.client
def __init__(self, prod_environment, username, password): if not prod_environment: wsdl_path = os.path.join( os.path.dirname(os.path.realpath(__file__)), '../api/test/server.wsdl') else: wsdl_path = os.path.join( os.path.dirname(os.path.realpath(__file__)), '../api/prod/server.wsdl') self.client = Client('file:///%s' % wsdl_path.lstrip('/')) security = Security() token = UsernameToken(username, password) security.tokens.append(token) self.client.set_options(wsse=security)
def __init__(self, wsdl, merchant_id, transaction_security_key, soap_log_prefix="CYBERSOURCE"): self.merchant_id = merchant_id # Build a SOAP client self.client = soap.get_client(wsdl, soap_log_prefix) # Add WSSE Security Header to client security = Security() token = UsernameToken(self.merchant_id, transaction_security_key) security.tokens.append(token) self.client.set_options(wsse=security)
def xml(self): usernametoken = UsernameToken.xml(self) password = usernametoken.getChild('Password') nonce = usernametoken.getChild('Nonce') created = usernametoken.getChild('Created') password.set('Type', 'http://docs.oasis-open.org/wss/2004/01/' 'oasis-200401-wss-username-token-profile-1.0' '#PasswordDigest') s = sha1() s.update(self.raw_nonce) s.update(created.getText()) s.update(password.getText()) password.setText(b64encode(s.digest())) nonce.set('EncodingType', 'http://docs.oasis-open.org/wss/2004' '/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary') return usernametoken
def set_wsse(self, user=None, passwd=None): ''' Basic ws-security auth ''' if user: self.user = user if passwd: self.passwd = passwd security = Security() if self.encrypt: token = UsernameDigestToken(self.user, self.passwd) else: token = UsernameToken(self.user, self.passwd) token.setnonce() token.setcreated() security.tokens.append(token) self.ws_client.set_options(wsse=security)
def getDate(wl): import datetime from suds.client import Client url = "http://10.31.70.153:7049/LoadTrafficRecordsScript/LoadTrafficRecordsScript?WSDL" client = Client(url) from suds.wsse import Security from suds.wsse import UsernameToken security = Security() token = UsernameToken(wl[0], wl[1]) security.tokens.append(token) client.set_options(wsse=security) client.set_options(soapheaders=wl[2]) response = client.service.getCurrentBillingPeriod() if response.results.result[ 0].billingPeriodDate.month == datetime.date.today().month: return None else: return response.results.result[0].billingPeriodDate.strftime('%Y%m')
def __init__(self, webservice_type, host, port, ssl, username, password): url = '' if (ssl): url = 'https://' + host + ':' + port else: url = 'http://' + host + ':' + port if webservice_type == 'configuration': self.wsdlFile = url + '/ws/v9/configurationservice?wsdl' elif webservice_type == 'defect': self.wsdlFile = url + '/ws/v9/defectservice?wsdl' else: raise "unknown web service type: " + webservice_type self.client = Client(self.wsdlFile) self.security = Security() self.token = UsernameToken(username, password) self.security.tokens.append(self.token) self.client.set_options(wsse=self.security)
def pass_security_cert(self): """ https接口需要安全验证 :return: 通过返回true,没有连接信息或者验证失败返回false """ if not self.client: return False else: security = Security() token = UsernameToken(self.user, self.password) security.tokens.append(token) try: self.client.set_options(wsse=security) except AttributeError as e: # print('need a log') self.error_logger.error('%s: %s' % (self.app_name, e.args[0])) MailHandler().send_mail(e.args[0], self.url) return False else: return True
def workday_client_login(*args, **kwargs): wsdl_url = kwargs['wsdl_url'] username = kwargs['username'] password = kwargs['password'] proxy = kwargs['proxy'] client_return = None print "Connecting to wsdl_url ..." try: if (proxy.strip() != ""): client_return = client.Client(wsdl_url, proxy={'https': proxy}) else: client_return = client.Client(wsdl_url) security = Security() token = UsernameToken(username, password) security.tokens.append(token) client_return.set_options(wsse=security) except Exception as e: print(e) return client_return print("Logged In to: " + wsdl_url) return client_return
def __init__(self, username=None, password=None): UsernameToken.__init__(self, username, password) self.setcreated() self.setnonce()
def setcreated(self, *args, **kwargs): UsernameToken.setcreated(self, *args, **kwargs) self.created = str(UTC(self.created))
def setcreated(self, *args, **kwargs): dt_adjusted = None if self.dt_diff : dt_adjusted = (self.dt_diff + dt.datetime.utcnow()) UsernameToken.setcreated(self, dt=dt_adjusted, *args, **kwargs) self.created = str(UTC(self.created))
def setcreated(self, *args, **kwargs): UsernameToken.setcreated(self, *args, **kwargs) if self.created is None : self.created = dt.datetime.utcnow() self.created = str(DateTime(self.created))
def setcreated(self, *args, **kwargs): UsernameToken.setcreated(self, *args, **kwargs) if is_debian_based: self.created = str(self.created.replace(tzinfo=UtcTimezone())) else: self.created = str(UTC(self.created))