// KeyCallBack implements a callback function to request keys from file-descriptor
func KeyCallBack(keyMgtFd int) (*os.File, func(*message.Curve25519Key) *message.Curve25519Key) {
knownKeys := make(map[message.Curve25519Key]message.Curve25519Key)
fd := os.NewFile(uintptr(keyMgtFd), "fd/"+strconv.Itoa(keyMgtFd))
return fd, func(pubkey *message.Curve25519Key) *message.Curve25519Key {
// KeyCallBack func(*Curve25519Key) *Curve25519Key
log.Sync()
if v, ok := knownKeys[*pubkey]; ok { // Return from cache if we can
return &v
}
b := make([]byte, 120)
log.Dataf("STATUS (KeyMGTRequest):\t%s\n", utils.B58encode(pubkey[:]))
log.Sync()
n, _ := fd.Read(b)
if n == 0 {
log.Datas("STATUS (KeyMGT):\tREAD FAILURE\n")
return nil
}
log.Datas("STATUS (KeyMGT):\tREAD DONE\n")
k1, k2 := utils.ParseKeyPair(strings.Trim(string(b[:n]), " \t\r\n"))
if k1 != nil {
pub1 := message.GenPubKey(k1) // Add to cache
knownKeys[*pub1] = *k1
}
if k2 != nil {
pub2 := message.GenPubKey(k2) // Add to cache
knownKeys[*pub2] = *k2
}
if v, ok := knownKeys[*pubkey]; ok { // Return from cache if we can
return &v
}
return nil
}
}
// New returns a MessageServer.
func New(driver, url, path string, pubKey, privKey []byte) (*MessageServer, error) {
var err error
ms := new(MessageServer)
ms.DB = messagestore.New(driver, url, path, Workers)
if err != nil {
return nil, err
}
ms.path = path
ms.PeerFile = path + "peers.config"
ms.AddToPeer = DefaultAddToPeer
ms.MaxTimeSkew = DefaultMaxTimeSkew
ms.MinPostSize = MinPostSize
ms.MaxPostSize = MaxPostSize
ms.MinHashCashBits = MinHashCashBits
ms.MaxSleep = DefaultMaxSleep
ms.MaxIndexGlobal = DefaultIndexGlobal
ms.MaxIndexKey = DefaultIndexKey
ms.TimeGrace = DefaultTimeGrace
ms.MaxAuthTokenAge = DefaultAuthTokenAge
ms.NotifyDuration = DefaultNotifyDuration
ms.FetchDuration = DefaultFetchDuration
ms.FetchMax = DefaultFetchMax
ms.ExpireDuration = DefaultExpireDuration
ms.ExpireFSDuration = DefaultExpireFSDuration
ms.StepLimit = DefaultStepLimit
ms.ListenPort = DefaultListenPort
ms.MinStoreTime = DefaultMinStoreTime
ms.MaxStoreTime = DefaultMaxStoreTime
ms.MaxAgeSigners = DefaultMaxAgeSigners
ms.MaxAgeRecipients = DefaultMaxAgeRecipients
messagestore.MaxAgeRecipients = DefaultMaxAgeRecipients
messagestore.MaxAgeSigners = DefaultMaxAgeSigners
ms.EnablePeerHandler = true
ms.authPrivKey, err = message.GenLongTermKey(true, false)
if err != nil {
return nil, err
}
ms.AuthPubKey = message.GenPubKey(ms.authPrivKey)
if pubKey != nil && privKey != nil {
ms.TokenPubKey = new([ed25519.PublicKeySize]byte)
ms.TokenPrivKey = new([ed25519.PrivateKeySize]byte)
copy(ms.TokenPubKey[:], pubKey)
copy(ms.TokenPrivKey[:], privKey)
} else {
ms.TokenPubKey, ms.TokenPrivKey, err = ed25519.GenerateKey(rand.Reader)
log.Printf("Peer authentication public key: %s\n", utils.B58encode(ms.TokenPubKey[:]))
log.Printf("Peer authentication private key: %s\n", utils.B58encode(ms.TokenPrivKey[:]))
if err != nil {
return nil, err
}
}
ms.InfoStruct = new(ServerInfo)
ms.InfoStruct.MinHashCashBits = ms.MinHashCashBits
ms.InfoStruct.MinPostSize = ms.MinPostSize
ms.InfoStruct.MaxPostSize = ms.MaxPostSize
ms.InfoStruct.AuthPubKey = utils.B58encode(ms.AuthPubKey[:])
return ms, nil
}
// CmdGenTempKey generates a temporary key for a given private key
func CmdGenTempKey() int {
var privkey message.Curve25519Key
privkeystr := selectPrivKey(OptionsVar.Privkey, GlobalConfigVar.PrivateKey, "tty")
if privkeystr == "" {
log.Fatal("No private key given (-privkey)")
return 1
}
copy(privkey[:], utils.B58decode(privkeystr))
pubkey := message.GenPubKey(&privkey)
privkeytemp, err := message.GenRandomKey()
if err != nil {
log.Errorf("Key generation error:%s\n", err)
return 1
}
pubkeytemp := message.GenPubKey(privkeytemp)
log.Dataf("STATUS (PrivateKey):\t%s_%s\n", utils.B58encode(privkey[:]), utils.B58encode(privkeytemp[:]))
log.Dataf("STATUS (PublicKey):\t%s_%s\n", utils.B58encode(pubkey[:]), utils.B58encode(pubkeytemp[:]))
log.Printf("PRIVATE key: %s_%s\n\n", utils.B58encode(privkey[:]), utils.B58encode(privkeytemp[:]))
log.Printf("Public key: %s_%s\n", utils.B58encode(pubkey[:]), utils.B58encode(pubkeytemp[:]))
return 0
}
// CmdGenKey generates a long-term public key
func CmdGenKey() int {
privkey, err := message.GenLongTermKey(OptionsVar.Hidden, OptionsVar.Sync)
if err != nil {
log.Errorf("Key generation error:%s\n", err)
return 1
}
pubkey := message.GenPubKey(privkey)
log.Dataf("STATUS (PrivateKey):\t%s\n", utils.B58encode(privkey[:]))
// log.Dataf("STATUS (PublicKey):\t%s\n", utils.B58encode(pubkey[:]))
log.Printf("PRIVATE key: %s\n\n", utils.B58encode(privkey[:]))
// log.Printf("Public key: %s\n", utils.B58encode(pubkey[:]))
_ = pubkey
return 0
}
// Delete implements the delete call for messages.
func (ms MessageServer) Delete(w http.ResponseWriter, r *http.Request) {
var messageID *[message.MessageIDSize]byte
var privateKey *message.Curve25519Key
for i := 0; i < 4; i++ {
ms.RandomSleep() // Let's not give instant gratification here
}
w.Header().Set("Content-Type", "text/plain; charset=us-ascii")
getValues := r.URL.Query()
if getValues != nil {
if v, ok := getValues["messageid"]; ok {
t := utils.B58decode(v[0])
if len(t) < message.MessageIDSize || len(t) > message.MessageIDSize {
io.WriteString(w, "ERROR: Bad parameter\n")
return
}
messageID = new([message.MessageIDSize]byte)
copy(messageID[:], t)
}
if v, ok := getValues["privkey"]; ok {
t := utils.B58decode(v[0])
if len(t) < message.Curve25519KeySize || len(t) > message.Curve25519KeySize {
io.WriteString(w, "ERROR: Bad parameter\n")
return
}
privateKey = new(message.Curve25519Key)
copy(privateKey[:], t)
}
if privateKey != nil && messageID != nil {
publicKey := message.GenPubKey(privateKey)
err := ms.DB.PreExpire(messageID, publicKey)
if err == nil {
log.Errorf("Message censored: %x, asshole.\n", *messageID)
io.WriteString(w, "SUCCESS: If you want to call it that\n")
return
}
log.Errorf("Message censoring failed! %s\n", err)
}
}
io.WriteString(w, "ERROR: Missing parameters\n")
return
}
// CmdEncrypt encrypts data.
func CmdEncrypt() int {
var privkey, embedConstantPrivKey, embedTemporaryPrivKey, embedConstantPubKey, embedTemporaryPubKey *message.Curve25519Key
var err error
var inData, encMessage []byte
var meta *message.MetaDataSend
var signKeyPair *message.SignKeyPair
var removeFile string
if OptionsVar.Server == "" {
getPeers(false)
}
// OptionsVar.anonymous . disable private key and signkey
if OptionsVar.Anonymous {
OptionsVar.Signkey = ""
OptionsVar.Privkey = ""
GlobalConfigVar.PrivateKey = ""
}
mindelay := uint32(OptionsVar.Mindelay)
maxdelay := uint32(OptionsVar.Maxdelay)
// Read input data
maxInData := int64(GlobalConfigVar.BodyLength - (message.Curve25519KeySize * 2) - innerHeader)
//maxInData := int64(MsgSizeLimit)
if OptionsVar.Repost {
maxInData -= utils.RepostHeaderSize - message.KeyHeaderSize - message.SignHeaderSize
}
log.Debugf("Size limit: %d\n", maxInData)
inData, err = inputData(OptionsVar.Infile, maxInData)
if err != nil {
log.Fatalf("No input data: %s\n", err)
return 1
}
// Verify list contents
if OptionsVar.MessageType == message.MsgTypeList {
err := utils.VerifyListContent(inData)
if err != nil {
log.Errorf("Could not verify list input: %s\n", err)
return 1
}
}
// Select private key to use
privkeystr := selectPrivKey(OptionsVar.Privkey, GlobalConfigVar.PrivateKey, "")
// Parse privkey
if privkeystr != "" {
privkey = new(message.Curve25519Key)
copy(privkey[:], utils.B58decode(privkeystr))
}
// Generate embedded keypairs
if OptionsVar.Embedkey {
if OptionsVar.Notrace || privkey == nil {
embedConstantPrivKey, err = message.GenLongTermKey(OptionsVar.Hidden, OptionsVar.Sync)
if err != nil {
log.Errorf("Key generation error:%s\n", err)
return 1
}
} else {
embedConstantPrivKey = privkey
}
embedConstantPubKey = message.GenPubKey(embedConstantPrivKey)
embedTemporaryPrivKey, err = message.GenRandomKey()
if err != nil {
log.Errorf("Key generation error:%s\n", err)
return 1
}
embedTemporaryPubKey = message.GenPubKey(embedTemporaryPrivKey)
}
embedded := utils.EncodeEmbedded(embedConstantPubKey, embedTemporaryPubKey)
recipientConstantPubKey, recipientTemporaryPubKey := utils.ParseKeyPair(OptionsVar.Recipientkey)
// Find a signature keypair if we can
signKeyDir := ""
if GlobalConfigVar.KeyDir != "" {
signKeyDir = GlobalConfigVar.KeyDir
}
if OptionsVar.Signdir != "" {
signKeyDir = OptionsVar.Signdir
}
if OptionsVar.Signkey != "" {
var d []byte
d, err = utils.MaxReadFile(2048, OptionsVar.Signkey)
if err == nil {
signKeyPair = new(message.SignKeyPair)
kp, err := signKeyPair.Unmarshal(d)
if err != nil {
log.Errorf("Sign keypair decode error: %s\n", err)
signKeyPair = nil
} else {
signKeyPair = kp
}
} else {
log.Errorf("Sign keypair read error: %s\n", err)
}
}
if signKeyPair == nil && signKeyDir != "" {
var d []byte
d, removeFile, err = utils.ReadRandomFile(signKeyDir, 2048)
if err == nil {
signKeyPair = new(message.SignKeyPair)
kp, err := signKeyPair.Unmarshal(d)
if err != nil {
log.Errorf("Sign keypair decode error: %s\n", err)
signKeyPair = nil
removeFile = ""
} else {
signKeyPair = kp
}
} else {
log.Errorf("Sign keypair read error: %s\n", err)
}
}
// Set up sender parameters
sender := message.Sender{
Signer: signKeyPair,
SenderPrivateKey: privkey,
ReceiveConstantPublicKey: recipientConstantPubKey,
ReceiveTemporaryPublicKey: recipientTemporaryPubKey,
TotalLength: GlobalConfigVar.BodyLength,
PadToLength: GlobalConfigVar.PadToLength,
HashCashBits: GlobalConfigVar.MinHashCash,
}
// We want encryption output in realtime
log.Sync()
inData = append(embedded, inData...)
if OptionsVar.Repost {
// Generate a repost-message
encMessage, meta, err = sender.EncryptRepost(byte(OptionsVar.MessageType), inData)
if err == nil {
rph := utils.EncodeRepostHeader(meta.PadKey, mindelay, maxdelay)
encMessage = append(rph[:], encMessage...)
log.Datas("STATUS (Process):\tPREPOST\n")
log.Dataf("STATUS (RepostSettings):\t%d %d\n", mindelay, maxdelay)
}
} else {
// Generate a normal message
encMessage, meta, err = sender.Encrypt(byte(OptionsVar.MessageType), inData)
if err == nil {
log.Datas("STATUS (Process):\tPOST\n")
}
}
if err != nil {
log.Fatalf("Encryption failed: %s\n", err)
return 1
}
log.Sync()
// Output. repost is only written to stdout or file
if OptionsVar.Outfile == "-" || (OptionsVar.Repost && OptionsVar.Outfile == "") {
err = utils.WriteStdout(encMessage)
// Display data as necessary
if err == nil {
log.Dataf("STATUS (RecPubKey):\t%s\n", utils.B58encode(meta.ReceiverConstantPubKey[:]))
if OptionsVar.Embedkey {
log.Dataf("STATUS (EmbedPublicKey):\t%s_%s\n", utils.B58encode(embedConstantPubKey[:]), utils.B58encode(embedTemporaryPubKey[:]))
log.Dataf("STATUS (EmbedPrivateKey):\t%s_%s\n", utils.B58encode(embedConstantPrivKey[:]), utils.B58encode(embedTemporaryPrivKey[:]))
}
if meta.MessageKey != nil {
log.Dataf("STATUS (ListInput):\tNULL %s %s\n", utils.B58encode(meta.MessageID[:]), utils.B58encode(meta.MessageKey[:]))
log.Dataf("STATUS (Message):\t%s_%s\n", utils.B58encode(meta.MessageID[:]), utils.B58encode(meta.MessageKey[:]))
} else {
log.Dataf("STATUS (ListInput):\tNULL %s NULL\n", utils.B58encode(meta.MessageID[:]))
log.Dataf("STATUS (MessageID):\t%s\n", utils.B58encode(meta.MessageID[:]))
}
}
} else if OptionsVar.Outfile != "" || OptionsVar.Repost {
err = utils.WriteNewFile(OptionsVar.Outfile, encMessage)
// Display data as necessary
log.Dataf("STATUS (RecPubKey):\t%s\n", utils.B58encode(meta.ReceiverConstantPubKey[:]))
if err == nil {
if OptionsVar.Embedkey {
log.Dataf("STATUS (EmbedPublicKey):\t%s_%s\n", utils.B58encode(embedConstantPubKey[:]), utils.B58encode(embedTemporaryPubKey[:]))
log.Dataf("STATUS (EmbedPrivateKey):\t%s_%s\n", utils.B58encode(embedConstantPrivKey[:]), utils.B58encode(embedTemporaryPrivKey[:]))
}
if meta.MessageKey != nil {
log.Dataf("STATUS (ListInput):\tNULL %s %s\n", utils.B58encode(meta.MessageID[:]), utils.B58encode(meta.MessageKey[:]))
log.Dataf("STATUS (Message):\t%s_%s\n", utils.B58encode(meta.MessageID[:]), utils.B58encode(meta.MessageKey[:]))
log.Printf("Pastebin Address:\t%s_%s\n", utils.B58encode(meta.MessageID[:]), utils.B58encode(meta.MessageKey[:]))
} else {
log.Dataf("STATUS (ListInput):\tNULL %s NULL\n", utils.B58encode(meta.MessageID[:]))
log.Dataf("STATUS (MessageID):\t%s\n", utils.B58encode(meta.MessageID[:]))
log.Printf("Pastebin Address:\t%s\n", utils.B58encode(meta.MessageID[:]))
}
}
} else {
// Post to server
server := OptionsVar.Server
proto := repproto.New(OptionsVar.Socksserver, OptionsVar.Server, GlobalConfigVar.PasteServers...)
if server == "" {
server, err = proto.Post(meta.MessageID[:], encMessage)
} else {
err = proto.PostSpecific(server, encMessage)
}
sep := "/"
if server != "" && server[len(server)-1] == '/' {
sep = ""
}
if err == nil {
if meta.MessageKey != nil {
log.Dataf("STATUS (URL):\t%s/%s_%s\n", server, utils.B58encode(meta.MessageID[:]), utils.B58encode(meta.MessageKey[:]))
}
if OptionsVar.Embedkey {
log.Dataf("STATUS (EmbedPublicKey):\t%s_%s\n", utils.B58encode(embedConstantPubKey[:]), utils.B58encode(embedTemporaryPubKey[:]))
log.Dataf("STATUS (EmbedPrivateKey):\t%s_%s\n", utils.B58encode(embedConstantPrivKey[:]), utils.B58encode(embedTemporaryPrivKey[:]))
}
if meta.MessageKey != nil {
log.Dataf("STATUS (ListInput):\t%s %s %s\n", server, utils.B58encode(meta.MessageID[:]), utils.B58encode(meta.MessageKey[:]))
log.Dataf("STATUS (Message):\t%s_%s\n", utils.B58encode(meta.MessageID[:]), utils.B58encode(meta.MessageKey[:]))
log.Printf("Pastebin Address:\t%s%s%s_%s\n", server, sep, utils.B58encode(meta.MessageID[:]), utils.B58encode(meta.MessageKey[:]))
} else {
log.Dataf("STATUS (ListInput):\t%s %s NULL\n", server, utils.B58encode(meta.MessageID[:]))
log.Dataf("STATUS (MessageID):\t%s\n", utils.B58encode(meta.MessageID[:]))
log.Printf("Pastebin Address:\t%s%s%s\n", server, sep, utils.B58encode(meta.MessageID[:]))
}
}
}
if err != nil {
log.Fatalf("Output failed: %s\n", err)
log.Sync()
return 1
}
if removeFile != "" {
// Operation has been successful, remove signer keyfile (if any)
os.Remove(removeFile)
}
return 0
}