def store_incoming_message( pubkey_str, message, volume=None ):
try:
message_json = storage.tuple_to_json( message )
except Exception, e:
log.error("Failed to serialize incoming message")
log.exception(e)
return False
def write_gateway_privkey( password, gateway_name, gateway_privkey_str ):
encrypted_data = keys.encrypt_private_key( gateway_privkey_str, password )
try:
encrypted_data_json = storage.tuple_to_json( encrypted_data )
except Exception, e:
log.exception(e)
log.error("Failed to serialize encrypted private gateway key" )
return None
def store_message( receiver_pubkey_str, sender_privkey_str, folder, message, attachment_paths, attachment_data ):
try:
message_json = storage.tuple_to_json( message )
except Exception, e:
log.error("Failed to serialize message")
log.exception(e)
return False
def store_private_key_to_path( key_path, privkey, password, volume ):
privkey_str = privkey.exportKey()
encrypted_private_key = encrypt_private_key( privkey_str, password )
try:
encrypted_privkey_json = storage.tuple_to_json( encrypted_private_key )
except Exception, e:
log.error("Failed to serialize encrypted private key")
return False
def write_contact( pubkey_str, contact ):
global STORAGE_DIR
contact_path = make_contact_path( pubkey_str, contact.addr )
try:
contact_json = storage.tuple_to_json( contact )
except Exception, e:
log.error("Failed to serialize contact")
log.exception(e)
return False
def post_message(sender_privkey_pem, encrypted_incoming_message, use_http=False):
# called by the endpoint
# start to inform the recipient's server that they have a new message
# EncryptedIncomingMessage = collections.namedtuple( "EncryptedIncomingMessage", ["incoming_message_ciphertext", "sender_addr", "receiver_addr", "signature"] )
# serialize this
try:
data = storage.tuple_to_json(encrypted_incoming_message)
data = base64.b64encode(data)
except Exception, e:
log.exception(e)
log.error("Failed to serialize")
return False
def store_public_key( key_name, pubkey, syndicate_user_privkey ):
pubkey_str = pubkey.publickey().exportKey()
signature = sign_public_key( pubkey_str, syndicate_user_privkey )
pubkey = SignedPublicKey( signature=base64.b64encode(signature), pubkey_str=pubkey_str )
try:
pubkey_json = storage.tuple_to_json( pubkey )
except Exception, e:
log.error("Failed to serialize signed public key")
log.exception(e)
return False
def make_outbound_message( pubkey_str, privkey_str, contact_rec, message ):
# generate an incoming message to be sent to this contact's email server
incoming_message = SyndicateIncomingMessage( id=message.id,
sender_addr=message.sender_addr,
receiver_addrs=message.receiver_addrs,
cc_addrs=message.cc_addrs,
subject=message.subject,
timestamp=message.timestamp,
handle=message.handle,
attachment_names=message.attachment_names,
message_signature=message.signature,
verified=True )
# serialize outbound incoming message
try:
incoming_message_json = storage.tuple_to_json( incoming_message )
except Exception, e:
log.exception(e)
log.error("Failed to serialize outbound message to %s" % contact_rec.addr)
return rc
