func (ch *Channel) SignEnvelope(ev wire.Envelope) (*wire.Envelope, error) {
	// Put signature in correct slot
	switch ch.Me {
	case 1:
		ev.Signature1 = ed25519.Sign(sliceTo64Byte(ch.Identity1.Privkey), ev.Payload)[:]
	case 2:
		ev.Signature2 = ed25519.Sign(sliceTo64Byte(ch.Identity2.Privkey), ev.Payload)[:]
	}

	return &ev, nil
}

func (ks *Keyserver) updateSignatureProposer() {
	// invariant: do not access the db if ThisReplicaNeedsToSignLastEpoch = false
	want := ks.rs.ThisReplicaNeedsToSignLastEpoch
	have := ks.signatureProposer != nil
	if have == want {
		return
	}

	switch want {
	case true:
		tehBytes, err := ks.db.Get(tableEpochHeads(ks.rs.LastEpochDelimiter.EpochNumber))
		if err != nil {
			log.Panicf("ThisReplicaNeedsToSignLastEpoch but no TEH for last epoch in db: %s", err)
		}
		var teh proto.EncodedTimestampedEpochHead
		if err := teh.Unmarshal(tehBytes); err != nil {
			log.Panicf("tableEpochHeads(%d) invalid: %s", ks.rs.LastEpochDelimiter.EpochNumber, err)
		}
		seh := &proto.SignedEpochHead{
			Head:       teh,
			Signatures: map[uint64][]byte{ks.replicaID: ed25519.Sign(ks.sehKey, tehBytes)[:]},
		}
		ks.signatureProposer = StartProposer(ks.log, ks.clk, ks.retryProposalInterval,
			replication.LogEntry{Data: proto.MustMarshal(&proto.KeyserverStep{Type: &proto.KeyserverStep_ReplicaSigned{ReplicaSigned: seh}})})
	case false:
		ks.signatureProposer.Stop()
		ks.signatureProposer = nil
	}
}

// Sign signs the message with the private key using Ed25519.
func Sign(priv *PrivateKey, message []byte) ([]byte, bool) {
	if !priv.Valid() {
		return nil, false
	}
	sig := ed25519.Sign(priv.S, message)
	return sig[:], true
}

func (u *User) SetKeys(pubkey *[ed25519.PublicKeySize]byte, privkey *[ed25519.PrivateKeySize]byte) (err error) {
	sign := ed25519.Sign(privkey, signtestmsg)
	if ed25519.Verify(pubkey, signtestmsg, sign) {
		return nil
	}
	return ErrInvalidKey
}

func replyWithChallenge(w http.ResponseWriter, login string) {

	var defaultSaltRaw [32]byte
	rand.Read(defaultSaltRaw[:])
	salt := base64.StdEncoding.EncodeToString(defaultSaltRaw[:])

	u, ok := users[login]
	if ok {
		salt = u.Salt
	}

	var token [32]byte
	rand.Read(token[:])
	sig := ed25519.Sign(signingKey, token[:])

	signedTokenRaw := make([]byte, len(token)+len(sig))
	copy(signedTokenRaw, token[:])
	copy(signedTokenRaw[len(token):], sig[:])
	signedToken := base64.StdEncoding.EncodeToString(signedTokenRaw)

	err := json.NewEncoder(w).Encode(challenge{signedToken, salt})
	if err != nil {
		log.Println(err)
		http.Error(w, "Error with your request", http.StatusBadRequest)
	}
}

// Sign returns a signature for a given blob
func (s *Ed25519Signer) Sign(request *pb.SignatureRequest) (*pb.Signature, error) {
	priv := [ed25519.PrivateKeySize]byte{}
	copy(priv[:], s.privateKey.Private())
	sig := ed25519.Sign(&priv, request.Content)

	return &pb.Signature{KeyInfo: &pb.KeyInfo{KeyID: &pb.KeyID{ID: s.privateKey.ID()}, Algorithm: &pb.Algorithm{Algorithm: data.ED25519Key.String()}}, Content: sig[:]}, nil
}

func (ek *Ed25519PrivateKey) Sign(rand io.Reader, data []byte) (*ssh.Signature, error) {
	signature := ed25519.Sign(ek.bytes, data)
	return &ssh.Signature{
		Format: ek.PublicKey().Type(),
		Blob:   (*signature)[:],
	}, nil
}

func (p *RawPacket) Sign(privk *[ed25519.PrivateKeySize]byte) {
	length := uint16(len(p.Payload))
	buf := make([]byte, length+4)
	binary.BigEndian.PutUint16(buf, length)
	binary.BigEndian.PutUint16(buf[2:], p.Frametype)
	copy(buf[4:], p.Payload)
	p.Signature = ed25519.Sign(privk, buf)
}

// Create a factom.Entry and commit/reveal
func (a *APICall) Factomize() error {
	type entryBody struct {
		APIMethod  string
		ReturnData string
		Timestamp  int64
	}
	b := new(entryBody)

	b.APIMethod = a.APIMethod

	// get the ReturnData from the api call
	resp, err := http.Get(a.APIMethod)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	data, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	if resp.StatusCode != 200 {
		return fmt.Errorf(string(data))
	}
	b.ReturnData = string(data)

	// get the current time
	b.Timestamp = time.Now().Unix()

	// create the factom entry
	e := factom.NewEntry()

	e.ChainID = a.ChainID
	if e.Content, err = json.Marshal(b); err != nil {
		return err
	}

	// Write the signature of the Entry Content to the first ExtID
	e.ExtIDs = append(e.ExtIDs, func() []byte {
		sec := new([64]byte)
		if s, err := hex.DecodeString(a.SecKey); err != nil {
			log.Fatal(err)
		} else {
			copy(sec[:], s)
		}
		return ed.Sign(sec, e.Content)[:]
	}())

	// Commit+Reveal the Entry to the Factom Network
	if err := factom.CommitEntry(e, a.ECAddr); err != nil {
		return err
	}
	time.Sleep(10 * time.Second)
	if err := factom.RevealEntry(e); err != nil {
		return err
	}

	return nil
}

func SignKeys(keys []*[32]byte, sk *[64]byte) [][]byte {

	pkList := make([][]byte, 0)
	for _, key := range keys {
		signature := ed25519.Sign(sk, key[:])
		pkList = append(pkList, append(append([]byte{}, key[:]...), signature[:]...))
	}
	return pkList
}

func (ch *Channel) CosignProposedUpdateTx() *wire.Envelope {
	ev := ch.TheirProposedUpdateTxEnvelope
	ev.Signatures[ch.Me] = ed25519.Sign(sliceTo64Byte(ch.Account.Privkey), ev.Payload)[:]

	ch.LastFullUpdateTx = ch.TheirProposedUpdateTx
	ch.LastFullUpdateTxEnvelope = ch.TheirProposedUpdateTxEnvelope

	return ev
}

// Sign a messageid.
func (keypair *SignKeyPair) Sign(msgID [MessageIDSize]byte) *[SignHeaderSize]byte {
	signHeader := new([SignHeaderSize]byte)
	signHeader[0] = byte(Version)
	copy(signHeader[signHeaderPubkeyStart:signHeaderPubkeyEnd], keypair.PublicKey[:])
	copy(signHeader[signHeaderNonceStart:signHeaderNonceEnd], keypair.Nonce[:])
	signature := ed25519.Sign(keypair.PrivateKey, msgID[:])
	copy(signHeader[signHeaderSignatureStart:signHeaderSignatureEnd], signature[:])
	copy(signHeader[signHeaderMsgIDStart:signHeaderMsgIDEnd], msgID[:])
	return signHeader
}

// Sign a SpendPacket.
func (s *SpendPacket) Sign(privkey *[ed25519.PrivateKeySize]byte) {
	if privkey == nil {
		s.Signature = []byte{0x00}
		return
	}
	sig := ed25519.Sign(privkey, s.Image())
	s.Signature = make([]byte, len(sig))
	copy(s.Signature, sig[:])
	return
}

// ED25519Signature returns the ED25519 signature of data using the key.
func ED25519Signature(key, data []byte) ([]byte, error) {
	if len(key) != ed25519.PrivateKeySize {
		return nil, fmt.Errorf("Invalid size of key (%v)", len(key))
	}

	var k [ed25519.PrivateKeySize]byte
	copy(k[:], key)
	signature := ed25519.Sign(&k, data)

	return signature[:], nil
}

func ed25519Sign(privKey data.PrivateKey, message []byte) ([]byte, error) {
	if privKey.Algorithm() != data.ED25519Key {
		return nil, fmt.Errorf("private key type not supported: %s", privKey.Algorithm())
	}

	priv := [ed25519.PrivateKeySize]byte{}
	copy(priv[:], privKey.Private()[ed25519.PublicKeySize:])
	sig := ed25519.Sign(&priv, message)

	return sig[:], nil
}

// CounterSignToken creates a counter-signature for token
// recPubKey is the public key of Bob. Returns true/false and the countersigned prooftoken
func CounterSignToken(proof *[ProofTokenSize]byte, recPubKey *[ed25519.PublicKeySize]byte, recPrivKey *[ed25519.PrivateKeySize]byte) (bool, *[ProofTokenSignedSize]byte) {
	var counterSig [ProofTokenSignedSize]byte
	ok, _, _ := VerifyProofToken(proof, recPubKey)
	if !ok {
		return false, nil
	}
	copy(counterSig[:ProofTokenSize], proof[:ProofTokenSize])
	sig := ed25519.Sign(recPrivKey, proof[:ProofTokenSize])
	copy(counterSig[ProofTokenSize:], sig[:ed25519.SignatureSize])
	return true, &counterSig
}

// Sign attempts to sign a a message with a provideded key.
func Sign(sk, message []byte) (signature []byte, err error) {
	if len(message) == 0 {
		return nil, errors.New("cannot sign an empty message")
	}
	key, err := ToByteArray64(sk)
	if err != nil {
		return nil, errors.New("invalid signing key")
	}

	signature = ed25519.Sign(key, message)[:]
	return
}

func signKEX(kex *[kexPubSize + SignatureSize]byte, signer *[IdentityPrivateSize]byte) bool {
	if kex == nil {
		return false
	}

	if signer == nil {
		return true
	}

	sig := ed25519.Sign(signer, kex[:kexPubSize])
	copy(kex[kexPubSize:], sig[:])
	return true
}

// Unmarshal d into keypair.
func (keypair SignKeyPair) Unmarshal(d []byte) (*SignKeyPair, error) {
	kp := new(SignKeyPair)
	kp.PublicKey = new([SignerPubKeySize]byte)
	kp.PrivateKey = new([ed25519.PrivateKeySize]byte)
	copy(kp.PublicKey[:], d[0:SignerPubKeySize])
	copy(kp.PrivateKey[:], d[SignerPubKeySize:SignerPubKeySize+ed25519.PrivateKeySize])
	copy(kp.Nonce[:], d[SignerPubKeySize+ed25519.PrivateKeySize:SignerPubKeySize+ed25519.PrivateKeySize+hashcash.NonceSize])
	kp.Bits = d[SignerPubKeySize+ed25519.PrivateKeySize+hashcash.NonceSize]
	msg := []byte("validationtest")
	if ed25519.Verify(kp.PublicKey, msg, ed25519.Sign(kp.PrivateKey, msg)) {
		return kp, nil
	}
	return nil, ErrNoKeyFound
}

func (s *scriptState) buildHMACDelivery(to int, message []byte, seed int) *pond.Request {
	pub, priv, digest := s.makeOneTimePubKey(to, seed)
	sig := ed25519.Sign(priv, message)

	return &pond.Request{
		Deliver: &pond.Delivery{
			To:               s.publicIdentities[to][:],
			Message:          message,
			OneTimePublicKey: pub[:],
			HmacOfPublicKey:  proto.Uint64(digest),
			OneTimeSignature: sig[:],
		},
	}
}