Пример #1
0
Файл: wsse.py Проект: ichux/suds
 def xml(self):
     """
     Get xml representation of the object.
     @return: The root node.
     @rtype: L{Element}
     """
     root = Element('UsernameToken', ns=wssens)
     u = Element('Username', ns=wssens)
     u.setText(self.username)
     root.append(u)
     p = Element('Password', ns=wssens)
     p.setText(self.password)
     if self.password_digest:
         p.set("Type", wsdigest)
         p.setText(self.password_digest)
     else:
         p.set("Type", wstext)
     root.append(p)
     if self.nonce is not None:
         n = Element('Nonce', ns=wssens)
         if self.nonce_has_encoding:
             n.set("EncodingType", nonce_encoding_type)
         n.setText(self.nonce)
         root.append(n)
     if self.created is not None:
         n = Element('Created', ns=wsuns)
         n.setText(str(DateTime(self.created)))
         root.append(n)
     return root
Пример #2
0
    def build_soap_client(self):
        if self.soap_endpoint is None or not self.soap_endpoint:
            self.soap_endpoint = self.get_soap_endpoint()

        self.soap_client = suds.client.Client(self.wsdl_file_url,
                                              faults=False,
                                              cachingpolicy=1)
        self.soap_client.set_options(location=self.soap_endpoint)
        self.soap_client.set_options(
            headers={"user-agent": "FuelSDK-Python-v1.3.0"})

        if self.use_oAuth2_authentication == "True":
            element_oAuth = Element("fueloauth",
                                    ns=("etns", "http://exacttarget.com"))
            element_oAuth.setText(self.authToken)
            self.soap_client.set_options(soapheaders=(element_oAuth))
        else:
            element_oAuth = Element("oAuth",
                                    ns=("etns", "http://exacttarget.com"))
            element_oAuthToken = Element("oAuthToken").setText(
                self.internalAuthToken)
            element_oAuth.append(element_oAuthToken)
            self.soap_client.set_options(soapheaders=(element_oAuth))

            security = suds.wsse.Security()
            token = suds.wsse.UsernameToken("*", "*")
            security.tokens.append(token)
            self.soap_client.set_options(wsse=security)
Пример #3
0
    def build_soap_client(self):
        if self.soap_endpoint is None or not self.soap_endpoint:
            self.soap_endpoint = self.get_soap_endpoint()

        self.soap_client = suds.client.Client(self.wsdl_file_url,
                                              faults=False,
                                              cachingpolicy=1)
        self.soap_client.set_options(location=self.soap_endpoint)
        self.soap_client.set_options(
            headers={'user-agent': 'FuelSDK-Python-v1.2.0'})

        if self.use_oAuth2_authentication == 'True':
            element_oAuth = Element('fueloauth',
                                    ns=('etns', 'http://exacttarget.com'))
            element_oAuth.setText(self.authToken)
            self.soap_client.set_options(soapheaders=(element_oAuth))
        else:
            element_oAuth = Element('oAuth',
                                    ns=('etns', 'http://exacttarget.com'))
            element_oAuthToken = Element('oAuthToken').setText(
                self.internalAuthToken)
            element_oAuth.append(element_oAuthToken)
            self.soap_client.set_options(soapheaders=(element_oAuth))

            security = suds.wsse.Security()
            token = suds.wsse.UsernameToken('*', '*')
            security.tokens.append(token)
            self.soap_client.set_options(wsse=security)
Пример #4
0
 def xml(self):
     """
     Get xml representation of the object.
     @return: The root node.
     @rtype: L{Element}
     """
     root = Element('UsernameToken', ns=wssens)
     u = Element('Username', ns=wssens)
     u.setText(self.username)
     root.append(u)
     p = Element('Password', ns=wssens)
     p.setText(self.password)
     if self.password_digest:
         p.set('Type', wsdigest)
         p.setText(self.password_digest)
     root.append(p)
     if self.nonce is not None:
         n = Element('Nonce', ns=wssens)
         if self.nonce_has_encoding:
             n.set('EncodingType', nonce_encoding_type)
         n.setText(self.nonce)
         root.append(n)
     if self.created is not None:
         n = Element('Created', ns=wsuns)
         n.setText(str(DateTime(self.created)))
         root.append(n)
     return root
Пример #5
0
 def xml(self):
     """
     Get xml representation of the object.
     @return: The root node.
     @rtype: L{Element}
     """
     root = Element('UsernameToken', ns=wssens)
     u = Element('Username', ns=wssens)
     u.setText(self.username)
     root.append(u)
     p = Element('Password', ns=wssens)
     p.setText(self.password)
     p.set(
         'Type', 'http://docs.oasis-open.org/wss/2004/01/'
         'oasis-200401-wss-username-token-profile-1.0#' +
         ('PasswordDigest' if self.digest else 'PasswordText'))
     root.append(p)
     if self.nonce is not None:
         n = Element('Nonce', ns=wssens)
         if self.digest:
             n.set(
                 'EncodingType', 'http://docs.oasis-open.org/wss/2004'
                 '/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary'
             )
             n.setText(b64encode(self.nonce))
         else:
             n.setText(self.nonce)
         root.append(n)
     if self.created is not None:
         n = Element('Created', ns=wsuns)
         n.setText(str(UTC(self.created)))
         root.append(n)
     return root
Пример #6
0
 def to_xml(self, factory):
     # Dear Docdata: apparently, reusing Vat was not possible..?
     #node = factory.create('ns0:totalVatAmount') does not support setting text.
     element = Element('ns0:totalVatAmount')
     element.setText(str(int(self.value * 100)))
     element.set('rate', self.rate)
     element.set('currency', self.currency)
     return element
Пример #7
0
 def to_xml(self, factory):
     # Dear Docdata: apparently, reusing Vat was not possible..?
     #node = factory.create('ns0:totalVatAmount') does not support setting text.
     element = Element('ns0:totalVatAmount')
     element.setText(str(int(self.value * 100)))
     element.set('rate', self.rate)
     element.set('currency', self.currency)
     return element
Пример #8
0
 def to_xml(self, factory):
     # make sure the namespace is set to the correct one
     metadata = factory.resolver.find('ns0:totalVatAmount')
     element = Element("totalVatAmount", ns=metadata.namespace())
     element.setText(str(int(self.value * 100)))
     element.set('rate', self.rate)
     element.set('currency', self.currency)
     return element
Пример #9
0
 def _setupNationalRailClient(self):
     logging.info('Setting up national rail client')
     token = Element('AccessToken', ns=DARWIN_WEBSERVICE_NAMESPACE)
     val = Element('TokenValue', ns=DARWIN_WEBSERVICE_NAMESPACE)
     val.setText(DARWIN_TOKEN)
     token.append(val)
     client = Client(LDBWS_URL)
     client.set_options(soapheaders=token)
     self.nationalRailClient = client
Пример #10
0
 def xml(self):
     root = Element("Timestamp", ns=wsuns)
     created = Element('Created', ns=wsuns)
     created.setText(str(UTC(self.created)))
     expires = Element('Expires', ns=wsuns)
     expires.setText(str(UTC(self.expires)))
     root.append(created)
     root.append(expires)
     return root
Пример #11
0
 def xml(self):
     root = Element("Timestamp", ns=wsuns)
     created = Element('Created', ns=wsuns)
     created.setText(str(DateTime(self.created)))
     expires = Element('Expires', ns=wsuns)
     expires.setText(str(DateTime(self.expires)))
     root.append(created)
     root.append(expires)
     return root
Пример #12
0
 def xml(self):
     root = Element("Timestamp", ns=wsuns)
     # xsd:datetime format does not have fractional seconds
     created = Element("Created", ns=wsuns)
     created.setText(str(UTC(self.created - timedelta(microseconds=self.created.microsecond))))
     expires = Element("Expires", ns=wsuns)
     expires.setText(str(UTC(self.expires - timedelta(microseconds=self.expires.microsecond))))
     root.append(created)
     root.append(expires)
     return root
Пример #13
0
    def to_xml(self, factory):
        # Needs to be an xsd:int with an attribute
        # Can't do that with factory.create('ns0:quantity')
        #metadata = factory.resolver.find('ns0:quantity')
        #ns = metadata.namespace()

        element = Element('ns0:quantity')
        element.setText(str(self.value))
        element.set('unitOfMeasure', self.unit)
        return element
Пример #14
0
    def to_xml(self, factory):
        # Needs to be an xsd:int with an attribute
        # Can't do that with factory.create('ns0:quantity')
        #metadata = factory.resolver.find('ns0:quantity')
        #ns = metadata.namespace()

        element = Element('ns0:quantity')
        element.setText(str(self.value))
        element.set('unitOfMeasure', self.unit)
        return element
Пример #15
0
def encryptMessage(cert, symmetric_key, elements_to_encrypt, enc_key_uri, reference_type=KEY_REFERENCE_ISSUER_SERIAL, key_transport=KEY_TRANSPORT_RSA_OAEP):
    sym_key = symmetric_key.sym_key
    iv = symmetric_key.iv
    block_encryption = symmetric_key.block_encryption_algorithm

    reference_list = Element("ReferenceList", ns=wsencns)

    for (element_to_encrypt, type) in elements_to_encrypt:
        reference = Element("DataReference", ns=wsencns)
        id = "EncDataId-" + str(generate_unique_id())
        reference.set("URI", '#' + id)
        reference_list.append(reference)

        element_content = element_to_encrypt.canonical()
        if type == 'Content':
            element_content = element_content[element_content.index(">") + 1:element_content.rindex("<")]
        enc_data = Element("EncryptedData", ns=wsencns)
        enc_data.set("Id", id)
        enc_data.set("Type", "http://www.w3.org/2001/04/xmlenc#" + type)
        
        block_encryption_props = blockEncryptionProperties[block_encryption]
        enc_method = Element("EncryptionMethod", ns=wsencns)
        enc_method.set("Algorithm", block_encryption_props['uri'])
        
        key_info = Element("KeyInfo", ns=dsns)
        sec_token_ref = Element("SecurityTokenReference", ns=wssens)
        wsse_reference = Element("Reference", ns=wssens)
        wsse_reference.set("URI", enc_key_uri)
        sec_token_ref.append(wsse_reference)
        key_info.append(sec_token_ref)
        
        cipher_data = Element("CipherData", ns=wsencns)
        cipher_value = Element("CipherValue", ns=wsencns)
        cipher = EVP.Cipher(alg=blockEncryptionProperties[block_encryption]['openssl_cipher'], key=sym_key, iv=iv, op=1, padding=0)
        pad_bytes = block_encryption_props['block_size'] - len(element_content) % block_encryption_props['block_size']
        element_content = element_content + ' ' * (pad_bytes - 1) + chr(pad_bytes)
        enc_content = cipher.update(element_content.encode("utf-8"))
        enc_content = enc_content + cipher.final()
        enc_content = iv + enc_content
        cipher_value.setText(b64encode(enc_content))
        cipher_data.append(cipher_value)

        enc_data.append(enc_method)
        enc_data.append(key_info)
        enc_data.append(cipher_data)
        
        if type == 'Element':
            element_to_encrypt.parent.replaceChild(element_to_encrypt, enc_data)
        elif type == 'Content':
            element_to_encrypt.setText('')
            for child in element_to_encrypt.children:
                element_to_encrypt.remove(child)
            element_to_encrypt.append(enc_data)
    
    return reference_list
 def xml(self):
     self.created = Token.utc()
     root = Element("Timestamp", ns=WSUNS)
     created = Element('Created', ns=WSUNS)
     created.setText(self._trim_to_ms(str(UTC(self.created))))
     root.append(created)
     if self.validity is not None:
         self.expires = self.created + timedelta(seconds=self.validity)
         expires = Element('Expires', ns=WSUNS)
         expires.setText(self._trim_to_ms(str(UTC(self.expires))))
         root.append(expires)
     return root
Пример #17
0
 def xml(self):
     self.created = datetime.utcnow()
     root = Element("Timestamp", ns=WSUNS)
     created = Element('Created', ns=WSUNS)
     created.setText(iso_utc(self.created))
     root.append(created)
     if self.validity is not None:
         self.expires = self.created + timedelta(seconds=self.validity)
         expires = Element('Expires', ns=WSUNS)
         expires.setText(iso_utc(self.expires))
         root.append(expires)
     return root
Пример #18
0
 def connect(self):
     from .client import SmsClient
     from suds.sax.element import Element
     self.client = SmsClient(self._vim.server_fqdn)
     session = eval(list(self._vim.client.client.options.transport.cookiejar)[0].value)
     cookie = Element("vcSessionCookie")
     cookie.setText(session)
     self.client.wsdl.options.__pts__.set("soapheaders", cookie)
     ref = Property('ServiceInstance')
     ref._type = 'ServiceInstance'
     self.service_instance = SmsServiceInstance(self, name='ServiceInstance', ref=ref)
     self.connected = True
Пример #19
0
 def xml(self):
     self.created = Token.utc()
     root = Element("Timestamp", ns=WSUNS)
     created = Element('Created', ns=WSUNS)
     created.setText(self._trim_to_ms(str(UTC(self.created))))
     root.append(created)
     if self.validity is not None:
         self.expires = self.created + timedelta(seconds=self.validity)
         expires = Element('Expires', ns=WSUNS)
         expires.setText(self._trim_to_ms(str(UTC(self.expires))))
         root.append(expires)
     return root
Пример #20
0
 def xml(self):
     self.created = datetime.utcnow()
     root = Element("Timestamp", ns=WSUNS)
     created = Element('Created', ns=WSUNS)
     created.setText(iso_utc(self.created))
     root.append(created)
     if self.validity is not None:
         self.expires = self.created + timedelta(seconds=self.validity)
         expires = Element('Expires', ns=WSUNS)
         expires.setText(iso_utc(self.expires))
         root.append(expires)
     return root
Пример #21
0
 def xml(self):
     """
     Get xml representation of the object.
     @return: The root node.
     @rtype: L{Element}
     """
     root = Element('UsernameToken', ns=wssens)
     u = Element('Username', ns=wssens)
     u.setText(self.username)
     root.append(u)
     p = Element('Password', ns=wssens)
     p.setText(self.password)
     root.append(p)
     if self.nonce is not None:
         n = Element('Nonce', ns=wssens)
         n.setText(self.nonce)
         root.append(n)
     if self.created is not None:
         n = Element('Created', ns=wsuns)
         n.setText(
             str(
                 UTC(self.created -
                     timedelta(microseconds=self.created.microsecond))))
         root.append(n)
     return root
Пример #22
0
 def xml(self):
     """
     Get xml representation of the object.
     @return: The root node.
     @rtype: L{Element}
     """
     root = Element('UsernameToken', ns=wssens)
     root.set('wsu:Id', 'UsernameToken-%i' % hash(self))
     u = Element('Username', ns=wssens)
     u.setText(self.username)
     root.append(u)
     p = Element('Password', ns=wssens)
     p.setText(self.password)
     # The Type attribute defaults to PasswordText, but some endpoints
     # seem to want it specified anyway.
     p.set('Type', PASSWORD_TYPES['plain'])
     root.append(p)
     if self.nonce is not None:
         n = Element('Nonce', ns=wssens)
         n.setText(self.nonce)
         root.append(n)
     if self.created is not None:
         n = Element('Created', ns=wsuns)
         n.setText(self.created.isoformat())
         root.append(n)
     return root
Пример #23
0
    def xml(self):
        """
        Get xml representation of the object.
        @return: The root node.
        @rtype: L{Element}
        """
        root = Element('UsernameToken', ns=WSSE_NS)
        for p, u in self.nsprefixes.items():
            root.addPrefix(p, u)
        root.append(Attribute('wsu:Id', 'UsernameToken-9'))
        root.append(Attribute('xmlns:wsu', WSU_URI))

        u = Element('Username', ns=WSSE_NS)
        u.setText(self.username)
        root.append(u)
        p = Element('Password', ns=WSSE_NS)
        p.setText(self.password)
        p.append(Attribute('Type', WSU_UN_URI))
        root.append(p)
        if self.nonce is not None:
            n = Element('Nonce', ns=WSSE_NS)
            n.setText(self.nonce)
            root.append(n)
        if self.created is not None:
            n = Element('Created', ns=WSU_NS)
            n.setText(str(UTC(self.created)))
            root.append(n)
        return root
Пример #24
0
    def xml(self):
        usernametoken = Element("UsernameToken", ns=wssens)

        username = Element("Username", ns=wssens)
        username.setText(self.username)
        usernametoken.append(username)

        password = Element("Password", ns=wssens)
        s = hashlib.sha1()
        s.update(self.nonce)
        s.update(self._print_datetime(self.created).encode("utf-8"))
        s.update(self.password.encode("utf-8"))
        password.setText(b64encode(s.digest()).decode("utf-8"))
        password.set(
            "Type",
            "http://docs.oasis-open.org/wss/2004/01/" "oasis-200401-wss-username-token-profile-1.0" "#PasswordDigest",
        )
        usernametoken.append(password)

        nonce = Element("Nonce", ns=wssens)
        nonce.setText(b64encode(self.nonce).decode("utf-8"))
        nonce.set(
            "EncodingType",
            "http://docs.oasis-open.org/wss/2004" "/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary",
        )
        usernametoken.append(nonce)

        created = Element("Created", ns=wsuns)
        created.setText(self._print_datetime(self.created))
        usernametoken.append(created)

        return usernametoken
Пример #25
0
    def xml(self):
        """
        Get xml representation of the object.
        @return: The root node.
        @rtype: L{Element}
        """
        root = Element('UsernameToken', ns=wssens)

        u = Element('Username', ns=wssens)
        u.setText(self.username)
        root.append(u)

        p = Element('Password', ns=wssens)
        p.setText(self.generate_digest())
        p.set(wspassd[0], wspassd[1])
        root.append(p)

        n = Element('Nonce', ns=wssens)
        n.setText(base64.encodestring(self.nonce)[:-1])
        n.set(wsenctype[0], wsenctype[1])
        root.append(n)

        n = Element('Created', ns=wsuns)
        n.setText(self.created)
        root.append(n)

        self.reset()
        return root
Пример #26
0
    def _create_wsse_header(self, username, password):
        username_element = Element('wsse:Username')
        username_element.setText(username)

        password_element = Element('wsse:Password')
        password_element.set('Type', 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText')
        password_element.setText(sha256(password.encode()).hexdigest())

        nonce = Element('wsse:Nonce')
        nonce.set('EncodingType', 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary')
        nonce.setText(base64.b64encode(os.urandom(64)))

        bogota_tz = pytz.timezone('America/Bogota')
        created = Element('wsu:Created')
        created.setText(pytz.utc.localize(datetime.now()).astimezone(bogota_tz).strftime('%Y-%m-%dT%H:%M:%S.000-05:00'))

        username_token = Element('wsse:UsernameToken')
        username_token.set('wsu:Id', 'UsernameToken-1')
        username_token.append(username_element)
        username_token.append(password_element)
        username_token.append(nonce)
        username_token.append(created)

        header = Element('wsse:Security').append(username_token)

        return header
Пример #27
0
 def xml(self):
     if self.digest and self.password is None:
         raise RuntimeError("Cannot generate password digest without the password.")
     if self.autosetnonce:
         self.setnonce()
     if self.autosetcreated:
         self.setcreated()
     root = Element('UsernameToken', ns=WSSENS)
     u = Element('Username', ns=WSSENS)
     u.setText(self.username)
     root.append(u)
     if self.password is not None:
         password = self.password
         if self.digest:
             password = self.get_digest()
         p = Element('Password', ns=WSSENS)
         p.setText(password)
         p.set('Type', DIGEST_TYPE if self.digest else TEXT_TYPE)
         root.append(p)
     if self.nonce is not None:
         n = Element('Nonce', ns=WSSENS)
         n.setText(base64.encodestring(self.nonce)[:-1])
         n.set('EncodingType', BASE64_ENC_TYPE)
         root.append(n)
     if self.created:
         c = Element('Created', ns=WSUNS)
         c.setText(iso_utc(self.created))
         root.append(c)
     return root
Пример #28
0
    def xml(self):
        usernametoken = Element('UsernameToken', ns=wssens)

        username = Element('Username', ns=wssens)
        username.setText(self.username)
        usernametoken.append(username)

        password = Element('Password', ns=wssens)
        s = hashlib.sha1()
        s.update(self.nonce)
        s.update(self._print_datetime(self.created).encode('utf-8'))
        s.update(self.password.encode('utf-8'))
        password.setText(b64encode(s.digest()).decode('utf-8'))
        password.set(
            'Type', 'http://docs.oasis-open.org/wss/2004/01/'
            'oasis-200401-wss-username-token-profile-1.0'
            '#PasswordDigest')
        usernametoken.append(password)

        nonce = Element('Nonce', ns=wssens)
        nonce.setText(b64encode(self.nonce).decode('utf-8'))
        nonce.set(
            'EncodingType', 'http://docs.oasis-open.org/wss/2004'
            '/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary')
        usernametoken.append(nonce)

        created = Element('Created', ns=wsuns)
        created.setText(self._print_datetime(self.created))
        usernametoken.append(created)

        return usernametoken
Пример #29
0
    def xml(self):
        """
		Get xml representation of the object.
		@return: The root node.
		@rtype: L{Element}
		"""
        root = Element('UsernameToken', ns=wssens)
        u = Element('Username', ns=wssens)
        u.setText(self.username)
        root.append(u)
        p = Element('Password', ns=wssens)
        p.setText(self.password)
        root.append(p)
        if self.nonce is not None:
            n = Element('Nonce', ns=wssens)
            n.setText(self.nonce)
            root.append(n)
        if self.created is not None:
            n = Element('Created', ns=wsuns)
            n.setText(self.created)
            #txt=str(DateTime(self.created))
            #txt=txt.replace('Z', '')

            #n.setText(txt)
            root.append(n)
        return root
Пример #30
0
    def xml(self):
        """
		Get xml representation of the object.
		@return: The root node.
		@rtype: L{Element}
		"""
        root = Element('UsernameToken', ns=wssens)

        u = Element('Username', ns=wssens)
        u.setText(self.username)
        root.append(u)

        p = Element('Password', ns=wssens)
        p.setText(self.generate_digest())
        p.set(wspassd[0], wspassd[1])
        root.append(p)

        n = Element('Nonce', ns=wssens)
        nonce_bytes = self.nonce
        if not isinstance(self.nonce, bytes):
            nonce_bytes = self.nonce.encode('utf-8')

        n.setText(base64.encodebytes(nonce_bytes)[:-1])
        n.set(wsenctype[0], wsenctype[1])
        root.append(n)

        n = Element('Created', ns=wsuns)
        n.setText(self.created)
        root.append(n)

        self.reset()
        return root
Пример #31
0
    def xml(self):
        usernametoken = Element('UsernameToken', ns=wssens)

        username = Element('Username', ns=wssens)
        username.setText(self.username)
        usernametoken.append(username)

        password = Element('Password', ns=wssens)
        s = hashlib.sha1()
        s.update(self.nonce)
        s.update(self._print_datetime(self.created).encode('utf-8'))
        s.update(self.password.encode('utf-8'))
        password.setText(b64encode(s.digest()).decode('utf-8'))
        password.set('Type', 'http://docs.oasis-open.org/wss/2004/01/'
                             'oasis-200401-wss-username-token-profile-1.0'
                             '#PasswordDigest')
        usernametoken.append(password)

        nonce = Element('Nonce', ns=wssens)
        nonce.setText(b64encode(self.nonce).decode('utf-8'))
        nonce.set(
            'EncodingType',
            'http://docs.oasis-open.org/wss/2004'
            '/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary'
        )
        usernametoken.append(nonce)

        created = Element('Created', ns=wsuns)
        created.setText(self._print_datetime(self.created))
        usernametoken.append(created)

        return usernametoken
Пример #32
0
 def xml(self):
     if self.digest and self.password is None:
         raise RuntimeError("Cannot generate password digest without the password.")
     if self.autosetnonce:
         self.setnonce()
     if self.autosetcreated:
         self.setcreated()
     root = Element('UsernameToken', ns=WSSENS)
     u = Element('Username', ns=WSSENS)
     u.setText(self.username)
     root.append(u)
     if self.password is not None:
         password = self.password
         if self.digest:
             password = self.get_digest()
         p = Element('Password', ns=WSSENS)
         p.setText(password)
         p.set('Type', DIGEST_TYPE if self.digest else TEXT_TYPE)
         root.append(p)
     if self.nonce is not None:
         n = Element('Nonce', ns=WSSENS)
         n.setText(base64.encodestring(self.nonce)[:-1])
         n.set('EncodingType', BASE64_ENC_TYPE)
         root.append(n)
     if self.created:
         c = Element('Created', ns=WSUNS)
         c.setText(str(UTC(self.created)))
         root.append(c)
     return root
Пример #33
0
    def to_xml(self, factory):
        # Needs to be an xsd:int with an attribute. Suds is not
        # responding nicely with basic types combined with attributes, so
        # we can't do that with factory.create('ns0:quantity')
        #
        # See also:
        # https://stackoverflow.com/questions/13103023/how-can-i-assign-a-value-to-a-factory-created-simpletype-object-with-python-suds

        # make sure the namespace is set to the correct one
        metadata = factory.resolver.find('ns0:quantity')
        element = Element("quantity", ns=metadata.namespace())

        element.setText(str(self.value))
        element.set('unitOfMeasure', self.unit)
        return element
Пример #34
0
 def connect(self):
     from .client import SmsClient
     from suds.sax.element import Element
     self.client = SmsClient("{0}:8443".format(self._vim.server_fqdn))
     session = eval(
         list(self._vim.client.client.options.transport.cookiejar)[0].value)
     cookie = Element("vcSessionCookie")
     cookie.setText(session)
     self.client.wsdl.options.__pts__.set("soapheaders", cookie)
     ref = Property('ServiceInstance')
     ref._type = 'ServiceInstance'
     self.service_instance = SmsServiceInstance(self,
                                                name='ServiceInstance',
                                                ref=ref)
     self.connected = True
Пример #35
0
 def xml(self):
     root = Element("Timestamp", ns=wsuns)
     # xsd:datetime format does not have fractional seconds
     created = Element('Created', ns=wsuns)
     created.setText(
         str(
             UTC(self.created -
                 timedelta(microseconds=self.created.microsecond))))
     expires = Element('Expires', ns=wsuns)
     expires.setText(
         str(
             UTC(self.expires -
                 timedelta(microseconds=self.expires.microsecond))))
     root.append(created)
     root.append(expires)
     return root
Пример #36
0
 def xml(self):
     """
     Get xml representation of the object.
     @return: The root node.
     @rtype: L{Element}
     """
     root = Element('Timestamp', ns=wsuns)
     root.set('wsu:Id', 'Timestamp-%i' % hash(self))
     c = Element('Created', ns=wsuns)
     c.setText(self.created.isoformat())
     root.append(c)
     if self.expires:
         e = Element('Expires', ns=wsuns)
         e.setText(self.expires.isoformat())
         root.append(e)
     return root
Пример #37
0
    def build_soap_header(self, el, data):
        """Set up a SOAP object for our headers"""
        ## make our first element
        for name in data:
            if type(data[name]) is dict:
                ## append to the current element
                nel = Element(name)
                el.children.append(nel)
                self.build_soap_header(nel, data[name])
            else:
                opt = Element(name)
                opt.setText(data[name])
                el.children.append(opt)
                # print "{name} - {data}".format(name=name,data=data[name])

        return el
Пример #38
0
 def __init__(self, key):
     """
     input - 'key' - your unique access token.
     """
     self.key = key
     self.url = 'https://lite.realtime.nationalrail.co.uk/OpenLDBWS/wsdl.aspx?ver=2017-10-01'
     self.namespace = ('ns2',
                       'http://thalesgroup.com/RTTI/2013-11-28/Token/types')
     self.header = Element('AccessToken', ns=self.namespace)
     header_val = Element('TokenValue',
                          ns=self.namespace,
                          parent=self.header)
     header_val.setText(key)
     self.header.append(header_val)
     self.__client = Client(self.url)
     self.__client.set_options(soapheaders=self.header)
def describe_vehicle_failure2(vin):
    """This fails because there is a bug related when prettyxml is False
    https://fedorahosted.org/suds/ticket/432
    """
    client = Client(CHROME_URL)

    account_info = client.factory.create('AccountInfo')
    account_info._number = CHROME_ACCOUNT_NUMBER
    account_info._secret = CHROME_ACCOUNT_SECRET
    account_info._country = 'US'
    account_info._language = 'en'

    vin_element = Element('vin', ns=('ns1', 'urn:description7a.services.chrome.com'))
    vin_element.setText(vin)

    result = client.service.describeVehicle(account_info, vin_element)
    print result
Пример #40
0
def describe_vehicle_failure2(vin):
    """This fails because there is a bug related when prettyxml is False
    https://fedorahosted.org/suds/ticket/432
    """
    client = Client(CHROME_URL)

    account_info = client.factory.create('AccountInfo')
    account_info._number = CHROME_ACCOUNT_NUMBER
    account_info._secret = CHROME_ACCOUNT_SECRET
    account_info._country = 'US'
    account_info._language = 'en'

    vin_element = Element('vin',
                          ns=('ns1', 'urn:description7a.services.chrome.com'))
    vin_element.setText(vin)

    result = client.service.describeVehicle(account_info, vin_element)
    print result
Пример #41
0
    def create_element(self,
                       name,
                       ns=None,
                       prefix=None,
                       attrs=None,
                       text=None):
        """Создание нового элемента"""
        new_element = Element(name, ns=ns)
        if prefix:
            new_element.setPrefix(prefix)

        if attrs:
            for k, v in attrs.items():
                new_element.set(k, v)

        if text:
            new_element.setText(text)
        return new_element
def describe_vehicle_success_with_never_unwrap_output_patch(vin):
    """This uses a patched version of suds which never tries to unwrap the output message
    """
    # NOTE: prettyxml must be set to True in order to add `vin_element` below
    # https://fedorahosted.org/suds/ticket/432
    client = Client(CHROME_URL, prettyxml=True, never_unwrap_output=True)

    account_info = client.factory.create('AccountInfo')
    account_info._number = CHROME_ACCOUNT_NUMBER
    account_info._secret = CHROME_ACCOUNT_SECRET
    account_info._country = 'US'
    account_info._language = 'en'

    vin_element = Element('vin', ns=('ns1', 'urn:description7a.services.chrome.com'))
    vin_element.setText(vin)

    result = client.service.describeVehicle(account_info, vin_element)
    print str(result)[:1000]
    print result._bestMakeName
def create_version():
    el = Element('Version')
    el.setPrefix('ns0')

    major_release = Element('majorRelease')
    major_release.setPrefix('ns0')
    major_release.setText('1')
    el.append(major_release)

    minor_release = Element('minorRelease')
    minor_release.setPrefix('ns0')
    minor_release.setText('18')
    el.append(minor_release)

    return {
        'majorRelease': '1',
        'minorRelease': '0',
    }

    return el
def describe_vehicle_failure3(vin):
    """This fails becuase attributes on the root of the response element, such
    as bestMakeName, are not available
    """
    # NOTE: prettyxml must be set to True in order to add `vin_element` below
    # https://fedorahosted.org/suds/ticket/432
    client = Client(CHROME_URL, prettyxml=True)

    account_info = client.factory.create('AccountInfo')
    account_info._number = CHROME_ACCOUNT_NUMBER
    account_info._secret = CHROME_ACCOUNT_SECRET
    account_info._country = 'US'
    account_info._language = 'en'

    vin_element = Element('vin', ns=('ns1', 'urn:description7a.services.chrome.com'))
    vin_element.setText(vin)

    result = client.service.describeVehicle(account_info, vin_element)
    print str(result)[:1000]
    print result._bestMakeName
def create_version():
    el = Element('Version')
    el.setPrefix('ns0')

    major_release = Element('majorRelease')
    major_release.setPrefix('ns0')
    major_release.setText('1')
    el.append(major_release)

    minor_release = Element('minorRelease')
    minor_release.setPrefix('ns0')
    minor_release.setText('18')
    el.append(minor_release)

    return {
        'majorRelease': '1',
        'minorRelease': '0',
    }

    return el
Пример #46
0
 def __init__(self, internal_oauth_token, url=None):
     self.client = Client(settings.EXACTTARGET_SOAP_WSDL_URL)
     # Make easy the access to the types
     self.valid_types = []
     for valid_type in self.client.sd[0].types:
         self.valid_types.append(valid_type[0].name)
     if url:
         self.client.set_options(location=url)
     # Add the default Security in the header
     security = Security()
     token = UsernameToken('*', '*')
     security.tokens.append(token)
     self.client.set_options(wsse=security)
     # Add oAuth token to SOAP header.
     ns = (None, constants.OAUTH_HEADER_URL)
     oauth_header = Element("oAuth", ns=ns)
     oauth_element = Element("oAuthToken")
     oauth_element.setText(internal_oauth_token)
     oauth_header.append(oauth_element)
     self.client.set_options(soapheaders=oauth_header)
Пример #47
0
def describe_vehicle_success_with_never_unwrap_output_patch(vin):
    """This uses a patched version of suds which never tries to unwrap the output message
    """
    # NOTE: prettyxml must be set to True in order to add `vin_element` below
    # https://fedorahosted.org/suds/ticket/432
    client = Client(CHROME_URL, prettyxml=True, never_unwrap_output=True)

    account_info = client.factory.create('AccountInfo')
    account_info._number = CHROME_ACCOUNT_NUMBER
    account_info._secret = CHROME_ACCOUNT_SECRET
    account_info._country = 'US'
    account_info._language = 'en'

    vin_element = Element('vin',
                          ns=('ns1', 'urn:description7a.services.chrome.com'))
    vin_element.setText(vin)

    result = client.service.describeVehicle(account_info, vin_element)
    print str(result)[:1000]
    print result._bestMakeName
Пример #48
0
    def marshalled(self, context):
        """Add an authenticator token to the document before it is sent.

        :param context: The current message context.
        """
        body = context.envelope.getChild("Body")
        operation = body[0]

        if operation.name in ("AuthenticateUser", "RegisterAccount"):
            pass
        elif self.authenticator:
            namespace = operation.namespace()
            element = Element("Authenticator", ns=namespace)
            element.setText(self.authenticator)
            operation.insert(element)
        else:
            document = Document(self.client.wsdl)
            method = self.client.service.AuthenticateUser.method
            parameter = document.param_defs(method)[0]
            element = document.mkparam(method, parameter, self.credentials)
            operation.insert(element)
Пример #49
0
    def __init__(self, wsdl=None, api_key=None, timeout=5):
        """
        Constructor

        Keyword arguments:
        wsdl -- the URL of the Darwin LDB WSDL document. Will fall back to using the DARWIN_WEBSERVICE_WSDL environment variable if not supplied
        api_key -- a valid API key for the Darwin LDB webservice. Will fall back to the DARWIN_WEBSERVICE_API_KEY if not supplied
        timeout -- a timeout in seconds for calls to the LDB Webservice (default 5)
        """
        if not wsdl:
            wsdl = os.environ['DARWIN_WEBSERVICE_WSDL']
        if not api_key:
            api_key = os.environ['DARWIN_WEBSERVICE_API_KEY']
        self._soap_client = Client(wsdl)
        self._soap_client.set_options(timeout=timeout)
        #build soap headers
        token3 = Element('AccessToken', ns=DARWIN_WEBSERVICE_NAMESPACE)
        token_value = Element('TokenValue', ns=DARWIN_WEBSERVICE_NAMESPACE)
        token_value.setText(api_key)
        token3.append(token_value)
        self._soap_client.set_options(soapheaders=(token3))
Пример #50
0
def describe_vehicle_failure3(vin):
    """This fails becuase attributes on the root of the response element, such
    as bestMakeName, are not available
    """
    # NOTE: prettyxml must be set to True in order to add `vin_element` below
    # https://fedorahosted.org/suds/ticket/432
    client = Client(CHROME_URL, prettyxml=True)

    account_info = client.factory.create('AccountInfo')
    account_info._number = CHROME_ACCOUNT_NUMBER
    account_info._secret = CHROME_ACCOUNT_SECRET
    account_info._country = 'US'
    account_info._language = 'en'

    vin_element = Element('vin',
                          ns=('ns1', 'urn:description7a.services.chrome.com'))
    vin_element.setText(vin)

    result = client.service.describeVehicle(account_info, vin_element)
    print str(result)[:1000]
    print result._bestMakeName
Пример #51
0
    def marshalled(self, context):
        """Add an authenticator token to the document before it is sent.

        :param context: The current message context.
        """
        body = context.envelope.getChild("Body")
        operation = body[0]

        if operation.name in ("AuthenticateUser", "RegisterAccount"):
            pass
        elif self.authenticator:
            namespace = operation.namespace()
            element = Element("Authenticator", ns=namespace)
            element.setText(self.authenticator)
            operation.insert(element)
        else:
            document = Document(self.client.wsdl)
            method = self.client.service.AuthenticateUser.method
            parameter = document.param_defs(method)[0]
            element = document.mkparam(method, parameter, self.credentials)
            operation.insert(element)
Пример #52
0
def basic():
    xml = "<a>Me &amp;&amp; &lt;b&gt;my&lt;/b&gt; shadow&apos;s &lt;i&gt;dog&lt;/i&gt; love to &apos;play&apos; and sing &quot;la,la,la&quot;;</a>"
    p = Parser()
    d = p.parse(string=xml)
    a = d.root()
    print 'A(parsed)=\n%s' % a
    assert str(a) == xml
    b = Element('a')
    b.setText('Me &&amp; &lt;b>my</b> shadow\'s <i>dog</i> love to \'play\' and sing "la,la,la";')
    print 'B(encoded)=\n%s' % b
    assert str(b) == xml
    print 'A(text-decoded)=\n%s' % a.getText()
    print 'B(text-decoded)=\n%s' % b.getText()
    assert a.getText() == b.getText()
    print 'test pruning'
    j = Element('A')
    j.set('n', 1)
    j.append(Element('B'))
    print j
    j.prune()
    print j
def describe_vehicle_failure(vin):
    """This fails because an extra accountInfo element is added in the request xml
    """
    client = Client(CHROME_URL)

    account_info = client.factory.create('AccountInfo')
    account_info._number = CHROME_ACCOUNT_NUMBER
    account_info._secret = CHROME_ACCOUNT_SECRET
    account_info._country = 'US'
    account_info._language = 'en'

    vin_element = Element('vin', ns=('ns1', 'urn:description7a.services.chrome.com'))
    vin_element.setText(vin)

    vehicle_description_request = client.factory.create('VehicleDescriptionRequest')
    vehicle_description_request.accountInfo = account_info
    vehicle_description_request.switch.append(vin_element)
    print vehicle_description_request

    result = client.service.describeVehicle(vehicle_description_request)
    print result
Пример #54
0
    def __init__(self, wsdl=None, api_key=None, timeout=5):
        """
        Constructor

        Keyword arguments:
        wsdl -- the URL of the Darwin LDB WSDL document. Will fall back to using the DARWIN_WEBSERVICE_WSDL environment variable if not supplied
        api_key -- a valid API key for the Darwin LDB webservice. Will fall back to the DARWIN_WEBSERVICE_API_KEY if not supplied
        timeout -- a timeout in seconds for calls to the LDB Webservice (default 5)
        """
        if not wsdl:
            wsdl = os.environ['DARWIN_WEBSERVICE_WSDL']
        if not api_key:
            api_key = os.environ['DARWIN_WEBSERVICE_API_KEY']
        self._soap_client = Client(wsdl)
        self._soap_client.set_options(timeout=timeout)
        #build soap headers
        token3 = Element('AccessToken', ns=DARWIN_WEBSERVICE_NAMESPACE)
        token_value = Element('TokenValue', ns=DARWIN_WEBSERVICE_NAMESPACE)
        token_value.setText(api_key)
        token3.append(token_value)
        self._soap_client.set_options(soapheaders=(token3))
Пример #55
0
def basic():
    xml = "<a>Me &amp;&amp; &lt;b&gt;my&lt;/b&gt; shadow&apos;s &lt;i&gt;dog&lt;/i&gt; love to &apos;play&apos; and sing &quot;la,la,la&quot;;</a>"
    p = Parser()
    d = p.parse(string=xml)
    a = d.root()
    print 'A(parsed)=\n%s' % a
    assert str(a) == xml
    b = Element('a')
    b.setText('Me && <b>my</b> shadow\'s <i>dog</i> love to \'play\' and sing "la,la,la";')
    print 'B(encoded)=\n%s' % b
    assert str(b) == xml
    print 'A(text-decoded)=\n%s' % a.getText()
    print 'B(text-decoded)=\n%s' % b.getText()
    assert a.getText() == b.getText()
    print 'test pruning'
    j = Element('A')
    j.set('n', 1)
    j.append(Element('B'))
    print j
    j.prune()
    print j
    def build_soap_client(self):
        if self.soap_endpoint is None or not self.soap_endpoint:
            self.soap_endpoint = self.get_soap_endpoint()

        self.soap_client = suds.client.Client(self.wsdl_file_url, faults=False, cachingpolicy=1)
        self.soap_client.set_options(location=self.soap_endpoint)
        self.soap_client.set_options(headers={'user-agent' : 'FuelSDK-Python-v1.2.0'})

        if self.use_oAuth2_authentication == 'True':
            element_oAuth = Element('fueloauth', ns=('etns', 'http://exacttarget.com'))
            element_oAuth.setText(self.authToken);
            self.soap_client.set_options(soapheaders=(element_oAuth))
        else:
            element_oAuth = Element('oAuth', ns=('etns', 'http://exacttarget.com'))
            element_oAuthToken = Element('oAuthToken').setText(self.internalAuthToken)
            element_oAuth.append(element_oAuthToken)
            self.soap_client.set_options(soapheaders=(element_oAuth))

            security = suds.wsse.Security()
            token = suds.wsse.UsernameToken('*', '*')
            security.tokens.append(token)
            self.soap_client.set_options(wsse=security)
Пример #57
0
def buildEncryptedKey(key_id, cert, sym_key, reference_type=KEY_REFERENCE_ISSUER_SERIAL, block_encryption=BLOCK_ENCRYPTION_AES128_CBC, key_transport=KEY_TRANSPORT_RSA_OAEP):
    enc_key = Element("EncryptedKey", ns=wsencns)
    enc_key.set("Id", key_id)
    enc_method = Element("EncryptionMethod", ns=wsencns)
    enc_method.set("Algorithm", keyTransportProperties[key_transport]['uri'])
    key_info = build_key_info(cert, reference_type)
    
    cipher_data = Element("CipherData", ns=wsencns)
    cipher_value = Element("CipherValue", ns=wsencns)
    block_encryption_props = blockEncryptionProperties[block_encryption]
    pub_key = cert.getRsaPublicKey()
    enc_sym_key = pub_key.public_encrypt(sym_key, keyTransportProperties[key_transport]['padding'])
    cipher_value.setText(b64encode(enc_sym_key))
    cipher_data.append(cipher_value)
    
    sha1 = EVP.MessageDigest('sha1')
    sha1.update(enc_sym_key)
    cipher_value_sha1 = sha1.final()

    enc_key.append(enc_method)
    enc_key.append(key_info)
    enc_key.append(cipher_data)

    return (enc_key, cipher_value_sha1)