Method SendMessageTo

api/unit_inbox.go:134–222

(w http.ResponseWriter, r *http.Request)

}

func (api *API) SendMessageTo(w http.ResponseWriter, r *http.Request) {
	// authenticate source unit
	srcUnit := Authenticate(w, r)
	if srcUnit == nil {
		return
	}

	// get dest unit by fingerprint
	dstUnitFingerprint := chi.URLParam(r, "fingerprint")
	dstUnit := models.FindUnitByFingerprint(dstUnitFingerprint)
	if dstUnit == nil {
		ERROR(w, http.StatusNotFound, ErrRecNotFound)
		return
	}

	// read the message and signature from the source unit
	client := clientIP(r)
	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		ERROR(w, http.StatusUnprocessableEntity, err)
		return
	}

	var message Message
	if err = json.Unmarshal(body, &message); err != nil {
		log.Debug("error while decoding message from %s: %v", srcUnit.Identity(), err)
		log.Debug("%s", body)
		ERROR(w, http.StatusUnprocessableEntity, err)
		return
	}

	if err := models.ValidateMessage(message.Data, message.Signature); err != nil {
		log.Warning("client %s sent a broken message structure: %v", srcUnit.Identity(), err)
		ERROR(w, http.StatusUnprocessableEntity, err)
		return
	}

	// parse source unit key
	srcKeys, err := crypto.FromPublicPEM(srcUnit.PublicKey)
	if err != nil {
		log.Warning("error decoding key from %s: %v", srcUnit.Identity(), err)
		log.Debug("%s", srcUnit.PublicKey)
		ERROR(w, http.StatusUnprocessableEntity, ErrInvalidKey)
		return
	}

	// decode data, signature and verify SIGN(SHA256(data))
	data, err := base64.StdEncoding.DecodeString(message.Data)
	if err != nil {
		log.Warning("error decoding message from %s: %v", srcUnit.Identity(), err)
		log.Debug("%s", message.Data)
		ERROR(w, http.StatusUnprocessableEntity, ErrDecoding)
		return
	}

	signature, err := base64.StdEncoding.DecodeString(message.Signature)
	if err != nil {
		log.Warning("error decoding signature from %s: %v", srcUnit.Identity(), err)