def __init__(self,contents,hashkeyID=None):
#assumes contents are objects not jsonDUMPs
if hashkeyID is None:
self.hashkeyID = hash_util.hash_str(str(contents))
else:
self.hashkeyID = hashkeyID
self.contents = contents
def handle_message(self, msg):
#print "got", msg, msg.recipient
#print to, to.hashid, self.myinfo.hashid
if msg.type == "CPOLL":
self.handle_CPOLL(msg)
return True
if msg.type == "CRESP":
cname = self.get_channel_from_hashid(msg.get_content("CHANNEL"))
if len(msg.message) > 0:
for m in msg.message:
#print m
ckey = ChatMessage.passwrd_to_3DES(cname)
chash = hash_util.hash_str(cname)
m.DESKEY = ChatMessage.passwrd_to_3DES(cname)
#print len(m.message)
m = copy.deepcopy(m)
m.decrypt()
m_owner = UserInfo.from_secret(m.sender)
#cname = self.get_channel_from_hashid(chash)
if str(m_owner.hashid) != str(self.myinfo.hashid):
print "<"+cname+">","["+m_owner.handle+"]", m.message
subscribed_channels[cname] = msg.get_content("pollTime")
return True
if msg.type == "CPOST":
self.handle_CPOST(msg)
return True
to = UserInfo.from_secret(msg.recipient)
if not hash_util.hash_equal(to.hashid,self.myinfo.hashid):
#print("got somebody else's message")
return True
if msg.type == "CHAT":
origin = UserInfo.from_secret(msg.sender)
local_origin = self.get_friend_from_hash(origin.hashid)
if local_origin is None:
print("You got a message from a user outside your friend list")
return
msg.desecure(self.myinfo)
msg.decrypt()
print( "{"+local_origin.handle+"} "+msg.message)
return True
if msg.type == "PING":
msg.desecure(self.myinfo)
msg.decrypt()
to = UserInfo.from_secret(msg.sender)
pid = msg.message
if pid in self.open_pings.keys():
now = time.time()
delta = now - self.open_pings[pid]
print self.get_friend_from_hash(to.hashid).handle, "is online", delta
else:
print to.handle, "is online and has pinged you"
newmsg = ChatMessage(self.owner, to.hashid, self.owner, self.myinfo.gen_secret(False), to.gen_secret(False), pid, to.sign(pid) )
newmsg.type = "PING"
newmsg.encrypt()
newmsg.secure(to)
self.send_message(newmsg,None)
return True
return True
def __init__(self, myservice, filename):
self.myservice = myservice
self.filename = filename
self.hashloc = hash_util.hash_str(filename)
self.contents = ""
self.waiting = True
request = Database_Message(myservice.owner, self.hashloc)
myservice.send_message(request,None)
def __init__(self,filename):
self.filename = filename
self.filehash_name = hash_util.hash_str(filename)
self.done = False
self.has_key = False
self.input_stream = Queue.Queue()
self.chunklist = []
self.chunks = {}
def __init__(self, myservice, filename):
self.myservice = myservice
self.filename = filename
self.hashloc = hash_util.hash_str(filename)
self.contents = ""
self.waiting = True
request = Database_Message(myservice.owner, self.hashloc)
myservice.send_message(request, None)
def handle_command(self, comand_st, arg_str):
#print "debug", comand_st, arg_str
global subscribed_channels
### one of your commands got typed in
if comand_st == "/listen":
chan = arg_str
if not chan in subscribed_channels.keys():
subscribed_channels[chan] = 0.0
if comand_st == "/post":
chan, msg = arg_str.split(" ",1)
ckey = ChatMessage.passwrd_to_3DES(chan)
chash = hash_util.hash_str(chan)
pmsg = ChatMessage(self.owner, chash, self.owner, self.myinfo.gen_secret(False), "NONE", msg, "NONE" )
pmsg.DESKEY = ChatMessage.passwrd_to_3DES(chan)
pmsg.type = "CPOST"
pmsg.encrypt()
pmsg.DESKEY = None
self.send_message(pmsg, None)
if comand_st == "/add":
self.add_friend(arg_str)
if comand_st == "/send":
args = arg_str.split(" ",1)
to_str = args[0]
to = self.get_friend(to_str)
if to is None:
return
try:
msg = args[1]
except:
print("you need a message")
return
newmsg = ChatMessage(self.owner, to.hashid, self.owner, self.myinfo.gen_secret(False), to.gen_secret(False), msg, to.sign(msg) )
newmsg.encrypt()
newmsg.secure(to)
self.send_message(newmsg, None)
if comand_st == "/whoami":
print( self.myinfo.gen_secret(False))
if comand_st == "/who":
print("Your friends are:")
for f in self.friends:
print(f.handle)
for f in self.friends:
self.ping(f.handle)
if comand_st == "/save":
mylist = [self.myinfo]+self.friends
write_preferences("userinfo/data.txt",mylist)
if comand_st == "/rename":
args = arg_str.split(" ")
old = args[0]
new = args[1]
f = self.get_friend(old)
if not f is None:
f.handle = new
print(old+" has been renamed "+new)
if comand_st == "/ping":
user = arg_str
self.ping(user)
def poll_channels(self):
global subscribed_channels
for c in subscribed_channels.keys():
# print "pollin", c
lasttime = subscribed_channels[c]
chash = hash_util.hash_str(c)
newmsg = ChatMessage(self.owner, chash, self.owner, self.myinfo.gen_secret(False), "NONE", str(lasttime), "NONE" )
newmsg.type = "CPOLL"
self.send_message(newmsg, None)
time.sleep(1)
def writeFile(self,key):
keyfilestr = str(key)
hashid = hash_util.hash_str(key.name)
d = Data_Atom(keyfilestr,hashid)
self.putChunk(d)
atoms = []
for k in key.chunks:
atoms.append(key.chunks[k])
mystuff = self.polite_distribute(atoms)
for a in mystuff:
writeChunk(a)
def http_get(self,path):
path = path[1:].upper()
possible = path.split(".")
path = possible[-2]
key = hash_util.hash_str(path)
self.open_requests[key] = Open_request(self, path)
data = self.open_requests[key].get_file(blocking=True)
try:
raw = data[:-64]
sig = data[-64:]
if self.blockchain.validate(raw,sig,path):
return raw
else:
return "403 Forbidden"
except ValueError:
return data
def http_get(self, path):
path = path[1:].upper()
possible = path.split(".")
path = possible[-2]
key = hash_util.hash_str(path)
self.open_requests[key] = Open_request(self, path)
data = self.open_requests[key].get_file(blocking=True)
try:
raw = data[:-64]
sig = data[-64:]
if self.blockchain.validate(raw, sig, path):
return raw
else:
return "403 Forbidden"
except ValueError:
return data
def stage():
filename = ".\\tests\\shakespeare.txt"
key = makeKeyFile(filename,smartChunk)
cfs = getCFSsingleton()
cfs.writeFile(key)
time.sleep(2)
# generate the id for the keyfile from the filename
hashid =hash_util.hash_str(filename)
keyfile_raw = cfs.getChunk(hashid).contents
keyfile = KeyFile.parse(keyfile_raw)
atoms = []
for key in keyfile.chunklist:
atoms.append(Data_Atom(key,key))
return atoms
def store(self, filename,segment_size=128):
segment_ids = []
segments = []
with open(filename, "rb") as f:
byte = f.read(segment_size)
while byte:
newid = hash_util.generate_random_key().key
segment_ids.append(newid)
segments.append(byte)
byte = f.read(segment_size)
keyfile = "KEYFILE\n"+filename+"\n"+reduce(lambda x,y: x+"\n"+y,segment_ids)
keyfile_hash = hash_util.hash_str(filename)
keyfile_message = shelver.Database_Message(self.owner,keyfile_hash, "FileSystem", "PUT")
keyfile_message.add_content("file_contents",keyfile)
self.send_message(keyfile_message,None)
number_of_chunks = len(segments)
for i in range(0,number_of_chunks):
chunkfile_message = shelver.Database_Message(self.owner,hash_util.Key(segment_ids[i]), "FileSystem", "PUT")
actual_contents = str(keyfile_hash)+"\n"+segments[i]
chunkfile_message.add_content("file_contents",actual_contents)
self.send_message(chunkfile_message,None)
def sign(self, msg):
hash_to_sign = hash_util.hash_str(msg).key
return rsa.encrypt(hash_to_sign, self.publickey)
#hash of Last Block|blockid|Exchanges|declaration|timestamp|nonce
#64 bit int
#hash of last block = 160 bit hash of the previous block
#Exchanges = <Domain,Newowner>sig(oldowner)
#Declaration = <Domain, newowner>
#timestamp = unix epoc time
#none =
# '|' is the divider between sections
# '+' is the divider between Exchanges
#EXAMPLE
"""
test = hash_util.hash_str("TEST")
print test
test_user = sec_service.SecNodeInfo.generate_new("Brendan")
print test_user.gen_secret(False)
"""
difficulty = 2**140
test = """0x0000000000000000000000000000000000000000|0||<test,Brendan:0x540be95c12e72a28c32388994ff0efb12ac63ca7:0x800b400ed966fcc0d4807adf5e884f1ed6af227aaeb00c463ebdf473d4da1b9bde466a9d155df80dbc565575a5130344691425d0f705c88514d77912f3fd339d?0x10001>|1384540375.4590001|"""
nonce = hash_util.generate_random_key()
newhash = hash_util.hash_str(test + str(nonce))
while newhash.toint() > difficulty:
print
nonce = hash_util.generate_random_key()
newhash = hash_util.hash_str(test + str(nonce))
print ""
print nonce
print newhash
def http_get(self,path):
key = hash_util.hash_str(path)
self.open_requests[key] = Open_request(self, path)
return self.open_requests[key].get_file(blocking=True)
def get_record(self, name):
hash_loc = hash_util.hash_str(name)
newmsg = Database_Message(self.owner, hash_loc, "ECHO", "GET")
self.send_message(newmsg)
def read(self,filename):
filehash = hash_util.hash_str(filename)
new_partial = Partial_file(filename)
self.partial_files[str(filehash)]=new_partial
get_keyfile_message = shelver.Database_Message(self.owner,filehash, "FileSystem", "GET")
self.send_message(get_keyfile_message,None)
def validate(self, msg, signature):
unsigned = rsa.decrypt(signature, self.publickey)
hash_to_sign = hash_util.hash_str(msg).key
return unsigned == hash_to_sign
def get_record(self,name,return_service="DATABASE"):
hash_loc = hash_util.hash_str(name)
newmsg = Database_Message(self.owner,hash_loc,SERVICE_ECHO,GET)
self.send_message(newmsg, None)
def get_record(self,node_info, name):
hash_loc = hash_util.hash_str(name)
newmsg = Database_Get_Message(node_info,hash_loc,SERVICE_ECHO,GET)
self.send_message(newmsg)
def generate_new(cls, handle):
(pubkey, privkey) = rsa.newkeys(512)
pubkey_str = hex(pubkey.n)[:-1] + "?" + hex(pubkey.e)[:-1]
myhash = hash_util.hash_str(pubkey_str)
return SecNodeInfo(handle, myhash, pubkey, privkey)
def put_record(self, name, data):
hash_loc = hash_util.hash_str(name)
newmsg = Database_Message(self.owner, hash_loc, DATABASE, PUT)
newmsg.add_content("file_contents", data)
self.send_message(newmsg, None)
def get_record(self, name, return_service="DATABASE"):
hash_loc = hash_util.hash_str(name)
newmsg = Database_Message(self.owner, hash_loc, SERVICE_ECHO, GET)
self.send_message(newmsg, None)
def get_channel_from_hashid(self, hid):
for c in subscribed_channels.keys():
if hash_util.hash_str(c) == hid:
return c
return None
def get_record(self,name):
hash_loc = hash_util.hash_str(name)
newmsg = Database_Message(self.owner,hash_loc,"ECHO","GET")
self.send_message(newmsg)
def getfileinfo(self,path,task):
fileloc = hash_util.hash_str(path)
request_message = shelver.Database_Message(self.owner, fileloc, Response_service="FTP", file_type="GET")
self.send_message(request_message,None)
self.outstanding_jobs.append(("get",fileloc,task))
def put_record(self,node_info, name,data):
hash_loc = hash_util.hash_str(name)
newmsg = Database_Put_Message(node_info,hash_loc, data)
self.send_message(newmsg)
#Exchanges = <Domain,Newowner>sig(oldowner)
#Declaration = <Domain, newowner>
#timestamp = unix epoc time
#none =
# '|' is the divider between sections
# '+' is the divider between Exchanges
#EXAMPLE
"""
test = hash_util.hash_str("TEST")
print test
test_user = sec_service.SecNodeInfo.generate_new("Brendan")
print test_user.gen_secret(False)
"""
difficulty = 2**140
test="""0x0000000000000000000000000000000000000000|0||<test,Brendan:0x540be95c12e72a28c32388994ff0efb12ac63ca7:0x800b400ed966fcc0d4807adf5e884f1ed6af227aaeb00c463ebdf473d4da1b9bde466a9d155df80dbc565575a5130344691425d0f705c88514d77912f3fd339d?0x10001>|1384540375.4590001|"""
nonce = hash_util.generate_random_key()
newhash = hash_util.hash_str(test+str(nonce))
while newhash.toint() > difficulty:
print
nonce = hash_util.generate_random_key()
newhash = hash_util.hash_str(test+str(nonce))
print ""
print nonce
print newhash
def put_record(self,name,data):
hash_loc = hash_util.hash_str(name)
newmsg = Database_Message(self.owner,hash_loc,DATABASE,PUT)
newmsg.add_content("file_contents",data)
self.send_message(newmsg, None)
def generate_new(cls, handle):
(pubkey, privkey) = rsa.newkeys(1024)
pubkey_str = hex(pubkey.n)[:-1]+"?"+hex(pubkey.e)[:-1]
myhash = hash_util.hash_str(pubkey_str)
return UserInfo(handle,myhash,pubkey,privkey)
def getfileinfo(self,path,task):
fileloc = hash_util.hash_str(path)
request_message = shelver.Database_Message(self.owner, fileloc, Response_service="FTP", file_type="GET")
self.send_message(request_message,None)
self.outstanding_jobs.append(("get",fileloc,task))
def validate(self, msg, signature):
unsigned = rsa.decrypt(signature, self.publickey)
hash_to_sign = hash_util.hash_str(msg).key
return unsigned == hash_to_sign
def sign(self, msg):
hash_to_sign = hash_util.hash_str(msg).key
return rsa.encrypt(hash_to_sign, self.publickey)
def gethashval(self):
if self.raw == "":
self.raw = str(self)
return hash_util.hash_str(self.raw).key
