308 lines
11 KiB
Go
308 lines
11 KiB
Go
/*
|
|
Copyright © 2021 Arsen Musayelyan
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/signal"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/rs/zerolog"
|
|
"github.com/rs/zerolog/log"
|
|
flag "github.com/spf13/pflag"
|
|
)
|
|
|
|
var workDir *string
|
|
var destDir *string
|
|
|
|
func main() {
|
|
// Use ConsoleWriter logger
|
|
log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).Hook(FatalHook{})
|
|
|
|
// Create --send-to flag to send to a specific IP
|
|
sendTo := flag.String("send-to", "", "Use IP address of receiver instead of mDNS")
|
|
// Create --dest-dir flag to save to a specified folder
|
|
destDir = flag.String("dest-dir", "", "Destination directory for files or dirs sent over opensend")
|
|
// Create --work-dir flag to perform operations in a specified directory
|
|
workDir = flag.String("work-dir", "", "Working directory for opensend")
|
|
// Create --config to select config file to use
|
|
givenCfgPath := flag.String("config", "", "Opensend config to use")
|
|
// Create --skip-mdns to skip service registration
|
|
skipMdns := flag.Bool("skip-mdns", false, "Skip zeroconf service registration (use if mdns fails)")
|
|
// Create -t flag for type
|
|
actionType := flag.StringP("type", "t", "", "Type of data being sent")
|
|
// Create -d flag for data
|
|
actionData := flag.StringP("data", "d", "", "Data to send")
|
|
// Create -s flag for sending
|
|
sendFlag := flag.BoolP("send", "s", false, "Send data")
|
|
// Create -r flag for receiving
|
|
recvFlag := flag.BoolP("receive", "r", false, "Receive data")
|
|
targetFlag := flag.StringP("target", "T", "", "Target as defined in opensend.toml")
|
|
loopFlag := flag.BoolP("loop", "L", false, "Continuously wait for connections and handle them concurrently")
|
|
// Parse flags
|
|
flag.Parse()
|
|
|
|
// Declare config variable
|
|
var config *Config
|
|
// If config flag not provided
|
|
if *givenCfgPath == "" {
|
|
// Get config path
|
|
confPath := GetConfigPath()
|
|
// Read config at path
|
|
config = NewConfig(confPath)
|
|
} else {
|
|
// Otherwise, read config at provided path
|
|
config = NewConfig(*givenCfgPath)
|
|
}
|
|
|
|
// If work directory flag not provided
|
|
if *workDir == "" {
|
|
// If send flag provided
|
|
if *sendFlag {
|
|
// Set work directory to sender as defined in config
|
|
*workDir = ExpandPath(config.Sender.WorkDir)
|
|
} else {
|
|
// Otherwise set work directory to receiver as defined in config
|
|
*workDir = ExpandPath(config.Receiver.WorkDir)
|
|
}
|
|
}
|
|
|
|
// If destination directory flag not provided
|
|
if *destDir == "" {
|
|
// If receiver flag provided
|
|
if *recvFlag {
|
|
// Set destination directory to receiver as defined in config
|
|
*destDir = ExpandPath(config.Receiver.DestDir)
|
|
}
|
|
}
|
|
|
|
// If target flag provided
|
|
if *targetFlag != "" {
|
|
// Set IP to target's IP
|
|
*sendTo = config.Targets[*targetFlag].IP
|
|
}
|
|
|
|
// Create channel for signals
|
|
sig := make(chan os.Signal, 1)
|
|
// Send message on channel upon reception of SIGINT or SIGTERM
|
|
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
|
|
// Intercept signal
|
|
go func() {
|
|
signal := <-sig
|
|
// Warn user that a signal has been received and that opensend is shutting down
|
|
log.Warn().Str("signal", signal.String()).Msg("Signal received. Shutting down.")
|
|
// Remove opensend directory to avoid future conflicts
|
|
_ = os.RemoveAll(*workDir)
|
|
// Exit with code 0
|
|
os.Exit(0)
|
|
}()
|
|
|
|
// Create opensend dir ignoring errors
|
|
_ = os.Mkdir(*workDir, 0755)
|
|
// If -s given
|
|
if *sendFlag {
|
|
if *actionType == "" || *actionData == "" {
|
|
log.Fatal().Msg("Valid action type and data is required to send")
|
|
}
|
|
// Create 32 byte buffer
|
|
sharedKeyBytes := make([]byte, 32)
|
|
// Read random bytes into buffer
|
|
_, err := io.ReadFull(rand.Reader, sharedKeyBytes)
|
|
if err != nil {
|
|
log.Fatal().Err(err).Msg("Error generating random bytes")
|
|
}
|
|
// Encode random bytes to hexadecimal
|
|
sharedKey := hex.EncodeToString(sharedKeyBytes)
|
|
// Notify user a key has been created
|
|
log.Info().Msg("Generated random shared key")
|
|
// Create variable to store chosen IP
|
|
var choiceIP string
|
|
// If IP is provided via --send-to
|
|
if *sendTo != "" {
|
|
// Notify user that provided IP is being used
|
|
log.Info().Msg("IP provided. Skipping discovery.")
|
|
// Set chosen IP to provided
|
|
choiceIP = *sendTo
|
|
// Otherwise
|
|
} else {
|
|
// Notify user device discovery is beginning
|
|
log.Info().Msg("Discovering opensend receivers")
|
|
// Discover all _opensend._tcp.local. mDNS services
|
|
discoveredReceivers, discoveredIPs := DiscoverReceivers()
|
|
// Create reader for STDIN
|
|
reader := bufio.NewReader(os.Stdin)
|
|
// Print hostnames of each receiver
|
|
for index, receiver := range discoveredReceivers {
|
|
// Print hostname and index+1
|
|
fmt.Println("["+strconv.Itoa(index+1)+"]", receiver)
|
|
}
|
|
// Prompt user for choice
|
|
fmt.Print("Choose a receiver: ")
|
|
choiceStr, _ := reader.ReadString('\n')
|
|
// Convert input to int after trimming spaces
|
|
choiceInt, err := strconv.Atoi(strings.TrimSpace(choiceStr))
|
|
if err != nil {
|
|
log.Fatal().Err(err).Msg("Error converting choice to int")
|
|
}
|
|
// Set choiceIndex to choiceInt-1 to allow for indexing
|
|
choiceIndex := choiceInt - 1
|
|
// Get IP of chosen receiver
|
|
choiceIP = discoveredIPs[choiceIndex]
|
|
}
|
|
// Instantiate Config object
|
|
parameters := NewParameters(*actionType, *actionData)
|
|
// Validate data in config struct
|
|
parameters.Validate()
|
|
// Collect any files that may be required for transaction into opensend directory
|
|
parameters.CollectFiles(*workDir)
|
|
// Create config file in opensend directory
|
|
parameters.CreateFile(*workDir)
|
|
// Notify user of key exchange
|
|
log.Info().Msg("Performing key exchange")
|
|
// Exchange RSA keys with receiver
|
|
rawKey := SenderKeyExchange(choiceIP)
|
|
// Inform user receiver key has been received
|
|
log.Info().Msg("Receiver key received")
|
|
// Encrypt shared key using RSA public key
|
|
key := EncryptKey(sharedKey, rawKey)
|
|
// Save encrypted key in opensend directory as key.aes
|
|
SaveEncryptedKey(key, *workDir+"/key.aes")
|
|
// Notify user file encryption is beginning
|
|
log.Info().Msg("Encrypting files")
|
|
// Encrypt all files in opensend directory using shared key
|
|
EncryptFiles(*workDir, sharedKey)
|
|
// Notify user server has started
|
|
log.Info().Msg("Server started on port 9898")
|
|
// Send all files in opensend directory using an HTTP server on port 9898
|
|
SendFiles(*workDir)
|
|
} else if *recvFlag && *loopFlag {
|
|
// Declare zeroconf shutdown variable
|
|
var zeroconfShutdown func()
|
|
for {
|
|
// Create opensend dir ignoring errors
|
|
_ = os.Mkdir(*workDir, 0755)
|
|
// If --skip-mdns is not given
|
|
if !*skipMdns {
|
|
// Register {hostname}._opensend._tcp.local. mDNS service and pass shutdown function
|
|
zeroconfShutdown = RegisterService()
|
|
}
|
|
// Notify user keypair is being generated
|
|
log.Info().Msg("Generating RSA keypair")
|
|
// Generate keypair
|
|
privateKey, publicKey := GenerateRSAKeypair()
|
|
// Notify user opensend is waiting for key exchange
|
|
log.Info().Msg("Waiting for sender key exchange")
|
|
// Exchange keys with sender
|
|
senderIP := ReceiverKeyExchange(publicKey)
|
|
// If --skip-mdns is not given
|
|
if !*skipMdns {
|
|
// Shutdown zeroconf service as connection will be unavailable during transfer
|
|
zeroconfShutdown()
|
|
}
|
|
// Sleep 300ms to allow sender time to start HTTP server
|
|
time.Sleep(300 * time.Millisecond)
|
|
// Notify user files are being received
|
|
log.Info().Msg("Receiving files from server (This may take a while)")
|
|
// Connect to sender's TCP socket
|
|
connection := NewSender(senderIP)
|
|
// Get files from sender and place them into the opensend directory
|
|
RecvFiles(connection)
|
|
// Get encrypted shared key from sender
|
|
encryptedKey := GetKey(connection)
|
|
// Send stop signal to sender's HTTP server
|
|
SendSrvStopSignal(connection)
|
|
// Decrypt shared key
|
|
sharedKey := DecryptKey(encryptedKey, privateKey)
|
|
// Notify user file decryption is beginning
|
|
log.Info().Msg("Decrypting files")
|
|
// Decrypt all files in opensend directory using shared key
|
|
DecryptFiles(*workDir, sharedKey)
|
|
// Instantiate Config
|
|
parameters := &Parameters{}
|
|
// Read config file in opensend directory
|
|
parameters.ReadFile(*workDir + "/parameters.msgpack")
|
|
// Notify user that action is being executed
|
|
log.Info().Msg("Executing action")
|
|
// Execute MessagePack action using files within opensend directory
|
|
parameters.ExecuteAction(*workDir, *destDir)
|
|
// Remove opensend directory
|
|
err := os.RemoveAll(*workDir)
|
|
if err != nil {
|
|
log.Fatal().Err(err).Msg("Error removing opensend directory")
|
|
}
|
|
}
|
|
} else if *recvFlag {
|
|
// If --skip-mdns is not given
|
|
if !*skipMdns {
|
|
// Register {hostname}._opensend._tcp.local. mDNS service and pass shutdown function
|
|
zeroconfShutdown := RegisterService()
|
|
// Shutdown zeroconf server at the end of main()
|
|
defer zeroconfShutdown()
|
|
}
|
|
// Notify user keypair is being generated
|
|
log.Info().Msg("Generating RSA keypair")
|
|
// Generate keypair
|
|
privateKey, publicKey := GenerateRSAKeypair()
|
|
// Notify user opensend is waiting for key exchange
|
|
log.Info().Msg("Waiting for sender key exchange")
|
|
// Exchange keys with sender
|
|
senderIP := ReceiverKeyExchange(publicKey)
|
|
// Sleep 300ms to allow sender time to start HTTP server
|
|
time.Sleep(300 * time.Millisecond)
|
|
// Notify user files are being received
|
|
log.Info().Msg("Receiving files from server (This may take a while)")
|
|
// Connect to sender's TCP socket
|
|
sender := NewSender(senderIP)
|
|
// Get files from sender and place them into the opensend directory
|
|
RecvFiles(sender)
|
|
// Get encrypted shared key from sender
|
|
encryptedKey := GetKey(sender)
|
|
// Send stop signal to sender's HTTP server
|
|
SendSrvStopSignal(sender)
|
|
// Decrypt shared key
|
|
sharedKey := DecryptKey(encryptedKey, privateKey)
|
|
// Notify user file decryption is beginning
|
|
log.Info().Msg("Decrypting files")
|
|
// Decrypt all files in opensend directory using shared key
|
|
DecryptFiles(*workDir, sharedKey)
|
|
// Instantiate Config
|
|
parameters := &Parameters{}
|
|
// Read config file in opensend directory
|
|
parameters.ReadFile(*workDir + "/parameters.msgpack")
|
|
// Notify user that action is being executed
|
|
log.Info().Msg("Executing Action")
|
|
// Execute MessagePack action using files within opensend directory
|
|
parameters.ExecuteAction(*workDir, *destDir)
|
|
} else {
|
|
flag.Usage()
|
|
log.Fatal().Msg("You must choose sender or receiver mode using -s or -r")
|
|
}
|
|
// Remove opensend directory
|
|
err := os.RemoveAll(*workDir)
|
|
if err != nil {
|
|
log.Fatal().Err(err).Msg("Error removing opensend directory")
|
|
}
|
|
}
|