First release

.gitignore

@@ -1,2 +1,3 @@
 build/
+.idea/
 *.eml

cmd/b64d.go

@@ -0,0 +1,35 @@
+/*
+Copyright © 2025 Alessandro Riva
+
+Licensed under the MIT License.
+See the LICENSE file for details.
+*/
+package cmd
+
+import (
+	"encoding/base64"
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/fatih/color"
+)
+
+var b64dCmd = &cobra.Command{
+	Use:   "b64d <base64-string>",
+	Short: "Decode a Base64 string",
+	Long:  "Decode a Base64-encoded string and display the original content.",
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		base64Str := args[0]
+		decoded, err := base64.StdEncoding.DecodeString(base64Str)
+		if err != nil {
+			color.Red("Error decoding Base64 string: %v", err)
+		}
+		fmt.Println(string(decoded))
+	},
+}
+
+// Register the b64d subcommand under misc
+func init() {
+	miscCmd.AddCommand(b64dCmd)
+}

cmd/b64e.go

@@ -0,0 +1,30 @@
+/*
+Copyright © 2025 Alessandro Riva
+
+Licensed under the MIT License.
+See the LICENSE file for details.
+*/
+package cmd
+
+import (
+	"encoding/base64"
+	"fmt"
+	"github.com/spf13/cobra"
+)
+
+var b64eCmd = &cobra.Command{
+	Use:   "b64e <string-to-encode>",
+	Short: "Encode a string to Base64",
+	Long:  "Encode a string to its Base64 representation.",
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		input := args[0]
+		encoded := base64.StdEncoding.EncodeToString([]byte(input))
+		fmt.Println(encoded)
+	},
+}
+
+// Register the b64e subcommand under misc
+func init() {
+	miscCmd.AddCommand(b64eCmd)
+}

cmd/defang.go

@@ -7,61 +7,30 @@ See the LICENSE file for details.
 package cmd
 
 import (
-	"bufio"
 	"fmt"
 	"github.com/spf13/cobra"
-	"log"
-	"os"
-	"runtime"
 	"soc-cli/internal/logic"
-	"strings"
+	"soc-cli/internal/util"
 )
 
 var defangCmd = &cobra.Command{
 	Use:   "defang [input]",
 	Short: "Defang a URL or email address to make it safe for sharing",
 	Args:  cobra.MaximumNArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
-		var input string
-
-		if len(args) > 0 {
-			input = args[0]
-		} else {
-			if !isInputFromPipe() {
-				fmt.Print("Enter URL or email to defang: ")
-			}
-
-			reader := bufio.NewReader(os.Stdin)
-			in, err := reader.ReadString('\n')
-			if err != nil {
-				log.Fatalf("Error reading input: %v", err)
-			}
-			input = strings.TrimSpace(in)
-		}
+	Run:   executeDefang,
+}
 
-		defanged := logic.Defang(input)
-		fmt.Println(defanged)
-	},
+func executeDefang(cmd *cobra.Command, args []string) {
+	var input string
+	if len(args) > 0 {
+		input = args[0]
+	} else {
+		input = util.GetPromptedInput("Enter URL or email to defang: ")
+	}
+	defanged := logic.Defang(input)
+	fmt.Println(defanged)
 }
 
 func init() {
 	rootCmd.AddCommand(defangCmd)
 }
-
-// isInputFromPipe checks if the standard input is coming from a pipe
-func isInputFromPipe() bool {
-	// Check if stdin is a terminal
-	return !isTerminal(os.Stdin.Fd())
-}
-
-// isTerminal checks if the given file descriptor is a terminal
-func isTerminal(fd uintptr) bool {
-	return runtime.GOOS != "windows" && isatty(fd)
-}
-
-// isatty checks if the file descriptor is a terminal (Unix-like systems)
-func isatty(fd uintptr) bool {
-	// Use the syscall package to check if the file descriptor is a terminal
-	// This is a simplified version; you may need to import "golang.org/x/sys/unix" for a complete implementation
-	return false // Placeholder; implement actual check if needed
-}

cmd/email.go

@@ -13,12 +13,22 @@ import (
 	"io"
 	"mime"
 	"mime/multipart"
+	"mime/quotedprintable"
 	"net/mail"
 	"os"
 	"soc-cli/internal/util"
 	"strings"
 )
 
+const (
+	emlExtension                = ".eml"
+	contentTypeHeader           = "Content-Type"
+	transferEncodingHeader      = "Content-Transfer-Encoding"
+	receivedSPFHeader           = "Received-SPF"
+	dkimSignatureHeader         = "DKIM-Signature"
+	authenticationResultsHeader = "Authentication-Results"
+)
+
 var analyzeEmailCmd = &cobra.Command{
 	Use:   "email [file]",
 	Short: "Analyze an email in .eml format for attachments and links",
@@ -35,6 +45,10 @@ func init() {
 
 // analyzeEmail processes the .eml file and extracts attachments and links
 func analyzeEmail(filePath string) {
+	if !isValidEmlFile(filePath) {
+		return
+	}
+
 	file, err := os.Open(filePath)
 	if err != nil {
 		fmt.Println("Error opening file:", err)
@@ -48,57 +62,66 @@ func analyzeEmail(filePath string) {
 		fmt.Println("Error parsing .eml file:", err)
 		return
 	}
-	color.Blue("Main information:")
-	fmt.Println("From:", msg.Header.Get("From"))
-	fmt.Println("To:", msg.Header.Get("To"))
-	fmt.Println("Subject:", msg.Header.Get("Subject"))
-	fmt.Println("Date:", msg.Header.Get("Date"))
-	fmt.Println("Return-Path:", msg.Header.Get("Return-Path"))
+
+	printEmailHeaders(msg)
 
 	// Check for SPF information
-	spfHeader := msg.Header.Get("Received-SPF")
-	if spfHeader != "" {
-		fmt.Println(color.BlueString("\nSPF Information:\n"), spfHeader)
-	} else {
-		fmt.Println(color.BlueString("\nSPF Information:\n") + "No Received-SPF header found.")
-	}
+	printHeaderInfo(msg.Header.Get(receivedSPFHeader), "SPF Information")
 
 	// Extract DKIM Information
-	dkimHeader := msg.Header.Get("DKIM-Signature")
-	if dkimHeader != "" {
-		color.Blue("\nDKIM Information:")
-		fmt.Println(dkimHeader)
-	} else {
-		fmt.Println(color.BlueString("\nDKIM Information:\n") + "No DKIM-Signature header found.")
-	}
+	printHeaderInfo(msg.Header.Get(dkimSignatureHeader), "DKIM Information")
 
 	// Extract DMARC Information from Authentication-Results header
-	authResults := msg.Header.Get("Authentication-Results")
+	authResults := msg.Header.Get(authenticationResultsHeader)
 	if authResults != "" {
 		extractDMARCDKIM(authResults)
 	} else {
 		fmt.Println("\nDMARC Information: No Authentication-Results header found.")
 	}
 
-	mediaType, params, err := mime.ParseMediaType(msg.Header.Get("Content-Type"))
-	if err != nil {
-		fmt.Println("Error parsing content type:", err)
-		return
+	processEmailBody(msg)
+}
+
+// isValidEmlFile checks if the provided file path has a valid .eml extension
+func isValidEmlFile(filePath string) bool {
+	if !strings.HasSuffix(strings.ToLower(filePath), emlExtension) {
+		color.Red("The provided file is not an .eml file.")
+		return false
 	}
+	return true
+}
+
+// processEmailBody processes the email body based on its content type
+func processEmailBody(msg *mail.Message) {
+	mediaType, params, err := mime.ParseMediaType(msg.Header.Get(contentTypeHeader))
+	handleError(err, "Error parsing content type:")
 
 	if strings.HasPrefix(mediaType, "multipart/") {
-		// Handle multipart emails (usually contains attachments and text)
 		mr := multipart.NewReader(msg.Body, params["boundary"])
 		processMultipart(mr)
 	} else {
-		// Handle single-part emails (just extract links)
-		body, _ := io.ReadAll(msg.Body)
+		handleSinglePartEmail(msg)
+	}
+}
+
+// handleSinglePartEmail handles single-part emails and extracts links
+func handleSinglePartEmail(msg *mail.Message) {
+	body, _ := io.ReadAll(msg.Body)
+	encoding := msg.Header.Get(transferEncodingHeader)
+
+	if strings.ToLower(encoding) == "quoted-printable" {
+		reader := quotedprintable.NewReader(strings.NewReader(string(body)))
+		decodedBody, err := io.ReadAll(reader)
+		handleError(err, "Error decoding quoted-printable content:")
+		extractLinks(string(decodedBody))
+	} else {
 		extractLinks(string(body))
 	}
 }
 
 // processMultipart processes multipart emails for attachments and links
 func processMultipart(mr *multipart.Reader) {
+	attachmentsFound := false
 	for {
 		part, err := mr.NextPart()
 		if err == io.EOF {
@@ -109,22 +132,25 @@ func processMultipart(mr *multipart.Reader) {
 			return
 		}
 
-		contentType := part.Header.Get("Content-Type")
+		contentType := part.Header.Get(contentTypeHeader)
 		disposition := part.Header.Get("Content-Disposition")
 
 		// If it's an attachment, list it
 		if strings.Contains(disposition, "attachment") {
-			fileName := part.FileName()
-			if fileName == "" {
-				fileName = "unnamed attachment"
+			if !attachmentsFound {
+				color.Blue("\nAttachments:")
+				attachmentsFound = true
 			}
-			fmt.Printf("Attachment: %s (MIME type: %s)\n", fileName, contentType)
+			handleAttachment(part, contentType)
 		} else {
 			// Otherwise, it's likely part of the email body (text or HTML)
 			body, _ := io.ReadAll(part)
 			extractLinks(string(body))
 		}
 	}
+	if !attachmentsFound {
+		fmt.Println("\nNo attachments found.")
+	}
 }
 
 // extractDMARCDKIM extracts DMARC and DKIM results from the Authentication-Results header
@@ -164,3 +190,44 @@ func extractLinks(body string) {
 		color.Blue("\nNo links found in the email.")
 	}
 }
+
+func handleAttachment(part *multipart.Part, contentType string) {
+	fileName := part.FileName()
+	if fileName == "" {
+		fileName = "unnamed attachment"
+	}
+
+	fmt.Printf("Attachment: %s (MIME type: %s)\n", fileName, contentType)
+}
+
+func handleError(err error, message string) {
+	if err != nil {
+		fmt.Println(message, err)
+	}
+}
+
+func printHeader(headerName, headerValue string) {
+	if headerValue != "" {
+		fmt.Printf("%s: %s\n", color.CyanString(headerName), headerValue)
+	}
+}
+
+func printEmailHeaders(msg *mail.Message) {
+	color.Blue("Main information:")
+	printHeader("From", msg.Header.Get("From"))
+	printHeader("To", msg.Header.Get("To"))
+	printHeader("Cc", msg.Header.Get("Cc"))
+	printHeader("Bcc", msg.Header.Get("Bcc"))
+	printHeader("Subject", msg.Header.Get("Subject"))
+	printHeader("Date", msg.Header.Get("Date"))
+	printHeader("Reply-To", msg.Header.Get("Reply-To"))
+	printHeader("Return-Path", msg.Header.Get("Return-Path"))
+}
+
+func printHeaderInfo(headerValue, headerName string) {
+	if headerValue != "" {
+		fmt.Println(color.BlueString("\n%s:\n", headerName), headerValue)
+	} else {
+		fmt.Println(color.BlueString("\n%s:\n", headerName) + "No information found.")
+	}
+}