// Get basic message from database. func GetMessage(log chan string, txidHash objects.Hash) *objects.Message { mutex.Lock() defer mutex.Unlock() hash := txidHash.GetBytes() if hashList == nil || dbConn == nil { return nil } if hashList[string(hash)] != MSG && hashList[string(hash)] != PUB { return nil } msg := new(objects.Message) for s, err := dbConn.Query("SELECT * FROM msg WHERE hash=?", hash); err == nil; err = s.Next() { var timestamp int64 encrypted := make([]byte, 0, 0) txidhash := make([]byte, 0, 0) addrhash := make([]byte, 0, 0) s.Scan(&txidhash, &addrhash, ×tamp, &encrypted) msg.TxidHash.FromBytes(txidhash) msg.AddrHash.FromBytes(addrhash) msg.Timestamp = time.Unix(timestamp, 0) msg.Content.FromBytes(encrypted) return msg } // Not Found return nil }
// Starts a new TCP Server wth configuration specified in ApiConfig. // Server will terminate cleanly only when data is sent to the Quit channel. // // See (struct ApiConfig) for details. func Start(config *ApiConfig) { var err error var frame quibit.Frame defer quit(config) config.Log <- "Starting api..." // Start Database Services err = db.Initialize(config.Log, config.DbFile) defer db.Cleanup() if err != nil { config.Log <- fmt.Sprintf("Error initializing database: %s", err) config.Log <- "Quit" return } config.LocalVersion.Timestamp = time.Now().Round(time.Second) locVersion := objects.MakeFrame(objects.VERSION, objects.REQUEST, &config.LocalVersion) for str, _ := range config.NodeList.Nodes { locVersion.Peer = str config.SendQueue <- *locVersion } // Set Up Clocks second := time.Tick(2 * time.Second) minute := time.Tick(time.Minute) for { select { case frame = <-config.RecvQueue: config.Log <- fmt.Sprintf("Received %s frame...", CmdString(frame.Header.Command)) switch frame.Header.Command { case objects.VERSION: version := new(objects.Version) err = version.FromBytes(frame.Payload) if err != nil { config.Log <- fmt.Sprintf("Error parsing version: %s", err) } else { fVERSION(config, frame, version) } case objects.PEER: nodeList := new(objects.NodeList) err = nodeList.FromBytes(frame.Payload) if err != nil { config.Log <- fmt.Sprintf("Error parsing peer list: %s", err) } else { fPEER(config, frame, nodeList) } case objects.OBJ: obj := new(objects.Obj) err = obj.FromBytes(frame.Payload) if err != nil { config.Log <- fmt.Sprintf("Error parsing obj list: %s", err) } else { fOBJ(config, frame, obj) } case objects.GETOBJ: getObj := new(objects.Hash) if len(frame.Payload) == 0 { break } err = getObj.FromBytes(frame.Payload) if err != nil { config.Log <- fmt.Sprintf("Error parsing getobj hash: %s", err) } else { fGETOBJ(config, frame, getObj) } case objects.PUBKEY_REQUEST: pubReq := new(objects.Hash) err = pubReq.FromBytes(frame.Payload) if err != nil { config.Log <- fmt.Sprintf("Error parsing pubkey request hash: %s", err) } else { fPUBKEY_REQUEST(config, frame, pubReq) } case objects.PUBKEY: pub := new(objects.EncryptedPubkey) err = pub.FromBytes(frame.Payload) if err != nil { config.Log <- fmt.Sprintf("Error parsing pubkey: %s", err) } else { fPUBKEY(config, frame, pub) } case objects.MSG: msg := new(objects.Message) err = msg.FromBytes(frame.Payload) if err != nil { config.Log <- fmt.Sprintf("Error parsing message: %s", err) } else { fMSG(config, frame, msg) } case objects.PUB: msg := new(objects.Message) err = msg.FromBytes(frame.Payload) if err != nil { config.Log <- fmt.Sprintf("Error parsing publication: %s", err) } else { fPUB(config, frame, msg) } case objects.PURGE: purge := new(objects.Purge) err = purge.FromBytes(frame.Payload) if err != nil { config.Log <- fmt.Sprintf("Error parsing purge: %s", err) } else { fPURGE(config, frame, purge) } case objects.CHECKTXID: chkTxid := new(objects.Hash) if len(frame.Payload) == 0 { break } err = chkTxid.FromBytes(frame.Payload) if err != nil { config.Log <- fmt.Sprintf("Error parsing checktxid hash: %s", err) } else { fCHECKTXID(config, frame, chkTxid) } default: config.Log <- fmt.Sprintf("Received invalid frame for command: %d", frame.Header.Command) } case <-config.Quit: fmt.Println() // Dump Nodes to File DumpNodes(config) return case <-second: // Reconnection Logic for key, node := range config.NodeList.Nodes { peer := quibit.GetPeer(key) if peer == nil || !peer.IsConnected() { quibit.KillPeer(key) if node.Attempts >= 3 { config.Log <- fmt.Sprintf("Max connection attempts reached for %s, disconnecting...", key) // Max Attempts Reached, disconnect delete(config.NodeList.Nodes, key) } else { config.Log <- fmt.Sprintf("Disconnected from peer %s, trying to reconnect...", key) peer = new(quibit.Peer) peer.IP = node.IP peer.Port = node.Port config.PeerQueue <- *peer runtime.Gosched() peer = nil node.Attempts++ config.NodeList.Nodes[key] = node locVersion.Peer = key config.SendQueue <- *locVersion } } } if len(config.NodeList.Nodes) < 1 { config.Log <- "All connections lost, re-bootstrapping..." for i, str := range config.Bootstrap { if i >= bufLen { break } p := new(quibit.Peer) n := new(objects.Node) err := n.FromString(str) if err != nil { fmt.Println("Error Decoding Peer ", str, ": ", err) continue } p.IP = n.IP p.Port = n.Port config.PeerQueue <- *p runtime.Gosched() config.NodeList.Nodes[n.String()] = *n } for str, _ := range config.NodeList.Nodes { locVersion.Peer = str config.SendQueue <- *locVersion } } case <-minute: // Dump old messages err = db.SweepMessages(30 * 24 * time.Hour) if err != nil { config.Log <- fmt.Sprintf("Error Sweeping Messages: %s", err) } } } // Should NEVER get here! panic("Must've been a cosmic ray!") }
// Handle Pubkey, Message, and Purge Registration func register(config *api.ApiConfig) { var message objects.Message var txid [16]byte for { select { case pubHash := <-config.PubkeyRegister: // Check if pubkey is in database... pubkey := checkPubkey(config, pubHash) if pubkey == nil { break } outbox := localdb.GetBox(localdb.OUTBOX) for _, metamsg := range outbox { recvHash := objects.MakeHash([]byte(metamsg.Recipient)) if string(pubHash.GetBytes()) == string(recvHash.GetBytes()) { // Send message and move to sendbox msg, err := localdb.GetMessageDetail(metamsg.TxidHash) if err != nil { config.Log <- err.Error() break } msg.Encrypted = encryption.Encrypt(config.Log, pubkey, string(msg.Decrypted.GetBytes())) msg.MetaMessage.Timestamp = time.Now().Round(time.Second) err = localdb.AddUpdateMessage(msg, localdb.SENDBOX) if err != nil { config.Log <- err.Error() break } sendMsg := new(objects.Message) sendMsg.Timestamp = msg.MetaMessage.Timestamp sendMsg.TxidHash = msg.MetaMessage.TxidHash sendMsg.AddrHash = recvHash sendMsg.Content = *msg.Encrypted config.RecvQueue <- *objects.MakeFrame(objects.MSG, objects.BROADCAST, sendMsg) } } case message = <-config.MessageRegister: // If address is registered, store message in inbox detail, err := localdb.GetAddressDetail(message.AddrHash) if err != nil { config.Log <- "Message address not in database..." break } if !detail.IsRegistered { config.Log <- "Message not for registered address..." break } config.Log <- "Registering new encrypted message..." msg := new(objects.FullMessage) msg.MetaMessage.TxidHash = message.TxidHash msg.MetaMessage.Timestamp = message.Timestamp msg.MetaMessage.Recipient = detail.String msg.Encrypted = &message.Content err = localdb.AddUpdateMessage(msg, localdb.INBOX) if err != nil { config.Log <- err.Error() } case message = <-config.PubRegister: // If address is registered, store message in inbox detail, err := localdb.GetAddressDetail(message.AddrHash) if err != nil { config.Log <- "Message address not in database..." break } if !detail.IsSubscribed { config.Log <- "Not Subscribed to Address..." break } config.Log <- "Registering new publication..." msg := new(objects.FullMessage) msg.MetaMessage.TxidHash = message.TxidHash msg.MetaMessage.Timestamp = message.Timestamp msg.MetaMessage.Sender = detail.String msg.MetaMessage.Recipient = "<Subscription Message>" msg.Encrypted = &message.Content msg.Decrypted = new(objects.DecryptedMessage) msg.Decrypted.FromBytes(encryption.DecryptPub(config.Log, detail.Pubkey, msg.Encrypted)) err = localdb.AddUpdateMessage(msg, localdb.INBOX) if err != nil { config.Log <- err.Error() } case txid = <-config.PurgeRegister: // If Message in database, mark as purged detail, err := localdb.GetMessageDetail(objects.MakeHash(txid[:])) if err != nil { break } detail.MetaMessage.Purged = true err = localdb.AddUpdateMessage(detail, -1) if err != nil { config.Log <- fmt.Sprintf("Error registering purge: %s", err) } } // End select } // End for } // End register
func (service *EMPService) PublishMessage(r *http.Request, args *SendMsg, reply *SendResponse) error { if !basicAuth(service.Config, r) { service.Config.Log <- fmt.Sprintf("Unauthorized RPC Request from: %s", r.RemoteAddr) return errors.New("Unauthorized") } // Nil Check if len(args.Sender) == 0 || len(args.Plaintext) == 0 { return errors.New("All fields required.") } var err error // Get Addresses sendAddr := encryption.StringToAddress(args.Sender) if len(sendAddr) == 0 { return errors.New("Invalid sender address!") } sender, err := localdb.GetAddressDetail(objects.MakeHash(sendAddr)) if err != nil { return errors.New(fmt.Sprintf("Error pulling send address from Database: %s", err)) } if sender.Privkey == nil { return errors.New("Private Key Required to Publish Message") } // Create New Message msg := new(objects.FullMessage) msg.Decrypted = new(objects.DecryptedMessage) msg.Encrypted = nil txid := make([]byte, len(msg.Decrypted.Txid), cap(msg.Decrypted.Txid)) // Fill out decrypted message n, err := rand.Read(txid) if n < len(msg.Decrypted.Txid[:]) || err != nil { return errors.New(fmt.Sprintf("Problem with random reader: %s", err)) } copy(msg.Decrypted.Pubkey[:], sender.Pubkey) msg.Decrypted.Subject = args.Subject msg.Decrypted.MimeType = "text/plain" msg.Decrypted.Content = args.Plaintext msg.Decrypted.Length = uint32(len(msg.Decrypted.Content)) // Fill Out Meta Message (save timestamp) msg.MetaMessage.Purged = false msg.MetaMessage.TxidHash = objects.MakeHash(txid) msg.MetaMessage.Sender = sender.String msg.MetaMessage.Recipient = "<Subscription Message>" // Get Signature priv := new(ecdsa.PrivateKey) priv.PublicKey.Curve = encryption.GetCurve() priv.D = new(big.Int) priv.D.SetBytes(sender.Privkey) sign := msg.Decrypted.GetBytes() sign = sign[:len(sign)-65] signHash := objects.MakeHash(sign) x, y, err := ecdsa.Sign(rand.Reader, priv, signHash.GetBytes()) if err != nil { return err } copy(msg.Decrypted.Signature[:], encryption.MarshalPubkey(x, y)) // Send message and add to sendbox... msg.Encrypted = encryption.EncryptPub(service.Config.Log, sender.Privkey, string(msg.Decrypted.GetBytes())) msg.MetaMessage.Timestamp = time.Now().Round(time.Second) // Now Add Txid copy(msg.Decrypted.Txid[:], txid) err = localdb.AddUpdateMessage(msg, localdb.SENDBOX) if err != nil { return err } sendMsg := new(objects.Message) sendMsg.TxidHash = msg.MetaMessage.TxidHash sendMsg.AddrHash = objects.MakeHash(sender.Address) sendMsg.Timestamp = msg.MetaMessage.Timestamp sendMsg.Content = *msg.Encrypted service.Config.RecvQueue <- *objects.MakeFrame(objects.PUB, objects.BROADCAST, sendMsg) reply.IsSent = true // Finish by setting msg's txid reply.TxidHash = msg.MetaMessage.TxidHash.GetBytes() return nil }