def add_to_params(self, parameters, value):
"""
This gets called with the value of our ``--priv-launch-key``
if it is specified. It needs to determine if the path
provided is valid and, if it is, it stores it in the instance
variable ``_key_path`` for use by the decrypt routine.
"""
if value:
path = os.path.expandvars(value)
path = os.path.expanduser(path)
if os.path.isfile(path):
self._key_path = path
endpoint_prefix = \
self._operation_model.service_model.endpoint_prefix
event = 'after-call.%s.%s' % (endpoint_prefix,
self._operation_model.name)
self._session.register(event, self._decrypt_password_data)
else:
msg = ('priv-launch-key should be a path to the '
'local SSH private key file used to launch '
'the instance.')
raise ValueError(msg)
python类decrypt()的实例源码
def downstream_recv(self, data):
try:
enc=data.peek()
if self.aes_key is None: #receive aes key
if len(enc) < self.rsa_key_size/8:
return
cmsg=enc[:self.rsa_key_size/8]
try:
self.aes_key=rsa.decrypt(cmsg, self.pk)
except rsa.pkcs1.DecryptionError:
self.close()
return
data.drain(self.rsa_key_size/8)
if AES is not None:
self.enc_cipher = AES.new(self.aes_key, AES.MODE_CBC, self._iv_enc)
else:
self.enc_cipher = pyaes.AESModeOfOperationCBC(self.aes_key, iv = self._iv_enc)
super(RSA_AESServer, self).downstream_recv(data)
except Exception as e:
logging.debug(e)
def decryptAndVerify(self, ciphertextPickle, senderPublic):
try:
if (ciphertextPickle):
decoded = pickle.loads(ciphertextPickle)
if (decoded):
signature = decoded[0]
content = decoded[1]
if (rsa.verify(content, signature, senderPublic)):
debug("crypt", "Message signature was verified. Decrypting..")
return rsa.decrypt(content, self.DRMPrivateKey)
else:
debug("crypt", "Message was empty. \"No Updates\"")
except Exception as e:
debug("crypt", "Error decrypting message. -> %s" % str(e))
# Load the keys
def on_handshake_respone(self, recv_buffer):
proto = YYProto_pb2.YYProto()
proto.ParseFromString(recv_buffer[4:])
#hexdump.hexdump(proto.key_ack.rsa_key)
try:
rc4_key = rsa.decrypt(proto.key_ack.rsa_key, self.rsa_pri_key)
except:
print 'decode key error username %s' % (self.username)
self.state = YY_CLIENT_WAITING
self.stream.close()
return
self.rc4_e = RC4(rc4_key)
self.rc4_d = RC4(rc4_key)
#print 'rc4_key'
#hexdump.hexdump(rc4_key)
self.login_request()
def post(self):
payload = {
'owner' : request.form['owner'],
'package' : request.form['package'],
'data' : request.form['data']
}
owner = request.form['owner']
package = request.form['package']
data = request.form['data']
b = ENGINE.get_named_secret(owner)
print(b)
secret = rsa.decrypt(eval(b), KEY[1])
# data is a python tuple of the templated solidity at index 0 and an example payload at index 1
# compilation of this code should return true
# if there are errors, don't commit it to the db
# otherwise, commit it
raw_data = decrypt(secret, eval(data))
package_data = json.loads(raw_data.decode('utf8'))
'''
payload = {
'tsol' : open(code_path[0]).read(),
'example' : example
}
'''
# assert that the code compiles with the provided example
tsol.compile(StringIO(package_data['tsol']), package_data['example'])
template = pickle.dumps(package_data['tsol'])
example = pickle.dumps(package_data['example'])
if ENGINE.add_package(owner, package, template, example) == True:
return success_payload(None, 'Package successfully uploaded.')
return error_payload('Problem uploading package. Try again.')
def perform_operation(self, indata, priv_key, cli_args=None):
'''Decrypts files.'''
return rsa.decrypt(indata, priv_key)
def perform_operation(self, indata, priv_key, cli_args=None):
"""Decrypts files."""
return rsa.decrypt(indata, priv_key)
def perform_operation(self, indata, priv_key, cli_args=None):
'''Decrypts files.'''
return rsa.decrypt(indata, priv_key)
def perform_operation(self, indata, priv_key, cli_args=None):
"""Decrypts files."""
return rsa.decrypt(indata, priv_key)
def perform_operation(self, indata, priv_key, cli_args=None):
"""Decrypts files."""
return rsa.decrypt(indata, priv_key)
def perform_operation(self, indata, priv_key, cli_args=None):
"""Decrypts files."""
return rsa.decrypt(indata, priv_key)
def _decrypt_password_data(self, parsed, **kwargs):
"""
This handler gets called after the GetPasswordData command has been
executed. It is called with the and the ``parsed`` data. It checks to
see if a private launch key was specified on the command. If it was,
it tries to use that private key to decrypt the password data and
replace it in the returned data dictionary.
"""
if self._key_path is not None:
logger.debug("Decrypting password data using: %s", self._key_path)
value = parsed.get('PasswordData')
if not value:
return
try:
with open(self._key_path) as pk_file:
pk_contents = pk_file.read()
private_key = rsa.PrivateKey.load_pkcs1(six.b(pk_contents))
value = base64.b64decode(value)
value = rsa.decrypt(value, private_key)
logger.debug(parsed)
parsed['PasswordData'] = value.decode('utf-8')
logger.debug(parsed)
except Exception:
logger.debug('Unable to decrypt PasswordData', exc_info=True)
msg = ('Unable to decrypt password data using '
'provided private key file.')
raise ValueError(msg)
def perform_operation(self, indata, priv_key, cli_args=None):
"""Decrypts files."""
return rsa.decrypt(indata, priv_key)
def perform_operation(self, indata, priv_key, cli_args=None):
'''Decrypts files.'''
return rsa.decrypt(indata, priv_key)
def encryptAndSign(self, plaintext, recipientPublic):
try:
content = rsa.encrypt(plaintext, recipientPublic)
signature = rsa.sign(content, self.DRMPrivateKey, "SHA-1")
return pickle.dumps([signature, content])
except Exception as e:
debug("crypt", "Failed encrypting the message. -> %s" % str(e))
return
# Verify signature with sender's public key, then proceed to use
# our own private key to decrypt the message
# pass the expected timestamp, to thawrt rplay attacks. gets cryptd
def perform_operation(self, indata, priv_key, cli_args=None):
"""Decrypts files."""
return rsa.decrypt(indata, priv_key)
def perform_operation(self, indata, priv_key, cli_args=None):
"""Decrypts files."""
return rsa.decrypt(indata, priv_key)
def perform_operation(self, indata, priv_key, cli_args=None):
"""Decrypts files."""
return rsa.decrypt(indata, priv_key)
def perform_operation(self, indata, priv_key, cli_args=None):
"""Decrypts files."""
return rsa.decrypt(indata, priv_key)
def perform_operation(self, indata, priv_key, cli_args=None):
'''Decrypts files.'''
return rsa.decrypt(indata, priv_key)
def perform_operation(self, indata, priv_key, cli_args=None):
"""Decrypts files."""
return rsa.decrypt(indata, priv_key)
def rsa_decrypt(private_key,data) :
try :
decrypt_string=''
while len(data)>128 : # RSA Decrypt byte once ..
decrypt_string+=rsa.decrypt(data[:128],private_key)
data=data[128:]
decrypt_string+=rsa.decrypt(data,private_key)
return decrypt_string
except :
return None
def print_help() :
print 'Using :'
print ''
print ' bule_fariy.py encrypt|decrypt'
print ''
print ' bule_fariy.py encrypt encrypt current path all file'
print ' bule_fariy.py decrypt decrypt current path all file'
def perform_operation(self, indata, priv_key, cli_args=None):
"""Decrypts files."""
return rsa.decrypt(indata, priv_key)
def decrypt_hismessage(mypriv=None):
"""
Try to decrypt his message using mypriv
return message if success else False
"""
if mypriv is None:
mypriv = storage_get("mypriv")
try:
rawdata = clipboard_read()
crypto = d64(rawdata)
message = rsa.decrypt(crypto, mypriv)
return message
except:
return False
def decrypt_assistant():
cname = input("Bitte gebe den Pfad zur .crypt-Datei an: ")
if cname.split(".")[-1] != "crypt":
print("Keine Crypt-Datei angegeben.")
return
c = open(cname, "r")
crypt = c.read()
c.close()
fname = '.'.join(cname.split(".")[:-1])
print("Die Datei wird entschlüsselt.")
crypt, name = unarmor("RSPLUS OUTPUT", crypt)
crypt = ''.join(crypt.split("\n"))
crypt = str(base64.b64decode(bytes(crypt, "utf-8")), "utf-8")
passw = getpass("Für ihren privaten Schlüssel benötigen wir ein Passwort: ")
names = prikr.gets(passw)
if not name in names:
print("You do not have the private key to encrypt.")
return
print("Entschlüssele (dauert einen Moment)")
msg = str(bytes(rsa.decrypt(crypt, prikr.get(name, passw)).strip("b'"), "utf-8"), "utf-8")
print(msg)
msg = eval("'''" + msg + "'''")
f = open(fname, "w")
f.write(msg)
f.close()
def decrypt_assistant():
cname = input("Bitte gebe den Pfad zur .crypt-Datei an: ")
if cname.split(".")[-1] != "crypt":
print("Keine Crypt-Datei angegeben.")
return
c = open(cname, "r")
crypt = c.read()
c.close()
fname = '.'.join(cname.split(".")[:-1])
print("Die Datei wird entschlüsselt.")
crypt, name = unarmor("RSPLUS OUTPUT", crypt)
crypt = ''.join(crypt.split("\n"))
crypt = str(base64.b64decode(bytes(crypt, "utf-8")), "utf-8")
passw = getpass("Für ihren privaten Schlüssel benötigen wir ein Passwort: ")
names = prikr.gets(passw)
if not name in names:
print("You do not have the private key to encrypt.")
return
print("Entschlüssele (dauert einen Moment)")
msg = str(bytes(rsa.decrypt(crypt, prikr.get(name, passw)).strip("b'"), "utf-8"), "utf-8")
print(msg)
msg = eval("'''" + msg + "'''")
f = open(fname, "w")
f.write(msg)
f.close()
def perform_operation(self, indata, priv_key, cli_args=None):
"""Decrypts files."""
return rsa.decrypt(indata, priv_key)
def test_enc_dec(self):
message = unicode_string.encode('utf-8')
print("\tMessage: %s" % message)
encrypted = rsa.encrypt(message, self.pub)
print("\tEncrypted: %s" % encrypted)
decrypted = rsa.decrypt(encrypted, self.priv)
print("\tDecrypted: %s" % decrypted)
self.assertEqual(message, decrypted)
def perform_operation(self, indata, priv_key, cli_args=None):
'''Decrypts files.'''
return rsa.decrypt(indata, priv_key)
