def rpc_unfollow(self, sender, signature): self.log.info("Unfollow request from %s" % sender.id.encode("hex")) self.router.addContact(sender) try: verify_key = nacl.signing.VerifyKey(sender.signed_pubkey[64:]) verify_key.verify("unfollow:" + self.proto.guid, signature) f = FollowData() f.delete_follower(sender.id) return ["True"] except Exception: self.log.warning("Failed to validate follower signature") return ["False"]
def rpc_unfollow(self, sender, signature): self.log.info("Unfollow request from %s" % sender.id.encode("hex")) self.router.addContact(sender) try: verify_key = nacl.signing.VerifyKey(sender.signed_pubkey[64:]) verify_key.verify("unfollow:" + self.proto.guid, signature) f = FollowData() f.delete_follower(sender.id) return ["True"] except Exception: self.log.warning("Failed to validate follower signature") return ["False"]
def rpc_follow(self, sender, proto, signature): self.log.info("Follow request from %s" % sender.id.encode("hex")) self.router.addContact(sender) try: verify_key = nacl.signing.VerifyKey(sender.signed_pubkey[64:]) verify_key.verify(proto, signature) f = Followers.Follower() f.ParseFromString(proto) if f.guid != sender.id: raise Exception('GUID does not match sending node') if f.following != self.proto.guid: raise Exception('Following wrong node') f.signature = signature FollowData().set_follower(f) proto = Profile().get(False) m = Metadata() m.name = proto.name m.handle = proto.handle m.avatar_hash = proto.avatar_hash m.nsfw = proto.nsfw return [ "True", m.SerializeToString(), self.signing_key.sign(m.SerializeToString())[:64] ] except Exception: self.log.warning("Failed to validate follower") return ["False"]
def send_notification(self, message): """ Sends a notification message to all online followers. It will resolve each guid before sending the notification. Messages must be less than 140 characters. Returns the number of followers the notification reached. """ if len(message) > 140: return defer.succeed(0) def send(nodes): def how_many_reached(responses): count = 0 for resp in responses: if resp[1][0] and resp[1][1][0] == "True": count += 1 return count ds = [] signature = self.signing_key.sign(str(message))[:64] for n in nodes: if n[1] is not None: ds.append(self.protocol.callNotify(n[1], message, signature)) return defer.DeferredList(ds).addCallback(how_many_reached) dl = [] f = objects.Followers() f.ParseFromString(FollowData().get_followers()) for follower in f.followers: dl.append(self.kserver.resolve(follower.guid)) return defer.DeferredList(dl).addCallback(send)
def rpc_get_following(self, sender): self.log.info("Fetching following list from db") self.router.addContact(sender) ser = FollowData().get_following() if ser is None: return ["None"] else: return [ser, self.signing_key.sign(ser)[:64]]
def rpc_notify(self, sender, message, signature): if len(message) <= 140 and FollowData().is_following(sender.id): try: verify_key = nacl.signing.VerifyKey(sender.signed_pubkey[64:]) verify_key.verify(message, signature) except Exception: return ["False"] self.log.info("Received a notification from %s" % sender) self.router.addContact(sender) for listener in self.listeners: try: verifyObject(NotificationListener, listener) listener.notify(sender.id, message) except DoesNotImplement: pass return ["True"] else: return ["False"]
def save_to_db(result): if result[0] and result[1][0] == "True": try: u = objects.Following.User() u.guid = node_to_follow.id u.signed_pubkey = node_to_follow.signed_pubkey m = objects.Metadata() m.ParseFromString(result[1][1]) u.metadata.MergeFrom(m) u.signature = result[1][2] pubkey = node_to_follow.signed_pubkey[64:] verify_key = nacl.signing.VerifyKey(pubkey) verify_key.verify(result[1][1], result[1][2]) FollowData().follow(u) return True except Exception: return False else: return False
def get_following(self, request): def parse_following(following): if following is not None: response = {"following": []} for f in following.users: user_json = { "guid": f.guid.encode("hex"), "handle": f.metadata.handle, "name": f.metadata.name, "avatar_hash": f.metadata.avatar_hash.encode("hex"), "nsfw": f.metadata.nsfw } response["following"].append(user_json) request.setHeader('content-type', "application/json") request.write(json.dumps(response, indent=4)) request.finish() else: request.write(NoResource().render(request)) request.finish() if "guid" in request.args: def get_node(node): if node is not None: self.mserver.get_following(node).addCallback( parse_following) else: request.write(NoResource().render(request)) request.finish() self.kserver.resolve(unhexlify( request.args["guid"][0])).addCallback(get_node) else: ser = FollowData().get_following() if ser is not None: f = objects.Following() f.ParseFromString(ser) parse_following(f) else: parse_following(None) return server.NOT_DONE_YET
def notify(self, guid, message): # pull the metadata for this node from the db f = Following() ser = FollowData().get_following() if ser is not None: f.ParseFromString(ser) for user in f.users: if user.guid == guid: avatar_hash = user.metadata.avatar_hash handle = user.metadata.handle timestamp = int(time.time()) NotificationStore().save_notification(guid, handle, message, timestamp, avatar_hash) notification_json = { "notification": { "guid": guid.encode("hex"), "message": message, "timestamp": timestamp, "avatar_hash": avatar_hash.encode("hex") } } if handle: notification_json["notification"]["handle"] = handle self.ws.push(json.dumps(notification_json, indent=4))
def save_to_db(result): if result[0] and result[1][0] == "True": FollowData().unfollow(node_to_unfollow.id) return True else: return False