#!/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()
Comments