Hackaton export formats

cmd/root.go

@@ -4,17 +4,21 @@ import (
 	"os"
 
 	"github.com/Appliscale/cloud-security-audit/configuration"
-	"github.com/Appliscale/cloud-security-audit/resource"
 	"github.com/Appliscale/cloud-security-audit/csasession"
+	"github.com/Appliscale/cloud-security-audit/resource"
 
 	"github.com/Appliscale/cloud-security-audit/environment"
+	"github.com/Appliscale/cloud-security-audit/report"
 	"github.com/Appliscale/cloud-security-audit/scanner"
 	"github.com/spf13/cobra"
+	"strings"
 )
 
 // var cfgFile string
 var config = configuration.GetConfig()
 
+const STDOUT = "stdout"
+
 // rootCmd represents the base command when called without any subcommands
 var rootCmd = &cobra.Command{
 	Use:   "cloud-security-audit",
@@ -45,6 +49,8 @@ var (
 	profile     string
 	mfa         bool
 	mfaDuration int64
+	format      string
+	outputFile  string
 )
 
 func init() {
@@ -58,6 +64,8 @@ func init() {
 
 	rootCmd.Flags().BoolVarP(&mfa, "mfa", "m", false, "indicates usage of Multi Factor Authentication")
 	rootCmd.Flags().Int64VarP(&mfaDuration, "mfa-duration", "d", 0, "sets the duration of the MFA session")
+	rootCmd.Flags().StringVarP(&format, "format", "f", "TABLE", "specifies output format, available are: JSON, HTML, CSV, TABLE")
+	rootCmd.Flags().StringVarP(&outputFile, "output", "o", "STDOUT", "specify output file")
 }
 
 func getRegions() *[]string {
@@ -88,10 +96,54 @@ func getProfile() string {
 	return "default"
 }
 
+var printFormats = map[string]func(report.Report, *os.File){"TABLE": report.PrintTable, "JSON": report.PrintJsonReport, "HTML": report.PrintHtmlReport, "CSV": report.PrintCSVReport}
+
+func getFormat() func(report.Report, *os.File) {
+	for formatName, formatValue := range printFormats {
+		if format == formatName {
+			return formatValue
+		}
+	}
+	config.Logger.Error("Wrong type: " + format + " Available are: TABLE, JSON, HTML, CSV. Using default: TABLE")
+	return report.PrintTable
+}
+
+func getOutputFile() *os.File {
+	var ans string
+	if strings.ToLower(outputFile) == STDOUT {
+		return os.Stdout
+	}
+
+	if _, err := os.Stat(outputFile); err == nil {
+		config.Logger.GetInput("file "+outputFile+" already exists. Do you want to override it? [Y/n]", &ans)
+		if strings.ToLower(ans) == "y" || strings.ToLower(ans) == "yes" || ans == "" {
+			f, err := os.Create(outputFile)
+			if err != nil {
+				panic(err)
+			}
+			return f
+		} else {
+			os.Exit(1)
+		}
+	} else if os.IsNotExist(err) {
+		f, err := os.Create(outputFile)
+		if err != nil {
+			os.Exit(1)
+		}
+		return f
+	} else {
+		config.Logger.Error("Cannot determine if file " + outputFile + " exists")
+		os.Exit(1)
+	}
+	return os.Stdout
+}
+
 func initConfig() {
 	config.Regions = getRegions()
 	config.Services = getServices()
 	config.Profile = getProfile()
+	config.PrintFormat = getFormat()
+	config.OutputFile = getOutputFile()
 	config.Mfa = mfa
 	config.MfaDuration = mfaDuration
 	configuration.InitialiseMFA(config)

configuration/config.go

@@ -1,9 +1,11 @@
 package configuration
 
 import (
-	"github.com/Appliscale/cloud-security-audit/logger"
 	"github.com/Appliscale/cloud-security-audit/csasession/clientfactory"
 	"github.com/Appliscale/cloud-security-audit/csasession/sessionfactory"
+	"github.com/Appliscale/cloud-security-audit/logger"
+	"github.com/Appliscale/cloud-security-audit/report"
+	"os"
 )
 
 type Config struct {
@@ -15,6 +17,8 @@ type Config struct {
 	Logger         *logger.Logger
 	Mfa            bool
 	MfaDuration    int64
+	PrintFormat    func(report.Report, *os.File)
+	OutputFile     *os.File
 }
 
 func GetConfig() (config Config) {

configuration/config_mocks.go

@@ -1,9 +1,9 @@
 package configuration
 
 import (
-	"github.com/Appliscale/cloud-security-audit/logger"
 	"github.com/Appliscale/cloud-security-audit/csasession/clientfactory/mocks"
 	"github.com/Appliscale/cloud-security-audit/csasession/sessionfactory"
+	"github.com/Appliscale/cloud-security-audit/logger"
 	"testing"
 )
 

environment/checkfiles.go

@@ -2,8 +2,8 @@ package environment
 
 import (
 	"bufio"
-	"github.com/Appliscale/perun/helpers"
 	"github.com/Appliscale/cloud-security-audit/configuration"
+	"github.com/Appliscale/perun/helpers"
 	"os"
 	"strconv"
 	"strings"

environment/createfiles.go

@@ -2,8 +2,8 @@ package environment
 
 import (
 	"fmt"
-	"github.com/Appliscale/perun/helpers"
 	"github.com/Appliscale/cloud-security-audit/configuration"
+	"github.com/Appliscale/perun/helpers"
 	"os"
 	"strings"
 )

report/report.go

@@ -1,25 +1,52 @@
 package report
 
 import (
+	"github.com/Appliscale/cloud-security-audit/logger"
 	"github.com/olekukonko/tablewriter"
 	"os"
 	"strings"
 )
 
+var ReportLogger = logger.CreateDefaultLogger()
+
 type Report interface {
 	FormatDataToTable() [][]string
-	GetHeaders() []string
+	GetTableHeaders() []string
+	GetJsonReport() []byte
+	PrintHtmlReport(*os.File) error
+	GetCsvReport() []byte
+}
+
+func handleOutput(output []byte, file *os.File) {
+	out := append(output, []byte("\n\n")...)
+	_, err := file.Write(out)
+	if err != nil {
+		panic(err)
+	}
+	file.Sync()
+}
+
+func PrintJsonReport(r Report, filename *os.File) {
+	handleOutput(r.GetJsonReport(), filename)
+}
+
+func PrintHtmlReport(r Report, filename *os.File) {
+	r.PrintHtmlReport(filename)
+}
+
+func PrintCSVReport(r Report, filename *os.File) {
+	handleOutput(r.GetCsvReport(), filename)
 }
 
-func PrintTable(r Report) {
+func PrintTable(r Report, file *os.File) {
 
 	data := r.FormatDataToTable()
 
-	table := tablewriter.NewWriter(os.Stdout)
+	table := tablewriter.NewWriter(file)
 	// Configure Headers
 	table.SetReflowDuringAutoWrap(false)
 	table.SetAutoFormatHeaders(false)
-	table.SetHeader(customFormatHeaders(r.GetHeaders()))
+	table.SetHeader(customFormatHeaders(r.GetTableHeaders()))
 	// Configure rows&cells
 	table.SetRowSeparator("-")
 	table.SetRowLine(true)

report/resourceReports/csv_report.go

@@ -0,0 +1,5 @@
+package resourceReports
+
+type CsvReport interface {
+	GetCsvReport() ([]byte, error)
+}

report/ec2report.go → report/resourceReports/ec2report.go

@@ -1,21 +1,26 @@
-package report
+package resourceReports
 
 import (
 	"bytes"
+	"encoding/json"
+	"fmt"
 	"github.com/Appliscale/cloud-security-audit/configuration"
 	"github.com/Appliscale/cloud-security-audit/environment"
+	"github.com/Appliscale/cloud-security-audit/report"
 	"github.com/Appliscale/cloud-security-audit/resource"
+	"html/template"
+	"os"
 	"sort"
 	"strconv"
 	"strings"
 )
 
 type Ec2Report struct {
-	VolumeReport      *VolumeReport
-	InstanceID        string
-	SortableTags      *SortableTags
-	SecurityGroupsIDs []string
-	AvailabilityZone  string
+	VolumeReport      *VolumeReport `json:"volume_report"`
+	InstanceID        string        `json:"instance_id"`
+	SortableTags      *SortableTags `json:"sortable_tags"`
+	SecurityGroupsIDs []string      `json:"security_groups_ids"`
+	AvailabilityZone  string        `json:"availability_zone"`
 }
 
 func NewEc2Report(instanceID string) *Ec2Report {
@@ -36,7 +41,64 @@ type Ec2ReportRequiredResources struct {
 	AvailabilityZone string
 }
 
-func (e *Ec2Reports) GetHeaders() []string {
+func (e Ec2Reports) GetJsonReport() []byte {
+	output, err := json.Marshal(e)
+	if err == nil {
+		return output
+	}
+	report.ReportLogger.Error("Error generating Json report")
+	os.Exit(1)
+	return []byte{}
+}
+
+func (e Ec2Reports) PrintHtmlReport(outputFile *os.File) error {
+	data := e.GetJsonReport()
+	reportTemplate := GetHtmlTemplate()
+
+	tmpl, err := template.New("report_template").Parse(reportTemplate)
+	if err != nil {
+		report.ReportLogger.Error("Can not parse reportTemplate")
+	}
+
+	err = tmpl.Execute(outputFile, map[string]string{"EC2_JSON_PLACEHOLDER": string(data)})
+	if err != nil {
+		report.ReportLogger.Error("Can not execute reportTemplate")
+	}
+
+	return err
+}
+
+func (e Ec2Reports) GetCsvReport() []byte {
+	const internalSep = ";"
+	const externalSep = ","
+
+	csv := []string{strings.Join([]string{
+		"\"Availability Zone\"",
+		"\"EC2\"",
+		"\"Volumes encrypton\"",
+		"\"Open Security Groups\"",
+		"\"EC2 Tags\"",
+	}, externalSep)}
+
+	for _, row := range e {
+		rowStr := make([]string, 0)
+
+		rowStr = append(rowStr, strings.Join(*row.VolumeReport, internalSep))
+		rowStr = append(rowStr, row.InstanceID)
+
+		for tag, val := range row.SortableTags.Tags {
+			rowStr = append(rowStr, fmt.Sprintf("%s%s%s", tag, internalSep, val))
+		}
+
+		rowStr = append(rowStr, strings.Join(row.SecurityGroupsIDs, internalSep))
+
+		csv = append(csv, strings.Join(rowStr, externalSep))
+	}
+
+	return []byte(strings.Join(csv, "\n"))
+}
+
+func (e *Ec2Reports) GetTableHeaders() []string {
 	return []string{"Availability\nZone", "EC2", "Volumes\n(None) - not encrypted\n(DKMS) - encrypted with default KMSKey", "Security\nGroups\n(Incoming CIDR = 0\x2E0\x2E0\x2E0/0)\nID : PROTOCOL : PORT", "EC2 Tags"}
 }
 
@@ -65,12 +127,12 @@ func (e *Ec2Reports) GenerateReport(r *Ec2ReportRequiredResources) {
 			volume := r.Volumes.FindById(*blockDeviceMapping.Ebs.VolumeId)
 			if !*volume.Encrypted {
 				ec2OK = false
-				ec2Report.VolumeReport.AddEBS(*volume.VolumeId, NONE)
+				ec2Report.VolumeReport.AddEBS(*volume.VolumeId, report.NONE)
 			} else {
 				kmskey := r.KMSKeys.FindByKeyArn(*volume.KmsKeyId)
 				if !kmskey.Custom {
 					ec2OK = false
-					ec2Report.VolumeReport.AddEBS(*volume.VolumeId, DKMS)
+					ec2Report.VolumeReport.AddEBS(*volume.VolumeId, report.DKMS)
 				}
 			}
 		}

report/ec2report_test.go → report/resourceReports/ec2report_test.go

@@ -1,4 +1,4 @@
-package report
+package resourceReports
 
 import (
 	"sort"