#!/usr/bin/python
import sys
import time, os, getpass
import urllib2, re, random
class bcolors:
    LIGHT_GREEN = '\033[36m'
    OKBLUE = '\033[94m'
    BLUE = '\033[34m'
    WARNING = '\033[93m'
    FAIL = '\033[91m'
    ENDC = '\033[0m'
    LIGHT_RED = '\033[31m'
    GREEN='\033[32m'
    BROWN='\033[33m'
    GRAY='\033[37m'
    def disable(self):
        self.LIGHT_GREEN = ''
        self.OKBLUE = ''
        self.BLUE = ''
        self.WARNING = ''
        self.FAIL = ''
        self.ENDC = ''
        self.LIGHT_RED = ''
        self.GREEN=''
        self.BROWN=''
        self.GRAY=''
def banners(selections):
	selections=selections
	a=bcolors.BLUE+'''
 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ _________ 
||T |||w |||e |||e |||p |||C |||r |||y |||p |||t |||       ||
||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_______||
|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_______\|
	'''+bcolors.ENDC
	b=bcolors.BLUE+('''
    ______)              )   ___                  
   (, /                 (__/_____)                
     /  _   _  _   _ __   /       __      __  _/_ 
  ) /   (_(/ _(/__(/_/_)_/       / (_(_/_ /_)_(__ 
 (_/              .-/   (______)    .-/.-/        
                 (_/               (_/(_/         
	''')+bcolors.ENDC
	c=bcolors.BLUE+'''
""8""                          8""""8                           
  8   e   e  e eeee eeee eeeee 8    " eeeee  e    e eeeee eeeee 
  8e  8   8  8 8    8    8   8 8e     8   8  8    8 8   8   8   
  88  8e  8  8 8eee 8eee 8eee8 88     8eee8e 8eeee8 8eee8   8e  
  88  88  8  8 88   88   88    88   e 88   8   88   88      88  
  88  88ee8ee8 88ee 88ee 88    88eee8 88   8   88   88      88  
	'''+bcolors.ENDC
	d=bcolors.BLUE+'''
_______ _  _  _ _______ _______  _____  _______  ______ __   __  _____  _______
   |    |  |  | |______ |______ |_____] |       |_____/   \_/   |_____]    |   
   |    |__|__| |______ |______ |       |_____  |    \_    |    |          |   
	'''+bcolors.ENDC
	e=bcolors.BLUE+'''
888888 Yb        dP 888888 888888 88""Yb  dP""b8 88""Yb Yb  dP 88""Yb 888888 
  88    Yb  db  dP  88__   88__   88__dP dP   `" 88__dP  YbdP  88__dP   88   
  88     YbdPYbdP   88""   88""   88"""  Yb      88"Yb    8P   88"""    88   
  88      YP  YP    888888 888888 88      YboodP 88  Yb  dP    88       88   
	'''
	if selections == 'a':
		print a
	if 	selections == 'b':
		print b
	if selections == 'c':
		print c
	if selections == 'd':
		print d 
	if selections == 'e':
		print e
	print bcolors.GREEN+"Created By @MrXors"+bcolors.ENDC
rando=str(random.choice('abcde'))
banners(rando)
try:
	import gnupg
	pass
except ImportError:
	print "Run Setup.py To Install the Correct Mods."
	sys.exit() 
try:
	import tweepy
	pass
except ImportError:
	print "Run Setup.py To Install the Correct Mods."
	sys.exit() 
try:
	import pastebin_python 
	pass
except ImportError:
	print "Run Setup.py To Install the Correct Mods."
	sys.exit()
try:
	import pynotify 
	pass
except ImportError:
	print "Run Setup.py To Install the Correct Mods."
	sys.exit()
def start_up():
	try:
		os.mkdir('conf')
	except OSError:
		pass
	pass
	#try:
	#	os.mkdir(str(config.gpghome_dir))
	#except OSError:
	#	pass
	#pass
	try:
		os.mkdir('logs/')
	except OSError:
		pass
	try:
		os.mkdir('logs/old_gpg')
	except OSError:
		pass
	try:
		os.mkdir('logs/archive')
	except OSError:
		pass
	try:
		os.system('touch logs/downloads')
	except OSError:
		pass
	try:
		os.system('touch logs/request')
	except OSError:
		pass
	#try:
	#	os.system('touch keys/public_key')
	#except OSError:
	#	pass
	pass
	try:
		os.system('touch conf/__init__.py')
	except OSError:
		pass
	pass
	try:
		os.system('touch conf/settings.py')
	except OSError:
		pass
	pass
	try:
		set_data=open('conf/settings.py', 'r')
		new_set_data=set_data.readlines()
		key_ans_count=0
		for line in new_set_data:
			if 'gpghome_ans' in line:
				#print line
				key_ans_count=key_ans_count+1
				break
			else:
				pass
			#	print "NO DATA"
		if key_ans_count == 1:
			pass
		else:

			print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Setting Up TweepCrypt For First time useage!"+bcolors.ENDC
			print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Please Have Dev Keys From Twitter \& PasteBin Ready to Continue!"+bcolors.ENDC
			print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"If You Don't Have Any Keys just run (\"python tweepcrypt.py -g\") After Running This!"+bcolors.ENDC
			gpg_home_dir=raw_input(bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Enter Your FULL PATH for GPG Keys (\"/root/dir/to/gpg\") : "+bcolors.ENDC)
			email_ans=raw_input( bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Enter Your Email Address: "+bcolors.ENDC)
			pbin_dev_ans=raw_input(bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Enter Your PasteBin Development Keys located in http://pastebin.com/api: "+bcolors.ENDC)
			twit_consumer_key_ans=raw_input( bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Enter Your Twitter CONSUMER_KEY: "+bcolors.ENDC)
			twit_consumer_secret_ans=raw_input(bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Enter Your Twitter CONSUMER_SECRET: "+bcolors.ENDC)
			twit_access_key_ans=raw_input( bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Enter Your Twitter ACCESS_KEY: "+bcolors.ENDC)
			twit_access_secret_ans=raw_input( bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Enter Your Twitter ACCESS_SECRET: "+bcolors.ENDC)
			print  bcolors.LIGHT_RED+"TweepCrypt.py WILL NOT WORK WITH OUT THE CORRECT KEYS FROM TWITTER & PASTEBIN !"+bcolors.ENDC
			time.sleep(0.1)
			setting=open('conf/settings.py', 'a+')
			setting.write('#!/usr/bin/python\n\
gpghome_ans=0\n\
#######################################################\n\
#GPG PASSWORD DONT STORE IT HERE. LAZY ASS.\n\
gpgpasswd=""\n\
#######################################################\n\
#Destroy Twitter Message with Encryption Link.\n\
#destroy=0\n\
######################################################\n\
#Your Email Address or Email Address of your Public Key\n\
email=\"'+str(email_ans)+'\"\n\
####################################################\n\
#Location Of your Gpg Keys the default is ~/.gnupg/\n\
gpghome_dir=\"'+str(gpg_home_dir)+'\"\n\
##############################################\n\
#PasteBin Key \n\
#Go to http://pastebin.com/api once you have Created an account with pastebin.com\n\
pastebin_key=\"'+str(pbin_dev_ans)+'\"\n\
#####User Name and Password Not Needed.\n\
pastebin_username="None"\n\
pastebin_passwd="None"\n\
###############################################\n\
#Twitter Keys\n\
#Go To dev.twitter.com\n\
#Select your account in the top right corner of the screen and select "My Applications"\n\
###Click "Create New Application"\n\
##### Name = Whatever Name You Want\n\
##### Description = Whatever Name You Want\n\
##### WebSite URL = I Use https://twitter.com\n\
##### CallBack URL = I Use https://twitter.com\n\
##### Check Yes You Agree To TOS\n\
########## Once App is Created Select it in My Applications\n\
########## Click on the Settings tab\n\
########## Check the Box the say Read, Write and Direct Messages\n\
########## Check The Box That Says "Allow this application to be used to Sign in with Twitter"\n\
########## Click Update This Twitter Application\n\
################### Go To the Details TAB and Scroll Down To Create My Access Token\n\
############## Now You Should See \n\
########## CONSUMER_KEY\n\
########## CONSUMER_SECRET \n\
########## ACCESS_KEY \n\
########## ACCESS_SECRET\n\
##########\n\
##########COPY AND PASTE THEM IN THERE CORRECT LOCATION RIGHT HERE\n\
CONSUMER_KEY =\"'+str(twit_consumer_key_ans)+'\"\n\
CONSUMER_SECRET =\"'+str(twit_consumer_secret_ans)+'\"\n\
ACCESS_KEY =\"'+str(twit_access_key_ans)+'\"\n\
ACCESS_SECRET =\"'+str(twit_access_secret_ans)+'\"\n')
			setting.close()
	except OSError:
		pass
	pass
	from conf import settings as config
	try:
		os.mkdir(str(config.gpghome_dir))
	except OSError:
		pass
	pass
start_up()
from conf import settings as config
from optparse import OptionParser
from pastebin_python import PastebinPython
from pastebin_python.pastebin_exceptions import PastebinBadRequestException, PastebinNoPastesException, PastebinFileException
from pastebin_python.pastebin_constants import PASTE_PUBLIC, PASTE_PRIVATE, EXPIRE_10_MIN, EXPIRE_1_DAY, EXPIRE_1_HOUR
from pastebin_python.pastebin_formats import FORMAT_NONE, FORMAT_PYTHON, FORMAT_HTML
#Class for App

def getpassword():
	passwd=getpass.getpass()
	return passwd
def user_to_text():
	user_to_msg=raw_input(bcolors.GREEN+"Who would you like to Message: "+bcolors.ENDC)
	without_at=re.compile(r'@(.*)')
	clean_user=without_at.findall(user_to_msg)
	try:
		return clean_user[0]
	except IndexError:
		return user_to_msg.lower()
class noti(object):
	"""docstring for noti"""
	def __init__(self, img_tod, title, arg, sec):
		super(noti, self).__init__()
		self.img_tod=img_tod
		self.title=title
		self.arg=arg
		self.sec=sec
		if pynotify.init('noti class'):
			n = pynotify.Notification(title, arg, img_tod)
			n.set_timeout(sec)
			n.show()
class Paste_Bin(object):
	"""docstring for Paste_Bin"""
	def __init__(self):
		super(Paste_Bin, self).__init__()
		self.pastebin_key= config.pastebin_key 
		self.pastebin_username=config.pastebin_username
		self.pastebin_passwd=config.pastebin_passwd
		self.pbin = PastebinPython(api_dev_key=self.pastebin_key)
	def Post_Paste_From_File(self, filename):
		'''
		createPaste(api_paste_code, api_paste_name='', api_paste_format='', api_paste_private='', api_paste_expire_date='')
		'''
		self.filename=filename
		try:
			paste_link=self.pbin.createPasteFromFile(filename, 'TweepCrypt', FORMAT_PYTHON, PASTE_PUBLIC, EXPIRE_1_DAY)
			if 'Post limit, maximum pastes per 24h reached' in paste_link:
				comment="Paste Failed "+time.ctime()
				return comment
			else:
				print paste_link
				hm=re.compile(r'http://pastebin.com/(.*)')
				hrmm=hm.findall(str(paste_link))
				if hrmm[0] == None:
					pass
				else:
					if len(hrmm[0]) < 3:
						pass
					else:
						return hrmm[0]
		except PastebinBadRequestException as e:
			print e
		except PastebinFileException as e:
			print e
		pass
	def Post_Paste_From_CmdLine(self, cmd):
		'''
		createPaste(api_paste_code, api_paste_name='', api_paste_format='', api_paste_private='', api_paste_expire_date='')
		'''
		self.cmd=cmd
		try:
			paste_link=self.pbin.createPaste(str(cmd), 'TweepCrypt Test', FORMAT_PYTHON, PASTE_PUBLIC, EXPIRE_1_DAY)
			print paste_link
		except PastebinBadRequestException as e:
			print e
		except PastebinFileException as e:
			print e
		pass
class gnupghome(object):
	"""docstring for gnupghome"""
	def __init__(self, homedir):
		super(gnupghome, self).__init__()
		self.homedir=homedir
		self.gpg=gnupg.GPG(gnupghome=homedir)
	def gen_keys(self, typeE="RSA", length=1024, namereal="", namecom="", namemail=""):
		self.typeE=typeE
		self.length=length
		self.namereal=namereal
		self.namecom=namecom
		self.namemail=namemail
		input_data=self.gpg.gen_key_input(key_type=str(typeE), key_length=int(length), name_real=str(namereal), name_comment=str(namecom), name_email=str(namemail), expire_date=0, passphrase=getpassword())
		print bcolors.LIGHT_RED+"[+]"+bcolors.ENDC+bcolors.WARNING+"This Will Take A Few Minutes, Do Other Task To Create Entropy."+bcolors.ENDC
		key=self.gpg.gen_key(input_data)
		pass
	def list_uids(self):
		keys=self.gpg.list_keys()
		self.uids=[]
		for line in keys:
			self.uids+=[line['uids']]
		return self.uids
	def list_all(self):
		keys=self.gpg.list_keys()
		self.public_fingerprints=[]
		self.uids=[]
		for line in keys:
			self.public_fingerprints+=[line['fingerprint']]
			self.uids+=[line['uids']]
		return self.uids, self.public_fingerprints
	def whoami(self):
		keys=self.gpg.list_keys()
		self.uid=[]
		for line in keys:
			self.uid+=line['uids']
		return self.uid[0]
	def export_my_pubkey(self):
		keys=self.gpg.list_keys()
		self.public_finger=keys[0]['fingerprint']
		return self.public_finger
	def exportkeys(self, fingerprint_ID):
		self.fingerprint_ID=fingerprint_ID
		pub_key=self.gpg.export_keys(fingerprint_ID)
		return pub_key
	def importK(self, keys):
		self.keys=keys
		resu=self.gpg.import_keys(keys)
		return resu.results[0]['ok'][:]	
	def encryptFiles(self, recip, encrypt_data, outputfile):
		self.outputfile=outputfile
		self.encrypt_data=encrypt_data
		self.x=open(encrypt_data, 'rb')
		self.recip=recip
		data=self.gpg.encrypt_file(self.x, recipients=recip, passphrase=config.gpgpasswd, output=outputfile, always_trust=True, armor=True)
		return outputfile
		pass		
	def decryptFiles(self, darg, desired_filename):
		self.desired_filename=desired_filename
		self.darg=darg
		public_key=0
		gpg_message=0
		moved=0
		public_key_check=open(darg, 'r')
		message_check=str(public_key_check.readlines()[0])
		public_key_check.close()
		if '-----BEGIN PGP PUBLIC KEY BLOCK-----' in message_check:
			public_key=public_key+1
		if '-----BEGIN PGP MESSAGE-----' in message_check:
			gpg_message=gpg_message+1
		if public_key == 1:
			os.rename(darg, 'PublicKey.pub')
			moved=moved+1
			pass
		else:
			pass
		if gpg_message == 1:
			with open(darg) as f:
				decrypted_data=self.gpg.decrypt_file(f, passphrase=str(config.gpgpasswd), always_trust=True, output=str(desired_filename))
				time.sleep(0.2)
				if decrypted_data.ok == False:
					print decrypted_data.stderr
					print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+"Decryption Failed, Message Not Decrypted."+bcolors.ENDC
					pass
				else:
					if decrypted_data.ok == True:
						print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Message Decrypted"+bcolors.ENDC
						pass
					else:	
						pass
				pass
		else:
			pass
		if moved == 0:
			return "DING"
		else:
			if moved == 1:
				return "DONG"
class tweet(object):
	"""docstring for tweet"""
	def __init__(self):
		super(tweet, self).__init__()
		self.CONSUMER_KEY = config.CONSUMER_KEY 
		self.CONSUMER_SECRET = config.CONSUMER_SECRET  
		self.ACCESS_KEY = config.ACCESS_KEY  
		self.ACCESS_SECRET = config.ACCESS_SECRET  
		self.auth = tweepy.OAuthHandler(self.CONSUMER_KEY, self.CONSUMER_SECRET) 
		self.auth.set_access_token(self.ACCESS_KEY, self.ACCESS_SECRET) 
		self.api = tweepy.API(self.auth)
	def me(self):
		time.sleep(0.1)
		return self.api.me().name
	def my_image_url(self):
		x=self.api.me()
		return str(x.profile_image_url)
		pass
	def verify_twitter_friend(self, user_name):
		self.user_name=user_name
		find_friend=self.api.me()
		for line in find_friend.followers():
			if user_name.lower() == line.screen_name.lower():
				return bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"They Do Follow You."+bcolors.ENDC
			else:
				pass
		pass
	def direct_msg(self):
		self.directMessages=self.api.direct_messages()
		self.frank=[]
		self.bank=[]
		for line in self.directMessages:
			if 'TweepCrypt:' in line.text:
				self.frank+=[line.text]
				self.bank+=[line.sender_screen_name]
			else:
				pass
		return self.frank
	def direct_req_msg(self):
		self.directMessages=self.api.direct_messages()
		self.frank=[]
		self.bank=[]
		for line in self.directMessages:
			if 'TweepCrypt Request:' in line.text:
				self.frank+=[line.text]
				self.bank+=[line.sender_screen_name]
				pass
			else:
				pass
		return self.frank, self.bank
	def direct_verify(self):
		self.direct_v=self.api.direct_messages()
		self.banks=[]
		for line in self.direct_v:
			if 'TweepCrypt:' in line.text:
				self.banks+=[line.sender_screen_name+ " " + line.text]
				pass
			else:
				pass
		return self.banks
	def send_dm(self, USER, MSG):
		self.USER=USER
		self.MSG=MSG
		try:
			self.api.send_direct_message(screen_name=str(USER), text="TweepCrypt: "+str(MSG))
		except tweepy.error.TweepError:
			return "Message Not Sent"
		pass
	def send_req(self, USER, MSG):
		self.MSG=MSG
		self.USER=USER
		try:
			self.api.send_direct_message(screen_name=str(USER), text="TweepCrypt Request: "+str(MSG))
		except tweepy.error.TweepError:
			return "Message Not Sent"
		pass
	def download_image(self, twitter_username):
		self.twitter_username=twitter_username
		coldp=self.api.search_users(str(twitter_username))
		ff=coldp[0]
		if str(ff.screen_name.lower()) == str(twitter_username.lower()):
			imgg=str(ff.profile_image_url)
			return imgg
		else:
			pass
def dwd_my_tweet_img(url):
	if os.path.isfile('conf/my_img'):
		pass
	else:
		url=str(url)
		get=urllib2.urlopen(url)
		s=open('conf/my_img', 'w')
		s.write(get.read())
	pass
def dwd_tweet_img(url):
	url=str(url)
	get=urllib2.urlopen(url)
	s=open('user_img', 'w')
	s.write(get.read())
	pass
def download_gpgmsg(url, user_name):
	webFile = urllib2.urlopen(url)
	current_time=time.ctime()
	find_current=re.compile(r'\d\d.\d\d.\d\d')
	digit_time=find_current.findall(str(current_time))
	dd=time.ctime().split(" ")
	ddd=str(dd[1]+"_"+dd[3]+"_"+dd[4]+"_"+dd[5])
	filename =ddd+'.gpg_pastebin_download'
	localFile = open(os.path.abspath('.')+"/logs/"+user_name+"/"+user_name+"_"+filename, 'w')
	localFile.write(webFile.read())
	pass	
def logger(input_data):
	input_data=input_data
	data_safe=open('logs/downloads', 'a+')
	data_safe.write(str(input_data)+"\n")
	data_safe.close()
	pass
def verify_lnk(input_data):
	input_data=input_data
	match_count=0
	data_safe=open('logs/downloads', 'a+').readlines()
	for line in data_safe:
		if input_data in line:
			match_count=match_count+1
		else:
			pass
	if match_count > 0:
		return "VERIFIED"
	else:
		return "NOPE"
def user_folder(user_name):
	try:
		os.mkdir('logs/'+str(user_name.lower()))
		log=open('logs/'+str(user_name.lower())+"/"+'data.log', 'a+')
		log.write(time.ctime()+"\n")
		time.sleep(0.5)
		log.close()
	except:
		log=open('logs/'+str(user_name.lower())+"/"+'data.log', 'a+')
		log.write(time.ctime()+"\n")
		time.sleep(0.5)
		log.close()
	pass
def main():
	dwd_my_tweet_img(tweet().my_image_url())
	gpg=gnupghome(config.gpghome_dir)
	if os.path.isfile(str(config.gpghome_dir)+'/public_key'):
		pass
	else:
		www_d=open(str(config.gpghome_dir)+'/public_key', 'w')
		try:
			www_d.write(gpg.exportkeys(gpg.export_my_pubkey()))
		except IndexError:
			print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+"NO GPG KEYS FOUND!!!"+bcolors.ENDC
			gen_key_ans=raw_input("Create GPG Keys ?: Y or N: ")
			if str(gen_key_ans.lower()) == 'y':
				print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Generating Keys"+bcolors.ENDC
				type_ans=raw_input("Enter Type: RSA, DSA: ")
				length_ans=raw_input("Enter Length: 1024, 2048: ")
				twitter_name_ans=raw_input("Enter Name: User Twitter Name with No @, ex(mrxors, cryptdev, moxie): ")
				comment_ans=raw_input("Enter Comments For Account: ex(DEV ACCOUNT, TEST, TWITTER GPG): ")
				gpg.gen_keys(str(type_ans.upper()), int(length_ans), str(twitter_name_ans), str(comment_ans), str(config.email))
				print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Keys Generated!"+bcolors.ENDC
				www_d.write(gpg.exportkeys(gpg.export_my_pubkey()))
			else:
				pass
		www_d.close()
	def request(user_to_request):
		user_to_request=user_to_request
		log_data=open('logs/request', 'r')
		log_data_read=log_data.readlines()
		for line in log_data_read:
			if str(user_to_request) in line:
				print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+"Request For GPG Public Key Already Sent"+bcolors.ENDC
				sys.exit()
			else: pass
		print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+"PUBLIC KEY FOR USER NOT FOUND"+bcolors.ENDC
		print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"SENDING GPG PUBLIC KEY REQUEST TO @"+str(user_to_request)+bcolors.ENDC
		ans_for_pub=raw_input(bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Would You Like To Send A Request For A Public Key and send Your Pub Key? Y or N: "+bcolors.ENDC)
		if ans_for_pub.lower() == 'y':
			if os.path.isfile(str(config.gpghome_dir)+'/public_key'):
				pass
			else:
				www=open(str(config.gpghome_dir)+'/public_key', 'w')
				www.write(gpg.exportkeys(gpg.export_my_pubkey()))
				www.close()
			tweet().send_dm(str(user_to_request), str(Paste_Bin().Post_Paste_From_File(str(config.gpghome_dir)+'/public_key')))
			logs_for_req=open('logs/request', 'a+')
			logs_for_req.write(str(user_to_request)+" Recieved a Request for a public key.\n")
			logs_for_req.close()
		else:
			print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+"Request Not Sent!"+bcolors.ENDC
			sys.exit()
		pass
	def Check_DM_for_Kicker():
		user_name_for_Decrypt=[]
		directMSG=tweet().direct_msg()
		for line in directMSG:
			new_line=re.compile(r'TweepCrypt:(.*)')
			my_add=new_line.findall(str(line)) 
			if verify_lnk(my_add[0][1:]) == "VERIFIED":
				pass
			else:
				if str(my_add[0][1:]) == 'None':
					pass
				else:
					logger(my_add[0][1:])
					for lpo in tweet().direct_verify():
						if lpo.split(" ")[2] == my_add[0][1:]:
							user_name_for_Decrypt+=[str(lpo.split(" ")[0].lower())]
							user_folder(str(lpo.split(" ")[0].lower())) 
					try:
						download_gpgmsg('http://pastebin.com/download.php?i='+str(my_add[0][1:]), lpo.split(" ")[0].lower())
					except:
						print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+"Did not Download!"+bcolors.ENDC
		def Decrypt_downloaded_MSG():
			total_msg_count=0
			total_public_key_count=0
			os.chdir('logs')
			for line in list(set(user_name_for_Decrypt)):
				if os.path.isdir(line):
					os.chdir(line)
					if os.path.isfile('user_img'):
						pass
					else:
						dwd_tweet_img(str(tweet().download_image(str(line.lower()))))
					x=os.listdir('.')
					for files in x:
						if '.gpg' in files:
							ff=time.ctime().split(" ")
							fff=str(ff[1]+"_"+ff[3]+"_"+ff[4]+"_"+ff[5])
							decfile_name=fff+".decrypt"
							time.sleep(0.5)
							xdf=gpg.decryptFiles(files, decfile_name)
							if str(xdf) == "DONG":
								print os.path.abspath('.')
								total_public_key_count=total_public_key_count+1
							else:
								try:
									os.mkdir('../old_gpg/'+str(line))
								except OSError:
									pass
								os.system('mv '+str(files)+" ../old_gpg/"+str(line)+"/"+str(files))
							try:
								dfiles=open(decfile_name, 'r')
								if os.path.isfile(str(os.path.abspath('.')+"/"+'user_img')):
									try:
										noti(os.path.abspath('.')+"/"+'user_img', "From: @"+str(line), str(dfiles.read()), 1000)
									except:
										print "pynotify failed read by hand"
										pass
								else:
									print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+"ERROR"+bcolors.ENDC
								dfiles.close()
								try:
									os.mkdir('../archive/'+str(line))
								except OSError:
									pass
								os.system('mv '+str(decfile_name)+" ../archive/"+str(line)+"/"+str(line)+"_"+str(decfile_name))
								total_msg_count=total_msg_count+1
							except:
								pass
						else:
							pass
					os.chdir('../')
			os.chdir('../')
			print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+ str(total_msg_count)+ bcolors.ENDC, bcolors.WARNING+ "New Messages." +bcolors.ENDC 
			print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+ str(total_public_key_count)+ bcolors.ENDC, bcolors.WARNING+ "New Public Key Request." +bcolors.ENDC
			pass
		Decrypt_downloaded_MSG()
		def ck_ky(user_to_ck):
			user_to_ck=user_to_ck
			uids, fingerpes=gpg.list_all()
			names=[]
			for line in uids:
				names+=[line[0]]
			if str(user_to_ck) in str(names):
				return "DING"
			else:
				return "DONG"
		lol=os.listdir('logs/')
		for shit in lol:
			if str(shit) == "old_gpg":
				pass
			else:
				if ck_ky(str(shit)) == "DING":
					pass
				else:
					if os.path.isdir("logs/"+str(shit)+"/"):
						shitz=os.listdir("logs/"+str(shit)+"/")
						for line in shitz:
							if str(line) == "PublicKey.pub":
								BOB=open("logs/"+str(shit)+"/"+str(line)).read()
								if '-----BEGIN PGP PUBLIC KEY BLOCK-----' in str(BOB):
									dfg=raw_input("Would You Like To Import "+str(shit.lower())+"'s"+ " Public Key? Y or N:")
									if dfg.lower() == 'y':
										d=gpg.importK(str(BOB))
										if d == '1':
											print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"KEY FROM "+str(shit)+" IMPORED SUCCESSFULLY!!"+bcolors.ENDC
											send_pub=raw_input(bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Would You Like To Send Your Public Key? Y or N: "+bcolors.ENDC)
											if send_pub.lower() == 'y':
												data_to_ck=open('logs/request', 'r').readlines()
												quid=0
												for lines_to_ck in data_to_ck:
													if line.lower() in lines_to_ck:
														print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+"REQUSET ALLREADY SENT!"+bcolors.ENDC
														quid=1
														pass
													if quid == 1:
														pass
													else:		
														tweet().send_dm(str(line.lower()), str(Paste_Bin().Post_Paste_From_File(str(config.gpghome_dir)+'/public_key')))
														odb=open('logs/request', 'a+')
														odb.write(str(line.lower())+ " Recieved a Request for a public key.\n")
														odb.close()
											else:	
												pass
										else:	
											pass
									else:	
										pass
								else:	
									pass
							else:
								pass
	def Killer(arg, msg_file):
		msg_file=str(msg_file)
		arg=arg
		twitter_name=str(arg)
		Verif=tweet().verify_twitter_friend(twitter_name)
		if Verif == None:
			print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+"They Do Not Follow You , Request A Follow"+bcolors.ENDC
			sys.exit()
		else:
			print Verif
		try:
			noti(str(os.path.abspath('.'))+'/conf/my_img', 'GPG Key Loaded:', gpg.whoami(), 1000)
		except:
			print "pynotify failed"
			pass
		user_folder(twitter_name)
		pubcount=0
		for line in gpg.list_uids():
			if twitter_name in line[0].lower():
				pubcount=pubcount+1
				print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Found Possible Key:"+bcolors.ENDC, bcolors.BLUE+ line[0].lower()+bcolors.ENDC 
				answer=raw_input(bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Use This Key Y or N "+bcolors.ENDC+bcolors.WARNING+">>>"+bcolors.ENDC)
				if answer.lower() == 'y':
					DMSG=re.compile(r'<(.*)>')
					DDMSG=DMSG.findall(str(line[0].lower()))
					gpg_ID=DDMSG[0]
					or_file=str(msg_file)
					if os.path.isfile(or_file) == True:
						print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"File Located"+bcolors.ENDC
						print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Encrypting File", str(or_file), "with user", str(gpg_ID), "With Twitter Name: ", str(twitter_name) + bcolors.ENDC
						eee=time.ctime().split(" ")
						eeee=str(eee[1]+"_"+eee[3]+"_"+eee[4]+"_"+eee[5])
						gpg.encryptFiles()
						tweet().send_dm(str(twitter_name), str(Paste_Bin().Post_Paste_From_File(gpg.encryptFiles(gpg_ID, or_file, 'logs/'+twitter_name+"/"+eeee+".enc_file"))))
						sys.exit()
					else:
						print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Setting Up Message..."+bcolors.ENDC
						print  str(msg_file)
						msg_file_name=str('logs/'+twitter_name+"/"+"msg.log")
						msg_te=open(msg_file_name, 'w')
						msg_te.write(str(msg_file)+"\n")
						msg_te.close()
						time.sleep(1)
						lll=time.ctime().split(" ")
						llll=str(lll[1]+"_"+lll[3]+"_"+lll[4]+"_"+lll[5])
						tweet().send_dm(str(twitter_name), str(Paste_Bin().Post_Paste_From_File(gpg.encryptFiles(gpg_ID, str(msg_file_name), 'logs/'+twitter_name+"/"+llll+".enc_msg"))))
						sys.exit()
				else:
					print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+"::Exiting::"+bcolors.ENDC
					sys.exit()					
			else:
				pass
		request(twitter_name)
		sys.exit()
	def Read_Single_DM(user_to_read):
		user_to_read=user_to_read
		if os.path.isfile('logs/archive/'+str(user_to_read)+'/user_img'):
			pass
		else:
			if os.path.isfile('logs/'+str(user_to_read)+'/user_img'):
				os.system('cp logs/'+str(user_to_read)+'/user_img logs/archive/'+str(user_to_read)+'/user_img')
			else:
				print "NO IMAGE"
		try:
			os.chdir('logs/archive/'+str(user_to_read))
			msg_count=0
			time.sleep(0.2)
			for l in os.listdir('.'):
				if '.decrypt' in l:
					msg_count=msg_count+1
					vs=open(l, 'r')
					v=vs.read()
					try:
						noti(os.path.abspath('.')+str('/user_img'), "From: @"+str(user_to_read), v, 1500)
					except:
						print "pynotify Failed read by hand."
						pass
					vs.close()
				else:
					pass
			print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+str(msg_count), "Messages From", str(user_to_read) + bcolors.ENDC
			pass
		except OSError:
			pass
	#####################################################################################################
	usager = bcolors.BLUE+"\npython %prog -u [Twitter_User] [options]\npython %prog -r"+bcolors.ENDC
	parser = OptionParser(usage=usager, version="%prog 1.0")
	parser.add_option("-u", "--user", action="store", type="string", dest="twitterUser", help=bcolors.WARNING+"Twitter User To Decrypt/Encrypt/Read Message with NO @ sign"+bcolors.ENDC)
	parser.add_option("-e", "--encrypt-message", action="store", type="string", dest="encrypted_message", help=bcolors.WARNING+"File/Message(\"string\") To Encrypt, needs -u to complete."+bcolors.ENDC)
	parser.add_option("-d", "--decrypted-messages", action="store_true", dest="decrypt_message", help=bcolors.WARNING+"Read All Decrypted Messages from selected Twitter User."+bcolors.ENDC)##
	parser.add_option("-r", "--read-new", action="store_true", dest="read_dm", help=bcolors.WARNING+"Collect All New Messages"+bcolors.ENDC)
	parser.add_option("-g", "--gen-key", action="store_true", dest="gen_key", help=bcolors.WARNING+"Generate an Encryption Key To Communicate."+bcolors.ENDC)
	(options, args) = parser.parse_args()
	###########################################################################
	#Twitter Name Display
	try:
		print bcolors.BLUE+"@"+tweet().me()+bcolors.ENDC
	except:
		print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+"Need An Internet Connection! or Oauth Keys for Twitter and PasteBin!"+bcolors.ENDC
		parser.print_help()
		sys.exit()
	##########################################################################
	#Help And Args
	try:
		if sys.argv[1]:
			pass
	except IndexError:
		parser.print_help()
		sys.exit()
	############################
	#-d
	if options.decrypt_message:
		if options.twitterUser:
			if len(config.gpgpasswd)> 1:
				pass
			else: 
				config.gpgpasswd=getpassword()
				pass
			Read_Single_DM(options.twitterUser.lower())
		else:
			print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+ "Need -u (Twitter User Name) to Complete"+bcolors.ENDC
	else:
		pass
	############################
	#-r 
	if options.read_dm:
		if len(config.gpgpasswd)> 1:
			pass
		else: 
			config.gpgpasswd=getpassword()
			pass
		Check_DM_for_Kicker()
	else:
		pass
	#############################
	#-e 
	if options.encrypted_message:
		if options.twitterUser:
			Killer(options.twitterUser.lower(), str(options.encrypted_message))
		else:
			print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+ "Need -u (Twitter User Name) to Complete"+bcolors.ENDC
	else:
		pass
	#############################
	#-g
	if options.gen_key:
		try:
			if gpg.whoami():
				print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Key Found:"+bcolors.ENDC+bcolors.WARNING+str(gpg.whoami()) + bcolors.ENDC
				gen_ans=raw_input(bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.WARNING+"Would you Like to Delete Keys and Generate New Keys? Y or N: "+bcolors.ENDC)
				if gen_ans.lower() == 'y':
					type_ans=raw_input("Enter Type: RSA, DSA: ")
					length_ans=raw_input("Enter Length: 1024, 2048: ")
					twitter_name_ans=raw_in
					put("Enter Name: User Twitter Name with No @, ex(mrxors, cryptdev, moxie): ")
					comment_ans=raw_input("Enter Comments For Account: ex(DEV ACCOUNT, TEST, TWITTER GPG): ")
					gpg.gen_keys(str(type_ans.upper()), int(length_ans), str(twitter_name_ans), str(comment_ans), str(config.email))
					print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Keys Generated!"+bcolors.ENDC
				else: pass
		except:
			print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Generating Keys"+bcolors.ENDC
			type_ans=raw_input("Enter Type: RSA, DSA: ")
			length_ans=raw_input("Enter Length: 1024, 2048: ")
			twitter_name_ans=raw_input("Enter Name: User Twitter Name with No @, ex(mrxors, cryptdev, moxie): ")
			comment_ans=raw_input("Enter Comments For Account: ex(DEV ACCOUNT, TEST, TWITTER GPG): ")
			gpg.gen_keys(str(type_ans.upper()), int(length_ans), str(twitter_name_ans), str(comment_ans), str(config.email))
			print bcolors.GREEN+"[+]"+bcolors.ENDC+bcolors.BLUE+"Keys Generated!"+bcolors.ENDC

if __name__ =='__main__':
	#try:
	main()
	#except:
	print bcolors.LIGHT_RED+"[-]"+bcolors.ENDC+bcolors.WARNING+"EXITING"+bcolors.ENDC
	sys.exit()