FTPoverEmail Beta v1.00
5.00/5 (1 vote)
FTPoverEmail Beta v1.00
I made a few more edits to FTPoverEmail. I got the SSH functionality working and fixed a couple of bugs for this next version. I’ve started studying for CCDP so my work on it has tailed off a fair amount. Here’s the next version with the bug fixes and SSH functionality. I called this one a beta in that at least it runs fully and that at least it works most of the time now :-D.
# __author__ = 'gecman'
import smtplib
import email
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email import encoders
import mimetypes
import os
import imaplib
import time
import sys
import subprocess
import signal
import urllib3
# TODO: Windows-1252 encoding adds an = sign which the program can't handle.
# Find a way to take care of it.
# TODO: Test more rapidly sent email
# TODO: Find a way to break interactive commands
# TODO: Ensure logging for all error messages
# The bash script checks progOverEmail2_new
# Global Variables
from_name = ''
to_name = ''
subject = ''
log_file = None
user = "your_email_here@gmail.com"
password = "your_password_here"
# sendresponse sends text based responses to the client
# response: The response text to send in the body of the mail
def sendresponse(response):
global log_file
# Create a response email from the response string
response_email = MIMEText(response)
# Configure the message header fields
response_email['Subject'] = subject
response_email['From'] = to_name
response_email['To'] = from_name
try:
# Declare an instance of the SMTP class and connect to the smtp server
smtp = smtplib.SMTP('smtp.gmail.com')
# Start the TLS connection
smtp.starttls()
# Login to the server
smtp.login(user, password)
smtp.sendmail(to_name, from_name, response_email.as_string())
smtp.close()
except smtplib.SMTPResponseException:
# The following lines dump the details of the error to stdout and log any issues
print(
"Server encountered the following error while attempting to
connect to SMTP server: \nType: {0}\nValue: {1}\nTraceback: {2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
log_file.write(time.strftime("%c") + " --------> " +
"Server encountered the following error while attempting to
connect to SMTP server: \nType: {0}\nValue: {1}\nTraceback: {2} \r\n".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
# sendfile Instead of just sending text, sends a file. Primarily used for the FTP get functionality.
# file_name: The name of the file to be attached to the email.
def sendfile(file_name, optional_text=None):
global log_file
# Declare the mime class and message header fields
response = MIMEMultipart()
response['Subject'] = subject
response['From'] = to_name
response['To'] = from_name
# Check to see if the caller passed optional text to place in the e-mail,
# otherwise use the default response.
if bool(optional_text):
# Write the optional text into the e-mail instead of the default
response.attach(MIMEText(optional_text))
# Use the default response
else:
# Attach the text portion of the message. Alerts the user of the file name
# and that it is attached.
response.attach(MIMEText("Grabbed file " + file_name + ". See attachment."))
# Define the major and minor mime type
# attachment = MIMEBase('application', "octet-stream")
# This command uses the mimetypes module to attempt to guess the mimetype of the file.
# The strict=False argument
# tells the mimetypes module to include modules not officially registered with IANA
# The file_type variable will be in the format of a tuple #major type#/#sub type# , #encoding#
file_type = mimetypes.guess_type(file_name, strict=False)
main_type = None
# mimetypes.guess_type returns None if it doesn't recognize the file type.
# In this case I chose to use the generic
# application octect-stream type, which should be safe.
if file_type is None:
attachment = MIMEBase('application', 'octet-stream')
else:
main_type = file_type[0].split('/')[0]
sub_type = file_type[0].split('/')[1]
# This pulls the major type and sub type and splits them around the
# '/' character providing the major type in the
# first argument and the sub type in the second argument
attachment = MIMEBase(main_type, sub_type)
# Read the file from disk and set it as the payload for the email
# The with statement ensures the file is properly closed even if an exception is raised.
try:
f = open(file_name, "rb")
attachment.set_payload(f.read())
f.close()
except OSError:
print(
"Server encountered the following error while attempting to open
the file you asked for: \nType: {0}\nValue: {1}\nTraceback: {2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
log_file.write(time.strftime("%c") + " --------> " +
"Server encountered the following error while attempting to open the file
you asked for: \nType: {0}\nValue: {1}\nTraceback: {2}\r\n".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
# TODO: Fix the fact that this shows the newlines as \n instead of properly adding newlines
sendresponse(
"Server encountered the following error while attempting to
open the file you asked for: \nType: {0}\nValue: {1}\nTraceback: {2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
# Check to see if the attachment requires encoding
if main_type == 'application' or main_type == 'audio' or main_type == 'image':
# Encode the attachment
encoders.encode_base64(attachment)
# This sets the header. The output will be in the following format:
# Content-Disposition: attachment; file_name="the_file_name"
# The os.path.basename(file_name) portion strips the leading part of the
# file path and just gives the actual file name
attachment.add_header('Content-Disposition', 'attachment;
file_name="%s"' % os.path.basename(file_name))
# A ttach the attachment to the response message
response.attach(attachment)
try:
# Declare an instance of the SMTP class and connect to the smtp server
smtp = smtplib.SMTP('smtp.gmail.com')
# Start the TLS connection
smtp.starttls()
# Login to the server
smtp.login(user, password)
# Send the response email
smtp.sendmail(to_name, from_name, response.as_string())
# Close the smtp connection
smtp.close()
except smtplib.SMTPResponseException:
# The following lines dump the details of the error to stdout and log any issues
print(
"Server encountered the following error while attempting to connect to
SMTP server: \nType: {0}\nValue: {1}\nTraceback: {2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
log_file.write(time.strftime("%c") + " --------> " +
"Server encountered the following error while attempting to connect to
SMTP server: \nType: {0}\nValue: {1}\nTraceback: {2} \r\n".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
# Responsible for connecting to the server via IMAP and actually grabbing the e-mail.
# It then passes the text or
# content of the e-mail to proccommand for processing.
def getemail():
# Declare as global variables. They are originally defined at the beginning.
# Without these the values won't
# carry over to other functions.
global from_name
global to_name
global subject
global log_file
try:
# Connect to Google's imap server
# TODO: This needs to be generic
mail = imaplib.IMAP4_SSL('imap.gmail.com')
# Login to the imap server
mail.login(user, password)
# List all mailbox (folder) names. In gmail these are called labels.
mail.list()
# Select the inbox folder
mail.select("inbox")
# Grab an ordered list of all mail. The search function returns an ordered list
# from newest to oldest. Only grab new mail.
result, data = mail.search(None, "UNSEEN")
# Check to see if there was new mail or not. If there wasn't return None.
if not data[0].split():
return None
# Data[0] is a list of email IDs in a space separated string.
id_list = data[0].split()
# Grab the latest email
# TODO add support for queuing
latest_email_id = id_list[-1]
# Fetch the email body for the given ID
result, data = mail.fetch(latest_email_id, "(RFC822)")
raw_email = data[0][1]
# Grab the body of the email including the raw text, headers, and payloads
# The following line converts the email from a string into an email message object
email_message = email.message_from_bytes(raw_email)
log_file.write(time.strftime("%c") + " --------> " + "-----Receiving E-mail-----\r\n")
print("-----Receiving E-mail-----\r\n")
if email_message['To'] is not None:
print(email_message['To'] + "\r\n")
log_file.write(time.strftime("%c") + " --------> " + email_message['To'] + "\r\n")
to_name = email_message['To']
else:
print("Received email with an empty To address. Ignoring the message.\r\n")
log_file.write(time.strftime("%c") + " --------> " +
"Received email with an empty To address. Ignoring the message.\r\n")
return
if email_message['Return-Path'] is not None:
print(email_message['Return-Path'])
log_file.write(time.strftime("%c") + " --------> " +
email_message['Return-Path'] + "\r\n")
from_name = email_message['Return-Path']
else:
log_file.write(time.strftime("%c") + " --------> " +
"Received email with an empty Return-Path. Ignoring the message.\r\n")
print("Received email with an empty Return-Path. Ignoring the message.")
return
if email_message['Subject'] is not None:
# If there is already a Re in the subject don't add it again
if email_message['Subject'].find("Re:") == -1:
subject = "Re: " + email_message['Subject']
else:
subject = email_message['Subject']
else:
subject = ''
print(subject + "\r\n")
log_file.write(time.strftime("%c") + " --------> " + subject + "\r\n")
# Check to see if this is a multipart email message. If it isn't just return the text portion.
if email_message.get_content_maintype() == 'multipart':
# Used to determine whether a command was found in the email
found_command = False
# Walk the various sections of the email.
# The enumerate function here returns a number for each email part walked through.
# IE 0 for the first part in
# the email, 1 for the next, and so on.
for index, part in enumerate(email_message.walk()):
# The multipart section is just a container so we can skip it.
if part.get_content_maintype() is 'multipart':
continue
# Check to see if we have reached the text body of the message
if part.get_content_type() == 'text/plain':
found_command = True
message = part.get_payload()
proccommand(message.splitlines(), index, email_message)
# This does not need to continue after this run
break
# If a command was found and successfully processed simply return
if found_command:
return
else:
sendresponse("Error: No command was found in multipart email. Was it there?")
print("Error: Server encountered a multipart email that did not appear
to have a command in it")
# Return the text payload
elif email_message.get_content_maintype() == 'text':
print(email_message.get_payload())
# Pass the message to proccommand
proccommand(email_message.get_payload().splitlines())
# It wasn't text - do not process the email
else:
print("Error processing email in getemail. Encountered unrecognized content type.")
log_file.write(time.strftime("%c") + " --------> " +
"Error processing email in getemail. Encountered unrecognized content type.\r\n")
sendresponse("Error processing email in getemail. Encountered unrecognized content type.")
return
log_file.write(time.strftime("%c") + " --------> " +
"-----End Message Receive-----\r\n\r\n")
except imaplib.IMAP4.error:
print(
"Unable to pull e-mail via IMAP. An error occured: \nType:
{0}\nValue: {1}\nTraceback: {2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
# TODO: Fix the fact that this shows the newlines as \n instead of properly adding newlines
log_file.write(time.strftime("%c") + " --------> " +
"Unable to pull e-mail via IMAP. An error occured: \nType:
{0}\nValue: {1}\nTraceback: {2}\r\n".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
# Processes the command retrieved from the email server
# message: The message from the email server in the form of [type] [command(s)]
# index: This is an index into a multipart email's parts. getemail may have
# already processed some of them and it is
# unnecessary to reprocess those parts
# email_message: This is an email_message passed from getemail.
# In terms of FTP, this is used for the put command
def proccommand(message, index=None, email_message=None):
global log_file
#found_command = False
# TODO These are temporary
command = message[0].split(' ')
message = message[0]
log_file.write(time.strftime("%c") + " --------> " + "Message: " + message + "\r\n")
# Used for logging to determine whether a command was successful or not
errors_occurred = False
# Process an FTP command
if "FTP" == command[0].upper():
# cd command ---------------------------
# Process the command "cd"
if command[1].lower() == "cd":
# Ensure the correct number of arguments was passed"
if len(command) != 3:
sendresponse("Error: Incorrect number of arguments for cd")
errors_occurred = True
# Make sure the path exists
elif not os.path.exists(command[2]):
sendresponse("Error: The path: \"" + command[2] + "\" does not exist")
errors_occurred = True
# Process the "cd" command
else:
os.chdir(command[2])
sendresponse("CD completed successfully. Directory is now: " + os.getcwd())
# dir command ---------------------------
# Process the command "dir"
elif command[1].lower() == "dir":
# Ensure the correct number of arguments was passed"
if len(command) < 2 or len(command) > 3:
sendresponse("Error: Incorrect number of arguments for dir")
errors_occurred = True
else:
# If no arguments are passed to dir then list the current directory
if len(command) == 2:
response = ""
for file in os.listdir(os.getcwd()):
# Contains newline delimited directory listing at end
response = response + file + "\n"
sendresponse(response)
# Process the dir command with directory argument
else:
# Make sure the path exists
if not os.path.exists(command[2]):
sendresponse("Error: The path: \"" + command[2] + "\" does not exist")
errors_occurred = True
# If the path does exist then list the directory
else:
response = ""
for file in os.listdir(command[2]):
# Contains newline delimited directory listing at end
response = response + file + "\n"
sendresponse(response)
# pwd command ---------------------------
# Process the pwd command
elif command[1].lower() == "pwd":
# Ensure correct number of arguments was passed
if len(command) != 2:
sendresponse("Error: Incorrect number of arguments for pwd")
errors_occurred = True
else:
# Get current directory and respond
sendresponse(os.getcwd())
# get command ---------------------------
# Process the get command
elif command[1].lower() == "get":
# TODO Consider any other downsides to this approach?
# Ensure correct number of arguments was passed. Must be at least 3
if len(command) < 3:
sendresponse("Error: Incorrect number of arguments for get")
errors_occurred = True
else:
# Make sure the file exists. Must include everything after the "FTP get" command
# The syntax " ".join(command[2:]) takes everything from the
# third argument on and joins it as one string
if not os.path.exists(" ".join(command[2:])):
sendresponse("Error: The path: \"" + " ".join(command[2:]) + "\" does not exist")
errors_occurred = True
else:
sendfile(" ".join(command[2:]))
# put command ---------------------------
elif command[1].lower() == "put":
# Ensure correct number of arguments was passed. Must be at least 3
if len(command) < 3:
sendresponse("Error: Incorrect number of arguments for put")
errors_occurred = True
else:
# There may be a better way to do this, but I'm using this to inform
# the functionality below whether it
# should actually execute. This defaults to true, but gets set to False
# if the path is determined to be
# non-valid
valid_path = True
# The line below splits command[2] into two pieces. For example say the path is
# C:\Users\randomUser\Downloads\tryMe.exe. The split command will split this into
# C:\Users\randomUser\Downloads\ and tryMe.exe.
# The [0] index grabs just the path prefix. In this case
# bool will return true IF there is a path prefix and false if there isn't.
# We don't want to check if
# the path exists if the user didn't provide any path
# (because a path of '' will return false. If the
# user didn't provide a path we want to just dump the file in the
# current directory whatever it is.
# The syntax " ".join(command[2:]) takes everything from the third argument
# on and joins it as one string
if bool(os.path.split(" ".join(command[2:]))[0]):
# Make sure the path exists exists
if not os.path.exists(os.path.split(" ".join(command[2:]))[0]):
valid_path = False
sendresponse(
"Error: The path: \"" + os.path.split(" ".join(command[2:]))[0] +
"\" does not exist")
errors_occurred = True
# Only execute this if a valid path is supplied (or no path as the case may be)
if valid_path:
# getemail already parsed some of the sections.
# The index comes from the getemail function and
# allows this section to skip the parts of the email that were already processed.
# email_message.walk() is a generator, but we want to index into it
# so we use the list function.
# This turns it into a list, which we are permitted to index into
for part in list(email_message.walk())[index:]:
# The multipart section is just a container so we can skip it.
if part.get_content_maintype() is 'multipart':
continue
# Grab the file name from the section
file_name = part.get_filename()
# Make sure the file name actually exists and if it does write the file.
if bool(file_name):
try:
file_descriptor = open(" ".join(command[2:]), 'wb')
# Get the payload of the email and write it.
# The decode=True argument basically says if
# the payload is encoded, decode it first otherwise,
# it gets returned as is.
file_descriptor.write(part.get_payload(decode=True))
file_descriptor.close()
sendresponse("Successfully processed the put command: " + message)
except OSError:
errors_occurred = True
print(
"Server encountered the following error while attempting to write
the file you uploaded: \nType: {0}\nValue: {1}\nTraceback:
{2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]),
str(sys.exc_info()[2])))
log_file.write(time.strftime("%c") + " --------> " +
"Server encountered the following error while attempting
to write the file you uploaded: \nType: {0}\nValue:
{1}\nTraceback: {2}\r\n".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]),
str(sys.exc_info()[2])))
# TODO: Fix the fact that this shows the newlines as \n
# instead of properly adding newlines
sendresponse(
"Server encountered the following error while attempting to
write the file you uploaded: \nType: {0}\nValue:
{1}\nTraceback: {2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]),
str(sys.exc_info()[2])))
# Break out of the for loop. We should only need to write one file.
break
# Delete a file with the "del" FTP command
# TODO: This requires more thorough testing
elif command[1].lower() == "del":
if len(command) == 3:
try:
os.remove(command[2])
sendresponse("Successfully deleted file: " + command[2])
except OSError:
print(
"Server encountered the following error while attempting to
delete the file: \nType: {0}\nValue: {1}\nTraceback: {2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
log_file.write(time.strftime("%c") + " --------> " +
"Server encountered the following error while attempting to
delete the file: \nType: {0}\nValue: {1}\nTraceback: {2}\r\n".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
# TODO: Fix the fact that this shows the newlines as \n instead of
# properly adding newlines
sendresponse(
"Server encountered the following error while attempting to
delete the file: \nType: {0}\nValue: {1}\nTraceback: {2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
else:
sendresponse(
'Error: Incorrect number of arguments sent to the "del" command.
Syntax is "FTP del <filename"')
# TODO May not be necessary. Added for testing purposes.
# Kill the server
elif command[1].lower() == "kill":
log_file.close()
sys.exit(0)
# This is called if the FTP command does not match any correct command.
else:
errors_occurred = True
sendresponse("Error: That command did not match an FTP command.")
print("Error: That command did not match an FTP command.")
log_file.write(time.strftime("%c") + " --------> " +
"Error: That command did not match an FTP command.")
# Perform an operation over SSH
elif command[0].upper() == "SSH":
# TODO THIS MUST BE TESTED
# Ensure the user actually passed an argument to the SSH command
if len(command) < 2:
errors_occurred = True
sendresponse("Error: It does not appeared you supplied an argument for your SSH command.")
print("Error: It does not appear the user supplied an argument with an SSH command.\r\n")
log_file.write(time.strftime("%c") + " --------> " +
"Error: It does not appear the user supplied an argument with an SSH command.")
# This conditional handles the event that the user wants to receive the output
# of their command back in binary
# form.
elif command[1].upper() == "BINARY":
# Make sure the user supplied an argument after the BINARY option
if len(command) > 2:
# Attempt to run the command passed to the shell. Output is saved by .check_output
# as a byte string
try:
command_output = subprocess.check_output(command[2], shell=True)
# Write the output of the command to a file then send the file to the user
# as an attachment.
try:
file_descriptor = open("output.bin", 'wb')
# Get the payload of the email and write it. The decode=True argument
# basically says if
# the payload is encoded, decode it first otherwise, it gets returned as is.
file_descriptor.write(command_output)
file_descriptor.close()
sendfile("output.bin", "The output of your command \"" + command[2] +
"\" is attached.")
# Remove the file now that it is no longer needed
os.remove("output.bin")
except OSError:
errors_occurred = True
print(
"Server encountered the following error while attempting to write
the output to a file: \nType: {0}\nValue: {1}\nTraceback: {2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
log_file.write(time.strftime("%c") + " --------> " +
"Server encountered the following error while attempting to write
the output to a file: \nType: {0}\nValue: {1}\nTraceback: {2}\r\n".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
# TODO: Fix the fact that this shows the newlines as \n instead of
# properly adding newlines
sendresponse(
"Server encountered the following error while attempting to write
the output to a file: \nType: {0}\nValue: {1}\nTraceback: {2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
# If the command fails, report an error
except subprocess.CalledProcessError:
sendresponse(
"Server encountered the following error while attempting to process
the command {3}: \nType: {0}\nValue: {1}\nTraceback: {2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]),
str(sys.exc_info()[2]), str(command[1])))
print(
"Server encountered the following error while attempting to process
the command {3}: \nType: {0}\nValue: {1}\nTraceback: {2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2]),
str(command[1])))
log_file.write(time.strftime("%c") + " --------> " +
"Server encountered the following error while attempting to process
the command {3}: \nType: {0}\nValue: {1}\nTraceback: {2}\r\n".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]),
str(sys.exc_info()[2]), str(command[1])))
else:
# Attempt to run the command passed to the shell.
# The below pipes everything into the command_output object.
# The command[1:] slice is necessary because we split everything based on spaces above.
# This combines all of
# the elements in the array after 1.
command_output = subprocess.Popen(" ".join(command[1:]),
shell=True,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE)
output = ""
# Print the lines from stderr into the response
for line in command_output.stderr:
output = output + str(line.rstrip())[2:-1] + '\n'
command_output.stdout.flush()
output += '\n\n'
# Print the lines from stdout into the response
for line in command_output.stdout:
output = output + str(line.rstrip())[2:-1] + '\n'
command_output.stdout.flush()
sendresponse("Successfully processed command: " +
message + "\r\n\r\n" + output)
# If the protocol or desired action did not match anything...
else:
sendresponse("Error: Bad or nonexistent command: " + message)
print("Server received an email which matched no commands.")
log_file.write(time.strftime("%c") + " --------> " +
"Server received an email which matched no commands.\r\n")
# Used server side for logging purposes
if errors_occurred:
print("Failed to process command \"" + message + "\"")
log_file.write(time.strftime("%c") + " --------> " +
"Failed to process command \"" + message + "\"\r\n")
else:
print("Successfully processed command: " + message)
log_file.write(time.strftime("%c") + " --------> " +
"Successfully processed command: " + message + "\r\n")
# Handler for when someone hits control-c while the server is running.
# We want to perform cleanup before the server
# exits.
def signal_handler(signal, frame):
print("Server exiting...")
log_file.write(time.strftime("%c") + " -------->
" + "Server shutting down...\r\n")
sys.exit(0)
# This is the main section
# Register the signal handler for control-c
signal.signal(signal.SIGINT, signal_handler)
# Open the log file for other functions to use
try:
# This opens the log file
log_file = open("log_file", 'a')
except OSError:
print(
"Server encountered the following error while attempting to open the
log file: \nType: {0}\nValue: {1}\nTraceback: {2}".format(
str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2])))
sys.exit(1)
# This is the main loop
while 1:
getemail()
time.sleep(5)
log_file.close()