func deferVerify(d []byte) (*message.Curve25519Key, *[message.MessageIDSize]byte, error) {
var keyHeader [message.KeyHeaderSize]byte
msg, err := message.Base64Message(d).Decode()
if err != nil {
return nil, nil, err
}
messageID := message.CalcMessageID(msg)
copy(keyHeader[:], msg[message.SignHeaderSize:message.SignHeaderSize+message.KeyHeaderSize])
_, recKeys, _ := message.ParseKeyHeader(&keyHeader)
return recKeys.ConstantPubKey, messageID, nil
}
// FetchPost fetches a post from a peer and adds it.
func (ms MessageServer) FetchPost(url, auth string, msgID [message.MessageIDSize]byte, expireRequest uint64) error {
// Fetch the post
proto := repproto.New(ms.SocksProxy, "")
data, err := proto.GetSpecificAuth(url, auth, msgID[:])
// data, err := proto.GetSpecific(url, msgID[:])
if err != nil {
return err
}
// Verify and use it
signheader, err := message.Base64Message(data).GetSignHeader()
if err != nil {
log.Debugf("Bad fetch:GetSignHeader: %s\n", err)
return err
}
details, err := message.VerifySignature(*signheader, ms.MinHashCashBits)
if err != nil {
log.Debugf("Bad fetch:VerifySignature: %s\n", err)
return err
}
constantRecipientPub, MessageID, err := deferVerify(data)
if err != nil {
log.Debugf("Bad fetch:deferVerify: %s\n", err)
return err
}
if *MessageID != details.MsgID {
log.Debugs("Bad fetch:MessageID\n")
return ErrBadMessageID
}
msgStruct := &structs.MessageStruct{
MessageID: *MessageID,
ReceiverConstantPubKey: *constantRecipientPub,
SignerPub: details.PublicKey,
OneTime: false,
Sync: false,
Hidden: false,
ExpireRequest: expireRequest,
}
if message.KeyIsSync(constantRecipientPub) {
msgStruct.Sync = true
}
if message.KeyIsHidden(constantRecipientPub) {
msgStruct.Hidden = true
}
sigStruct := &structs.SignerStruct{
PublicKey: details.PublicKey,
Nonce: details.HashCashNonce,
Bits: details.HashCashBits,
}
sigStruct.MaxMessagesPosted, sigStruct.MaxMessagesRetained, sigStruct.ExpireTarget = ms.calcLimits(details.HashCashBits)
return ms.DB.Put(msgStruct, sigStruct, data)
}
// ProcessPost verifies and adds a post to the database.
func (ms MessageServer) ProcessPost(postdata io.ReadCloser, oneTime bool, expireRequest uint64) string {
data, err := utils.MaxRead(ms.MaxPostSize, postdata)
if err != nil {
return "ERROR: Message too big\n"
}
if len(data) < ms.MinPostSize {
return "ERROR: Message too small\n"
}
signheader, err := message.Base64Message(data).GetSignHeader()
if err != nil {
log.Debugf("Post:GetSignHeader: %s\n", err)
return "ERROR: Sign Header\n"
}
details, err := message.VerifySignature(*signheader, ms.MinHashCashBits)
if err != nil {
log.Debugf("Post:VerifySignature: %s\n", err)
return "ERROR: HashCash\n"
}
constantRecipientPub, MessageID, err := deferVerify(data)
if err != nil {
log.Debugf("Post:deferVerify: %s\n", err)
return "ERROR: Verify\n"
}
if *MessageID != details.MsgID {
log.Debugs("Post:MessageID\n")
return "ERROR: MessageID\n"
}
msgStruct := &structs.MessageStruct{
MessageID: *MessageID,
ReceiverConstantPubKey: *constantRecipientPub,
SignerPub: details.PublicKey,
OneTime: oneTime,
Sync: false,
Hidden: false,
ExpireRequest: expireRequest,
}
if !oneTime {
if message.KeyIsSync(constantRecipientPub) {
msgStruct.Sync = true
}
} else {
msgStruct.Sync = false
}
if message.KeyIsHidden(constantRecipientPub) {
msgStruct.Hidden = true
}
sigStruct := &structs.SignerStruct{
PublicKey: details.PublicKey,
Nonce: details.HashCashNonce,
Bits: details.HashCashBits,
}
sigStruct.MaxMessagesPosted, sigStruct.MaxMessagesRetained, sigStruct.ExpireTarget = ms.calcLimits(details.HashCashBits)
_, _ = msgStruct, sigStruct
ms.RandomSleep()
// err = ms.DB.Put(msgStruct, sigStruct, data)
err = ms.DB.PutNotify(msgStruct, sigStruct, data, ms.notifyChan)
ms.RandomSleep()
if err != nil {
log.Debugf("Post:MessageDB: %s\n", err)
return fmt.Sprintf("ERROR: %s\n", err)
}
log.Debugf("Post:Added: %x\n", MessageID[:12])
if ms.Stat {
stat.Input <- stat.Post
}
return "SUCCESS: Connection close\n"
}