Python CryptoManager.decrypt方法代码示例

# 需要导入模块: from zato.common.crypto import CryptoManager [as 别名]
# 或者: from zato.common.crypto.CryptoManager import decrypt [as 别名]
 def test_enrypt(self):
     """ Encrypt a message using the public key.
     """
     _plain_text = uuid4().hex
     
     with NamedTemporaryFile(prefix='zato-test-') as tf_priv:
         with NamedTemporaryFile(prefix='zato-test-') as tf_pub:
             
             tf_priv.write(priv_key)
             tf_priv.flush()
             
             tf_pub.write(pub_key)
             tf_pub.flush()
             
             cm_priv = CryptoManager()
             cm_priv.priv_key_location = tf_priv.name
             cm_priv.load_keys()
             
             cm_pub = CryptoManager()
             cm_pub.pub_key_location = tf_pub.name
             cm_pub.load_keys()
             
             encrypted = cm_pub.encrypt(_plain_text)
             decrypted = cm_priv.decrypt(encrypted)
             
             eq_(_plain_text, decrypted)

# 需要导入模块: from zato.common.crypto import CryptoManager [as 别名]
# 或者: from zato.common.crypto.CryptoManager import decrypt [as 别名]
    def execute(self, args):

        repo_dir = os.path.join(os.path.abspath(os.path.join(self.original_dir, args.path)), 'config', 'repo')
        config = get_config(repo_dir, 'server.conf')
        priv_key_location = os.path.abspath(os.path.join(repo_dir, config.crypto.priv_key_location))
        
        cm = CryptoManager(priv_key_location=priv_key_location)
        cm.load_keys()
        
        engine_args = Bunch()
        engine_args.odb_type = config.odb.engine
        engine_args.odb_user = config.odb.username
        engine_args.odb_password = cm.decrypt(config.odb.password)
        engine_args.odb_host = config.odb.host
        engine_args.odb_db_name = config.odb.db_name
        
        engine = self._get_engine(engine_args)
        session = self._get_session(engine)
        
        auth = None
        headers = {}
        
        with closing(session) as session:
            cluster = session.query(Server).\
                filter(Server.token == config.main.token).\
                one().cluster
            
            channel = session.query(HTTPSOAP).\
                filter(HTTPSOAP.cluster_id == cluster.id).\
                filter(HTTPSOAP.url_path == args.url_path).\
                one()
            
            if channel.security_id:
                security = session.query(HTTPBasicAuth).\
                    filter(HTTPBasicAuth.id == channel.security_id).\
                    first()
                
                if security:
                    auth = (security.username, security.password)
                    
        if args.headers:
            for pair in args.headers.strip().split(';'):
                k, v = pair.strip().split('=', 1)
                headers[k] = v
                    
        client = AnyServiceInvoker('http://{}'.format(config.main.gunicorn_bind), args.url_path, auth,
            max_response_repr=int(args.max_response_repr), max_cid_repr=int(args.max_cid_repr))
        
        func = client.invoke_async if args.async else client.invoke
        response = func(args.name, args.payload, headers, args.channel, args.data_format, args.transport)
        
        if response.ok:
            self.logger.info(response.data or '(None)')
        else:
            self.logger.error(response.details)
            
        if args.verbose:
            self.logger.debug('inner.text:[{}]'.format(response.inner.text))
            self.logger.debug('response:[{}]'.format(response))

# 需要导入模块: from zato.common.crypto import CryptoManager [as 别名]
# 或者: from zato.common.crypto.CryptoManager import decrypt [as 别名]
 def xtest_decrypt_priv_key_in_string(self):
     """ Decrypt a message using a private key from string.
     """
     cm = CryptoManager()
     cm.priv_key = priv_key
     cm.load_keys()
     
     eq_(plain_text, cm.decrypt(secret))

# 需要导入模块: from zato.common.crypto import CryptoManager [as 别名]
# 或者: from zato.common.crypto.CryptoManager import decrypt [as 别名]
def decrypt(data, priv_key, b64=True):
    """ Decrypts data using the given private key.
    data - data to be encrypted
    priv_key - private key to use (as a PEM string)
    b64 - should the data be BASE64-decoded before being decrypted, defaults to True
    """

    cm = CryptoManager(priv_key=priv_key)
    cm.load_keys()

    return cm.decrypt(data, b64)

# 需要导入模块: from zato.common.crypto import CryptoManager [as 别名]
# 或者: from zato.common.crypto.CryptoManager import decrypt [as 别名]
 def xtest_decrypt_priv_key_in_file(self):
     """ Decrypt a message using a private key from file.
     """
     with NamedTemporaryFile(prefix='zato-test-') as tf:
         tf.write(priv_key)
         tf.flush()
         
         cm = CryptoManager()
         cm.priv_key_location = tf.name
         cm.load_keys()
         
         eq_(plain_text, cm.decrypt(secret))

# 需要导入模块: from zato.common.crypto import CryptoManager [as 别名]
# 或者: from zato.common.crypto.CryptoManager import decrypt [as 别名]
def decrypt(data, priv_key, padding=RSA.pkcs1_padding, b64=True):
    """ Decrypts data using the given private key.
    data - data to be encrypted
    priv_key - private key to use (as a PEM string)
    padding - padding to use, defaults to PKCS#1
    b64 - should the data be BASE64-decoded before being decrypted, defaults to True
    """
    logger.debug('Using priv_key:[{}]'.format(priv_key))
    
    cm = CryptoManager(priv_key=priv_key)
    cm.load_keys()
    
    return cm.decrypt(data, padding, b64)

# 需要导入模块: from zato.common.crypto import CryptoManager [as 别名]
# 或者: from zato.common.crypto.CryptoManager import decrypt [as 别名]
    def _on_web_admin(self, args):
        """Load ODB using component config and update security definition."""
        config_file = join(self.config_dir, 'repo', 'web-admin.conf')

        with open(config_file) as fp:
            c = bunchify(load(fp))

        private_key = join(self.config_dir, 'repo', 'web-admin-priv-key.pem')
        cm = CryptoManager(priv_key_location=private_key)
        cm.load_keys()
        db_password = cm.decrypt(c.DATABASE_PASSWORD)

        engine_url = "%s://%s:%[email protected]%s:%s/%s" % (
            c.db_type,
            c.DATABASE_USER,
            db_password,
            c.DATABASE_HOST,
            c.DATABASE_PORT,
            c.DATABASE_NAME)

        engine = sqlalchemy.create_engine(engine_url)
        session = self._get_session(engine)

        if engine.dialect.has_table(engine.connect(), 'sec_basic_auth'):
            try:
                secdef = session.query(HTTPBasicAuth).filter(
                    HTTPBasicAuth.name == args.secdef).one()
            except sqlalchemy.orm.exc.NoResultFound:
                self.logger.error(
                    "Security definition '%s' not found.", args.secdef)
                return 1

            self.logger.info("Security definition: %s" % secdef.name)
            self.logger.info("Username: %s" % secdef.username)
            self.logger.info("Old password: %s" % secdef.password)
            self.logger.info("Setting new password.")
            secdef.password = args.password
            session.commit()
            self.logger.info('OK')
        else:
            msg = "Zato ODB does not seem to have been set up yet."
            self.logger.error(msg)
            return self.SYS_ERROR.NO_ODB_FOUND

# 需要导入模块: from zato.common.crypto import CryptoManager [as 别名]
# 或者: from zato.common.crypto.CryptoManager import decrypt [as 别名]
 def execute(self, args):
     cm = CryptoManager(priv_key_location=os.path.abspath(args.path))
     cm.load_keys()
     
     self.logger.info('Secret is [{}]'.format(cm.decrypt(args.secret)))